cec: set a message state in CCECAdapterMessage and check this state after sending...
[deb_libcec.git] / src / lib / AdapterCommunication.cpp
... / ...
CommitLineData
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#include "platform/timeutils.h"
39
40using namespace std;
41using namespace CEC;
42
43CCECAdapterMessage::CCECAdapterMessage(const cec_command &command)
44{
45 clear();
46
47 //set ack polarity to high when transmitting to the broadcast address
48 //set ack polarity low when transmitting to any other address
49 push_back(MSGSTART);
50 push_escaped(MSGCODE_TRANSMIT_ACK_POLARITY);
51 if (command.destination == CECDEVICE_BROADCAST)
52 push_escaped(CEC_TRUE);
53 else
54 push_escaped(CEC_FALSE);
55 push_back(MSGEND);
56
57 // add source and destination
58 push_back(MSGSTART);
59 push_escaped(MSGCODE_TRANSMIT);
60 push_back(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
61 push_back(MSGEND);
62
63 // add opcode
64 push_back(MSGSTART);
65 push_escaped(command.parameters.empty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
66 push_back((uint8_t) command.opcode);
67 push_back(MSGEND);
68
69 // add parameters
70 for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
71 {
72 push_back(MSGSTART);
73
74 if (iPtr == command.parameters.size - 1)
75 push_escaped( MSGCODE_TRANSMIT_EOM);
76 else
77 push_escaped(MSGCODE_TRANSMIT);
78
79 push_escaped(command.parameters[iPtr]);
80
81 push_back(MSGEND);
82 }
83}
84
85CCECAdapterMessage &CCECAdapterMessage::operator =(const CCECAdapterMessage &msg)
86{
87 packet = msg.packet;
88 return *this;
89}
90
91void CCECAdapterMessage::push_escaped(int16_t byte)
92{
93 if (byte >= MSGESC && byte != MSGSTART)
94 {
95 push_back(MSGESC);
96 push_back(byte - ESCOFFSET);
97 }
98 else
99 push_back(byte);
100}
101
102CAdapterCommunication::CAdapterCommunication(CLibCEC *controller) :
103 m_port(NULL),
104 m_controller(controller)
105{
106 m_port = new CSerialPort;
107}
108
109CAdapterCommunication::~CAdapterCommunication(void)
110{
111 Close();
112
113 if (m_port)
114 {
115 delete m_port;
116 m_port = NULL;
117 }
118}
119
120bool CAdapterCommunication::Open(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */)
121{
122 CLockObject lock(&m_mutex);
123 if (!m_port)
124 {
125 m_controller->AddLog(CEC_LOG_ERROR, "port is NULL");
126 return false;
127 }
128
129 if (IsOpen())
130 {
131 m_controller->AddLog(CEC_LOG_ERROR, "port is already open");
132 }
133
134 if (!m_port->Open(strPort, iBaudRate))
135 {
136 CStdString strError;
137 strError.Format("error opening serial port '%s': %s", strPort, m_port->GetError().c_str());
138 m_controller->AddLog(CEC_LOG_ERROR, strError);
139 return false;
140 }
141
142 m_controller->AddLog(CEC_LOG_DEBUG, "connection opened");
143
144 //clear any input bytes
145 uint8_t buff[1024];
146 m_port->Read(buff, sizeof(buff), 500);
147
148 if (CreateThread())
149 {
150 m_controller->AddLog(CEC_LOG_DEBUG, "communication thread created");
151 return true;
152 }
153 else
154 {
155 m_controller->AddLog(CEC_LOG_DEBUG, "could not create a communication thread");
156 }
157
158 return false;
159}
160
161void CAdapterCommunication::Close(void)
162{
163 CLockObject lock(&m_mutex);
164 StopThread();
165
166 m_rcvCondition.Broadcast();
167}
168
169void *CAdapterCommunication::Process(void)
170{
171 m_controller->AddLog(CEC_LOG_DEBUG, "communication thread started");
172
173 while (!IsStopped())
174 {
175 ReadFromDevice(500);
176 WriteNextCommand();
177 Sleep(5);
178 }
179
180 return NULL;
181}
182
183bool CAdapterCommunication::ReadFromDevice(uint32_t iTimeout)
184{
185 int32_t iBytesRead;
186 uint8_t buff[1024];
187 if (!m_port)
188 return false;
189
190 iBytesRead = m_port->Read(buff, sizeof(buff), iTimeout);
191 if (iBytesRead < 0 || iBytesRead > 256)
192 {
193 CStdString strError;
194 strError.Format("error reading from serial port: %s", m_port->GetError().c_str());
195 m_controller->AddLog(CEC_LOG_ERROR, strError);
196 return false;
197 }
198 else if (iBytesRead > 0)
199 AddData(buff, (uint8_t) iBytesRead);
200
201 return iBytesRead > 0;
202}
203
204void CAdapterCommunication::AddData(uint8_t *data, uint8_t iLen)
205{
206 CLockObject lock(&m_mutex);
207 for (unsigned int iPtr = 0; iPtr < iLen; iPtr++)
208 m_inBuffer.Push(data[iPtr]);
209
210 m_rcvCondition.Signal();
211}
212
213void CAdapterCommunication::WriteNextCommand(void)
214{
215 CCECAdapterMessagePtr msg;
216 if (m_outBuffer.Pop(msg))
217 {
218 CLockObject lock(&msg->mutex);
219 if (m_port->Write(msg) != (int32_t) msg->size())
220 {
221 CStdString strError;
222 strError.Format("error writing to serial port: %s", m_port->GetError().c_str());
223 m_controller->AddLog(CEC_LOG_ERROR, strError);
224 msg->state = ADAPTER_MESSAGE_STATE_ERROR;
225 }
226 else
227 {
228 m_controller->AddLog(CEC_LOG_DEBUG, "command sent");
229 CCondition::Sleep((uint32_t) msg->size() * (uint32_t)24 /*data*/ + (uint32_t)5 /*start bit (4.5 ms)*/);
230 msg->state = ADAPTER_MESSAGE_STATE_SENT;
231 }
232 msg->condition.Signal();
233 }
234}
235
236bool CAdapterCommunication::Write(CCECAdapterMessagePtr data)
237{
238 data->state = ADAPTER_MESSAGE_STATE_WAITING;
239 m_outBuffer.Push(data);
240 return true;
241}
242
243bool CAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
244{
245 CLockObject lock(&m_mutex);
246
247 msg.clear();
248 uint64_t iNow = GetTimeMs();
249 uint64_t iTarget = iNow + iTimeout;
250 bool bGotFullMessage(false);
251 bool bNextIsEscaped(false);
252 bool bGotStart(false);
253
254 while(!bGotFullMessage && iNow < iTarget)
255 {
256 uint8_t buf = 0;
257 if (!m_inBuffer.Pop(buf))
258 {
259 if (!m_rcvCondition.Wait(&m_mutex, iTarget - iNow))
260 return false;
261 }
262
263 if (!bGotStart)
264 {
265 if (buf == MSGSTART)
266 bGotStart = true;
267 continue;
268 }
269 else if (buf == MSGSTART) //we found a msgstart before msgend, this is not right, remove
270 {
271 m_controller->AddLog(CEC_LOG_ERROR, "received MSGSTART before MSGEND");
272 msg.clear();
273 bGotStart = true;
274 }
275
276 if (buf == MSGEND)
277 {
278 bGotFullMessage = true;
279 }
280 else if (bNextIsEscaped)
281 {
282 msg.push_back(buf + (uint8_t)ESCOFFSET);
283 bNextIsEscaped = false;
284 }
285 else if (buf == MSGESC)
286 bNextIsEscaped = true;
287 else
288 msg.push_back(buf);
289 }
290
291 if (bGotFullMessage)
292 msg.state = ADAPTER_MESSAGE_STATE_RECEIVED;
293
294 return bGotFullMessage;
295}
296
297std::string CAdapterCommunication::GetError(void) const
298{
299 return m_port->GetError();
300}
301
302bool CAdapterCommunication::StartBootloader(void)
303{
304 if (!IsRunning())
305 return false;
306
307 m_controller->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
308 CCECAdapterMessagePtr output(new CCECAdapterMessage);
309
310 output->push_back(MSGSTART);
311 output->push_escaped(MSGCODE_START_BOOTLOADER);
312 output->push_back(MSGEND);
313
314 if (!Write(output))
315 {
316 m_controller->AddLog(CEC_LOG_ERROR, "could not start the bootloader");
317 return false;
318 }
319 m_controller->AddLog(CEC_LOG_DEBUG, "bootloader start command transmitted");
320 return true;
321}
322
323bool CAdapterCommunication::SetAckMask(uint16_t iMask)
324{
325 if (!IsRunning())
326 return false;
327
328 CStdString strLog;
329 strLog.Format("setting ackmask to %2x", iMask);
330 m_controller->AddLog(CEC_LOG_DEBUG, strLog.c_str());
331
332 CCECAdapterMessagePtr output(new CCECAdapterMessage);
333
334 output->push_back(MSGSTART);
335 output->push_escaped(MSGCODE_SET_ACK_MASK);
336 output->push_escaped(iMask >> 8);
337 output->push_escaped((uint8_t)iMask);
338 output->push_back(MSGEND);
339
340 if (!Write(output))
341 {
342 m_controller->AddLog(CEC_LOG_ERROR, "could not set the ackmask");
343 return false;
344 }
345
346 return true;
347}
348
349bool CAdapterCommunication::PingAdapter(void)
350{
351 if (!IsRunning())
352 return false;
353
354 m_controller->AddLog(CEC_LOG_DEBUG, "sending ping");
355 CCECAdapterMessagePtr output(new CCECAdapterMessage);
356
357 output->push_back(MSGSTART);
358 output->push_escaped(MSGCODE_PING);
359 output->push_back(MSGEND);
360
361 if (!Write(output))
362 {
363 m_controller->AddLog(CEC_LOG_ERROR, "could not send ping command");
364 return false;
365 }
366
367 m_controller->AddLog(CEC_LOG_DEBUG, "ping tranmitted");
368
369 // TODO check for pong
370 return true;
371}
372
373bool CAdapterCommunication::IsOpen(void) const
374{
375 return !IsStopped() && m_port->IsOpen();
376}