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

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

MTK

开发平台：

C++ Builder

CTS_ctrl.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. *****************************************************************************/
  35. /*****************************************************************************
  36.  *
  37.  * Filename:
  38.  * ---------
  39.  *   CTS_ctrl.cpp
  40.  *
  41.  * Project:
  42.  * --------
  43.  *   Maui META APP
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  Clima temperature system (CTS) control function source
  48.  *
  49.  * Author:
  50.  * -------
  51.  *  Andy Ueng (mtk00490)
  52.  *
  53.  *============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  56.  *------------------------------------------------------------------------------
  57.  * $Revision$
  58.  * $Modtime$
  59.  * $Log$
  60.  *
  61.  *------------------------------------------------------------------------------
  62.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  63.  *============================================================================
  64.  ****************************************************************************/
  65. #include <vcl.h>
  69. #pragma hdrstop
  71. #ifndef  _CTS_CTRL_H_
  72. #include "cts_ctrl.h"
  73. #endif
  75. #ifndef  _FT_UTILS_H_
  76. #include "ft_utils.h"
  77. #endif
  79. /*---------------------------------------------------------------------------*/
  80. static const char  CTS_CMD_BEGIN            =  0x02;
  81. static const char  CTS_CMD_ADR              =  0x81;
  82. static const char  CTS_CMD_START            =  0xF0;
  83. static const char  CTS_CMD_STOP             =  0xF0;
  84. static const char  CTS_CMD_TEMP_CHANNEL     =  0xB0;
  85. static const char  CTS_CMD_SET_ANALOG       =  0xE1;
  86. static const char  CTS_CMD_GET_ANALOG       =  0xC1;
  87. static const char  CTS_CHANNEL_TEMP         =  0xB0;
  88. static const char  CTS_CMD_END              =  0x03;
  89. static const char  CTS_BLANK                =  0xA0;
  92. #define  CTS_CMD_BUF_SIZE  256
  93. //===========================================================================
  94. CCTSCTRL::CCTSCTRL( void )
  95. {
  98. }
  100. //---------------------------------------------------------------------------
  101. CCTSCTRL::~CCTSCTRL()
  102. {
  104. }
  106. //=============================================================================
  107. bool CCTSCTRL::CTS_Init(int com_port)
  108. {
  109.     sUART  uart;
  111.     uart.com_port  = com_port;
  112.     uart.baud_rate = CBR_19200;
  113.     uart.byte_size = 8;
  114.     uart.parity    = ODDPARITY;
  115.     uart.stop_bits = ONESTOPBIT;
  116.     if(! UART_Obj.UART_Open( hCOM, uart ) )   return false;
  118.     return true;
  119. }
  121. //--------------------------------------------------------------------------
  122. bool CCTSCTRL::CTS_Close(void)
  123. {
  124.    UART_Obj.UART_Close( hCOM );
  125.    return true;
  126. }
  128. //--------------------------------------------------------------------------
  129. bool CCTSCTRL::CTS_Start( void )
  130. {
  131.     char cmd_data[CTS_CMD_BUF_SIZE];
  132.     char cmd[CTS_CMD_BUF_SIZE];
  134.     cmd_data[0] = CTS_CMD_ADR;
  135.     cmd_data[1] = CTS_CMD_START;
  136.     cmd_data[2] = 0xB0;
  137.     cmd_data[3] = 0xB0;
  138.     cmd_data[4] = 0xB1;
  139.     cmd_data[5] = '';
  140.     CTS_ComposeCmd( cmd_data, cmd );
  141.     UART_Obj.UART_SendData( hCOM, cmd );
  142.     return true;
  144. }
  146. //--------------------------------------------------------------------------
  147. bool CCTSCTRL::CTS_Stop( void )
  148. {
  149.     char cmd_data[CTS_CMD_BUF_SIZE];
  150.     char cmd[CTS_CMD_BUF_SIZE];
  152.     cmd_data[0] = CTS_CMD_ADR;
  153.     cmd_data[1] = CTS_CMD_STOP;
  154.     cmd_data[2] = 0xB0;
  155.     cmd_data[3] = 0xB0;
  156.     cmd_data[4] = 0xB0;
  157.     cmd_data[5] = '';
  158.     CTS_ComposeCmd( cmd_data, cmd );
  159.     UART_Obj.UART_SendData( hCOM, cmd );
  160.     return true;
  161. }
  163. //--------------------------------------------------------------------------
  164. bool CCTSCTRL::CTS_SetTemp( double temp )
  165. {
  166.     char cmd_temp[6];
  167.     char cmd_data[CTS_CMD_BUF_SIZE];
  168.     char cmd[CTS_CMD_BUF_SIZE];
  169.     int  i=0;
  171.     double_To_Array_ASCII_char( temp, cmd_temp );
  172.     cmd_temp[5] = '';
  173.     while( i<sizeof(cmd_temp) && cmd_temp[i]!='' )
  174.     {
  175.         cmd_temp[i] |= 0x80;
  176.         i++;
  177.     }
  179.     cmd_data[0] = CTS_CMD_ADR;
  180.     cmd_data[1] = CTS_CMD_SET_ANALOG;
  181.     cmd_data[2] = CTS_CMD_TEMP_CHANNEL;
  182.     cmd_data[3] = CTS_BLANK;
  183.     cmd_data[4] = '';
  184.     strcat(cmd_data, cmd_temp);
  186.     CTS_ComposeCmd( cmd_data, cmd );
  188.     UART_Obj.UART_SendData( hCOM, cmd );
  189.     return true;
  190. }
  192. //--------------------------------------------------------------------------
  193. bool CCTSCTRL::CTS_GetTemp( double &effective_temp, double &index_temp )
  194. {
  195.     char cmd_data[CTS_CMD_BUF_SIZE];
  196.     char cmd[CTS_CMD_BUF_SIZE];
  197.     char received_data[CTS_CMD_BUF_SIZE];
  198.     DWORD dw_byte_read;
  200.     cmd_data[0] = CTS_CMD_ADR;
  201.     cmd_data[1] = CTS_CMD_GET_ANALOG;
  202.     cmd_data[2] = CTS_CMD_TEMP_CHANNEL;
  203.     cmd_data[3] = '';
  205.     CTS_ComposeCmd( cmd_data, cmd );
  207.     UART_Obj.UART_SendData( hCOM, cmd );
  209.     for(int i=0; i<5; i++)
  210.     {
  211.         Sleep(500);
  212.         if( UART_Obj.UART_ReceiveData( hCOM, received_data, dw_byte_read ) ) break;
  213.     }
  214.     #if 0
  215.     received_data[0]  = 0x02;
  216.     received_data[1]  = 0x81;
  217.     received_data[2]  = 0xC1;
  218.     received_data[3]  = 0xB0;
  219.     received_data[4]  = 0xA0;
  220.     received_data[5]  = 0xAD;
  221.     received_data[6]  = 0xB1;
  222.     received_data[7]  = 0xB4;
  223.     received_data[8]  = 0xAE;
  224.     received_data[9]  = 0xB5;
  225.     received_data[10] = 0xA0;
  226.     received_data[11] = 0xAD;
  227.     received_data[12] = 0xB1;
  228.     received_data[13] = 0xB3;
  229.     received_data[14] = 0xAE;
  230.     received_data[15] = 0xB8;
  231.     received_data[16] = 0xFA;
  232.     received_data[17] = 0x03;
  233.     dw_byte_read = 18;
  234.     #endif
  235.     if(! CTS_ExtractTemp( received_data, dw_byte_read, effective_temp, index_temp ) )  return false;
  237.     return true;
  238. }
  240. //--------------------------------------------------------------------------
  241. bool CCTSCTRL::CTS_ExtractTemp( char* received_data, DWORD dw_byte_read, double &effective_temp, double &index_temp )
  242. {
  243.     char Temp_Header[5];
  244.     char effective_temp_array[6];
  245.     char index_temp_array[6];
  246.     int i;
  248.     if( ! CTS_TempHeaderBytesCheck(received_data)                                   ||
  249.         ! CTS_TempChkByteCheck( received_data, dw_byte_read, *(received_data+16) ) ||
  250.         ! CTS_TempTailByteCheck( received_data )
  251.       )
  252.       return false;
  254.     for(i=0;i<sizeof(effective_temp_array)-1; i++)
  255.     {
  256.         effective_temp_array[i] = *(received_data+5+i);
  257.     }
  258.     effective_temp_array[i]='';
  259.     ASCII_char_To_Array_double( effective_temp_array, effective_temp );
  261.     for(i=0;i<sizeof(index_temp_array)-1; i++)
  262.     {
  263.         index_temp_array[i] = *(received_data+11+i);
  264.     }
  265.     index_temp_array[i] = '';
  266.     ASCII_char_To_Array_double( index_temp_array, index_temp );
  267.     return true;
  268. }
  270. //--------------------------------------------------------------------------
  271. bool CCTSCTRL::CTS_TempHeaderBytesCheck( char* received_data )
  272. {
  273.     char Temp_Header[2];
  274.     Temp_Header[0] = 0x02;
  275.     Temp_Header[1] = 0x81;
  276.    // Temp_Header[2] = 0xC1;
  277.    // Temp_Header[3] = 0xB0;
  278.    // Temp_Header[4] = 0xA0;
  280.     for(int i=0; i<sizeof(Temp_Header); i++)
  281.     {
  282.        if( *(received_data+i) != Temp_Header[i] )  return false;
  283.     }
  284.     return true;
  285. }
  287. //--------------------------------------------------------------------------
  288. bool CCTSCTRL::CTS_TempChkByteCheck( char* received_data, DWORD dw_byte_read, char &r_chk )
  289. {
  290.     char c_chk=0;
  291.     for (unsigned int i=1; i<dw_byte_read-2; i++)
  292.     {
  293.         c_chk ^= *(received_data+i);
  294.     }
  296.     if(c_chk != r_chk)  return false;
  297.     return true;
  298. }
  300. //--------------------------------------------------------------------------
  301. bool CCTSCTRL::CTS_TempTailByteCheck( char* received_data )
  302. {
  303.     if( *(received_data+17) != CTS_CMD_END )  return false;
  305.     return true;
  306. }
  308. //--------------------------------------------------------------------------
  309. bool CCTSCTRL::CTS_ComposeCmd( char *cmd_data, char* cmd )
  310. {
  311.     char  cmd_chk=0;
  312.     int   i=0;
  313.     int   len;
  315.     while( cmd_data[i]!=0 && i<CTS_CMD_BUF_SIZE )
  316.     {
  317.         cmd_chk ^= cmd_data[i];
  318.         i++;
  319.     }
  320.     cmd_chk |= 0x80;
  321.     cmd[0] = CTS_CMD_BEGIN;
  322.     cmd[1] = '';
  323.     strcat(cmd, cmd_data);
  324.     len = strlen(cmd);
  325.     cmd[len]= cmd_chk;
  326.     cmd[len+1] = CTS_CMD_END;
  327.     cmd[len+2] = '';
  328.     return true;
  330. }
  332. //===========================================================================
  333. ////////////////////////////  Global information  ///////////////////////////
  334. //============================================================================
  335. HANDLE CCTSCTRL::CTS_GetComHandle( void )
  336. {
  337.     return hCOM;
  338. }
  340. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  341. DCB CCTSCTRL::Get_OriginalDCB( void )
  342. {
  343.      DCB dcb = UART_Obj.Get_OriginalDCB( );
  344.      return dcb;
  345. }
  347. //---------------------------------------------------------------------------
  348. bool CCTSCTRL::Set_OriginalDCB( DCB &dcb )
  349. {
  350.      UART_Obj.Set_OriginalDCB( dcb );
  351.      return true;
  352. }