bms/Application/app/protocol_old.c

#include <string.h>
#include "app/sox/soc.h"
#include "app/sox/measure.h"
#include "app/sox/measure_task.h"
#include "app/sox/health.h"
#include "app/sox/state.h"
#include "app/sox/iostate.h"
#include "bsp/gpio.h"
#include "bsp/ml5238.h"
#include "bsp/fmc_flash.h"
#include "libs/logger.h"
#include "bsp/uart.h"
#include "protocol_old.h"

static uart_enum_t current_uart = SHARK_UART0;
extern char* bsp_get_fversion(void);

uint16_t _checksum(uint8_t *data, uint16_t size) {
	uint32_t checksum;
	if((NULL == data) || (0 == size)) {
		return 0;
	}

	checksum = 0;
	while(size>1) {
		checksum += *(uint16_t*)data;
		data += 2;
		size -= 2;
	}

	if(size>0) {
		checksum += *data;
	}

	while(checksum>>16) {
		checksum = (checksum&0xFFFF)+(checksum>>16);
	}	

	return (uint16_t)~checksum;
}


static int get_response_data(uint8_t *data, uint8_t operate, uint8_t result){
	comm_head_t *head = (comm_head_t *)data;
	head->size = sizeof(comm_head_t);
	head->type = 0x30;
	head->dir = 0x16;
	head->bStatus = 1;
	head->cmd = 0x10;
	head->protocol = 'B';
	head->checksum = 0;

	comm_response_t *response = (comm_response_t *)head->data;
	response->remain_miles= 0; //Ê£ÓàÀï³Ì

	response->capacity = get_soc()->capacity;
	response->remain_charger_time= soc_get_charger_remain_time()/360; //10·ÖÖ®1Сʱµ¥Î»
	response->is_chargering = bms_state_get()->charging;
	
	response->load_current = measure_value()->load_current;
	response->pack_voltage = bms_state_get()->pack_voltage;
	response->max_temp = -100;
	for (int i = 0; i < PACK_TEMPS_NUM; i++){
		if (response->max_temp < measure_value()->pack_temp[i]){
			response->max_temp = measure_value()->pack_temp[i];
		}
	}
	
	response->health_state = *((uint16_t *)bms_health());
	response->balance_mask = 0x0;
	response->misc_status = (ml5238_is_charging() << 1) | (ml5238_is_discharging() << 2) | (AUX_VOL_IS_OPEN() << 3) |(io_state()->aux_lock_detect << 4) | ((get_soc()->capacity==100) << 5) | (((get_soc()->flags & SOC_FLAG_CALIBRATED) == 0) << 6);
	response->result = (operate << 4) | result;

	head->size += sizeof(comm_response_t);

	if (operate == OP_READ_INFO){
		uint8_t sn[32];
		int sn_len = sizeof(sn);
		fmc_read_sn(sn, &sn_len);
		if (sn_len == 0){
			sn[0] = 'B';
			memset(sn + 1, '0', sizeof(sn) - 1);
			sn_len = 18;
		}			
		memcpy(&data[head->size], sn, sn_len);
		head->size += sn_len;
		strcpy((char *)&data[head->size], bsp_get_fversion());
		head->size += strlen(bsp_get_fversion());
	}else if (operate == OP_ALARM_TIMES){
		memset(&data[head->size], 0, 42);
		head->size += 42;
	}else if (operate == OP_CELL_VOL){
		data[head->size ++] = CELLS_NUM;
		for (int i = 0; i <CELLS_NUM; i++){
			data[head->size ++] = (uint8_t)measure_value()->cell_vol[i];
			data[head->size ++] = (uint8_t)(measure_value()->cell_vol[i] >> 8);
		}
	}else if (operate == OP_TEMP_OTHER){
		for (int i = 0; i < PACK_TEMPS_NUM; i++){
			data[head->size ++] = measure_value()->pack_temp[i];
		}
		data[head->size ++] = (ml5238_is_charging() << 0) | (ml5238_is_discharging() << 1);
	}
	head->checksum = _checksum(data, head->size);

	return head->size;
}

void protocol_old_recv_frame(uart_enum_t uart_no, uint8_t *data, int len){
	current_uart = uart_no;
	comm_head_t *head = (comm_head_t *)data;
	if (/*head->type != 0x30 || */head->dir != 0x16 || head->bStatus == 1 || head->size < sizeof(comm_head_t)){
		return;
	}
	uint16_t checksum = head->checksum;
	head->checksum = 0;
	if (checksum != _checksum(data, len)){
		return;
	}

	data = head->data;
	data += 6;
	uint8_t operate = data[0];
	data += 1;
	uint8_t result = 1;
	if (operate == OP_OPEN_FET){
		if (data[8] == 0x03) {
			bms_state_get()->user_request = USER_REQUEST_PENDING | USER_REQUEST_DISCHARGER_ON|USER_REQUEST_CHARGER_ON;
		}else if (data[8] == 0x0){
			bms_state_get()->user_request = USER_REQUEST_PENDING | USER_REQUEST_SMALLCURRENT_OFF|USER_REQUEST_DISCHARGER_OFF|USER_REQUEST_CHARGER_OFF;
		}else if (data[8] == 0x04) {
			bms_state_get()->user_request = USER_REQUEST_PENDING | USER_REQUEST_SMALLCURRENT_ON;
		}else {
			result = 0;
		}
	}
	uint8_t response_data[256];
	uint16_t response_len = get_response_data(response_data, operate, result);
	if (response_len <= 0){
		return;
	}
	shark_uart_write_bytes(current_uart, response_data, response_len);
}