linux-serial/server/serialthread.cpp

#include <iostream>

#include "globalstorage.h"
#include "serialthread.h"


inline void msleep(int s)
{
        usleep(s*1000);
}
        
SerialThread::SerialThread()
        : Thread()
{
}
        

void SerialThread::operator()()
{
        const int delay = 5;
        mStopped = false;

        GlobalStorage* store = GlobalStorage::instance();
        CH7Serial& serial = store->serialPort;

        while (mContinue)
        {
                msleep(80);
                store->led3 = serial.readTarget(0);
                msleep(delay);

                store->led4 = serial.readTarget(1);
                msleep(delay);

                store->led5 = serial.readTarget(2);
                msleep(delay);

                store->switch2 = serial.readTarget(3);
                msleep(delay);

                store->switch3 = serial.readTarget(4);
                msleep(delay);

                store->potmeter = serial.readTarget(5);
                msleep(delay);

                store->temp = serial.readTarget(6);
                std::cout << store->potmeter << std::endl;

                boost::mutex::scoped_lock lock(store->writeMutex);
        
                if (! store->commands.empty() )
                {       
                        WriteCommand cmd = store->commands.front();
                        store->commands.pop();
                        std::cout << "Command:"<< (int) cmd.target<<","<< (int) cmd.data << std::endl;
                        serial.writeTarget( cmd.target, cmd.data);
                } 
                                
        }
        mStopped = true;
}
1	torben	60	#include <iostream>
2
3	torben	67	#include "globalstorage.h"
4	torben	60	#include "serialthread.h"
5
6
7			inline void msleep(int s)
8			{
9			usleep(s*1000);
10			}
11
12	torben	67	SerialThread::SerialThread()
13			: Thread()
14	torben	60	{
15			}
16
17
18			void SerialThread::operator()()
19			{
20			const int delay = 5;
21			mStopped = false;
22
23	torben	67	GlobalStorage* store = GlobalStorage::instance();
24			CH7Serial& serial = store->serialPort;
25
26	torben	60	while (mContinue)
27			{
28	torben	68	msleep(80);
29	torben	67	store->led3 = serial.readTarget(0);
30	torben	60	msleep(delay);
31
32	torben	67	store->led4 = serial.readTarget(1);
33	torben	60	msleep(delay);
34
35	torben	67	store->led5 = serial.readTarget(2);
36	torben	60	msleep(delay);
37
38	torben	67	store->switch2 = serial.readTarget(3);
39	torben	60	msleep(delay);
40
41	torben	67	store->switch3 = serial.readTarget(4);
42	torben	60	msleep(delay);
43
44	torben	67	store->potmeter = serial.readTarget(5);
45	torben	60	msleep(delay);
46
47	torben	67	store->temp = serial.readTarget(6);
48			std::cout << store->potmeter << std::endl;
49
50			boost::mutex::scoped_lock lock(store->writeMutex);
51
52			if (! store->commands.empty() )
53			{
54			WriteCommand cmd = store->commands.front();
55			store->commands.pop();
56	torben	68	std::cout << "Command:"<< (int) cmd.target<<","<< (int) cmd.data << std::endl;
57	torben	67	serial.writeTarget( cmd.target, cmd.data);
58			}
59
60	torben	60	}
61			mStopped = true;
62			}