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] name module name

31)  * @param[in] mgrs managers

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

34) Output::Output(const std::string &name, Mgrs &mgrs,

35)                const Directory &dirBase):

36)   Module(name, mgrs, dirBase),

37)   m_fileInStream(dirBase.getFile("instream"), mgrs.m_streamMgr),

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

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

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

55)   m_mgrs.m_callMgr.cancelTimeCall(this);

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

139)   // clear buffered data
140)   m_buffer.clear();
141) 

142)   // request time callback in one second (for trying to re-open device)

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

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

173)   outputFrameData(data);

174) 

175)   /* request time callback in one second
176)      (for outputting current frame again or reopening device) */

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

178) }
179) 

180) /**
181)  * @brief output frame data to device
182)  * @param[in] data data of one frame to output to device
183)  */
184) void Output::outputFrameData(const std::string &data)
185) {
186)   // no device -> leave
187)   if (!m_pDevice)
188)     return;
189) 
190)   // add data to buffer (if current buffer contains less than 10 frames)
191)   if (m_buffer.size() < data.size() * 10)
192)     m_buffer += data;
193) 
194)   // write (at least some) data to device
195)   std::string::size_type len;
196)   if (!m_pDevice->write(m_buffer, len))
197)     closeDevice(); // error -> close device
198)   else
199)     m_buffer = m_buffer.substr(len); // done -> remove written data from buffer
200) }
201)