2 * This file is part of the libCEC(R) library.
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
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.
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.
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.
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
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/
33 #include "USBCECAdapterCommunication.h"
34 #include "../platform/sockets/serialport.h"
35 #include "../platform/util/timeutils.h"
36 #include "../LibCEC.h"
37 #include "../CECProcessor.h"
41 using namespace PLATFORM
;
43 #define CEC_ADAPTER_PING_TIMEOUT 15000
45 void *CUSBCECAdapterProcessor::Process(void)
50 if (m_inBuffer
.Pop(command
))
51 m_callback
->OnCommandReceived(command
);
58 void CUSBCECAdapterProcessor::AddCommand(cec_command command
)
60 m_inBuffer
.Push(command
);
63 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(CCECProcessor
*processor
, const char *strPort
, uint16_t iBaudRate
/* = 38400 */) :
65 m_processor(processor
),
68 m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN
),
69 m_lastInitiator(CECDEVICE_UNKNOWN
),
70 m_bNextIsEscaped(false),
72 m_messageProcessor(NULL
),
75 m_port
= new CSerialPort(strPort
, iBaudRate
);
78 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
83 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs
/* = 10000 */)
86 uint64_t iNow
= GetTimeMs();
87 uint64_t iTarget
= iTimeoutMs
> 0 ? iNow
+ iTimeoutMs
: iNow
+ CEC_DEFAULT_TRANSMIT_WAIT
;
89 /* try to ping the adapter */
92 while (iNow
< iTarget
&& (bPinged
= PingAdapter()) == false)
94 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry
);
99 /* try to read the firmware version */
100 m_iFirmwareVersion
= CEC_FW_VERSION_UNKNOWN
;
101 unsigned iFwVersionTry(0);
102 while (bPinged
&& iNow
< iTarget
&& (m_iFirmwareVersion
= GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN
&& iFwVersionTry
< 3)
104 CLibCEC::AddLog(CEC_LOG_WARNING
, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry
);
109 if (m_iFirmwareVersion
== CEC_FW_VERSION_UNKNOWN
)
111 CLibCEC::AddLog(CEC_LOG_DEBUG
, "defaulting to firmware version 1");
112 m_iFirmwareVersion
= 1;
115 if (m_iFirmwareVersion
>= 2)
117 /* try to set controlled mode */
118 unsigned iControlledTry(0);
119 bool bControlled(false);
120 while (iNow
< iTarget
&& (bControlled
= SetControlledMode(true)) == false)
122 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry
);
126 bReturn
= bControlled
;
132 CLockObject
lock(m_mutex
);
133 m_bInitialised
= bReturn
;
139 bool CUSBCECAdapterCommunication::Open(IAdapterCommunicationCallback
*cb
, uint32_t iTimeoutMs
/* = 10000 */, bool bSkipChecks
/* = false */)
141 uint64_t iNow
= GetTimeMs();
142 uint64_t iTimeout
= iNow
+ iTimeoutMs
;
145 CLockObject
lock(m_mutex
);
149 CLibCEC::AddLog(CEC_LOG_ERROR
, "port is NULL");
155 CLibCEC::AddLog(CEC_LOG_ERROR
, "port is already open");
161 bool bConnected(false);
162 while (!bConnected
&& iNow
< iTimeout
)
164 if ((bConnected
= m_port
->Open(iTimeout
)) == false)
166 strError
.Format("error opening serial port '%s': %s", m_port
->GetName().c_str(), m_port
->GetError().c_str());
174 CLibCEC::AddLog(CEC_LOG_ERROR
, strError
);
178 CLibCEC::AddLog(CEC_LOG_DEBUG
, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
182 //clear any input bytes
184 while (m_port
->Read(buff
, 1024, 100) > 0)
186 CLibCEC::AddLog(CEC_LOG_DEBUG
, "data received, clearing it");
192 if (!bSkipChecks
&& !CheckAdapter())
194 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter failed to pass basic checks");
201 CLibCEC::AddLog(CEC_LOG_DEBUG
, "communication thread started");
206 CLibCEC::AddLog(CEC_LOG_ERROR
, "could not create a communication thread");
213 void CUSBCECAdapterCommunication::Close(void)
218 void *CUSBCECAdapterCommunication::Process(void)
220 m_messageProcessor
= new CUSBCECAdapterProcessor(m_callback
);
221 m_messageProcessor
->CreateThread();
225 bool bCommandReceived(false);
226 CTimeout
pingTimeout(CEC_ADAPTER_PING_TIMEOUT
);
230 CLockObject
lock(m_mutex
);
232 bCommandReceived
= m_callback
&& Read(command
, 0) && m_bInitialised
;
235 /* push the next command to the callback method if there is one */
236 if (!IsStopped() && bCommandReceived
)
237 m_messageProcessor
->AddCommand(command
);
239 /* ping the adapter every 15 seconds */
240 if (pingTimeout
.TimeLeft() == 0)
242 pingTimeout
.Init(CEC_ADAPTER_PING_TIMEOUT
);
253 /* stop the message processor */
254 m_messageProcessor
->StopThread();
255 delete m_messageProcessor
;
257 /* notify all threads that are waiting on messages to be sent */
258 CCECAdapterMessage
*msg(NULL
);
259 while (m_outBuffer
.Pop(msg
))
260 msg
->event
.Broadcast();
262 /* set the ackmask to 0 before closing the connection */
263 SetAckMaskInternal(0, true);
265 if (m_iFirmwareVersion
>= 2)
266 SetControlledMode(false);
277 cec_adapter_message_state
CUSBCECAdapterCommunication::Write(const cec_command
&data
, uint8_t iMaxTries
, uint8_t iLineTimeout
/* = 3 */, uint8_t iRetryLineTimeout
/* = 3 */)
279 cec_adapter_message_state
retVal(ADAPTER_MESSAGE_STATE_UNKNOWN
);
283 CCECAdapterMessage
*output
= new CCECAdapterMessage(data
);
285 /* set the number of retries */
286 if (data
.opcode
== CEC_OPCODE_NONE
) //TODO
287 output
->maxTries
= 1;
288 else if (data
.initiator
!= CECDEVICE_BROADCAST
)
289 output
->maxTries
= iMaxTries
;
291 output
->lineTimeout
= iLineTimeout
;
292 output
->retryTimeout
= iRetryLineTimeout
;
296 while (bRetry
&& ++output
->tries
< output
->maxTries
)
298 bRetry
= (!Write(output
) || output
->NeedsRetry()) && output
->transmit_timeout
> 0;
300 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT
);
302 retVal
= output
->state
;
308 bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage
*data
)
310 data
->state
= ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT
;
311 m_outBuffer
.Push(data
);
312 data
->event
.Wait(5000);
314 if ((data
->expectControllerAck
&& data
->state
!= ADAPTER_MESSAGE_STATE_SENT_ACKED
) ||
315 (!data
->expectControllerAck
&& data
->state
!= ADAPTER_MESSAGE_STATE_SENT
))
317 CLibCEC::AddLog(CEC_LOG_DEBUG
, "command was not %s", data
->state
== ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED
? "acked" : "sent");
324 bool CUSBCECAdapterCommunication::Read(cec_command
&command
, uint32_t iTimeout
)
329 CCECAdapterMessage msg
;
330 if (Read(msg
, iTimeout
))
332 if (ParseMessage(msg
))
334 command
= m_currentframe
;
335 m_currentframe
.Clear();
342 bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage
&msg
, uint32_t iTimeout
)
344 CLockObject
lock(m_mutex
);
347 CCECAdapterMessage
*buf(NULL
);
349 if (!m_inBuffer
.Pop(buf
))
351 if (iTimeout
== 0 || !m_rcvCondition
.Wait(m_mutex
, m_bHasData
, iTimeout
))
354 m_bHasData
= !m_inBuffer
.IsEmpty();
359 msg
.packet
= buf
->packet
;
360 msg
.state
= ADAPTER_MESSAGE_STATE_INCOMING
;
367 CStdString
CUSBCECAdapterCommunication::GetError(void) const
370 strError
= m_port
->GetError();
374 bool CUSBCECAdapterCommunication::StartBootloader(void)
380 CLibCEC::AddLog(CEC_LOG_DEBUG
, "starting the bootloader");
382 CCECAdapterMessage params
;
383 return SendCommand(MSGCODE_START_BOOTLOADER
, params
, false);
386 bool CUSBCECAdapterCommunication::PingAdapter(void)
388 CLockObject
lock(m_mutex
);
389 CLibCEC::AddLog(CEC_LOG_DEBUG
, "sending ping");
391 CCECAdapterMessage params
;
392 return SendCommand(MSGCODE_PING
, params
);
395 bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage
&msg
)
398 bool bIsError(msg
.IsError());
403 CLockObject
adapterLock(m_mutex
);
404 switch(msg
.Message())
406 case MSGCODE_FRAME_START
:
408 m_currentframe
.Clear();
411 m_currentframe
.initiator
= msg
.Initiator();
412 m_currentframe
.destination
= msg
.Destination();
413 m_currentframe
.ack
= msg
.IsACK();
414 m_currentframe
.eom
= msg
.IsEOM();
416 if (m_currentframe
.ack
== 0x1)
418 m_lastInitiator
= m_currentframe
.initiator
;
419 m_processor
->HandlePoll(m_currentframe
.initiator
, m_currentframe
.destination
);
423 case MSGCODE_RECEIVE_FAILED
:
425 m_currentframe
.Clear();
426 if (m_lastInitiator
!= CECDEVICE_UNKNOWN
)
427 bIsError
= m_processor
->HandleReceiveFailed(m_lastInitiator
);
430 case MSGCODE_FRAME_DATA
:
434 m_currentframe
.PushBack(msg
[1]);
435 m_currentframe
.eom
= msg
.IsEOM();
443 CLibCEC::AddLog(bIsError
? CEC_LOG_WARNING
: CEC_LOG_DEBUG
, msg
.ToString());
447 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
449 uint16_t iReturn(m_iFirmwareVersion
);
451 if (iReturn
== CEC_FW_VERSION_UNKNOWN
)
453 CLockObject
lock(m_mutex
);
454 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting the firmware version");
455 cec_datapacket response
= GetSetting(MSGCODE_FIRMWARE_VERSION
);
456 if (response
.size
== 2)
458 m_iFirmwareVersion
= (response
[0] << 8 | response
[1]);
459 iReturn
= m_iFirmwareVersion
;
460 CLibCEC::AddLog(CEC_LOG_DEBUG
, "firmware version %d", m_iFirmwareVersion
);
467 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout
)
469 m_iLineTimeout
= iTimeout
;
470 bool bReturn(m_iLineTimeout
!= iTimeout
);
474 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the line timeout to %d", iTimeout
);
475 CCECAdapterMessage params
;
476 params
.PushEscaped(iTimeout
);
477 bReturn
= SendCommand(MSGCODE_TRANSMIT_IDLETIME
, params
);
483 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask
)
485 return SetAckMaskInternal(iMask
, IsRunning());
488 bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask
, bool bWriteDirectly
/* = false */)
490 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting ackmask to %2x", iMask
);
492 CCECAdapterMessage params
;
493 params
.PushEscaped(iMask
>> 8);
494 params
.PushEscaped((uint8_t)iMask
);
495 return SendCommand(MSGCODE_SET_ACK_MASK
, params
, true, false, bWriteDirectly
);
498 bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration
*configuration
)
500 if (m_iFirmwareVersion
< 2)
504 bReturn
&= SetAutoEnabled(true);
505 bReturn
&= SetDeviceType(CLibCEC::GetType(configuration
->logicalAddresses
.primary
));
506 bReturn
&= SetDefaultLogicalAddress(configuration
->logicalAddresses
.primary
);
507 bReturn
&= SetLogicalAddressMask(CLibCEC::GetMaskForType(configuration
->logicalAddresses
.primary
));
508 bReturn
&= SetPhysicalAddress(configuration
->iPhysicalAddress
);
509 bReturn
&= SetCECVersion(CEC_VERSION_1_3A
);
510 bReturn
&= SetOSDName(configuration
->strDeviceName
);
512 bReturn
= WriteEEPROM();
516 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled
)
518 CLockObject
lock(m_mutex
);
519 CLibCEC::AddLog(CEC_LOG_DEBUG
, "turning controlled mode %s", controlled
? "on" : "off");
521 CCECAdapterMessage params
;
522 params
.PushEscaped(controlled
? 1 : 0);
523 return SendCommand(MSGCODE_SET_CONTROLLED
, params
);
526 bool CUSBCECAdapterCommunication::SetAutoEnabled(bool enabled
)
528 CLockObject
lock(m_mutex
);
529 CLibCEC::AddLog(CEC_LOG_DEBUG
, "turning autonomous mode %s", enabled
? "on" : "off");
531 CCECAdapterMessage params
;
532 params
.PushEscaped(enabled
? 1 : 0);
533 return SendCommand(MSGCODE_SET_AUTO_ENABLED
, params
);
536 bool CUSBCECAdapterCommunication::SetDeviceType(cec_device_type type
)
538 CLockObject
lock(m_mutex
);
539 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the device type to %1X", (uint8_t)type
);
541 CCECAdapterMessage params
;
542 params
.PushEscaped((uint8_t)type
);
543 return SendCommand(MSGCODE_SET_DEVICE_TYPE
, params
);
546 bool CUSBCECAdapterCommunication::SetDefaultLogicalAddress(cec_logical_address address
)
548 CLockObject
lock(m_mutex
);
549 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the default logical address to %1X", address
);
551 CCECAdapterMessage params
;
552 params
.PushEscaped((uint8_t)address
);
553 return SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS
, params
);
556 bool CUSBCECAdapterCommunication::SetLogicalAddressMask(uint16_t iMask
)
558 CLockObject
lock(m_mutex
);
559 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the logical address mask to %2X", iMask
);
561 CCECAdapterMessage params
;
562 params
.PushEscaped(iMask
>> 8);
563 params
.PushEscaped((uint8_t)iMask
);
564 return SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK
, params
);
567 bool CUSBCECAdapterCommunication::SetPhysicalAddress(uint16_t iPhysicalAddress
)
569 CLockObject
lock(m_mutex
);
570 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the physical address to %2X", iPhysicalAddress
);
572 CCECAdapterMessage params
;
573 params
.PushEscaped(iPhysicalAddress
>> 8);
574 params
.PushEscaped((uint8_t)iPhysicalAddress
);
575 return SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS
, params
);
578 bool CUSBCECAdapterCommunication::SetCECVersion(cec_version version
)
580 CLockObject
lock(m_mutex
);
581 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the CEC version to %s", CLibCEC::GetInstance()->ToString(version
));
583 CCECAdapterMessage params
;
584 params
.PushEscaped((uint8_t)version
);
585 return SendCommand(MSGCODE_SET_HDMI_VERSION
, params
);
588 bool CUSBCECAdapterCommunication::SetOSDName(const char *strOSDName
)
590 CLockObject
lock(m_mutex
);
591 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the OSD name to %s", strOSDName
);
593 CCECAdapterMessage params
;
594 for (size_t iPtr
= 0; iPtr
< strlen(strOSDName
); iPtr
++)
595 params
.PushEscaped(strOSDName
[iPtr
]);
596 return SendCommand(MSGCODE_SET_OSD_NAME
, params
);
599 bool CUSBCECAdapterCommunication::WriteEEPROM(void)
601 CLockObject
lock(m_mutex
);
602 CLibCEC::AddLog(CEC_LOG_DEBUG
, "writing settings in the EEPROM");
604 CCECAdapterMessage params
;
605 return SendCommand(MSGCODE_WRITE_EEPROM
, params
);
608 bool CUSBCECAdapterCommunication::IsOpen(void)
610 return !IsStopped() && m_port
->IsOpen() && IsRunning();
613 bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage
&message
)
616 bool bTransmitSucceeded(false);
617 uint8_t iPacketsLeft(message
.isTransmission
? message
.Size() / 4 : 1);
619 int64_t iNow
= GetTimeMs();
620 int64_t iTargetTime
= iNow
+ (message
.transmit_timeout
<= 5 ? CEC_DEFAULT_TRANSMIT_WAIT
: message
.transmit_timeout
);
622 while (!bTransmitSucceeded
&& !bError
&& iNow
< iTargetTime
)
625 CCECAdapterMessage msg
;
632 if (msg
.Message() == MSGCODE_FRAME_START
&& msg
.IsACK())
634 m_processor
->HandlePoll(msg
.Initiator(), msg
.Destination());
635 m_lastInitiator
= msg
.Initiator();
640 if (msg
.Message() == MSGCODE_RECEIVE_FAILED
&&
641 m_lastInitiator
!= CECDEVICE_UNKNOWN
&&
642 m_processor
->HandleReceiveFailed(m_lastInitiator
))
648 bError
= msg
.IsError();
651 message
.reply
= msg
.Message();
652 CLibCEC::AddLog(CEC_LOG_DEBUG
, msg
.ToString());
656 switch(msg
.Message())
658 case MSGCODE_COMMAND_ACCEPTED
:
659 if (iPacketsLeft
> 0)
661 if (!message
.isTransmission
&& iPacketsLeft
== 0)
662 bTransmitSucceeded
= true;
663 CLibCEC::AddLog(CEC_LOG_DEBUG
, "%s - waiting for %d more", msg
.ToString().c_str(), iPacketsLeft
);
665 case MSGCODE_TRANSMIT_SUCCEEDED
:
666 CLibCEC::AddLog(CEC_LOG_DEBUG
, msg
.ToString());
667 bTransmitSucceeded
= (iPacketsLeft
== 0);
668 bError
= !bTransmitSucceeded
;
669 message
.reply
= MSGCODE_TRANSMIT_SUCCEEDED
;
672 // ignore other data while waiting
680 message
.state
= bTransmitSucceeded
&& !bError
?
681 ADAPTER_MESSAGE_STATE_SENT_ACKED
:
682 ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED
;
684 return bTransmitSucceeded
&& !bError
;
687 void CUSBCECAdapterCommunication::AddData(uint8_t *data
, size_t iLen
)
689 CLockObject
lock(m_mutex
);
690 for (size_t iPtr
= 0; iPtr
< iLen
; iPtr
++)
694 if (data
[iPtr
] == MSGSTART
)
697 else if (data
[iPtr
] == MSGSTART
) //we found a msgstart before msgend, this is not right, remove
699 if (m_currentAdapterMessage
.Size() > 0)
700 CLibCEC::AddLog(CEC_LOG_WARNING
, "received MSGSTART before MSGEND, removing previous buffer contents");
701 m_currentAdapterMessage
.Clear();
704 else if (data
[iPtr
] == MSGEND
)
706 CCECAdapterMessage
*newMessage
= new CCECAdapterMessage
;
707 newMessage
->packet
= m_currentAdapterMessage
.packet
;
708 m_inBuffer
.Push(newMessage
);
709 m_currentAdapterMessage
.Clear();
711 m_bNextIsEscaped
= false;
713 m_rcvCondition
.Broadcast();
715 else if (m_bNextIsEscaped
)
717 m_currentAdapterMessage
.PushBack(data
[iPtr
] + (uint8_t)ESCOFFSET
);
718 m_bNextIsEscaped
= false;
720 else if (data
[iPtr
] == MSGESC
)
722 m_bNextIsEscaped
= true;
726 m_currentAdapterMessage
.PushBack(data
[iPtr
]);
731 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout
, size_t iSize
/* = 256 */)
740 CLockObject
lock(m_mutex
);
741 iBytesRead
= m_port
->Read(buff
, sizeof(uint8_t) * iSize
, iTimeout
);
742 if (iBytesRead
< 0 || iBytesRead
> 256)
744 CLibCEC::AddLog(CEC_LOG_ERROR
, "error reading from serial port: %s", m_port
->GetError().c_str());
748 else if (iBytesRead
> 0)
750 AddData(buff
, iBytesRead
);
753 return iBytesRead
> 0;
756 void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage
*msg
)
758 CLockObject
adapterLock(m_mutex
);
759 if (!m_port
->IsOpen())
761 CLibCEC::AddLog(CEC_LOG_ERROR
, "error writing to serial port: the connection is closed");
762 msg
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
766 if (msg
->isTransmission
&& (msg
->Size() < 2 || msg
->At(1) != MSGCODE_TRANSMIT_IDLETIME
))
769 SetLineTimeout(msg
->lineTimeout
);
771 SetLineTimeout(msg
->retryTimeout
);
774 if (m_port
->Write(msg
->packet
.data
, msg
->Size()) != (ssize_t
) msg
->Size())
776 CLibCEC::AddLog(CEC_LOG_ERROR
, "error writing to serial port: %s", m_port
->GetError().c_str());
777 msg
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
781 CLibCEC::AddLog(CEC_LOG_DEBUG
, "command sent");
782 msg
->state
= ADAPTER_MESSAGE_STATE_SENT
;
784 if (msg
->expectControllerAck
)
786 if (!WaitForAck(*msg
))
787 CLibCEC::AddLog(CEC_LOG_DEBUG
, "did not receive ack");
793 void CUSBCECAdapterCommunication::WriteNextCommand(void)
795 CCECAdapterMessage
*msg(NULL
);
796 if (m_outBuffer
.Pop(msg
))
797 SendMessageToAdapter(msg
);
800 CStdString
CUSBCECAdapterCommunication::GetPortName(void)
803 strName
= m_port
->GetName();
807 bool CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode
, CCECAdapterMessage
¶ms
, bool bExpectAck
/* = true */, bool bIsTransmission
/* = false */, bool bSendDirectly
/* = true */)
809 CLockObject
lock(m_mutex
);
811 CCECAdapterMessage
*output
= new CCECAdapterMessage
;
813 output
->PushBack(MSGSTART
);
814 output
->PushEscaped(msgCode
);
815 output
->Append(params
);
816 output
->PushBack(MSGEND
);
817 output
->isTransmission
= bIsTransmission
;
818 output
->expectControllerAck
= bExpectAck
;
821 SendMessageToAdapter(output
);
825 bool bWriteOk
= output
->state
== (output
->expectControllerAck
? ADAPTER_MESSAGE_STATE_SENT_ACKED
: ADAPTER_MESSAGE_STATE_SENT
);
828 CLibCEC::AddLog(CEC_LOG_ERROR
, "'%s' failed", CCECAdapterMessage::ToString(msgCode
));
837 cec_datapacket
CUSBCECAdapterCommunication::GetSetting(cec_adapter_messagecode msgCode
)
839 cec_datapacket retVal
;
842 CCECAdapterMessage params
;
843 if (!SendCommand(msgCode
, params
, false))
845 CLibCEC::AddLog(CEC_LOG_ERROR
, "%s failed", CCECAdapterMessage::ToString(msgCode
));
849 Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
850 ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT
, 5 /* start + msgcode + 2 bytes for fw version + end */);
851 CCECAdapterMessage input
;
854 if (input
.Message() != msgCode
)
855 CLibCEC::AddLog(CEC_LOG_ERROR
, "invalid response to %s received (%s)", CCECAdapterMessage::ToString(msgCode
), CCECAdapterMessage::ToString(input
.Message()));
858 for (uint8_t iPtr
= 1; iPtr
< input
.Size(); iPtr
++)
859 retVal
.PushBack(input
[iPtr
]);
864 CLibCEC::AddLog(CEC_LOG_ERROR
, "no response to %s received", CCECAdapterMessage::ToString(msgCode
));