/* Copyright Statement: * * This software/firmware and related documentation ("AutoChips Software") are * protected under relevant copyright laws. The information contained herein is * confidential and proprietary to AutoChips Inc. and/or its licensors. Without * the prior written permission of AutoChips inc. and/or its licensors, any * reproduction, modification, use or disclosure of AutoChips Software, and * information contained herein, in whole or in part, shall be strictly * prohibited. * * AutoChips Inc. (C) 2016. All rights reserved. * * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("AUTOCHIPS SOFTWARE") * RECEIVED FROM AUTOCHIPS AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER * ON AN "AS-IS" BASIS ONLY. AUTOCHIPS EXPRESSLY DISCLAIMS ANY AND ALL * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR * NONINFRINGEMENT. NEITHER DOES AUTOCHIPS PROVIDE ANY WARRANTY WHATSOEVER WITH * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, * INCORPORATED IN, OR SUPPLIED WITH THE AUTOCHIPS SOFTWARE, AND RECEIVER AGREES * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN AUTOCHIPS * SOFTWARE. AUTOCHIPS SHALL ALSO NOT BE RESPONSIBLE FOR ANY AUTOCHIPS SOFTWARE * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND AUTOCHIPS'S * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE AUTOCHIPS SOFTWARE * RELEASED HEREUNDER WILL BE, AT AUTOCHIPS'S OPTION, TO REVISE OR REPLACE THE * AUTOCHIPS SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE * CHARGE PAID BY RECEIVER TO AUTOCHIPS FOR SUCH AUTOCHIPS SOFTWARE AT ISSUE. */ #include "ac780x_uart_reg.h" #include "ac780x_gpio.h" #include "Radar.h" #include "uart.h" #include "string.h" #include "crc16.h" #define LaDarUARTx UART0 #define LaDarUARTx_IRQn UART0_IRQn #define RADAR_RX_BUFF_LENGTH 7 #define RADAR_MAX_BUFFERSIZE 32 #define RadarCmd_NULL (0) #define RadarCmd_AirHeight (1) #define RadarCmd_Trans (2) uint8_t g_radarRxDataBuff[RADAR_RX_BUFF_LENGTH]; uint16_t g_radarRxDataIndex; uint8_t *g_radarTxDataPoint; uint16_t g_radarTxDataLength; uint16_t g_radarTxDataIndex; static uint8_t * p_float; //static float tmp_v; static int16_t tmp_v; //static uint16_t _crc = 0; static uint8_t recvbuffer_len = 0; static uint8_t databuffer_len = 0; static uint8_t trans_recvbuffer[RADAR_MAX_BUFFERSIZE] = {0}; //透传指令暂存buffer static uint8_t trans_databuffer[RADAR_MAX_BUFFERSIZE] = {0}; //透传回应数据暂存buffer #define WAITTING_TIMEOUT (100) //单位 ms static uint8_t cmd_radar = RadarCmd_NULL; uint8_t waiting_time_ladar =0; //等待数据时间， ms static uint8_t radar_timeout_count = 0; //雷达超时次数 static float airHeight = 0; static uint8_t _status = 0; //uint8_t radar_cmd[8] = {0x7F, 0x04, 0x0A, 0x0F, 0x00, 0x02, 0x48, 0x0E}; uint8_t radar_cmd[8] = {0xFF, 0x03, 0x00, 0x01, 0x00, 0x01, 0xC0, 0x14}; //static uint8_t radar_cmd[32]; //uint8_t //static uint32_t ladar_printfBuff[16]; //static uint16_t ladar_printfLen = 0; static int TransmitData(uint8_t *pdata, uint16_t length); /** * UartEventCallback * * @param[in] device: UART_Type pointer * @param[in] wpara: UART lsr0 register * @param[in] lpara: UART lsr1 register * @return none * * @brief uart receive handle */ static void UartEventCallback(void *device, uint32_t wpara, uint32_t lpara) { uint8_t data = 0; uint16_t _crc = 0; UART_Type *uart_Device = (UART_Type *)device; /*rx interrupt*/ if ((uart_Device->IER & UART_IER_ERXNE_Msk) && (wpara & UART_LSR0_DR_Msk)) { data = uart_Device->RBR; waiting_time_ladar =0; if(RadarCmd_AirHeight == cmd_radar){ radar_timeout_count = 0; g_radarRxDataBuff[g_radarRxDataIndex++] = data; if (g_radarRxDataIndex >= RADAR_RX_BUFF_LENGTH) { g_radarRxDataIndex = 0; _crc = crc16(g_radarRxDataBuff, RADAR_RX_BUFF_LENGTH-2); if( _crc == (((uint16_t)g_radarRxDataBuff[5]<<8) | g_radarRxDataBuff[6])){ _status = STATUS_NORMAL; tmp_v = (int16_t)(g_radarRxDataBuff[3]<<8)|g_radarRxDataBuff[4]; airHeight = tmp_v/1000.0; }else{ _status = STATUS_DataError; airHeight = 0.0; } //读空高命令结束 cmd_radar = RadarCmd_NULL; // ladar_printfLen = snprintf((char*)ladar_printfBuff, 64, "Radar st[%d], airheight: %f m [%x][%x][%x][%x][%x][%x][%x]\r\n", // _status, airHeight, // g_radarRxDataBuff[0], // g_radarRxDataBuff[1], // g_radarRxDataBuff[2], // g_radarRxDataBuff[3], // g_radarRxDataBuff[4], // g_radarRxDataBuff[5], // g_radarRxDataBuff[6]); // rs485_TransmitData((uint8_t*)ladar_printfBuff, ladar_printfLen); } }else if(RadarCmd_Trans == cmd_radar){ if(databuffer_len < RADAR_MAX_BUFFERSIZE){ trans_databuffer[databuffer_len++]=data; } } } /*tx interrupt*/ if ((uart_Device->IER & UART_IER_ETXE_Msk) && (wpara & UART_LSR0_THRE_Msk)) { uart_Device->RBR = g_radarTxDataPoint[g_radarTxDataIndex++]; if (g_radarTxDataIndex >= g_radarTxDataLength) { UART_SetTXEInterrupt(device, DISABLE); ///<发送最后一个字节时关闭发送空中断 } } } /** * uart_Initialize * * @param[in] none * @return none * * @brief uart 初始化 */ static void uart0_Initialize(void) { UART_ConfigType uartConfig = {0}; uartConfig.baudrate = 115200; uartConfig.dataBits = UART_WORD_LEN_8BIT; uartConfig.stopBits = UART_STOP_1BIT; uartConfig.parity = UART_PARI_NO; uartConfig.fifoByteEn = DISABLE; ///>8) & 0x00ff); //// radar_cmd[7] = (uint8_t)(crc & 0x00ff); // // TransmitData(radar_cmd, 8); // return 0; //} void Radar_CheckResponse(void) { if(RadarCmd_NULL != cmd_radar){ if(waiting_time_ladar >= WAITTING_TIMEOUT){ //通信命令结束 cmd_radar = RadarCmd_NULL; if(RadarCmd_AirHeight == cmd_radar){ radar_timeout_count++; g_radarRxDataIndex = 0; if(radar_timeout_count >= 3){ radar_timeout_count =3; _status = STATUS_NoResponse; airHeight = 0.0; } // ladar_printfLen = snprintf((char*)ladar_printfBuff, 64, "Radar_CheckResponse st[%d], airheight: %f m \r\n", _status, airHeight); // rs485_TransmitData((uint8_t*)ladar_printfBuff, ladar_printfLen); }else { recvbuffer_len = 0; } } } } void Radar_SendRequest(void) { if(RadarCmd_NULL != cmd_radar){ return; } // ladar_printfLen = snprintf((char*)ladar_printfBuff, 64, "Radar_SendRequest recvbuffer_len[%d] m \r\n", recvbuffer_len); // rs485_TransmitData((uint8_t*)ladar_printfBuff, ladar_printfLen); if(recvbuffer_len > 0){ //有透传数据需要发送 cmd_radar = RadarCmd_Trans; TransmitData(trans_recvbuffer, recvbuffer_len); waiting_time_ladar = 0; //清空接收缓存 databuffer_len=0; memset(trans_databuffer, 0, RADAR_MAX_BUFFERSIZE); }else{ //读取空高数据 cmd_radar = RadarCmd_AirHeight; TransmitData(radar_cmd, 8); waiting_time_ladar = 0; g_radarRxDataIndex = 0; } } void Radar_SendData(uint8_t* pData, uint8_t data_len) { if(data_len > RADAR_MAX_BUFFERSIZE){ return ; } if(RadarCmd_Trans == cmd_radar){ //上一个透传指令还没结束 return; } memcpy(trans_recvbuffer, pData, data_len); recvbuffer_len = data_len; } void Radar_ReadData(uint8_t* pBuffer, uint8_t read_len) { if(read_len > RADAR_MAX_BUFFERSIZE){ read_len = RADAR_MAX_BUFFERSIZE; } memcpy(pBuffer, trans_databuffer, read_len); //清空接收缓存 databuffer_len=0; memset(trans_databuffer, 0, RADAR_MAX_BUFFERSIZE); } //uint8_t Radar_SetInstallHeight(uint16_t install_height) //{ // //清空、接收缓冲 // g_radarRxDataIndex = 0; // TransmitData(radar_cmd, 8); // // return 0; //} uint8_t Radar_GetHeight(float* height) { *height = airHeight; return _status; } uint8_t Radar_Print(void) { return 0; } void Radar_DeInit(void) { } void Radar_Timer1_Callback(void) { if(waiting_time_ladar < 0xFF){ waiting_time_ladar++; } }