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(50);
                
                store->led3 = serial.readTarget(0);
                msleep(delay);

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

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

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

                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;

                writeCommand(); 
        }
        mStopped = true;
}

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