bt-67xx_universal_hw/modules/MegaTec/megatec.c

/*
 * megatec.c
 *
 *  Created on: 22.05.2017
 *      Author: balbekova
 */
#include "FreeRTOS.h"
#include "task.h"
#include "usart.h"
#include "megatec.h"
#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif

#include <string.h>
#include <math.h>

#define UPS_PDU_MAX_LEN 50

uint16_t TimeParam = 0;
uint16_t TimeParam2 = 0;
bool megatec_send = true;

enum {
	NORMAL = 0x00,
	VER_ERROR = 0x01,
	CHKSUM_ERROR = 0x02,
	LCHKSUM_ERROR = 0x03,
	CID2_INVALID = 0x04,
	CMD_FMT_ERROR = 0x05,
	INVALID_DATA = 0x06,
};

static struct {
	uint8_t data[UPS_PDU_MAX_LEN];
	uint16_t len;
} ups_pdu;


const char* MegaTecCMD[] =
{
		"Q1\r",
		"T\r",
		"TL\r",
		"T",
		"Q\r",
		"S",
		"R",
		"C\r",
		"CT\r",
		"I\r",
		"F\r"
};


void init_UPS_value(void)
{
	UPS.Freq_in = 0;
	UPS.VAC_in = 0;
	UPS.VAC_out = 0;
	UPS.Temp = 0;
	UPS.Load = 0;
	UPS.SOC = 0;
	UPS.work_time = 0;
	UPS.Status = 0;
	UPS.Present = false;

	memset(UPS.model, 0, 11);
	memset(UPS.vertion, 0, 11);
}

void send_MegaTec_cmd(cmdMegaTecEnums_t command)
{
	if(command == ups_test_time){
		uint8_t req[10];

		memset(req, 0, 10);
		sprintf(req, "%s%d\r", MegaTecCMD[command], TimeParam);
		ups_send_block(req, strlen(req));
	}
	else if(command == ups_shutdown){

	}
	else if(command == ups_shutdown_restore){
		uint8_t req[10];

		memset(req, 0, 10);
		sprintf(req, "%s.%d%s%d\r", MegaTecCMD[command-1], TimeParam, MegaTecCMD[command], TimeParam2);
		ups_send_block(req, strlen(req));
	}
	else{
		ups_send_block(MegaTecCMD[command], strlen(MegaTecCMD[command]));
	}
}

bool ups_megatec_rx_pdu(void)
{
	int c = 0;

	ups_pdu.len = 0;

	while ((ups_pdu.len < UPS_PDU_MAX_LEN) && (c != 0x0d)) {
		c = ups_getchar(500);//portMAX_DELAY
		if(c < 0)
		{
			ups_pdu.len = 0;
			break;
		}
		ups_pdu.data[ups_pdu.len++] = c;
	}

	if (ups_pdu.len == 0)
		return false;

	return true;
}

void ups_status_response(char *data)
{
	uint8_t i;
	char *endValue;
	char value[10];
	uint8_t len = 0;
	if(data[0] != '(')
		return;

	data++;

	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);
	UPS.VAC_in = atof(value);

	//TODO
	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);

	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);
	UPS.VAC_out = atof(value);

	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);
	UPS.Load = atoi(value);

	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);
	UPS.Freq_in = atof(value);

	//TODO
	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);

	memset(value, 0, 10);
	endValue = strpbrk(data," ");
	len = endValue - data;
	strncpy(value, data, len);
	data += (len + 1);
	UPS.Temp = atof(value);

	memset(value, 0, 10);
	endValue = strpbrk(data,"\r");
	len = endValue - data;
	strncpy(value, data, len);
	uint8_t stat = 0;
	for(i = 0; i < len; i ++)
	{
		stat |= (value[i] - 0x30) << (7-i);
	}
	UPS.Status = stat;
}

void ups_info_response(char *data)
{
	uint8_t i = 0;
	char *endValue;
	uint8_t len = 0;
	if(data[0] != '#')
		return;

	data++;

	data += 16;

	while(data[0] == ' '){
		data ++;
		i ++;
	}
	if(i < 11){
		endValue = strpbrk(data," ");
		len = endValue - data;
		strncpy(UPS.model, data, len);
		data += (len + 1);
	}

	endValue = strpbrk(data,"\r");
	len = endValue - data;
	strncpy(UPS.vertion, data, len);

}

void ups_megatec_process_pdu(cmdMegaTecEnums_t command)
{
	switch(command)
	{
	case ups_status_req:
		ups_status_response(ups_pdu.data);
		break;
	case ups_info:
		ups_info_response(ups_pdu.data);
		break;
	case ups_rating_info:

		break;
	default:
		break;
	}
}

int ups_metac_service_pdu(cmdMegaTecEnums_t command)
{
	while(!megatec_send)
	{
		vTaskDelay(50);
	}
	megatec_send = false;
	send_MegaTec_cmd(command);
	if (ups_megatec_rx_pdu())
	{
		megatec_send = true;
		if(strncmp(ups_pdu.data, "ACK", 3) == 0)
			return 1;
		else if(strncmp(ups_pdu.data, "NCK", 3) == 0)
			return 0;

	}
	return -1;
}

void request_task(void)
{

		for(;;)
		{
			if(megatec_send){
				megatec_send= false;
				send_MegaTec_cmd(ups_status_req);
				if (ups_megatec_rx_pdu())
					ups_megatec_process_pdu(ups_status_req);

				megatec_send=true;
			}
			//vTaskDelay(100);
			if(megatec_send){
				megatec_send = false;
				 send_MegaTec_cmd(ups_info);
				if (ups_megatec_rx_pdu())
					ups_megatec_process_pdu(ups_info);
				megatec_send = true;
			}

	        vTaskDelay(1000);

		}
}

void ups_megatec_init(void) {
	init_UPS_value();

	xTaskCreate(request_task, ( char * ) "request_task", configMINIMAL_STACK_SIZE * 2, NULL, tskIDLE_PRIORITY, NULL);

}