cec: fix some logging. only transmit packets once
[deb_libcec.git] / src / lib / AdapterCommunication.cpp
CommitLineData
a8f0bd18
LOK
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
828682d3 33#include "AdapterCommunication.h"
2abe74eb 34
1113cb7d 35#include "CECProcessor.h"
b9187cc6 36#include "platform/serialport.h"
a8f0bd18 37#include "util/StdString.h"
50aa01e6 38#include "platform/timeutils.h"
a8f0bd18
LOK
39
40using namespace std;
41using namespace CEC;
42
ad24cbaf
LOK
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);
57f45e6c 59 push_escaped(command.opcode_set == 0 ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
ad24cbaf
LOK
60 push_back(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
61 push_back(MSGEND);
62
63 // add opcode
57f45e6c 64 if (command.opcode_set == 1)
ad24cbaf
LOK
65 {
66 push_back(MSGSTART);
ab1469a0 67 push_escaped(command.parameters.IsEmpty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
57f45e6c
LOK
68 push_back((uint8_t) command.opcode);
69 push_back(MSGEND);
ad24cbaf 70
57f45e6c
LOK
71 // add parameters
72 for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
73 {
74 push_back(MSGSTART);
ad24cbaf 75
57f45e6c
LOK
76 if (iPtr == command.parameters.size - 1)
77 push_escaped( MSGCODE_TRANSMIT_EOM);
78 else
79 push_escaped(MSGCODE_TRANSMIT);
ad24cbaf 80
57f45e6c
LOK
81 push_escaped(command.parameters[iPtr]);
82
83 push_back(MSGEND);
84 }
ad24cbaf 85 }
06bfd4d7
LOK
86
87 // set timeout
88 transmit_timeout = command.transmit_timeout;
ad24cbaf
LOK
89}
90
91CCECAdapterMessage &CCECAdapterMessage::operator =(const CCECAdapterMessage &msg)
92{
93 packet = msg.packet;
88c43521 94 state = msg.state;
ad24cbaf
LOK
95 return *this;
96}
97
b8c91906 98CStdString CCECAdapterMessage::MessageCodeAsString(void) const
e41b06f9
LOK
99{
100 CStdString strMsg;
101 switch (message())
102 {
103 case MSGCODE_NOTHING:
104 strMsg = "NOTHING";
105 break;
106 case MSGCODE_PING:
107 strMsg = "PING";
108 break;
109 case MSGCODE_TIMEOUT_ERROR:
b8c91906
LOK
110 strMsg = "TIMEOUT";
111 break;
e41b06f9 112 case MSGCODE_HIGH_ERROR:
b8c91906
LOK
113 strMsg = "HIGH_ERROR";
114 break;
e41b06f9 115 case MSGCODE_LOW_ERROR:
b8c91906 116 strMsg = "LOW_ERROR";
e41b06f9
LOK
117 break;
118 case MSGCODE_FRAME_START:
119 strMsg = "FRAME_START";
e41b06f9
LOK
120 break;
121 case MSGCODE_FRAME_DATA:
122 strMsg = "FRAME_DATA";
e41b06f9
LOK
123 break;
124 case MSGCODE_RECEIVE_FAILED:
125 strMsg = "RECEIVE_FAILED";
126 break;
127 case MSGCODE_COMMAND_ACCEPTED:
128 strMsg = "COMMAND_ACCEPTED";
129 break;
130 case MSGCODE_COMMAND_REJECTED:
131 strMsg = "COMMAND_REJECTED";
132 break;
133 case MSGCODE_SET_ACK_MASK:
134 strMsg = "SET_ACK_MASK";
135 break;
136 case MSGCODE_TRANSMIT:
137 strMsg = "TRANSMIT";
138 break;
139 case MSGCODE_TRANSMIT_EOM:
140 strMsg = "TRANSMIT_EOM";
141 break;
142 case MSGCODE_TRANSMIT_IDLETIME:
143 strMsg = "TRANSMIT_IDLETIME";
144 break;
145 case MSGCODE_TRANSMIT_ACK_POLARITY:
146 strMsg = "TRANSMIT_ACK_POLARITY";
147 break;
148 case MSGCODE_TRANSMIT_LINE_TIMEOUT:
149 strMsg = "TRANSMIT_LINE_TIMEOUT";
150 break;
151 case MSGCODE_TRANSMIT_SUCCEEDED:
152 strMsg = "TRANSMIT_SUCCEEDED";
153 break;
154 case MSGCODE_TRANSMIT_FAILED_LINE:
155 strMsg = "TRANSMIT_FAILED_LINE";
156 break;
157 case MSGCODE_TRANSMIT_FAILED_ACK:
158 strMsg = "TRANSMIT_FAILED_ACK";
159 break;
160 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
161 strMsg = "TRANSMIT_FAILED_TIMEOUT_DATA";
162 break;
163 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
164 strMsg = "TRANSMIT_FAILED_TIMEOUT_LINE";
165 break;
166 case MSGCODE_FIRMWARE_VERSION:
167 strMsg = "FIRMWARE_VERSION";
168 break;
169 case MSGCODE_START_BOOTLOADER:
170 strMsg = "START_BOOTLOADER";
171 break;
172 case MSGCODE_FRAME_EOM:
173 strMsg = "FRAME_EOM";
174 break;
175 case MSGCODE_FRAME_ACK:
176 strMsg = "FRAME_ACK";
177 break;
178 }
179
180 return strMsg;
181}
182
b8c91906
LOK
183CStdString CCECAdapterMessage::ToString(void) const
184{
185 CStdString strMsg;
fd5e333a 186 if (size() == 0)
b8c91906 187 {
fd5e333a
LOK
188 strMsg = "empty message";
189 }
190 else
191 {
192 strMsg = MessageCodeAsString();
193
194 switch (message())
b8c91906 195 {
fd5e333a
LOK
196 case MSGCODE_TIMEOUT_ERROR:
197 case MSGCODE_HIGH_ERROR:
198 case MSGCODE_LOW_ERROR:
199 {
200 int iLine = (size() >= 3) ? (at(1) << 8) | at(2) : 0;
201 uint32_t iTime = (size() >= 7) ? (at(3) << 24) | (at(4) << 16) | (at(5) << 8) | at(6) : 0;
202 strMsg.AppendFormat(" line:%i", iLine);
203 strMsg.AppendFormat(" time:%u", iTime);
204 }
205 break;
206 case MSGCODE_FRAME_START:
207 if (size() >= 2)
208 strMsg.AppendFormat(" initiator:%1x destination:%1x ack:%s %s", initiator(), destination(), ack() ? "high" : "low", eom() ? "eom" : "");
209 break;
210 case MSGCODE_FRAME_DATA:
211 if (size() >= 2)
212 strMsg.AppendFormat(" %02x %s", at(1), eom() ? "eom" : "");
213 break;
214 default:
215 break;
b8c91906 216 }
b8c91906
LOK
217 }
218
219 return strMsg;
220}
221
e41b06f9
LOK
222bool CCECAdapterMessage::is_error(void) const
223{
224 cec_adapter_messagecode code = message();
855a3a98 225 return (code == MSGCODE_HIGH_ERROR ||
e41b06f9
LOK
226 code == MSGCODE_LOW_ERROR ||
227 code == MSGCODE_RECEIVE_FAILED ||
228 code == MSGCODE_COMMAND_REJECTED ||
229 code == MSGCODE_TRANSMIT_LINE_TIMEOUT ||
230 code == MSGCODE_TRANSMIT_FAILED_LINE ||
231 code == MSGCODE_TRANSMIT_FAILED_ACK ||
232 code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
233 code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE);
234}
235
c7903c02 236void CCECAdapterMessage::push_escaped(uint8_t byte)
ad24cbaf 237{
a96eb42e 238 if (byte >= MSGESC)
ad24cbaf
LOK
239 {
240 push_back(MSGESC);
c7903c02 241 push_back(byte - ESCOFFSET);
ad24cbaf
LOK
242 }
243 else
c7903c02 244 push_back(byte);
ad24cbaf
LOK
245}
246
1113cb7d 247CAdapterCommunication::CAdapterCommunication(CCECProcessor *processor) :
12027dbe 248 m_port(NULL),
1113cb7d 249 m_processor(processor)
a8f0bd18
LOK
250{
251 m_port = new CSerialPort;
252}
253
828682d3 254CAdapterCommunication::~CAdapterCommunication(void)
a8f0bd18 255{
12027dbe
LOK
256 Close();
257
258 if (m_port)
259 {
260 delete m_port;
261 m_port = NULL;
262 }
a8f0bd18
LOK
263}
264
25701fa6 265bool CAdapterCommunication::Open(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */)
a8f0bd18 266{
f077e8ed 267 CLockObject lock(&m_mutex);
13fd6a66
LOK
268 if (!m_port)
269 {
1113cb7d 270 m_processor->AddLog(CEC_LOG_ERROR, "port is NULL");
a8f0bd18 271 return false;
13fd6a66
LOK
272 }
273
274 if (IsOpen())
275 {
1113cb7d 276 m_processor->AddLog(CEC_LOG_ERROR, "port is already open");
13fd6a66 277 }
a8f0bd18
LOK
278
279 if (!m_port->Open(strPort, iBaudRate))
280 {
281 CStdString strError;
282 strError.Format("error opening serial port '%s': %s", strPort, m_port->GetError().c_str());
1113cb7d 283 m_processor->AddLog(CEC_LOG_ERROR, strError);
a8f0bd18
LOK
284 return false;
285 }
286
1113cb7d 287 m_processor->AddLog(CEC_LOG_DEBUG, "connection opened");
a8f0bd18
LOK
288
289 //clear any input bytes
290 uint8_t buff[1024];
417aca83 291 while (m_port->Read(buff, sizeof(buff), 500) > 0) {}
a8f0bd18 292
828682d3 293 if (CreateThread())
a8f0bd18 294 {
b9eea66d 295 m_startCondition.Wait(&m_mutex);
1113cb7d 296 m_processor->AddLog(CEC_LOG_DEBUG, "communication thread started");
a8f0bd18
LOK
297 return true;
298 }
299 else
300 {
1113cb7d 301 m_processor->AddLog(CEC_LOG_DEBUG, "could not create a communication thread");
a8f0bd18
LOK
302 }
303
304 return false;
305}
306
828682d3 307void CAdapterCommunication::Close(void)
a8f0bd18 308{
f077e8ed 309 CLockObject lock(&m_mutex);
b9eea66d 310 m_startCondition.Broadcast();
d5bffd3c 311 m_rcvCondition.Broadcast();
b9eea66d 312 StopThread();
a8f0bd18
LOK
313}
314
828682d3 315void *CAdapterCommunication::Process(void)
a8f0bd18 316{
b9eea66d
LOK
317 {
318 CLockObject lock(&m_mutex);
319 m_startCondition.Signal();
320 }
12027dbe 321
13fd6a66 322 while (!IsStopped())
a8f0bd18 323 {
b9abf920 324 ReadFromDevice(500);
c02980af 325 Sleep(5);
3c53ac93 326 WriteNextCommand();
a8f0bd18
LOK
327 }
328
a8f0bd18
LOK
329 return NULL;
330}
331
25701fa6 332bool CAdapterCommunication::ReadFromDevice(uint32_t iTimeout)
a8f0bd18 333{
25701fa6 334 int32_t iBytesRead;
13fd6a66
LOK
335 uint8_t buff[1024];
336 if (!m_port)
337 return false;
b6c82769 338
13fd6a66
LOK
339 iBytesRead = m_port->Read(buff, sizeof(buff), iTimeout);
340 if (iBytesRead < 0 || iBytesRead > 256)
a8f0bd18 341 {
13fd6a66
LOK
342 CStdString strError;
343 strError.Format("error reading from serial port: %s", m_port->GetError().c_str());
1113cb7d 344 m_processor->AddLog(CEC_LOG_ERROR, strError);
13fd6a66 345 return false;
a8f0bd18 346 }
13fd6a66
LOK
347 else if (iBytesRead > 0)
348 AddData(buff, (uint8_t) iBytesRead);
25701fa6 349
13fd6a66 350 return iBytesRead > 0;
a8f0bd18
LOK
351}
352
8bca69de 353void CAdapterCommunication::AddData(uint8_t *data, uint8_t iLen)
a8f0bd18 354{
f077e8ed 355 CLockObject lock(&m_mutex);
50aa01e6
LOK
356 for (unsigned int iPtr = 0; iPtr < iLen; iPtr++)
357 m_inBuffer.Push(data[iPtr]);
d5bffd3c
LOK
358
359 m_rcvCondition.Signal();
a8f0bd18
LOK
360}
361
3c53ac93 362void CAdapterCommunication::WriteNextCommand(void)
a8f0bd18 363{
28352a04 364 CCECAdapterMessage *msg;
3c53ac93 365 if (m_outBuffer.Pop(msg))
a96eb42e
LOK
366 SendMessageToAdapter(msg);
367}
368
369void CAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
370{
a96eb42e
LOK
371 CLockObject lock(&msg->mutex);
372 if (m_port->Write(msg) != (int32_t) msg->size())
a8f0bd18 373 {
a96eb42e
LOK
374 CStdString strError;
375 strError.Format("error writing to serial port: %s", m_port->GetError().c_str());
1113cb7d 376 m_processor->AddLog(CEC_LOG_ERROR, strError);
a96eb42e 377 msg->state = ADAPTER_MESSAGE_STATE_ERROR;
25701fa6 378 }
a96eb42e
LOK
379 else
380 {
1113cb7d 381 m_processor->AddLog(CEC_LOG_DEBUG, "command sent");
530afcae 382 CCondition::Sleep((uint32_t) msg->size() * 24 /*data*/ + 5 /*start bit (4.5 ms)*/);
a96eb42e
LOK
383 msg->state = ADAPTER_MESSAGE_STATE_SENT;
384 }
385 msg->condition.Signal();
3c53ac93 386}
2abe74eb 387
28352a04 388bool CAdapterCommunication::Write(CCECAdapterMessage *data)
3c53ac93 389{
0e31a62c 390 data->state = ADAPTER_MESSAGE_STATE_WAITING;
3c53ac93 391 m_outBuffer.Push(data);
a8f0bd18
LOK
392 return true;
393}
394
220537f2 395bool CAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
a8f0bd18 396{
f077e8ed 397 CLockObject lock(&m_mutex);
a8f0bd18 398
50aa01e6
LOK
399 msg.clear();
400 uint64_t iNow = GetTimeMs();
401 uint64_t iTarget = iNow + iTimeout;
402 bool bGotFullMessage(false);
403 bool bNextIsEscaped(false);
404 bool bGotStart(false);
a8f0bd18 405
50aa01e6 406 while(!bGotFullMessage && iNow < iTarget)
a8f0bd18 407 {
50aa01e6
LOK
408 uint8_t buf = 0;
409 if (!m_inBuffer.Pop(buf))
a8f0bd18 410 {
56701628 411 if (!m_rcvCondition.Wait(&m_mutex, (uint32_t) (iTarget - iNow)))
50aa01e6 412 return false;
a8f0bd18 413 }
a8f0bd18 414
50aa01e6 415 if (!bGotStart)
a8f0bd18 416 {
50aa01e6
LOK
417 if (buf == MSGSTART)
418 bGotStart = true;
419 continue;
a8f0bd18 420 }
50aa01e6 421 else if (buf == MSGSTART) //we found a msgstart before msgend, this is not right, remove
a8f0bd18 422 {
855a3a98 423 if (msg.size() > 0)
1113cb7d 424 m_processor->AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
50aa01e6
LOK
425 msg.clear();
426 bGotStart = true;
a8f0bd18 427 }
a8f0bd18 428
50aa01e6 429 if (buf == MSGEND)
a8f0bd18 430 {
50aa01e6 431 bGotFullMessage = true;
a8f0bd18 432 }
50aa01e6
LOK
433 else if (bNextIsEscaped)
434 {
435 msg.push_back(buf + (uint8_t)ESCOFFSET);
436 bNextIsEscaped = false;
437 }
438 else if (buf == MSGESC)
439 bNextIsEscaped = true;
440 else
441 msg.push_back(buf);
a8f0bd18
LOK
442 }
443
0e31a62c
LOK
444 if (bGotFullMessage)
445 msg.state = ADAPTER_MESSAGE_STATE_RECEIVED;
446
50aa01e6 447 return bGotFullMessage;
a8f0bd18
LOK
448}
449
828682d3 450std::string CAdapterCommunication::GetError(void) const
a8f0bd18
LOK
451{
452 return m_port->GetError();
453}
2abe74eb
LOK
454
455bool CAdapterCommunication::StartBootloader(void)
456{
28352a04 457 bool bReturn(false);
2abe74eb 458 if (!IsRunning())
28352a04 459 return bReturn;
2abe74eb 460
1113cb7d 461 m_processor->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
28352a04 462 CCECAdapterMessage *output = new CCECAdapterMessage;
25701fa6 463
5a1e87c8
LOK
464 output->push_back(MSGSTART);
465 output->push_escaped(MSGCODE_START_BOOTLOADER);
466 output->push_back(MSGEND);
2abe74eb 467
802b7a0f
LOK
468 CLockObject lock(&output->mutex);
469 if (Write(output))
470 output->condition.Wait(&output->mutex);
a96eb42e 471 bReturn = output->state == ADAPTER_MESSAGE_STATE_SENT;
28352a04
LOK
472 delete output;
473
474 return bReturn;
2abe74eb
LOK
475}
476
2abe74eb
LOK
477bool CAdapterCommunication::PingAdapter(void)
478{
28352a04 479 bool bReturn(false);
2abe74eb 480 if (!IsRunning())
28352a04 481 return bReturn;
2abe74eb 482
1113cb7d 483 m_processor->AddLog(CEC_LOG_DEBUG, "sending ping");
28352a04 484 CCECAdapterMessage *output = new CCECAdapterMessage;
25701fa6 485
5a1e87c8
LOK
486 output->push_back(MSGSTART);
487 output->push_escaped(MSGCODE_PING);
488 output->push_back(MSGEND);
2abe74eb 489
802b7a0f
LOK
490 CLockObject lock(&output->mutex);
491 if (Write(output))
492 output->condition.Wait(&output->mutex);
a96eb42e 493 bReturn = output->state == ADAPTER_MESSAGE_STATE_SENT;
28352a04
LOK
494 delete output;
495
496 return bReturn;
2abe74eb 497}
13fd6a66
LOK
498
499bool CAdapterCommunication::IsOpen(void) const
500{
b9eea66d 501 return !IsStopped() && m_port->IsOpen() && IsRunning();
13fd6a66 502}