/*
 * user.c
 *
 *  Created on: Nov 11, 2024
 *      Author: 10425
 */


#include "user.h"

volatile uint8_t  	usart1_count = 0;						//串口接收数据个数
uint8_t 		  	RxBuff1[BUFF_LEN] = {0};					//串口接收缓冲区
uint8_t  		  	TXBuff1[BUFF_LEN] = {0};					//串口发送缓冲区
uint8_t	 			uBuff1[BUFF_LEN] = {0};


volatile uint8_t  	usart3_count = 0;						//串口接收数据个数
uint8_t 		  	RxBuff3[BUFF_LEN] = {0};					//串口接收缓冲区
uint8_t  		  	TXBuff3[BUFF_LEN] = {0};					//串口发送缓冲区
uint8_t	 			uBuff3[BUFF_LEN] = {0};

uint16_t RegularConvData_Tab[ADCBUFF_LEN];
volatile struct REGISTER dev_reg ={0};


#define	REGISTER_CNT	12
int16_t  user_register[REGISTER_CNT] = {0};				//寄存器值

void ADC_MAX(void)
{
	int16_t max_Mx ,max_My,max_Mz,max_Ez;
	int16_t	min_Mx,min_My,min_Mz,min_Ez;
	static int16_t max_Mx1=0,max_My1=0,max_Mz1=0,max_Ez1=0;
	static int16_t min_Mx1=0,min_My1=0,min_Mz1=0,min_Ez1=0;
	int16_t REF;

	static int16_t last_x=0,last_y =0,last_z=0,last_e=0;
	static uint16_t number =0;

	int16_t i =0;
	max_Mx =RegularConvData_Tab[1];
	min_Mx =RegularConvData_Tab[1];
	max_My =RegularConvData_Tab[2];
	min_My =RegularConvData_Tab[2];
	max_Mz =RegularConvData_Tab[3];
	min_Mz =RegularConvData_Tab[3];
	max_Ez =RegularConvData_Tab[4];
	min_Ez =RegularConvData_Tab[4];

	for(i=5;i<ADCBUFF_LEN;)
	{
		REF = RegularConvData_Tab[i++];
		if(RegularConvData_Tab[i]>max_Mx)
		{
			max_Mx = RegularConvData_Tab[i];
		}
		else if(RegularConvData_Tab[i]<min_Mx)
		{
			min_Mx = RegularConvData_Tab[i];
		}
		i++;

		if(RegularConvData_Tab[i]>max_My)
		{
			max_My = RegularConvData_Tab[i];
		}
		else if(RegularConvData_Tab[i]<min_My)
		{
			min_My = RegularConvData_Tab[i];
		}
		i++;

		if(RegularConvData_Tab[i]>max_Mz)
		{
			max_Mz = RegularConvData_Tab[i];
		}
		else if(RegularConvData_Tab[i]<min_Mz)
		{
			min_Mz = RegularConvData_Tab[i];
		}
		i++;

		if(RegularConvData_Tab[i]>max_Ez)
		{
			max_Ez = RegularConvData_Tab[i];
		}
		else if(RegularConvData_Tab[i]<min_Ez)
		{
			min_Ez = RegularConvData_Tab[i];
		}
		i++;
	}

	max_Mx1+=max_Mx;
	max_My1+=max_My;
	max_Mz1+=max_Mz;
	max_Ez1+=max_Ez;

	min_Mx1+=min_Mx;
	min_My1+=min_My;
	min_Mz1+=min_Mz;
	min_Ez1+=min_Ez;

	if(number++ >= 2 )
	{
		number=0;
		max_Mx=max_Mx1/3;
		max_My=max_My1/3;
		max_Mz=max_Mz1/3;
		max_Ez=max_Ez1/3;

		min_Mx=min_Mx1/3;
		min_My=min_My1/3,
		min_Mz=min_Mz1/3,
		min_Ez=min_Ez1/3;


		dev_reg.electric_X = 0;
		dev_reg.electric_Y = 0;
		dev_reg.electric_Z = (max_Ez-min_Ez)*3300/4095;
		dev_reg.electric_Z = (dev_reg.electric_Z*0.1231-0.3242)*100;
		if(abs(dev_reg.electric_Z -last_e)<30)
		{
			dev_reg.electric_Z =last_e;
		}
		else {
			last_e=dev_reg.electric_Z;
		}
		dev_reg.electric_Z =dev_reg.electric_Z-120;
		if(dev_reg.electric_Z<0)dev_reg.electric_Z=0;
		dev_reg.electric_V = dev_reg.electric_Z;


		dev_reg.magnetic_X = (max_Mx-min_Mx)*3300/4095;
		dev_reg.magnetic_X =dev_reg.magnetic_X*1000*100/2/14640;
		if(abs(dev_reg.magnetic_X -last_x)<30)
		{
			dev_reg.magnetic_X =last_x;
		}
		else {
			last_x=dev_reg.magnetic_X;
		}


		dev_reg.magnetic_Y = (max_My-min_My)*3300/4095;
		dev_reg.magnetic_Y =dev_reg.magnetic_Y*1000*100/2/14640;
		if(abs(dev_reg.magnetic_Y -last_y)<30)
		{
			dev_reg.magnetic_Y =last_y;
		}
		else {
			last_y=dev_reg.magnetic_Y;
		}


		dev_reg.magnetic_Z = (max_Mz-min_Mz)*3300/4095;
		dev_reg.magnetic_Z =dev_reg.magnetic_Z*1000*100/2/14640;
		if(abs(dev_reg.magnetic_Z -last_z)<30)
		{
			dev_reg.magnetic_Z =last_z;
		}
		else {
			last_z=dev_reg.magnetic_Z;
		}

		dev_reg.magnetic_V = (int16_t)sqrt(pow(dev_reg.magnetic_X,2)+pow(dev_reg.magnetic_Y,2)
									+pow(dev_reg.magnetic_Z,2));

		max_Mx1=0;
		max_My1=0;
		max_Mz1=0;
		max_Ez1=0;

		min_Mx1=0;
		min_My1=0,
		min_Mz1=0,
		min_Ez1=0;
		send_UI(7);
	}

	dev_reg.REF = REF*3300/4095;

}

void send_data(UART_HandleTypeDef*huart,uint8_t* data,uint16_t len)
{
	if(huart->Instance == USART1)
	{
		HAL_GPIO_WritePin(TXEN_485_GPIO_Port, TXEN_485_Pin, GPIO_PIN_SET);//使能485芯片发送
		HAL_UART_Transmit_DMA(huart, data, len);

	}
	else {
		HAL_UART_Transmit_DMA(huart, data, len);
	}
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART1)
    {
        // 发送完成后的处理逻辑
    	HAL_GPIO_WritePin(TXEN_485_GPIO_Port, TXEN_485_Pin, GPIO_PIN_RESET);//使能485芯片接收
    }
}

void Usart_Receive()
{
	if(usart3_count>0)
	{
		if( (uint16_t)uBuff3[0] == dev_reg.addr )
		{
			switch(uBuff3[1])
			{
			case 0x03:						//读传感器数据
				MODBUS_03H();
				break;

			default:break;
			}
		}
	}
	if(usart1_count>0)
	{
		if( (uint16_t)uBuff1[0] == 1 )
		{
			switch(uBuff1[1])
			{
			case 0x03:						//读传感器数据
				change_addr();
				break;

			case 0x10:						//读传感器数据
				MODBUS_10H();
				break;

			default:break;
			}
		}
	}


}
/************************************************************
 * Name:    CRC-16/MODBUS       x16+x15+x2+1
 * Poly:    0x8005
 * Init:    0xFFFF
 * Refin:   True
 * Refout:  True
 * Xorout:  0x0000
 * Note:
 **********************************************************/
uint16_t crc16_modbus(uint8_t *data, uint16_t length)
{
    uint8_t i;
    uint16_t crc = 0xffff;        // Initial value
    while(length--)
    {
        crc ^= *data++;            // crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001;        // 0xA001 = reverse 0x8005
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

void MODBUS_03H()
{
	//接收到的数据帧
	//485地址 功能位	寄存器地址	寄存器个数	crc低位 crc高位
	uint8_t		crch,crcl;
	uint16_t 	crcack;
	uint16_t 	addr 	=  (uint16_t)uBuff3[2]<<8 | uBuff3[3];	//寄存器地址
	uint16_t	number  =  (uint16_t)uBuff3[4]<<8 | uBuff3[5];	//寄存器数量
	uint16_t 	crc = 	crc16_modbus(uBuff3,6);               	//计算CRC
	crch = crc>>8;
	crcl = crc&0x00FF;

	int16_t *p = (int16_t*)&dev_reg;
	for(uint8_t i=1;i<REGISTER_CNT;i++)
	{
		user_register[i] = *(p+i);
	}

	if( (addr+number) <= REGISTER_CNT && crcl == uBuff3[6] && crch == uBuff3[7])
	{
		uint8_t cnt = 0;
		TXBuff3[cnt++] = uBuff3[0];
		TXBuff3[cnt++] = uBuff3[1];
		TXBuff3[cnt++] = number*2;			//数据个数，单位/字节
		for(uint8_t i =0;i<number;i++)
		{
			TXBuff3[cnt++] = user_register[addr+i] >>8;
			TXBuff3[cnt++] = user_register[addr+i] & 0xFF;
		}
		crcack = crc16_modbus(TXBuff3,cnt);
		TXBuff3[cnt++] = crcack & 0xff;
		TXBuff3[cnt++] = crcack >>8;
		send_data(&huart3, TXBuff3, cnt);
	}
}

void send_UI(uint8_t a)
{
	uint8_t cnt =0;
	uint16_t crcValue = 0;
	TXBuff1[cnt++] = 1;
	TXBuff1[cnt++] = 0x10;		//功能位
	TXBuff1[cnt++] = 0x1000>>8;	//寄存器起始地址
	TXBuff1[cnt++] = 0x1000&0xFF;
	TXBuff1[cnt++] = 0;		//寄存器个数
	TXBuff1[cnt++] = a;
	TXBuff1[cnt++] = a*2;	//字节数

	TXBuff1[cnt++] = dev_reg.magnetic_X>>8;
	TXBuff1[cnt++] = dev_reg.magnetic_X&0xFF;

	TXBuff1[cnt++] = dev_reg.magnetic_Y>>8;
	TXBuff1[cnt++] = dev_reg.magnetic_Y&0xFF;

	TXBuff1[cnt++] = dev_reg.magnetic_Z>>8;
	TXBuff1[cnt++] = dev_reg.magnetic_Z&0xFF;

	TXBuff1[cnt++] = dev_reg.magnetic_V>>8;
	TXBuff1[cnt++] = dev_reg.magnetic_V&0xFF;

	TXBuff1[cnt++] = dev_reg.electric_V>>8;
	TXBuff1[cnt++] = dev_reg.electric_V&0xFF;

	TXBuff1[cnt++] = dev_reg.tempe>>8;
	TXBuff1[cnt++] = dev_reg.tempe&0xFF;

	TXBuff1[cnt++] = dev_reg.humidness>>8;
	TXBuff1[cnt++] = dev_reg.humidness&0xFF;


	if(a ==8)
	{
		TXBuff1[cnt++] = dev_reg.addr>>8;
		TXBuff1[cnt++] = dev_reg.addr&0xFF;
	}


	crcValue = crc16_modbus(TXBuff1, cnt);
	TXBuff1[cnt++] = crcValue&0xFF;
	TXBuff1[cnt++] = crcValue>>8;
	send_data(&huart1, TXBuff1, cnt);
}


void MODBUS_10H()
{
	uint8_t cnt =0;
	uint16_t crcValue =0;
	TXBuff1[cnt++] = 1;
	TXBuff1[cnt++] = 3;
	TXBuff1[cnt++] = 0x1007>>8;
	TXBuff1[cnt++] = 0x1007&0xFF;
	TXBuff1[cnt++] = 0;
	TXBuff1[cnt++] = 1;
	crcValue = crc16_modbus(TXBuff1, cnt);
	TXBuff1[cnt++] = crcValue&0xFF;
	TXBuff1[cnt++] = crcValue>>8;
	send_data(&huart1, TXBuff1, cnt);
}

void change_addr()
{
	if(uBuff1[2] == 2)
	{
		int16_t data =uBuff1[3]<<8 |uBuff1[4];

		if(data == 0)
		{
			send_UI(8);
		}
		else {
			if(data != dev_reg.addr)
			{
				dev_reg.addr =data;
				uint8_t parameters[2];
				parameters[0] = data>>8;
				parameters[1] = data&0xFF;
				AT24C16_WriteBytes(0, parameters, sizeof(parameters));
			}
		}
	}
}