cec: fix some threading related bugs, like trying to join with a detached thread...
[deb_libcec.git] / src / lib / AdapterCommunication.cpp
1 /*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33 #include "AdapterCommunication.h"
34
35 #include "LibCEC.h"
36 #include "platform/serialport.h"
37 #include "util/StdString.h"
38
39 using namespace std;
40 using namespace CEC;
41
42 CAdapterCommunication::CAdapterCommunication(CLibCEC *controller) :
43 m_controller(controller),
44 m_inbuf(NULL),
45 m_iInbufSize(0),
46 m_iInbufUsed(0),
47 m_bStarted(false),
48 m_bStop(false)
49 {
50 m_port = new CSerialPort;
51 }
52
53 CAdapterCommunication::~CAdapterCommunication(void)
54 {
55 StopThread();
56 m_port->Close();
57 delete m_port;
58 m_port = NULL;
59 }
60
61 bool CAdapterCommunication::Open(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint64_t iTimeoutMs /* = 10000 */)
62 {
63 CLockObject lock(&m_commMutex);
64 if (m_bStarted)
65 return false;
66
67 if (!m_port->Open(strPort, iBaudRate))
68 {
69 CStdString strError;
70 strError.Format("error opening serial port '%s': %s", strPort, m_port->GetError().c_str());
71 m_controller->AddLog(CEC_LOG_ERROR, strError);
72 return false;
73 }
74
75 m_controller->AddLog(CEC_LOG_DEBUG, "connection opened");
76
77 //clear any input bytes
78 uint8_t buff[1024];
79 m_port->Read(buff, sizeof(buff), 50);
80
81 CCondition::Sleep(CEC_SETTLE_DOWN_TIME);
82
83 m_bStop = false;
84 m_bStarted = true;
85
86 if (CreateThread())
87 {
88 m_controller->AddLog(CEC_LOG_DEBUG, "reader thread created");
89 return true;
90 }
91 else
92 {
93 m_controller->AddLog(CEC_LOG_DEBUG, "could not create a reader thread");
94 }
95
96 return false;
97 }
98
99 void CAdapterCommunication::Close(void)
100 {
101 StopThread();
102 m_port->Close();
103 }
104
105 void *CAdapterCommunication::Process(void)
106 {
107 while (!m_bStop)
108 {
109 if (!ReadFromDevice(250))
110 {
111 m_bStarted = false;
112 break;
113 }
114
115 if (!m_bStop)
116 CCondition::Sleep(50);
117 }
118
119 CLockObject lock(&m_commMutex);
120 m_bStarted = false;
121 return NULL;
122 }
123
124 bool CAdapterCommunication::ReadFromDevice(uint64_t iTimeout)
125 {
126 uint8_t buff[1024];
127 CLockObject lock(&m_commMutex);
128 if (!m_port)
129 return false;
130
131 int32_t iBytesRead = m_port->Read(buff, sizeof(buff), iTimeout);
132 lock.Leave();
133 if (iBytesRead < 0 || iBytesRead > 256)
134 {
135 CStdString strError;
136 strError.Format("error reading from serial port: %s", m_port->GetError().c_str());
137 m_controller->AddLog(CEC_LOG_ERROR, strError);
138 return false;
139 }
140 else if (iBytesRead > 0)
141 AddData(buff, (uint8_t) iBytesRead);
142
143 return true;
144 }
145
146 void CAdapterCommunication::AddData(uint8_t *data, uint8_t iLen)
147 {
148 CLockObject lock(&m_bufferMutex);
149 if (iLen + m_iInbufUsed > m_iInbufSize)
150 {
151 m_iInbufSize = iLen + m_iInbufUsed;
152 m_inbuf = (uint8_t*)realloc(m_inbuf, m_iInbufSize);
153 }
154
155 memcpy(m_inbuf + m_iInbufUsed, data, iLen);
156 m_iInbufUsed += iLen;
157 lock.Leave();
158 m_condition.Signal();
159 }
160
161 bool CAdapterCommunication::Write(const cec_frame &data)
162 {
163 CLockObject lock(&m_commMutex);
164
165 if (m_port->Write(data) != (int) data.size())
166 {
167 CStdString strError;
168 strError.Format("error writing to serial port: %s", m_port->GetError().c_str());
169 m_controller->AddLog(CEC_LOG_ERROR, strError);
170 return false;
171 }
172
173 m_controller->AddLog(CEC_LOG_DEBUG, "command sent");
174
175 CCondition::Sleep((int) data.size() * 24 /*data*/ + 5 /*start bit (4.5 ms)*/ + 50 /* to be on the safe side */);
176
177 return true;
178 }
179
180 bool CAdapterCommunication::Read(cec_frame &msg, uint64_t iTimeout)
181 {
182 CLockObject lock(&m_bufferMutex);
183
184 if (m_iInbufUsed < 1)
185 m_condition.Wait(&m_bufferMutex, iTimeout);
186
187 if (m_iInbufUsed < 1)
188 return false;
189
190 //search for first start of message
191 int startpos = -1;
192 for (int i = 0; i < m_iInbufUsed; i++)
193 {
194 if (m_inbuf[i] == MSGSTART)
195 {
196 startpos = i;
197 break;
198 }
199 }
200
201 if (startpos == -1)
202 return false;
203
204 //move anything from the first start of message to the beginning of the buffer
205 if (startpos > 0)
206 {
207 memmove(m_inbuf, m_inbuf + startpos, m_iInbufUsed - startpos);
208 m_iInbufUsed -= startpos;
209 }
210
211 if (m_iInbufUsed < 2)
212 return false;
213
214 //look for end of message
215 startpos = -1;
216 int endpos = -1;
217 for (int i = 1; i < m_iInbufUsed; i++)
218 {
219 if (m_inbuf[i] == MSGEND)
220 {
221 endpos = i;
222 break;
223 }
224 else if (m_inbuf[i] == MSGSTART)
225 {
226 startpos = i;
227 break;
228 }
229 }
230
231 if (startpos > 0) //we found a msgstart before msgend, this is not right, remove
232 {
233 m_controller->AddLog(CEC_LOG_ERROR, "received MSGSTART before MSGEND");
234 memmove(m_inbuf, m_inbuf + startpos, m_iInbufUsed - startpos);
235 m_iInbufUsed -= startpos;
236 return false;
237 }
238
239 if (endpos > 0) //found a MSGEND
240 {
241 msg.clear();
242 bool isesc = false;
243 for (int i = 1; i < endpos; i++)
244 {
245 if (isesc)
246 {
247 msg.push_back(m_inbuf[i] + (uint8_t)ESCOFFSET);
248 isesc = false;
249 }
250 else if (m_inbuf[i] == MSGESC)
251 {
252 isesc = true;
253 }
254 else
255 {
256 msg.push_back(m_inbuf[i]);
257 }
258 }
259
260 if (endpos + 1 < m_iInbufUsed)
261 memmove(m_inbuf, m_inbuf + endpos + 1, m_iInbufUsed - endpos - 1);
262
263 m_iInbufUsed -= endpos + 1;
264
265 return true;
266 }
267
268 return false;
269 }
270
271 std::string CAdapterCommunication::GetError(void) const
272 {
273 return m_port->GetError();
274 }
275
276 bool CAdapterCommunication::StartBootloader(void)
277 {
278 if (!IsRunning())
279 return false;
280
281 m_controller->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
282 cec_frame output;
283 output.push_back(MSGSTART);
284 PushEscaped(output, MSGCODE_START_BOOTLOADER);
285 output.push_back(MSGEND);
286
287 if (!Write(output))
288 {
289 m_controller->AddLog(CEC_LOG_ERROR, "could not start the bootloader");
290 return false;
291 }
292 m_controller->AddLog(CEC_LOG_DEBUG, "bootloader start command transmitted");
293 return true;
294 }
295
296 void CAdapterCommunication::PushEscaped(cec_frame &vec, uint8_t byte)
297 {
298 if (byte >= MSGESC && byte != MSGSTART)
299 {
300 vec.push_back(MSGESC);
301 vec.push_back(byte - ESCOFFSET);
302 }
303 else
304 {
305 vec.push_back(byte);
306 }
307 }
308
309 bool CAdapterCommunication::SetAckMask(uint16_t iMask)
310 {
311 if (!IsRunning())
312 return false;
313
314 CStdString strLog;
315 strLog.Format("setting ackmask to %2x", iMask);
316 m_controller->AddLog(CEC_LOG_DEBUG, strLog.c_str());
317
318 cec_frame output;
319
320 output.push_back(MSGSTART);
321 PushEscaped(output, MSGCODE_SET_ACK_MASK);
322 PushEscaped(output, iMask >> 8);
323 PushEscaped(output, (uint8_t)iMask);
324 output.push_back(MSGEND);
325
326 if (!Write(output))
327 {
328 m_controller->AddLog(CEC_LOG_ERROR, "could not set the ackmask");
329 return false;
330 }
331
332 return true;
333 }
334
335 bool CAdapterCommunication::PingAdapter(void)
336 {
337 if (!IsRunning())
338 return false;
339
340 m_controller->AddLog(CEC_LOG_DEBUG, "sending ping");
341 cec_frame output;
342 output.push_back(MSGSTART);
343 PushEscaped(output, MSGCODE_PING);
344 output.push_back(MSGEND);
345
346 if (!Write(output))
347 {
348 m_controller->AddLog(CEC_LOG_ERROR, "could not send ping command");
349 return false;
350 }
351
352 m_controller->AddLog(CEC_LOG_DEBUG, "ping tranmitted");
353
354 // TODO check for pong
355 return true;
356 }