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

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

MTK

开发平台：

C++ Builder

misc.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) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  *   misc.cpp
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   Maui META APP
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *  Misc. function source
  49.  *
  50.  * Author:
  51.  * -------
  52.  *  Andy Ueng (mtk00490)
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * $Revision$
  59.  * $Modtime$
  60.  * $Log$
  61.  * 
  62.  *------------------------------------------------------------------------------
  63.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  64.  *============================================================================
  65.  ****************************************************************************/
  66. #pragma hdrstop
  68. #ifndef  _FT_UTILS_H_
  69. #include "ft_utils.h"
  70. #endif
  72. #ifndef META_DLL_H
  73. #include "meta.h"
  74. #endif
  76. #ifndef  _RF_COMMON_H_
  77. #include "rf_common.h"
  78. #endif
  80. #ifndef  _RF_APC_H_
  81. #include "rf_apc.h"
  82. #endif
  84. #ifndef  _RF_APC_8PSK_H_
  85. #include "rf_apc_8psk.h"
  86. #endif
  88. #ifndef  _RF_AFC_H_
  89. #include "rf_afc.h"
  90. #endif
  92. #ifndef  _MAN_ERROR_H_
  93. #include "man_error.h"
  94. #endif
  99. //------------------------------------------------------------------------------
  100. extern bool isBootTarget;
  102. //---------------------------------------------------------------------------
  103. static const short ARFCN_RANGE[][4] =
  104. {
  105.    {   0, 124, 975, 1023 },  /* GSM900  */
  106.    { 512, 885, 512,  885 },  /* DCS1800 */
  107.    { 512, 810, 512,  810 },  /* PCS1900 */
  108.    { 128, 251, 128,  251 },  /* GSM850  */
  109.    { 259, 293, 259,  293 }   /* GSM450  */
  110. };
  113. static const int APC_LOWEST_POWER_RANGE[][2] =
  114. {
  115.    { 0, 36 },  /* GSM900  */
  116.    { 0, 33 },  /* DCS1800 */
  117.    { 0, 33 },  /* PCS1900 */
  118.    { 0, 36 },  /* GSM850  */
  119.    { 0, 36 }   /* GSM450  */
  120. };
  122. // convert
  123. //---------------------------------------------------------------------------
  124. bool IsValidDelay(AnsiString ansi_str, int &delay)
  125. {
  126.    RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, delay), RANGE_ERR_DELAY);
  127.    return true;
  128. }
  130. //---------------------------------------------------------------------------
  131. bool IsValidARFCN(AnsiString ansi_str, E_BANDSEL band, short &arfcn)
  132. {
  133.     bool invalid = true;
  135.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, arfcn), RANGE_ERR_ARFCN);
  136.     if (((arfcn>=ARFCN_RANGE[band][0])&&(arfcn<=ARFCN_RANGE[band][1]))||
  137.         ((arfcn>=ARFCN_RANGE[band][2])&&(arfcn<=ARFCN_RANGE[band][3]))  )
  138.     {
  139.         invalid = false;
  140.     }
  141.     RANGE_CHECK_ERROR(invalid, RANGE_ERR_ARFCN);
  142.     return true;
  143. }
  145. //---------------------------------------------------------------------------
  146. bool IsValidARFCN2(AnsiString ansi_str, E_BANDSEL band, short &arfcn)
  147. {
  148.     bool invalid = true;
  149.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, arfcn), RANGE_ERR_ARFCN2);
  150.     if ((-1 == arfcn)||
  151.         ((arfcn>=ARFCN_RANGE[band][0])&&(arfcn<=ARFCN_RANGE[band][1]))||
  152.         ((arfcn>=ARFCN_RANGE[band][2])&&(arfcn<=ARFCN_RANGE[band][3]))
  153.        )
  154.     {
  155.         invalid = false;
  156.     }
  157.     RANGE_CHECK_ERROR(invalid, RANGE_ERR_ARFCN);
  158.     return true;
  159. }
  161. //---------------------------------------------------------------------------
  162. bool IsValidARFCNStep(AnsiString ansi_str, short &arfcn_step)
  163. {
  164.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, arfcn_step), RANGE_ERR_ARFCN_STEP);
  165.     RANGE_CHECK_ERROR(arfcn_step <= 0                             , RANGE_ERR_ARFCN_STEP);
  166.     return true;
  167. }
  169. //---------------------------------------------------------------------------
  170. bool IsValidApcLowestPower(AnsiString ansi_str, int band, int &apc_lowest_power)
  171. {
  172.     bool invalid = true;
  173.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, apc_lowest_power), RANGE_ERR_APC_LOWEST_POWER);
  174.     if ((apc_lowest_power >= APC_LOWEST_POWER_RANGE[band][0]) && (apc_lowest_power<=APC_LOWEST_POWER_RANGE[band][1]))
  175.     {
  176.         invalid = false;
  177.     }
  178.     RANGE_CHECK_ERROR(invalid, RANGE_ERR_APC_LOWEST_POWER);
  179.     return true;
  180. }
  182. //---------------------------------------------------------------------------
  183. bool IsValidPMCount(AnsiString ansi_str, unsigned int &pmcount)
  184. {
  185.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, pmcount, 1, 2147483647), RANGE_ERR_PM_COUNT);
  186.     return true;
  187. }
  189. //---------------------------------------------------------------------------
  190. bool IsValidAFCCount(AnsiString ansi_str, short &count)
  191. {
  192.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, count, 1, 32767), RANGE_ERR_AFC_COUNT);
  193.     return true;
  194. }
  196. //---------------------------------------------------------------------------
  197. bool IsValidGain(AnsiString ansi_str, int &gain)
  198. {
  199.     float f_gain;
  200.     RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, f_gain), RANGE_ERR_GAIN);
  201.     gain = (int) (f_gain*8);
  202.     return true;
  203. }
  205. //---------------------------------------------------------------------------
  206. bool IsValidPathLoss(AnsiString ansi_str, float &path_loss)
  207. {
  208.     RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, path_loss), RANGE_ERR_PATH_LOSS);
  209.     return true;
  210. }
  212. //----------------------------------------------------------------------------
  213. bool IsValidRegBit(AnsiString ansi_str, unsigned char &bit)
  214. {
  215.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, bit, 0, 1), RANGE_ERR_REG_BIT);
  216.     return true;
  217. }
  219. //---------------------------------------------------------------------------
  220. bool IsValidMeasurementCount(AnsiString ansi_str, unsigned int &measuremnt_count)
  221. {
  222.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, measuremnt_count, 1, 4294967295), RANGE_ERR_MEASUREMENT_COUNT);
  223.     return true;
  224. }
  226. //---------------------------------------------------------------------------
  227. bool IsValidPeriod(AnsiString ansi_str, unsigned int &period)
  228. {
  229.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, period, 1000, 4294967295), RANGE_ERR_PERIOD);
  231.     return true;
  232. }
  234. //---------------------------------------------------------------------------
  235. bool IsValidRefDetSlopeSkew(AnsiString ansi_str, unsigned char &skew)
  236. {
  237.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, skew, 0, 255), RANGE_ERR_REFDET_SLOPE_SKEW);
  238.     return true;
  239. }
  241. //---------------------------------------------------------------------------
  242. bool IsValidAmFbDac(AnsiString ansi_str, unsigned char &dac)
  243. {
  244.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, dac, 0, 255), RANGE_ERR_AM_FB_DAC);
  245.     return true;
  246. }
  248. //---------------------------------------------------------------------------
  249. extern bool  IsValidAmFbDac(AnsiString ansi_str, unsigned char &dac);
  250. //---------------------------------------------------------------------------
  251. bool IsValidPCL(AnsiString ansi_str, int band, int &pcl)
  252. {
  253.     static const int PCL_RANGE[][2] =
  254.     {
  255.         {4,  31},  /* GSM900  */
  256.         {0,  28},  /* DCS1800 */
  257.         {0,  15},  /* PCS1900 */
  258.         {4,  31}  /* GSM850 */
  259.     };
  261.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, pcl), RANGE_ERR_PCL);
  262.     if (pcl != -1)
  263.     {
  264.         RANGE_CHECK_ERROR((pcl<PCL_RANGE[band][0])||(pcl>PCL_RANGE[band][1]) , RANGE_ERR_PCL );
  265.     }
  267.     return true;
  268. }
  270. //---------------------------------------------------------------------------
  271. bool IsValidCFGPCL(AnsiString ansi_str, int band, int &pcl)
  272. {
  273.     static const int PCL_RANGE[][2] =
  274.     {
  275.         {4, 31},  /* GSM400 */
  276.         {4, 31},  /* GSM850 */
  277.         {4, 31},  /* GSM900  */
  278.         {0, 28},  /* DCS1800 */
  279.         {0, 15},  /* PCS1900 */
  280.     };
  282.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, pcl)                , RANGE_ERR_CFG_PCL);
  283.     RANGE_CHECK_ERROR((pcl<PCL_RANGE[band][0]) || (pcl>PCL_RANGE[band][1]) , RANGE_ERR_CFG_PCL);
  284.     return true;
  285. }
  287. //---------------------------------------------------------------------------
  288. bool IsValidCFGMAX_P(AnsiString ansi_str, double &d_max_p)
  289. {
  290.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_max_p), RANGE_ERR_CFG_MAX_P);
  291.     return true;
  292. }
  294. //---------------------------------------------------------------------------
  295. bool IsValidCFGWANTED_P(AnsiString ansi_str, double &d_wanted_p)
  296. {
  297.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_wanted_p), RANGE_ERR_CFG_WANTED_P);
  298.     return true;
  299. }
  301. //---------------------------------------------------------------------------
  302. bool IsValidCFGMIN_P(AnsiString ansi_str, double &d_min_p)
  303. {
  304.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_min_p), RANGE_ERR_CFG_MIN_P);
  305.     return true;
  306. }
  308. //---------------------------------------------------------------------------
  309. bool IsValidCFGC(AnsiString ansi_str, double &d_c)
  310. {
  311.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_c), RANGE_ERR_CFG_C);
  312.     return true;
  313. }
  315. //---------------------------------------------------------------------------
  316. bool IsValidCFGCORRECTION(AnsiString ansi_str, double &d_correction)
  317. {
  318.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_correction), RANGE_ERR_CFG_CORRECTION);
  319.     return true;
  320. }
  322. //---------------------------------------------------------------------------
  323. bool IsValidCFGRecursiveTimes(AnsiString ansi_str, int &i_RecursiveTimes)
  324. {
  325.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_RecursiveTimes), RANGE_ERR_RECURSIVE_TIMES);
  326.     RANGE_CHECK_ERROR(i_RecursiveTimes<=-1                              , RANGE_ERR_RECURSIVE_TIMES);
  327.     return true;
  328. }
  330. //---------------------------------------------------------------------------
  331. bool IsValidCFGTSC(AnsiString ansi_str, char &c_TSC)
  332. {
  333.     RANGE_CHECK_ERROR(!AnsiString_To_char(ansi_str, c_TSC, 0, 7), RANGE_ERR_CFG_TSC);
  334.     RANGE_CHECK_ERROR(c_TSC<=-1                                 , RANGE_ERR_CFG_TSC);
  335.     return true;
  336. }
  338. //---------------------------------------------------------------------------
  339. bool IsValidCFGAPCDelta(AnsiString ansi_str, double &d_APCDelta)
  340. {
  341.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_APCDelta), RANGE_ERR_CFG_APC_DELTA);
  342.     return true;
  343. }
  345. //---------------------------------------------------------------------------
  346. bool IsValidPCLDac(AnsiString ansi_str, unsigned short &pcl_dac)
  347. {
  348.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedShort(ansi_str, pcl_dac, 0, 1023) , RANGE_ERR_PCL_DAC);
  349.     return true;
  350. }
  352. //---------------------------------------------------------------------------
  353. bool IsValidVbias(unsigned int ui_rf_id, AnsiString ansi_str, unsigned char &vbias)
  354. {
  355.     if (RF_ID_AERO2E != ui_rf_id)
  356.     {
  357.         RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, vbias, MIN_PA_VBIAS, MAX_PA_VBIAS_MT6140), RANGE_ERR_VBIAS);
  358.     }
  359.     else
  360.     {
  361.         RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, vbias, MIN_PA_VBIAS, MAX_PA_VBIAS_AERO2E), RANGE_ERR_VBIAS);
  362.     }
  364.     return true;
  365. }
  367. //---------------------------------------------------------------------------
  368. bool IsValidAFC(AnsiString ansi_str, short &afc)
  369. {
  370.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, afc, 0, 8191) , RANGE_ERR_AFC);
  371.     return true;
  372. }
  374. //---------------------------------------------------------------------------
  375. bool IsValidFreqErr(AnsiString ansi_str, double &freq_err)
  376. {
  377.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, freq_err), RANGE_ERR_FREQERR);
  378.     return true;
  379. }
  381. //---------------------------------------------------------------------------
  382. bool IsValidBand(AnsiString &band)
  383. {
  384.     AnsiString BAND_NAME[] =
  385.     {
  386.         "GSM",
  387.         "DCS",
  388.         "PCS",
  389.         "GSM850"
  390.     };
  392.     for (int i=0; i<sizeof(BAND_NAME)/sizeof(BAND_NAME[0]); i++)
  393.     {
  394.         if (BAND_NAME[i].AnsiCompareIC(band) == 0)
  395.         {
  396.             return true;
  397.         }
  398.     }
  399.     return false;
  400. }
  402. //---------------------------------------------------------------------------
  403. bool IsValidCAPID63(AnsiString ansi_str, int &cap_id)
  404. {
  405.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, cap_id, 0, 63) , RANGE_ERR_CAPID);
  406.     return true;
  407. }
  409. //---------------------------------------------------------------------------
  410. bool IsValidCAPID127(AnsiString ansi_str, int &cap_id)
  411. {
  412.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, cap_id, 0, 127), RANGE_ERR_CAPID);
  413.     return true;
  414. }
  416. //---------------------------------------------------------------------------
  417. bool IsValidCAPID511(AnsiString ansi_str, int &cap_id)
  418. {
  419.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, cap_id, 0, 511), RANGE_ERR_CAPID);
  420.     return true;
  421. }
  423. //---------------------------------------------------------------------------
  424. bool IsValidTA(AnsiString ansi_str, int &ta)
  425. {
  426.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, ta, 0, 63), RANGE_ERR_TA);
  427.     return true;
  428. }
  430. //---------------------------------------------------------------------------
  431. //////////////////////////////      IP2      ////////////////////////////////
  432. //---------------------------------------------------------------------------
  433. bool IsValidSky74045Icorrection(AnsiString ansi_str, signed char &i_corr)
  434. {
  435.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, i_corr, -127, 127), RANGE_ERR_ICORRECTION);
  436.     return true;
  437. }
  439. //---------------------------------------------------------------------------
  440. bool IsValidSky74045Qcorrection(AnsiString ansi_str, signed char &q_corr)
  441. {
  442.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, q_corr, -127, 127), RANGE_ERR_QCORRECTION);
  443.     return true;
  444. }
  446. //---------------------------------------------------------------------------
  447. bool IsValidSky74117Icorrection(AnsiString ansi_str, signed char &i_corr)
  448. {
  449.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, i_corr, -63, 63), RANGE_ERR_ICORRECTION);
  450.     return true;
  451. }
  453. //---------------------------------------------------------------------------
  454. bool IsValidSky74117Qcorrection(AnsiString ansi_str, signed char &q_corr)
  455. {
  456.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, q_corr, -63, 63), RANGE_ERR_QCORRECTION);
  457.     return true;
  458. }
  460. //---------------------------------------------------------------------------
  461. bool IsValidAcode(AnsiString ansi_str, unsigned char &acode)
  462. {
  463.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, acode, 0, 63), RANGE_ERR_ACODE);
  464.     return true;
  465. }
  467. //---------------------------------------------------------------------------
  468. bool IsValidAmcode(AnsiString ansi_str, unsigned char &amcode)
  469. {
  470.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, amcode, 0, 255), RANGE_ERR_AMCODE);
  471.     return true;
  472. }
  474. //---------------------------------------------------------------------------
  475. bool IsValidAmcode127(AnsiString ansi_str, unsigned char &amcode)
  476. {
  477.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, amcode, 0, 127), RANGE_ERR_AMCODE);
  478.     return true;
  479. }
  481. //---------------------------------------------------------------------------
  482. bool IsValidBcode(AnsiString ansi_str, unsigned char &bcode)
  483. {
  484.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, bcode, 0, 127), RANGE_ERR_BCODE);
  485.     return true;
  486. }
  488. //---------------------------------------------------------------------------
  489. bool IsValidCcode(AnsiString ansi_str, unsigned char &ccode)
  490. {
  491.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, ccode, 0, 127), RANGE_ERR_CCODE);
  492.     return true;
  493. }
  495. //---------------------------------------------------------------------------
  496. bool IsValidMultiSlotTxPattern(AnsiString ansi_str, unsigned short &pattern)
  497. {
  498.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedBinary(ansi_str, pattern, 0, 65535), RANGE_ERR_MUTLISLOT_TX_PATTERN);
  499.     return true;
  500. }
  502. //---------------------------------------------------------------------------
  503. bool IsValidCTPattern(AnsiString ansi_str, unsigned short &pattern)
  504. {
  505.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedBinary(ansi_str, pattern, 0, 65535), RANGE_ERR_CT_PATTERN);
  506.     return true;
  507. }
  509. //---------------------------------------------------------------------------
  510. bool IsValidC3TA(AnsiString ansi_str, unsigned char &ta)
  511. {
  512.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, ta, 0, 7), RANGE_ERR_C3TA);
  513.     return true;
  514. }
  516. //---------------------------------------------------------------------------
  517. bool IsValidC3TB(AnsiString ansi_str, unsigned char &tb)
  518. {
  519.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, tb, 0, 3), RANGE_ERR_C3TB);
  520.     return true;
  521. }
  523. //---------------------------------------------------------------------------
  524. bool IsValidC3TC(AnsiString ansi_str, unsigned char &tc)
  525. {
  526.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, tc, 0, 3), RANGE_ERR_C3TC);
  527.     return true;
  528. }
  530. //---------------------------------------------------------------------------
  531. bool IsValidC3TN(AnsiString ansi_str, unsigned char &tn)
  532. {
  533.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, tn, 0, 63), RANGE_ERR_C3TN);
  534.     return true;
  535. }
  537. //---------------------------------------------------------------------------
  538. bool IsValidC3TO(AnsiString ansi_str, unsigned char &to)
  539. {
  540.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, to, 0, 15), RANGE_ERR_C3TO);
  541.     return true;
  542. }
  544. //---------------------------------------------------------------------------
  545. bool IsValidC3PM(AnsiString ansi_str, unsigned char &pm)
  546. {
  547.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, pm, 0, 15), RANGE_ERR_C3PM);
  548.     return true;
  549. }
  551. //---------------------------------------------------------------------------
  552. bool IsValidAFCSlope(AnsiString ansi_str, int &slope)
  553. {
  554.     float f_gain;
  555.     RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, f_gain), RANGE_ERR_AFC_SLOPE);
  556.     if (0.0 == f_gain)
  557.     {
  558.         f_gain=0.00000001;
  559.     }
  560.     slope = (int)(AFC_SLOPE_SCALE/f_gain);
  561.     return true;
  562. }
  564. //---------------------------------------------------------------------------
  565. bool IsValid2GAFCSlope(AnsiString ansi_str, double &slope)
  566. {
  567.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, slope), RANGE_ERR_AFC_SLOPE);
  568.     return true;
  569. }
  571. //---------------------------------------------------------------------------
  572. bool IsValidCFGAFCSlope(AnsiString ansi_str, double &slope)
  573. {
  574.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, slope), RANGE_ERR_CFG_AFC_SLOPE);
  575.     return true;
  576. }
  578. //---------------------------------------------------------------------------
  579. bool IsValidCFGFrequencyErrorPPM(AnsiString ansi_str, double &ppm)
  580. {
  581.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, ppm), RANGE_ERR_CFG_FREQUENCY_ERROR_PPM);
  582.     return true;
  583. }
  585. //---------------------------------------------------------------------------
  586. bool IsValidCFGFrequencyError(AnsiString ansi_str, double &freq_err)
  587. {
  588.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, freq_err), RANGE_ERR_CFG_FREQUENCY_ERROR);
  589.     return true;
  590. }
  592. //==============================================================================
  593. //////////////////////////////  BB TX Parameters  //////////////////////////////
  594. //==============================================================================
  595. //---------------------------------------------------------------------------
  596. bool IsValidTrimIQ(AnsiString ansi_str, signed char &trim_iq)
  597. {
  598.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, trim_iq, -8, 7) , RANGE_ERR_TRIM_IQ);
  599.     return true;
  600. }
  602. //---------------------------------------------------------------------------
  603. bool  IsValidTrimIQStep(AnsiString ansi_str, char &trim_iq_step)
  604. {
  605.     RANGE_CHECK_ERROR(!AnsiString_To_char(ansi_str, trim_iq_step, 1, 15) , RANGE_ERR_TRIM_IQ_STEP);
  606.     return true;
  607. }
  609. //---------------------------------------------------------------------------
  610. bool IsValidOffsetIQ(E_BBTXCFG_VER_T eBbTxCfgVer, AnsiString ansi_str, signed char &offiq)
  611. {
  612.     if (eBbTxCfgVer < BBTXCFG_VER4)
  613.     {
  614.         RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, offiq, MIN_OFFSET_IQ_OLD, MAX_OFFSET_IQ_OLD), RANGE_ERR_OFFSET_IQ);
  615.     }
  616.     else
  617.     {
  618.         RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, offiq, MIN_OFFSET_IQ_NEW, MAX_OFFSET_IQ_NEW), RANGE_ERR_OFFSET_IQ);
  619.     }
  620.     return true;
  621. }
  623. //---------------------------------------------------------------------------
  624. bool IsValidBBTXCalibratedFlag(AnsiString ansi_str, unsigned char &cal_flag)
  625. {
  626.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, cal_flag, 0, 255), RANGE_ERR_BB_TX_CAL_FLAG );
  627.     return true;
  628. }
  630. //---------------------------------------------------------------------------
  631. bool IsValidOffsetIQStep(AnsiString ansi_str, char &off_iq_step)
  632. {
  633.     RANGE_CHECK_ERROR(!AnsiString_To_char(ansi_str, off_iq_step, 1, 63), RANGE_ERR_OFFSET_IQ_STEP);
  634.     return true;
  635. }
  637. //---------------------------------------------------------------------------
  638. bool IsValidTxCalbias(E_BBTXCFG_VER_T eBbTxCfgVer, AnsiString ansi_str, signed char &calbias)
  639. {
  640.     if (BBTXCFG_VER2 == eBbTxCfgVer)
  641.     {
  642.         RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, calbias, MIN_CALBIAS_OLD, MAX_CALBIAS_OLD), RANGE_ERR_TX_CALBIAS);
  643.     }
  644.     else
  645.     {
  646.         RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, calbias, MIN_CALBIAS_NEW, MAX_CALBIAS_NEW), RANGE_ERR_TX_CALBIAS);
  647.     }
  648.     return true;
  649. }
  651. //---------------------------------------------------------------------------
  652. bool IsValidTxIQSwap(AnsiString ansi_str, char &iq_swap)
  653. {
  654.     RANGE_CHECK_ERROR(!AnsiString_To_char(ansi_str, iq_swap, 0, 1), RANGE_ERR_TX_IQSWAP);
  655.     return true;
  656. }
  658. //---------------------------------------------------------------------------
  659. bool IsValidBBTXCommonModeVoltage(AnsiString ansi_str, signed char &voltage)
  660. {
  661.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, voltage, -4, 3), RANGE_ERR_BB_TX_COMMON_MODE_VOLTAGE);
  662.     return true;
  663. }
  665. //------------------------------------------------------------------------------
  666. bool IsValidBBTXGain(AnsiString ansi_str, signed char &gain)
  667. {
  668.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, gain, -4, 3), RANGE_ERR_BB_TX_GAIN);
  669.     return true;
  670. }
  672. //------------------------------------------------------------------------------
  673. bool IsValidBBTXCalrcsel(AnsiString ansi_str, signed char &Calrcsel)
  674. {
  675.     RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, Calrcsel, -4, 3), RANGE_ERR_CALRCSEL);
  676.     return true;
  677. }
  679. //------------------------------------------------------------------------------
  680. bool IsValidBBTXPhasesel(E_BBTXCFG_VER_T eBbTxCfgVer, AnsiString ansi_str, signed char &Phasesel)
  681. {
  682.     if (eBbTxCfgVer <= BBTXCFG_VER4)
  683.     {
  684.         RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, Phasesel, MIN_PHASESEL_OLD, MAX_PHASESEL_OLD), RANGE_ERR_PHASESEL);
  685.     }
  686.     else
  687.     {
  688.         RANGE_CHECK_ERROR(!AnsiString_To_signedchar(ansi_str, Phasesel, MIN_PHASESEL_NEW, MAX_PHASESEL_NEW), RANGE_ERR_PHASESEL);
  689.     }
  690.     return true;
  691. }
  693. //------------------------------------------------------------------------------
  694. bool IsValidBBTXPhaseselStep(AnsiString ansi_str, char &Phasesel_step)
  695. {
  696.     RANGE_CHECK_ERROR(!AnsiString_To_char(ansi_str, Phasesel_step, 1, 11), RANGE_ERR_PHASESEL_STEP);
  697.     return true;
  698. }
  700. //------------------------------------------------------------------------------
  701. bool IsValidAPCBatLowVoltage(AnsiString ansi_str, double &voltage)
  702. {
  703.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, voltage, 0, 10.0), RANGE_ERR_APC_BAT_LOW_VOLTAGE);
  704.     return true;
  705. }
  707. //------------------------------------------------------------------------------
  708. bool IsValidAPCBatHighVoltage(AnsiString ansi_str, double &voltage)
  709. {
  710.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, voltage, 0, 10.0), RANGE_ERR_APC_BAT_HIGH_VOLTAGE);
  711.     return true;
  712. }
  714. //------------------------------------------------------------------------------
  715. bool IsValidAPCBatLowTemperature(AnsiString ansi_str, double &temperature)
  716. {
  717.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, temperature, -50.0, 100.0), RANGE_ERR_APC_BAT_LOW_TEMPERATURE);
  718.     return true;
  719. }
  721. //------------------------------------------------------------------------------
  722. bool IsValidAPCBatHighTemperature(AnsiString ansi_str, double &temperature)
  723. {
  724.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, temperature, -50.0, 100.0), RANGE_ERR_APC_BAT_HIGH_TEMPERATURE);
  725.     return true;
  726. }
  728. //---------------------------------------------------------------------------
  729. bool IsValidRamp(AnsiString ansi_str, unsigned char &ramp)
  730. {
  731.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, ramp, 0, 255), RANGE_ERR_RAMP);
  732.     return true;
  733. }
  735. //---------------------------------------------------------------------------
  736. bool IsValidWeight(AnsiString ansi_str, unsigned int rf_id, unsigned short &weight)
  737. {
  738.     if (RF_ID_A60111A != rf_id)
  739.     {
  740.         float f_weight;
  741.         RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, f_weight, 0.0, 3.99), RANGE_ERR_WEIGHT);
  742.         weight = (unsigned short)(f_weight*WEIGHT_SCALE);
  743.     }
  744.     else
  745.     {
  746.         short s_weight;
  747.         RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, s_weight, -4, 4), RANGE_ERR_WEIGHT);
  748.         weight = (unsigned short) (s_weight + A60111A_WEIGHT_OFFSET);
  749.     }
  750.     return true;
  751. }
  753. //---------------------------------------------------------------------------
  754. bool IsValidADCSlope(AnsiString ansi_str, int &slope)
  755. {
  756.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, slope), RANGE_ERR_ADC_SLOPE);
  757.     return true;
  758. }
  760. //---------------------------------------------------------------------------
  761. bool IsValidADCOffset(AnsiString ansi_str, int &dcoffset)
  762. {
  763.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, dcoffset), RANGE_ERR_ADC_OFFSET);
  764.     return true;
  765. }
  767. //---------------------------------------------------------------------------
  768. bool IsValidADCInput(AnsiString ansi_str, int &adc_input)
  769. {
  770.     float fdata;
  771.     RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, fdata), RANGE_ERR_ADC_INPUT);
  772.     fdata *= 1000;
  773.     fdata += (fdata>=0) ? 0.5 : -0.5 ;
  774.     adc_input = (int)fdata;
  775.     return true;
  776. }
  778. //---------------------------------------------------------------------------
  779. bool IsValidADCVoltage(AnsiString ansi_str, int &adc_voltage)
  780. {
  781.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, adc_voltage), RANGE_ERR_ADC_VOLTAGE);
  782.     return true;
  783. }
  785. //---------------------------------------------------------------------------
  786. bool IsValidCurrentLimit(AnsiString ansi_str, int &current_limit)
  787. {
  788.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, current_limit), RANGE_ERR_CURRENT_LIMIT);
  789.     return true;
  790. }
  792. //---------------------------------------------------------------------------
  793. bool IsValidADCChannel(AnsiString ansi_str, int &adc_channel)
  794. {
  795.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, adc_channel), RANGE_ERR_ADC_CHANNEL);
  796.     RANGE_CHECK_ERROR(adc_channel <= -1                            , RANGE_ERR_ADC_CHANNEL);
  797.     return true;
  798. }
  800. //---------------------------------------------------------------------------
  801. bool IsValidADCResistance(AnsiString ansi_str, double &adc_resistance)
  802. {
  803.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, adc_resistance), RANGE_ERR_ADC_RESISTANCE);
  804.     RANGE_CHECK_ERROR(adc_resistance <= 0                            , RANGE_ERR_ADC_RESISTANCE);
  805.     return true;
  806. }
  808. //---------------------------------------------------------------------------
  809. bool IsValidADCMaxVoltageDifference(AnsiString ansi_str, double &adc_max_voltage_difference)
  810. {
  811.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, adc_max_voltage_difference), RANGE_ERR_ADC_MAX_VOLTAGE_DIFFERENCE);
  812.     RANGE_CHECK_ERROR(adc_max_voltage_difference <= 0                            , RANGE_ERR_ADC_MAX_VOLTAGE_DIFFERENCE);
  813.     return true;
  814. }
  816. //---------------------------------------------------------------------------
  817. bool IsValidADCMaxCurrentDifference(AnsiString ansi_str, double &adc_max_current_difference)
  818. {
  819.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, adc_max_current_difference), RANGE_ERR_ADC_MAX_CURRENT_DIFFERENCE);
  820.     RANGE_CHECK_ERROR(adc_max_current_difference <= 0                             , RANGE_ERR_ADC_MAX_CURRENT_DIFFERENCE);
  821.     return true;
  822. }
  824. //---------------------------------------------------------------------------
  825. bool IsValidADCMeasurementCount(AnsiString ansi_str, int &adc_measurement_count)
  826. {
  827.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, adc_measurement_count), RANGE_ERR_ADC_MEASUREMENT_COUNT);
  828.     RANGE_CHECK_ERROR(adc_measurement_count<=0                               , RANGE_ERR_ADC_MEASUREMENT_COUNT);
  829.     return true;
  830. }
  832. //==============================================================================
  833. bool IsValidGPIBAddr(AnsiString ansi_str, int &GPIB_addr)
  834. {
  835.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, GPIB_addr) , RANGE_ERR_GPIB_ADDR);
  836.     RANGE_CHECK_ERROR(GPIB_addr<=-1                               , RANGE_ERR_GPIB_ADDR);
  837.     return true;
  838. }
  840. //---------------------------------------------------------------------------
  841. bool IsValidTimeout(AnsiString ansi_str, int &timeout )
  842. {
  843.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, timeout), RANGE_ERR_TIMEOUT);
  844.     RANGE_CHECK_ERROR(timeout<=-1                              , RANGE_ERR_TIMEOUT);
  845.     return true;
  846. }
  848. //---------------------------------------------------------------------------
  849. bool IsValidCableLoss(AnsiString ansi_str, double &cable_loss)
  850. {
  851.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, cable_loss), RANGE_ERR_CABLE_LOSS);
  852.     return true;
  853. }
  855. //---------------------------------------------------------------------------
  856. bool IsValidPower(AnsiString ansi_str, double &power)
  857. {
  858.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, power), RANGE_ERR_POWER);
  859.     return true;
  860. }
  862. //==============================================================================
  863. ////////////////////////////// RX path loss CFG  ///////////////////////////////
  864. //==============================================================================
  865. bool IsValidCFGPMCount(AnsiString ansi_str, char m_pm, short &n_pm)
  866. {
  867.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, n_pm), RANGE_ERR_CFG_PMCOUNT);
  868.     if (n_pm * m_pm > 2000)
  869.     {
  870.         return false;
  871.     }
  872.     return true;
  873. }
  875. //==============================================================================
  876. //////////////////////////// phase error CFG  //////////////////////////////////
  877. //==============================================================================
  878. bool IsValidPhaseError(AnsiString ansi_str, double &d_ph_err)
  879. {
  880.     RANGE_CHECK_ERROR(!AnsiString_To_Double(ansi_str, d_ph_err), RANGE_ERR_PHASE_ERROR);
  881.     return true;
  882. }
  886. //===========================================================================
  887. static const int  pcl2power_table[][32] =
  888. {  //  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9  0  1
  889.    {  39,39,39,37,35,33,31,29,27,25,23,21,19,17,15,13,11, 9, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5  },  // GSM900
  890.    {  30,28,26,24,22,20,18,16,14,12,10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,36,34,32  },  // DCS1800
  891.    {  30,28,26,24,22,20,18,16,14,12,10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0, 0,33,33,33,33,33,33,33,33,33,32  },  // PCS1900
  892.    {  39,39,39,37,35,33,31,29,27,25,23,21,19,17,15,13,11, 9, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5  },  // GSM850
  894. };
  896. //---------------------------------------------------------------------------
  897. int PCL2POWER(int band, int pcl)
  898. {
  899.     if (pcl<0)  pcl=0;
  900.     if (pcl>31) pcl = 31;
  901.     int  power=pcl2power_table[band][pcl];
  902.     return(power);
  903. }
  905. //---------------------------------------------------------------------------
  906. static const int  power2pcl_table[][32] =
  907. {  //  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8
  908.    {  19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 2  },  // GSM900
  909.    {  15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,31,30,29  },  // DCS1800
  910.    {  15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,31,30,29  },  // PCS1900
  911.    {  19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 2  },  // GSM850
  912. };
  914. //---------------------------------------------------------------------------
  915. int POWER2PCL(int band, int power)
  916. {
  917.    if(band == BANDSEL_GSM900 || band==BANDSEL_GSM850)  power -= 5;
  918.    power/=2;
  919.    if(power<0)  power = 0;
  920.    if(power>31)  power = 31;
  921.    int pcl = power2pcl_table[band][power];
  922.    return(pcl);
  923. }
  925. //==============================================================================
  926. bool IsValidRepeats(AnsiString ansi_str, int &repeats)
  927. {
  928.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, repeats, 0, 255), RANGE_ERR_REPEATS);
  929.     return true;
  930. }
  932. //==============================================================================
  933. bool IsValidSpeakerVolume(AnsiString ansi_str, int &SpeakerVolume)
  934. {
  935.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, SpeakerVolume, 0, 6), RANGE_ERR_SPEAKERVOLUME);
  936.     return true;
  937. }
  939. //==============================================================================
  940. bool IsValidBuzzerVolume(AnsiString ansi_str, int &BuzzerVolume)
  941. {
  942.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, BuzzerVolume, 0, 7), RANGE_ERR_BUZZERVOLUME);
  943.     return true;
  944. }
  946. //==============================================================================
  947. bool IsValidVolume(AnsiString ansi_str, int &Volume)
  948. {
  949.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, Volume, 0, 6), RANGE_ERR_VOLUME);
  950.     return true;
  951. }
  953. //==============================================================================
  954. bool IsValidInstrument(AnsiString ansi_str, int &Instrument)
  955. {
  956.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, Instrument, 1, 128), RANGE_ERR_INSTRUMENT);
  957.     return true;
  958. }
  960. //==============================================================================
  961. bool getGPIBAddrNumFromStr(AnsiString as_str, int &i_gpib_addr_num)
  962. {
  963.     AnsiString as_gpib_addr_2;
  964.     int iLD = as_str.AnsiPos("::");
  965.     if (iLD <= 0)
  966.       return false;
  968.     as_gpib_addr_2 = as_str.SubString( iLD+2, as_str.Length() );
  969.     iLD = as_gpib_addr_2.LastDelimiter("::");
  970.     as_gpib_addr_2 =  as_gpib_addr_2.SubString( 1, iLD-2 );
  971.     i_gpib_addr_num = as_gpib_addr_2.ToInt();
  972.     return true;
  973. }
  975. //==============================================================================
  976. bool IsValidBatteryCompensate(AnsiString ansi_str, unsigned short &battery_compensate)
  977. {
  978.     float f_battery_compensate;
  979.     RANGE_CHECK_ERROR( !AnsiString_To_Float( ansi_str, f_battery_compensate, 0.1, 1.9) , RANGE_ERR_BATTERY_COMPENSATE );
  980.     battery_compensate = (unsigned short)(f_battery_compensate*BATTERY_COMPENSATE_SCALE);
  981.     return true;
  982. }
  984. //------------------------------------------------------------------------------
  985. bool IsValidTxAfcOffset(AnsiString ansi_str, short &tx_afc_offset)
  986. {
  987.     RANGE_CHECK_ERROR(!AnsiString_To_Short(ansi_str, tx_afc_offset, -65536, 65535), RANGE_ERR_TX_AFC_OFFSET);
  988.     return true;
  989. }
  991. //------------------------------------------------------------------------------
  992. bool IsValidInterslotLowestDAC(AnsiString ansi_str, unsigned char &dac)
  993. {
  994.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, dac, 0, 255), RANGE_ERR_INTERSLOT_LOWEST_DAC);
  995.     return true;
  996. }
  998. //---------------------------------------------------------------------------
  999. ////////////////////////////     BV        //////////////////////////////////
  1000. //---------------------------------------------------------------------------
  1001. bool IsValidBVAP(AnsiString ansi_str, int &i_ap)
  1002. {
  1003.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_ap, 0, 7), RANGE_ERR_BV_AP);
  1004.     return true;
  1005. }
  1007. //---------------------------------------------------------------------------
  1008. bool IsValidBVAS(AnsiString ansi_str, int &i_as)
  1009. {
  1010.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_as, 0, 7), RANGE_ERR_BV_AS);
  1011.     return true;
  1012. }
  1014. //---------------------------------------------------------------------------
  1015. bool IsValidBVAO(AnsiString ansi_str, int &i_ao)
  1016. {
  1017.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_ao, 0, 63), RANGE_ERR_BV_AO);
  1018.     return true;
  1019. }
  1021. //---------------------------------------------------------------------------
  1022. bool IsValidBVBD(AnsiString ansi_str, int &i_bd)
  1023. {
  1024.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_bd, 0, 31), RANGE_ERR_BV_BD);
  1025.     return true;
  1026. }
  1028. //---------------------------------------------------------------------------
  1029. bool IsValidBVKAG(AnsiString ansi_str, int &i_kag)
  1030. {
  1031.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_kag, 0, 31), RANGE_ERR_BV_KAG);
  1032.     return true;
  1033. }
  1035. //---------------------------------------------------------------------------
  1036. bool IsValidBVKSG(AnsiString ansi_str, int &i_ksg)
  1037. {
  1038.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_ksg, 0, 15), RANGE_ERR_BV_KSG);
  1039.     return true;
  1040. }
  1042. //---------------------------------------------------------------------------
  1043. bool IsValidBVKAD(AnsiString ansi_str, int &i_kad)
  1044. {
  1045.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_kad, 0, 31), RANGE_ERR_BV_KAD);
  1046.     return true;
  1047. }
  1049. //---------------------------------------------------------------------------
  1050. bool IsValidBVKSD(AnsiString ansi_str, int &i_ksd)
  1051. {
  1052.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_ksd, 0, 15), RANGE_ERR_BV_KSD);
  1053.     return true;
  1054. }
  1056. //---------------------------------------------------------------------------
  1057. bool IsValidBVVRE(AnsiString ansi_str, int &i_vre)
  1058. {
  1059.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_vre, 0, 1), RANGE_ERR_BV_VRE);
  1060.     return true;
  1061. }
  1063. //---------------------------------------------------------------------------
  1064. bool IsValidBVVOF(AnsiString ansi_str, int &i_vof)
  1065. {
  1066.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_vof, 0, 127), RANGE_ERR_BV_VOF);
  1067.     return true;
  1068. }
  1070. //---------------------------------------------------------------------------
  1071. bool IsValidBVARE(AnsiString ansi_str, int &i_are)
  1072. {
  1073.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_are, 0, 1), RANGE_ERR_BV_ARE);
  1074.     return true;
  1075. }
  1077. //---------------------------------------------------------------------------
  1078. bool IsValidBVAOF(AnsiString ansi_str, int &i_aof)
  1079. {
  1080.     RANGE_CHECK_ERROR(!AnsiString_To_Integer(ansi_str, i_aof, 0, 127), RANGE_ERR_BV_AOF);
  1081.     return true;
  1082. }
  1085. //==============================================================================
  1086. //////////////////////////////////   CTS   /////////////////////////////////////
  1087. //==============================================================================
  1088. //------------------------------------------------------------------------------
  1089. bool IsValidCTSTemperature(AnsiString ansi_str, float &temperature)
  1090. {
  1091.     RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, temperature, -20.0, 70.0), RANGE_ERR_CTS_TEMPERATURE);
  1092.     return true;
  1093. }
  1095. //------------------------------------------------------------------------------
  1096. bool IsValidCTSTemperatureStep(AnsiString ansi_str, float &temperature_step)
  1097. {
  1098.     RANGE_CHECK_ERROR(!AnsiString_To_Float(ansi_str, temperature_step, 0.1, 90.0), RANGE_ERR_CTS_TEMPERATURE_STEP);
  1099.     return true;
  1100. }
  1102. //==============================================================================
  1103. ///////////////////////////////   register   ///////////////////////////////////
  1104. //==============================================================================
  1105. bool IsValidHexBsiAddr(AnsiString ansi_str, unsigned int &bsi_addr)
  1106. {
  1107.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedInt(ansi_str, bsi_addr), RANGE_ERR_REG_ADDR);
  1108.     return true;
  1109. }
  1111. //------------------------------------------------------------------------------
  1112. bool IsValidDecBsiAddr(AnsiString ansi_str, unsigned int &bsi_addr)
  1113. {
  1114.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, bsi_addr, 1, 4294967295), RANGE_ERR_REG_ADDR);
  1115.     return true;
  1116. }
  1118. //------------------------------------------------------------------------------
  1119. bool IsValidHexBsiData(AnsiString ansi_str, unsigned int &bsi_data)
  1120. {
  1121.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedInt(ansi_str, bsi_data), RANGE_ERR_REG_VALUE);
  1122.     return true;
  1123. }
  1125. //------------------------------------------------------------------------------
  1126. bool IsValidDecBsiData(AnsiString ansi_str, unsigned int &bsi_data)
  1127. {
  1128.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, bsi_data, 1, 4294967295), RANGE_ERR_REG_VALUE);
  1129.     return true;
  1130. }