src/testclient/main.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011 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 <cec.h>
  34
  35 #include <cstdio>
  36 #include <fcntl.h>
  37 #include <iostream>
  38 #include <fstream>
  39 #include <string>
  40 #include <sstream>
  41 #include "../lib/platform/threads.h"
  42 #include "../lib/util/StdString.h"
  43
  44 using namespace CEC;
  45 using namespace std;
  46
  47 #define CEC_TEST_CLIENT_VERSION 8
  48
  49 #include <cecloader.h>
  50
  51 int        g_cecLogLevel = CEC_LOG_ALL;
  52 int        g_iLogicalAddress = CECDEVICE_PLAYBACKDEVICE1;
  53 ofstream   g_logOutput;
  54 bool       g_bShortLog = false;
  55 CStdString g_strPort;
  56
  57 inline bool HexStrToInt(const std::string& data, uint8_t& value)
  58 {
  59   int iTmp(0);
  60   if (sscanf(data.c_str(), "%x", &iTmp) == 1)
  61   {
  62     if (iTmp > 256)
  63       value = 255;
  64           else if (iTmp < 0)
  65       value = 0;
  66     else
  67       value = (uint8_t) iTmp;
  68
  69     return true;
  70   }
  71
  72   return false;
  73 }
  74
  75 //get the first word (separated by whitespace) from string data and place that in word
  76 //then remove that word from string data
  77 bool GetWord(string& data, string& word)
  78 {
  79   stringstream datastream(data);
  80   string end;
  81
  82   datastream >> word;
  83   if (datastream.fail())
  84   {
  85     data.clear();
  86     return false;
  87   }
  88
  89   size_t pos = data.find(word) + word.length();
  90
  91   if (pos >= data.length())
  92   {
  93     data.clear();
  94     return true;
  95   }
  96
  97   data = data.substr(pos);
  98
  99   datastream.clear();
 100   datastream.str(data);
 101
 102   datastream >> end;
 103   if (datastream.fail())
 104     data.clear();
 105
 106   return true;
 107 }
 108
 109 void flush_log(ICECAdapter *cecParser)
 110 {
 111   cec_log_message message;
 112   while (cecParser && cecParser->GetNextLogMessage(&message))
 113   {
 114     if ((message.level & g_cecLogLevel) == message.level)
 115     {
 116       CStdString strLevel;
 117       switch (message.level)
 118       {
 119       case CEC_LOG_ERROR:
 120         strLevel = "ERROR:   ";
 121         break;
 122       case CEC_LOG_WARNING:
 123         strLevel = "WARNING: ";
 124         break;
 125       case CEC_LOG_NOTICE:
 126         strLevel = "NOTICE:  ";
 127         break;
 128       case CEC_LOG_TRAFFIC:
 129         strLevel = "TRAFFIC: ";
 130         break;
 131       case CEC_LOG_DEBUG:
 132         strLevel = "DEBUG:   ";
 133         break;
 134       default:
 135         break;
 136       }
 137
 138       CStdString strFullLog;
 139       strFullLog.Format("%s[%16lld]\t%s", strLevel.c_str(), message.time, message.message);
 140       cout << strFullLog.c_str() << endl;
 141
 142       if (g_logOutput.is_open())
 143       {
 144         if (g_bShortLog)
 145           g_logOutput << message.message << endl;
 146         else
 147           g_logOutput << strFullLog.c_str() << endl;
 148       }
 149     }
 150   }
 151 }
 152
 153 void list_devices(ICECAdapter *parser)
 154 {
 155   cec_adapter *devices = new cec_adapter[10];
 156   uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
 157   if (iDevicesFound <= 0)
 158   {
 159     cout << "Found devices: NONE" << endl;
 160   }
 161   else
 162   {
 163     CStdString strLog;
 164     strLog.Format("Found devices: %d", iDevicesFound);
 165     cout << strLog.c_str() << endl;
 166     for (unsigned int iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
 167     {
 168       CStdString strDevice;
 169       strDevice.Format("device:        %d\npath:          %s\ncom port:      %s", iDevicePtr + 1, devices[iDevicePtr].path, devices[iDevicePtr].comm);
 170       cout << endl << strDevice.c_str() << endl;
 171     }
 172   }
 173 }
 174
 175 void show_help(const char* strExec)
 176 {
 177   cout << endl <<
 178       strExec << " {-h|--help|-l|--list-devices|[COM PORT]}" << endl <<
 179       endl <<
 180       "parameters:" << endl <<
 181       "  -h --help                   Shows this help text" << endl <<
 182       "  -l --list-devices           List all devices on this system" << endl <<
 183       "  -la --logical-address {a}   The logical address to use." << endl <<
 184       "  -f --log-file {file}        Writes all libCEC log message to a file" << endl <<
 185       "  -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl <<
 186       "                              and log levels to a file." << endl <<
 187       "  -d --log-level {level}      Sets the log level. See cectypes.h for values." << endl <<
 188       "  [COM PORT]                  The com port to connect to. If no COM" << endl <<
 189       "                              port is given, the client tries to connect to the" << endl <<
 190       "                              first device that is detected." << endl <<
 191       endl <<
 192       "Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
 193       "available commands" << endl;
 194 }
 195
 196 void show_console_help(void)
 197 {
 198   cout << endl <<
 199   "================================================================================" << endl <<
 200   "Available commands:" << endl <<
 201   endl <<
 202   "tx {bytes}                transfer bytes over the CEC line." << endl <<
 203   "txn {bytes}               transfer bytes but don't wait for transmission ACK." << endl <<
 204   "[tx 40 00 FF 11 22 33]    sends bytes 0x40 0x00 0xFF 0x11 0x22 0x33" << endl <<
 205   endl <<
 206   "on {address}              power on the device with the given logical address." << endl <<
 207   "[on 5]                    power on a connected audio system" << endl <<
 208   endl <<
 209   "standby {address}         put the device with the given address in standby mode." << endl <<
 210   "[standby 0]               powers off the TV" << endl <<
 211   endl <<
 212   "la {logical_address}      change the logical address of the CEC adapter." << endl <<
 213   "[la 4]                    logical address 4" << endl <<
 214   endl <<
 215   "pa {physical_address}     change the physical address of the CEC adapter." << endl <<
 216   "[pa 10 00]                physical address 1.0.0.0" << endl <<
 217   endl <<
 218   "osd {addr} {string}       set OSD message on the specified device." << endl <<
 219   "[osd 0 Test Message]      displays 'Test Message' on the TV" << endl <<
 220   endl <<
 221   "ver {addr}                get the CEC version of the specified device." << endl <<
 222   "[ver 0]                   get the CEC version of the TV" << endl <<
 223   endl <<
 224   "ven {addr}                get the vendor ID of the specified device." << endl <<
 225   "[ven 0]                   get the vendor ID of the TV" << endl <<
 226   endl <<
 227   "lang {addr}               get the menu language of the specified device." << endl <<
 228   "[lang 0]                  get the menu language of the TV" << endl <<
 229   endl <<
 230   "pow {addr}                get the power status of the specified device." << endl <<
 231   "[pow 0]                   get the power status of the TV" << endl <<
 232   endl <<
 233   "[mon] {1|0}               enable or disable CEC bus monitoring." << endl <<
 234   "[log] {1 - 31}            change the log level. see cectypes.h for values." << endl <<
 235   "[ping]                    send a ping command to the CEC adapter." << endl <<
 236   "[bl]                      to let the adapter enter the bootloader, to upgrade" << endl <<
 237   "                          the flash rom." << endl <<
 238   "[r]                       reconnect to the CEC adapter." << endl <<
 239   "[h] or [help]             show this help." << endl <<
 240   "[q] or [quit]             to quit the CEC test client and switch off all" << endl <<
 241   "                          connected CEC devices." << endl <<
 242   "================================================================================" << endl;
 243 }
 244
 245 int main (int argc, char *argv[])
 246 {
 247   ICECAdapter *parser = LoadLibCec("CECTester");
 248   if (!parser || parser->GetMinVersion() > CEC_TEST_CLIENT_VERSION)
 249   {
 250 #ifdef __WINDOWS__
 251     cout << "Cannot load libcec.dll" << endl;
 252 #else
 253     cout << "Cannot load libcec.so" << endl;
 254 #endif
 255     return 1;
 256   }
 257   CStdString strLog;
 258   strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersion(), parser->GetLibVersionMinor());
 259   cout << strLog.c_str() << endl;
 260
 261   //make stdin non-blocking
 262 #ifndef __WINDOWS__
 263   int flags = fcntl(0, F_GETFL, 0);
 264   flags |= O_NONBLOCK;
 265   fcntl(0, F_SETFL, flags);
 266 #endif
 267
 268   int iArgPtr = 1;
 269   while (iArgPtr < argc)
 270   {
 271     if (argc >= iArgPtr + 1)
 272     {
 273       if (!strcmp(argv[iArgPtr], "-f") ||
 274           !strcmp(argv[iArgPtr], "--log-file") ||
 275           !strcmp(argv[iArgPtr], "-sf") ||
 276           !strcmp(argv[iArgPtr], "--short-log-file"))
 277       {
 278         if (argc >= iArgPtr + 2)
 279         {
 280           g_logOutput.open(argv[iArgPtr + 1]);
 281           g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") || !strcmp(argv[iArgPtr], "--short-log-file"));
 282           iArgPtr += 2;
 283         }
 284         else
 285         {
 286           cout << "== skipped log-file parameter: no file given ==" << endl;
 287           ++iArgPtr;
 288         }
 289       }
 290       else if (!strcmp(argv[iArgPtr], "-d") ||
 291           !strcmp(argv[iArgPtr], "--log-level"))
 292       {
 293         if (argc >= iArgPtr + 2)
 294         {
 295           int iNewLevel = atoi(argv[iArgPtr + 1]);
 296           if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
 297           {
 298             g_cecLogLevel = iNewLevel;
 299             cout << "log level set to " << argv[iArgPtr + 1] << endl;
 300           }
 301           else
 302           {
 303             cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
 304           }
 305           iArgPtr += 2;
 306         }
 307         else
 308         {
 309           cout << "== skipped log-level parameter: no level given ==" << endl;
 310           ++iArgPtr;
 311         }
 312       }
 313       else if (!strcmp(argv[iArgPtr], "-la") ||
 314                !strcmp(argv[iArgPtr], "--logical-address"))
 315       {
 316         if (argc >= iArgPtr + 2)
 317         {
 318           int iNewAddress = atoi(argv[iArgPtr + 1]);
 319           if (iNewAddress >= 0 && iNewAddress <= 15)
 320           {
 321             g_iLogicalAddress = iNewAddress;
 322             cout << "logical address set to " << argv[iArgPtr + 1] << endl;
 323           }
 324           else
 325           {
 326             cout << "== skipped logical-address parameter: invalid address '" << argv[iArgPtr + 1] << "' ==" << endl;
 327           }
 328           iArgPtr += 2;
 329         }
 330         else
 331         {
 332           cout << "== skipped logical-address parameter: no address given ==" << endl;
 333           ++iArgPtr;
 334         }
 335       }
 336       else if (!strcmp(argv[iArgPtr], "--list-devices") ||
 337                !strcmp(argv[iArgPtr], "-l"))
 338       {
 339         list_devices(parser);
 340         UnloadLibCec(parser);
 341         return 0;
 342       }
 343       else if (!strcmp(argv[iArgPtr], "--help") ||
 344                !strcmp(argv[iArgPtr], "-h"))
 345       {
 346         show_help(argv[0]);
 347         UnloadLibCec(parser);
 348         return 0;
 349       }
 350       else
 351       {
 352         g_strPort = argv[iArgPtr++];
 353       }
 354     }
 355   }
 356
 357   if (g_strPort.IsEmpty())
 358   {
 359     cout << "no serial port given. trying autodetect: ";
 360     cec_adapter devices[10];
 361     uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
 362     if (iDevicesFound <= 0)
 363     {
 364       cout << "FAILED" << endl;
 365       UnloadLibCec(parser);
 366       return 1;
 367     }
 368     else
 369     {
 370       cout << endl << " path:     " << devices[0].path << endl <<
 371           " com port: " << devices[0].comm << endl << endl;
 372       g_strPort = devices[0].comm;
 373     }
 374   }
 375
 376   parser->SetLogicalAddress((cec_logical_address) g_iLogicalAddress);
 377
 378   if (!parser->Open(g_strPort.c_str()))
 379   {
 380     cout << "unable to open the device on port " << g_strPort << endl;
 381     flush_log(parser);
 382     UnloadLibCec(parser);
 383     return 1;
 384   }
 385
 386   cout << "cec device opened" << endl;
 387
 388   parser->PowerOnDevices(CECDEVICE_TV);
 389   flush_log(parser);
 390
 391   parser->SetActiveView();
 392   flush_log(parser);
 393
 394   bool bContinue(true);
 395   cout << "waiting for input" << endl;
 396   while (bContinue)
 397   {
 398     flush_log(parser);
 399
 400     /* just ignore the command buffer and clear it */
 401     cec_command dummy;
 402     while (parser && parser->GetNextCommand(&dummy)) {}
 403
 404     string input;
 405     getline(cin, input);
 406     cin.clear();
 407
 408     if (!input.empty())
 409     {
 410       string command;
 411       if (GetWord(input, command))
 412       {
 413         if (command == "tx" || command == "txn")
 414         {
 415           string strvalue;
 416           uint8_t ivalue;
 417           cec_command bytes;
 418           bytes.clear();
 419
 420           while (GetWord(input, strvalue) && HexStrToInt(strvalue, ivalue))
 421             bytes.push_back(ivalue);
 422
 423           if (command == "txn")
 424             bytes.transmit_timeout = 0;
 425
 426           parser->Transmit(bytes);
 427         }
 428         else if (command == "on")
 429         {
 430           string strValue;
 431           uint8_t iValue = 0;
 432           if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 433           {
 434             parser->PowerOnDevices((cec_logical_address) iValue);
 435           }
 436           else
 437           {
 438             cout << "invalid destination" << endl;
 439           }
 440         }
 441         else if (command == "standby")
 442         {
 443           string strValue;
 444           uint8_t iValue = 0;
 445           if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 446           {
 447             parser->StandbyDevices((cec_logical_address) iValue);
 448           }
 449           else
 450           {
 451             cout << "invalid destination" << endl;
 452           }
 453         }
 454         else if (command == "la")
 455         {
 456           string strvalue;
 457           if (GetWord(input, strvalue))
 458           {
 459             parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
 460           }
 461         }
 462         else if (command == "pa")
 463         {
 464           string strB1, strB2;
 465           uint8_t iB1, iB2;
 466           if (GetWord(input, strB1) && HexStrToInt(strB1, iB1) &&
 467               GetWord(input, strB2) && HexStrToInt(strB2, iB2))
 468           {
 469             uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
 470             parser->SetPhysicalAddress(iPhysicalAddress);
 471           }
 472         }
 473         else if (command == "osd")
 474         {
 475           bool bFirstWord(false);
 476           string strAddr, strMessage, strWord;
 477           uint8_t iAddr;
 478           if (GetWord(input, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
 479           {
 480             while (GetWord(input, strWord))
 481             {
 482               if (bFirstWord)
 483               {
 484                 bFirstWord = false;
 485                 strMessage.append(" ");
 486               }
 487               strMessage.append(strWord);
 488             }
 489             parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
 490           }
 491         }
 492         else if (command == "ping")
 493         {
 494           parser->PingAdapter();
 495         }
 496         else if (command == "mon")
 497         {
 498           CStdString strEnable;
 499           if (GetWord(input, strEnable) && (strEnable.Equals("0") || strEnable.Equals("1")))
 500           {
 501             parser->SwitchMonitoring(strEnable.Equals("1"));
 502           }
 503         }
 504         else if (command == "bl")
 505         {
 506           parser->StartBootloader();
 507         }
 508         else if (command == "lang")
 509         {
 510           CStdString strDev;
 511           if (GetWord(input, strDev))
 512           {
 513             int iDev = atoi(strDev);
 514             if (iDev >= 0 && iDev < 15)
 515             {
 516               CStdString strLog;
 517               cec_menu_language language;
 518               if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
 519                 strLog.Format("menu language '%s'", language.language);
 520               else
 521                 strLog = "failed!";
 522               cout << strLog.c_str() << endl;
 523             }
 524           }
 525         }
 526         else if (command == "ven")
 527         {
 528           CStdString strDev;
 529           if (GetWord(input, strDev))
 530           {
 531             int iDev = atoi(strDev);
 532             if (iDev >= 0 && iDev < 15)
 533             {
 534               uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
 535               CStdString strLog;
 536               strLog.Format("vendor id: %06x", iVendor);
 537               cout << strLog.c_str() << endl;
 538             }
 539           }
 540         }
 541         else if (command == "ver")
 542         {
 543           CStdString strDev;
 544           if (GetWord(input, strDev))
 545           {
 546             int iDev = atoi(strDev);
 547             if (iDev >= 0 && iDev < 15)
 548             {
 549               cec_version iVersion = parser->GetDeviceCecVersion((cec_logical_address) iDev);
 550               switch (iVersion)
 551               {
 552               case CEC_VERSION_1_2:
 553                 cout << "CEC version 1.2" << endl;
 554                 break;
 555               case CEC_VERSION_1_2A:
 556                 cout << "CEC version 1.2a" << endl;
 557                 break;
 558               case CEC_VERSION_1_3:
 559                 cout << "CEC version 1.3" << endl;
 560                 break;
 561               case CEC_VERSION_1_3A:
 562                 cout << "CEC version 1.3a" << endl;
 563                 break;
 564               default:
 565                 cout << "unknown CEC version" << endl;
 566                 break;
 567               }
 568             }
 569           }
 570         }
 571         else if (command == "pow")
 572         {
 573           CStdString strDev;
 574           if (GetWord(input, strDev))
 575           {
 576             int iDev = atoi(strDev);
 577             if (iDev >= 0 && iDev < 15)
 578             {
 579               cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
 580               switch (iPower)
 581               {
 582               case CEC_POWER_STATUS_ON:
 583                 cout << "powered on" << endl;
 584                 break;
 585               case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
 586                 cout << "on -> standby" << endl;
 587                 break;
 588               case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
 589                 cout << "standby -> on" << endl;
 590                 break;
 591               case CEC_POWER_STATUS_STANDBY:
 592                 cout << "standby" << endl;
 593                 break;
 594               default:
 595                 cout << "unknown power status" << endl;
 596                 break;
 597               }
 598             }
 599           }
 600         }
 601         else if (command == "r")
 602         {
 603           cout << "closing the connection" << endl;
 604           parser->Close();
 605           flush_log(parser);
 606
 607           cout << "opening a new connection" << endl;
 608           parser->Open(g_strPort.c_str());
 609           flush_log(parser);
 610
 611           cout << "setting active view" << endl;
 612           parser->SetActiveView();
 613         }
 614         else if (command == "h" || command == "help")
 615         {
 616           show_console_help();
 617         }
 618         else if (command == "q" || command == "quit")
 619         {
 620           bContinue = false;
 621         }
 622         else if (command == "log")
 623         {
 624           CStdString strLevel;
 625           if (GetWord(input, strLevel))
 626           {
 627             int iNewLevel = atoi(strLevel);
 628             if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
 629             {
 630               g_cecLogLevel = iNewLevel;
 631               cout << "log level changed to " << strLevel.c_str() << endl;
 632             }
 633           }
 634         }
 635       }
 636       if (bContinue)
 637         cout << "waiting for input" << endl;
 638     }
 639     CCondition::Sleep(50);
 640   }
 641
 642   parser->StandbyDevices(CECDEVICE_BROADCAST);
 643   parser->Close();
 644   flush_log(parser);
 645   UnloadLibCec(parser);
 646
 647   if (g_logOutput.is_open())
 648     g_logOutput.close();
 649
 650   return 0;
 651 }