linux-serial/server/serverthread.cpp


#include "serverthread.h"
#include "globalstorage.h"

#include <list>
#include <iostream>
#include <sstream>

using CPPSocket::TCPServer;
using CPPSocket::TCPConnection;
using CPPSocket::Address;

using std::cout;
using std::endl;

typedef std::list<TCPConnection*>::iterator ClientIt;
ServerThread::ServerThread()
                : Thread()
{
}

ServerThread::~ServerThread()
{
        for (ClientIt it = mClients.begin(); it != mClients.end(); it++)
        {
                (*it)->disconnect();
                delete (*it);
        }
}

void ServerThread::operator()()
{
        mStopped = false;

        TCPServer& server = GlobalStorage::instance()->server;
        
        while(mContinue)
        {
                if (server.wait4Connection(0,1500))
                {
                        Address addr;
                        mClients.push_back( server.getConnection(addr) );
                        std::cout << "Connection from " << addr.getIPString() << ":"  
                                        << addr.getPort() << std::endl;

                        for (ClientIt it = mClients.begin(); it != mClients.end(); it++)
                        {
                                if ( ! (*it)->isConnected() )
                                {
                                        std::cout << "removing dead connection" << std::endl;
                                        delete (*it);
                                        mClients.erase(it);
                                        it = mClients.begin();
                                }
                        }
                }

                for (ClientIt it = mClients.begin(); it != mClients.end(); it++)
                {
                        std::string str;
                        TCPConnection& conn = *(*it);
                        GlobalStorage* store = GlobalStorage::instance();
                        SerialThread& serial = store->serialThread;
                        
                        conn >> str;
                        if (str.size() >0)
                        {
                                cout << "Got " << str.size() << " bytes :" << str << endl;
                                do
                                {
                                        if ( str == "100")
                                        {
                                                std::ostringstream tmp;
                                        
                                                if (store->led3)
                                                        tmp << "111|";
                                                else
                                                        tmp << "110|";
        
                                                if (store->led4)
                                                        tmp << "121|";
                                                else
                                                        tmp << "120|";
        
                                                if (store->led5)
                                                        tmp << "131|";
                                                else
                                                        tmp << "130|";

                                                if (store->switch2)
                                                        tmp << "141|";
                                                else
                                                        tmp << "140|";

                                                if (store->switch3)
                                                        tmp << "151|";
                                                else
                                                        tmp << "150|";

                                                tmp << ( store->temp + 4000) << "|";
                                                tmp << ( store->potmeter+2000) << "|";
                                                conn << tmp.str();
                                        } else {
        
                                                boost::mutex::scoped_lock lock(store->writeMutex);
                                                if (str == "111")
                                                        store->commands.push( WriteCommand(0,1) );
                                                else if (str == "110")
                                                        store->commands.push( WriteCommand(0,0) );
                                                else if (str == "121")
                                                        store->commands.push( WriteCommand(1,1) );
                                                else if (str == "120")
                                                        store->commands.push( WriteCommand(1,0) );
                                                else if (str == "131")
                                                        store->commands.push( WriteCommand(2,1) );
                                                else if (str == "130")
                                                        store->commands.push( WriteCommand(2,0) );
                                        }
                                } while (str.length 
                        }
                        str = "";
                }
                Sleep(2);
                                
        }
        
        
        mStopped = true;
}
1
2	#include "serverthread.h"
3	#include "globalstorage.h"
4
5	#include <list>
6	#include <iostream>
7	#include <sstream>
8
9	using CPPSocket::TCPServer;
10	using CPPSocket::TCPConnection;
11	using CPPSocket::Address;
12
13	using std::cout;
14	using std::endl;
15
16	typedef std::list<TCPConnection*>::iterator ClientIt;
17	ServerThread::ServerThread()
18	: Thread()
19	{
20	}
21
22	ServerThread::~ServerThread()
23	{
24	for (ClientIt it = mClients.begin(); it != mClients.end(); it++)
25	{
26	(*it)->disconnect();
27	delete (*it);
28	}
29	}
30
31	void ServerThread::operator()()
32	{
33	mStopped = false;
34
35	TCPServer& server = GlobalStorage::instance()->server;
36
37	while(mContinue)
38	{
39	if (server.wait4Connection(0,1500))
40	{
41	Address addr;
42	mClients.push_back( server.getConnection(addr) );
43	std::cout << "Connection from " << addr.getIPString() << ":"
44	<< addr.getPort() << std::endl;
45
46	for (ClientIt it = mClients.begin(); it != mClients.end(); it++)
47	{
48	if ( ! (*it)->isConnected() )
49	{
50	std::cout << "removing dead connection" << std::endl;
51	delete (*it);
52	mClients.erase(it);
53	it = mClients.begin();
54	}
55	}
56	}
57
58	for (ClientIt it = mClients.begin(); it != mClients.end(); it++)
59	{
60	std::string str;
61	TCPConnection& conn = (it);
62	GlobalStorage* store = GlobalStorage::instance();
63	SerialThread& serial = store->serialThread;
64
65	conn >> str;
66	if (str.size() >0)
67	{
68	cout << "Got " << str.size() << " bytes :" << str << endl;
69	do
70	{
71	if ( str == "100")
72	{
73	std::ostringstream tmp;
74
75	if (store->led3)
76	tmp << "111\|";
77	else
78	tmp << "110\|";
79
80	if (store->led4)
81	tmp << "121\|";
82	else
83	tmp << "120\|";
84
85	if (store->led5)
86	tmp << "131\|";
87	else
88	tmp << "130\|";
89
90	if (store->switch2)
91	tmp << "141\|";
92	else
93	tmp << "140\|";
94
95	if (store->switch3)
96	tmp << "151\|";
97	else
98	tmp << "150\|";
99
100	tmp << ( store->temp + 4000) << "\|";
101	tmp << ( store->potmeter+2000) << "\|";
102	conn << tmp.str();
103	} else {
104
105	boost::mutex::scoped_lock lock(store->writeMutex);
106	if (str == "111")
107	store->commands.push( WriteCommand(0,1) );
108	else if (str == "110")
109	store->commands.push( WriteCommand(0,0) );
110	else if (str == "121")
111	store->commands.push( WriteCommand(1,1) );
112	else if (str == "120")
113	store->commands.push( WriteCommand(1,0) );
114	else if (str == "131")
115	store->commands.push( WriteCommand(2,1) );
116	else if (str == "130")
117	store->commands.push( WriteCommand(2,0) );
118	}
119	} while (str.length
120	}
121	str = "";
122	}
123	Sleep(2);
124
125	}
126
127
128	mStopped = true;
129	}