3 * This file is part of the libCEC(R) library.
5 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
6 * libCEC(R) is an original work, containing original code.
8 * libCEC(R) is a trademark of Pulse-Eight Limited.
10 * This program is dual-licensed; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 * Alternatively, you can license this library under a commercial license,
26 * please contact Pulse-Eight Licensing for more information.
28 * For more information contact:
29 * Pulse-Eight Licensing <license@pulse-eight.com>
30 * http://www.pulse-eight.com/
31 * http://www.pulse-eight.net/
34 #include "lib/platform/threads/threads.h"
35 #include "lib/adapter/AdapterCommunication.h"
36 #include "USBCECAdapterMessage.h"
46 class CAdapterPingThread
;
47 class CAdapterEepromWriteThread
;
48 class CUSBCECAdapterCommands
;
49 class CCECAdapterMessageQueue
;
50 class CCECAdapterMessage
;
52 class CUSBCECAdapterCommunication
: public IAdapterCommunication
, public PLATFORM::CThread
54 friend class CUSBCECAdapterCommands
;
55 friend class CCECAdapterMessageQueue
;
56 friend class CAdapterEepromWriteThread
;
60 * @brief Create a new USB-CEC communication handler.
61 * @param callback The callback to use for incoming CEC commands.
62 * @param strPort The name of the com port to use.
63 * @param iBaudRate The baudrate to use on the com port connection.
65 CUSBCECAdapterCommunication(IAdapterCommunicationCallback
*callback
, const char *strPort
, uint16_t iBaudRate
= CEC_SERIAL_DEFAULT_BAUDRATE
);
66 virtual ~CUSBCECAdapterCommunication(void);
68 /** @name IAdapterCommunication implementation */
70 bool Open(uint32_t iTimeoutMs
= CEC_DEFAULT_CONNECT_TIMEOUT
, bool bSkipChecks
= false, bool bStartListening
= true);
73 std::string
GetError(void) const;
74 cec_adapter_message_state
Write(const cec_command
&data
, bool &bRetry
, uint8_t iLineTimeout
, bool bIsReply
);
76 bool StartBootloader(void);
77 bool SetLogicalAddresses(const cec_logical_addresses
&addresses
);
78 cec_logical_addresses
GetLogicalAddresses(void);
79 bool PingAdapter(void);
80 uint16_t GetFirmwareVersion(void);
81 uint32_t GetFirmwareBuildDate(void);
82 bool IsRunningLatestFirmware(void);
83 bool PersistConfiguration(const libcec_configuration
&configuration
);
84 bool GetConfiguration(libcec_configuration
&configuration
);
85 std::string
GetPortName(void);
86 uint16_t GetPhysicalAddress(void);
87 bool SetControlledMode(bool controlled
);
88 cec_vendor_id
GetVendorId(void) { return CEC_VENDOR_UNKNOWN
; }
89 bool SupportsSourceLogicalAddress(const cec_logical_address
UNUSED(address
)) { return true; }
90 cec_adapter_type
GetAdapterType(void);
91 uint16_t GetAdapterVendorId(void) const;
92 uint16_t GetAdapterProductId(void) const;
95 bool ProvidesExtendedResponse(void);
101 * @brief Clear all input bytes.
102 * @param iTimeout Timeout when anything was received.
104 void ClearInputBytes(uint32_t iTimeout
= CEC_CLEAR_INPUT_DEFAULT_WAIT
);
107 * @brief Change the current CEC line timeout.
108 * @param iTimeout The new timeout.
109 * @return True when acked by the controller, false otherwise.
111 bool SetLineTimeout(uint8_t iTimeout
);
114 * @brief Send a command to the controller and wait for an ack.
115 * @param msgCode The command to send.
116 * @param params The parameters to the command.
117 * @param bIsRetry True when this command is being retried, false otherwise.
118 * @return The message. Delete when done with it.
120 CCECAdapterMessage
*SendCommand(cec_adapter_messagecode msgCode
, CCECAdapterMessage
¶ms
, bool bIsRetry
= false);
123 * @brief Change the "initialised" status.
124 * @param bSetTo The new value.
126 void SetInitialised(bool bSetTo
= true);
129 * @return True when initialised, false otherwise.
131 bool IsInitialised(void);
134 * @brief Pings the adapter, checks the firmware version and sets controlled mode.
135 * @param iTimeoutMs The timeout after which this fails if no proper data was received.
136 * @return True when the checks passed, false otherwise.
138 bool CheckAdapter(uint32_t iTimeoutMs
= CEC_DEFAULT_CONNECT_TIMEOUT
);
141 * @brief Handle a poll message inside the adapter message (checks if one is present).
142 * @param msg The adapter message to parse.
143 * @return True when the message resulted in a CEC error, false otherwise.
145 bool HandlePoll(const CCECAdapterMessage
&msg
);
148 * @brief Read data from the device.
149 * @param iTimeout The read timeout to use.
150 * @param iSize The maximum read size.
151 * @return True when something was read, false otherwise.
153 bool ReadFromDevice(uint32_t iTimeout
, size_t iSize
= 256);
156 * @brief Writes a message to the serial port.
157 * @param message The message to write.
158 * @return True when written, false otherwise.
160 bool WriteToDevice(CCECAdapterMessage
*message
);
163 * @brief Called before sending a CEC command over the line, so we know we're expecting an ack.
164 * @param dest The destination of the CEC command.
166 void MarkAsWaiting(const cec_logical_address dest
);
169 * @brief Clear and reset the message queue.
171 void ResetMessageQueue(void);
173 PLATFORM::ISocket
* m_port
; /**< the com port connection */
174 PLATFORM::CMutex m_mutex
; /**< mutex for changes in this class */
175 uint8_t m_iLineTimeout
; /**< the current line timeout on the CEC line */
176 cec_logical_address m_lastPollDestination
; /**< the destination of the last poll message that was received */
177 bool m_bInitialised
; /**< true when the connection is initialised, false otherwise */
178 bool m_bWaitingForAck
[15]; /**< array in which we store from which devices we're expecting acks */
179 CAdapterPingThread
* m_pingThread
; /**< ping thread, that pings the adapter every 15 seconds */
180 CAdapterEepromWriteThread
* m_eepromWriteThread
; /**< eeprom writes are done async */
181 CUSBCECAdapterCommands
* m_commands
; /**< commands that can be sent to the adapter */
182 CCECAdapterMessageQueue
* m_adapterMessageQueue
; /**< the incoming and outgoing message queue */
183 cec_logical_addresses m_logicalAddresses
; /**< the logical address list that this instance is using */
186 class CAdapterEepromWriteThread
: public PLATFORM::CThread
189 CAdapterEepromWriteThread(CUSBCECAdapterCommunication
*com
) :
192 m_iLastEepromWrite(0),
193 m_iScheduleEepromWrite(0) {}
194 virtual ~CAdapterEepromWriteThread(void) {}
200 CUSBCECAdapterCommunication
*m_com
;
202 PLATFORM::CCondition
<bool> m_condition
;
203 PLATFORM::CMutex m_mutex
;
204 int64_t m_iLastEepromWrite
; /**< last time that this instance did an eeprom write */
205 int64_t m_iScheduleEepromWrite
; /**< in case there were more than 2 changes within 30 seconds, do another write at this time */
208 class CAdapterPingThread
: public PLATFORM::CThread
211 CAdapterPingThread(CUSBCECAdapterCommunication
*com
, uint32_t iTimeout
) :
213 m_timeout(iTimeout
){}
214 virtual ~CAdapterPingThread(void) {}
218 CUSBCECAdapterCommunication
*m_com
;
219 PLATFORM::CTimeout m_timeout
;