You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
702 lines
24 KiB
702 lines
24 KiB
/**
|
|
* @file Ramses.c
|
|
* @author Chen Jihang (embedded@eseaoptics.com)
|
|
* @brief trios公司光谱仪驱动
|
|
* @version 1.0
|
|
* @date 2023-01-04
|
|
*
|
|
* @copyright ESEA (c) 2020
|
|
*
|
|
*/
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include "Ramses.h"
|
|
#include "elog.h"
|
|
#include "FreeRTOS.h"
|
|
#include "cmsis_os.h"
|
|
#include "usart.h"
|
|
|
|
#if 1
|
|
|
|
// #include "endian.h"
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
static uint8_t Ramses_SN_command[8] = {0x23, 0x00, 0x08, 0x0B, 0x00, 0x00, 0x00, 0x01};
|
|
static uint8_t Ramses_Data_command[8] = {0x23, 0x00, 0x00, 0x80, 0xA8, 0x00, 0x81, 0x01};
|
|
static uint8_t Ramses_Set_IT_Auto[8] = {0x23, 0x00, 0x00, 0x30, 0x78, 0x05, 0x00, 0x01};
|
|
|
|
My_Ramses_TypeDef myramses =
|
|
{
|
|
Ramses_init,
|
|
Ramses_Port,
|
|
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
Uart_Interface_Default, /* 接口类型 0: common, 1: 485 ,2:3160*/
|
|
Uart_RSMODE_232, /* mode_232_485 0 commome 1:485*/
|
|
Uart_Trans_DMA, /* trans_type0 :polling, 1: IT 2: DMA*/
|
|
Uart_Trans_DMA, /* rcv_type 0 :polling, 1: IT 2: DMA*/
|
|
Uart_IDLE_IT_ENABLE, /* idle_enable_disable 0 :不启用空闲 , 1: 启用空闲/
|
|
NULL, /* pointer huart*/
|
|
};
|
|
UART_HandleTypeDef *pRamsesUart = &huart2;
|
|
#define Ramses_Uart_IRQHandler USART2_IRQHandler
|
|
|
|
extern volatile uint8_t measure_flag ;
|
|
|
|
uint8_t Ramses_Rcv_Buf[Ramses_Rcv_Buf_Size] = {0};
|
|
uint8_t Ramses_Rcv_Buf_Copy[Ramses_Rcv_Buf_Size] = {0};
|
|
Ramses_TypeDef *ramses;
|
|
|
|
osThreadId_t ramsesHandle;
|
|
const osThreadAttr_t RAMSES_attributes = {
|
|
.name = "ramses",
|
|
.stack_size = 1024,
|
|
.priority = (osPriority_t) osPriorityBelowNormal,
|
|
};
|
|
|
|
|
|
void Ramses_Uart_IRQHandler(void)
|
|
{
|
|
uint16_t count = 0;
|
|
uint16_t data_length = 0;
|
|
if (__HAL_UART_GET_FLAG(pRamsesUart, UART_FLAG_TC) != RESET)
|
|
{
|
|
log_i("Ramses_ ..huart TC callback ...");
|
|
pRamsesUart->gState = HAL_UART_STATE_READY;
|
|
__HAL_UART_CLEAR_FLAG(pRamsesUart, UART_FLAG_TC);
|
|
}
|
|
|
|
if (__HAL_UART_GET_FLAG(pRamsesUart, UART_FLAG_IDLE) != RESET)
|
|
{
|
|
log_i("Ramses_ ..huart IDLE ...");
|
|
count = __HAL_DMA_GET_COUNTER( pRamsesUart->hdmarx );
|
|
data_length = Ramses_Rcv_Buf_Size - count;
|
|
if ( data_length > 0 )
|
|
{
|
|
// log_i("Ramses_ IDLE.. data_length %d", data_length);
|
|
Ramses_copy( ramses, data_length );
|
|
// log_i("Oscar_. IDLE..res %02X %d %02X", oscar->uarthelper ->receive_buf[0], oscar->uarthelper ->receive_buf[2], oscar->uarthelper ->receive_buf[data_length-1]);
|
|
}
|
|
__HAL_UART_CLEAR_IDLEFLAG( pRamsesUart );
|
|
}
|
|
}
|
|
|
|
int Ramses_copy(Ramses_TypeDef *ramses ,uint16_t size)
|
|
{
|
|
// log_i( "Ramses_ idle copy state %d size :%d ", ramses->state,size);
|
|
// if ( ramses->state == MODULE_RAMSESE_STATE_CHECK_SENSOR )
|
|
// {
|
|
__disable_irq();
|
|
// memcpy(Ramses_Rcv_Buf_Copy+ramses->size_received, Ramses_Rcv_Buf+ramses->size_received, size);
|
|
ramses->size_received = size;
|
|
// ramses->size_received = ramses->size_received + size;
|
|
// log_i( "Rramses->size_received after %d " , ramses->size_received);
|
|
__enable_irq();
|
|
// return 0;
|
|
// }
|
|
return 0;
|
|
}
|
|
|
|
void Ramses_Port ()
|
|
{
|
|
ramsesHandle = osThreadNew( Ramses_Task, (void*) ( &ramses->state ), &RAMSES_attributes );
|
|
}
|
|
|
|
|
|
void Ramses_Task(void * argument)
|
|
{
|
|
Ramses_clean_data_recved_flag(ramses);
|
|
Ramses_clean_ip_recved_flag(ramses);
|
|
Ramses_clean_info_recved_flag(ramses);
|
|
MODULE_RAMSESE_WORK_STATE *state = argument;
|
|
static int err_con=0;
|
|
for ( ; ; )
|
|
{
|
|
/* step-> 1 ：get_sn 2： get_ip （积分时间） 3 get_data, 倒过来，可能不一定依据顺序走 */
|
|
// log_i( "Ramses_ state %d " , *state );
|
|
switch ( *state )
|
|
{
|
|
case MODULE_RAMSESE_STATE_WAIT:
|
|
break;
|
|
case MODULE_RAMSESE_STATE_START:
|
|
ramses->timebase = osKernelGetTickCount();
|
|
// sensor_enable();
|
|
*state=MODULE_RAMSESE_STATE_SEND_CMD;
|
|
break;
|
|
case MODULE_RAMSESE_STATE_SEND_CMD:
|
|
if( (osKernelGetTickCount() - ramses->timebase) >=5000){
|
|
ramses->timebase = osKernelGetTickCount();
|
|
ramses->size_received = 0;
|
|
memset( Ramses_Rcv_Buf, 0, sizeof(Ramses_Rcv_Buf) );
|
|
Ramses_cmd_get_infomation(ramses,0x80);
|
|
__HAL_UART_ENABLE_IT( pRamsesUart, UART_IT_IDLE );
|
|
HAL_UART_Receive_DMA( pRamsesUart, Ramses_Rcv_Buf,sizeof(Ramses_Rcv_Buf) );
|
|
err_con = 0;
|
|
*state = MODULE_RAMSESE_STATE_CHECK_SENSOR;
|
|
}
|
|
break;
|
|
case MODULE_RAMSESE_STATE_CHECK_SENSOR:
|
|
log_i( "Ramses_ CHECK_SENSOR %d size_received : %d " , *state , ramses->size_received);
|
|
// 判断 size_received 大小进行处理
|
|
if( ramses->size_received >=19)
|
|
{
|
|
Ramses_receive_callback( ramses, Ramses_Rcv_Buf, ramses->size_received) ;
|
|
}
|
|
if(Ramses_get_serial_number(ramses)!=0xffff){
|
|
HAL_UART_DMAStop( pRamsesUart );
|
|
ramses->sn=Ramses_get_serial_number( ramses );
|
|
log_i( "Ramses_ SN %4X " , ramses->sn);
|
|
Ramses_clean_flag(ramses,Ramses_FLAG_MASK_RECVED_INFO);
|
|
ramses->error =0;
|
|
err_con=0;
|
|
log_i("Ramses Get Infomation Succeed");
|
|
Ramses_clean_flag( ramses ,Ramses_FLAG_MASK_BUSY|Ramses_FLAG_MASK_RECVED_DATA|Ramses_FLAG_MASK_RECVED_IP);
|
|
|
|
ramses->size_received = 0;
|
|
memset( Ramses_Rcv_Buf, 0, sizeof(Ramses_Rcv_Buf) );
|
|
Ramses_cmd_messung( ramses ,0x80);
|
|
__HAL_UART_ENABLE_IT( pRamsesUart, UART_IT_IDLE );
|
|
HAL_UART_Receive_DMA( pRamsesUart, Ramses_Rcv_Buf,sizeof(Ramses_Rcv_Buf) );
|
|
*state=MODULE_RAMSESE_STATE_GET_DATA;
|
|
}
|
|
if( (osKernelGetTickCount() - ramses->timebase) >=10000){
|
|
log_w( "Ramses Get Infomation Failed %d,Retrying...", err_con );
|
|
|
|
err_con++;
|
|
if(err_con>10){
|
|
log_e("Ramses Init Error");
|
|
// operating_state.plug3_state=0; //TODO?
|
|
ramses->error = 1;
|
|
*state=MODULE_RAMSESE_STATE_ERROR;
|
|
break;
|
|
}
|
|
ramses->timebase = osKernelGetTickCount();
|
|
Ramses_clean_flag( ramses ,Ramses_FLAG_MASK_BUSY);
|
|
ramses->size_received = 0;
|
|
memset( Ramses_Rcv_Buf, 0, sizeof(Ramses_Rcv_Buf) );
|
|
Ramses_cmd_get_infomation(ramses,0x80);
|
|
__HAL_UART_ENABLE_IT( pRamsesUart, UART_IT_IDLE );
|
|
HAL_UART_Receive_DMA( pRamsesUart, Ramses_Rcv_Buf,sizeof(Ramses_Rcv_Buf) );
|
|
*state=MODULE_RAMSESE_STATE_CHECK_SENSOR;
|
|
}
|
|
break;
|
|
case MODULE_RAMSESE_STATE_GET_DATA:
|
|
// log_i( "Ramses_ GET_DATA %d size_received : %d " , *state , ramses->size_received);
|
|
if( ramses->size_received >=576)
|
|
{
|
|
log_i( "Ramses_ receive data deal --->>> : %d " , ramses->size_received);
|
|
Ramses_receive_callback( ramses, Ramses_Rcv_Buf, ramses->size_received) ;
|
|
}
|
|
if(Ramses_get_flag( ramses ,Ramses_FLAG_MASK_RECVED_DATA)!=0){
|
|
ramses->error = 0;
|
|
ramses->flag_ip = Ramses_get_flag( ramses ,Ramses_FLAG_MASK_RECVED_INFO)!=0;
|
|
Ramses_clean_flag( ramses ,Ramses_FLAG_MASK_BUSY|Ramses_FLAG_MASK_RECVED_DATA|Ramses_FLAG_MASK_RECVED_IP);
|
|
log_i("Ramses Get Data Succeed");
|
|
// operating_state.plug3_state=1; //TODO?
|
|
err_con=0;
|
|
*state=MODULE_RAMSESE_STATE_OK;
|
|
}
|
|
if( (osKernelGetTickCount() - ramses->timebase) >= 10000 ){
|
|
log_w("Ramses Get Data Failed %d,Retrying...",err_con);
|
|
|
|
err_con++;
|
|
if(err_con>=10){
|
|
log_e("Ramses Init Error");
|
|
// operating_state.plug3_state=0; //TODO?
|
|
ramses->error =1;
|
|
*state = MODULE_RAMSESE_STATE_ERROR;
|
|
break;
|
|
}
|
|
ramses->timebase = osKernelGetTickCount();
|
|
|
|
Ramses_clean_flag( ramses ,Ramses_FLAG_MASK_BUSY|Ramses_FLAG_MASK_RECVED_DATA|Ramses_FLAG_MASK_RECVED_IP);
|
|
HAL_UART_DMAStop( pRamsesUart );
|
|
ramses->size_received = 0;
|
|
memset( Ramses_Rcv_Buf, 0, sizeof(Ramses_Rcv_Buf) );
|
|
Ramses_cmd_messung( ramses ,0x80);
|
|
__HAL_UART_ENABLE_IT( pRamsesUart, UART_IT_IDLE );
|
|
HAL_UART_Receive_DMA( pRamsesUart, Ramses_Rcv_Buf,sizeof(Ramses_Rcv_Buf) );
|
|
}
|
|
break;
|
|
case MODULE_RAMSESE_STATE_OK:
|
|
break;
|
|
case MODULE_RAMSESE_STATE_ERROR:
|
|
break;
|
|
case MODULE_RAMSESE_STATE_STOP:
|
|
break;
|
|
default:
|
|
*state=MODULE_RAMSESE_STATE_WAIT;
|
|
break;
|
|
}
|
|
|
|
osDelay(80 );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief 初始化
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param send_obj 发送函数的第一个参数
|
|
* @param send_fun 发送函数
|
|
* @return struct trios_ramses* 成功:设备描述符 失败:NULL
|
|
*/
|
|
int Ramses_init( )
|
|
{
|
|
|
|
ramses = (Ramses_TypeDef *)malloc(sizeof(Ramses_TypeDef));
|
|
|
|
/* 设置超时*/
|
|
Ramses_Set_Timeout(ramses, 9000);
|
|
|
|
// set paras;
|
|
ramses->state = MODULE_RAMSESE_STATE_WAIT;
|
|
ramses->flag = 0;
|
|
ramses->timebase = 0;
|
|
ramses->timeout_ms = 9000;
|
|
ramses->status = Uart_Status_Ready;
|
|
ramses->send_flag = 0;
|
|
// ramses->command_seq = 4;
|
|
ramses->step = 2;
|
|
ramses->size_received = 0;
|
|
ramses->sn = 0xffff;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief 向传感器发送命令
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param dev_id 设备ID
|
|
* @param module_id 模块ID
|
|
* @param instruction 指令
|
|
* @param parameter1 参数1
|
|
* @param parameter2 参数2
|
|
* @return int
|
|
*/
|
|
int Ramses_send_cmd(Ramses_TypeDef *ramses,uint16_t dev_id,uint8_t module_id,uint8_t instruction,uint8_t parameter1,uint8_t parameter2)
|
|
{
|
|
|
|
int i=0;
|
|
ramses->cmd_buf[i++]=0x23;
|
|
ramses->cmd_buf[i++]=(dev_id>>8)&0x0f;
|
|
ramses->cmd_buf[i++]=dev_id&0xff;
|
|
ramses->cmd_buf[i++]=module_id;
|
|
ramses->cmd_buf[i++]=instruction;
|
|
ramses->cmd_buf[i++]=parameter1;
|
|
ramses->cmd_buf[i++]=parameter2;
|
|
ramses->cmd_buf[i++]=0x01;
|
|
|
|
|
|
HAL_UART_Transmit_DMA( pRamsesUart, ramses->cmd_buf, i );
|
|
// HAL_UARTEx_ReceiveToIdle_DMA( )
|
|
// ramses->send_fun(ramses->send_class,ramses->cmd_buf,i);
|
|
return 0;
|
|
}
|
|
/**
|
|
* @brief 测量
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @return int 成功:0 失败:负值
|
|
*/
|
|
int Ramses_cmd_messung(Ramses_TypeDef *ramses,uint8_t module_id)
|
|
{
|
|
if((ramses->flag&Ramses_FLAG_MASK_BUSY)!=0 || (ramses->flag&Ramses_FLAG_MASK_RECVED_DATA)!=0){
|
|
return -2;
|
|
}
|
|
ramses->flag|=Ramses_FLAG_MASK_BUSY;
|
|
return Ramses_send_cmd(ramses,0x0000,module_id,0xa8,0x00,0x81);
|
|
}
|
|
/**
|
|
* @brief 设置积分时间
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param integration_time 积分时间
|
|
* @return int 成功:0 失败:负值
|
|
*/
|
|
int Ramses_cmd_set_integration_time(Ramses_TypeDef *ramses,enum trios_integration_time integration_time)
|
|
{
|
|
if((ramses->flag&Ramses_FLAG_MASK_BUSY)!=0){
|
|
return -2;
|
|
}
|
|
if(integration_time<0 || integration_time>0x0c){
|
|
return -1;
|
|
}
|
|
return Ramses_send_cmd(ramses,0x0000,0x30,0x78,0x05,integration_time);
|
|
}
|
|
/**
|
|
* @brief 获取模块信息
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param module_id 模块ID
|
|
* @return int 成功:0 失败:负值
|
|
*/
|
|
int Ramses_cmd_get_infomation(Ramses_TypeDef *ramses,uint8_t module_id)
|
|
{
|
|
log_w(" Ramses_cmd_get_infomation .... %d ",ramses->flag&Ramses_FLAG_MASK_BUSY);
|
|
|
|
if((ramses->flag&Ramses_FLAG_MASK_BUSY)!=0){
|
|
return -2;
|
|
}
|
|
ramses->flag|=Ramses_FLAG_MASK_BUSY;
|
|
return Ramses_send_cmd(ramses,0x0000,module_id,0xb0,0x00,0x00);
|
|
}
|
|
/**
|
|
* @brief 获取IP头原始数据
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param buf 缓冲区
|
|
* @param size 缓冲区大小
|
|
* @return uint32_t 成功:数据大小 失败:负值
|
|
*/
|
|
uint32_t Ramses_get_ip_raw(Ramses_TypeDef *ramses,uint8_t *buf,uint32_t size)
|
|
{
|
|
if(size<Ramses_IP_SIZE){
|
|
return -1;
|
|
}
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_IP)==0){
|
|
return -2;
|
|
}
|
|
memcpy(buf,ramses->ip.raw,Ramses_IP_SIZE);
|
|
return Ramses_IP_SIZE;
|
|
}
|
|
/**
|
|
* @brief 获取光谱原始数据
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param buf 缓冲区
|
|
* @param size 缓冲区大小
|
|
* @return uint32_t 成功:数据大小 失败:负值
|
|
*/
|
|
uint32_t Ramses_get_data_raw(Ramses_TypeDef *ramses,uint8_t *buf,uint32_t size)
|
|
{
|
|
int i;
|
|
if(size<Ramses_DATA_SIZE*Ramses_DATA_NUM){
|
|
return 0;
|
|
}
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_DATA)==0){
|
|
return 0;
|
|
}
|
|
for(i=0;i<Ramses_DATA_NUM;i++){
|
|
memcpy(&buf[i*Ramses_DATA_SIZE],ramses->data[i].raw,Ramses_DATA_SIZE);
|
|
}
|
|
return i*Ramses_DATA_SIZE;
|
|
}
|
|
/**
|
|
* @brief 获取转换后的光谱数据
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param data 数据缓冲区
|
|
* @param num 缓冲区长度
|
|
* @return uint32_t 成功:数据长度 失败:0xffffffff
|
|
*/
|
|
uint32_t Ramses_get_data(Ramses_TypeDef *ramses,int16_t *data,uint32_t num)
|
|
{
|
|
int i;
|
|
int j;
|
|
uint8_t endian_mask;
|
|
// endian_mask=endian_get_local_endian_mask(ENDIAN_MASK_LITTLE_ENDIAN);
|
|
if(num<(Ramses_DATA_SIZE-8)*Ramses_DATA_NUM/2)
|
|
{
|
|
return 0;
|
|
}
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_DATA)==0){
|
|
return 0;
|
|
}
|
|
for(i=0,j=0;i<Ramses_DATA_NUM;i++){
|
|
// if(endian_write(endian_mask,ENDIAN_WIDTH_MASK_2BYTE,&((uint8_t*)data)[j],ramses->data[i].data,ramses->data[i].data_size)!=0){
|
|
// Ramses_clean_data_recved_flag(trios_ramses);
|
|
// return 0xffffffff;
|
|
// }
|
|
// j+=ramses->data[i].data_size;
|
|
}
|
|
return j/2;
|
|
}
|
|
/**
|
|
* @brief 获取X轴倾斜角度
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param incl_xgain 标定数据
|
|
* @param incl_xoffset 标定数据
|
|
* @return double 成功:X轴倾角 失败:NAN
|
|
*/
|
|
double Ramses_get_x_inclination_angle(Ramses_TypeDef *ramses,double incl_xgain,double incl_xoffset)
|
|
{
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_IP)==0){
|
|
return NAN;
|
|
}
|
|
return (ramses->ip.data[4]-incl_xoffset)*incl_xgain;
|
|
}
|
|
/**
|
|
* @brief 获取Y轴倾斜角度
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param incl_ygain 标定数据
|
|
* @param incl_yoffset 标定数据
|
|
* @return double 成功:Y轴倾角 失败:NAN
|
|
*/
|
|
double Ramses_get_y_inclination_angle(Ramses_TypeDef *ramses,double incl_ygain,double incl_yoffset)
|
|
{
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_IP)==0){
|
|
return NAN;
|
|
}
|
|
return (ramses->ip.data[5]-incl_yoffset)*incl_ygain;
|
|
}
|
|
/**
|
|
* @brief 获取设备倾角
|
|
*
|
|
* @param x_inclination_angle X轴倾角
|
|
* @param y_inclination_angle Y轴倾角
|
|
* @return double 成功:设备倾角 失败:NAN
|
|
*/
|
|
double Ramses_get_inclination_angle(double x_inclination_angle,double y_inclination_angle)
|
|
{
|
|
if(x_inclination_angle==NAN || y_inclination_angle==NAN){
|
|
return NAN;
|
|
}
|
|
return atan(sqrt(pow(tan(x_inclination_angle*M_PI/180),2)+pow(tan(y_inclination_angle*M_PI/180),2)));
|
|
}
|
|
/**
|
|
* @brief 获取压力
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param incl_kref 标定数据
|
|
* @param incl_kbg 标定数据
|
|
* @param press_gain 标定数据
|
|
* @param press_surface_bar 标定数据
|
|
* @param press_sens_mv_bar_1ma 标定数据
|
|
* @param press_sens_mv_bar_4ma 标定数据
|
|
* @return double 压力
|
|
*/
|
|
double Ramses_get_pressure(Ramses_TypeDef *ramses,double incl_kref,double incl_kbg,double press_gain,double press_surface_bar,double press_sens_mv_bar_1ma,double press_sens_mv_bar_4ma)
|
|
{
|
|
uint16_t npress;
|
|
uint16_t nbg;
|
|
uint16_t nrefh;
|
|
uint16_t nrefl;
|
|
double noffset;
|
|
double press_sens;
|
|
double vpress_v;
|
|
double p_bar;
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_IP)==0){
|
|
return NAN;
|
|
}
|
|
npress=((uint16_t)ramses->ip.data[7]<<8)+ramses->ip.data[6];
|
|
nbg=((uint16_t)ramses->ip.data[11]<<8)+ramses->ip.data[10];
|
|
nrefh=((uint16_t)ramses->ip.data[13]<<8)+ramses->ip.data[12];
|
|
nrefl=((uint16_t)ramses->ip.data[15]<<8)+ramses->ip.data[14];
|
|
noffset=nrefl-(incl_kref*(nrefh-nrefl));
|
|
vpress_v=incl_kbg*(npress-noffset)/(nbg-noffset);
|
|
press_sens=(press_sens_mv_bar_4ma<=0?press_sens_mv_bar_1ma:press_sens_mv_bar_4ma);
|
|
p_bar=1000.0*vpress_v/(press_sens*press_gain);
|
|
return p_bar-1.021;
|
|
}
|
|
/**
|
|
* @brief 获取深度(米)
|
|
*
|
|
* @param pressure 压力
|
|
* @return double 成功:深度 失败:NAN
|
|
*/
|
|
double Ramses_get_depth_m(double pressure)
|
|
{
|
|
if(pressure==NAN){
|
|
return NAN;
|
|
}
|
|
return pressure*10;
|
|
}
|
|
/**
|
|
* @brief 获取设备序列号
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @return uint16_t 成功:设备序列号 失败:0xffff
|
|
*/
|
|
uint16_t Ramses_get_serial_number(Ramses_TypeDef *ramses)
|
|
{
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_INFO)==0){
|
|
return 0xffff;
|
|
}
|
|
return ramses->infomation.serial_number;
|
|
}
|
|
/**
|
|
* @brief 清除指定标志位
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param mask 掩码
|
|
*/
|
|
void Ramses_clean_flag(Ramses_TypeDef *ramses,uint8_t mask)
|
|
{
|
|
ramses->flag&=~mask;
|
|
}
|
|
/**
|
|
* @brief 获取指定标志位
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param mask 掩码
|
|
* @return uint8_t 标志位
|
|
*/
|
|
uint8_t Ramses_get_flag(Ramses_TypeDef *ramses,uint8_t mask)
|
|
{
|
|
return ramses->flag&mask;
|
|
}
|
|
/**
|
|
* @brief 传感器消息解码
|
|
*
|
|
* @param trios_ramses 设备描述符
|
|
* @param buf 接收到的数据缓冲区
|
|
* @param size 接收到的数据长度
|
|
*/
|
|
void Ramses_receive_callback(Ramses_TypeDef *ramses,uint8_t *buf,uint32_t size)
|
|
{
|
|
int i;
|
|
for(i=0;i<size;i++){
|
|
if(ramses->recv_buf_p==0 && buf[i]!=0x23){ // 已经过滤 开始的0x13 0x11
|
|
continue;
|
|
}
|
|
if(ramses->recv_flag_40==1){
|
|
if(buf[i]==0x64){
|
|
ramses->recv_buf[ramses->recv_buf_p++]=0x40;
|
|
}
|
|
else if(buf[i]==0x65){
|
|
ramses->recv_buf[ramses->recv_buf_p++]=0x23;
|
|
}
|
|
else if(buf[i]==0x66){
|
|
ramses->recv_buf[ramses->recv_buf_p++]=0x11;
|
|
}
|
|
else if(buf[i]==0x67){
|
|
ramses->recv_buf[ramses->recv_buf_p++]=0x13;
|
|
}
|
|
else{
|
|
ramses->data_index=0;
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
ramses->recv_flag_40=0;
|
|
}
|
|
else if(buf[i]==0x40){
|
|
ramses->recv_flag_40=1;
|
|
}
|
|
else{ // == 0x23 切换 recv_buf 数组下标
|
|
ramses->recv_buf[ramses->recv_buf_p++]=buf[i];
|
|
}
|
|
if(ramses->recv_buf_p>7 && ramses->recv_buf_p==8+(2<<(ramses->recv_buf[1]>>5))){
|
|
if(ramses->recv_buf[4]==0xff){ // 0xff 表征 SN信息帧
|
|
if(ramses->recv_buf_p!=Ramses_INFO_SIZE){
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
ramses->infomation.dev_id=((uint16_t)ramses->recv_buf[1]<<8)+ramses->recv_buf[2];
|
|
ramses->infomation.module_id=ramses->recv_buf[3];
|
|
ramses->infomation.serial_number=((uint16_t)ramses->recv_buf[8]<<8)+ramses->recv_buf[7];
|
|
ramses->infomation.firmware_number[0]=ramses->recv_buf[10];
|
|
ramses->infomation.firmware_number[1]=ramses->recv_buf[9];
|
|
memcpy(ramses->infomation.individual_information,&ramses->recv_buf[7],Ramses_INFO_SIZE-12);
|
|
ramses->recv_buf_p=0;
|
|
ramses->flag|=Ramses_FLAG_MASK_RECVED_INFO;
|
|
ramses->flag&=~Ramses_FLAG_MASK_BUSY;
|
|
}
|
|
else if(ramses->recv_buf[4]==0xfe){ // 0xfe错误
|
|
ramses->data_index=0;
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
else{
|
|
if(ramses->recv_buf[3]==0x80 || ramses->recv_buf[3]==0x30 || ramses->recv_buf[3]==0x00){
|
|
// log_i(".... 0x80 0x 30 0x00");
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_DATA)!=0){
|
|
ramses->data_index=0;
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
if(ramses->recv_buf_p!=Ramses_DATA_SIZE){
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
if(ramses->recv_buf[4]!=Ramses_DATA_NUM-1-ramses->data_index){
|
|
ramses->data_index=0;
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
memcpy(ramses->data[ramses->data_index].raw,ramses->recv_buf,Ramses_DATA_SIZE);
|
|
ramses->data[ramses->data_index].dev_id=((uint16_t)ramses->recv_buf[1]<<8)+ramses->recv_buf[2];
|
|
ramses->data[ramses->data_index].module_id=ramses->recv_buf[3];
|
|
ramses->data[ramses->data_index].framebyte=ramses->recv_buf[4];
|
|
ramses->data[ramses->data_index].data=&ramses->data[ramses->data_index].raw[7];
|
|
ramses->data[ramses->data_index].data_size=Ramses_DATA_SIZE-8;
|
|
ramses->data_index++;
|
|
ramses->recv_buf_p=0;
|
|
if(ramses->data_index==Ramses_DATA_NUM){
|
|
ramses->data_index=0;
|
|
ramses->flag|=Ramses_FLAG_MASK_RECVED_DATA;
|
|
ramses->flag&=~Ramses_FLAG_MASK_BUSY;
|
|
}
|
|
}
|
|
else if(ramses->recv_buf[3]==0x20){
|
|
if((ramses->flag&Ramses_FLAG_MASK_RECVED_IP)!=0){
|
|
ramses->data_index=0;
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
if(ramses->recv_buf_p!=Ramses_IP_SIZE){
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
memcpy(ramses->ip.raw,ramses->recv_buf,Ramses_IP_SIZE);
|
|
ramses->ip.dev_id=((uint16_t)ramses->recv_buf[1]<<8)+ramses->recv_buf[2];
|
|
ramses->ip.module_id=ramses->recv_buf[3];
|
|
ramses->ip.framebyte=ramses->recv_buf[4];
|
|
ramses->ip.data=&ramses->ip.raw[7];
|
|
ramses->ip.data_size=Ramses_IP_SIZE-8;
|
|
ramses->recv_buf_p=0;
|
|
ramses->flag|=Ramses_FLAG_MASK_RECVED_IP;
|
|
}
|
|
else{
|
|
ramses->data_index=0;
|
|
ramses->recv_flag_40=0;
|
|
ramses->recv_buf_p=0;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
Ramses_Set_Timeout(Ramses_TypeDef *ramses, uint16_t timeout_ms )
|
|
{
|
|
ramses->timebase = osKernelGetTickCount();
|
|
|
|
ramses->timeout_enable = 1;
|
|
}
|
|
Ramses_Get_Timeout( Ramses_TypeDef *ramses )
|
|
{
|
|
if ((osKernelGetTickCount() - ramses->timebase) > ramses->timeout_ms)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void Ramses_Set_State (Ramses_TypeDef *ramses, MODULE_RAMSESE_WORK_STATE state)
|
|
{
|
|
ramses->state = state;
|
|
}
|
|
|
|
#endif |