Blinker

1) /* Blinker
2)    Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>
3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #include <string>
7) 
8) #include <BlinkenLib/BlinkenFrame.h>
9) #include <BlinkenLib/BlinkenProto.h>
10) 
11) #include "Device.h"
12) #include "Directory.h"
13) #include "File.h"
14) #include "InStreamFile.h"

15) #include "Mgrs.h"

16) #include "Module.h"
17) #include "NameFile.h"
18) #include "Output.h"
19) #include "Protocol.h"
20) #include "ProtocolFile.h"
21) #include "SerCfgFile.h"
22) #include "StreamRecv.h"

23) #include "Time.h"

24) #include "TimeCallee.h"
25) 
26) namespace Blinker {
27) 
28) /**
29)  * @brief constructor

30)  * @param[in] mgrs managers

31)  * @param[in] dirBase base directory
32)  */

33) Output::Output(Mgrs &mgrs,

34)                const Directory &dirBase):

35)   Module(mgrs, dirBase),
36)   m_fileInStream(dirBase.getFile("instream"), mgrs.m_streamMgr),

37)   m_fileProtocol(dirBase.getFile("protocol")),
38)   m_fileDevice(dirBase.getFile("device")),

39)   m_fileSerCfg(dirBase.getFile("ser_cfg")),
40)   m_pDevice(NULL)

41) {
42)   // set up
43)   m_fileInStream.setStreamRecv(this);
44)   readProto();
45)   openDevice();
46) }
47) 
48) /// virtual destructor
49) Output::~Output()
50) {
51)   // clean up
52)   closeDevice();
53)   m_fileInStream.setStreamRecv(NULL);

54)   m_mgrs.m_callMgr.cancelTimeCall(this);

55) }
56) 
57) /// check for update of configuration
58) void Output::updateConfig()
59) {
60)   // input stream name file was modified -> re-get input stream
61)   if (m_fileInStream.checkModified())
62)     m_fileInStream.update();
63) 
64)   // protocol file was modified -> re-read protocol
65)   if (m_fileProtocol.checkModified())
66)     readProto();
67) 
68)   // device file or serial settings file was modified -> re-open device
69)   if (m_fileDevice.checkModified() || m_fileSerCfg.checkModified())
70)     openDevice();
71) }
72) 
73) /**
74)  * @brief set current frame
75)  * @param[in] stream stream name
76)  * @param[in] pFrame current frame (NULL for none)
77)  */
78) void Output::setFrame(const std::string &stream, stBlinkenFrame *pFrame)
79) {
80)   outputFrame();
81)   (void)stream; // unused
82)   (void)pFrame; // unused
83) }
84) 
85) /// callback when requested time reached
86) void Output::timeCall()
87) {
88)   // if device is not open, try to (re-)open it
89)   if (!m_pDevice)
90)     openDevice();
91) 
92)   // re-output current frame
93)   outputFrame();
94) }
95) 
96) /// (re-)read protocol
97) void Output::readProto()
98) {
99)   // update protocol from file
100)   m_fileProtocol.update();
101) 
102)   // re-output current frame using new protocol
103)   outputFrame();
104) }
105) 
106) /// open device
107) void Output::openDevice()
108) {
109)   closeDevice();
110) 
111)   // get new device name and new serial config
112)   m_fileDevice.update();
113)   m_fileSerCfg.update();
114) 
115)   // open device
116)   if (m_fileDevice.m_valid)
117)     m_pDevice = new Device(m_fileDevice.m_obj.m_str);
118) 
119)   // serial config available -> configure serial port
120)   if (m_pDevice && m_fileSerCfg.m_valid) {
121)     if (!m_pDevice->setSerCfg(m_fileSerCfg.m_obj))
122)       closeDevice(); // error -> close device
123)   }
124) 
125)   // output current frame to device
126)   outputFrame();
127) }
128) 
129) /// close device
130) void Output::closeDevice()
131) {
132)   // close device
133)   if (m_pDevice) {
134)     delete m_pDevice;
135)     m_pDevice = NULL;
136)   }
137) 
138)   // request time callback in one second (for trying to re-open device)

139)   m_mgrs.m_callMgr.requestTimeCall(this, Time::now() + Time(1));

140) }
141) 
142) /// output current frame to device
143) void Output::outputFrame()
144) {
145)   stBlinkenFrame *pFrame;
146)   char buf[65536];
147)   int len;
148)   std::string data;
149) 
150)   // no protocol or no device -> leave
151)   if (!m_fileProtocol.m_valid || !m_pDevice)
152)     return;
153) 
154)   // get current frame from input stream
155)   pFrame = m_fileInStream.getCurFrame();
156) 
157)   // convert frame to protocol data
158)   if (pFrame)
159)     len = BlinkenFrameToNetwork(pFrame, m_fileProtocol.m_obj.m_proto,
160)                                 buf, sizeof(buf));
161)   else
162)     len = BlinkenProtoMakePacket(m_fileProtocol.m_obj.m_proto,
163)                                  BlinkenPacketStreamEnd, buf, sizeof(buf));
164)   if (len < 0)
165)     len = 0;
166)   data.assign(buf, len);
167) 
168)   // output data to device
169)   if (!m_pDevice->write(data))
170)     closeDevice(); // error -> close device
171) 
172)   // request time callback in one second (for outputting current frame again)

173)   m_mgrs.m_callMgr.requestTimeCall(this, Time::now() + Time(1));