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 "USBCECAdapterCommands.h"
35 #include "USBCECAdapterMessageQueue.h"
36 #include "../platform/sockets/serialport.h"
37 #include "../platform/util/timeutils.h"
38 #include "../LibCEC.h"
39 #include "../CECProcessor.h"
43 using namespace PLATFORM
;
45 #define CEC_ADAPTER_PING_TIMEOUT 15000
47 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback
*callback
, const char *strPort
, uint16_t iBaudRate
/* = 38400 */) :
48 IAdapterCommunication(callback
),
51 m_lastPollDestination(CECDEVICE_UNKNOWN
),
52 m_bInitialised(false),
55 m_adapterMessageQueue(NULL
)
57 for (unsigned int iPtr
= 0; iPtr
< 15; iPtr
++)
58 m_bWaitingForAck
[iPtr
] = false;
59 m_port
= new CSerialPort(strPort
, iBaudRate
);
62 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
66 delete m_adapterMessageQueue
;
70 bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs
/* = 10000 */, bool bSkipChecks
/* = false */, bool bStartListening
/* = true */)
72 bool bConnectionOpened(false);
74 CLockObject
lock(m_mutex
);
76 /* we need the port settings here */
79 CLibCEC::AddLog(CEC_LOG_ERROR
, "port is NULL");
80 return bConnectionOpened
;
83 /* return true when the port is already open */
86 CLibCEC::AddLog(CEC_LOG_WARNING
, "port is already open");
90 /* adapter commands */
92 m_commands
= new CUSBCECAdapterCommands(this);
94 if (!m_adapterMessageQueue
)
95 m_adapterMessageQueue
= new CCECAdapterMessageQueue(this);
97 /* try to open the connection */
99 CTimeout
timeout(iTimeoutMs
);
100 while (!bConnectionOpened
&& timeout
.TimeLeft() > 0)
102 if ((bConnectionOpened
= m_port
->Open(timeout
.TimeLeft())) == false)
104 strError
.Format("error opening serial port '%s': %s", m_port
->GetName().c_str(), m_port
->GetError().c_str());
107 /* and retry every 250ms until the timeout passed */
110 /* return false when we couldn't connect */
111 if (!bConnectionOpened
)
113 CLibCEC::AddLog(CEC_LOG_ERROR
, strError
);
117 CLibCEC::AddLog(CEC_LOG_DEBUG
, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
123 bConnectionOpened
= false;
124 CLibCEC::AddLog(CEC_LOG_ERROR
, "could not create a communication thread");
126 else if (!bSkipChecks
&& !CheckAdapter())
128 bConnectionOpened
= false;
129 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter failed to pass basic checks");
131 else if (bStartListening
)
133 /* start a ping thread, that will ping the adapter every 15 seconds
134 if it doesn't receive any ping for 30 seconds, it'll switch to auto mode */
135 m_pingThread
= new CAdapterPingThread(this, CEC_ADAPTER_PING_TIMEOUT
);
136 if (m_pingThread
->CreateThread())
138 bConnectionOpened
= true;
142 bConnectionOpened
= false;
143 CLibCEC::AddLog(CEC_LOG_ERROR
, "could not create a ping thread");
147 if (!bConnectionOpened
|| !bStartListening
)
150 return bConnectionOpened
;
153 void CUSBCECAdapterCommunication::Close(void)
155 /* stop the reader thread */
158 CLockObject
lock(m_mutex
);
160 /* set the ackmask to 0 before closing the connection */
161 if (IsRunning() && m_port
->IsOpen() && m_port
->GetErrorNumber() == 0)
163 CLibCEC::AddLog(CEC_LOG_DEBUG
, "%s - closing the connection", __FUNCTION__
);
165 if (m_commands
->GetFirmwareVersion() >= 2)
166 SetControlledMode(false);
169 /* stop and delete the ping thread */
171 m_pingThread
->StopThread(0);
175 /* close and delete the com port connection */
179 libcec_parameter param
;
180 CLibCEC::Alert(CEC_ALERT_CONNECTION_LOST
, param
);
183 cec_adapter_message_state
CUSBCECAdapterCommunication::Write(const cec_command
&data
, bool &bRetry
, uint8_t iLineTimeout
)
185 cec_adapter_message_state
retVal(ADAPTER_MESSAGE_STATE_UNKNOWN
);
189 CCECAdapterMessage
*output
= new CCECAdapterMessage(data
, iLineTimeout
);
191 /* mark as waiting for an ack from the destination */
192 MarkAsWaiting(data
.destination
);
194 /* send the message */
195 bRetry
= (!m_adapterMessageQueue
->Write(output
) || output
->NeedsRetry()) && output
->transmit_timeout
> 0;
196 if (output
->state
== ADAPTER_MESSAGE_STATE_ERROR
)
199 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT
);
200 retVal
= output
->state
;
206 void *CUSBCECAdapterCommunication::Process(void)
208 CCECAdapterMessage msg
;
209 CLibCEC::AddLog(CEC_LOG_DEBUG
, "communication thread started");
213 /* read from the serial port */
214 if (!ReadFromDevice(50, 5))
217 /* TODO sleep 5 ms so other threads can get a lock */
221 m_adapterMessageQueue
->Clear();
222 CLibCEC::AddLog(CEC_LOG_DEBUG
, "communication thread ended");
226 bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage
&msg
)
228 bool bIsError(msg
.IsError());
229 cec_adapter_messagecode
messageCode(msg
.Message());
230 CLockObject
lock(m_mutex
);
232 if (messageCode
== MSGCODE_FRAME_START
&& msg
.IsACK())
234 m_lastPollDestination
= msg
.Destination();
235 if (msg
.Destination() < CECDEVICE_BROADCAST
)
237 if (!m_bWaitingForAck
[msg
.Destination()] && !msg
.IsEOM())
240 m_callback
->HandlePoll(msg
.Initiator(), msg
.Destination());
243 m_bWaitingForAck
[msg
.Destination()] = false;
246 else if (messageCode
== MSGCODE_RECEIVE_FAILED
)
248 /* hack to suppress warnings when an LG is polling */
249 if (m_lastPollDestination
!= CECDEVICE_UNKNOWN
)
250 bIsError
= m_callback
->HandleReceiveFailed(m_lastPollDestination
);
256 void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest
)
258 /* mark as waiting for an ack from the destination */
259 if (dest
< CECDEVICE_BROADCAST
)
261 CLockObject
lock(m_mutex
);
262 m_bWaitingForAck
[dest
] = true;
266 void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout
/* = 1000 */)
268 CTimeout
timeout(iTimeout
);
270 ssize_t
iBytesRead(0);
271 bool bGotMsgEnd(true);
273 while (timeout
.TimeLeft() > 0 && ((iBytesRead
= m_port
->Read(buff
, 1024, 5)) > 0 || !bGotMsgEnd
))
276 /* if something was received, wait for MSGEND */
277 for (ssize_t iPtr
= 0; iPtr
< iBytesRead
; iPtr
++)
278 bGotMsgEnd
= buff
[iPtr
] == MSGEND
;
282 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout
)
285 bool bChanged(false);
287 /* only send the command if the timeout changed */
289 CLockObject
lock(m_mutex
);
290 bChanged
= (m_iLineTimeout
!= iTimeout
);
291 m_iLineTimeout
= iTimeout
;
295 bReturn
= m_commands
->SetLineTimeout(iTimeout
);
300 bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage
*message
)
302 CLockObject
adapterLock(m_mutex
);
303 if (!m_port
->IsOpen())
305 CLibCEC::AddLog(CEC_LOG_DEBUG
, "error writing command '%s' to serial port '%s': the connection is closed", CCECAdapterMessage::ToString(message
->Message()), m_port
->GetName().c_str());
306 message
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
310 /* write the message */
311 if (m_port
->Write(message
->packet
.data
, message
->Size()) != (ssize_t
) message
->Size())
313 CLibCEC::AddLog(CEC_LOG_DEBUG
, "error writing command '%s' to serial port '%s': %s", CCECAdapterMessage::ToString(message
->Message()), m_port
->GetName().c_str(), m_port
->GetError().c_str());
314 message
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
318 CLibCEC::AddLog(CEC_LOG_DEBUG
, "command '%s' sent", message
->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message
->Message()));
319 message
->state
= ADAPTER_MESSAGE_STATE_SENT
;
323 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout
, size_t iSize
/* = 256 */)
325 ssize_t
iBytesRead(0);
330 /* read from the serial port */
332 CLockObject
lock(m_mutex
);
333 if (!m_port
|| !m_port
->IsOpen())
335 iBytesRead
= m_port
->Read(buff
, sizeof(uint8_t) * iSize
, iTimeout
);
338 if (iBytesRead
< 0 || iBytesRead
> 256)
340 CLibCEC::AddLog(CEC_LOG_ERROR
, "error reading from serial port: %s", m_port
->GetError().c_str());
344 else if (iBytesRead
> 0)
346 /* add the data to the current frame */
347 m_adapterMessageQueue
->AddData(buff
, iBytesRead
);
353 CCECAdapterMessage
*CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode
, CCECAdapterMessage
¶ms
, bool bIsRetry
/* = false */)
355 if (!m_port
|| !m_port
->IsOpen() ||
356 !m_adapterMessageQueue
)
359 /* create the adapter message for this command */
360 CCECAdapterMessage
*output
= new CCECAdapterMessage
;
361 output
->PushBack(MSGSTART
);
362 output
->PushEscaped((uint8_t)msgCode
);
363 output
->Append(params
);
364 output
->PushBack(MSGEND
);
366 /* write the command */
367 if (!m_adapterMessageQueue
->Write(output
))
369 if (output
->state
== ADAPTER_MESSAGE_STATE_ERROR
)
375 if (!bIsRetry
&& output
->Reply() == MSGCODE_COMMAND_REJECTED
&& msgCode
!= MSGCODE_SET_CONTROLLED
)
377 /* if the controller reported that the command was rejected, and we didn't send the command
378 to set controlled mode, then the controller probably switched to auto mode. set controlled
380 CLibCEC::AddLog(CEC_LOG_DEBUG
, "setting controlled mode and retrying");
382 if (SetControlledMode(true))
383 return SendCommand(msgCode
, params
, true);
390 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs
/* = 10000 */)
393 CTimeout
timeout(iTimeoutMs
> 0 ? iTimeoutMs
: CEC_DEFAULT_TRANSMIT_WAIT
);
395 /* try to ping the adapter */
397 unsigned iPingTry(0);
398 while (timeout
.TimeLeft() > 0 && (bPinged
= PingAdapter()) == false)
400 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry
);
404 /* try to read the firmware version */
405 if (bPinged
&& timeout
.TimeLeft() > 0 && m_commands
->RequestFirmwareVersion() >= 2)
407 /* try to set controlled mode for v2+ firmwares */
408 unsigned iControlledTry(0);
409 bool bControlled(false);
410 while (timeout
.TimeLeft() > 0 && (bControlled
= SetControlledMode(true)) == false)
412 CLibCEC::AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry
);
415 bReturn
= bControlled
;
420 SetInitialised(bReturn
);
424 bool CUSBCECAdapterCommunication::IsOpen(void)
426 /* thread is not being stopped, the port is open and the thread is running */
427 return !IsStopped() && m_port
->IsOpen() && IsRunning();
430 CStdString
CUSBCECAdapterCommunication::GetError(void) const
432 return m_port
->GetError();
435 void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo
/* = true */)
437 CLockObject
lock(m_mutex
);
438 m_bInitialised
= bSetTo
;
441 bool CUSBCECAdapterCommunication::IsInitialised(void)
443 CLockObject
lock(m_mutex
);
444 return m_bInitialised
;
447 bool CUSBCECAdapterCommunication::StartBootloader(void)
449 return m_port
->IsOpen() ? m_commands
->StartBootloader() : false;
452 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask
)
454 return m_port
->IsOpen() ? m_commands
->SetAckMask(iMask
) : false;
457 bool CUSBCECAdapterCommunication::PingAdapter(void)
459 return m_port
->IsOpen() ? m_commands
->PingAdapter() : false;
462 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
464 return m_commands
->GetFirmwareVersion();
467 bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration
*configuration
)
469 return m_port
->IsOpen() ? m_commands
->PersistConfiguration(configuration
) : false;
472 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration
*configuration
)
474 return m_port
->IsOpen() ? m_commands
->GetConfiguration(configuration
) : false;
477 CStdString
CUSBCECAdapterCommunication::GetPortName(void)
479 return m_port
->GetName();
482 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled
)
484 return m_port
->IsOpen() ? m_commands
->SetControlledMode(controlled
) : false;
487 void *CAdapterPingThread::Process(void)
491 if (m_timeout
.TimeLeft() == 0)
493 /* reinit the timeout */
494 m_timeout
.Init(CEC_ADAPTER_PING_TIMEOUT
);
496 /* send a ping to the adapter */
498 int iFailedCounter(0);
499 while (!bPinged
&& iFailedCounter
< 3)
501 if (!m_com
->PingAdapter())
503 /* sleep 1 second and retry */
513 if (iFailedCounter
== 3)
515 /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
516 CLibCEC::AddLog(CEC_LOG_ERROR
, "failed to ping the adapter 3 times in a row. closing the connection.");
517 m_com
->StopThread(false);