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_lastDestination(CECDEVICE_UNKNOWN
),
70 m_bNextIsEscaped(false),
72 m_messageProcessor(NULL
),
75 for (unsigned int iPtr
= 0; iPtr
< 15; iPtr
++)
76 m_bWaitingForAck
[iPtr
] = false;
77 m_port
= new CSerialPort(strPort
, iBaudRate
);
80 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs
/* = 10000 */)
83 uint64_t iNow
= GetTimeMs();
84 uint64_t iTarget
= iTimeoutMs
> 0 ? iNow
+ iTimeoutMs
: iNow
+ CEC_DEFAULT_TRANSMIT_WAIT
;
86 /* try to ping the adapter */
89 while (iNow
< iTarget
&& (bPinged
= PingAdapter()) == false)
91 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry
);
96 /* try to read the firmware version */
97 m_iFirmwareVersion
= CEC_FW_VERSION_UNKNOWN
;
98 unsigned iFwVersionTry(0);
99 while (bPinged
&& iNow
< iTarget
&& (m_iFirmwareVersion
= GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN
&& iFwVersionTry
< 3)
101 CLibCEC::AddLog(CEC_LOG_WARNING
, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry
);
106 if (m_iFirmwareVersion
== CEC_FW_VERSION_UNKNOWN
)
108 CLibCEC::AddLog(CEC_LOG_DEBUG
, "defaulting to firmware version 1");
109 m_iFirmwareVersion
= 1;
112 if (m_iFirmwareVersion
>= 2)
114 /* try to set controlled mode */
115 unsigned iControlledTry(0);
116 bool bControlled(false);
117 while (iNow
< iTarget
&& (bControlled
= SetControlledMode(true)) == false)
119 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry
);
123 bReturn
= bControlled
;
129 CLockObject
lock(m_mutex
);
130 m_bInitialised
= bReturn
;
136 bool CUSBCECAdapterCommunication::Open(IAdapterCommunicationCallback
*cb
, uint32_t iTimeoutMs
/* = 10000 */, bool bSkipChecks
/* = false */, bool bStartListening
/* = true */)
138 uint64_t iNow
= GetTimeMs();
139 uint64_t iTimeout
= iNow
+ iTimeoutMs
;
142 CLockObject
lock(m_mutex
);
146 CLibCEC::AddLog(CEC_LOG_ERROR
, "port is NULL");
152 CLibCEC::AddLog(CEC_LOG_ERROR
, "port is already open");
158 bool bConnected(false);
159 while (!bConnected
&& iNow
< iTimeout
)
161 if ((bConnected
= m_port
->Open(iTimeout
)) == false)
163 strError
.Format("error opening serial port '%s': %s", m_port
->GetName().c_str(), m_port
->GetError().c_str());
171 CLibCEC::AddLog(CEC_LOG_ERROR
, strError
);
175 CLibCEC::AddLog(CEC_LOG_DEBUG
, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
179 //clear any input bytes
181 ssize_t
iBytesRead(0);
182 bool bGotMsgStart(false), bGotMsgEnd(false);
183 while ((iBytesRead
= m_port
->Read(buff
, 1024, 100)) > 0 || (bGotMsgStart
&& !bGotMsgEnd
))
186 CLibCEC::AddLog(CEC_LOG_DEBUG
, "data received, clearing it");
187 // if something was received, wait for MSGEND
188 for (ssize_t iPtr
= 0; iPtr
< iBytesRead
; iPtr
++)
190 if (buff
[iPtr
] == MSGSTART
)
192 else if (buff
[iPtr
] == MSGEND
)
200 if (!bSkipChecks
&& !CheckAdapter())
202 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter failed to pass basic checks");
207 else if (bStartListening
)
211 CLibCEC::AddLog(CEC_LOG_DEBUG
, "communication thread started");
218 CLibCEC::AddLog(CEC_LOG_ERROR
, "could not create a communication thread");
231 void CUSBCECAdapterCommunication::Close(void)
236 void *CUSBCECAdapterCommunication::Process(void)
238 m_messageProcessor
= new CUSBCECAdapterProcessor(m_callback
);
239 m_messageProcessor
->CreateThread();
243 bool bCommandReceived(false);
244 CTimeout
pingTimeout(CEC_ADAPTER_PING_TIMEOUT
);
248 CLockObject
lock(m_mutex
);
250 bCommandReceived
= m_callback
&& Read(command
, 0) && m_bInitialised
;
253 /* push the next command to the callback method if there is one */
254 if (!IsStopped() && bCommandReceived
)
255 m_messageProcessor
->AddCommand(command
);
257 /* ping the adapter every 15 seconds */
258 if (pingTimeout
.TimeLeft() == 0)
260 pingTimeout
.Init(CEC_ADAPTER_PING_TIMEOUT
);
271 /* stop the message processor */
272 m_messageProcessor
->StopThread();
273 delete m_messageProcessor
;
274 m_messageProcessor
= NULL
;
276 /* notify all threads that are waiting on messages to be sent */
277 CCECAdapterMessage
*msg(NULL
);
278 while (m_outBuffer
.Pop(msg
))
279 msg
->event
.Broadcast();
281 /* set the ackmask to 0 before closing the connection */
282 SetAckMaskInternal(0, true);
284 if (m_iFirmwareVersion
>= 2)
285 SetControlledMode(false);
293 m_rcvCondition
.Broadcast();
297 cec_adapter_message_state
CUSBCECAdapterCommunication::Write(const cec_command
&data
, uint8_t iMaxTries
, uint8_t iLineTimeout
/* = 3 */, uint8_t iRetryLineTimeout
/* = 3 */)
299 cec_adapter_message_state
retVal(ADAPTER_MESSAGE_STATE_UNKNOWN
);
303 CCECAdapterMessage
*output
= new CCECAdapterMessage(data
);
305 /* set the number of retries */
306 if (data
.opcode
== CEC_OPCODE_NONE
) //TODO
307 output
->maxTries
= 1;
308 else if (data
.initiator
!= CECDEVICE_BROADCAST
)
309 output
->maxTries
= iMaxTries
;
311 output
->lineTimeout
= iLineTimeout
;
312 output
->retryTimeout
= iRetryLineTimeout
;
315 if (data
.destination
< 15)
317 CLockObject
lock(m_mutex
);
318 m_bWaitingForAck
[data
.destination
] = true;
322 while (bRetry
&& ++output
->tries
< output
->maxTries
)
324 bRetry
= (!Write(output
) || output
->NeedsRetry()) && output
->transmit_timeout
> 0;
326 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT
);
328 retVal
= output
->state
;
334 bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage
*data
)
336 data
->state
= ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT
;
337 m_outBuffer
.Push(data
);
338 data
->event
.Wait(5000);
340 if ((data
->expectControllerAck
&& data
->state
!= ADAPTER_MESSAGE_STATE_SENT_ACKED
) ||
341 (!data
->expectControllerAck
&& data
->state
!= ADAPTER_MESSAGE_STATE_SENT
))
343 CLibCEC::AddLog(CEC_LOG_DEBUG
, "command was not %s", data
->state
== ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED
? "acked" : "sent");
350 bool CUSBCECAdapterCommunication::Read(cec_command
&command
, uint32_t iTimeout
)
355 CCECAdapterMessage msg
;
356 if (Read(msg
, iTimeout
))
358 if (ParseMessage(msg
))
360 command
= m_currentframe
;
361 m_currentframe
.Clear();
368 bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage
&msg
, uint32_t iTimeout
)
370 CLockObject
lock(m_mutex
);
373 CCECAdapterMessage
*buf(NULL
);
375 if (!m_inBuffer
.Pop(buf
))
377 if (iTimeout
== 0 || !m_rcvCondition
.Wait(m_mutex
, m_bHasData
, iTimeout
))
380 m_bHasData
= !m_inBuffer
.IsEmpty();
385 msg
.packet
= buf
->packet
;
386 msg
.state
= ADAPTER_MESSAGE_STATE_INCOMING
;
393 CStdString
CUSBCECAdapterCommunication::GetError(void) const
396 strError
= m_port
->GetError();
400 bool CUSBCECAdapterCommunication::StartBootloader(void)
406 CLibCEC::AddLog(CEC_LOG_DEBUG
, "starting the bootloader");
408 CCECAdapterMessage params
;
409 return SendCommand(MSGCODE_START_BOOTLOADER
, params
, false);
412 bool CUSBCECAdapterCommunication::PingAdapter(void)
414 CLockObject
lock(m_mutex
);
415 CLibCEC::AddLog(CEC_LOG_DEBUG
, "sending ping");
417 CCECAdapterMessage params
;
418 return SendCommand(MSGCODE_PING
, params
);
421 bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage
&msg
)
424 bool bIsError(msg
.IsError());
429 CLockObject
adapterLock(m_mutex
);
430 switch(msg
.Message())
432 case MSGCODE_FRAME_START
:
434 m_currentframe
.Clear();
437 m_currentframe
.initiator
= msg
.Initiator();
438 m_currentframe
.destination
= msg
.Destination();
439 m_currentframe
.ack
= msg
.IsACK();
440 m_currentframe
.eom
= msg
.IsEOM();
442 if (m_currentframe
.ack
== 0x1)
444 m_lastDestination
= m_currentframe
.destination
;
445 if (m_currentframe
.destination
< 15)
447 if (!m_bWaitingForAck
[m_currentframe
.destination
])
448 m_processor
->HandlePoll(m_currentframe
.initiator
, m_currentframe
.destination
);
450 m_bWaitingForAck
[m_currentframe
.destination
] = false;
455 case MSGCODE_RECEIVE_FAILED
:
457 m_currentframe
.Clear();
458 if (m_lastDestination
!= CECDEVICE_UNKNOWN
)
459 bIsError
= m_processor
->HandleReceiveFailed(m_lastDestination
);
462 case MSGCODE_FRAME_DATA
:
466 m_currentframe
.PushBack(msg
[1]);
467 m_currentframe
.eom
= msg
.IsEOM();
475 CLibCEC::AddLog(bIsError
? CEC_LOG_WARNING
: CEC_LOG_DEBUG
, msg
.ToString());
479 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
481 uint16_t iReturn(m_iFirmwareVersion
);
483 if (iReturn
== CEC_FW_VERSION_UNKNOWN
)
485 CLockObject
lock(m_mutex
);
486 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting the firmware version");
487 cec_datapacket response
= GetSetting(MSGCODE_FIRMWARE_VERSION
, 2);
488 if (response
.size
== 2)
490 m_iFirmwareVersion
= (response
[0] << 8 | response
[1]);
491 iReturn
= m_iFirmwareVersion
;
492 CLibCEC::AddLog(CEC_LOG_DEBUG
, "firmware version %d", m_iFirmwareVersion
);
499 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout
)
503 if (m_iLineTimeout
!= iTimeout
)
505 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the line timeout to %d", iTimeout
);
506 CCECAdapterMessage params
;
507 params
.PushEscaped(iTimeout
);
508 bReturn
= SendCommand(MSGCODE_TRANSMIT_IDLETIME
, params
);
510 m_iLineTimeout
= iTimeout
;
516 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask
)
518 return SetAckMaskInternal(iMask
, IsRunning());
521 bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask
, bool bWriteDirectly
/* = false */)
523 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting ackmask to %2x", iMask
);
525 CCECAdapterMessage params
;
526 params
.PushEscaped(iMask
>> 8);
527 params
.PushEscaped((uint8_t)iMask
);
528 return SendCommand(MSGCODE_SET_ACK_MASK
, params
, true, false, bWriteDirectly
);
531 bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration
*configuration
)
533 if (m_iFirmwareVersion
< 2)
537 bReturn
&= SetSettingAutoEnabled(true);
538 bReturn
&= SetSettingDeviceType(CLibCEC::GetType(configuration
->logicalAddresses
.primary
));
539 bReturn
&= SetSettingDefaultLogicalAddress(configuration
->logicalAddresses
.primary
);
540 bReturn
&= SetSettingLogicalAddressMask(CLibCEC::GetMaskForType(configuration
->logicalAddresses
.primary
));
541 bReturn
&= SetSettingPhysicalAddress(configuration
->iPhysicalAddress
);
542 bReturn
&= SetSettingCECVersion(CEC_VERSION_1_3A
);
543 bReturn
&= SetSettingOSDName(configuration
->strDeviceName
);
545 bReturn
= WriteEEPROM();
549 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration
*configuration
)
551 configuration
->iFirmwareVersion
= m_iFirmwareVersion
;
552 if (m_iFirmwareVersion
< 2)
556 cec_device_type type
;
557 if (GetSettingDeviceType(type
))
559 CLibCEC::AddLog(CEC_LOG_DEBUG
, "using persisted device type setting %s", m_processor
->ToString(type
));
560 configuration
->deviceTypes
.Clear();
561 configuration
->deviceTypes
.Add(type
);
565 CLibCEC::AddLog(CEC_LOG_DEBUG
, "no persisted device type setting");
569 if (GetSettingPhysicalAddress(configuration
->iPhysicalAddress
))
571 CLibCEC::AddLog(CEC_LOG_DEBUG
, "using persisted physical address setting %4x", configuration
->iPhysicalAddress
);
575 CLibCEC::AddLog(CEC_LOG_DEBUG
, "no persisted physical address setting");
579 CStdString strDeviceName
;
580 if (GetSettingOSDName(strDeviceName
))
582 snprintf(configuration
->strDeviceName
, 13, "%s", strDeviceName
.c_str());
583 CLibCEC::AddLog(CEC_LOG_DEBUG
, "using persisted device name setting %s", configuration
->strDeviceName
);
587 CLibCEC::AddLog(CEC_LOG_DEBUG
, "no persisted device name setting");
591 // don't read the following settings:
592 // - auto enabled (always enabled)
593 // - default logical address (autodetected)
594 // - logical address mask (autodetected)
595 // - CEC version (1.3a)
597 // TODO to be added to the firmware:
598 // - base device (4 bits)
599 // - HDMI port number (4 bits)
600 // - TV vendor id (12 bits)
601 // - wake devices (8 bits)
602 // - standby devices (8 bits)
603 // - use TV menu language (1 bit)
604 // - activate source (1 bit)
605 // - power off screensaver (1 bit)
606 // - power off on standby (1 bit)
607 // - send inactive source (1 bit)
611 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled
)
613 CLockObject
lock(m_mutex
);
614 CLibCEC::AddLog(CEC_LOG_DEBUG
, "turning controlled mode %s", controlled
? "on" : "off");
616 CCECAdapterMessage params
;
617 params
.PushEscaped(controlled
? 1 : 0);
618 return SendCommand(MSGCODE_SET_CONTROLLED
, params
);
621 bool CUSBCECAdapterCommunication::SetSettingAutoEnabled(bool enabled
)
623 CLockObject
lock(m_mutex
);
624 CLibCEC::AddLog(CEC_LOG_DEBUG
, "turning autonomous mode %s", enabled
? "on" : "off");
626 CCECAdapterMessage params
;
627 params
.PushEscaped(enabled
? 1 : 0);
628 return SendCommand(MSGCODE_SET_AUTO_ENABLED
, params
);
631 bool CUSBCECAdapterCommunication::GetSettingAutoEnabled(bool &enabled
)
633 CLockObject
lock(m_mutex
);
634 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting autonomous mode setting");
636 cec_datapacket response
= GetSetting(MSGCODE_GET_AUTO_ENABLED
, 1);
637 if (response
.size
== 1)
639 enabled
= response
[0] == 1;
645 bool CUSBCECAdapterCommunication::SetSettingDeviceType(cec_device_type type
)
647 CLockObject
lock(m_mutex
);
648 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the device type to %1X", (uint8_t)type
);
650 CCECAdapterMessage params
;
651 params
.PushEscaped((uint8_t)type
);
652 return SendCommand(MSGCODE_SET_DEVICE_TYPE
, params
);
655 bool CUSBCECAdapterCommunication::GetSettingDeviceType(cec_device_type
&value
)
657 CLockObject
lock(m_mutex
);
658 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting device type setting");
660 cec_datapacket response
= GetSetting(MSGCODE_GET_DEVICE_TYPE
, 1);
661 if (response
.size
== 1)
663 value
= (cec_device_type
)response
[0];
669 bool CUSBCECAdapterCommunication::SetSettingDefaultLogicalAddress(cec_logical_address address
)
671 CLockObject
lock(m_mutex
);
672 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the default logical address to %1X", address
);
674 CCECAdapterMessage params
;
675 params
.PushEscaped((uint8_t)address
);
676 return SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS
, params
);
679 bool CUSBCECAdapterCommunication::GetSettingDefaultLogicalAddress(cec_logical_address
&address
)
681 CLockObject
lock(m_mutex
);
682 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting default logical address setting");
684 cec_datapacket response
= GetSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS
, 1);
685 if (response
.size
== 1)
687 address
= (cec_logical_address
)response
[0];
693 bool CUSBCECAdapterCommunication::SetSettingLogicalAddressMask(uint16_t iMask
)
695 CLockObject
lock(m_mutex
);
696 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the logical address mask to %2X", iMask
);
698 CCECAdapterMessage params
;
699 params
.PushEscaped(iMask
>> 8);
700 params
.PushEscaped((uint8_t)iMask
);
701 return SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK
, params
);
704 bool CUSBCECAdapterCommunication::GetSettingLogicalAddressMask(uint16_t &iMask
)
706 CLockObject
lock(m_mutex
);
707 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting logical address mask setting");
709 cec_datapacket response
= GetSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK
, 2);
710 if (response
.size
== 2)
712 iMask
= ((uint16_t)response
[0] << 8) | ((uint16_t)response
[1]);
718 bool CUSBCECAdapterCommunication::SetSettingPhysicalAddress(uint16_t iPhysicalAddress
)
720 CLockObject
lock(m_mutex
);
721 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the physical address to %04X", iPhysicalAddress
);
723 CCECAdapterMessage params
;
724 params
.PushEscaped(iPhysicalAddress
>> 8);
725 params
.PushEscaped((uint8_t)iPhysicalAddress
);
726 return SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS
, params
);
729 bool CUSBCECAdapterCommunication::GetSettingPhysicalAddress(uint16_t &iPhysicalAddress
)
731 CLockObject
lock(m_mutex
);
732 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting physical address setting");
734 cec_datapacket response
= GetSetting(MSGCODE_GET_PHYSICAL_ADDRESS
, 2);
735 if (response
.size
== 2)
737 iPhysicalAddress
= ((uint16_t)response
[0] << 8) | ((uint16_t)response
[1]);
743 bool CUSBCECAdapterCommunication::SetSettingCECVersion(cec_version version
)
745 CLockObject
lock(m_mutex
);
746 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the CEC version to %s", CLibCEC::GetInstance()->ToString(version
));
748 CCECAdapterMessage params
;
749 params
.PushEscaped((uint8_t)version
);
750 return SendCommand(MSGCODE_SET_HDMI_VERSION
, params
);
753 bool CUSBCECAdapterCommunication::GetSettingCECVersion(cec_version
&version
)
755 CLockObject
lock(m_mutex
);
756 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting CEC version setting");
758 cec_datapacket response
= GetSetting(MSGCODE_GET_HDMI_VERSION
, 1);
759 if (response
.size
== 1)
761 version
= (cec_version
)response
[0];
767 bool CUSBCECAdapterCommunication::SetSettingOSDName(const char *strOSDName
)
769 CLockObject
lock(m_mutex
);
770 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting the OSD name to %s", strOSDName
);
772 CCECAdapterMessage params
;
773 for (size_t iPtr
= 0; iPtr
< strlen(strOSDName
); iPtr
++)
774 params
.PushEscaped(strOSDName
[iPtr
]);
775 return SendCommand(MSGCODE_SET_OSD_NAME
, params
);
778 bool CUSBCECAdapterCommunication::GetSettingOSDName(CStdString
&strOSDName
)
780 CLockObject
lock(m_mutex
);
781 CLibCEC::AddLog(CEC_LOG_DEBUG
, "requesting OSD name setting");
783 cec_datapacket response
= GetSetting(MSGCODE_GET_OSD_NAME
, 13);
784 if (response
.size
== 0)
788 for (uint8_t iPtr
= 0; iPtr
< response
.size
&& iPtr
< 13; iPtr
++)
789 buf
[iPtr
] = (char)response
[iPtr
];
790 buf
[response
.size
] = 0;
792 strOSDName
.Format("%s", buf
);
796 bool CUSBCECAdapterCommunication::WriteEEPROM(void)
798 CLockObject
lock(m_mutex
);
799 CLibCEC::AddLog(CEC_LOG_DEBUG
, "writing settings in the EEPROM");
801 CCECAdapterMessage params
;
802 return SendCommand(MSGCODE_WRITE_EEPROM
, params
);
805 bool CUSBCECAdapterCommunication::IsOpen(void)
807 return !IsStopped() && m_port
->IsOpen() && IsRunning();
810 bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage
&message
)
813 bool bTransmitSucceeded(false);
814 uint8_t iPacketsLeft(message
.isTransmission
? message
.Size() / 4 : 1);
816 int64_t iNow
= GetTimeMs();
817 int64_t iTargetTime
= iNow
+ (message
.transmit_timeout
<= 5 ? CEC_DEFAULT_TRANSMIT_WAIT
: message
.transmit_timeout
);
819 while (!bTransmitSucceeded
&& !bError
&& iNow
< iTargetTime
)
822 CCECAdapterMessage msg
;
829 if (msg
.Message() == MSGCODE_FRAME_START
&& msg
.IsACK())
831 if (msg
.Initiator() < 15 && m_bWaitingForAck
[msg
.Initiator()])
832 m_bWaitingForAck
[msg
.Initiator()] = false;
833 else if (msg
.Initiator() < 15)
835 m_processor
->HandlePoll(msg
.Initiator(), msg
.Destination());
836 m_lastDestination
= msg
.Initiator();
842 if (msg
.Message() == MSGCODE_RECEIVE_FAILED
&&
843 m_lastDestination
!= CECDEVICE_UNKNOWN
&&
844 m_processor
->HandleReceiveFailed(m_lastDestination
))
850 bError
= msg
.IsError();
853 message
.reply
= msg
.Message();
854 CLibCEC::AddLog(CEC_LOG_DEBUG
, msg
.ToString());
858 switch(msg
.Message())
860 case MSGCODE_COMMAND_ACCEPTED
:
861 if (iPacketsLeft
> 0)
863 if (!message
.isTransmission
&& iPacketsLeft
== 0)
864 bTransmitSucceeded
= true;
865 CLibCEC::AddLog(CEC_LOG_DEBUG
, "%s - waiting for %d more", msg
.ToString().c_str(), iPacketsLeft
);
867 case MSGCODE_TRANSMIT_SUCCEEDED
:
868 CLibCEC::AddLog(CEC_LOG_DEBUG
, msg
.ToString());
869 bTransmitSucceeded
= (iPacketsLeft
== 0);
870 bError
= !bTransmitSucceeded
;
871 message
.reply
= MSGCODE_TRANSMIT_SUCCEEDED
;
874 // ignore other data while waiting
882 message
.state
= bTransmitSucceeded
&& !bError
?
883 ADAPTER_MESSAGE_STATE_SENT_ACKED
:
884 ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED
;
886 return bTransmitSucceeded
&& !bError
;
889 void CUSBCECAdapterCommunication::AddData(uint8_t *data
, size_t iLen
)
891 CLockObject
lock(m_mutex
);
892 for (size_t iPtr
= 0; iPtr
< iLen
; iPtr
++)
896 if (data
[iPtr
] == MSGSTART
)
899 else if (data
[iPtr
] == MSGSTART
) //we found a msgstart before msgend, this is not right, remove
901 if (m_currentAdapterMessage
.Size() > 0)
902 CLibCEC::AddLog(CEC_LOG_WARNING
, "received MSGSTART before MSGEND, removing previous buffer contents");
903 m_currentAdapterMessage
.Clear();
906 else if (data
[iPtr
] == MSGEND
)
908 CCECAdapterMessage
*newMessage
= new CCECAdapterMessage
;
909 newMessage
->packet
= m_currentAdapterMessage
.packet
;
910 m_inBuffer
.Push(newMessage
);
911 m_currentAdapterMessage
.Clear();
913 m_bNextIsEscaped
= false;
915 m_rcvCondition
.Broadcast();
917 else if (m_bNextIsEscaped
)
919 m_currentAdapterMessage
.PushBack(data
[iPtr
] + (uint8_t)ESCOFFSET
);
920 m_bNextIsEscaped
= false;
922 else if (data
[iPtr
] == MSGESC
)
924 m_bNextIsEscaped
= true;
928 m_currentAdapterMessage
.PushBack(data
[iPtr
]);
933 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout
, size_t iSize
/* = 256 */)
942 CLockObject
lock(m_mutex
);
943 iBytesRead
= m_port
->Read(buff
, sizeof(uint8_t) * iSize
, iTimeout
);
944 if (iBytesRead
< 0 || iBytesRead
> 256)
946 CLibCEC::AddLog(CEC_LOG_ERROR
, "error reading from serial port: %s", m_port
->GetError().c_str());
950 else if (iBytesRead
> 0)
952 AddData(buff
, iBytesRead
);
955 return iBytesRead
> 0;
958 void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage
*msg
)
960 CLockObject
adapterLock(m_mutex
);
961 if (!m_port
->IsOpen())
963 CLibCEC::AddLog(CEC_LOG_ERROR
, "error writing to serial port: the connection is closed");
964 msg
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
968 if (msg
->isTransmission
&& (msg
->Size() < 2 || msg
->At(1) != MSGCODE_TRANSMIT_IDLETIME
))
971 SetLineTimeout(msg
->lineTimeout
);
973 SetLineTimeout(msg
->retryTimeout
);
976 if (m_port
->Write(msg
->packet
.data
, msg
->Size()) != (ssize_t
) msg
->Size())
978 CLibCEC::AddLog(CEC_LOG_ERROR
, "error writing to serial port: %s", m_port
->GetError().c_str());
979 msg
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
983 CLibCEC::AddLog(CEC_LOG_DEBUG
, "command sent");
984 msg
->state
= ADAPTER_MESSAGE_STATE_SENT
;
986 if (msg
->expectControllerAck
)
988 if (!WaitForAck(*msg
))
989 CLibCEC::AddLog(CEC_LOG_DEBUG
, "did not receive ack");
995 void CUSBCECAdapterCommunication::WriteNextCommand(void)
997 CCECAdapterMessage
*msg(NULL
);
998 if (m_outBuffer
.Pop(msg
))
999 SendMessageToAdapter(msg
);
1002 CStdString
CUSBCECAdapterCommunication::GetPortName(void)
1005 strName
= m_port
->GetName();
1009 bool CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode
, CCECAdapterMessage
¶ms
, bool bExpectAck
/* = true */, bool bIsTransmission
/* = false */, bool bSendDirectly
/* = true */, bool bIsRetry
/* = false */)
1011 CLockObject
lock(m_mutex
);
1013 CCECAdapterMessage
*output
= new CCECAdapterMessage
;
1015 output
->PushBack(MSGSTART
);
1016 output
->PushEscaped((uint8_t)msgCode
);
1017 output
->Append(params
);
1018 output
->PushBack(MSGEND
);
1019 output
->isTransmission
= bIsTransmission
;
1020 output
->expectControllerAck
= bExpectAck
;
1023 SendMessageToAdapter(output
);
1027 bool bWriteOk
= output
->state
== (output
->expectControllerAck
? ADAPTER_MESSAGE_STATE_SENT_ACKED
: ADAPTER_MESSAGE_STATE_SENT
);
1028 cec_adapter_messagecode reply
= output
->reply
;
1033 CLibCEC::AddLog(CEC_LOG_ERROR
, "'%s' failed", CCECAdapterMessage::ToString(msgCode
));
1035 if (!bIsRetry
&& reply
== MSGCODE_COMMAND_REJECTED
&& msgCode
!= MSGCODE_SET_CONTROLLED
)
1037 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting controlled mode and retrying");
1038 if (SetControlledMode(true))
1039 return SendCommand(msgCode
, params
, bExpectAck
, bIsTransmission
, bSendDirectly
, true);
1047 cec_datapacket
CUSBCECAdapterCommunication::GetSetting(cec_adapter_messagecode msgCode
, uint8_t iResponseLength
)
1049 cec_datapacket retVal
;
1052 CCECAdapterMessage params
;
1053 if (!SendCommand(msgCode
, params
, false))
1055 CLibCEC::AddLog(CEC_LOG_ERROR
, "%s failed", CCECAdapterMessage::ToString(msgCode
));
1059 Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
1060 ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT
, iResponseLength
+ 3 /* start + msgcode + iResponseLength + end */);
1061 CCECAdapterMessage input
;
1064 if (input
.Message() != msgCode
)
1065 CLibCEC::AddLog(CEC_LOG_ERROR
, "invalid response to %s received (%s)", CCECAdapterMessage::ToString(msgCode
), CCECAdapterMessage::ToString(input
.Message()));
1068 for (uint8_t iPtr
= 1; iPtr
< input
.Size(); iPtr
++)
1069 retVal
.PushBack(input
[iPtr
]);
1074 CLibCEC::AddLog(CEC_LOG_ERROR
, "no response to %s received", CCECAdapterMessage::ToString(msgCode
));