AirControlValve/User/protocol.c

#include "protocol.h"
#include "process.h"
#include "cfg.h"
#include "uart.h"
#include "adc.h"


#ifdef IS_BOOTLOADER
uint32_t Firmware_Version[4] = {1, 1, 4, 20241112};
#else
uint32_t Firmware_Version[4] = {1, 1, 4, 20241112};
#endif



uint16_t Read_FirmwareVersion(uint8_t *pBuf, uint16_t buf_len)
{
	int i;
	
	if( buf_len < 16){
		return 0;
	}
	
	for (i = 0; i < 4; ++i)
	{
		pBuf[i * 4] = (Firmware_Version[i] >> 24) & 0xff;
		pBuf[i * 4 + 1] = (Firmware_Version[i] >> 16) & 0xff;
		pBuf[i * 4 + 2] = (Firmware_Version[i] >> 8) & 0xff;
		pBuf[i * 4 + 3] = (Firmware_Version[i] >> 0) & 0xff;
	}
	
	return 16;
	
}

uint16_t Read_HardwareVersion(uint8_t *pBuf, uint16_t buf_len)
{

	if( buf_len < 2){
		return 0;
	}
	
	pBuf[0] = (config->hw_version >> 8)&0xff;
	pBuf[1] = (config->hw_version >> 0)&0xff;
	
	return 2;
}


uint16_t Read_Deviceid(uint8_t *pBuf, uint16_t buf_len)
{

	if( buf_len < 4){
		return 0;
	}
	
	pBuf[0] = (config->deviceid >> 24)&0xff;
	pBuf[1] = (config->deviceid >> 16)&0xff;
	pBuf[2] = (config->deviceid >> 8)&0xff;
	pBuf[3] = (config->deviceid >> 0)&0xff;
	
	return 4;
	
}

uint16_t Read_Devicetype(uint8_t *pBuf, uint16_t buf_len)
{

	if( buf_len < 2){
		return 0;
	}
	
	pBuf[0] = (config->devicetype >> 8)&0xff;
	pBuf[1] = (config->devicetype >> 0)&0xff;
	
	return 2;

}

uint16_t Read_Addr(uint8_t *pBuf, uint16_t buf_len)
{
	if( buf_len < 2){
		return 0;
	}
	
	pBuf[0] = 0x00;
	pBuf[1] = config->addr;
	
	return 2;
}

uint16_t Read_Baudrate(uint8_t *pBuf, uint16_t buf_len)
{
	if( buf_len < 2){
		return 0;
	}
	
	pBuf[0] = 0x00;
	pBuf[1] = config->br_index;
	
	return 2;

}


uint16_t Read_Temperature(uint8_t *pBuf, uint16_t buf_len)
{
	float temp=0;

	if( buf_len < 4){
		return 0;
	}
	
	temp = Process_GetTemperature();
	
	pBuf[0] = ((uint8_t*)(&temp))[0];
	pBuf[1] = ((uint8_t*)(&temp))[1];
	pBuf[2] = ((uint8_t*)(&temp))[2];
	pBuf[3] = ((uint8_t*)(&temp))[3];
	
	return 4;
}

uint16_t Read_Pressure(uint8_t *pBuf, uint16_t buf_len)
{
	float pressure=0;
	if( buf_len < 4){
		return 0;
	}
	
	pressure = Process_GetPressure();
	
	pBuf[0] = ((uint8_t*)(&pressure))[0];
	pBuf[1] = ((uint8_t*)(&pressure))[1];
	pBuf[2] = ((uint8_t*)(&pressure))[2];
	pBuf[3] = ((uint8_t*)(&pressure))[3];
	
	return 4;
}

//uint16_t Read_Status(uint8_t *pBuf, uint16_t buf_len)
//{

//	if( buf_len < 2){
//		return 0;
//	}
//	

//	pBuf[0] = Process_GetValveStatus();
//	pBuf[1] = 0x00;
//	
//	return 2;
//}

//uint16_t Read_Raw(uint8_t *pBuf, uint16_t buf_len)
//{
//	uint16_t hall_1;
//	uint16_t hall_2;
//	
//	if( buf_len < 4){
//		return 0;
//	}
//	
//	getHallValue(&hall_1, &hall_2);
//	
//	pBuf[0] = (hall_1 >> 8)&0xff;
//	pBuf[1] = (hall_1 >> 0)&0xff;
//	
//	pBuf[2] = (hall_2 >> 8)&0xff;
//	pBuf[3] = (hall_2 >> 0)&0xff;
//	
//	return 4;
//}

//uint16_t Read_Threshold(uint8_t *pBuf, uint16_t buf_len)
//{

//	if( buf_len < 2){
//		return 0;
//	}
//	
//	pBuf[0] = (config->threshold >> 8)&0xff;
//	pBuf[1] = (config->threshold >> 0)&0xff;
//	
//	return 2;
//}

uint16_t Read_Height(uint8_t *pBuf, uint16_t buf_len)
{
	float height =0;
	if( buf_len < 6){
		return 0;
	}
	
	pBuf[0] = Process_GetAirHeight(&height);
	pBuf[1] = 0x00;
	
	pBuf[2] = ((uint8_t*)(&height))[0];
	pBuf[3] = ((uint8_t*)(&height))[1];
	pBuf[4] = ((uint8_t*)(&height))[2];
	pBuf[5] = ((uint8_t*)(&height))[3];
	
	return 6;
}


uint16_t Read_Angle(uint8_t *pBuf, uint16_t buf_len)
{
	static float roll =0;
	static float pitch =0;
	static float yaw =0;
	
	if( buf_len < 12){
		return 0;
	}
	
	Process_GetAngle(&roll, &pitch, &yaw);
	
	pBuf[0] = ((uint8_t*)(&roll))[0];
	pBuf[1] = ((uint8_t*)(&roll))[1];
	pBuf[2] = ((uint8_t*)(&roll))[2];
	pBuf[3] = ((uint8_t*)(&roll))[3];
	
	pBuf[4] = ((uint8_t*)(&pitch))[0];
	pBuf[5] = ((uint8_t*)(&pitch))[1];
	pBuf[6] = ((uint8_t*)(&pitch))[2];
	pBuf[7] = ((uint8_t*)(&pitch))[3];
	
	pBuf[8] = ((uint8_t*)(&yaw))[0];
	pBuf[9] = ((uint8_t*)(&yaw))[1];
	pBuf[10] = ((uint8_t*)(&yaw))[2];
	pBuf[11] = ((uint8_t*)(&yaw))[3];
	
	return 12;

}

uint16_t Read_Bias(uint8_t *pBuf, uint16_t buf_len)
{
	
	if( buf_len < 8){
		return 0;
	}
	

	pBuf[0] = ((uint8_t*)(&config->temperature_bias))[0];
	pBuf[1] = ((uint8_t*)(&config->temperature_bias))[1];
	pBuf[2] = ((uint8_t*)(&config->temperature_bias))[2];
	pBuf[3] = ((uint8_t*)(&config->temperature_bias))[3];
	
	pBuf[4] = ((uint8_t*)(&config->pressure_bias))[0];
	pBuf[5] = ((uint8_t*)(&config->pressure_bias))[1];
	pBuf[6] = ((uint8_t*)(&config->pressure_bias))[2];
	pBuf[7] = ((uint8_t*)(&config->pressure_bias))[3];
	

	return 8;
}

uint16_t Read_RadarTransData(uint8_t *pBuf, uint16_t buf_len, uint8_t read_len)
{
	float height =0;
	if( buf_len < read_len){
		return 0;
	}
	
	if(read_len > 32){
		read_len = 32;
	}
	
	Process_RRadarTransData(pBuf, read_len);
	
	return read_len;
}



/*=======================================================================================*/

uint8_t Write_Addr(uint8_t *pdata, uint8_t len)
{
	if(len == 2){
		config->addr = pdata[1]; 
		return RET_OK|RET_NEED_SAVE;
		
	}else{
		return RET_DATAINVALID;
	}
}

uint8_t Write_Baudrate(uint8_t *pdata, uint8_t len)
{
	if(len == 2){
		if(pdata[1] >= BaudRate_4800 && pdata[1] <= BaudRate_230400){
			config->br_index = pdata[1]; 
			return RET_OK|RET_NEED_SAVE;
		
		}else{
			return RET_DATAINVALID;
		}
		
		
	}else{
		return RET_DATAINVALID;
	}

}

uint8_t Write_HardwareVersion(uint8_t *pdata, uint8_t len)
{
	if(len == 2){
		
		config->hw_version = ((uint16_t)pdata[0]<<8) | pdata[1]; 
		return RET_OK|RET_NEED_SAVE;
		
	}else{
		return RET_DATAINVALID;
	}
	

}
uint8_t Write_Deviceid(uint8_t *pdata, uint8_t len)
{
	if(len == 4){
		config->deviceid = ((uint32_t)pdata[0]<<24) | ((uint32_t)pdata[1]<<16)| ((uint32_t)pdata[2]<<8)| pdata[3]; 
		return RET_OK|RET_NEED_SAVE;
		
	}else{
		return RET_DATAINVALID;
	}

}
uint8_t Write_Devicetype(uint8_t *pdata, uint8_t len)
{

	if(len == 2){
		
		config->devicetype = ((uint16_t)pdata[0]<<8) | pdata[1]; 
		return RET_OK|RET_NEED_SAVE;
		
	}else{
		return RET_DATAINVALID;
	}
	
}

uint8_t Write_Bias(uint8_t *pdata, uint8_t len)
{
	float tmp;
	uint8_t* p=(uint8_t*)&tmp;
	
	if(len == 8){
		
		p[0]=pdata[0];
		p[1]=pdata[1];
		p[2]=pdata[2];
		p[3]=pdata[3];
		
		config->temperature_bias = tmp;
		
		p[0]=pdata[4];
		p[1]=pdata[5];
		p[2]=pdata[6];
		p[3]=pdata[7];
		
		config->pressure_bias = tmp;
		
		Process_SetBias(config->temperature_bias, config->pressure_bias);
		
		return RET_OK|RET_NEED_SAVE;
		
	}else{
		return RET_DATAINVALID;
	}
}


//uint8_t Write_Threshold(uint8_t *pdata, uint8_t len)
//{

//	if(len == 2){
//		config->valvecolse_base = getHalldiff();
//		config->threshold = ((uint16_t)pdata[0]<<8) | pdata[1]; 
//		
//		return RET_OK|RET_NEED_SAVE;
//		
//	}else{
//		return RET_DATAINVALID;
//	}
//}

uint8_t Write_RadarTransData(uint8_t *pdata, uint8_t len)
{
	if(len <= 32){
		
		Process_WRadarTransData(pdata, len); 
		return RET_OK;
		
	}else{
		return RET_DATAINVALID;
	}
	
}