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

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

MTK

开发平台：

C++ Builder

bt_script.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_script.cpp
  16.  *
  17.  * Project:
  18.  * --------
  19.  *   Maui META APP
  20.  *
  21.  * Description:
  22.  * ------------
  23.  *   BT HCI command script 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. //===========================================================================
  44. #pragma hdrstop
  46. #ifndef  _BT_COMMON_H_
  47. #include "bt_common.h"
  48. #endif
  50. #ifndef  _BT_SCRIPT_H_
  51. #include "bt_script.h"
  52. #endif
  54. #ifndef  _BT_HCI_COMMON_H_
  55. #include "bt_hci_common.h"
  56. #endif
  58. // man
  59. #ifndef  _MAN_ACTIVE_H_
  60. #include "man_active.h"
  61. #endif
  64. // misc
  65. #ifndef  _STR_UTILS_H_
  66. #include "str_utils.h"
  67. #endif
  69. #ifndef  _FILE_UTILS_H_
  70. #include "file_utils.h"
  71. #endif
  73. #ifndef  _FT_UTILS_H_
  74. #include "ft_utils.h"
  75. #endif
  77. #ifndef  _MISC_BT_H_
  78. #include "misc_bt.h"
  79. #endif
  81. // message
  82. #ifndef _META_LAB_MSG_H_
  83. #include "meta_lab_msg.h"
  84. #endif
  86. #define INVALID_TAG  -1
  88. const AnsiString HEADER_WORD[]=
  89. {
  90.     "B1:",
  91.     "B2:",
  92.     "B3:",
  93.     "B4:",
  94.     "B5:",
  95.     "B6:",
  96.     "B7:",
  97.     "B8:",
  98.     "B9:",
  99.     "B10",
  100.     "B11:",
  101.     "B12:",
  102.     "B13:",
  103.     "B14:",
  104.     "B15:",
  105.     "B16:",
  106.     "B17:",
  107.     "B18:",
  108.     "B19:",
  109.     "B20",
  110.     "B21:",
  111.     "B22:",
  112.     "B23:",
  113.     "B24:",
  114.     "B25:",
  115.     "B26:",
  116.     "B27:",
  117.     "B28:",
  118.     "B29:",
  119.     "B30",
  120.     "B31:",
  121.     "B32:",
  122.     "B33:",
  123.     "B34:",
  124.     "B35:",
  125.     "B36:",
  126.     "B37:",
  127.     "B38:",
  128.     "B39:",
  129.     "B40",
  130.     "B41:",
  131.     "B42:",
  132.     "B43:",
  133.     "B44:",
  134.     "B45:",
  135.     "B46:",
  136.     "B47:",
  137.     "B48:",
  138.     "B49:",
  139.     "BYTE",
  140.     "WORD",
  141.     "DWORD",
  143. };
  145. //----------------------------------------------------------------------------
  151. static CBTSCT*  gs_bt_sct_ptr;
  152. static bool g_bIsRunning = false;
  153. //==============================================================================
  154. static void  REQ_Read_From_File( void )
  155. {   gs_bt_sct_ptr->REQ_Read_From_File();
  156. }
  158. //----------------------------------------------------------------------------
  159. static void  REQ_Test_Script( void )
  160. {   gs_bt_sct_ptr->REQ_Test_Script();
  161. }
  163. //----------------------------------------------------------------------------
  164. //static void  REQ_Send_HCI_Command( void )
  165. //{   gs_bt_sct_ptr->REQ_Send_HCI_Command();
  166. //}
  168. //------------------------------------------------------------------------------
  169. static void __stdcall CNF_HCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  170. {   gs_bt_sct_ptr->CNF_HCIEvent( cnf, token, usrData );
  171. }
  173. //===========================================================================
  174. CBTSCT::CBTSCT(void)
  175. {
  176.     g_bIsRunning = false;
  177.     ConfirmCallback = 0;
  178.     AllocateVector();
  179. }
  181. //---------------------------------------------------------------------------
  182. CBTSCT::~CBTSCT(void)
  183. {
  184.     DeAllocateVector();
  185. }
  187. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  188. void CBTSCT::AllocateVector(void)
  189. {
  190.     if (NULL == m_pvScript)
  191.     {
  192.         m_pvScript = new vector<S_BT_SCT_SCRIPT>;
  193.     }
  195.     if (NULL == m_pvBVar)
  196.     {
  197.         m_pvBVar = new vector<S_BT_B_VAR>;
  198.     }
  200.     if (NULL == m_pvWVar)
  201.     {
  202.         m_pvWVar = new vector<S_BT_W_VAR>;
  203.     }
  205.     if (NULL == m_pvDVar)
  206.     {
  207.         m_pvDVar = new vector<S_BT_D_VAR>;
  208.     }
  209. }
  211. //---------------------------------------------------------------------------
  212. void CBTSCT::DeAllocateVector(void)
  213. {
  214.     if (NULL != m_pvScript)
  215.     {
  216.         if (!m_pvScript->empty())
  217.         {
  218.             m_pvScript->erase(m_pvScript->begin(), m_pvScript->end());
  219.         }
  220.         delete m_pvScript;
  221.         m_pvScript = NULL;
  222.     }
  224.     if (NULL != m_pvBVar)
  225.     {
  226.         if (!m_pvBVar->empty())
  227.         {
  228.             m_pvBVar->erase(m_pvBVar->begin(), m_pvBVar->end());
  229.         }
  230.         delete m_pvBVar;
  231.         m_pvBVar = NULL;
  232.     }
  234.     if (NULL != m_pvWVar)
  235.     {
  236.         if (!m_pvWVar->empty())
  237.         {
  238.             m_pvWVar->erase(m_pvWVar->begin(), m_pvWVar->end());
  239.         }
  240.         delete m_pvWVar;
  241.         m_pvWVar = NULL;
  242.     }
  244.     if (NULL != m_pvDVar)
  245.     {
  246.         if (!m_pvDVar->empty())
  247.         {
  248.             m_pvDVar->erase(m_pvDVar->begin(), m_pvDVar->end());
  249.         }
  251.         delete m_pvDVar;
  252.         m_pvDVar = NULL;
  253.     }
  254. }
  256. //---------------------------------------------------------------------------
  257. void  CBTSCT::EraseVector(void)
  258. {
  259.     if (!m_pvScript->empty())
  260.     {
  261.         m_pvScript->erase(m_pvScript->begin(), m_pvScript->end());
  262.     }
  264.     if (NULL != m_pvBVar)
  265.     {
  266.         if (!m_pvBVar->empty())
  267.         {
  268.             m_pvBVar->erase(m_pvBVar->begin(), m_pvBVar->end());
  269.         }
  270.     }
  272.     if (NULL != m_pvWVar)
  273.     {
  274.         if (!m_pvWVar->empty())
  275.         {
  276.             m_pvWVar->erase(m_pvWVar->begin(), m_pvWVar->end());
  277.         }
  278.     }
  280.     if (NULL != m_pvDVar)
  281.     {
  282.         if (!m_pvDVar->empty())
  283.         {
  284.             m_pvDVar->erase(m_pvDVar->begin(), m_pvDVar->end());
  285.         }
  286.     }
  287. }
  289. //---------------------------------------------------------------------------
  290. void CBTSCT::ResetBVarData(void)
  291. {
  292.     if (NULL != m_pvBVar)
  293.     {
  294.         if (!m_pvBVar->empty())
  295.         {
  296.             vector<S_BT_B_VAR>:: iterator iter_b_var;
  297.             for (iter_b_var = m_pvBVar->begin(); iter_b_var != m_pvBVar->end(); iter_b_var++)
  298.             {
  299.                 iter_b_var->b_valid = false;
  300.             }
  301.         }
  302.     }
  303. }
  305. //---------------------------------------------------------------------------
  306. void CBTSCT::REQ_Stop(void)
  307. {
  308.     if (!g_bIsRunning)
  309.     {
  310.         return;
  311.     }
  312.     Confirm(METAAPP_STOP);
  313. }
  316. //---------------------------------------------------------------------------
  317. void CBTSCT::Confirm(E_METAAPP_RESULT_T confirm_state )
  318. {
  319.     if (!g_bIsRunning)
  320.     {
  321.         return;
  322.     }
  323.     g_bIsRunning = false;
  325.     // CloseFile();
  326.     if (NULL == ConfirmCallback)
  327.     {
  328.         return;
  329.     }
  330.     m_eConfirmState = confirm_state;
  331.     ActiveMan->SetActiveFunction(ConfirmCallback);
  332. }
  335. //============================================================================
  336. void CBTSCT::REQ_Start(S_BT_SCT &bt_sct)
  337. {
  338.     gs_bt_sct_ptr  = this;
  339.     g_bIsRunning    = true;
  341.     m_sBTSCT = bt_sct;
  343.     ResetBVarData();
  345.     for (m_IterScript = m_pvScript->begin(); m_IterScript != m_pvScript->end(); m_IterScript++)
  346.     {
  347.         if (m_IterScript->as_script_name.AnsiCompareIC(m_sBTSCT.as_script_name) == 0)
  348.         {
  349.             break;
  350.         }
  351.     }
  353.     m_IterCmd = m_IterScript->v_cmd.begin();
  354.     ActiveMan->SetActiveFunction(::REQ_Test_Script);
  355. }
  357. //---------------------------------------------------------------------------
  358. void CBTSCT::REQ_Test_Script(void)
  359. {
  360.     if (!g_bIsRunning)
  361.     {
  362.         return;
  363.     }
  365.     if (m_IterCmd != m_IterScript->v_cmd.end())
  366.     {
  367.         m_IterEvent = m_IterCmd->v_hci_event.begin();
  368.         BT_HCI_COMMAND hci_cmd;
  370.         InterpretCommand(m_IterCmd->as_hci_cmd, hci_cmd);
  371.         REQ_Send_HCI_Command(hci_cmd, m_IterCmd->ui_ms_timeout, m_IterCmd->uc_last_event);
  372.         m_IterCmd++;
  373.     }
  374.     else
  375.     {
  376.         Confirm(METAAPP_SUCCESS);
  377.     }
  378. }
  380. //---------------------------------------------------------------------------
  381. void CBTSCT::REQ_Send_HCI_Command( BT_HCI_COMMAND hci_cmd, unsigned int  ms_timeout, unsigned last_event )
  382. {
  383.     if (!g_bIsRunning)
  384.     {
  385.         return;
  386.     }
  387.     AddTxLogToStringList(hci_cmd);
  388.     META_RESULT MetaResult = META_BT_SendHCICommand_r(m_META_HANDLE_Obj.Get_MainHandle(), ms_timeout, &hci_cmd, ::CNF_HCIEvent, NULL, last_event);
  390.     if (META_SUCCESS != MetaResult)
  391.     {
  392.         if (META_TIMEOUT == MetaResult)
  393.         {
  394.             Confirm(METAAPP_TIMEOUT);
  395.             return;
  396.         }
  397.         else if (META_CANCEL == MetaResult)
  398.         {
  399.             Confirm(METAAPP_CANCEL);
  400.             return;
  401.         }
  402.         else
  403.         {
  404.             Confirm(METAAPP_FAIL);
  405.             return;
  406.         }
  407.     }
  408. }
  410. //---------------------------------------------------------------------------
  411. void __stdcall CBTSCT::CNF_HCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  412. {
  413.    // if(!g_bIsRunning)  return;
  414.    // m_IterEvent
  415.     m_sHCIEvent = *cnf;
  416.     AddRxLogToStringList(*cnf);
  417.     if (!InterpretEvent(m_sHCIEvent, *m_IterEvent))
  418.     {
  419.         AddParseLogToStringList("Receive unexpected event");
  420.         Confirm(METAAPP_FAIL);
  421.         return;
  422.     }
  424.     if (m_IterEvent != m_IterCmd->v_hci_event.end())
  425.     {
  426.         m_IterEvent++;
  427.     }
  428.     ActiveMan->SetActiveFunction(::REQ_Test_Script);
  429. }
  432. //===========================================================================
  433. void CBTSCT::REQ_Read_From_File_Start(S_BT_SCT &bt_sct)
  434. {
  435.     gs_bt_sct_ptr  = this;
  436.     g_bIsRunning    = true;
  438.     m_sBTSCT = bt_sct;
  441.     EraseVector();
  442.     ActiveMan->SetActiveFunction(::REQ_Read_From_File);
  443. }
  445. //----------------------------------------------------------------------------
  446. bool CBTSCT::REQ_Read_Last_SCT_File_Start(S_BT_SCT &bt_sct)
  447. {
  448.      m_sBTSCT = bt_sct;
  450.      EraseVector();
  452.     if (!OpenFile())
  453.     {
  454.         CloseFile();
  455.         return false;
  456.     }
  458.     if (!ParseFile())
  459.     {
  460.         CloseFile();
  461.         return false;
  462.     }
  464.     CloseFile();
  465.     return true;
  466. }
  468. //----------------------------------------------------------------------------
  469. void CBTSCT::REQ_Read_From_File(void)
  470. {
  471.     if (!g_bIsRunning)
  472.     {
  473.         return;
  474.     }
  475.     if (!OpenFile())
  476.     {
  477.         CloseFile();
  478.         Confirm( METAAPP_FAIL );
  479.         return;
  480.     }
  482.     if (!ParseFile())
  483.     {
  484.         CloseFile();
  485.         Confirm(METAAPP_FAIL);
  486.         return;
  487.     }
  489.     CloseFile();
  490.     Confirm(METAAPP_SUCCESS);
  491. }
  493. //----------------------------------------------------------------------------
  494. bool  CBTSCT::OpenFile(void)
  495. {
  496.    // if( m_ifs.is_open() )
  497.    // {
  498.    //     CloseFile();
  499.    // }
  500.     if (!CheckFileExist(m_sBTSCT.filename))
  501.     {
  502.         return false;
  503.     }
  505.     m_pifs = new ifstream;
  506.     m_pifs->open(m_sBTSCT.filename.c_str());
  507.     //m_ifs.seekg( ios::beg );
  508.         //m_ifs.setmode( filebuf::text ); // set to text mode
  509.     //m_pFBuf = m_ifs.rdbuf();
  511.     return true;
  512. }
  514. //---------------------------------------------------------------------------
  515. void CBTSCT::CloseFile(void)
  516. {
  517.     if (m_pifs->is_open())
  518.     {
  519.         m_pifs->close();
  520.         delete m_pifs;
  521.     }
  522. }
  524. //---------------------------------------------------------------------------
  525. bool CBTSCT::ParseFile(void)
  526. {
  527.     const int str_size = 256;
  528.     char str[str_size];
  529.     m_eSCTSec = BT_SCT_UNKNOW;
  530.     while (!m_pifs->eof())
  531.     {
  532.         m_pifs->getline(str, str_size, 'n');
  533.         if (!ParseCommandLine(str))
  534.         {
  535.             AnsiString as_str = str;
  536.             AddParseLogToStringList(as_str + " error");
  537.             return false;
  538.         }
  539.        // streampos pos = m_ifs.tellg();
  540.        // m_ifs.tellg();
  541.     }
  542.     return true;
  543. }
  545. //---------------------------------------------------------------------------
  546. bool CBTSCT::ParseCommandLine(AnsiString as_cmd)
  547. {
  548.     bool ok;
  549.     as_cmd = as_cmd.UpperCase();
  550.     as_cmd = as_cmd.Trim();
  551.     if (as_cmd.AnsiCompareIC("") == 0)
  552.     {
  553.         return true;  // NULL
  554.     }
  555.     if (as_cmd.AnsiPos("//") != 0)
  556.     {
  557.         return true; // note
  558.     }
  559.     for (int i=0; i<sizeof(HEADER_WORD)/sizeof(HEADER_WORD[0]); i++)
  560.     {
  561.         if (as_cmd.AnsiPos(HEADER_WORD[i] ) != 0)
  562.         {
  563.             m_eSCTSec = (E_BT_SCT_TAG) i;
  564.             bool ok = ParseSCTHeader(as_cmd);
  565.             {
  566.                 return ok;
  567.             }
  568.         }
  569.     }
  571.     ok = ParseSCTBody(as_cmd);
  572.     return ok;
  573. }
  575. //---------------------------------------------------------------------------
  576. AnsiString CBTSCT::Get_ScriptTagString(E_BT_SCT_TAG eTag)
  577. {
  578.     AnsiString as_tag;
  579.     if ((eTag >= BT_SCT_B1_TAG) && (eTag <= BT_SCT_B49_TAG))
  580.     {
  581.         as_tag = "B" + IntToStr(eTag + 1);
  582.     }
  583.     return as_tag;
  584. }
  586. //---------------------------------------------------------------------------
  587. bool CBTSCT::ParseSCTHeader(AnsiString as_cmd)
  588. {
  589.     S_BT_SCT_SCRIPT script;
  590.     int iLD_l = as_cmd.AnsiPos(": ");
  591.     if (iLD_l != 0)
  592.     {
  593.         script.as_script_name = as_cmd.SubString(iLD_l+2, as_cmd.Length()-iLD_l-1);
  594.         RemoveLastSpaceFromStr(script.as_script_name);
  595.         if ((m_eSCTSec >= BT_SCT_B1_TAG) && (m_eSCTSec <= BT_SCT_B49_TAG))
  596.         {
  597.             script.as_script_tag = Get_ScriptTagString(m_eSCTSec);
  598.         }
  599.         m_pvScript->push_back(script);
  600.     }
  601.     else
  602.     {
  603.         S_BT_SCT_OP op;
  604.         AnsiString as_rem;
  605.         int iLD_space = as_cmd.LastDelimiter( " " );
  606.         int iLD_comma = as_cmd.AnsiPos( "," );
  607.         if( iLD_comma != 0 )
  608.         {
  609.             if( iLD_comma > iLD_space )
  610.             {
  611.                 op.as_op2 = as_cmd.SubString( iLD_comma+1, as_cmd.Length()-iLD_comma );
  613.             }
  614.             else
  615.             {
  616.                 op.as_op2 = as_cmd.SubString( iLD_space+1, as_cmd.Length()-iLD_space );
  617.             }
  618.             as_rem = as_cmd.SubString( 1, iLD_comma-1 );
  619.             iLD_space = as_rem.LastDelimiter( " " );
  620.             op.as_op1 = as_rem.SubString( iLD_space+1, as_cmd.Length()-iLD_space );
  621.         }
  622.         else // no op2
  623.         {
  624.             if( as_cmd.AnsiPos(""") == 0 ) // no " "
  625.             {
  626.                 op.as_op1 = as_cmd.SubString( iLD_space+1, as_cmd.Length() - iLD_comma );
  627.                 as_rem = as_cmd;
  628.             }
  629.             else
  630.             {
  631.                 int iLD_1stQuotes = as_cmd.AnsiPos(""");
  632.                 int iLD_2ndQuotes = as_cmd.LastDelimiter(""");
  633.                 op.as_op1 = as_cmd.SubString( iLD_1stQuotes+1, iLD_2ndQuotes - iLD_1stQuotes -1 );
  634.                 as_rem = as_cmd.SubString( 1, iLD_1stQuotes - 1 );
  635.             }
  636.             op.as_op2 = "";
  637.         }
  639.         switch( m_eSCTSec )
  640.         {
  641.             case BT_SCT_B_TAG:                    // "B",
  642.             {
  643.                 S_BT_B_VAR b_var;
  644.                 b_var.as_name = op.as_op1;
  645.                 if( op.as_op2.AnsiCompareIC("") == 0 )
  646.                 {
  647.                   //  b_var.uc_value = 0;
  648.                     b_var.b_valid  = false;
  649.                 }
  650.                 else
  651.                 {
  652.                     AnsiString_Hex_To_UnsignedChar( op.as_op2, b_var.uc_value );
  653.                     b_var.b_valid   = true;
  654.                 }
  655.                 m_pvBVar->push_back( b_var );
  656.             }
  657.             break;
  659.             case BT_SCT_W_TAG:                    // "W",
  660.             {
  661.                 S_BT_W_VAR w_var;
  662.                 w_var.as_name = op.as_op1;
  663.                 if( op.as_op2.AnsiCompareIC("") == 0 )
  664.                 {   w_var.us_value = 0;
  665.                 }
  666.                 else
  667.                 {
  668.                     AnsiString_Hex_To_UnsignedShort( op.as_op2, w_var.us_value );
  669.                 }
  670.                 m_pvWVar->push_back( w_var );
  671.             }
  672.             break;
  674.             case BT_SCT_D_TAG:                    // "D",
  675.             {
  676.                 S_BT_D_VAR d_var;
  677.                 d_var.as_name = op.as_op1;
  678.                 if( op.as_op2.AnsiCompareIC("") == 0 )
  679.                 {   d_var.ui_value = 0;
  680.                 }
  681.                 else
  682.                 {
  683.                     AnsiString_Hex_To_UnsignedInt( op.as_op2, d_var.ui_value );
  684.                 }
  685.                 m_pvDVar->push_back( d_var );
  686.             }
  687.             break;
  688.         } // switch()
  689.     } // else
  691.     return true;
  692. }
  694. //---------------------------------------------------------------------------
  695. bool CBTSCT::ParseSCTBody( AnsiString as_cmd )
  696. {
  697.     vector<S_BT_SCT_SCRIPT>:: iterator iter_script = m_pvScript->end()-1;
  698.     vector<S_BT_SCT_CMD>:: iterator iter_cmd = iter_script->v_cmd.end()-1;
  699.     S_BT_SCT_CMD cmd;
  700.     int i;
  701.     unsigned char array[HCI_CMD_MAX_LEN];
  702.    // for( i=0; i<HCI_CMD_MAX_LEN; i++ )
  703.    //     cmd.s_hci_cmd.m_cmd[i] = 0;
  705.     if( as_cmd.AnsiPos("TX:") != 0 )
  706.     {
  707.         int iLD_l = as_cmd.AnsiPos("TX:");
  708.         AnsiString as_TX_cmd = as_cmd.SubString( iLD_l+4, as_cmd.Length() );
  709.        // if( ! InterpretCommand( as_TX_cmd ) )
  710.        //     return false;
  711.        // int count = String_Hex_To_Array_UnsignedChar( as_TX_cmd.c_str(), array, HCI_CMD_MAX_LEN );
  712.        // cmd.s_hci_cmd.m_opcode = (array[HCI_CMD_OPCODE_HIGH_IDX] << 8) | array[HCI_CMD_OPCODE_LOW_IDX];
  713.        // cmd.s_hci_cmd.m_len    =  array[HCI_CMD_LEN_IDX];
  714.        // for( i=HCI_CMD_PARAMETER_START_IDX; i<count; i++ )
  715.        // {   cmd.s_hci_cmd.m_cmd[i-HCI_CMD_PARAMETER_START_IDX] = array[i];
  716.        // }
  717.        // cmd.s_hci_cmd.m_opcode = Get_OpCode( as_TX_cmd );
  718.        // cmd.s_hci_cmd.m_len    = Get_CommandParameterLen( as_TX_cmd );
  719.         cmd.as_hci_cmd = as_TX_cmd;
  720.         iter_script->v_cmd.push_back( cmd );
  721.     }
  722.     else if( as_cmd.AnsiPos("RX:") != 0 )
  723.     {
  724.         //BT_HCI_EVENT event;
  725.         int iLD_l = as_cmd.AnsiPos("RX:");
  726.         AnsiString as_RX_event = as_cmd.SubString( iLD_l+4, as_cmd.Length() ).Trim();
  727.        // if( ! InterpretCommand( as_RX_event ) )
  728.        //     return false;
  729.        // int count = String_Hex_To_Array_UnsignedChar( as_RX_event.c_str(), array, HCI_CMD_MAX_LEN );
  730.        // event.m_event = array[HCI_EVENT_ID_IDX];
  731.        // event.m_len   = array[HCI_EVENT_LEN_IDX];
  732.        // for( i=HCI_EVENT_PARAMETER_START_IDX; i<count; i++ )
  733.        // {   event.m_parms[i-HCI_EVENT_PARAMETER_START_IDX] = array[i];
  734.        // }
  735.         //vector<BT_HCI_EVENT>:: iterator iter_event = iter_cmd->v_hci_event.end()-1;
  736.         //event.m_event = Get_LastEvent( as_RX_event );
  737.         //event.m_len   = Get_EventParameterLen( as_RX_event );
  738.         iter_cmd->uc_last_event = Get_LastEvent( as_RX_event );
  739.         iter_cmd->ui_ms_timeout = 20000;
  740.         iter_cmd->v_hci_event.push_back( as_RX_event );
  741.     }
  743.     return true;
  744. }
  746. //---------------------------------------------------------------------------
  747. bool  CBTSCT::InterpretCommand( AnsiString as_cmd, BT_HCI_COMMAND &hci_cmd )
  748. {
  749.     bool b_find;
  750.     vector<S_BT_B_VAR>:: iterator iter_b_var;
  751.     unsigned char array[HCI_CMD_MAX_LEN];
  752.     int count = ::Get_CharAppearCount( as_cmd, '&' );
  753.     AnsiString as_var_name;
  754.     for(int i=0; i<count; i++ )
  755.     {
  756.         b_find = false;
  757.         int iLD_l = Get_CharAppearPosition( as_cmd, '&', 1 );;
  758.         int iLD_r = Get_CharAppearPosition( as_cmd, '&', ',', 1 );
  759.         if( iLD_r < iLD_l )
  760.         {
  761.             iLD_r = as_cmd.Length()+1;
  762.         }
  764.         as_var_name = as_cmd.SubString( iLD_l+1, iLD_r-iLD_l-1 );
  767.         for( iter_b_var = m_pvBVar->begin(); iter_b_var != m_pvBVar->end(); iter_b_var++ )
  768.         {
  769.             if( iter_b_var->as_name.AnsiCompareIC(as_var_name) == 0 )
  770.             {
  771.                 char str_value[HCI_CMD_MAX_LEN];
  772.                 sprintf( str_value, "%X", iter_b_var->uc_value );
  773.                 AnsiString as_value(str_value);
  774.                 as_cmd = as_cmd.SubString(1, iLD_l-1) + as_value + as_cmd.SubString(iLD_r, as_cmd.Length()-iLD_r+1);
  775.                 b_find = true;
  776.                 break;
  777.             }
  778.         }
  780.         if( ! b_find )
  781.             return false;
  783.        // String_Hex_To_Array_UnsignedChar( as_cmd.c_str(), hci_cmd.m_cmd, HCI_CMD_MAX_LEN );
  785.     }  // for
  787.     hci_cmd.m_opcode = Get_OpCode( as_cmd );
  788.     hci_cmd.m_len    = Get_CommandParameterLen( as_cmd );
  789.     count = AnsiString_Hex_To_Array_UnsignedChar( as_cmd.c_str(), array, HCI_CMD_MAX_LEN, ',' );
  790.     for( int i=0; i<hci_cmd.m_len; i++ )
  791.     {   hci_cmd.m_cmd[i] = array[i+HCI_CMD_PARAMETER_START_IDX];
  792.     }
  794.     return true;
  795. }
  797. //---------------------------------------------------------------------------
  798. bool  CBTSCT::InterpretEvent( BT_HCI_EVENT hci_event, AnsiString as_event )
  799. {
  800.     bool b_find;
  801.     AnsiString as_var_name;
  802.     vector<S_BT_B_VAR>:: iterator iter_b_var;
  803.     unsigned char str[2*HCI_CMD_MAX_LEN+1];
  804.     int count = ::Get_CharAppearCount( as_event, '&' );
  805.     for(int i=0; i<count; i++ )
  806.     {
  807.         b_find = false;
  808.         int iLD_l = Get_CharAppearPosition( as_event, '&', 1 );;
  809.         int iLD_r = Get_CharAppearPosition( as_event, '&', ',', 1 );
  810.         if( iLD_r < iLD_l )
  811.         {
  812.             iLD_r = as_event.Length()+1;
  813.         }
  815.         as_var_name = as_event.SubString( iLD_l+1, iLD_r-iLD_l-1 );
  818.         for( iter_b_var = m_pvBVar->begin(); iter_b_var != m_pvBVar->end(); iter_b_var++ )
  819.         {
  820.             if( iter_b_var->as_name.AnsiCompareIC(as_var_name) == 0 )
  821.             {
  822.                // as_event = as_event.SubString(1, iLD_l-1) + IntToStr(iter_b_var->uc_value) + as_event.SubString(iLD_r, as_event.Length()-iLD_r+1);
  823.                 int count_seq = Get_CharAppearCount( as_event, ',' );
  824.                 int index = Get_VariableIndex( as_event, as_var_name, count_seq+1  );
  825.                 if( index < 0 )
  826.                     return false;
  827.                 if( ! iter_b_var->b_valid )
  828.                 {
  829.                     iter_b_var->uc_value = hci_event.m_parms[index-HCI_EVENT_PARAMETER_START_IDX];
  830.                     iter_b_var->b_valid  = true;
  831.                 }
  832.                 else
  833.                 {
  834.                     if( iter_b_var->uc_value != hci_event.m_parms[index-HCI_EVENT_PARAMETER_START_IDX] )
  835.                         return false;
  836.                 }
  837.                 char str_value[HCI_CMD_MAX_LEN];
  838.                 sprintf( str_value, "%X", iter_b_var->uc_value );
  839.                 AnsiString as_value(str_value);
  840.                 as_event = as_event.SubString(1, iLD_l-1) + as_value + as_event.SubString(iLD_r, as_event.Length()-iLD_r+1);
  841.                 b_find = true;
  842.                 break;
  843.             }
  844.         }
  846.         if( ! b_find )
  847.             return false;
  849.     }  // for
  851.     AnsiString_Hex_To_Array_UnsignedChar( as_event.c_str(), str, HCI_CMD_MAX_LEN, ','  );
  853.     if( str[HCI_EVENT_ID_IDX] != hci_event.m_event )   return false;
  854.     if( str[HCI_EVENT_LEN_IDX]!= hci_event.m_len )     return false;
  855.     for( int i=0; i<hci_event.m_len; i++ )
  856.     {
  857.         if( str[HCI_EVENT_PARAMETER_START_IDX+i] != hci_event.m_parms[i] )
  858.             return false;
  859.     }        
  860.     //sprintf( str, "%X,", hci_event.m_event );
  861.     //AnsiString as_last_event( str );
  862.     //sprintf( str, "%X,", hci_event.m_len );
  863.     //AnsiString as_par_len( str );
  864.     //Array_To_Hex_String_UnsignedChar( str, hci_event.m_parms, hci_event.m_len, ',' );
  865.     //AnsiString as_par( (const char*) str );
  866.     //AnsiString as_receive_event = as_last_event + as_par_len + as_par;
  868.    // if( as_receive_event.AnsiCompareIC(as_event) != 0 )
  869.    //     return false;
  870.   //  int count = ::Get_CharAppearCount( as_cmd, '&' );
  871.   //  for(int i=0; i<count; i++ )
  872.   //  {
  873.   //  }
  875.     return true;
  876. }
  878. //---------------------------------------------------------------------------
  879. unsigned short CBTSCT::Get_OpCode( AnsiString as_cmd )
  880. {
  881.     unsigned short opcode;
  882.     unsigned short opcode_low, opcode_hi;
  883.     AnsiString as_opcode_low, as_opcode_hi;
  884.     int iLD = as_cmd.AnsiPos(",");
  885.     as_opcode_low = as_cmd.SubString( 1, iLD-1 );
  886.     AnsiString_Hex_To_UnsignedShort( as_opcode_low, opcode_low );
  887.     as_cmd = as_cmd.SubString( iLD+1, as_cmd.Length() );
  888.     iLD = as_cmd.AnsiPos(",");
  889.     as_opcode_hi = as_cmd.SubString( 1, iLD-1 );
  890.     AnsiString_Hex_To_UnsignedShort( as_opcode_hi, opcode_hi );
  891.     opcode = ((opcode_hi & 0x00FF) << 8) | (opcode_low & 0x00FF);
  892.     return opcode;
  893. }
  895. //---------------------------------------------------------------------------
  896. unsigned char CBTSCT::Get_CommandParameterLen( AnsiString as_cmd )
  897. {
  898.     unsigned char len;
  899.     int iLD;
  900.     for(int i=0; i<2; i++ )
  901.     {
  902.         iLD = as_cmd.AnsiPos(",");
  903.         as_cmd = as_cmd.SubString( iLD+1, as_cmd.Length() );
  904.     }
  905.     iLD = as_cmd.AnsiPos(",");
  906.     AnsiString as_len = as_cmd.SubString( 1, iLD-1 );
  907.     AnsiString_Hex_To_UnsignedChar( as_len, len );
  909.     return len;
  910. }
  912. //---------------------------------------------------------------------------
  913. unsigned char CBTSCT::Get_LastEvent( AnsiString as_event )
  914. {
  915.     unsigned char last_event;
  916.     int iLD = as_event.AnsiPos(",");
  917.     AnsiString as_last_event = as_event.SubString( 1, iLD-1 );
  918.     AnsiString_Hex_To_UnsignedChar( as_last_event, last_event );
  920.     return last_event;
  921. }
  923. //---------------------------------------------------------------------------
  924. unsigned char CBTSCT::Get_EventParameterLen( AnsiString as_event )
  925. {
  926.     unsigned char len;
  927.     int iLD = as_event.AnsiPos(",");
  928.     as_event = as_event.SubString( iLD+1, as_event.Length() );
  929.     iLD = as_event.AnsiPos(",");
  930.     AnsiString as_len = as_event.SubString( 1, iLD-1 );
  931.     AnsiString_Hex_To_UnsignedChar( as_len, len );
  933.     return len;
  934. }
  936. //---------------------------------------------------------------------------
  937. int CBTSCT::Get_VariableIndex( AnsiString as, AnsiString as_var, unsigned char len )
  938. {
  939.    // unsigned char str[2*HCI_CMD_MAX_LEN+1];
  940.    // String_Hex_To_Array_UnsignedChar( as.c_str(), str, len  );
  941.     int index = -1;
  942.     AnsiString as_temp;
  943.     for( int i=0; i<len; i++ )
  944.     {
  945.         int iLD = as.AnsiPos(",");
  946.         if( iLD < 1 )
  947.             iLD = as.Length()+1;
  948.         as_temp = as.SubString( 1, iLD-1 );
  949.         as = as.SubString(iLD+1, as.Length()-iLD);
  950.         if( as_temp.AnsiPos("&") != 0 )
  951.         {
  952.             iLD = as_temp.AnsiPos("&");
  953.             as_temp = as_temp.SubString(iLD+1, as_temp.Length()-iLD).Trim();
  954.             if( as_temp.AnsiCompareIC(as_var) == 0 )
  955.             {
  956.                 index = i;
  957.                 break;
  958.             }
  959.         }
  961.     }
  963.     return index;
  964. }
  965. //===========================================================================
  966. ////////////////////////////   Log  information   ////////////////////////
  967. //===========================================================================
  968. void CBTSCT::AddParseLogToStringList(AnsiString as_log)
  969. {
  970.     m_sBTSCT.log->Add(as_log);
  971.     PostMessage(
  972.                          m_sBTSCT.hPostMsgDestHandle,
  973.                          WM_ML_BT_PRINT_MSG,
  974.                          PAGEIDX_BT_SCT,
  975.                          0
  976.                         );
  977. }
  979. //----------------------------------------------------------------------------
  980. void  CBTSCT::AddTxLogToStringList(BT_HCI_COMMAND hci_cmd)
  981. {
  982. #if 0
  983.     unsigned char        str[1024];
  984.     Array_To_Hex_String_UnsignedChar( str, hci_cmd.m_cmd, hci_cmd.m_len, ',' );
  985.     AnsiString as_cmd( (const char*)str );
  986.     AnsiString as_log = "[" + TimeToStr(Time()) + "] TX: " + as_cmd;
  987. #endif
  989.     char        str[1024];
  990.     AnsiString as_log;
  991.     sprintf( str, "%X,", hci_cmd.m_opcode & 0x00FF );
  992.     AnsiString as_opcode_low(str);
  993.     sprintf( str, "%X,", (hci_cmd.m_opcode & 0xFF00)>>8 );
  994.     AnsiString as_opcode_high(str);
  995.     Array_To_Hex_String_UnsignedChar( str, hci_cmd.m_cmd, hci_cmd.m_len, ',' );
  996.     AnsiString as_cmd( (const char*)str );
  997.     if( 0 == hci_cmd.m_len )
  998.        as_cmd = "";
  999.     sprintf( str, "%X,", hci_cmd.m_len );
  1000.     AnsiString as_length(str);
  1003.     as_log = "[" + TimeToStr(Time()) + "] TX: " + as_opcode_low + as_opcode_high + as_length  + as_cmd;
  1004.     m_sBTSCT.log->Add( as_log );
  1006.     PostMessage(
  1007.                          m_sBTSCT.hPostMsgDestHandle,
  1008.                          WM_ML_BT_PRINT_MSG,
  1009.                          PAGEIDX_BT_SCT,
  1010.                          0
  1011.                         );
  1012. }
  1014. //--------------------------------------------------------------------------
  1015. void  CBTSCT::AddRxLogToStringList(BT_HCI_EVENT hci_event)
  1016. {
  1017. #if 0
  1018.     unsigned char        str[1024];
  1019.     Array_To_Hex_String_UnsignedChar( str, hci_event.m_parms, hci_event.m_len, ',' );
  1020.     AnsiString as_event( (const char*) str );
  1021.     AnsiString as_log = "[" + TimeToStr(Time()) + "] RX: " + as_event;
  1022. #endif
  1024.     unsigned char        str[1024];
  1025.     AnsiString as_log;
  1026.     sprintf( str, "%X,", hci_event.m_event );
  1027.     AnsiString as_event( (const char*) str );
  1028.     sprintf( str, "%X,", hci_event.m_len );
  1029.     AnsiString as_length( (const char*) str );
  1030.     Array_To_Hex_String_UnsignedChar( str, hci_event.m_parms, hci_event.m_len, ',' );
  1031.     AnsiString as_param( (const char*) str );
  1032.     if(  0 == hci_event.m_len )
  1033.         as_param = "";
  1034.         
  1035.     as_log = "[" + TimeToStr(Time()) + "] RX: " + as_event + as_length + as_param;
  1037.     m_sBTSCT.log->Add( as_log );
  1039.     PostMessage(
  1040.                          m_sBTSCT.hPostMsgDestHandle,
  1041.                          WM_ML_BT_PRINT_MSG,
  1042.                          PAGEIDX_BT_SCT,
  1043.                          0
  1044.                         );
  1045. }
  1047. //===========================================================================
  1048. ////////////////////////////   Global  information   ////////////////////////
  1049. //===========================================================================
  1050. E_METAAPP_RESULT_T CBTSCT::Get_ConfirmState(void)
  1051. {
  1052.     return  m_eConfirmState;
  1053. }
  1055. //---------------------------------------------------------------------------
  1056. BT_HCI_EVENT CBTSCT::Get_HCIEvent(void)
  1057. {   return m_sHCIEvent;
  1058. }
  1060. //---------------------------------------------------------------------------
  1061. vector<S_BT_SCT_SCRIPT>*  CBTSCT::Get_ScriptVector( void )
  1062. {
  1063.     return m_pvScript;
  1064. }