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 "CECProcessor.h"
  36 #include "platform/serialport.h"
  37 #include "util/StdString.h"
  38 #include "platform/timeutils.h"
  39
  40 using namespace std;
  41 using namespace CEC;
  42
  43 CCECAdapterMessage::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(command.opcode_set == 0 ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
  60   push_back(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
  61   push_back(MSGEND);
  62
  63   // add opcode
  64   if (command.opcode_set == 1)
  65   {
  66     push_back(MSGSTART);
  67     push_escaped(command.parameters.IsEmpty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
  68     push_back((uint8_t) command.opcode);
  69     push_back(MSGEND);
  70
  71     // add parameters
  72     for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
  73     {
  74       push_back(MSGSTART);
  75
  76       if (iPtr == command.parameters.size - 1)
  77         push_escaped( MSGCODE_TRANSMIT_EOM);
  78       else
  79         push_escaped(MSGCODE_TRANSMIT);
  80
  81       push_escaped(command.parameters[iPtr]);
  82
  83       push_back(MSGEND);
  84     }
  85   }
  86
  87   // set timeout
  88   transmit_timeout = command.transmit_timeout;
  89 }
  90
  91 CCECAdapterMessage &CCECAdapterMessage::operator =(const CCECAdapterMessage &msg)
  92 {
  93   packet = msg.packet;
  94   state  = msg.state;
  95   return *this;
  96 }
  97
  98 CStdString CCECAdapterMessage::MessageCodeAsString(void) const
  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:
 110     strMsg = "TIMEOUT";
 111     break;
 112   case MSGCODE_HIGH_ERROR:
 113     strMsg = "HIGH_ERROR";
 114     break;
 115   case MSGCODE_LOW_ERROR:
 116     strMsg = "LOW_ERROR";
 117     break;
 118   case MSGCODE_FRAME_START:
 119     strMsg = "FRAME_START";
 120     break;
 121   case MSGCODE_FRAME_DATA:
 122     strMsg = "FRAME_DATA";
 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
 183 CStdString CCECAdapterMessage::ToString(void) const
 184 {
 185   CStdString strMsg;
 186   if (size() == 0)
 187   {
 188     strMsg = "empty message";
 189   }
 190   else
 191   {
 192     strMsg = MessageCodeAsString();
 193
 194     switch (message())
 195     {
 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;
 216     }
 217   }
 218
 219   return strMsg;
 220 }
 221
 222 bool CCECAdapterMessage::is_error(void) const
 223 {
 224   cec_adapter_messagecode code = message();
 225   return (code == MSGCODE_HIGH_ERROR ||
 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
 236 void CCECAdapterMessage::push_escaped(uint8_t byte)
 237 {
 238   if (byte >= MSGESC)
 239   {
 240     push_back(MSGESC);
 241     push_back(byte - ESCOFFSET);
 242   }
 243   else
 244     push_back(byte);
 245 }
 246
 247 CAdapterCommunication::CAdapterCommunication(CCECProcessor *processor) :
 248     m_port(NULL),
 249     m_processor(processor),
 250     m_iLineTimeout(0)
 251 {
 252   m_port = new CSerialPort;
 253 }
 254
 255 CAdapterCommunication::~CAdapterCommunication(void)
 256 {
 257   Close();
 258
 259   if (m_port)
 260   {
 261     delete m_port;
 262     m_port = NULL;
 263   }
 264 }
 265
 266 bool CAdapterCommunication::Open(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */)
 267 {
 268   CLockObject lock(&m_mutex);
 269   if (!m_port)
 270   {
 271     m_processor->AddLog(CEC_LOG_ERROR, "port is NULL");
 272     return false;
 273   }
 274
 275   if (IsOpen())
 276   {
 277     m_processor->AddLog(CEC_LOG_ERROR, "port is already open");
 278   }
 279
 280   if (!m_port->Open(strPort, iBaudRate))
 281   {
 282     CStdString strError;
 283     strError.Format("error opening serial port '%s': %s", strPort, m_port->GetError().c_str());
 284     m_processor->AddLog(CEC_LOG_ERROR, strError);
 285     return false;
 286   }
 287
 288   m_processor->AddLog(CEC_LOG_DEBUG, "connection opened");
 289
 290   //clear any input bytes
 291   uint8_t buff[1];
 292   while (m_port->Read(buff, 1, 5) == 1) {}
 293
 294   if (CreateThread())
 295   {
 296     m_startCondition.Wait(&m_mutex);
 297     m_processor->AddLog(CEC_LOG_DEBUG, "communication thread started");
 298     return true;
 299   }
 300   else
 301   {
 302     m_processor->AddLog(CEC_LOG_DEBUG, "could not create a communication thread");
 303   }
 304
 305   //TODO implement the timeout. use the variable for now to silence the compiler warning
 306   iTimeoutMs = 0;
 307
 308   return false;
 309 }
 310
 311 void CAdapterCommunication::Close(void)
 312 {
 313   CLockObject lock(&m_mutex);
 314   m_startCondition.Broadcast();
 315   m_rcvCondition.Broadcast();
 316   StopThread();
 317 }
 318
 319 void *CAdapterCommunication::Process(void)
 320 {
 321   {
 322     CLockObject lock(&m_mutex);
 323     m_startCondition.Signal();
 324   }
 325
 326   while (!IsStopped())
 327   {
 328     ReadFromDevice(50);
 329     Sleep(5);
 330     WriteNextCommand();
 331   }
 332
 333   CCECAdapterMessage *msg;
 334   if (m_outBuffer.Pop(msg))
 335     msg->condition.Broadcast();
 336
 337   return NULL;
 338 }
 339
 340 bool CAdapterCommunication::ReadFromDevice(uint32_t iTimeout)
 341 {
 342   int32_t iBytesRead;
 343   uint8_t buff[1024];
 344   if (!m_port)
 345     return false;
 346
 347   iBytesRead = m_port->Read(buff, sizeof(buff), iTimeout);
 348   if (iBytesRead < 0 || iBytesRead > 256)
 349   {
 350     CStdString strError;
 351     strError.Format("error reading from serial port: %s", m_port->GetError().c_str());
 352     m_processor->AddLog(CEC_LOG_ERROR, strError);
 353     return false;
 354   }
 355   else if (iBytesRead > 0)
 356     AddData(buff, (uint8_t) iBytesRead);
 357
 358   return iBytesRead > 0;
 359 }
 360
 361 void CAdapterCommunication::AddData(uint8_t *data, uint8_t iLen)
 362 {
 363   CLockObject lock(&m_mutex);
 364   for (unsigned int iPtr = 0; iPtr < iLen; iPtr++)
 365     m_inBuffer.Push(data[iPtr]);
 366
 367   m_rcvCondition.Signal();
 368 }
 369
 370 void CAdapterCommunication::WriteNextCommand(void)
 371 {
 372   CCECAdapterMessage *msg;
 373   if (m_outBuffer.Pop(msg))
 374     SendMessageToAdapter(msg);
 375 }
 376
 377 void CAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
 378 {
 379   CLockObject lock(&msg->mutex);
 380   if (m_port->Write(msg) != (int32_t) msg->size())
 381   {
 382     CStdString strError;
 383     strError.Format("error writing to serial port: %s", m_port->GetError().c_str());
 384     m_processor->AddLog(CEC_LOG_ERROR, strError);
 385     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 386   }
 387   else
 388   {
 389     m_processor->AddLog(CEC_LOG_DEBUG, "command sent");
 390     msg->state = ADAPTER_MESSAGE_STATE_SENT;
 391   }
 392   msg->condition.Signal();
 393 }
 394
 395 bool CAdapterCommunication::Write(CCECAdapterMessage *data)
 396 {
 397   data->state = ADAPTER_MESSAGE_STATE_WAITING;
 398   m_outBuffer.Push(data);
 399   return true;
 400 }
 401
 402 bool CAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
 403 {
 404   CLockObject lock(&m_mutex);
 405
 406   msg.clear();
 407   uint64_t iNow = GetTimeMs();
 408   uint64_t iTarget = iNow + iTimeout;
 409   bool bGotFullMessage(false);
 410   bool bNextIsEscaped(false);
 411   bool bGotStart(false);
 412
 413   while(!bGotFullMessage && iNow < iTarget)
 414   {
 415     uint8_t buf = 0;
 416     if (!m_inBuffer.Pop(buf))
 417     {
 418       if (!m_rcvCondition.Wait(&m_mutex, (uint32_t) (iTarget - iNow)))
 419         return false;
 420     }
 421
 422     if (!bGotStart)
 423     {
 424       if (buf == MSGSTART)
 425         bGotStart = true;
 426       continue;
 427     }
 428     else if (buf == MSGSTART) //we found a msgstart before msgend, this is not right, remove
 429     {
 430       if (msg.size() > 0)
 431         m_processor->AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
 432       msg.clear();
 433       bGotStart = true;
 434     }
 435
 436     if (buf == MSGEND)
 437     {
 438       bGotFullMessage = true;
 439     }
 440     else if (bNextIsEscaped)
 441     {
 442       msg.push_back(buf + (uint8_t)ESCOFFSET);
 443       bNextIsEscaped = false;
 444     }
 445     else if (buf == MSGESC)
 446       bNextIsEscaped = true;
 447     else
 448       msg.push_back(buf);
 449   }
 450
 451   if (bGotFullMessage)
 452     msg.state = ADAPTER_MESSAGE_STATE_RECEIVED;
 453
 454   return bGotFullMessage;
 455 }
 456
 457 std::string CAdapterCommunication::GetError(void) const
 458 {
 459   return m_port->GetError();
 460 }
 461
 462 bool CAdapterCommunication::StartBootloader(void)
 463 {
 464   bool bReturn(false);
 465   if (!IsRunning())
 466     return bReturn;
 467
 468   m_processor->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
 469   CCECAdapterMessage *output = new CCECAdapterMessage;
 470
 471   output->push_back(MSGSTART);
 472   output->push_escaped(MSGCODE_START_BOOTLOADER);
 473   output->push_back(MSGEND);
 474
 475   CLockObject lock(&output->mutex);
 476   if (Write(output))
 477     output->condition.Wait(&output->mutex);
 478   bReturn = output->state == ADAPTER_MESSAGE_STATE_SENT;
 479   delete output;
 480
 481   return bReturn;
 482 }
 483
 484 bool CAdapterCommunication::PingAdapter(void)
 485 {
 486   bool bReturn(false);
 487   if (!IsRunning())
 488     return bReturn;
 489
 490   m_processor->AddLog(CEC_LOG_DEBUG, "sending ping");
 491   CCECAdapterMessage *output = new CCECAdapterMessage;
 492
 493   output->push_back(MSGSTART);
 494   output->push_escaped(MSGCODE_PING);
 495   output->push_back(MSGEND);
 496
 497   CLockObject lock(&output->mutex);
 498   if (Write(output))
 499     output->condition.Wait(&output->mutex);
 500   bReturn = output->state == ADAPTER_MESSAGE_STATE_SENT;
 501   delete output;
 502
 503   return bReturn;
 504 }
 505
 506 bool CAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 507 {
 508   bool bReturn(m_iLineTimeout != iTimeout);
 509
 510   if (!bReturn)
 511   {
 512     CCECAdapterMessage *output = new CCECAdapterMessage;
 513
 514     output->push_back(MSGSTART);
 515     output->push_escaped(MSGCODE_TRANSMIT_IDLETIME);
 516     output->push_escaped(iTimeout);
 517     output->push_back(MSGEND);
 518
 519     if ((bReturn = Write(output)) == false)
 520       m_processor->AddLog(CEC_LOG_ERROR, "could not set the idletime");
 521     delete output;
 522   }
 523
 524   return bReturn;
 525 }
 526
 527 bool CAdapterCommunication::IsOpen(void) const
 528 {
 529   return !IsStopped() && m_port->IsOpen() && IsRunning();
 530 }