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	#include <iostream>
2
3	#include "globalstorage.h"
4	#include "serialthread.h"
5
6
7	inline void msleep(int s)
8	{
9	usleep(s*1000);
10	}
11
12	SerialThread::SerialThread()
13	: Thread()
14	{
15	}
16
17
18	void SerialThread::operator()()
19	{
20	const int delay = 5;
21	mStopped = false;
22
23	GlobalStorage* store = GlobalStorage::instance();
24	CH7Serial& serial = store->serialPort;
25
26	while (mContinue)
27	{
28	msleep(80);
29	store->led3 = serial.readTarget(0);
30	msleep(delay);
31
32	store->led4 = serial.readTarget(1);
33	msleep(delay);
34
35	store->led5 = serial.readTarget(2);
36	msleep(delay);
37
38	store->switch2 = serial.readTarget(3);
39	msleep(delay);
40
41	store->switch3 = serial.readTarget(4);
42	msleep(delay);
43
44	store->potmeter = serial.readTarget(5);
45	msleep(delay);
46
47	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	std::cout << "Command:"<< (int) cmd.target<<","<< (int) cmd.data << std::endl;
57	serial.writeTarget( cmd.target, cmd.data);
58	}
59
60	}
61	mStopped = true;
62	}