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, 0, 0, 20241015};
#else
uint32_t Firmware_Version[4] = {1, 1, 2, 20241015};
#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;
}


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

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_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;
	}
}