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

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

MTK

开发平台：

C++ Builder

bt_mt.cpp：源码内容
  1. #include <windows.h>
  2. #include <dos.h>
  3. #include <stdio.h>
  4. #include <process.h>
  5. #include <dir.h>
  6. #include <string.h>
  7. #include <assert.h>
  9. #pragma hdrstop
  11. #ifndef  _BT_HCI_FT_H_
  12. #include "bt_hci_ft.h"
  13. #endif
  15. #ifndef _BT_MT_H_
  16. #include "bt_mt.h"
  17. #endif
  19. #ifndef _BT_MT_PARSE_H_
  20. #include "bt_mt_Parse.h"
  21. #endif
  23. //=============================================================================
  24. #define  BT_MODULE_TEST_SRCSTR_SIZE  8192
  25. //=============================================================================
  26. static long  GiveDateTime(void);
  27. //=============================================================================
  28. int CBTMT::TimerTick(void)
  29. {
  30.     int ok = ERR_NONE;
  31.     int n;
  33.     Ticks++;
  34.     m_cLogString[0] = 0;
  35.     LogStrPtr = m_cLogString;
  36.     //m_pcHci->rs232.LogString[0] = 0;
  37.     //m_pcHci->rs232.LogStrPtr = m_pcHci->rs232.LogString;
  38.     m_cHciUart.rs232.LogString[0] = 0;
  39.     m_cHciUart.rs232.LogStrPtr = m_cHciUart.rs232.LogString;
  40.     
  41.     //---------------------------------
  42.     if (WaitCounter > 0)
  43.     {
  44.         WaitCounter--;
  45.         goto _process_result;
  46.     }
  48.     //---------------------------------
  49.     if (TimeoutTime > 0)
  50.     {
  51.         TimeoutCounter++;
  52.         if (TimeoutCounter == TimeoutTime)
  53.         {
  54.             ProcFailCount++;
  55.             LogStrPtr += sprintf( LogStrPtr, "Tick Time :%ld n", Ticks );
  56.             LogStrPtr += sprintf( LogStrPtr, "TIMEOUT (%d ms)!! n", (int)(TimeoutCounter*TIMERTICK_UNITE) );
  57.             if (WaitRX != 0)
  58.             {
  59.                 WaitRX = 0;
  60.             }
  61.             ok = ERR_TIMEOUT;
  62.             goto _process_result;  // //goto _process_result;
  63.         }
  64.     }
  66.     //---------------------------------
  67.     if (WaitRX)
  68.     {
  69.         //if (!m_pcHci->rs232.IsRxDataReady())
  70.         if (!m_cHciUart.rs232.IsRxDataReady())
  71.         {
  72.             goto _process_result;
  73.         }
  74.         LogStrPtr += sprintf(LogStrPtr, "Tick Time :%ldn", Ticks );
  75.        // LogStrPtr += sprintf(LogStrPtr, "%s", m_pcHci->rs232.LogString);
  76.         LogStrPtr += sprintf(LogStrPtr, "%s", m_cHciUart.rs232.LogString);
  77.         //m_pcHci->rs232.LogString[0] = 0;
  78.         //m_pcHci->rs232.LogStrPtr = m_pcHci->rs232.LogString;
  79.         m_cHciUart.rs232.LogString[0] = 0;
  80.         m_cHciUart.rs232.LogStrPtr = m_cHciUart.rs232.LogString;
  81.         //if (!m_pcHci->ReadEvent())
  82.         if (!m_cHciUart.ReadEvent())
  83.         {
  84.             LogStrPtr += sprintf(LogStrPtr, "Read HCI m_ucEvent Fail");
  85.             goto _process_result;
  86.         }
  87.         //LogStrPtr += sprintf(LogStrPtr, "%s", m_pcHci->rs232.LogString);
  88.         LogStrPtr += sprintf(LogStrPtr, "%s", m_cHciUart.rs232.LogString);
  89.         WaitRX = 0;
  90.         //if (Parse.CompareEvent(m_pcHci->EventBuf, m_pcHci->EventLen))
  91.         if (Parse.CompareEvent(m_iEventIdx, m_cHciUart.EventBuf, m_cHciUart.EventLen))
  92.         {
  93.             WaitRX = 0;
  94.             LogStrPtr += sprintf(LogStrPtr, "PASS: Compare HCI RX data n");
  95.         }
  96.         else
  97.         {
  98.             if (WaitRX != 2)   // not waiting for some event
  99.             {
  100.                 WaitRX=0;
  101.                 ProcFailCount++;
  102.                 LogStrPtr += sprintf(LogStrPtr, "FAIL: Wrong HCI RX data n");
  103.                 LogStrPtr += sprintf(LogStrPtr, "Pattern : ");
  104.                 for (n = 0; n < Parse.m_iEvtLen[m_iEventIdx]; n++)
  105.                 {
  106.                     LogStrPtr += sprintf(LogStrPtr, "%02X ", Parse.m_ucEvent[n]);
  107.                 }
  108.                 LogStrPtr += sprintf(LogStrPtr, " n");
  109.             }
  110.             LogStrPtr += sprintf(LogStrPtr, "HCI Data:");
  111.             //for (n = 0; n < m_pcHci->EventLen; n++)
  112.             for (n = 0; n < m_cHciUart.EventLen; n++)
  113.             {
  114.                 //LogStrPtr += sprintf(LogStrPtr, "%02X ", m_pcHci->EventBuf[n]);
  115.                 LogStrPtr += sprintf(LogStrPtr, "%02X ", m_cHciUart.EventBuf[n]);
  116.             }
  117.             LogStrPtr += sprintf(LogStrPtr, "n");
  118.             ok = ERR_RXCOMP;
  119.         }
  120.         ProcessResult(ok);
  121.     }
  122.     //---------------------------------
  123.     TimeoutCounter = 0;
  124.     // LogStrPtr += sprintf( LogStrPtr, "Tick Time :%ldn", Ticks );
  125.     ok = ExecuteNextScript();
  127.  _process_result:
  128.    ProcessResult( ok );
  129.    if(LogFs!=0)
  130.       fputs(m_cLogString, LogFs );
  131.    return(ok);
  133. }
  135. //-----------------------------------------------
  136. int CBTMT::ExecuteNextScript(void)
  137. {
  138.     int ok;
  139.     long fpos;
  140.     char str[BT_MODULE_TEST_SRCSTR_SIZE];
  141.     char *p;
  143.     if (RUN_Time < 0)
  144.     {
  145.         RUN_Time = GiveDateTime();
  146.     }
  147.     if (CS_feof(ScrFs))
  148.     {
  149.         CountProcResult();
  150.         CloseScript();
  151.         return(ERR_FILEEND);
  152.     }
  153.     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  154.     LogStrPtr += sprintf(LogStrPtr, "n=> %s", str);
  155.     Parse.PreParseString(m_iEventIdx, str);
  156.     if (IsForceEnd)
  157.     {
  158.         Parse.StrType = STRTYPE_END;
  159.     }
  161.     switch (Parse.StrType)
  162.     {
  163.         case STRTYPE_HCI:
  164.         {
  165.             if ((BT_RS232 == m_eBtTrans[1]) && (2 == Parse.StrValue2))
  166.             {
  167.                 //ok = HciUart[Parse.StrValue2-1].SetTransport(Parse.StrValue, 115200L, 0 );
  168.                 ok = m_cHciUart.SetTransport(m_iComPort, 115200L, 0);
  169.                 if (!ok)
  170.                 {
  171.                     ProcFailCount++;
  172.                     LogStrPtr += sprintf(LogStrPtr, "Open COM%d Fail! n", m_iComPort);
  173.                     return(ERR_HCIOPEN);
  174.                 }
  175.                 // m_pcHci = &(HciUart[Parse.StrValue2-1]);
  176.                 LogStrPtr += sprintf(LogStrPtr, "Open COM%d OK n", m_iComPort);
  177.             }
  178.         }
  179.         break;
  181.         case STRTYPE_LOGPATH:
  182.         {
  183.             strcpy(LogPath, Parse.String);
  184.             mkdir(LogPath);
  185.         }
  186.         break;
  188.         case STRTYPE_TITLE:
  189.         {
  190.         }
  191.         break;
  193.         case STRTYPE_PROCNAME:
  194.         {
  195.             CountProcResult();
  196.         }
  197.         break;
  199.         case STRTYPE_WAITPROCNAME:
  200.         {
  201.             CountProcResult();
  202.             IsWaitProc = 1;
  203.             WaitProcPos = CS_ftell( ScrFs );
  204.         }
  205.         break;
  207.         case STRTYPE_TIMEOUT:
  208.         {
  209.             TimeoutCounter = TimeoutTime = (int)(Parse.StrValue/TIMERTICK_UNITE);
  210.             LogStrPtr += sprintf( LogStrPtr, "Setting TIMEOUT value (%d ms) n", (int)(TimeoutTime*TIMERTICK_UNITE));
  211.         }
  212.         break;
  214.         case STRTYPE_WAIT:
  215.         {
  216.             WaitCounter = WaitTime = (int)(Parse.StrValue/TIMERTICK_UNITE);
  217.             LogStrPtr += sprintf( LogStrPtr, "Waiting %d ms n", (int)(WaitTime*TIMERTICK_UNITE));
  218.         }
  219.         break;
  221.         case STRTYPE_VAR:
  222.         {
  223.             Parse.VarData[Parse.StrValue2] = Parse.StrValue;
  224.             LogStrPtr += sprintf(LogStrPtr, "Set Var[%d] value = %d n", Parse.StrValue2, (int)Parse.VarData[Parse.StrValue2]);
  225.         }
  226.         break;
  228.         case STRTYPE_TX_HCI_CMD:
  229.         {
  230.             E_BT_DEVICE_T bt_device_tx = (E_BT_DEVICE_T) Parse.StrValue2-1;
  231.             m_iEventIdx = 0;
  232.             m_iEventNum = 0;
  233.             m_iAutoEventIdx = 0;
  234.             m_iAutoEventNum = 0;
  235.             BT_META_HCI_T cmd;
  236.             cmd.e_bt_device = (E_BT_DEVICE_T) Parse.StrValue2-1;
  237.             cmd.e_bt_trans[0] = m_eBtTrans[0];
  238.             cmd.e_bt_trans[1] = m_eBtTrans[1];
  239.             // m_pcHci = &(HciUart[Parse.StrValue2-1]);
  240.             if (BT_RS232 == m_eBtTrans[Parse.StrValue2-1])
  241.             {
  242.                 ok = m_cHciMETA.RegAutoCallBack0();
  243.                 if (!ok)
  244.                 {
  245.                     return(ERR_META);
  246.                 }
  247.                 Parse.String2Command();
  248.                 do
  249.                 {
  250.                     fpos = CS_ftell(ScrFs);
  251.                     if (CS_feof(ScrFs))
  252.                     {
  253.                         break;
  254.                     }
  255.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  256.                     Parse.PreParseStringType(str);
  257.                     if (Parse.StrType != STRTYPE_CONTI)
  258.                     {
  259.                         break;
  260.                     }
  261.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  262.                     Parse.PreParseString(m_iEventIdx, str);
  263.                     Parse.String2Command();
  264.                 }while(1);
  265.                 CS_fseek(ScrFs, fpos, SEEK_SET);
  266.                 //ok = m_pcHci->SendCommand(Parse.Command, Parse.CmdLen );
  267.                 ok = m_cHciUart.SendCommand(Parse.Command, Parse.CmdLen);
  268.                 //LogStrPtr += sprintf(LogStrPtr, "%s", m_pcHci->rs232.LogString);
  269.                 LogStrPtr += sprintf(LogStrPtr, "%s", m_cHciUart.rs232.LogString);
  270.                 //m_pcHci->rs232.LogString[0] = 0;
  271.                 m_cHciUart.rs232.LogString[0] = 0;
  272.                 if (ok)
  273.                 {
  274.                     LogStrPtr += sprintf(LogStrPtr, "Send HCI Command OK! n");
  275.                     return(ERR_NONE);
  276.                 }
  277.                 else
  278.                 {
  279.                     LogStrPtr += sprintf(LogStrPtr, "Send HCI Command FAIL!! n");
  280.                     ProcFailCount++;
  281.                     return(ERR_TX);
  282.                 }
  283.             }
  284.             else
  285.             {
  286.                 Parse.String2Command();
  287.                 do
  288.                 {
  289.                     fpos = CS_ftell(ScrFs);
  290.                     if (CS_feof(ScrFs))
  291.                     {
  292.                         break;
  293.                     }
  294.                     //int i = 1;
  295.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  296.                     Parse.PreParseStringType(str);
  297.                     Parse.PreParseString(m_iEventIdx, str);
  298.                     if (STRTYPE_RX_HCI_EVENT == Parse.StrType)
  299.                     {
  300.                         if (bt_device_tx == (E_BT_DEVICE_T) Parse.StrValue2-1)
  301.                         {
  302.                             Parse.String2Event(m_iEventIdx);
  303.                             m_iEventIdx++;
  304.                             m_iEventNum = m_iEventIdx;
  305.                         }
  306.                         else
  307.                         {
  308.                             Parse.String2AutoEvent(m_iAutoEventIdx);
  309.                             m_iAutoEventIdx++;
  310.                             m_iAutoEventNum = m_iAutoEventIdx;
  311.                         }
  312.                     }
  313.                     else if ((STRTYPE_TX_HCI_CMD == Parse.StrType)  ||
  314.                              (STRTYPE_TX_ACL_DATA == Parse.StrType) ||
  315.                              (STRTYPE_TX_SCO_DATA == Parse.StrType) ||
  316.                              (STRTYPE_PROCNAME == Parse.StrType)
  317.                              )
  318.                     {
  319.                         CS_fseek(ScrFs, fpos, SEEK_SET);
  320.                         break;
  321.                     }
  322.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  323.                 }while(1);
  325.                 CBTHCIFT BT_HCI_FT_Obj;
  326.                 BT_HCI_FT_Obj.Reset_HCI_Command(cmd.s_hci_cmd);
  327.                 cmd.s_hci_cmd.m_opcode = (Parse.Command[2] << 8) | Parse.Command[1];
  328.                 cmd.s_hci_cmd.m_len    = Parse.Command[3];
  329.                 for (int i = 0; i < cmd.s_hci_cmd.m_len; i++)
  330.                 {
  331.                     cmd.s_hci_cmd.m_cmd[i] = Parse.Command[4 + i];
  332.                 }
  333.                 cmd.i_event_num = m_iEventNum;
  334.                 for (int event_idx = 0; event_idx < cmd.i_event_num; event_idx++)
  335.                 {
  336.                     cmd.s_hci_event[event_idx].m_event = Parse.m_ucEvent[event_idx][1];
  337.                     cmd.s_hci_event[event_idx].m_len   = Parse.m_ucEvent[event_idx][2];
  338.                     for (int i = 0; i < cmd.s_hci_event[event_idx].m_len; i++)
  339.                     {
  340.                         cmd.s_hci_event[event_idx].m_parms[i] = Parse.m_ucEvent[event_idx][3 + i];
  341.                     }
  342.                 }
  343.                 cmd.i_auto_event_num = m_iAutoEventNum;
  344.                 for (int event_idx = 0; event_idx < cmd.i_auto_event_num; event_idx++)
  345.                 {
  346.                     cmd.s_hci_auto_event[event_idx].m_event = Parse.m_ucAutoEvent[event_idx][1];
  347.                     cmd.s_hci_auto_event[event_idx].m_len   = Parse.m_ucAutoEvent[event_idx][2];
  348.                     for (int i = 0; i < cmd.s_hci_auto_event[event_idx].m_len; i++)
  349.                     {
  350.                         cmd.s_hci_auto_event[event_idx].m_parms[i] = Parse.m_ucAutoEvent[event_idx][3 + i];
  351.                     }
  352.                 }
  353.                 ok = m_cHciMETA.SendCommand(cmd);
  354.                 if (!ok)
  355.                 {
  356.                     ProcFailCount++;
  357.                     LogStrPtr += sprintf(LogStrPtr, "Send HCI command Fail! n");
  358.                     return(ERR_TX);
  359.                 }
  360.             }
  361.         }
  362.         break;
  364.         case STRTYPE_TX_ACL_DATA:
  365.         {
  366.             m_iEventIdx = 0;
  367.             m_iEventNum = 0;
  368.             E_BT_DEVICE_T bt_device_tx = (E_BT_DEVICE_T) Parse.StrValue2-1;
  369.             BT_META_ACL_DATA_T acl_data;
  370.             acl_data.e_bt_device = (E_BT_DEVICE_T) Parse.StrValue2-1;
  371.             acl_data.e_bt_trans[0] = m_eBtTrans[0];
  372.             acl_data.e_bt_trans[1] = m_eBtTrans[1];
  373.             // m_pcHci = &(HciUart[Parse.StrValue2-1]);
  374.             if (BT_RS232 == m_eBtTrans[Parse.StrValue2-1])
  375.             {
  376.                 ok = m_cHciMETA.RegAclRxData0();
  377.                 if (!ok)
  378.                 {
  379.                     return(ERR_META);
  380.                 }
  381.                 Parse.String2TxAclData();
  382.                 do
  383.                 {
  384.                     fpos = CS_ftell(ScrFs);
  385.                     if (CS_feof(ScrFs))
  386.                     {
  387.                         break;
  388.                     }
  389.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  390.                     Parse.PreParseStringType(str);
  391.                     if (Parse.StrType != STRTYPE_CONTI)
  392.                     {
  393.                         break;
  394.                     }
  395.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  396.                     Parse.PreParseString(m_iEventIdx, str);
  397.                     Parse.String2TxAclData();
  398.                 }while(1);
  399.                 CS_fseek(ScrFs, fpos, SEEK_SET);
  400.                 //ok = m_pcHci->SendCommand(Parse.Command, Parse.CmdLen );
  401.                 ok = m_cHciUart.SendCommand(Parse.Command, Parse.CmdLen);
  402.                 //LogStrPtr += sprintf(LogStrPtr, "%s", m_pcHci->rs232.LogString);
  403.                 LogStrPtr += sprintf(LogStrPtr, "%s", m_cHciUart.rs232.LogString);
  404.                 //m_pcHci->rs232.LogString[0] = 0;
  405.                 m_cHciUart.rs232.LogString[0] = 0;
  406.                 if (ok)
  407.                 {
  408.                     LogStrPtr += sprintf(LogStrPtr, "Send HCI Command OK! n");
  409.                     return(ERR_NONE);
  410.                 }
  411.                 else
  412.                 {
  413.                     LogStrPtr += sprintf(LogStrPtr, "Send HCI Command FAIL!! n");
  414.                     ProcFailCount++;
  415.                     return(ERR_TX);
  416.                 }
  417.             }
  418.             else
  419.             {
  420.                 Parse.String2TxAclData();
  421.                 do
  422.                 {
  423.                     fpos = CS_ftell(ScrFs);
  424.                     if (CS_feof(ScrFs))
  425.                     {
  426.                         break;
  427.                     }
  428.                     //int i = 1;
  429.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  430.                     Parse.PreParseStringType(str);
  431.                     Parse.PreParseString(m_iEventIdx, str);
  432.                     if (STRTYPE_RX_HCI_EVENT == Parse.StrType)
  433.                     {
  434.                         if (bt_device_tx == (E_BT_DEVICE_T) Parse.StrValue2-1)
  435.                         {
  436.                             Parse.String2Event(m_iEventIdx);
  437.                             m_iEventIdx++;
  438.                             m_iEventNum = m_iEventIdx;
  439.                         }
  440.                         else
  441.                         {
  442.                             Parse.String2RxAclData();
  443.                         }
  444.                     }
  445.                     else if ((STRTYPE_TX_HCI_CMD == Parse.StrType)  ||
  446.                              (STRTYPE_TX_ACL_DATA == Parse.StrType) ||
  447.                              (STRTYPE_TX_SCO_DATA == Parse.StrType) ||
  448.                              (STRTYPE_PROCNAME == Parse.StrType))
  449.                     {
  450.                         CS_fseek(ScrFs, fpos, SEEK_SET);
  451.                         break;
  452.                     }
  453.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  454.                 }while(1);
  456.                 //CBTHCIFT BT_HCI_FT_Obj;
  457.                 //BT_HCI_FT_Obj.Reset_HCI_Command(acl_data.s_tx_acl_data);
  458.                 acl_data.s_tx_acl_data.m_con_hdl = (Parse.m_ucTxAclData[2] << 8) | Parse.m_ucTxAclData[1];
  459.                 acl_data.s_tx_acl_data.m_len    = Parse.m_ucTxAclData[3] | (Parse.m_ucTxAclData[4] << 8);
  460.                 for (int i = 0; i < acl_data.s_tx_acl_data.m_len; i++)
  461.                 {
  462.                     acl_data.s_tx_acl_data.m_buffer[i] = Parse.m_ucTxAclData[5 + i];
  463.                 }
  464.                 acl_data.i_event_num = m_iEventNum;
  465.                 for (int event_idx = 0; event_idx < acl_data.i_event_num; event_idx++)
  466.                 {
  467.                     acl_data.s_hci_event[event_idx].m_event = Parse.m_ucEvent[event_idx][1];
  468.                     acl_data.s_hci_event[event_idx].m_len   = Parse.m_ucEvent[event_idx][2];
  469.                     for (int i = 0; i < acl_data.s_hci_event[event_idx].m_len; i++)
  470.                     {
  471.                         acl_data.s_hci_event[event_idx].m_parms[i] = Parse.m_ucEvent[event_idx][3 + i];
  472.                     }
  473.                 }
  475.                 ok = m_cHciMETA.SendAclData(acl_data);
  476.                 if (!ok)
  477.                 {
  478.                     ProcFailCount++;
  479.                     LogStrPtr += sprintf(LogStrPtr, "Send HCI command Fail! n");
  480.                     return(ERR_TX);
  481.                 }
  482.             }
  483.         }
  484.         break;
  486.         case STRTYPE_RX_HCI_EVENT:
  487.         {
  488.             if (BT_RS232 == m_eBtTrans[Parse.StrValue2-1])
  489.             {
  490.                 // m_pcHci = &(HciUart[Parse.StrValue2-1]);
  491.                 Parse.String2Event(m_iEventIdx);
  492.                 m_iEventIdx++;
  493.                 m_iAutoEventNum = m_iEventIdx;
  494.                 do
  495.                 {
  496.                     fpos = CS_ftell(ScrFs);
  497.                     if (CS_feof(ScrFs))
  498.                     {
  499.                         break;
  500.                     }
  501.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  502.                     ok = Parse.PreParseStringType(str);
  503.                     if (!ok)
  504.                     {
  505.                         return(ERR_PARSESTR);
  506.                     }
  507.                     if (Parse.StrType != STRTYPE_CONTI)
  508.                     {
  509.                         break;
  510.                     }
  511.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  512.                     Parse.PreParseString(m_iEventIdx, str);
  513.                     Parse.String2Event(m_iEventIdx);
  514.                 }while(1);
  515.                 CS_fseek(ScrFs, fpos, SEEK_SET);
  516.                 LogStrPtr += sprintf(LogStrPtr, "Waiting for HCI Data...... n");
  517.                 WaitRX = 1;
  518.             }
  519.             else
  520.             {
  521.                 Parse.String2AutoEvent(m_iAutoEventIdx);
  522.                 BT_META_HCI_T cmd;
  523.                 cmd.i_auto_event_num = m_iAutoEventNum;
  524.                 cmd.s_hci_auto_event[m_iAutoEventIdx].m_event = Parse.m_ucAutoEvent[m_iAutoEventIdx][1];
  525.         cmd.s_hci_auto_event[m_iAutoEventIdx].m_len = Parse.m_ucAutoEvent[m_iAutoEventIdx][2];
  526.                 for (int i = 0; i < cmd.s_hci_auto_event[m_iAutoEventIdx].m_len; i++)
  527.                 {
  528.             cmd.s_hci_auto_event[m_iAutoEventIdx].m_parms[i] = Parse.m_ucAutoEvent[m_iAutoEventIdx][3 + i];
  529.                 }
  530.                 m_cHciMETA.Set_HciCmd(cmd);
  531.                 m_iAutoEventIdx++;
  532.                 m_iAutoEventNum = m_iAutoEventIdx;
  533.                 do
  534.                 {
  535.                     fpos = CS_ftell(ScrFs);
  536.                     if (CS_feof(ScrFs))
  537.                     {
  538.                         break;
  539.                     }
  540.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  541.                     ok = Parse.PreParseStringType(str);
  542.                     if (!ok)
  543.                     {
  544.                         return(ERR_PARSESTR);
  545.                     }
  546.                     if (Parse.StrType != STRTYPE_CONTI)
  547.                     {
  548.                         break;
  549.                     }
  550.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  551.                     Parse.PreParseString(m_iEventIdx, str);
  552.                     Parse.String2Event(m_iEventIdx);
  553.                 }while(1);
  554.                 CS_fseek(ScrFs, fpos, SEEK_SET);
  555.                 LogStrPtr += sprintf(LogStrPtr, "Waiting for HCI Data...... n");
  556.                 WaitRX = 1;
  557.                 while (!m_cHciMETA.Get_CallAutoCallback(Parse.StrValue2-1))
  558.                 {
  559.                     Sleep(100);
  560.                 }
  561.                 ok = m_cHciMETA.Get_EventOk();
  562.                 if (!ok)
  563.                 {
  564.                     ProcFailCount++;
  565.                     LogStrPtr += sprintf(LogStrPtr, "Receive HCI event Fail! n");
  566.                     return(ERR_RXCOMP);
  567.                 }
  568.                 WaitRX = 0;
  569.             }
  570.         }
  571.         break;
  573.         case STRTYPE_RX_ACL_DATA:
  574.         {
  575.             if (BT_RS232 == m_eBtTrans[Parse.StrValue2-1])
  576.             {
  577.                 Parse.String2RxAclData();
  578.                 do
  579.                 {
  580.                     fpos = CS_ftell(ScrFs);
  581.                     if (CS_feof(ScrFs))
  582.                     {
  583.                         break;
  584.                     }
  585.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  586.                     ok = Parse.PreParseStringType(str);
  587.                     if (!ok)
  588.                     {
  589.                         return(ERR_PARSESTR);
  590.                     }
  591.                     if (Parse.StrType != STRTYPE_CONTI)
  592.                     {
  593.                         break;
  594.                     }
  595.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  596.                     Parse.PreParseString(m_iEventIdx, str);
  597.                     Parse.String2RxAclData();
  598.                 }while(1);
  599.                 CS_fseek(ScrFs, fpos, SEEK_SET);
  600.                 LogStrPtr += sprintf(LogStrPtr, "Waiting for HCI Data...... n");
  601.                 WaitRX = 1;
  602.             }
  603.             else
  604.             {
  605.                 Parse.String2RxAclData();
  606.                 do
  607.                 {
  608.                     fpos = CS_ftell(ScrFs);
  609.                     if (CS_feof(ScrFs))
  610.                     {
  611.                         break;
  612.                     }
  613.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  614.                     ok = Parse.PreParseStringType(str);
  615.                     if (!ok)
  616.                     {
  617.                         return(ERR_PARSESTR);
  618.                     }
  619.                     if (Parse.StrType != STRTYPE_CONTI)
  620.                     {
  621.                         break;
  622.                     }
  623.                     LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  624.                     Parse.PreParseString(m_iEventIdx, str);
  625.                     Parse.String2RxAclData();
  626.                 }while(1);
  627.                 CS_fseek(ScrFs, fpos, SEEK_SET);
  628.                 LogStrPtr += sprintf(LogStrPtr, "Waiting for HCI Data...... n");
  629. #if 0
  630.                 WaitRX = 1;
  631.                 while (!m_cHciMETA.Get_CallAutoCallback(Parse.StrValue2-1))
  632.                 {
  633.                     Sleep(100);
  634.                 }
  635.                 ok = m_cHciMETA.Get_EventOk();
  636.                 if (!ok)
  637.                 {
  638.                     ProcFailCount++;
  639.                     LogStrPtr += sprintf(LogStrPtr, "Receive HCI event Fail! n");
  640.                     return(ERR_RXCOMP);
  641.                 }
  642.                 WaitRX = 0;
  643. #endif                
  644.             }
  645.         }
  646.         break;
  648.         case STRTYPE_WAITRX:
  649.         {
  650.             // m_pcHci = &(HciUart[Parse.StrValue2-1]);
  651.             Parse.String2Event(m_iEventIdx);
  652.             do
  653.             {
  654.                 fpos = CS_ftell(ScrFs);
  655.                 if (CS_feof(ScrFs))
  656.                 {
  657.                     break;
  658.                 }
  659.                 CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  660.                 ok = Parse.PreParseStringType(str);
  661.                 if (!ok)
  662.                 {
  663.                     return(ERR_PARSESTR);
  664.                 }
  665.                 if (Parse.StrType != STRTYPE_CONTI)
  666.                 {
  667.                     break;
  668.                 }
  669.                 LogStrPtr += sprintf(LogStrPtr, "n=> %s", str);
  670.                 Parse.PreParseString(m_iEventIdx, str);
  671.                 Parse.String2Event(m_iEventIdx);
  672.             }while(1);
  673.             CS_fseek(ScrFs, fpos, SEEK_SET);
  674.             LogStrPtr += sprintf(LogStrPtr, "Waiting for HCI Data......n");
  675.             WaitRX = 2;
  676.         }
  677.         break;
  679.         case STRTYPE_SIMRX:
  680.         {
  681.             //m_pcHci = &(HciUart[Parse.StrValue2-1]);
  682.             Parse.String2Event(m_iEventIdx);
  683.             do
  684.             {
  685.                 fpos = CS_ftell(ScrFs);
  686.                 if (CS_feof(ScrFs))
  687.                 {
  688.                     break;
  689.                 }
  690.                 CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  691.                 ok = Parse.PreParseStringType(str);
  692.                 if (!ok)
  693.                 {
  694.                     return ERR_PARSESTR;
  695.                 }
  696.                 if (Parse.StrType != STRTYPE_CONTI)
  697.                 {
  698.                     CS_fseek(ScrFs, fpos, SEEK_SET);
  699.                     break;
  700.                 }
  701.                 LogStrPtr += sprintf(LogStrPtr, "=> %s", str);
  702.                 Parse.PreParseString(m_iEventIdx, str);
  703.                 Parse.String2Event(m_iEventIdx);
  704.             }while(1);
  705.             //m_pcHci->rs232.PutData2Buf(Parse.m_ucEvent, Parse.m_iEvtLen);
  706.             m_cHciUart.rs232.PutData2Buf(Parse.m_ucEvent, Parse.m_iEvtLen[m_iEventIdx]);
  707.             LogStrPtr += sprintf( LogStrPtr, "Put debug data to UART RX buffer. n");
  708.             CS_fseek(ScrFs, fpos, SEEK_SET);
  709.         }
  710.         break;
  712.         case STRTYPE_PATCH:
  713.         {
  714.             // m_pcHci = &(HciUart[Parse.StrValue2-1]);
  715.             ok = GeneratePatchScript( Parse.StrValue2, Parse.String );
  716.             if (ok)
  717.             {
  718.                 SelSource = SRC_TMPFILE;
  719.                 if (TmpFs != 0)
  720.                 {
  721.                     fclose(TmpFs);
  722.                 }
  723.                 TmpFs = fopen("~tmpfile.txt", "rt");
  724.             }
  725.         }
  726.         break;
  728.         case STRTYPE_BAUDRATE:
  729.         {
  730.             //m_pcHci = &(HciUart[Parse.StrValue2-1]);
  731.             ok = GenerateChangeBaudrateScript(Parse.StrValue2, Parse.StrValue);
  732.             if (ok)
  733.             {
  734.                 SelSource = SRC_TMPFILE;
  735.                 if (TmpFs != 0)
  736.                 {
  737.                     fclose(TmpFs);
  738.                 }
  739.                 TmpFs = fopen("~tmpfile.txt", "rt");
  740.             }
  741.         }
  742.         break;
  744.         case STRTYPE_FAILPROC:
  745.         {
  746.             FILE *fs = fopen("~failprc.txt", "w+t");
  747.             if (fs != 0)
  748.             {
  749.                 HasFailProc = true;
  750.                 while (!feof(ScrFs))
  751.                 {
  752.                     CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  753.                     Parse.PreParseStringType(str);
  754.                     if (Parse.StrType == STRTYPE_FAILEND)
  755.                     {
  756.                         fputs("END", fs);
  757.                         fclose(fs);
  758.                         break;
  759.                     }
  760.                     else
  761.                     {
  762.                         fputs(str, fs);
  763.                     }
  764.                 }
  765.             }
  766.         }
  767.         break;
  769.         case STRTYPE_GOTONEXTPROC:
  770.         {
  771.             bool has_fail_proc = HasFailProc;
  772.             HasFailProc = false;
  773.             while (!feof(ScrFs))
  774.             {
  775.                 CS_fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  776.                 Parse.PreParseStringType(str);
  777.                 if (Parse.StrType == STRTYPE_PROCNAME)
  778.                 {
  779.                     CountProcResult();
  780.                     break;
  781.                 }
  782.                 else if (Parse.StrType == STRTYPE_END)
  783.                 {
  784.                     if (SelSource == SRC_ORGFILE)
  785.                     {
  786.                         CountProcResult();
  787.                         return ERR_FILEEND;
  788.                     }
  789.                     else if (SelSource == SRC_TMPFILE)
  790.                     {
  791.                         if (TmpFs != 0)
  792.                         {
  793.                             fclose(TmpFs);
  794.                         }
  795.                         TmpFs = 0;
  796.                         SelSource = SRC_ORGFILE;
  797.                     }
  798.                 }
  799.             }
  800.             HasFailProc = has_fail_proc;
  801.         }
  802.         break;
  804.         case STRTYPE_FORCEEND:
  805.         {
  806.             IsForceEnd = true;
  807.         }
  808.         break;
  810.         case STRTYPE_SHOWMSG:
  811.         {
  812.             ::MessageBox(NULL, Parse.String, "Message", MB_OK);
  813.         }
  814.         break;
  816.         case STRTYPE_KYLE:
  817.         {
  818.             ok = GenerateKyleScript(Parse.StrArg1, Parse.StrArg2, Parse.StrArg3);
  819.             if (ok)
  820.             {
  821.                 SelSource = SRC_TMPFILE;
  822.                 if (TmpFs!=0)
  823.                 {
  824.                     fclose(TmpFs);
  825.                 }
  826.                 TmpFs = fopen("~tmpfile.txt", "rt");
  827.             }
  828.         }
  829.         break;
  831.         case STRTYPE_END:
  832.         {
  833.             if (SelSource == SRC_ORGFILE)
  834.             {
  835.                 CountProcResult();
  836.                 return ERR_FILEEND;
  837.             }
  838.             else if (SelSource == SRC_TMPFILE)
  839.             {
  840.                 if (TmpFs != 0)
  841.                 {
  842.                     fclose(TmpFs);
  843.                 }
  844.                 TmpFs = 0;
  845.                 SelSource = SRC_ORGFILE;
  846.            }
  847.        }
  848.        break;
  849.     } // switch ()
  851.     return ERR_NONE;
  852. }
  854. //-----------------------------------------------
  855. int CBTMT::GeneratePatchScript(int hci_no, char* patchfile)
  856. {
  857.     FILE *pfs, *fs;
  858.     char str[BT_MODULE_TEST_SRCSTR_SIZE], *p;
  859.     unsigned char buf[240];
  860.     long len;
  861.     int n;
  863.     pfs = fopen( patchfile, "rb" );
  864.     if (pfs == 0)
  865.     {
  866.         return 0;
  867.     }
  868.     fs = fopen("~tmpfile.txt", "w+t");
  869.     if (fs == 0)
  870.     {
  871.         fclose(pfs);
  872.         return(0);
  873.     }
  874.     // Generate 1'st segement of patch
  875.     len = fread(buf, 1, 240, pfs);
  876.     p=str;
  877.     p += sprintf(p, "TX%d : 01 C4 FC F5 00 F0 00 00 00 ", hci_no);
  878.     for (n=0; n<len; n++)
  879.     {
  880.         p+=sprintf(p, "%02X ", (int)buf[n]);
  881.     }
  882.     fputs(str, fs);
  883.     sprintf(str, "nRX%d : 04 0E 04 01 C4 FC 00n", hci_no);
  884.     fputs(str, fs);
  886.     // Generate middle segements of patch
  887.     len = fread(buf, 1, 240, pfs);
  888.     while (len >= 240)
  889.     {
  890.         p = str;
  891.         p += sprintf(p, "TX%d : 01 C4 FC F5 01 F0 00 00 00 ", hci_no);
  892.         for (n=0; n<len; n++)
  893.         {
  894.             p+=sprintf(p, "%02X ", (int)buf[n]);
  895.         }
  896.         fputs(str, fs);
  897.         sprintf(str, "nRX%d : 04 0E 04 01 C4 FC 00n", hci_no);
  898.         fputs(str, fs);
  899.         len = fread(buf, 1, 240, pfs);
  900.     }
  902.     // Generate last segement of patch
  903.     p = str;
  904.     p += sprintf(p, "TX%d : 01 C4 FC %02X 02 %02X 00 00 00 ", hci_no, (int)(5+len), (int)len);
  905.     for (n=0; n<len; n++)
  906.     {
  907.         p += sprintf(p, "%02X ", (int)buf[n]);
  908.     }
  909.     fputs(str, fs);
  910.     sprintf(str, "nRX%d : 04 0E 04 01 C4 FC 00n", hci_no);
  911.     fputs(str, fs);
  913.     sprintf(str, "END");
  914.     fputs(str, fs);
  915.     fclose(fs);
  916.     fclose(pfs);
  917.     return 1;
  918. }
  920. //-----------------------------------------------
  921. int CBTMT::GenerateChangeBaudrateScript(int hci_no, int baudrate)
  922. {
  923.     FILE *fs;
  924.     char str[BT_MODULE_TEST_SRCSTR_SIZE];
  925.     int baudchar;
  927.     if (1 == baudrate)
  928.     {
  929.         baudchar = 0x08; // 115K
  930.     }
  931.     else if (baudrate==2)
  932.     {
  933.         baudchar = 0x09; // 230K
  934.     }
  935.     else if (baudrate==4)
  936.     {
  937.         baudchar = 0x0A; // 460K
  938.     }
  939.     else if (baudrate==9)
  940.     {
  941.         baudchar = 0x0B; // 921K
  942.     }
  943.     else if (baudrate==3)
  944.     {
  945.         baudchar = 0x0C; // 3M
  946.     }
  947.     else
  948.     {
  949.         return(0);
  950.     }
  951.     fs = fopen("~tmpfile.txt", "w+t" );
  952.     if (fs==0)
  953.     {
  954.         return(0);
  955.     }
  957.     // Generate 1'st segement of patch
  958.     sprintf(str, "TX%d : 01 77 FC 02 %02X 00n", hci_no, baudchar);
  959.     fputs(str, fs);
  960.     sprintf(str, "RX%d : 04 0F 04 00 01 77 FCn", hci_no);
  961.     fputs(str, fs);
  962.     sprintf(str, "TX%d : FFn", hci_no, baudchar);
  963.     fputs(str, fs);
  964.     sprintf(str, "RX%d : 04 0E 04 00 01 C0 FCn", hci_no);
  965.     fputs(str, fs);
  966.     sprintf(str, "RX%d : 04 0E 04 00 01 C0 FCn", hci_no);
  967.     fputs(str, fs);
  968.     sprintf(str, "END");
  969.     fputs(str, fs);
  970.     fclose(fs);
  971.     return 1;
  972. }
  974. //-----------------------------------------------
  975. CBTMT::CBTMT(void)
  976. {
  977.     ScrFs = 0;
  978.     TmpFs = 0;
  979.     LogFs = 0;
  980.     strcpy(m_cTitle, "Test Process");
  981.     m_asProcName[0] = "Test1";
  982.     for (int n=1; n<PROCCOUNT; n++)
  983.     {
  984.         m_asProcName[n] = "";
  985.     }
  986.     m_iProcCount = 0;
  987.     m_iEventIdx = 0;
  988.     m_iAutoEventIdx = 0;
  989. //   Reset();
  990. }
  992. //-----------------------------------------------
  993. CBTMT::~CBTMT(void)
  994. {
  995.     if (TmpFs != 0)
  996.     {
  997.         fclose(TmpFs);
  998.         TmpFs = 0;
  999.     }
  1000.     if (ScrFs != 0)
  1001.     {
  1002.         fclose(ScrFs);
  1003.         ScrFs = 0;
  1004.     }
  1005.     if (LogFs != 0)
  1006.     {
  1007.         fclose(LogFs);
  1008.         LogFs = 0;
  1009.     }
  1010.     //HciUart[0].rs232.Close();
  1011.     //HciUart[1].rs232.Close();
  1012.     m_cHciUart.rs232.Close();
  1013. }
  1015. //-----------------------------------------------
  1016. int CBTMT::Reset(void)
  1017. {
  1018.     int n;
  1019.     //HciUart[0].rs232.Close();
  1020.     //HciUart[1].rs232.Close();
  1021.     m_cHciUart.rs232.Close();
  1022.    // m_pcHci = &HciUart[0];
  1024.    m_iLastProc = m_iCurProc = -1;
  1025.    for(n=0; n<PROCCOUNT+1; n++)  m_cProcFail[n] = 0;
  1026.    ProcFailCount = 0;
  1027.    m_iFailCount = 0;
  1028.    IsWaitProc=0;
  1029.    WaitProcPos=0;
  1030.    IsForceEnd = false;
  1031.    HasFailProc = false;
  1033.    Ticks = 0;
  1034.    WaitRX = 0;
  1035.    WaitTime = 0;
  1036.    WaitCounter = 0;
  1037.    TimeoutTime = 0;
  1038.    TimeoutCounter = 0;
  1039.    RUN_Time = -1;
  1041.    SelSource = SRC_ORGFILE;
  1042.    if(TmpFs!=0)
  1043.    {  fclose(TmpFs);  TmpFs = 0;   }
  1045.    if(ScrFs!=0)
  1046.    {  fclose(ScrFs);  ScrFs = 0;   }
  1047.    ScrFs = fopen( ScriptFilename, "rt" );
  1048.    if(ScrFs==0)   return(0);
  1050.    if(LogFs!=0)
  1051.    {  fclose(LogFs);  LogFs = 0;   }
  1052.    if(LogEnable)
  1053.       LogFs = fopen("logfile.txt", "w+t" );
  1054.    else
  1055.       LogFs = 0;
  1057.    LogPath[0] = 0;
  1059.    m_cLogString[0] = 0;
  1060.    LogStrPtr = m_cLogString;
  1061.    LogEnable = true;
  1063.    m_iErrorCode = ERR_NONE;
  1064.    return(1);
  1065. }
  1067. //-----------------------------------------------
  1068. bool CBTMT::OpenScript(char *filename)
  1069. {
  1070.     char str[BT_MODULE_TEST_SRCSTR_SIZE];
  1071.     strcpy(ScriptFilename, filename);
  1072.     if (ScrFs != NULL)
  1073.     {
  1074.         fclose(ScrFs);
  1075.     }
  1076.     ScrFs = fopen(ScriptFilename, "rt");
  1077.     if (ScrFs==0)
  1078.     {
  1079.         return(0);
  1080.     }
  1081.     m_iProcCount = 0;
  1082.     while (!feof(ScrFs))
  1083.     {
  1084.         fgets(str, BT_MODULE_TEST_SRCSTR_SIZE, ScrFs);
  1085.         Parse.PreParseStringType(str);
  1086.         // ok = Parse.PreParseStringType( str );
  1087.         // if(!ok)  return(ERR_PARSESTR);
  1088.         if (Parse.StrType == STRTYPE_TITLE)
  1089.         {
  1090.             strcpy(m_cTitle, Parse.String);
  1091.         }
  1092.         else if ((Parse.StrType == STRTYPE_PROCNAME)    ||
  1093.                  (Parse.StrType == STRTYPE_WAITPROCNAME)
  1094.                  )
  1095.         {
  1096.             if (m_iProcCount < PROCCOUNT)
  1097.             {
  1098.                 //strcpy(m_cProcName[m_iProcCount], Parse.String);
  1099.                 m_asProcName[m_iProcCount] = Parse.String;
  1100.                 m_iProcCount++;
  1101.             }
  1102.         }
  1103.     }
  1104.     fclose(ScrFs);
  1105.     ScrFs = 0;
  1106.     Reset();
  1107.     return 1;
  1108. }
  1110. //-----------------------------------------------
  1111. int CBTMT::CloseScript(void)
  1112. {
  1113.     long cur_time = GiveDateTime();
  1114.     RUN_Time = cur_time - RUN_Time;
  1115.     LogStrPtr += sprintf( LogStrPtr, "Execution Time = %ld secn", (long)RUN_Time);
  1117.     if (TmpFs != 0)
  1118.     {
  1119.         fclose(TmpFs);
  1120.         TmpFs = 0;
  1121.     }
  1123.     if (ScrFs != 0)
  1124.     {
  1125.         fclose(ScrFs);
  1126.         ScrFs = 0;
  1127.     }
  1129.     if (LogFs != 0)
  1130.     {
  1131.         fclose(LogFs);
  1132.         LogFs = 0;
  1133.     }
  1134.     //HciUart[0].rs232.Close();
  1135.     //HciUart[1].rs232.Close();
  1136.     m_cHciUart.rs232.Close();
  1137.     
  1138.     if ((LogPath[0] != 0) && (m_iFailCount != 0))  // copy log to logpath
  1139.     {
  1140.         char str[2048];
  1141.         sprintf(str, "copy logfile.txt %s\%08ld.txt", LogPath, (long)cur_time );
  1142.         system(str);
  1143.     }
  1144.     return 1;
  1145. }
  1147. //-----------------------------------------------
  1148. int  CBTMT::CountProcResult(void)
  1149. {
  1150. int fail_count = ProcFailCount ;
  1152.    if(m_iProcCount<0)
  1153.       return(0);
  1154.    if(m_iCurProc<0)
  1155.    {  m_iCurProc = 0;
  1156.       return(0);
  1157.    }
  1158.    if((IsWaitProc)&&(ProcFailCount!=0))    // do again
  1159.    {  m_cProcFail[m_iCurProc]= 1;
  1160.       m_iLastProc = -1;
  1161.       CS_fseek(ScrFs, WaitProcPos, SEEK_SET);
  1162.    }
  1163.    else
  1164.    {
  1165.       if(ProcFailCount!=0)
  1166.       {  m_cProcFail[m_iCurProc]= 1;
  1167.          m_iFailCount++;
  1168.          if(HasFailProc)
  1169.          {  system( " copy ~failprc.txt ~tmpfile.txt/Y" );
  1170.             SelSource = SRC_TMPFILE;
  1171.             if(TmpFs!=0) fclose(TmpFs);
  1172.             TmpFs = fopen("~tmpfile.txt", "rt" );
  1173.          }
  1174.       }
  1175.       else
  1176.       {  m_cProcFail[m_iCurProc] = 0;
  1177.          IsWaitProc = 0;
  1178.       }
  1179.       m_iLastProc = m_iCurProc;
  1180.       m_iCurProc += (m_iCurProc<m_iProcCount) ? 1 : 0;
  1181.    }
  1182.    ProcFailCount = 0;
  1183.    return(fail_count);
  1184. }
  1185. //-----------------------------------------------
  1187. int  CBTMT::ProcessResult( int err_code )
  1188. {
  1189.     m_iErrorCode = err_code;
  1190.     if( m_iErrorCode!=ERR_NONE )
  1191.        if(HasFailProc)
  1192.        {  system( " copy ~failprc.txt ~tmpfile.txt/Y" );
  1193.           SelSource = SRC_TMPFILE;
  1194.           if(TmpFs!=0) fclose(TmpFs);
  1195.           TmpFs = fopen("~tmpfile.txt", "rt" );
  1196.        }
  1197.     return(1);
  1198. }
  1199. //-----------------------------------------------
  1201. int CBTMT::CS_feof(FILE *fs)
  1202. {  if(SelSource==SRC_ORGFILE)
  1203.       return(feof(fs));
  1204.    if(SelSource==SRC_TMPFILE)
  1205.    {  int ok = feof(TmpFs);
  1206.       if(!ok)  return(ok);
  1207.       fclose(TmpFs);
  1208.       TmpFs = 0;
  1209.       SelSource = SRC_ORGFILE;
  1210.       return(ftell(fs));
  1211.    }
  1212.    return(0);
  1213. }
  1214. //-----------------------------------------------
  1216. char *CBTMT::CS_fgets(char *s, int n, FILE *fs)
  1217. {  if(SelSource==SRC_ORGFILE)
  1218.       return(fgets(s, n, fs));
  1219.    if(SelSource==SRC_TMPFILE)
  1220.    {  if(TmpFs==0)
  1221.       {  TmpFs = fopen("~tmpfile.txt", "rt" );  }
  1222.       return(fgets(s, n, TmpFs));
  1223.    }
  1224.    return(0);
  1225. }
  1226. //-----------------------------------------------
  1228. long int CBTMT::CS_ftell(FILE *fs)
  1229. {  if(SelSource==SRC_ORGFILE)
  1230.       return(ftell(fs));
  1231.    if(SelSource==SRC_TMPFILE)
  1232.       return(ftell(TmpFs));
  1233.    return(0);
  1234. }
  1236. //-----------------------------------------------
  1237. int CBTMT::CS_fseek(FILE *fs, long offset, int whence)
  1238. {  if(SelSource==SRC_ORGFILE)
  1239.       return(fseek(fs, offset, whence));
  1240.    if(SelSource==SRC_TMPFILE)
  1241.       return(fseek(TmpFs, offset, whence));
  1242.    return(0);
  1243. }
  1245. //-----------------------------------------------
  1246. static long  GiveDateTime( void )
  1247. {  struct date d;
  1248.    struct time t;
  1249.    unsigned long v = 0;
  1250.    getdate(&d);
  1251.    gettime(&t);
  1252.    v = (v*100)+d.da_mon;
  1253.    v = (v*100)+d.da_day;
  1254.    v = (v*100)+t.ti_hour;
  1255.    v = (v*100)+t.ti_min;
  1256.    v = (v*100)+t.ti_sec;
  1258.    return(v);
  1259. }
  1260. //=============================================================================
  1262. int   CBTMT::GenerateKyleScript( int arg1, int arg2, int arg3 )
  1263. {  FILE *fs;
  1264.    char str[BT_MODULE_TEST_SRCSTR_SIZE];
  1266.    fs = fopen("~tmpfile.txt", "w+t" );
  1267.    if(fs==0)  return(0);
  1269.    /*==== Generate Script statements =======*/
  1270.    // example:
  1271.    //
  1272.    // p=str;
  1273.    // p += sprintf( p, "TX1 : 01 C4 FC F5 %02X F0 00 00 00 ", arg1);
  1274.    // for(n=0; n<len; n++) {  p+=sprintf( p, "%02X ", (int)buf[n] ); }
  1275.    // fputs( str, fs );
  1276.    // sprintf( str, "nRX%d : 04 0E 04 01 C4 FC 00n", hci_no);
  1277.    // fputs( str, fs );
  1278.    // LogStrPtr += sprintf( LogStrPtr, "You can add trace string in this statement");
  1279.    //
  1280.    /*==== Generate Script statements */
  1282.    fclose(fs);
  1283.    return(1);
  1284. }
  1286. //=============================================================================
  1287. ///////////////////////////  Export information   /////////////////////////////
  1288. //=============================================================================
  1289. void CBTMT::Set_ComPort(int com_port)
  1290. {
  1291.     m_iComPort = com_port;
  1292. }
  1294. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1295. void CBTMT::Set_BTTrans(int idx, E_BT_TRANS_T bt_trans)
  1296. {
  1297.     assert(idx < 2);
  1298.     m_eBtTrans[idx] = bt_trans;
  1299. }
  1301. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1302. int CBTMT::Get_LogStringLen(void)
  1303. {
  1304.     return strlen(m_cLogString);
  1305. }
  1307. //-----------------------------------------------------------------------------
  1308. char CBTMT::Get_LogString(int idx)
  1309. {
  1310.     return m_cLogString[idx];
  1311. }
  1313. //-----------------------------------------------------------------------------
  1314. void CBTMT::Set_LogString(int idx, char c)
  1315. {
  1316.     m_cLogString[idx] = c;
  1317. }
  1319. //-----------------------------------------------------------------------------
  1320. char* CBTMT::Get_LogString(void)
  1321. {
  1322.     return m_cLogString;
  1323. }
  1325. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1326. int CBTMT::Get_LastProc(void)
  1327. {
  1328.     return m_iLastProc;
  1329. }
  1331. //-----------------------------------------------------------------------------
  1332. void CBTMT::Set_LastProc(int proc)
  1333. {
  1334.     m_iLastProc = proc;
  1335. }
  1337. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1338. int CBTMT::Get_CurProc(void)
  1339. {
  1340.     return m_iCurProc;
  1341. }
  1343. //-----------------------------------------------------------------------------
  1344. void CBTMT::Set_CurProc(int proc)
  1345. {
  1346.     m_iCurProc = proc;
  1347. }
  1349. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1350. int CBTMT::Get_ErrorCode(void)
  1351. {
  1352.     return m_iErrorCode;
  1353. }
  1355. //-----------------------------------------------------------------------------
  1356. void CBTMT::Set_ErrorCode(int err_code)
  1357. {
  1358.     m_iErrorCode = err_code;
  1359. }
  1361. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1362. int CBTMT::Get_FailCount(void)
  1363. {
  1364.     return m_iFailCount;
  1365. }
  1367. //----------------------------------------------------------------------------
  1368. void CBTMT::Set_FailCount(int fail_count)
  1369. {
  1370.     m_iFailCount = fail_count;
  1371. }
  1373. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1374. char* CBTMT::Get_Title(void)
  1375. {
  1376.     return m_cTitle;
  1377. }
  1379. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1380. int CBTMT::Get_ProcCount(void)
  1381. {
  1382.     return m_iProcCount;
  1383. }
  1385. //----------------------------------------------------------------------------
  1386. void CBTMT::Set_ProcCount(int proc_count)
  1387. {
  1388.     m_iProcCount = proc_count;
  1389. }
  1391. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1392. char CBTMT::Get_ProcFail(int idx)
  1393. {
  1394.     assert(idx <= PROCCOUNT);
  1395.     return m_cProcFail[idx];
  1396. }
  1398. //----------------------------------------------------------------------------
  1399. void CBTMT::Set_ProcFail(int idx, char proc_fail)
  1400. {
  1401.     assert(idx <= PROCCOUNT);
  1402.     m_cProcFail[idx] = proc_fail;
  1403. }
  1405. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1406. AnsiString CBTMT::Get_ProcName(int idx)
  1407. {
  1408.     assert(idx < PROCCOUNT);
  1409.     return m_asProcName[idx];
  1410. }
  1412. //----------------------------------------------------------------------------
  1413. void CBTMT::Set_ProcName(int idx, AnsiString proc_name)
  1414. {
  1415.     assert(idx < PROCCOUNT);
  1416.     m_asProcName[idx] = proc_name;
  1417. }