X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2Fadapter%2FUSBCECAdapterCommunication.cpp;h=a74194369029665969f01de31ab8783b70b997d5;hb=a75e3a5a63546d6f7e670bc2a7a1931887a5d2a0;hp=0134751d31b2b05f8eb4f88f3320ff9b09fba686;hpb=7bb4ed43f15a0fa2be17d2c3f580b181ac7430a7;p=deb_libcec.git

diff --git a/src/lib/adapter/USBCECAdapterCommunication.cpp b/src/lib/adapter/USBCECAdapterCommunication.cpp
index 0134751..a741943 100644
--- a/src/lib/adapter/USBCECAdapterCommunication.cpp
+++ b/src/lib/adapter/USBCECAdapterCommunication.cpp
@@ -31,6 +31,8 @@
  */
 
 #include "USBCECAdapterCommunication.h"
+#include "USBCECAdapterCommands.h"
+#include "USBCECAdapterMessageQueue.h"
 #include "../platform/sockets/serialport.h"
 #include "../platform/util/timeutils.h"
 #include "../LibCEC.h"
@@ -40,132 +42,158 @@ using namespace std;
 using namespace CEC;
 using namespace PLATFORM;
 
-CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(CCECProcessor *processor, const char *strPort, uint16_t iBaudRate /* = 38400 */) :
+#define CEC_ADAPTER_PING_TIMEOUT 15000
+
+CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate /* = 38400 */) :
+    IAdapterCommunication(callback),
     m_port(NULL),
-    m_processor(processor),
     m_iLineTimeout(0),
-    m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN),
-    m_lastInitiator(CECDEVICE_UNKNOWN),
-    m_bNextIsEscaped(false),
-    m_bGotStart(false)
+    m_lastPollDestination(CECDEVICE_UNKNOWN),
+    m_bInitialised(false),
+    m_pingThread(NULL),
+    m_commands(NULL),
+    m_adapterMessageQueue(NULL)
 {
-  m_port = new PLATFORM::CSerialPort(strPort, iBaudRate);
+  for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
+    m_bWaitingForAck[iPtr] = false;
+  m_port = new CSerialPort(strPort, iBaudRate);
 }
 
 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
 {
   Close();
-
-  if (m_port)
-  {
-    delete m_port;
-    m_port = NULL;
-  }
+  delete m_commands;
+  delete m_adapterMessageQueue;
 }
 
-bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs /* = 10000 */)
+bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs /* = 10000 */, bool bSkipChecks /* = false */, bool bStartListening /* = true */)
 {
-  uint64_t iNow = GetTimeMs();
-  uint64_t iTimeout = iNow + iTimeoutMs;
+  bool bConnectionOpened(false);
+  {
+    CLockObject lock(m_mutex);
 
-  CLockObject lock(m_mutex);
+    /* we need the port settings here */
+    if (!m_port)
+    {
+      CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
+      return bConnectionOpened;
+    }
 
-  if (!m_port)
-  {
-    CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
-    return false;
-  }
+    /* return true when the port is already open */
+    if (IsOpen())
+    {
+      CLibCEC::AddLog(CEC_LOG_WARNING, "port is already open");
+      return true;
+    }
 
-  if (IsOpen())
-  {
-    CLibCEC::AddLog(CEC_LOG_ERROR, "port is already open");
-    return true;
-  }
+    /* adapter commands */
+    if (!m_commands)
+      m_commands = new CUSBCECAdapterCommands(this);
 
-  CStdString strError;
-  bool bConnected(false);
-  while (!bConnected && iNow < iTimeout)
-  {
-    if ((bConnected = m_port->Open(iTimeout)) == false)
+    if (!m_adapterMessageQueue)
+      m_adapterMessageQueue = new CCECAdapterMessageQueue(this);
+
+    /* try to open the connection */
+    CStdString strError;
+    CTimeout timeout(iTimeoutMs);
+    while (!bConnectionOpened && timeout.TimeLeft() > 0)
     {
-      strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
-      Sleep(250);
-      iNow = GetTimeMs();
+      if ((bConnectionOpened = m_port->Open(timeout.TimeLeft())) == false)
+      {
+        strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
+        Sleep(250);
+      }
+      /* and retry every 250ms until the timeout passed */
     }
+
+    /* return false when we couldn't connect */
+    if (!bConnectionOpened)
+    {
+      CLibCEC::AddLog(CEC_LOG_ERROR, strError);
+      return false;
+    }
+
+    CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
+    ClearInputBytes();
   }
 
-  if (!bConnected)
+  if (!CreateThread())
   {
-    CLibCEC::AddLog(CEC_LOG_ERROR, strError);
-    return false;
+    bConnectionOpened = false;
+    CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
   }
-
-  CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
-
-  //clear any input bytes
-  uint8_t buff[1024];
-  while (m_port->Read(buff, 1024, 100) > 0)
+  else if (!bSkipChecks && !CheckAdapter())
   {
-    CLibCEC::AddLog(CEC_LOG_DEBUG, "data received, clearing it");
-    Sleep(250);
+    bConnectionOpened = false;
+    CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
   }
-
-  if (CreateThread())
+  else if (bStartListening)
   {
-    CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
-    return true;
+    /* start a ping thread, that will ping the adapter every 15 seconds
+       if it doesn't receive any ping for 30 seconds, it'll switch to auto mode */
+    m_pingThread = new CAdapterPingThread(this, CEC_ADAPTER_PING_TIMEOUT);
+    if (m_pingThread->CreateThread())
+    {
+      bConnectionOpened = true;
+    }
+    else
+    {
+      bConnectionOpened = false;
+      CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a ping thread");
+    }
   }
-  else
+
+  if (!bConnectionOpened || !bStartListening)
+    StopThread(0);
+  if (!bConnectionOpened)
   {
-    CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
+    delete m_port;
+    m_port = NULL;
   }
 
-  return false;
+  return bConnectionOpened;
 }
 
 void CUSBCECAdapterCommunication::Close(void)
 {
-  CLockObject lock(m_mutex);
-  m_rcvCondition.Broadcast();
-  StopThread();
-}
-
-void *CUSBCECAdapterCommunication::Process(void)
-{
-  while (!IsStopped())
+  /* set the ackmask to 0 before closing the connection */
+  if (IsRunning())
   {
-    ReadFromDevice(50);
-    Sleep(5);
-    WriteNextCommand();
+    SetAckMask(0);
+    if (m_commands->GetFirmwareVersion() >= 2)
+      SetControlledMode(false);
   }
 
-  CCECAdapterMessage *msg(NULL);
-  if (m_outBuffer.Pop(msg))
-    msg->condition.Broadcast();
+  /* stop and delete the ping thread */
+  if (m_pingThread)
+    m_pingThread->StopThread(0);
+  delete m_pingThread;
+  m_pingThread = NULL;
 
-  return NULL;
+  /* stop the reader thread */
+  StopThread(0);
+
+  /* close and delete the com port connection */
+  delete m_port;
+  m_port = NULL;
 }
 
 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, uint8_t iMaxTries, uint8_t iLineTimeout /* = 3 */, uint8_t iRetryLineTimeout /* = 3 */)
 {
   cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
+  if (!IsRunning())
+    return retVal;
 
-  CCECAdapterMessage *output = new CCECAdapterMessage(data);
-
-  /* set the number of retries */
-  if (data.opcode == CEC_OPCODE_NONE) //TODO
-    output->maxTries = 1;
-  else if (data.initiator != CECDEVICE_BROADCAST)
-    output->maxTries = iMaxTries;
+  CCECAdapterMessage *output = new CCECAdapterMessage(data, iMaxTries, iLineTimeout, iRetryLineTimeout);
 
-  output->lineTimeout = iLineTimeout;
-  output->retryTimeout = iRetryLineTimeout;
-  output->tries = 0;
+  /* mark as waiting for an ack from the destination */
+  MarkAsWaiting(data.destination);
 
+  /* send the message */
   bool bRetry(true);
   while (bRetry && ++output->tries < output->maxTries)
   {
-    bRetry = (!Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
+    bRetry = (!m_adapterMessageQueue->Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
     if (bRetry)
       Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
   }
@@ -175,433 +203,324 @@ cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &
   return retVal;
 }
 
-bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage *data)
+void *CUSBCECAdapterCommunication::Process(void)
 {
-  bool bReturn(false);
-
-  CLockObject lock(data->mutex);
-  data->state = ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT;
-  m_outBuffer.Push(data);
-  data->condition.Wait(data->mutex);
+  CCECAdapterMessage msg;
+  CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
 
-  if (data->state != ADAPTER_MESSAGE_STATE_SENT)
+  while (!IsStopped())
   {
-    CLibCEC::AddLog(CEC_LOG_ERROR, "command was not sent");
+    /* read from the serial port */
+    if (!ReadFromDevice(50, 5))
+      break;
+
+    /* TODO sleep 5 ms so other threads can get a lock */
+    Sleep(5);
   }
-  else if (data->expectControllerAck)
+
+  m_adapterMessageQueue->Clear();
+  CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread ended");
+  return NULL;
+}
+
+bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage &msg)
+{
+  bool bIsError(msg.IsError());
+  cec_adapter_messagecode messageCode(msg.Message());
+  CLockObject lock(m_mutex);
+
+  if (messageCode == MSGCODE_FRAME_START && msg.IsACK())
   {
-    bReturn = WaitForAck(*data);
-    if (bReturn)
-    {
-      if (data->isTransmission)
-        data->state = ADAPTER_MESSAGE_STATE_SENT_ACKED;
-    }
-    else
+    m_lastPollDestination = msg.Destination();
+    if (msg.Destination() < CECDEVICE_BROADCAST)
     {
-      data->state = ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
-      CLibCEC::AddLog(CEC_LOG_DEBUG, "did not receive ack");
+      if (!m_bWaitingForAck[msg.Destination()] && !msg.IsEOM())
+      {
+        if (m_callback)
+          m_callback->HandlePoll(msg.Initiator(), msg.Destination());
+      }
+      else
+        m_bWaitingForAck[msg.Destination()] = false;
     }
   }
-  else
+  else if (messageCode == MSGCODE_RECEIVE_FAILED)
   {
-    bReturn = true;
+    /* hack to suppress warnings when an LG is polling */
+    if (m_lastPollDestination != CECDEVICE_UNKNOWN)
+      bIsError = m_callback->HandleReceiveFailed(m_lastPollDestination);
   }
 
-  return bReturn;
+  return bIsError;
 }
 
-bool CUSBCECAdapterCommunication::Read(cec_command &command, uint32_t iTimeout)
+void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest)
 {
-  CCECAdapterMessage msg;
-  if (Read(msg, iTimeout))
+  /* mark as waiting for an ack from the destination */
+  if (dest < CECDEVICE_BROADCAST)
   {
-    if (ParseMessage(msg))
-    {
-      command = m_currentframe;
-      m_currentframe.Clear();
-      return true;
-    }
+    CLockObject lock(m_mutex);
+    m_bWaitingForAck[dest] = true;
   }
-  return false;
 }
 
-bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
+void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout /* = 1000 */)
 {
-  CLockObject lock(m_mutex);
-
-  msg.Clear();
-  CCECAdapterMessage *buf(NULL);
+  CTimeout timeout(iTimeout);
+  uint8_t buff[1024];
+  ssize_t iBytesRead(0);
+  bool bGotMsgEnd(false);
 
-  if (!m_inBuffer.Pop(buf))
+  while (timeout.TimeLeft() > 0 && ((iBytesRead = m_port->Read(buff, 1024, 5)) > 0 || !bGotMsgEnd))
   {
-    if (!m_rcvCondition.Wait(m_mutex, iTimeout))
-      return false;
-    m_inBuffer.Pop(buf);
+    /* if something was received, wait for MSGEND */
+    for (ssize_t iPtr = 0; iPtr < iBytesRead; iPtr++)
+      bGotMsgEnd = buff[iPtr] == MSGEND;
   }
+}
+
+bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
+{
+  bool bReturn(true);
+  bool bChanged(false);
 
-  if (buf)
+  /* only send the command if the timeout changed */
   {
-    msg.packet = buf->packet;
-    msg.state = msg.state = ADAPTER_MESSAGE_STATE_INCOMING;
-    delete buf;
-    return true;
+    CLockObject lock(m_mutex);
+    bChanged = (m_iLineTimeout != iTimeout);
+    m_iLineTimeout = iTimeout;
   }
-  return false;
-}
 
-CStdString CUSBCECAdapterCommunication::GetError(void) const
-{
-  CStdString strError;
-  strError = m_port->GetError();
-  return strError;
+  if (bChanged)
+    bReturn = m_commands->SetLineTimeout(iTimeout);
+
+  return bReturn;
 }
 
-bool CUSBCECAdapterCommunication::StartBootloader(void)
+bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
 {
-  bool bReturn(false);
-  if (!IsRunning())
-    return bReturn;
-
-  CLibCEC::AddLog(CEC_LOG_DEBUG, "starting the bootloader");
-  CCECAdapterMessage *output = new CCECAdapterMessage;
-
-  output->PushBack(MSGSTART);
-  output->PushEscaped(MSGCODE_START_BOOTLOADER);
-  output->PushBack(MSGEND);
-  output->isTransmission = false;
-  output->expectControllerAck = false;
+  CLockObject adapterLock(m_mutex);
+  if (!m_port->IsOpen())
+  {
+    CLibCEC::AddLog(CEC_LOG_DEBUG, "error writing command '%s' to the serial port: the connection is closed", CCECAdapterMessage::ToString(message->Message()));
+    message->state = ADAPTER_MESSAGE_STATE_ERROR;
+    return false;
+  }
 
-  if ((bReturn = Write(output)) == false)
-    CLibCEC::AddLog(CEC_LOG_ERROR, "could not start the bootloader");
-  delete output;
+  /* write the message */
+  if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
+  {
+    CLibCEC::AddLog(CEC_LOG_DEBUG, "error writing command '%s' to the serial port: %s", CCECAdapterMessage::ToString(message->Message()), m_port->GetError().c_str());
+    message->state = ADAPTER_MESSAGE_STATE_ERROR;
+    return false;
+  }
 
-  return bReturn;
+  CLibCEC::AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
+  message->state = ADAPTER_MESSAGE_STATE_SENT;
+  return true;
 }
 
-bool CUSBCECAdapterCommunication::PingAdapter(void)
+bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 {
-  bool bReturn(false);
-  if (!IsRunning())
-    return bReturn;
-
-  CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping");
-  CCECAdapterMessage *output = new CCECAdapterMessage;
+  ssize_t iBytesRead(0);
+  uint8_t buff[256];
+  if (iSize > 256)
+    iSize = 256;
 
-  output->PushBack(MSGSTART);
-  output->PushEscaped(MSGCODE_PING);
-  output->PushBack(MSGEND);
-  output->isTransmission = false;
+  /* read from the serial port */
+  {
+    CLockObject lock(m_mutex);
+    if (!m_port)
+      return false;
+    iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
+  }
 
-  if ((bReturn = Write(output)) == false)
-    CLibCEC::AddLog(CEC_LOG_ERROR, "could not ping the adapter");
-  delete output;
+  if (iBytesRead < 0 || iBytesRead > 256)
+  {
+    CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
+    StopThread(false);
+    return false;
+  }
+  else if (iBytesRead > 0)
+  {
+    /* add the data to the current frame */
+    m_adapterMessageQueue->AddData(buff, iBytesRead);
+  }
 
-  return bReturn;
+  return true;
 }
 
-bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage &msg)
+CCECAdapterMessage *CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry /* = false */)
 {
-  bool bEom(false);
-  bool bIsError(msg.IsError());
+  if (!m_port || !m_port->IsOpen() ||
+      !m_adapterMessageQueue)
+    return NULL;
 
-  if (msg.IsEmpty())
-    return bEom;
+  /* create the adapter message for this command */
+  CCECAdapterMessage *output = new CCECAdapterMessage;
+  output->PushBack(MSGSTART);
+  output->PushEscaped((uint8_t)msgCode);
+  output->Append(params);
+  output->PushBack(MSGEND);
 
-  switch(msg.Message())
+  /* write the command */
+  if (!m_adapterMessageQueue->Write(output))
   {
-  case MSGCODE_FRAME_START:
-    {
-      m_currentframe.Clear();
-      if (msg.Size() >= 2)
-      {
-        m_currentframe.initiator   = msg.Initiator();
-        m_currentframe.destination = msg.Destination();
-        m_currentframe.ack         = msg.IsACK();
-        m_currentframe.eom         = msg.IsEOM();
-      }
-      if (m_currentframe.ack == 0x1)
-      {
-        m_lastInitiator = m_currentframe.initiator;
-        m_processor->HandlePoll(m_currentframe.initiator, m_currentframe.destination);
-      }
-    }
-    break;
-  case MSGCODE_RECEIVE_FAILED:
-    {
-      m_currentframe.Clear();
-      if (m_lastInitiator != CECDEVICE_UNKNOWN)
-        bIsError = m_processor->HandleReceiveFailed(m_lastInitiator);
-    }
-    break;
-  case MSGCODE_FRAME_DATA:
+    // timed out
+    return output;
+  }
+  else
+  {
+    if (!bIsRetry && output->Reply() == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED)
     {
-      if (msg.Size() >= 2)
-      {
-        m_currentframe.PushBack(msg[1]);
-        m_currentframe.eom = msg.IsEOM();
-      }
-      bEom = msg.IsEOM();
+      /* if the controller reported that the command was rejected, and we didn't send the command
+         to set controlled mode, then the controller probably switched to auto mode. set controlled
+         mode and retry */
+      CLibCEC::AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
+      delete output;
+      if (SetControlledMode(true))
+        return SendCommand(msgCode, params, true);
     }
-    break;
-  default:
-    break;
   }
 
-  CLibCEC::AddLog(bIsError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
-  return bEom;
+  return output;
 }
 
-uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
+bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = 10000 */)
 {
-  uint16_t iReturn(m_iFirmwareVersion);
-  if (!IsRunning())
-    return iReturn;
+  bool bReturn(false);
+  CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
 
-  if (iReturn == CEC_FW_VERSION_UNKNOWN)
+  /* try to ping the adapter */
+  bool bPinged(false);
+  unsigned iPingTry(0);
+  while (timeout.TimeLeft() > 0 && (bPinged = PingAdapter()) == false)
   {
-    CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
-    CCECAdapterMessage *output = new CCECAdapterMessage;
-
-    output->PushBack(MSGSTART);
-    output->PushEscaped(MSGCODE_FIRMWARE_VERSION);
-    output->PushBack(MSGEND);
-    output->isTransmission = false;
-    output->expectControllerAck = false;
-
-    SendMessageToAdapter(output);
-    delete output;
+    CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
+    CEvent::Sleep(500);
+  }
 
-    CCECAdapterMessage input;
-    if (!Read(input, CEC_DEFAULT_TRANSMIT_WAIT) || input.Message() != MSGCODE_FIRMWARE_VERSION || input.Size() != 3)
-      CLibCEC::AddLog(CEC_LOG_ERROR, "no or invalid firmware version (size = %d, message = %d)", input.Size(), input.Message());
-    else
+  /* try to read the firmware version */
+  if (bPinged && timeout.TimeLeft() > 0 && m_commands->RequestFirmwareVersion() >= 2)
+  {
+    /* try to set controlled mode for v2+ firmwares */
+    unsigned iControlledTry(0);
+    bool bControlled(false);
+    while (timeout.TimeLeft() > 0 && (bControlled = SetControlledMode(true)) == false)
     {
-      m_iFirmwareVersion = (input[1] << 8 | input[2]);
-      iReturn = m_iFirmwareVersion;
+      CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
+      CEvent::Sleep(500);
     }
+    bReturn = bControlled;
   }
+  else
+    bReturn = true;
 
-  return iReturn;
+  SetInitialised(bReturn);
+  return bReturn;
 }
 
-bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
+bool CUSBCECAdapterCommunication::IsOpen(void)
 {
-  m_iLineTimeout = iTimeout;
-  return true;
-  //TODO
-//  bool bReturn(m_iLineTimeout != iTimeout);
-//
-//  if (!bReturn)
-//  {
-//    CCECAdapterMessage *output = new CCECAdapterMessage;
-//
-//    output->PushBack(MSGSTART);
-//    output->PushEscaped(MSGCODE_TRANSMIT_IDLETIME);
-//    output->PushEscaped(iTimeout);
-//    output->PushBack(MSGEND);
-//    output->isTransmission = false;
-//
-//    if ((bReturn = Write(output)) == false)
-//      CLibCEC::AddLog(CEC_LOG_ERROR, "could not set the idletime");
-//    delete output;
-//  }
-//
-//  return bReturn;
+  /* thread is not being stopped, the port is open and the thread is running */
+  return !IsStopped() && m_port->IsOpen() && IsRunning();
 }
 
-bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
+CStdString CUSBCECAdapterCommunication::GetError(void) const
 {
-  bool bReturn(false);
-  CStdString strLog;
-  strLog.Format("setting ackmask to %2x", iMask);
-  CLibCEC::AddLog(CEC_LOG_DEBUG, strLog.c_str());
-
-  CCECAdapterMessage *output = new CCECAdapterMessage;
-
-  output->PushBack(MSGSTART);
-  output->PushEscaped(MSGCODE_SET_ACK_MASK);
-  output->PushEscaped(iMask >> 8);
-  output->PushEscaped((uint8_t)iMask);
-  output->PushBack(MSGEND);
-  output->isTransmission = false;
-
-  if ((bReturn = Write(output)) == false)
-    CLibCEC::AddLog(CEC_LOG_ERROR, "could not set the ackmask");
-  delete output;
-
-  return bReturn;
+  return m_port->GetError();
 }
 
-bool CUSBCECAdapterCommunication::IsOpen(void)
+void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo /* = true */)
 {
-  return !IsStopped() && m_port->IsOpen() && IsRunning();
+  CLockObject lock(m_mutex);
+  m_bInitialised = bSetTo;
 }
 
-bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage &message)
+bool CUSBCECAdapterCommunication::IsInitialised(void)
 {
-  bool bError(false);
-  bool bTransmitSucceeded(false);
-  uint8_t iPacketsLeft(message.Size() / 4);
-
-  int64_t iNow = GetTimeMs();
-  int64_t iTargetTime = iNow + message.transmit_timeout;
+  CLockObject lock(m_mutex);
+  return m_bInitialised;
+}
 
-  while (!bTransmitSucceeded && !bError && (message.transmit_timeout == 0 || iNow < iTargetTime))
-  {
-    CCECAdapterMessage msg;
-    int32_t iWait = (int32_t)(iTargetTime - iNow);
-    if (iWait <= 5 || message.transmit_timeout <= 5)
-      iWait = CEC_DEFAULT_TRANSMIT_WAIT;
+bool CUSBCECAdapterCommunication::StartBootloader(void)
+{
+  if (!IsRunning())
+    return false;
 
-    if (!Read(msg, iWait))
-    {
-      iNow = GetTimeMs();
-      continue;
-    }
+  return m_commands->StartBootloader();
+}
 
-    if (msg.Message() == MSGCODE_FRAME_START && msg.IsACK())
-    {
-      m_processor->HandlePoll(msg.Initiator(), msg.Destination());
-      m_lastInitiator = msg.Initiator();
-      iNow = GetTimeMs();
-      continue;
-    }
+bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
+{
+  return m_commands->SetAckMask(iMask);
+}
 
-    if (msg.Message() == MSGCODE_RECEIVE_FAILED &&
-        m_lastInitiator != CECDEVICE_UNKNOWN &&
-        m_processor->HandleReceiveFailed(m_lastInitiator))
-    {
-      iNow = GetTimeMs();
-      continue;
-    }
+bool CUSBCECAdapterCommunication::PingAdapter(void)
+{
+  return m_commands->PingAdapter();
+}
 
-    bError = msg.IsError();
-    if (bError)
-    {
-      message.reply = msg.Message();
-      CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
-    }
-    else
-    {
-      switch(msg.Message())
-      {
-      case MSGCODE_COMMAND_ACCEPTED:
-        CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
-        if (iPacketsLeft > 0)
-          iPacketsLeft--;
-        if (!message.isTransmission && iPacketsLeft == 0)
-          bTransmitSucceeded = true;
-        break;
-      case MSGCODE_TRANSMIT_SUCCEEDED:
-        CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
-        bTransmitSucceeded = (iPacketsLeft == 0);
-        bError = !bTransmitSucceeded;
-        message.reply = MSGCODE_TRANSMIT_SUCCEEDED;
-        break;
-      default:
-        // ignore other data while waiting
-        break;
-      }
+uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
+{
+  return m_commands->GetFirmwareVersion();
+}
 
-      iNow = GetTimeMs();
-    }
-  }
+bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration *configuration)
+{
+  return m_commands->PersistConfiguration(configuration);
+}
 
-  return bTransmitSucceeded && !bError;
+bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration *configuration)
+{
+  return m_commands->GetConfiguration(configuration);
 }
 
-void CUSBCECAdapterCommunication::AddData(uint8_t *data, size_t iLen)
+CStdString CUSBCECAdapterCommunication::GetPortName(void)
 {
-  CLockObject lock(m_mutex);
-  for (size_t iPtr = 0; iPtr < iLen; iPtr++)
-  {
-    if (!m_bGotStart)
-    {
-      if (data[iPtr] == MSGSTART)
-        m_bGotStart = true;
-    }
-    else if (data[iPtr] == MSGSTART) //we found a msgstart before msgend, this is not right, remove
-    {
-      if (m_currentAdapterMessage.Size() > 0)
-        CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
-      m_currentAdapterMessage.Clear();
-      m_bGotStart = true;
-    }
-    else if (data[iPtr] == MSGEND)
-    {
-      CCECAdapterMessage *newMessage = new CCECAdapterMessage;
-      newMessage->packet = m_currentAdapterMessage.packet;
-      m_inBuffer.Push(newMessage);
-      m_currentAdapterMessage.Clear();
-      m_bGotStart = false;
-      m_bNextIsEscaped = false;
-      m_rcvCondition.Signal();
-    }
-    else if (m_bNextIsEscaped)
-    {
-      m_currentAdapterMessage.PushBack(data[iPtr] + (uint8_t)ESCOFFSET);
-      m_bNextIsEscaped = false;
-    }
-    else if (data[iPtr] == MSGESC)
-    {
-      m_bNextIsEscaped = true;
-    }
-    else
-    {
-      m_currentAdapterMessage.PushBack(data[iPtr]);
-    }
-  }
+  return m_port->GetName();
 }
 
-bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout)
+bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 {
-  ssize_t iBytesRead;
-  uint8_t buff[256];
-  if (!m_port)
-    return false;
+  return m_commands->SetControlledMode(controlled);
+}
 
-  CLockObject lock(m_mutex);
-  iBytesRead = m_port->Read(buff, sizeof(buff), iTimeout);
-  if (iBytesRead < 0 || iBytesRead > 256)
-  {
-    CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
-    return false;
-  }
-  else if (iBytesRead > 0)
+void *CAdapterPingThread::Process(void)
+{
+  while (!IsStopped())
   {
-    AddData(buff, iBytesRead);
-  }
+    if (m_timeout.TimeLeft() == 0)
+    {
+      /* reinit the timeout */
+      m_timeout.Init(CEC_ADAPTER_PING_TIMEOUT);
 
-  return iBytesRead > 0;
-}
+      /* send a ping to the adapter */
+      bool bPinged(false);
+      int iFailedCounter(0);
+      while (!bPinged && iFailedCounter < 3)
+      {
+        if (!m_com->PingAdapter())
+        {
+          /* sleep 1 second and retry */
+          Sleep(1000);
+          ++iFailedCounter;
+        }
+        else
+        {
+          bPinged = true;
+        }
+      }
 
-void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
-{
-  CLockObject adapterLock(m_mutex);
-  CLockObject lock(msg->mutex);
-  if (msg->tries == 1)
-    SetLineTimeout(msg->lineTimeout);
-  else
-    SetLineTimeout(msg->retryTimeout);
+      if (iFailedCounter == 3)
+      {
+        /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
+        CLibCEC::AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
+        m_com->StopThread(false);
+        break;
+      }
+    }
 
-  if (m_port->Write(msg->packet.data, msg->Size()) != (ssize_t) msg->Size())
-  {
-    CStdString strError;
-    strError.Format("error writing to serial port: %s", m_port->GetError().c_str());
-    CLibCEC::AddLog(CEC_LOG_ERROR, strError);
-    msg->state = ADAPTER_MESSAGE_STATE_ERROR;
-  }
-  else
-  {
-    CLibCEC::AddLog(CEC_LOG_DEBUG, "command sent");
-    msg->state = ADAPTER_MESSAGE_STATE_SENT;
+    Sleep(500);
   }
-  msg->condition.Signal();
-}
-
-void CUSBCECAdapterCommunication::WriteNextCommand(void)
-{
-  CCECAdapterMessage *msg(NULL);
-  if (m_outBuffer.Pop(msg))
-    SendMessageToAdapter(msg);
+  return NULL;
 }