开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
bt_hci.cpp
资源名称：Maui_META_src_v5.0808.0.zip　[点击查看]
上传用户：gelin96
上传日期：2017-01-08
资源大小：20993k
文件大小：34k
源码类别：

MTK

开发平台：

C++ Builder

bt_hci.cpp：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2001
  8. *
  9. *****************************************************************************/
  11. /*****************************************************************************
  12.  *
  13.  * Filename:
  14.  * ---------
  15.  *   bt_hci.cpp
  16.  *
  17.  * Project:
  18.  * --------
  19.  *   Maui META APP
  20.  *
  21.  * Description:
  22.  * ------------
  23.  *   BT HCI command test source
  24.  *
  25.  * Author:
  26.  * -------
  27.  *  Andy Ueng (mtk00490)
  28.  *
  29.  *============================================================================
  30.  *             HISTORY
  31.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  32.  *------------------------------------------------------------------------------
  33.  * $Revision$
  34.  * $Modtime$
  35.  * $Log$
  36.  *
  37.  *------------------------------------------------------------------------------
  38.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  39.  *============================================================================
  40.  ****************************************************************************/
  41. //===========================================================================
  42. #include<iostream>
  44. #include <fstream>
  47. #pragma hdrstop
  49. #ifndef  _BT_COMMON_H_
  50. #include "bt_common.h"
  51. #endif
  53. #ifndef  _BT_HCI_COMMON_H_
  54. #include "bt_hci_common.h"
  55. #endif
  57. #ifndef  _BT_HCI_H_
  58. #include "bt_hci.h"
  59. #endif
  61. // man
  62. #ifndef  _MAN_ACTIVE_H_
  63. #include "man_active.h"
  64. #endif
  67. // misc
  68. #ifndef  _FILE_UTILS_H_
  69. #include "file_utils.h"
  70. #endif
  72. #ifndef  _FT_UTILS_H_
  73. #include "ft_utils.h"
  74. #endif
  76. #ifndef  _MISC_BT_H_
  77. #include "misc_bt.h"
  78. #endif
  80. // message
  81. #ifndef _META_LAB_MSG_H_
  82. #include "meta_lab_msg.h"
  83. #endif
  85. #define INVALID_TAG  -1
  87. const AnsiString KEY_WORD[]=
  88. {
  89.     "[GROUP]",
  90.     "[COMMAND]",
  91.     "[DEFINE]",
  92.     "[CATEGORY]"
  93. };
  95. //----------------------------------------------------------------------------
  96. static CBTHCI*  gs_bt_hci_ptr;
  97. static bool g_bIsRunning = false;
  99. //==============================================================================
  100. static void REQ_Read_From_File(void)
  101. {
  102.     gs_bt_hci_ptr->REQ_Read_From_File();
  103. }
  105. //----------------------------------------------------------------------------
  106. static void  REQ_Send_HCI_Command(void)
  107. {
  108.     gs_bt_hci_ptr->REQ_Send_HCI_Command();
  109. }
  111. //------------------------------------------------------------------------------
  112. static void __stdcall CNF_HCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  113. {
  114.     gs_bt_hci_ptr->CNF_HCIEvent( cnf, token, usrData );
  115. }
  117. //===========================================================================
  118. CBTHCI::CBTHCI(void)
  119. {
  120.     g_bIsRunning = false;
  121.     ConfirmCallback = 0;
  122.     m_fp = NULL;
  123.     AllocateVector();
  124. }
  126. //---------------------------------------------------------------------------
  127. CBTHCI::~CBTHCI(void)
  128. {
  129.     DeAllocateVector();
  130. }
  132. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  133. void CBTHCI::AllocateVector(void)
  134. {
  135.     if (NULL == m_pvHCIGroup)
  136.     {
  137.         m_pvHCIGroup = new vector<S_BT_HCI_GROUP>;
  138.     }
  140.     if (NULL == m_pvHCICategory)
  141.     {
  142.         m_pvHCICategory  = new vector<S_BT_HCI_CATEGORY>;
  143.     }
  144. }
  146. //---------------------------------------------------------------------------
  147. void CBTHCI::DeAllocateVector(void)
  148. {
  149.     if (NULL != m_pvHCIGroup)
  150.     {
  151.         if (!m_pvHCIGroup->empty())
  152.         {
  153.             m_pvHCIGroup->erase(m_pvHCIGroup->begin(), m_pvHCIGroup->end());
  154.         }
  155.         delete m_pvHCIGroup;
  156.         m_pvHCIGroup = NULL;
  157.     }
  159.     if (NULL != m_pvHCICategory)
  160.     {
  161.         if (!m_pvHCICategory->empty())
  162.         {
  163.             m_pvHCICategory->erase(m_pvHCICategory->begin(), m_pvHCICategory->end());
  164.         }
  165.         delete m_pvHCICategory;
  166.         m_pvHCICategory = NULL;
  167.     }
  168. }
  170. //---------------------------------------------------------------------------
  171. void CBTHCI::EraseVector(void)
  172. {
  173.     if (!m_pvHCIGroup->empty())
  174.     {
  175.         m_pvHCIGroup->erase(m_pvHCIGroup->begin(), m_pvHCIGroup->end());
  176.     }
  178.     if (!m_pvHCICategory->empty())
  179.     {
  180.         m_pvHCICategory->erase(m_pvHCICategory->begin(), m_pvHCICategory->end());
  181.     }
  182. }
  184. //---------------------------------------------------------------------------
  185. void CBTHCI::REQ_Stop(void)
  186. {
  187.     if (!g_bIsRunning)
  188.     {
  189.         return;
  190.     }
  191.     Confirm(METAAPP_STOP);
  192. }
  194. //---------------------------------------------------------------------------
  195. void CBTHCI::Confirm(E_METAAPP_RESULT_T confirm_state)
  196. {
  197.     if (!g_bIsRunning)
  198.     {
  199.         return;
  200.     }
  201.     g_bIsRunning = false;
  203.  //  CloseFile();
  204.     if (NULL == ConfirmCallback)
  205.     {
  206.         return;
  207.     }
  208.     m_eConfirmState = confirm_state;
  209.     ActiveMan->SetActiveFunction(ConfirmCallback);
  210. }
  212. //============================================================================
  213. void CBTHCI::REQ_Start( S_BT_HCI  &bt_hci )
  214. {
  215.     gs_bt_hci_ptr  = this;
  216.     g_bIsRunning    = true;
  218.     m_sBTHCI = bt_hci;
  222.     ActiveMan->SetActiveFunction( ::REQ_Send_HCI_Command );
  223. }
  225. //---------------------------------------------------------------------------
  226. void CBTHCI::REQ_Send_HCI_Command(void)
  227. {
  228.     if (!g_bIsRunning)
  229.     {
  230.         return;
  231.     }
  232.     AddTxLogToStringList(m_sBTHCI.s_hci_cmd);
  233.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), m_sBTHCI.ui_ms_timeout, &m_sBTHCI.s_hci_cmd, ::CNF_HCIEvent, NULL, m_sBTHCI.uc_last_event );
  235.     if (META_SUCCESS != MetaResult)
  236.     {
  237.         if (META_TIMEOUT == MetaResult)
  238.         {
  239.             Confirm(METAAPP_TIMEOUT);
  240.             return;
  241.         }
  242.         else if (META_CANCEL == MetaResult)
  243.         {
  244.             Confirm(METAAPP_CANCEL);
  245.             return;
  246.         }
  247.         else
  248.         {
  249.             Confirm(METAAPP_FAIL);
  250.             return;
  251.         }
  252.     }
  253.     Confirm(METAAPP_SUCCESS);
  254. }
  256. //---------------------------------------------------------------------------
  257. void __stdcall CBTHCI::CNF_HCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  258. {
  259.    // if(!g_bIsRunning)  return;
  260.     
  261.     m_sHCIEvent = *cnf;
  262.     AddRxLogToStringList(*cnf);
  264. }
  267. //===========================================================================
  268. void CBTHCI::REQ_Read_From_File_Start( S_BT_HCI  &bt_hci )
  269. {
  270.     gs_bt_hci_ptr  = this;
  271.     g_bIsRunning    = true;
  273.     m_sBTHCI = bt_hci;
  274.     //m_asFileName = filename;
  276.     EraseVector();
  277.     ActiveMan->SetActiveFunction( ::REQ_Read_From_File );
  278. }
  280. //----------------------------------------------------------------------------
  281. bool CBTHCI::REQ_Read_Last_HCI_File_Start( S_BT_HCI  &bt_hci )
  282. {
  283.      m_sBTHCI = bt_hci;
  285.      EraseVector();
  287.     if( ! OpenFile() )
  288.     {
  290.         return false;
  291.     }
  293.     if( ! ParseFile() )
  294.     {
  296.         return false;
  297.     }
  299.     CloseFile();
  300.     
  301.     return true;
  302. }
  304. //----------------------------------------------------------------------------
  305. void  CBTHCI::REQ_Read_From_File( void )
  306. {
  307.     if( ! g_bIsRunning )  return;
  308.     
  309.     if( ! OpenFile() )
  310.     {
  311.         CloseFile();
  312.         Confirm( METAAPP_FAIL );
  313.         return;
  314.     }
  316.     if( ! ParseFile() )
  317.     {
  318.         CloseFile();
  319.         Confirm(METAAPP_FAIL);
  320.         return;
  321.     }
  323.     CloseFile();
  324.     Confirm(METAAPP_SUCCESS);
  325. }
  327. //----------------------------------------------------------------------------
  328. bool  CBTHCI::OpenFile( void )
  329. {
  330.    // if( m_ifs.is_open() )
  331.    // {
  332.    //     CloseFile();
  333.    // }
  334.     if( ! CheckFileExist(m_sBTHCI.filename) )
  335.     {
  336.         return false;
  337.     }
  338. #if 0
  339.     m_pifs = new ifstream;
  340.     m_pifs->open( m_sBTHCI.filename.c_str(), ios::in );
  342.     if( 0 == m_pifs->is_open() )
  343.         return false;
  344. #endif
  345.     m_fp = fopen(m_sBTHCI.filename.c_str(), "r");
  347.     if( NULL == m_fp )
  348.     return false;
  349.     //m_ifs.seekg( ios::beg );
  350.    // m_pifs->setmode( filebuf::text ); // set to text mode
  351.     //m_pFBuf = m_ifs.rdbuf();
  353.     return true;
  354. }
  356. //---------------------------------------------------------------------------
  357. void CBTHCI::CloseFile( void )
  358. {
  359.     #if 0
  360.     if( m_pifs->is_open() )
  361.     {   m_pifs->close();
  362.         delete m_pifs;
  363.     }
  364.     #endif
  365.     if( NULL != m_fp )
  366.     {
  367.         fclose(m_fp);
  368.         m_fp = NULL;
  369.     }
  370. }
  373. //---------------------------------------------------------------------------
  374. bool CBTHCI::ParseFile( void )
  375. {
  376.     const int str_size = 256;
  377.     char str[str_size];
  378.     m_eHCISec = BT_HCI_UNKNOW;
  379.    // while( ! m_pifs->eof() )
  380.     while( !feof(m_fp) )
  381.     {
  382.        // m_pifs->getline( str, str_size, 'n' );
  383.         fgets( str, str_size, m_fp );
  384.         if( ! ParseCommandLine( str ) )
  385.         {
  386.             AnsiString as_str = str;
  387.             AddParseLogToStringList(as_str + " error");
  389.             return false;
  390.         }    
  391.        // streampos pos = m_ifs.tellg();
  392.        // m_ifs.tellg();
  393.     }    
  394.     return true;
  395. }
  397. //---------------------------------------------------------------------------
  398. bool CBTHCI::ParseCommandLine( AnsiString as_cmd )
  399. {
  400.     as_cmd = as_cmd.UpperCase();
  401.     if( as_cmd.AnsiCompareIC("") == 0 )  return true;  // NULL
  402.     if( as_cmd.AnsiPos("//") != 0 )  return true; // note
  404.     for( int i=0; i<sizeof(KEY_WORD)/sizeof(KEY_WORD[0]); i++ )
  405.     {
  406.         if( as_cmd.AnsiPos( KEY_WORD[i] ) != 0 )
  407.         {
  408.             m_eHCISec = (E_BT_HCI_TAG) i;
  409.             return true;
  410.         }
  411.     }
  413.     switch( m_eHCISec )
  414.     {
  415.         case BT_HCI_GROUP_TAG:
  416.         {
  417.              if( ! ParseHCIGroup( as_cmd ) )
  418.                 return false;
  419.         }
  420.         break;
  422.         case BT_HCI_COMMAND_TAG:
  423.         {
  424.              if( ! ParseHCICommand( as_cmd ) )
  425.                 return false;
  426.         }
  427.         break;
  429.         case BT_HCI_DEFINE_TAG:
  430.         {
  431.              if( ! ParseHCICmdDefine( as_cmd ) )
  432.                 return false;
  433.         }
  434.         break;
  436.         case BT_HCI_CATEGORY_TAG:
  437.         {
  438.              if( ! ParseHCICategory( as_cmd ) )
  439.                 return false;
  440.         }
  441.         break;
  442.     }
  443.     return true;
  444. }
  446. //---------------------------------------------------------------------------
  447. bool CBTHCI::ParseHCIGroup( AnsiString as_cmd )
  448. {
  449.     AnsiString as_group_tag;
  450.     AnsiString as_group_name;
  451.     int iLD_r, iLD_l;
  453.     iLD_l = as_cmd.LastDelimiter("[");
  454.     iLD_r = as_cmd.LastDelimiter("]");
  455.     as_group_tag  = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1);
  456.     as_group_name = as_cmd.SubString( iLD_r+2, as_cmd.Length() );
  457.     S_BT_HCI_GROUP group;
  458.     group.as_group_name = as_group_name;
  459.     group.as_group_tag  = as_group_tag;
  460.     m_pvHCIGroup->push_back( group );
  462.     return true;
  463. }
  465. //---------------------------------------------------------------------------
  466. bool CBTHCI::ParseHCICategory( AnsiString as_cmd )
  467. {
  468.     AnsiString as_category_tag;
  469.     AnsiString as_category_name;
  470.     int iLD_r, iLD_l;
  472.     // category header
  473.     if( as_cmd.AnsiPos("[S") != 0 || as_cmd.AnsiPos("[s") != 0 )
  474.     {
  475.         m_bFirstCategoryBody = true;
  476.         iLD_l = as_cmd.LastDelimiter("[");
  477.         iLD_r = as_cmd.LastDelimiter("]");
  478.         as_category_tag  = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1);
  479.         as_category_name = as_cmd.SubString( iLD_r+2, as_cmd.Length() );
  480.         S_BT_HCI_CATEGORY category;
  481.         category.as_category_name = as_category_name;
  482.         category.as_category_tag  = as_category_tag;
  483.         m_pvHCICategory->push_back( category );
  484. //        m_iHCICategory =
  485.     }
  486.     else  // category body
  487.     {
  489.         AnsiString as_cmd_tag;
  490.         AnsiString as_cmd_name;
  491.         //int iLD_r, iLD_l;
  494.         iLD_l = as_cmd.LastDelimiter("[");
  495.         iLD_r = as_cmd.LastDelimiter("]");
  496.         as_cmd_tag   = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1);
  497.         as_cmd_name  = as_cmd.SubString( iLD_r+2, as_cmd.Length() );
  498.        // iLD_l = as_cmd_tag.LastDelimiter("C");
  499.       //  as_category_tag = as_cmd_tag.SubString( 1, iLD_l-1 );
  502.         vector<S_BT_HCI_CATEGORY>:: iterator iter_category;
  503.         vector<S_BT_HCI_GROUP>:: iterator iter_group;
  504.         vector<S_BT_HCI_COMMAND>:: iterator iter_cmd;
  505.         if( m_bFirstCategoryBody )
  506.         {
  507.             m_bFirstCategoryBody = false;
  508.             for( iter_category = m_pvHCICategory->begin(); iter_category != m_pvHCICategory->end(); iter_category++ )
  509.             {
  510.                 m_vLastCateogryIter = iter_category;
  511.             }
  512.         }
  514.         S_BT_HCI_COMMAND command;
  515.        // command.as_cmd_name = as_cmd_name;
  516.         command.as_cmd_tag  = as_cmd_tag;
  518.         bool found = false;
  519.         for( iter_group = m_pvHCIGroup->begin(); (false==found) && (iter_group != m_pvHCIGroup->end()); iter_group++ )
  520.         {
  521.             for( iter_cmd = iter_group->v_cmd.begin(); iter_cmd != iter_group->v_cmd.end(); iter_cmd++ )
  522.             {
  523.                 if( iter_cmd->as_cmd_tag.AnsiCompareIC(as_cmd_tag) == 0 )
  524.                 {
  525.                      command = *iter_cmd;
  526.                      found = true;
  527.                      break;
  528.                 }
  529.             }
  530.         }
  531.         m_vLastCateogryIter->v_cmd.push_back( command );
  534.     }
  537.     return true;
  538. }
  540. //---------------------------------------------------------------------------
  541. bool CBTHCI::ParseHCICommand( AnsiString as_cmd )
  542. {
  543.     AnsiString as_group_tag;
  544.     AnsiString as_cmd_tag;
  545.     AnsiString as_cmd_name;
  546.     int iLD_r, iLD_l;
  548.     iLD_l = as_cmd.LastDelimiter("[");
  549.     iLD_r = as_cmd.LastDelimiter("]");
  550.     as_cmd_tag   = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1);
  551.     as_cmd_name  = as_cmd.SubString( iLD_r+2, as_cmd.Length() );
  552.     iLD_l = as_cmd_tag.LastDelimiter("C");
  553.     as_group_tag = as_cmd_tag.SubString( 1, iLD_l-1 );
  556.     vector<S_BT_HCI_GROUP>:: iterator iter;
  557.     for( iter = m_pvHCIGroup->begin(); iter != m_pvHCIGroup->end(); iter++ )
  558.     {
  559.         S_BT_HCI_GROUP group;
  560.         group = *iter;
  561.         if( group.as_group_tag.AnsiCompareIC( as_group_tag ) == 0 )
  562.         {
  563.             S_BT_HCI_COMMAND command;
  564.             command.as_cmd_name = as_cmd_name;
  565.             command.as_cmd_tag  = as_cmd_tag;
  566.             iter->v_cmd.push_back( command );
  567.             break;
  568.         }
  569.     }
  571.     return true;
  572. }
  574. //---------------------------------------------------------------------------
  575. bool CBTHCI::ParseHCICmdDefine( AnsiString as_cmd )
  576. {
  578.    // static AnsiString as_last_cmd_tag=""; // last parsing command tag
  579.     static AnsiString as_cur_cmd;
  580.     static AnsiString as_cmd_tag=""; // currently parsing command tag
  581.     AnsiString as_group_tag;
  582.    // static unsigned int send_par_num=0;
  583.    // static unsigned int receive_par_num=0;
  584.    // static vector<S_BT_HCI_GROUP>:: iterator last_iter;
  585.     static vector<S_BT_HCI_GROUP>:: iterator iter_group;
  586.     static vector<S_BT_HCI_COMMAND>:: iterator iter_cmd;
  587.     int iLD_r, iLD_l, iLD_c;
  590.     iLD_l = as_cmd.AnsiPos("(G");
  591.     iLD_r = as_cmd.LastDelimiter(")");
  592.     if( (0 != iLD_l) && (0 != iLD_r) ) // command define header
  593.     {
  594.         as_cur_cmd = as_cmd;
  595.         //as_last_cmd_tag = as_cur_cmd_tag;
  596.         as_cmd_tag  = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1);
  597.         iLD_c           = as_cmd_tag.AnsiPos("C");
  598.         as_group_tag    = as_cmd_tag.SubString( 1, iLD_c-1 );
  600.         S_BT_HCI_GROUP group;
  601.         S_BT_HCI_COMMAND command;
  602.         for( iter_group = m_pvHCIGroup->begin(); iter_group != m_pvHCIGroup->end(); iter_group++ )
  603.         {
  604.             group = *iter_group;
  605.             if( group.as_group_tag.AnsiCompareIC( as_group_tag ) == 0 )
  606.             {
  607.                 for( iter_cmd = iter_group->v_cmd.begin(); iter_cmd != iter_group->v_cmd.end(); iter_cmd++ )
  608.                 {
  609.                     command = *iter_cmd;
  610.                     if( command.as_cmd_tag.AnsiCompareIC( as_cmd_tag ) == 0 )
  611.                     {
  612.                         iter_cmd->ui_send_num = 0;
  613.                         iter_cmd->ui_receive_num = 0;
  614.                         break;
  615.                     }
  616.                 }
  617.                // last_iter    = curr_iter;
  618.                // curr_iter    = iter;
  620.             }
  621.         }
  623.        // if( as_last_cmd_tag.AnsiCompareIC("") != 0 ) // not first command define header
  624.        // {
  625.        //    // curr_iter->ui_send_num    = send_par_num;
  626.        //    // curr_iter->ui_receive_num = receive_par_num;
  627.        // }
  629.        // vector<S_BT_HCI_COMMAND>:: iterator iter;
  630.        // S_BT_HCI_COMMAND command;
  631.       //  for( iter = m_pvHCICmd->begin(); iter != m_pvHCICmd->end(); iter++ )
  632.        // {
  633.        //     command = *iter;
  634.        //     if( command.as_cmd_tag.AnsiCompareIC( as_cur_cmd_tag ) == 0 )
  635.        //     {
  636.        ////         last_iter    = curr_iter;
  637.        //        // curr_iter    = iter;
  638.        //        // break;
  639.        //     }
  640.        // }
  641.        //
  642.        // send_par_num     = 0;
  643.        // receive_par_num  = 0;
  644.     }
  645.     else // command define parameter
  646.     {
  648.         if( (iLD_l=as_cmd.AnsiPos("#")) != 0 ) // opcode
  649.         {
  650.             iLD_r = as_cmd.AnsiPos(" ");
  652.             if( 0 == iLD_r )
  653.             {
  654.                 if( as_cmd.AnsiPos("0X") == 0 )
  655.                 {
  656.                     iter_cmd->us_opcode = as_cmd.SubString( iLD_l+1, as_cmd.Length() ).ToInt();
  657.                 }
  658.                 else
  659.                 {
  660.                     iLD_r = as_cmd.AnsiPos("0X");
  661.                     AnsiString_Hex_To_UnsignedShort( as_cmd.SubString( iLD_r+2, as_cmd.Length()-iLD_r-2 ), iter_cmd->us_opcode );
  662.                 }
  663.             }
  664.             else
  665.             {
  666.                 if( as_cmd.AnsiPos("0X") == 0 )
  667.                 {
  668.                     iter_cmd->us_opcode = as_cmd.SubString( iLD_r+1, as_cmd.Length() ).ToInt();
  669.                 }
  670.                 else
  671.                 {
  672.                     iLD_r = as_cmd.AnsiPos("0X");
  673.                     AnsiString_Hex_To_UnsignedShort( as_cmd.SubString( iLD_r+2, as_cmd.Length()-iLD_r-2 ), iter_cmd->us_opcode );
  674.                 }
  675.             }
  676.         }
  677.         else if( (iLD_l=as_cmd.AnsiPos("$")) != 0 ) // last event
  678.         {
  679.             iLD_r = as_cmd.AnsiPos(" ");
  681.             if( 0 == iLD_r )
  682.             {
  683.                 if( as_cmd.AnsiPos("0X") == 0 )
  684.                 {
  685.                     iter_cmd->uc_last_event = as_cmd.SubString( iLD_l+1, as_cmd.Length() ).ToInt();
  686.                 }
  687.                 else
  688.                 {
  689.                     iLD_r = as_cmd.AnsiPos("0X");
  690.                     AnsiString_Hex_To_UnsignedChar( as_cmd.SubString( iLD_r+2, as_cmd.Length()-iLD_r-2 ), iter_cmd->uc_last_event );
  691.                 }
  692.             }
  693.             else
  694.             {
  695.                 if( as_cmd.AnsiPos("0X") == 0 )
  696.                 {
  697.                     iter_cmd->uc_last_event = as_cmd.SubString( iLD_r+1, as_cmd.Length() ).ToInt();
  698.                 }
  699.                 else
  700.                 {
  701.                     iLD_r = as_cmd.AnsiPos("0X");
  702.                     AnsiString_Hex_To_UnsignedChar( as_cmd.SubString( iLD_r+2, as_cmd.Length()-iLD_r-2 ), iter_cmd->uc_last_event );
  703.                 }
  704.             }
  705.         }
  706.         else if( (iLD_l=as_cmd.AnsiPos("@")) != 0 )   // send parameter
  707.         {
  708.             iLD_r = as_cmd.AnsiPos(" ");
  709.             S_BT_HCI_PARAMETER par;
  710.             if( 0 != iLD_r )
  711.             {
  712.                 par.ui_bytes  = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 ).ToInt();
  713.                 if( 0 == as_cmd.AnsiPos("(") )
  714.                 {
  715.                     par.as_name = as_cmd.SubString( iLD_r+1, as_cmd.Length() );
  716.                 }
  717.                 else
  718.                 {
  719.                     par.as_name = as_cmd.SubString( iLD_r+1, as_cmd.AnsiPos("(")-iLD_r-2 );
  720.                 }
  721.             }
  722.             else
  723.             {
  724.                 AnsiString as_log = "parsing " +  as_cur_cmd + " command " + as_cmd + " parameter fail";
  725.                 AddParseLogToStringList( as_log );
  727.                 return false;
  728.             }
  729.             // default value, range
  730.             iLD_l = as_cmd.AnsiPos("(");
  731.             if( 0 == iLD_l ) // default value & range not exist
  732.             {
  733.                 par.b_rangecheck = false;
  734.                 par.s_value.uc_nz_byte     = 0;
  735.                 par.s_min_value.uc_nz_byte = 0;
  736.                 par.s_max_value.uc_nz_byte = 0;
  737.                 for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  738.                 {
  739.                     par.s_value.uc_value[i]     = 0;
  740.                     par.s_min_value.uc_value[i] = 0;
  741.                     par.s_max_value.uc_value[i] = 0;
  742.                 }
  743.             }
  744.             else // default value or range exist
  745.             {
  746.                 iLD_r = as_cmd.AnsiPos(",");
  747.                 if( iLD_r != 0 ) // default value & range exist
  748.                 {
  749.                     if( as_cmd.AnsiPos("0X") ) // Hex
  750.                     {
  751.                         iLD_l = as_cmd.AnsiPos("0X");
  752.                         AnsiString_Hex_To_BTHCIValue( as_cmd.SubString(iLD_l+2, iLD_r-iLD_l-2), par.s_value );
  753.                     }
  754.                     else // Dec
  755.                     {   AnsiString_To_BTHCIValue( as_cmd.SubString(iLD_l+1, iLD_r-iLD_l-1), par.s_value );
  756.                     }
  757.                     iLD_l = iLD_r;
  758.                     iLD_r = as_cmd.AnsiPos(")");
  759.                     AnsiString as_range = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 );
  760.                     iLD_r = as_range.AnsiPos("-");
  761.                     if( iLD_r != 0 )
  762.                     {
  763.                         par.b_rangecheck = true;
  764.                         // min range
  765.                         AnsiString as_min_range = as_range.SubString( 1, iLD_r-1 );
  766.                         if( as_min_range.AnsiPos("0X") ) // Hex
  767.                         {
  768.                             iLD_l = as_min_range.AnsiPos("0X");
  769.                             AnsiString_Hex_To_BTHCIValue( as_min_range.SubString(iLD_l+2, as_min_range.Length()), par.s_min_value );
  770.                         }
  771.                         else // Dec
  772.                         {   AnsiString_To_BTHCIValue( as_min_range.SubString(1, as_min_range.Length()), par.s_min_value );
  773.                         }
  774.                         // max range
  775.                         AnsiString as_max_range = as_range.SubString( iLD_r+1, as_range.Length()-iLD_r );
  776.                         if( as_max_range.AnsiPos("0X") ) // Hex
  777.                         {
  778.                             iLD_l = as_max_range.AnsiPos("0X");
  779.                             AnsiString_Hex_To_BTHCIValue( as_max_range.SubString(iLD_l+2, as_max_range.Length()), par.s_max_value );
  780.                         }
  781.                         else // Dec
  782.                         {   AnsiString_To_BTHCIValue( as_max_range.SubString(1, as_max_range.Length()), par.s_max_value );
  783.                         }
  784.                     }
  785.                     else // no range check
  786.                     {
  787.                         par.b_rangecheck = false;
  788.                     }
  789.                 }
  790.                 else // default value or range exist
  791.                 {
  792.                     if( as_cmd.AnsiPos("-") != 0 ) // default value not exist, range exist
  793.                     {
  794.                         par.b_rangecheck = true;
  795.                         par.s_value.uc_nz_byte     = 0;
  796.                         for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  797.                         {
  798.                             par.s_value.uc_value[i]     = 0;
  799.                         }
  800.                         iLD_l = as_cmd.AnsiPos("(");
  801.                         iLD_r = as_cmd.AnsiPos(")");
  802.                         AnsiString as_range = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 );
  804.                         
  805.                         // min range
  806.                         iLD_r = as_range.AnsiPos("-");
  807.                         AnsiString as_min_range = as_range.SubString( 1, iLD_r-1 );
  808.                         if( as_min_range.AnsiPos("0X") ) // Hex
  809.                         {
  810.                             iLD_l = as_min_range.AnsiPos("0X");
  811.                             AnsiString_Hex_To_BTHCIValue( as_min_range.SubString(iLD_l+2, as_min_range.Length()), par.s_min_value );
  812.                         }
  813.                         else // Dec
  814.                         {   AnsiString_To_BTHCIValue( as_min_range.SubString(1, as_min_range.Length()), par.s_min_value );
  815.                         }
  816.                         // max range
  817.                         AnsiString as_max_range = as_range.SubString( iLD_r+1, as_range.Length()-iLD_r );
  818.                         if( as_max_range.AnsiPos("0X") ) // Hex
  819.                         {
  820.                             iLD_l = as_max_range.AnsiPos("0X");
  821.                             AnsiString_Hex_To_BTHCIValue( as_max_range.SubString(iLD_l+2, as_max_range.Length()), par.s_max_value );
  822.                         }
  823.                         else // Dec
  824.                         {   AnsiString_To_BTHCIValue( as_max_range.SubString(1, as_max_range.Length()), par.s_max_value );
  825.                         }
  826.                     }
  827.                     else // default value exist, range not exist
  828.                     {
  829.                         par.b_rangecheck = false;
  830.                         par.s_min_value.uc_nz_byte = 0;
  831.                         par.s_max_value.uc_nz_byte = 0;
  832.                         for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  833.                         {
  834.                             par.s_min_value.uc_value[i] = 0;
  835.                             par.s_max_value.uc_value[i] = 0;
  836.                         }
  837.                         iLD_l = as_cmd.AnsiPos("(");
  838.                         iLD_r = as_cmd.AnsiPos(")");
  839.                         AnsiString as_default = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 );
  840.                         if( as_default.AnsiPos("0X") ) // Hex
  841.                         {
  842.                             iLD_l = as_default.AnsiPos("0X");
  843.                             AnsiString_Hex_To_BTHCIValue( as_default.SubString(iLD_l+2, as_default.Length()), par.s_value );
  844.                         }
  845.                         else // Dec
  846.                         {   AnsiString_To_BTHCIValue( as_default.SubString(1, as_default.Length()), par.s_value );
  847.                         }
  849.                     }
  850.                 }
  851.             }
  853.             iter_cmd->v_send_par.push_back( par );
  854.             iter_cmd->ui_send_num++;
  855.         }
  856.         else if( (iLD_l=as_cmd.AnsiPos("~")) != 0 )   // receive parameter
  857.         {
  858.             S_BT_HCI_PARAMETER par;
  859.             iLD_r = as_cmd.AnsiPos("*");
  860.             if( 0 == iLD_r )
  861.             {
  862.                 iLD_r = as_cmd.AnsiPos(" ");
  864.                 if( 0 != iLD_r )
  865.                 {
  866.                     par.b_show   = true;
  867.                     par.ui_bytes = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 ).ToInt();
  868.                     par.as_name  = as_cmd.SubString( iLD_r+1, as_cmd.Length() ).Trim();
  869.                 }
  870.                 else
  871.                 {
  872.                     AnsiString as_log = "parsing " +  as_cur_cmd + " command " + as_cmd + " parameter fail";
  873.                     AddParseLogToStringList( as_log );
  875.                     return false;
  876.                 }
  877.             }
  878.             else
  879.             {
  880.                 iLD_l = as_cmd.AnsiPos("*");
  881.                 iLD_r = as_cmd.AnsiPos(" ");
  883.                 if( 0 != iLD_r )
  884.                 {
  885.                     par.b_show   = false;
  886.                     par.ui_bytes = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 ).ToInt();
  887.                     par.as_name  = as_cmd.SubString( iLD_r+1, as_cmd.Length() ).Trim();
  888.                 }
  889.                 else
  890.                 {
  891.                     AnsiString as_log = "parsing " +  as_cur_cmd + " command " + as_cmd + " parameter fail";
  892.                     AddParseLogToStringList( as_log );
  893.                     return false;
  894.                 }
  895.             }
  896.             iter_cmd->v_receive_par.push_back( par );
  897.             iter_cmd->ui_receive_num++;
  898.         }
  900.         if( (iLD_l=as_cmd.AnsiPos("&")) != 0 )   // timeout
  901.         {
  902.             iLD_r = as_cmd.AnsiPos(" ");
  904.             if( 0 == iLD_r )
  905.             {
  906.                 if( as_cmd.AnsiPos("0X") == 0 )
  907.                 {
  908.                     iter_cmd->ui_ms_timeout = as_cmd.SubString( iLD_l+1, as_cmd.Length() ).Trim().ToInt()*1000;
  909.                 }
  910.                 else
  911.                 {
  912.                     iLD_r = as_cmd.AnsiPos("0X");
  913.                     AnsiString_Hex_To_UnsignedInt( as_cmd.SubString( iLD_r+2, as_cmd.Length()-iLD_r-2 ), iter_cmd->ui_ms_timeout );
  914.                     iter_cmd->ui_ms_timeout *= 1000;
  915.                 }
  916.             }
  917.             else
  918.             {
  919.                 if( as_cmd.AnsiPos("0X") == 0 )
  920.                 {
  921.                     AnsiString as_timeout = as_cmd.SubString( iLD_r+1, as_cmd.Length()-iLD_r ).Trim();
  922.                     iter_cmd->ui_ms_timeout = as_timeout.ToInt()*1000;
  923.                 }
  924.                 else
  925.                 {
  926.                     iLD_r = as_cmd.AnsiPos("0X");
  927.                     AnsiString_Hex_To_UnsignedInt( as_cmd.SubString( iLD_r+2, as_cmd.Length()-iLD_r-2 ), iter_cmd->ui_ms_timeout );
  928.                     iter_cmd->ui_ms_timeout *= 1000;
  929.                 }
  930.             }
  931.         }
  932.         else
  933.         {   iter_cmd->ui_ms_timeout = HCI_DEFAULT_TIMEOUT_MS;
  934.         }
  935.     }
  937.     return true;
  938. }
  940. //===========================================================================
  941. //////////////////////////   Send/receive HCI command   /////////////////////
  942. //===========================================================================
  943. //void  CBTHCI::Compose_HCI_TX_Command( BT_HCI_COMMAND &hci_cmd )
  944. //{
  945. //    vector<S_BT_HCI_PARAMETER>:: iterator iter_par;
  946. //    int idx;
  947. //
  948. //    hci_cmd.m_cmd[0] = 0x01; // fixed pattern
  949. //    hci_cmd.m_cmd[1] = m_sTxCmd.us_opcode & 0x00FF;   // low byte of opcode
  950. //    hci_cmd.m_cmd[2] = (m_sTxCmd.us_opcode & 0xFF00) >> 16; // high byte of opcode
  951. //    hci_cmd.m_cmd[3] = m_sTxCmd.uc_total_par_size; // total parameter size
  952. //    idx = 4;
  953. //    for( iter_par = m_sTxCmd.v_par.begin(); iter_par != m_sTxCmd.v_par.end(); iter_par++ )
  954. //    {
  955. //        for(int i=0; i<iter_par->ui_bytes; i++ )
  956. //        {
  957. //            hci_cmd.m_cmd[idx] = iter_par->s_value.uc_value[i];
  958. //            idx++;
  959. //        }
  960. //    }
  961. //    hci_cmd.m_len = idx + 1;
  962. //}
  964. //---------------------------------------------------------------------------
  965. //void  CBTHCI::DeCompose_HCI_RX_Event( void )
  966. //{
  967. //    vector<S_BT_HCI_PARAMETER>:: iterator iter_par;
  968. //    int idx = 5;
  969. //
  970. //    m_sRxEvent.uc_event_code     = m_sRxEventFmt.uc_event[0];
  971. //    m_sRxEvent.uc_total_par_size = m_sRxEventFmt.uc_event[1];
  972. //    m_sRxEvent.uc_packet_num     = m_sRxEventFmt.uc_event[2];
  973. //    m_sRxEvent.us_opcode         = m_sRxEventFmt.uc_event[4];
  974. //    m_sRxEvent.us_opcode         = (m_sRxEvent.us_opcode << 8) | m_sRxEventFmt.uc_event[3];
  975. //
  976. //    for( iter_par = m_sRxEvent.v_par.begin(); iter_par != m_sRxEvent.v_par.end(); iter_par++ )
  977. //    {
  978. //        for(int i=0; i<iter_par->ui_bytes; i++ )
  979. //        {
  980. //            iter_par->s_value.uc_value[i] =  m_sRxEventFmt.uc_event[idx];
  981. //            idx++;
  982. //        }
  983. //    }
  984. //}
  986. //===========================================================================
  987. ////////////////////////////   Log  information   ////////////////////////
  988. //===========================================================================
  989. void  CBTHCI::AddParseLogToStringList(AnsiString as_log)
  990. {
  991.     m_sBTHCI.log->Add(as_log);
  992.     PostMessage(
  993.                          m_sBTHCI.hPostMsgDestHandle,
  994.                          WM_ML_BT_PRINT_MSG,
  995.                          PAGEIDX_BT_HCI,
  996.                          0
  997.                         );
  998. }
  1000. //----------------------------------------------------------------------------
  1001. void  CBTHCI::AddTxLogToStringList(BT_HCI_COMMAND hci_cmd)
  1002. {
  1003.     char        str[1024];
  1004.     AnsiString as_log;
  1005.     sprintf( str, "%X,", hci_cmd.m_opcode & 0x00FF );
  1006.     AnsiString as_opcode_low(str);
  1007.     sprintf( str, "%X,", (hci_cmd.m_opcode & 0xFF00)>>8 );
  1008.     AnsiString as_opcode_high(str);
  1009.     Array_To_Hex_String_UnsignedChar( str, hci_cmd.m_cmd, hci_cmd.m_len, ',' );
  1010.     AnsiString as_cmd( (const char*)str );
  1011.     if( 0 == hci_cmd.m_len )
  1012.        as_cmd = "";
  1013.     sprintf( str, "%X,", hci_cmd.m_len );
  1014.     AnsiString as_length(str);
  1015.    
  1017.     as_log = "[" + TimeToStr(Time()) + "] TX: " + as_opcode_low + as_opcode_high + as_length  + as_cmd;
  1019.     m_sBTHCI.log->Add( as_log );
  1021.     PostMessage(
  1022.                          m_sBTHCI.hPostMsgDestHandle,
  1023.                          WM_ML_BT_PRINT_MSG,
  1024.                          PAGEIDX_BT_HCI,
  1025.                          0
  1026.                         );
  1027. }
  1029. //--------------------------------------------------------------------------
  1030. void  CBTHCI::AddRxLogToStringList(BT_HCI_EVENT hci_event)
  1031. {
  1032.     unsigned char str[1024];
  1033.     AnsiString as_log;
  1034.     sprintf( str, "%X,", hci_event.m_event );
  1035.     AnsiString as_event( (const char*) str );
  1036.     sprintf( str, "%X,", hci_event.m_len );
  1037.     AnsiString as_length( (const char*) str );
  1038.     Array_To_Hex_String_UnsignedChar( str, hci_event.m_parms, hci_event.m_len, ',' );
  1039.     AnsiString as_param( (const char*) str );
  1040.     if(  0 == hci_event.m_len )
  1041.         as_param = "";
  1042.         
  1043.     as_log = "[" + TimeToStr(Time()) + "] RX: " + as_event + as_length + as_param;
  1044.     
  1045.     m_sBTHCI.log->Add( as_log );
  1047.     PostMessage(
  1048.                          m_sBTHCI.hPostMsgDestHandle,
  1049.                          WM_ML_BT_PRINT_MSG,
  1050.                          PAGEIDX_BT_HCI,
  1051.                          0
  1052.                         );
  1053. }
  1055. //===========================================================================
  1056. ////////////////////////////   Export  information   ////////////////////////
  1057. //===========================================================================
  1058. E_METAAPP_RESULT_T CBTHCI::Get_ConfirmState(void)
  1059. {
  1060.     return  m_eConfirmState;
  1061. }
  1063. //---------------------------------------------------------------------------
  1064. vector<S_BT_HCI_CATEGORY>*  CBTHCI::Get_HciCategoryVector( void )
  1065. {   return m_pvHCICategory;
  1066. }
  1068. //---------------------------------------------------------------------------
  1069. vector<S_BT_HCI_GROUP>*  CBTHCI::Get_HciGroupVector( void )
  1070. {
  1071.     return m_pvHCIGroup;
  1072. }
  1074. //---------------------------------------------------------------------------
  1075. BT_HCI_EVENT  CBTHCI::Get_HCIEvent( void )
  1076. {   return m_sHCIEvent;
  1077. }