fixed: compile
[deb_libcec.git] / 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 }