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)
        {
                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();
                        serial.writeTarget( cmd.target, cmd.data);
                } 
                                
                
                msleep(80);
        }
        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	67	store->led3 = serial.readTarget(0);
29	torben	60	msleep(delay);
30
31	torben	67	store->led4 = serial.readTarget(1);
32	torben	60	msleep(delay);
33
34	torben	67	store->led5 = serial.readTarget(2);
35	torben	60	msleep(delay);
36
37	torben	67	store->switch2 = serial.readTarget(3);
38	torben	60	msleep(delay);
39
40	torben	67	store->switch3 = serial.readTarget(4);
41	torben	60	msleep(delay);
42
43	torben	67	store->potmeter = serial.readTarget(5);
44	torben	60	msleep(delay);
45
46	torben	67	store->temp = serial.readTarget(6);
47			std::cout << store->potmeter << std::endl;
48
49			boost::mutex::scoped_lock lock(store->writeMutex);
50
51			if (! store->commands.empty() )
52			{
53			WriteCommand cmd = store->commands.front();
54			store->commands.pop();
55			serial.writeTarget( cmd.target, cmd.data);
56			}
57
58	torben	60
59	torben	67	msleep(80);
60	torben	60	}
61			mStopped = true;
62			}