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)   // request time callback in one second (for trying to re-open device)

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

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

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