src/lib/adapter/USBCECAdapterCommunication.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011-2012 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 "USBCECAdapterCommunication.h"
  34 #include "../platform/sockets/serialport.h"
  35 #include "../platform/util/timeutils.h"
  36 #include "../LibCEC.h"
  37 #include "../CECProcessor.h"
  38
  39 using namespace std;
  40 using namespace CEC;
  41 using namespace PLATFORM;
  42
  43 void *CUSBCECAdapterProcessor::Process(void)
  44 {
  45   cec_command command;
  46   while (!IsStopped())
  47   {
  48     if (m_inBuffer.Pop(command))
  49       m_callback->OnCommandReceived(command);
  50     Sleep(5);
  51   }
  52
  53   return NULL;
  54 }
  55
  56 void CUSBCECAdapterProcessor::AddCommand(cec_command command)
  57 {
  58   m_inBuffer.Push(command);
  59 }
  60
  61 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(CCECProcessor *processor, const char *strPort, uint16_t iBaudRate /* = 38400 */) :
  62     m_port(NULL),
  63     m_processor(processor),
  64     m_bHasData(false),
  65     m_iLineTimeout(0),
  66     m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN),
  67     m_lastInitiator(CECDEVICE_UNKNOWN),
  68     m_bNextIsEscaped(false),
  69     m_bGotStart(false),
  70     m_messageProcessor(NULL),
  71     m_bInitialised(false)
  72 {
  73   m_port = new PLATFORM::CSerialPort(strPort, iBaudRate);
  74 }
  75
  76 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
  77 {
  78   Close();
  79 }
  80
  81 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = 10000 */)
  82 {
  83   bool bReturn(false);
  84   uint64_t iNow = GetTimeMs();
  85   uint64_t iTarget = iTimeoutMs > 0 ? iNow + iTimeoutMs : iNow + CEC_DEFAULT_TRANSMIT_WAIT;
  86
  87   /* try to ping the adapter */
  88   bool bPinged(false);
  89   unsigned iPingTry(0);
  90   while (iNow < iTarget && (bPinged = PingAdapter()) == false)
  91   {
  92     CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
  93     CEvent::Sleep(500);
  94     iNow = GetTimeMs();
  95   }
  96
  97   /* try to read the firmware version */
  98   m_iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
  99   unsigned iFwVersionTry(0);
 100   while (bPinged && iNow < iTarget && (m_iFirmwareVersion = GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN && iFwVersionTry < 3)
 101   {
 102     CLibCEC::AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry);
 103     CEvent::Sleep(500);
 104     iNow = GetTimeMs();
 105   }
 106
 107   if (m_iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
 108   {
 109     CLibCEC::AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1");
 110     m_iFirmwareVersion = 1;
 111   }
 112
 113   if (m_iFirmwareVersion >= 2)
 114   {
 115     /* try to set controlled mode */
 116     unsigned iControlledTry(0);
 117     bool bControlled(false);
 118     while (iNow < iTarget && (bControlled = SetControlledMode(true)) == false)
 119     {
 120       CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
 121       CEvent::Sleep(500);
 122       iNow = GetTimeMs();
 123     }
 124     bReturn = bControlled;
 125   }
 126   else
 127     bReturn = true;
 128
 129   {
 130     CLockObject lock(m_mutex);
 131     m_bInitialised = bReturn;
 132   }
 133
 134   return bReturn;
 135 }
 136
 137 bool CUSBCECAdapterCommunication::Open(IAdapterCommunicationCallback *cb, uint32_t iTimeoutMs /* = 10000 */, bool bSkipChecks /* = false */)
 138 {
 139   uint64_t iNow = GetTimeMs();
 140   uint64_t iTimeout = iNow + iTimeoutMs;
 141
 142   {
 143     CLockObject lock(m_mutex);
 144
 145     if (!m_port)
 146     {
 147       CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
 148       return false;
 149     }
 150
 151     if (IsOpen())
 152     {
 153       CLibCEC::AddLog(CEC_LOG_ERROR, "port is already open");
 154       return true;
 155     }
 156
 157     m_callback = cb;
 158     CStdString strError;
 159     bool bConnected(false);
 160     while (!bConnected && iNow < iTimeout)
 161     {
 162       if ((bConnected = m_port->Open(iTimeout)) == false)
 163       {
 164         strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
 165         Sleep(250);
 166         iNow = GetTimeMs();
 167       }
 168     }
 169
 170     if (!bConnected)
 171     {
 172       CLibCEC::AddLog(CEC_LOG_ERROR, strError);
 173       return false;
 174     }
 175
 176     CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
 177
 178     if (!bSkipChecks)
 179     {
 180       //clear any input bytes
 181       uint8_t buff[1024];
 182       while (m_port->Read(buff, 1024, 100) > 0)
 183       {
 184         CLibCEC::AddLog(CEC_LOG_DEBUG, "data received, clearing it");
 185         Sleep(250);
 186       }
 187     }
 188   }
 189
 190   if (!bSkipChecks && !CheckAdapter())
 191   {
 192     CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
 193     return false;
 194   }
 195   else
 196   {
 197     if (CreateThread())
 198     {
 199       CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
 200       return true;
 201     }
 202     else
 203     {
 204       CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
 205     }
 206   }
 207
 208   return false;
 209 }
 210
 211 void CUSBCECAdapterCommunication::Close(void)
 212 {
 213   StopThread();
 214 }
 215
 216 void *CUSBCECAdapterCommunication::Process(void)
 217 {
 218   m_messageProcessor = new CUSBCECAdapterProcessor(m_callback);
 219   m_messageProcessor->CreateThread();
 220
 221   cec_command command;
 222   command.Clear();
 223   bool bCommandReceived(false);
 224   while (!IsStopped())
 225   {
 226     {
 227       CLockObject lock(m_mutex);
 228       ReadFromDevice(50);
 229       bCommandReceived = m_callback && Read(command, 0) && m_bInitialised;
 230     }
 231
 232     /* push the next command to the callback method if there is one */
 233     if (!IsStopped() && bCommandReceived)
 234       m_messageProcessor->AddCommand(command);
 235
 236     if (!IsStopped())
 237     {
 238       Sleep(5);
 239       WriteNextCommand();
 240     }
 241   }
 242
 243   /* stop the message processor */
 244   m_messageProcessor->StopThread();
 245   delete m_messageProcessor;
 246
 247   /* notify all threads that are waiting on messages to be sent */
 248   CCECAdapterMessage *msg(NULL);
 249   while (m_outBuffer.Pop(msg))
 250     msg->event.Broadcast();
 251
 252   /* set the ackmask to 0 before closing the connection */
 253   SetAckMaskInternal(0, true);
 254
 255   if (m_port)
 256   {
 257     delete m_port;
 258     m_port = NULL;
 259   }
 260
 261   return NULL;
 262 }
 263
 264 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, uint8_t iMaxTries, uint8_t iLineTimeout /* = 3 */, uint8_t iRetryLineTimeout /* = 3 */)
 265 {
 266   cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
 267   if (!IsRunning())
 268     return retVal;
 269
 270   CCECAdapterMessage *output = new CCECAdapterMessage(data);
 271
 272   /* set the number of retries */
 273   if (data.opcode == CEC_OPCODE_NONE) //TODO
 274     output->maxTries = 1;
 275   else if (data.initiator != CECDEVICE_BROADCAST)
 276     output->maxTries = iMaxTries;
 277
 278   output->lineTimeout = iLineTimeout;
 279   output->retryTimeout = iRetryLineTimeout;
 280   output->tries = 0;
 281
 282   bool bRetry(true);
 283   while (bRetry && ++output->tries < output->maxTries)
 284   {
 285     bRetry = (!Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
 286     if (bRetry)
 287       Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 288   }
 289   retVal = output->state;
 290
 291   delete output;
 292   return retVal;
 293 }
 294
 295 bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage *data)
 296 {
 297   data->state = ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT;
 298   m_outBuffer.Push(data);
 299   data->event.Wait(5000);
 300
 301   if ((data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT_ACKED) ||
 302       (!data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT))
 303   {
 304     CLibCEC::AddLog(CEC_LOG_DEBUG, "command was not %s", data->state == ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED ? "acked" : "sent");
 305     return false;
 306   }
 307
 308   return true;
 309 }
 310
 311 bool CUSBCECAdapterCommunication::Read(cec_command &command, uint32_t iTimeout)
 312 {
 313   if (!IsRunning())
 314     return false;
 315
 316   CCECAdapterMessage msg;
 317   if (Read(msg, iTimeout))
 318   {
 319     if (ParseMessage(msg))
 320     {
 321       command = m_currentframe;
 322       m_currentframe.Clear();
 323       return true;
 324     }
 325   }
 326   return false;
 327 }
 328
 329 bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
 330 {
 331   CLockObject lock(m_mutex);
 332
 333   msg.Clear();
 334   CCECAdapterMessage *buf(NULL);
 335
 336   if (!m_inBuffer.Pop(buf))
 337   {
 338     if (iTimeout == 0 || !m_rcvCondition.Wait(m_mutex, m_bHasData, iTimeout))
 339       return false;
 340     m_inBuffer.Pop(buf);
 341     m_bHasData = !m_inBuffer.IsEmpty();
 342   }
 343
 344   if (buf)
 345   {
 346     msg.packet = buf->packet;
 347     msg.state = ADAPTER_MESSAGE_STATE_INCOMING;
 348     delete buf;
 349     return true;
 350   }
 351   return false;
 352 }
 353
 354 CStdString CUSBCECAdapterCommunication::GetError(void) const
 355 {
 356   CStdString strError;
 357   strError = m_port->GetError();
 358   return strError;
 359 }
 360
 361 bool CUSBCECAdapterCommunication::StartBootloader(void)
 362 {
 363   bool bReturn(false);
 364   if (!IsRunning())
 365     return bReturn;
 366
 367   CLibCEC::AddLog(CEC_LOG_DEBUG, "starting the bootloader");
 368   CCECAdapterMessage *output = new CCECAdapterMessage;
 369
 370   output->PushBack(MSGSTART);
 371   output->PushEscaped(MSGCODE_START_BOOTLOADER);
 372   output->PushBack(MSGEND);
 373   output->isTransmission = false;
 374   output->expectControllerAck = false;
 375
 376   if ((bReturn = Write(output)) == false)
 377     CLibCEC::AddLog(CEC_LOG_ERROR, "could not start the bootloader");
 378   delete output;
 379
 380   return bReturn;
 381 }
 382
 383 bool CUSBCECAdapterCommunication::PingAdapter(void)
 384 {
 385   CLockObject lock(m_mutex);
 386   CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping");
 387
 388   CCECAdapterMessage *output = new CCECAdapterMessage;
 389
 390   output->PushBack(MSGSTART);
 391   output->PushEscaped(MSGCODE_PING);
 392   output->PushBack(MSGEND);
 393   output->isTransmission = false;
 394
 395   SendMessageToAdapter(output);
 396   bool bWriteOk = output->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 397   delete output;
 398   if (!bWriteOk)
 399   {
 400     CLibCEC::AddLog(CEC_LOG_ERROR, "could not ping the adapter");
 401     return false;
 402   }
 403
 404   return true;
 405 }
 406
 407 bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage &msg)
 408 {
 409   bool bEom(false);
 410   bool bIsError(msg.IsError());
 411
 412   if (msg.IsEmpty())
 413     return bEom;
 414
 415   CLockObject adapterLock(m_mutex);
 416   switch(msg.Message())
 417   {
 418   case MSGCODE_FRAME_START:
 419     {
 420       m_currentframe.Clear();
 421       if (msg.Size() >= 2)
 422       {
 423         m_currentframe.initiator   = msg.Initiator();
 424         m_currentframe.destination = msg.Destination();
 425         m_currentframe.ack         = msg.IsACK();
 426         m_currentframe.eom         = msg.IsEOM();
 427       }
 428       if (m_currentframe.ack == 0x1)
 429       {
 430         m_lastInitiator = m_currentframe.initiator;
 431         m_processor->HandlePoll(m_currentframe.initiator, m_currentframe.destination);
 432       }
 433     }
 434     break;
 435   case MSGCODE_RECEIVE_FAILED:
 436     {
 437       m_currentframe.Clear();
 438       if (m_lastInitiator != CECDEVICE_UNKNOWN)
 439         bIsError = m_processor->HandleReceiveFailed(m_lastInitiator);
 440     }
 441     break;
 442   case MSGCODE_FRAME_DATA:
 443     {
 444       if (msg.Size() >= 2)
 445       {
 446         m_currentframe.PushBack(msg[1]);
 447         m_currentframe.eom = msg.IsEOM();
 448       }
 449     }
 450     break;
 451   default:
 452     break;
 453   }
 454
 455   CLibCEC::AddLog(bIsError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
 456   return msg.IsEOM();
 457 }
 458
 459 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
 460 {
 461   uint16_t iReturn(m_iFirmwareVersion);
 462
 463   if (iReturn == CEC_FW_VERSION_UNKNOWN)
 464   {
 465     CLockObject lock(m_mutex);
 466     CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
 467     CCECAdapterMessage *output = new CCECAdapterMessage;
 468
 469     output->PushBack(MSGSTART);
 470     output->PushEscaped(MSGCODE_FIRMWARE_VERSION);
 471     output->PushBack(MSGEND);
 472     output->isTransmission = false;
 473     output->expectControllerAck = false;
 474
 475     SendMessageToAdapter(output);
 476     bool bWriteOk = output->state == ADAPTER_MESSAGE_STATE_SENT;
 477     delete output;
 478     if (!bWriteOk)
 479     {
 480       CLibCEC::AddLog(CEC_LOG_ERROR, "could not request the firmware version");
 481       return iReturn;
 482     }
 483
 484     Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
 485     ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT, 5 /* start + msgcode + 2 bytes for fw version + end */);
 486     CCECAdapterMessage input;
 487     if (Read(input, 0))
 488     {
 489       if (input.Message() != MSGCODE_FIRMWARE_VERSION || input.Size() != 3)
 490         CLibCEC::AddLog(CEC_LOG_ERROR, "invalid firmware version (size = %d, message = %d)", input.Size(), input.Message());
 491       else
 492       {
 493         m_iFirmwareVersion = (input[1] << 8 | input[2]);
 494         iReturn = m_iFirmwareVersion;
 495       }
 496     }
 497     else
 498     {
 499       CLibCEC::AddLog(CEC_LOG_ERROR, "no firmware version received");
 500     }
 501   }
 502
 503   return iReturn;
 504 }
 505
 506 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 507 {
 508   m_iLineTimeout = iTimeout;
 509   return true;
 510   //TODO
 511 //  bool bReturn(m_iLineTimeout != iTimeout);
 512 //
 513 //  if (!bReturn)
 514 //  {
 515 //    CCECAdapterMessage *output = new CCECAdapterMessage;
 516 //
 517 //    output->PushBack(MSGSTART);
 518 //    output->PushEscaped(MSGCODE_TRANSMIT_IDLETIME);
 519 //    output->PushEscaped(iTimeout);
 520 //    output->PushBack(MSGEND);
 521 //    output->isTransmission = false;
 522 //
 523 //    if ((bReturn = Write(output)) == false)
 524 //      CLibCEC::AddLog(CEC_LOG_ERROR, "could not set the idletime");
 525 //    delete output;
 526 //  }
 527 //
 528 //  return bReturn;
 529 }
 530
 531 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
 532 {
 533   return SetAckMaskInternal(iMask, false);
 534 }
 535
 536 bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask, bool bWriteDirectly /* = false */)
 537 {
 538   bool bReturn(false);
 539   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask);
 540
 541   CCECAdapterMessage *output = new CCECAdapterMessage;
 542
 543   output->PushBack(MSGSTART);
 544   output->PushEscaped(MSGCODE_SET_ACK_MASK);
 545   output->PushEscaped(iMask >> 8);
 546   output->PushEscaped((uint8_t)iMask);
 547   output->PushBack(MSGEND);
 548   output->isTransmission = false;
 549
 550   if (bWriteDirectly)
 551     SendMessageToAdapter(output);
 552   else if ((bReturn = Write(output)) == false)
 553     CLibCEC::AddLog(CEC_LOG_ERROR, "could not set the ackmask");
 554   delete output;
 555
 556   return bReturn;
 557 }
 558
 559
 560 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 561 {
 562   CLockObject lock(m_mutex);
 563   CLibCEC::AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
 564
 565   CCECAdapterMessage *output = new CCECAdapterMessage;
 566
 567   output->PushBack(MSGSTART);
 568   output->PushEscaped(MSGCODE_SET_CONTROLLED);
 569   output->PushEscaped(controlled);
 570   output->PushBack(MSGEND);
 571   output->isTransmission = false;
 572
 573   SendMessageToAdapter(output);
 574   bool bWriteOk = output->state == ADAPTER_MESSAGE_STATE_SENT;
 575   delete output;
 576   if (!bWriteOk)
 577   {
 578     CLibCEC::AddLog(CEC_LOG_ERROR, "could not set controlled mode");
 579     return false;
 580   }
 581
 582   return true;
 583 }
 584
 585 bool CUSBCECAdapterCommunication::IsOpen(void)
 586 {
 587   return !IsStopped() && m_port->IsOpen() && IsRunning();
 588 }
 589
 590 bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage &message)
 591 {
 592   bool bError(false);
 593   bool bTransmitSucceeded(false);
 594   uint8_t iPacketsLeft(message.Size() / 4);
 595
 596   int64_t iNow = GetTimeMs();
 597   int64_t iTargetTime = iNow + (message.transmit_timeout <= 5 ? CEC_DEFAULT_TRANSMIT_WAIT : message.transmit_timeout);
 598
 599   while (!bTransmitSucceeded && !bError && iNow < iTargetTime)
 600   {
 601     ReadFromDevice(50);
 602     CCECAdapterMessage msg;
 603     if (!Read(msg, 0))
 604     {
 605       iNow = GetTimeMs();
 606       continue;
 607     }
 608
 609     if (msg.Message() == MSGCODE_FRAME_START && msg.IsACK())
 610     {
 611       m_processor->HandlePoll(msg.Initiator(), msg.Destination());
 612       m_lastInitiator = msg.Initiator();
 613       iNow = GetTimeMs();
 614       continue;
 615     }
 616
 617     if (msg.Message() == MSGCODE_RECEIVE_FAILED &&
 618         m_lastInitiator != CECDEVICE_UNKNOWN &&
 619         m_processor->HandleReceiveFailed(m_lastInitiator))
 620     {
 621       iNow = GetTimeMs();
 622       continue;
 623     }
 624
 625     bError = msg.IsError();
 626     if (bError)
 627     {
 628       message.reply = msg.Message();
 629       CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 630     }
 631     else
 632     {
 633       switch(msg.Message())
 634       {
 635       case MSGCODE_COMMAND_ACCEPTED:
 636         if (iPacketsLeft > 0)
 637           iPacketsLeft--;
 638         if (!message.isTransmission && iPacketsLeft == 0)
 639           bTransmitSucceeded = true;
 640         CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - waiting for %d more", msg.ToString().c_str(), iPacketsLeft);
 641         break;
 642       case MSGCODE_TRANSMIT_SUCCEEDED:
 643         CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 644         bTransmitSucceeded = (iPacketsLeft == 0);
 645         bError = !bTransmitSucceeded;
 646         message.reply = MSGCODE_TRANSMIT_SUCCEEDED;
 647         break;
 648       default:
 649         // ignore other data while waiting
 650         break;
 651       }
 652
 653       iNow = GetTimeMs();
 654     }
 655   }
 656
 657   message.state = bTransmitSucceeded && !bError ?
 658       ADAPTER_MESSAGE_STATE_SENT_ACKED :
 659       ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
 660
 661   return bTransmitSucceeded && !bError;
 662 }
 663
 664 void CUSBCECAdapterCommunication::AddData(uint8_t *data, size_t iLen)
 665 {
 666   CLockObject lock(m_mutex);
 667   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 668   {
 669     if (!m_bGotStart)
 670     {
 671       if (data[iPtr] == MSGSTART)
 672         m_bGotStart = true;
 673     }
 674     else if (data[iPtr] == MSGSTART) //we found a msgstart before msgend, this is not right, remove
 675     {
 676       if (m_currentAdapterMessage.Size() > 0)
 677         CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
 678       m_currentAdapterMessage.Clear();
 679       m_bGotStart = true;
 680     }
 681     else if (data[iPtr] == MSGEND)
 682     {
 683       CCECAdapterMessage *newMessage = new CCECAdapterMessage;
 684       newMessage->packet = m_currentAdapterMessage.packet;
 685       m_inBuffer.Push(newMessage);
 686       m_currentAdapterMessage.Clear();
 687       m_bGotStart = false;
 688       m_bNextIsEscaped = false;
 689       m_bHasData = true;
 690       m_rcvCondition.Broadcast();
 691     }
 692     else if (m_bNextIsEscaped)
 693     {
 694       m_currentAdapterMessage.PushBack(data[iPtr] + (uint8_t)ESCOFFSET);
 695       m_bNextIsEscaped = false;
 696     }
 697     else if (data[iPtr] == MSGESC)
 698     {
 699       m_bNextIsEscaped = true;
 700     }
 701     else
 702     {
 703       m_currentAdapterMessage.PushBack(data[iPtr]);
 704     }
 705   }
 706 }
 707
 708 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 709 {
 710   ssize_t iBytesRead;
 711   uint8_t buff[256];
 712   if (!m_port)
 713     return false;
 714   if (iSize > 256)
 715     iSize = 256;
 716
 717   CLockObject lock(m_mutex);
 718   iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 719   if (iBytesRead < 0 || iBytesRead > 256)
 720   {
 721     CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 722     StopThread(false);
 723     return false;
 724   }
 725   else if (iBytesRead > 0)
 726   {
 727     AddData(buff, iBytesRead);
 728   }
 729
 730   return iBytesRead > 0;
 731 }
 732
 733 void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
 734 {
 735   CLockObject adapterLock(m_mutex);
 736   if (!m_port->IsOpen())
 737   {
 738     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: the connection is closed");
 739     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 740     return;
 741   }
 742
 743   if (msg->tries == 1)
 744     SetLineTimeout(msg->lineTimeout);
 745   else
 746     SetLineTimeout(msg->retryTimeout);
 747
 748   if (m_port->Write(msg->packet.data, msg->Size()) != (ssize_t) msg->Size())
 749   {
 750     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: %s", m_port->GetError().c_str());
 751     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 752   }
 753   else
 754   {
 755     CLibCEC::AddLog(CEC_LOG_DEBUG, "command sent");
 756     msg->state = ADAPTER_MESSAGE_STATE_SENT;
 757
 758     if (msg->expectControllerAck)
 759     {
 760       if (!WaitForAck(*msg))
 761         CLibCEC::AddLog(CEC_LOG_DEBUG, "did not receive ack");
 762     }
 763   }
 764   msg->event.Signal();
 765 }
 766
 767 void CUSBCECAdapterCommunication::WriteNextCommand(void)
 768 {
 769   CCECAdapterMessage *msg(NULL);
 770   if (m_outBuffer.Pop(msg))
 771     SendMessageToAdapter(msg);
 772 }
 773
 774 CStdString CUSBCECAdapterCommunication::GetPortName(void)
 775 {
 776   CStdString strName;
 777   strName = m_port->GetName();
 778   return strName;
 779 }