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

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

MTK

开发平台：

C++ Builder

misc_BT.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.  *   misc_BT.cpp
  16.  *
  17.  * Project:
  18.  * --------
  19.  *   Maui META APP
  20.  *
  21.  * Description:
  22.  * ------------
  23.  *  BT Misc. function 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. #include <vcl.h>
  42. #include <math.h>
  43.  
  44. #pragma hdrstop
  46. #ifndef META_DLL_H
  47. #include "meta.h"
  48. #endif
  50. #ifndef  _MAN_ERROR_H_
  51. #include "man_error.h"
  52. #endif
  54. #ifndef  _FT_UTILS_H_
  55. #include "ft_utils.h"
  56. #endif
  58. // BT
  59. #ifndef  _BT_COMMON_H_
  60. #include "bt_common.h"
  61. #endif
  63. #ifndef  _BT_HCI_H_
  64. #include "bt_hci.h"
  65. #endif
  68. //==============================================================================
  69. //////////////////////////////   Format transform  /////////////////////////////
  70. //==============================================================================
  71. bool  BTHCIValue_To_AnsiString( S_BT_HCI_VALUE hci_value, AnsiString &ansi_str )
  72. {
  74.     double value=0;
  75.     unsigned char  uc_value[BT_HCI_VALUE_SIZE*2];
  76.     int   i;
  77.     for( i=0; i<BT_HCI_VALUE_SIZE*2; i++ )
  78.     {
  79.         if( 0 == i % 2 )
  80.             uc_value[i] = hci_value.uc_value[i/2] & 0x0F;
  81.         else
  82.             uc_value[i] = (hci_value.uc_value[i/2] & 0xF0) >> 4;
  83.     }
  85.     for(  i=BT_HCI_VALUE_SIZE*2-1; i>=0; i-- )
  86.     {  value = value * 16 + uc_value[i];
  87.     }
  89.     ansi_str = Double_To_AnsiString( value );
  93.     return true;
  94. }
  96. //----------------------------------------------------------------------------
  97. bool  BTHCIValue_To_Hex_AnsiString( S_BT_HCI_VALUE hci_value, AnsiString &ansi_str )
  98. {
  99.     unsigned char  str[BT_HCI_VALUE_SIZE*2+1];
  100.     char  *ptr = str;
  101.     unsigned char  uc_value[BT_HCI_VALUE_SIZE*2];
  102.     unsigned char nz_byte=2*BT_HCI_VALUE_SIZE;
  103.     int   i;
  104.     for( i=0; i<BT_HCI_VALUE_SIZE*2; i++ )
  105.     {
  106.         if( 0 == i % 2 )
  107.             uc_value[i] = hci_value.uc_value[i/2] & 0x0F;
  108.         else
  109.             uc_value[i] = (hci_value.uc_value[i/2] & 0xF0) >> 4;
  110.     }
  113.     for( i=BT_HCI_VALUE_SIZE*2-1; i>=0; i-- )
  114.     {
  115.         if( 0 == uc_value[i] )
  116.            nz_byte--;
  117.         else
  118.            break;
  119.     }
  121.     for( i=0; i<nz_byte; i++ )
  122.     { //  sprintf( &str[nz_byte-i-1], "%X",  uc_value[i] );
  123.         ptr += sprintf( ptr, "%X", uc_value[nz_byte-i-1] );
  124.     }
  125.     str[nz_byte] = '';
  126.     ansi_str = (char *)str;
  128.     if( 0 == nz_byte )
  129.     ansi_str = "0";
  131.     return true;
  132. }
  134. //----------------------------------------------------------------------------
  135. bool  BDAddress_To_Hex_AnsiString( S_BD_ADDR bd_addr, AnsiString &ansi_str )
  136. {
  137.     int i;
  138.     char str[2*BD_ADDRESS_LEN+1];
  139.     char  *ptr = str;
  140.     for( i=0; i<BD_ADDRESS_LEN*2; i++ )
  141.     {
  142.         if( 0 == i%2 )
  143.         {
  144.             ptr += sprintf( ptr, "%X", (bd_addr.uc_BD_Addr[BD_ADDRESS_LEN-i/2-1] & 0xF0) >> 4 );
  145.         }
  146.         else
  147.         {
  148.             ptr += sprintf( ptr, "%X", bd_addr.uc_BD_Addr[BD_ADDRESS_LEN-i/2-1] & 0x0F );
  149.         }
  150.     }
  151.     str[2*BD_ADDRESS_LEN] = '';
  152.     ansi_str = str;
  153.     return true;
  154. }
  156. //----------------------------------------------------------------------------
  157. bool  BDAddress_To_Hex_Colon_AnsiString( S_BD_ADDR bd_addr, AnsiString &ansi_str )
  158. {
  159.     int i;
  160.     char str[3*BD_ADDRESS_LEN];
  161.     char  *ptr = str;
  162.     for( i=0; i<BD_ADDRESS_LEN*2; i++ )
  163.     {
  164.         if( 0 == i%2 )
  165.         {
  166.             ptr += sprintf( ptr, "%X", (bd_addr.uc_BD_Addr[BD_ADDRESS_LEN-i/2-1] & 0xF0) >> 4 );
  167.         }
  168.         else
  169.         {
  170.             ptr += sprintf( ptr, "%X", bd_addr.uc_BD_Addr[BD_ADDRESS_LEN-i/2-1] & 0x0F );
  171.             ptr += sprintf( ptr, ":" );
  172.         }
  173.     }
  174.     str[3*BD_ADDRESS_LEN-1] = '';
  175.     ansi_str = str;
  176.     return true;
  177. }
  179. //----------------------------------------------------------------------------
  180. bool  AnsiString_To_Hex_BDAddress( AnsiString ansi_str, S_BD_ADDR &bd_addr )
  181. {
  182.     char  str[256];
  183.     unsigned  char  val;
  184.     unsigned char  uc_value[BD_ADDRESS_LEN*2];
  186.    /* check if each char is valid */
  187.      int   i;
  188.       char  ch;
  189.       int   str_len = ansi_str.Length();
  190.       if(str_len==0)  return(false);
  191.       strcpy( str, ansi_str.c_str() );
  193.       for( i=0; i<BD_ADDRESS_LEN; i++ )
  194.       {   bd_addr.uc_BD_Addr[i] = 0;
  195.       }
  197.       for( i=0; i<BD_ADDRESS_LEN*2; i++ )
  198.       {   uc_value[i] = 0;
  199.       }
  201.       for( i=0; i<str_len; i++ )
  202.       {
  203.          val = 0;
  204.          ch = str[i];
  205.          if( (ch>='0')&&(ch<='9') )
  206.          {  val <<= 4;
  207.             val += ch-'0';
  208.          }
  209.          else if( (ch>='A')&&(ch<='F') )
  210.          {  val <<= 4;
  211.             val += ch-'A'+10;
  212.          }
  213.          else if( (ch>='a')&&(ch<='f') )
  214.          {  val <<= 4;
  215.             val += ch-'a'+10;
  216.          }
  217.          else if( ch==' ' )
  218.          {
  219.          }
  220.          else
  221.          {  return false;
  222.          }
  223.          uc_value[str_len-i-1] = val;
  224.       }
  229.       for( i=0; i<BD_ADDRESS_LEN; i++ )
  230.       {
  231.           bd_addr.uc_BD_Addr[i] = uc_value[2*i] + 16 * uc_value[2*i+1];
  233.       }
  237.    return( true );
  238. }
  240. //----------------------------------------------------------------------------
  241. bool  Colon_AnsiString_To_Hex_BDAddress( AnsiString ansi_str, S_BD_ADDR &bd_addr )
  242. {
  243.     char  str[256];
  244.     unsigned  char  val;
  245.     unsigned char  uc_value[BD_ADDRESS_LEN*2];
  247.    /* check if each char is valid */
  248.     int   i;
  249.     char  ch;
  250.     int   str_len = ansi_str.Length();
  251.     if(str_len!=(BD_ADDRESS_LEN*3-1))  return(false);
  252.     strcpy( str, ansi_str.c_str() );
  254.     for( i=0; i<BD_ADDRESS_LEN; i++ )
  255.     {   bd_addr.uc_BD_Addr[i] = 0;
  256.     }
  258.     for( i=0; i<BD_ADDRESS_LEN*2; i++ )
  259.     {   uc_value[i] = 0;
  260.     }
  262.     int count=0;
  263.     for( i=0; i<str_len; i++ )
  264.     {
  265.         val = 0;
  266.         ch = str[i];
  267.         if( (ch>='0')&&(ch<='9') )
  268.         {
  269.             val <<= 4;
  270.             val += ch-'0';
  271.             count++;
  272.         }
  273.         else if( (ch>='A')&&(ch<='F') )
  274.         {
  275.             val <<= 4;
  276.             val += ch-'A'+10;
  277.             count++;
  278.         }
  279.         else if( (ch>='a')&&(ch<='f') )
  280.         {
  281.             val <<= 4;
  282.             val += ch-'a'+10;
  283.             count++;
  284.         }
  285.         else if( ch==' ' || ch==':')
  286.         {
  287.             continue;
  288.         }
  289.         else
  290.         {
  291.             return false;
  292.         }
  293.         uc_value[BD_ADDRESS_LEN*2-count] = val;
  294.     }
  296.     for( i=0; i<BD_ADDRESS_LEN; i++ )
  297.     {
  298.         bd_addr.uc_BD_Addr[i] = uc_value[2*i] + 16 * uc_value[2*i+1];
  299.     }
  301.     return true;
  302. }
  304. //----------------------------------------------------------------------------
  305. bool  AnsiString_To_BTHCIValue( AnsiString ansi_str, S_BT_HCI_VALUE &out_value )
  306. {
  307.    /* check if each char is valid */
  308.    unsigned char  uc_value[BT_HCI_VALUE_SIZE*2];
  309.      int   i;
  310.       char  ch;
  311.       char  str[256];
  312.       int   str_len = ansi_str.Length();
  313.       if(str_len==0)  return(false);
  314.       strcpy( str, ansi_str.c_str() );
  316.       for( i=0; i<BT_HCI_VALUE_SIZE; i++ )
  317.       {   out_value.uc_value[i] = 0;
  318.       }
  320.       for( i=0; i<BT_HCI_VALUE_SIZE*2; i++ )
  321.       {   uc_value[i] = 0;
  322.       }
  324.       for( i=0; i<str_len; i++ )
  325.       {  ch = str[i];
  326.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  327.          break;
  328.       }
  329.       if( i!=str_len )
  330.          return(false);
  332.    /* convert string to integer */
  333.    double d_out_value = atof(ansi_str.c_str());
  334.    if( d_out_value >= pow(2.0, 160) )  return false;
  336.    for( i=0; i<str_len; i++ )
  337.    {
  338.        uc_value[str_len-i-1] = ansi_str.SubString(i+1,1).ToInt();
  339.    }
  341.    out_value.uc_nz_byte = 0;
  342.    for( i=0; i<sizeof(out_value.uc_value)/sizeof(out_value.uc_value[0]); i++ )
  343.    {
  344.           out_value.uc_value[i] = uc_value[2*i] + 16 * uc_value[2*i+1];
  345.          // out_value.uc_nz_byte++;
  346.    }
  348.    for( i=sizeof(out_value.uc_value)/sizeof(out_value.uc_value[0])-1; i>=0; i-- )
  349.    {
  350.        if( out_value.uc_value[i] != 0 )
  351.        {
  352.            out_value.uc_nz_byte = i+1;
  353.            break;
  354.        }
  355.    }
  357.    return true;
  358. }
  360. //----------------------------------------------------------------------------
  361. bool  AnsiString_Hex_To_BTHCIValue( AnsiString ansi_str, S_BT_HCI_VALUE &out_value )
  362. {
  363.     char  str[256];
  364.     unsigned  char  val;
  365.     unsigned char  uc_value[BT_HCI_VALUE_SIZE*2];
  367.    /* check if each char is valid */
  368.      int   i;
  369.       char  ch;
  370.       int   str_len = ansi_str.Length();
  371.       if(str_len==0)  return(false);
  372.       strcpy( str, ansi_str.c_str() );
  374.       for( i=0; i<sizeof(out_value.uc_value)/sizeof(out_value.uc_value[0]); i++ )
  375.       {   out_value.uc_value[i] = 0;
  376.       }
  378.       for( i=0; i<BT_HCI_VALUE_SIZE*2; i++ )
  379.       {   uc_value[i] = 0;
  380.       }
  382.       for( i=0; i<str_len; i++ )
  383.       {
  384.          val = 0;
  385.          ch = str[i];
  386.          if( (ch>='0')&&(ch<='9') )
  387.          {  val <<= 4;
  388.             val += ch-'0';
  389.          }
  390.          else if( (ch>='A')&&(ch<='F') )
  391.          {  val <<= 4;
  392.             val += ch-'A'+10;
  393.          }
  394.          else if( (ch>='a')&&(ch<='f') )
  395.          {  val <<= 4;
  396.             val += ch-'a'+10;
  397.          }
  398.          else if( ch==' ' )
  399.          {
  400.          }
  401.          else
  402.          {  return false;
  403.          }
  404.          uc_value[str_len-i-1] = val;
  405.       }
  409.       out_value.uc_nz_byte = 0;
  410.       for( i=0; i<sizeof(out_value.uc_value)/sizeof(out_value.uc_value[0]); i++ )
  411.       {
  412.           out_value.uc_value[i] = uc_value[2*i] + 16 * uc_value[2*i+1];
  413.          // if( out_value.uc_value[i] != 0 )
  414.          //     out_value.uc_nz_byte++;
  415.       }
  417.       for( i=sizeof(out_value.uc_value)/sizeof(out_value.uc_value[0])-1; i>=0; i-- )
  418.       {
  419.           if( out_value.uc_value[i] != 0 )
  420.           {
  421.               out_value.uc_nz_byte = i+1;
  422.               break;
  423.           }
  424.       }
  426.    return true;
  427. }
  429. //------------------------------------------------------------------------------
  430. bool  AnsiString_Hex_To_BTPIN( AnsiString ansi_str, S_BT_PIN &pt_pin )
  431. {
  432.     char  str[256];
  433.     unsigned char  val;
  434.     unsigned char  uc_value[BT_PIN_LEN*2];
  436.    /* check if each char is valid */
  437.      int   i;
  438.       char  ch;
  439.       int   str_len = ansi_str.Length();
  440.       if(str_len==0)  return(false);
  441.       pt_pin.uc_pin_len = str_len;
  442.    //   strcpy( str, ansi_str.c_str() );
  443.       strcpy( pt_pin.uc_PIN, ansi_str.c_str() );
  444. #if 0
  445.       for( i=0; i<BT_PIN_LEN; i++ )
  446.       {   pt_pin.uc_PIN[i] = 0;
  447.       }
  449.       for( i=0; i<BT_PIN_LEN*2; i++ )
  450.       {   uc_value[i] = 0;
  451.       }
  453.       for( i=0; i<str_len; i++ )
  454.       {
  455.          val = 0;
  456.          ch = str[i];
  457.          if( (ch>='0')&&(ch<='9') )
  458.          {  val <<= 4;
  459.             val += ch-'0';
  460.          }
  461.          else if( (ch>='A')&&(ch<='F') )
  462.          {  val <<= 4;
  463.             val += ch-'A'+10;
  464.          }
  465.          else if( (ch>='a')&&(ch<='f') )
  466.          {  val <<= 4;
  467.             val += ch-'a'+10;
  468.          }
  469.          else if( ch==' ' )
  470.          {
  471.          }
  472.          else
  473.          {  return false;
  474.          }
  475.          uc_value[str_len-i-1] = val;
  476.       }
  479.       for( i=0; i<BT_PIN_LEN; i++ )
  480.       {
  481.           pt_pin.uc_PIN[i] = uc_value[2*i] + 16 * uc_value[2*i+1];
  482.       }
  483. #endif
  484.       return true;
  485. }
  487. //==============================================================================
  488. //////////////////////////////    range check      /////////////////////////////
  489. //==============================================================================
  490. //----------------------------------------------------------------------------
  491. bool  IsValidHexBTHCIValue( AnsiString ansi_str, unsigned char bytes, S_BT_HCI_VALUE &hci_value, S_BT_HCI_VALUE &min_hci_value, S_BT_HCI_VALUE &max_hci_value )
  492. {
  493.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_BTHCIValue( ansi_str, hci_value ) , RANGE_ERR_BT_HCI_VALUE );
  495.     if( hci_value.uc_nz_byte > bytes )  return false;
  497.     AnsiString as_hci_value;
  498.     AnsiString as_min_hci_value;
  499.     AnsiString as_max_hci_value;
  500.     char str_hci_value[BT_HCI_VALUE_SIZE+1];
  501.     char str_min_hci_value[BT_HCI_VALUE_SIZE+1];
  502.     char str_max_hci_value[BT_HCI_VALUE_SIZE+1];
  503.     BTHCIValue_To_Hex_AnsiString( hci_value, as_hci_value );
  504.     BTHCIValue_To_Hex_AnsiString( min_hci_value, as_min_hci_value );
  505.     BTHCIValue_To_Hex_AnsiString( max_hci_value, as_max_hci_value );
  508.     strcpy( str_hci_value, as_hci_value.c_str() );
  509.     strcpy( str_min_hci_value, as_min_hci_value.c_str() );
  510.     strcpy( str_max_hci_value, as_max_hci_value.c_str() );
  512.     double d_hci_value = 0;
  513.     double d_min_hci_value = 0;
  514.     double d_max_hci_value = 0;
  515.     for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  516.     {
  517.         char val;
  518.         if( str_hci_value[i] == 0 )
  519.             break;
  521.          if( (str_hci_value[i]>='0')&&(str_hci_value[i]<='9') )
  522.          {
  523.             val = str_hci_value[i]-'0';
  524.          }
  525.          else if( (str_hci_value[i]>='A')&&(str_hci_value[i]<='F') )
  526.          {
  527.             val = str_hci_value[i]-'A'+10;
  528.          }
  529.          else if( (str_hci_value[i]>='a')&&(str_hci_value[i]<='f') )
  530.          {
  531.             val = str_hci_value[i]-'a'+10;
  532.          }
  533.          d_hci_value = d_hci_value*16 + val;
  534.     }
  536.     for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  537.     {
  538.         char val;
  539.         if( str_min_hci_value[i] == 0 )
  540.             break;
  542.          if( (str_min_hci_value[i]>='0')&&(str_min_hci_value[i]<='9') )
  543.          {
  544.             val = str_min_hci_value[i]-'0';
  545.          }
  546.          else if( (str_min_hci_value[i]>='A')&&(str_min_hci_value[i]<='F') )
  547.          {
  548.             val = str_min_hci_value[i]-'A'+10;
  549.          }
  550.          else if( (str_min_hci_value[i]>='a')&&(str_min_hci_value[i]<='f') )
  551.          {
  552.             val = str_min_hci_value[i]-'a'+10;
  553.          }
  554.          d_min_hci_value = d_min_hci_value*16 + val;
  555.     }
  557.     for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  558.     {
  559.         char val;
  560.         if( str_max_hci_value[i] == 0 )
  561.             break;
  563.          if( (str_max_hci_value[i]>='0')&&(str_max_hci_value[i]<='9') )
  564.          {
  565.             val = str_max_hci_value[i]-'0';
  566.          }
  567.          else if( (str_max_hci_value[i]>='A')&&(str_max_hci_value[i]<='F') )
  568.          {
  569.             val = str_max_hci_value[i]-'A'+10;
  570.          }
  571.          else if( (str_max_hci_value[i]>='a')&&(str_max_hci_value[i]<='f') )
  572.          {
  573.             val = str_max_hci_value[i]-'a'+10;
  574.          }
  575.          d_max_hci_value = d_max_hci_value*16 + val;
  576.     }
  579.     if( ( d_hci_value > d_max_hci_value ) ||
  580.         ( d_hci_value < d_min_hci_value )
  581.      )
  582.       return false;
  583.    return true;
  584. }
  586. //----------------------------------------------------------------------------
  587. bool  IsValidHexBDAddress( AnsiString ansi_str, S_BD_ADDR &bd_addr )
  588. {
  589.     if( ansi_str.AnsiPos(":") == 0 )
  590.     {
  591.         RANGE_CHECK_ERROR( !AnsiString_To_Hex_BDAddress( ansi_str, bd_addr ) , RANGE_ERR_BT_BD_ADDRESS );
  592.     }
  593.     else
  594.     {
  595.         RANGE_CHECK_ERROR( !Colon_AnsiString_To_Hex_BDAddress( ansi_str, bd_addr ) , RANGE_ERR_BT_BD_ADDRESS );
  596.     }
  598.     return true;
  599. }
  601. //----------------------------------------------------------------------------
  602. bool  IsValidDecBTHCIValue( AnsiString ansi_str, unsigned char bytes, S_BT_HCI_VALUE &hci_value, S_BT_HCI_VALUE &min_hci_value, S_BT_HCI_VALUE &max_hci_value )
  603. {
  604.     RANGE_CHECK_ERROR( !AnsiString_To_BTHCIValue( ansi_str, hci_value ) , RANGE_ERR_BT_HCI_VALUE );
  606.     if( hci_value.uc_nz_byte > bytes )  return false;
  608.     for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  609.     {
  610.         if(  (hci_value.uc_value[i] > max_hci_value.uc_value[i]) ||
  611.             (hci_value.uc_value[i] < min_hci_value.uc_value[i])
  612.          )
  613.             return false;
  614.     }
  616.     return true;
  617. }
  619. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  620. bool  IsValidHexBTHCIOpcode( AnsiString ansi_str, unsigned short &opcode )
  621. {
  622.    RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedShort( ansi_str, opcode ) , RANGE_ERR_BT_HCI_OPCODE );
  624.    return true;
  625. }
  627. //----------------------------------------------------------------------------
  628. bool  IsValidHexBTHCIEventIndex( AnsiString ansi_str, unsigned char &event_idx )
  629. {
  630.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedChar( ansi_str, event_idx ) , RANGE_ERR_BT_HCI_EVENT_INDEX );
  632.      return true;
  633. }
  635. //---------------------------------------------------------------------------
  636. bool  IsValidBTFreq( AnsiString ansi_str, unsigned char &freq )
  637. {
  638.    RANGE_CHECK_ERROR( !AnsiString_To_UnsignedChar( ansi_str, freq, 0, 255 ) , RANGE_ERR_BT_FREQ );
  640.    return true;
  641. }
  643. //---------------------------------------------------------------------------
  644. bool  IsValidBTTxDataLength( AnsiString ansi_str, unsigned short &len, unsigned short range_min, unsigned short range_max )
  645. {
  646.    RANGE_CHECK_ERROR( !AnsiString_To_UnsignedShort( ansi_str, len, range_min, range_max ) , RANGE_ERR_BT_TX_DATA_LENGTH );
  648.    return true;
  649. }
  650. //---------------------------------------------------------------------------
  651. bool  IsValidBTTxPollPeriod( AnsiString ansi_str, unsigned char &period )
  652. {
  653.    RANGE_CHECK_ERROR( !AnsiString_To_UnsignedChar( ansi_str, period, 0, 255 ) , RANGE_ERR_BT_TX_POLL_PERIOD );
  655.    return true;
  656. }
  658. //---------------------------------------------------------------------------
  659. bool  IsValidBTTxPacketCount( AnsiString ansi_str, unsigned int &count )
  660. {
  661.     RANGE_CHECK_ERROR( !AnsiString_To_UnsignedInteger( ansi_str, count, 0, 4294967295 ) , RANGE_ERR_BT_TX_PACKET_COUNT );
  663.     return true;
  664. }
  666. //---------------------------------------------------------------------------
  667. bool  IsValidBTTxPcl( AnsiString ansi_str, unsigned char &pcl )
  668. {
  669.    RANGE_CHECK_ERROR( !AnsiString_To_UnsignedChar( ansi_str, pcl, 1, 7 ) , RANGE_ERR_BT_TX_PCL );
  671.    return true;
  672. }
  674. //---------------------------------------------------------------------------
  675. bool  IsValidHexBTLAP( AnsiString ansi_str, unsigned int &lap )
  676. {
  677.    RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedInt( ansi_str, lap ) , RANGE_ERR_BT_TX_LAP );
  679.    return true;
  680. }
  682. //---------------------------------------------------------------------------
  683. bool  IsValidHexBTTxAccessCode( AnsiString ansi_str, unsigned char &code )
  684. {
  685.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedChar( ansi_str, code, 0, 255  ) , RANGE_ERR_BT_TX_ACCESS_CODE );
  687.     return true;
  688. }
  690. //---------------------------------------------------------------------------
  691. bool IsValidDecBTHCIValue( AnsiString ansi_str, unsigned char bytes, S_BT_HCI_VALUE &value )
  692. {
  693.     RANGE_CHECK_ERROR( !AnsiString_To_BTHCIValue( ansi_str, value ) , RANGE_ERR_BT_HCI_VALUE );
  695.    // unsigned char nz_count = 0;
  696.    // for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  697.    // {
  698.    //     if(  value.uc_value[i] != 0 )
  699.    //         nz_count++;
  700.    // }
  702.     if( value.uc_nz_byte > bytes )  return false;
  704.    // value.uc_nz_byte = nz_count;
  705.     return true;
  706. }
  708. //---------------------------------------------------------------------------
  709. bool IsValidHexBTHCIValue( AnsiString ansi_str, unsigned char bytes, S_BT_HCI_VALUE &value )
  710. {
  711.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_BTHCIValue( ansi_str, value ) , RANGE_ERR_BT_HCI_VALUE );
  713.    // unsigned char nz_count = 0;
  714.    // for( int i=0; i<BT_HCI_VALUE_SIZE; i++ )
  715.    // {
  716.    //     if(  value.uc_value[i] != 0 )
  717.    //         nz_count++;
  718.    // }
  720.     if( value.uc_nz_byte > bytes )  return false;
  722.    // value.uc_nz_byte = nz_count;
  723.     return true;
  724. }
  727. //---------------------------------------------------------------------------
  728. bool IsValidHexBTPIN( AnsiString ansi_str, S_BT_PIN &pin )
  729. {
  730.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_BTPIN( ansi_str, pin ) , RANGE_ERR_BT_PIN );
  732.     return true;
  733. }
  735. //---------------------------------------------------------------------------
  736. bool IsValidHexBDAddress( AnsiString ansi_str, unsigned char &address )
  737. {
  738.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedChar( ansi_str, address, 0, 15  ) , RANGE_ERR_BT_BD_ADDRESS );
  740.     return true;
  741. }
  743. //---------------------------------------------------------------------------
  744. bool  IsValidBTTimeout( AnsiString ansi_str, unsigned int &timeout )
  745. {   RANGE_CHECK_ERROR( !AnsiString_To_UnsignedInteger( ansi_str, timeout, 0, 10000000 ) , RANGE_ERR_BT_TIMEOUT );
  747.    return true;
  748. }
  750. //============================================================================
  751. //////////////////////////      ESCO     /////////////////////////////////////
  752. //============================================================================
  753. bool IsValidTxBandwidth( AnsiString ansi_str, unsigned int &ui_bandwidth )
  754. {
  755.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedInt( ansi_str, ui_bandwidth  ) , RANGE_ERR_BT_TX_BANDWIDTH );
  757.     return true;
  758. }
  760. //---------------------------------------------------------------------------
  761. bool IsValidRxBandwidth( AnsiString ansi_str, unsigned int &ui_bandwidth )
  762. {
  763.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedInt( ansi_str, ui_bandwidth ) , RANGE_ERR_BT_RX_BANDWIDTH );
  765.     return true;
  766. }
  768. //---------------------------------------------------------------------------
  769. bool IsValidMaxLatency( AnsiString ansi_str, unsigned short &us_latency )
  770. {
  771.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedShort( ansi_str, us_latency  ) , RANGE_ERR_BT_MAX_LATENCY );
  773.     return true;
  774. }
  776. //---------------------------------------------------------------------------
  777. bool IsValidRetransmissionEffort( AnsiString ansi_str, unsigned char &uc_effort )
  778. {
  779.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedChar( ansi_str, uc_effort, 0, 0x02  ) , RANGE_ERR_BT_RETRANSMISSION_EFFORT );
  781.     return true;
  782. }