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)   // device is not open -> try to (re-)open it
90)   if (!m_pDevice) {

91)     openDevice();

92)     return;
93)   }
94) 
95)   // buffer not empty -> try to output rest of data
96)   if (!m_buffer.empty()) {
97)     outputBufferedData();
98)     return;
99)   }

100) 

101)   // (re-)output current frame

102)   outputFrame();
103) }
104) 
105) /// (re-)read protocol
106) void Output::readProto()
107) {
108)   // update protocol from file
109)   m_fileProtocol.update();
110) 
111)   // re-output current frame using new protocol
112)   outputFrame();
113) }
114) 
115) /// open device
116) void Output::openDevice()
117) {
118)   closeDevice();
119) 
120)   // get new device name and new serial config
121)   m_fileDevice.update();
122)   m_fileSerCfg.update();
123) 
124)   // open device
125)   if (m_fileDevice.m_valid)
126)     m_pDevice = new Device(m_fileDevice.m_obj.m_str);
127) 
128)   // serial config available -> configure serial port
129)   if (m_pDevice && m_fileSerCfg.m_valid) {
130)     if (!m_pDevice->setSerCfg(m_fileSerCfg.m_obj))
131)       closeDevice(); // error -> close device
132)   }
133) 
134)   // output current frame to device
135)   outputFrame();
136) }
137) 
138) /// close device
139) void Output::closeDevice()
140) {
141)   // close device
142)   if (m_pDevice) {
143)     delete m_pDevice;
144)     m_pDevice = NULL;
145)   }
146) 

147)   // reset internal status

148)   m_buffer.clear();

149)   m_dropped = false;

150) 

151)   updateTimeCallback();

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

180)   outputFrameData(data);

181) 

182)   updateTimeCallback();

183) }
184) 

185) /**
186)  * @brief output frame data to device
187)  * @param[in] data data of one frame to output to device
188)  */
189) void Output::outputFrameData(const std::string &data)
190) {
191)   // add data to buffer (if current buffer contains less than 10 frames)

192)   if (m_buffer.size() < data.size() * 10) {

193)     m_buffer += data;

194)     m_dropped = false; // last frame was not dropped
195)   } else {
196)     m_dropped = true; // remember that last frame was dropped
197)   }
198) 
199)   outputBufferedData();
200) }
201) 
202) /// write data in output buffer to device
203) void Output::outputBufferedData()
204) {
205)   // no device -> forget buffered data, leave
206)   if (!m_pDevice) {
207)     m_buffer.clear();
208)     return;
209)   }

210) 
211)   // write (at least some) data to device
212)   std::string::size_type len;

213)   if (!m_pDevice->write(m_buffer, len)) {

214)     closeDevice(); // error -> close device

215)     return;
216)   }
217) 
218)   // remove written data from buffer
219)   m_buffer = m_buffer.substr(len);
220) 
221)   updateTimeCallback();
222) }
223) 
224) /// update time callback request
225) void Output::updateTimeCallback()
226) {
227)   /* no device -> call in 1s for re-opening device
228)      buffer empty, last frame not dropped -> call in 1s for re-outputting
229)      buffer not empty -> call in 50ms for outputting more data
230)      last frame dropped -> call in 50ms for frame update */
231)   Time delay(1);
232)   if (m_pDevice && (!m_buffer.empty() || m_dropped))
233)     delay.fromMs(50);
234)   m_mgrs.m_callMgr.requestTimeCall(this, Time::now() + delay);

235) }
236)