#include "board_common.h"

#include "app.h"



typedef enum
{
    T_I = 1,
    T_V,
}DATA_TYPE;

typedef enum
{
    I_0 = 0,
    I_1,
    I_2,
    I_3,
}I_CHANNEL;

typedef enum
{
    V_0= 0,
    V_1,
    V_2,
    V_3
}V_CHANNEL;

#define ADC_CHANNEL_MAX_NUM 10		
#define ADC_SAMPLE_BUFFER_SIZE 20 


#pragma pack (1)

typedef struct
{
    uint8_t header[2]; /* 报文头0xAA 0x55 */
    uint8_t type;  /* 1:电流, 2:电压 */
    uint8_t channel; /* 通道 */
    uint16_t crc; /* CRC */
}RxPacket;

#define RX_PACKET_SIZE sizeof(RxPacket)
typedef union
{
    RxPacket packet;
    uint8_t buffer[RX_PACKET_SIZE];
}RxPacket_u;


typedef struct
{
    uint8_t header[2]; /* 报文头0xAA 0x55 */
    uint8_t type;  /* 1:电流, 2:电压 */
    uint8_t channel; /* 通道 */
    uint16_t value; /* 数值 */
    uint16_t crc; /* CRC */
}RxPacketRes;

#define RX_PACKET_RES_SIZE sizeof(RxPacketRes)
typedef union
{
    RxPacketRes packet;
    uint8_t buffer[RX_PACKET_RES_SIZE];
}RxPacketRes_u;

#pragma pack ()

static uint16_t adcSampleBuffer[ADC_CHANNEL_MAX_NUM][ADC_SAMPLE_BUFFER_SIZE] = {0};
static bool adcDataReadable = false; 

void PrintHex(const unsigned char *buffer, unsigned int len)
{
    unsigned int i;
    PRINTF("\r\n");
    for(i=0; i<len; i++)
    {
        PRINTF("%02x ", buffer[i]);
        if (i!=0 && ((i+1)%16) == 0)
            PRINTF("\r\n");
    }
    PRINTF("\r\n");
}

static uint16_t CRC16(const uint8_t *Buf , uint32_t usLen)
{
    uint16_t i, j;
    uint16_t usCrc = 0xFFFF;
    for ( i = 0 ; i < usLen ; i++ )
    {
        usCrc ^= Buf[i];
        for ( j = 0 ; j < 8 ; j++ )
        {
            if ( usCrc & 1 )
            {
                usCrc >>=1;
                usCrc ^=0xA001;
            }
            else
            {
                usCrc >>= 1;
            }
        }
    }
    return usCrc;
}

void ADC_Sample(void)
{
    /* 采样adc数据 */
    ADC_SampleData sampleData;
    memset(&sampleData, 0x0, sizeof(ADC_SampleData));
    if (ADC1_ADC_GetSampleData(&sampleData, sizeof(ADC_SampleData)) < 0)
        return ;
    /* 
     * 将采样数据存储到指定buffer 
     */
    static uint8_t bufferIndex = 0;
    uint8_t channel = 0;
    for (; channel < ADC_CHANNEL_MAX_NUM; channel++)
    {
        adcSampleBuffer[channel][bufferIndex] = sampleData.sampleBuffer[channel];
    }

    if (bufferIndex < ADC_SAMPLE_BUFFER_SIZE)
    {
        bufferIndex++;
    }
    else
    {
        bufferIndex = 0;
        adcDataReadable = true; /* buffer已经满,数据可读 */
    }
    
}

double RootMeanSquareCalc(uint16_t *data, uint8_t num)
{
    double sum = 0;
	uint8_t i = 0;
	
    for(; i<num; i++)
    {
        sum += data[i] * data[i]; /* 平方和 */
        
        //PRINTF("%d\r\n", data[i]);
     }
 
    return sqrt(sum/num);
}


static void ReportChannelData(DATA_TYPE type, uint8_t ch)
{
	double rootMeanSquareVref = RootMeanSquareCalc((uint16_t *)&adcSampleBuffer[0], ADC_SAMPLE_BUFFER_SIZE);
    PRINTF("ref:%f\r\n", rootMeanSquareVref);
    double rootMeanSquare = 0.0;

    uint32_t v33 = 2500*4095/(uint16_t)rootMeanSquare;
    rootMeanSquare = RootMeanSquareCalc((uint16_t *)&adcSampleBuffer[1], ADC_SAMPLE_BUFFER_SIZE);
    uint32_t v12 = 12*v33*rootMeanSquare/4095;
    uint32_t vo = 0;
    uint32_t vi = 0;
    uint32_t v5 = 0;
    uint32_t value = 0;
    switch (type)
    {
        case T_I:
            rootMeanSquare = RootMeanSquareCalc((uint16_t *)&adcSampleBuffer[6+ch], ADC_SAMPLE_BUFFER_SIZE);
            PRINTF("ADC:%f\r\n", rootMeanSquare);
            vo = 100*2500*rootMeanSquare/rootMeanSquareVref;
            value = vo/100;
            PRINTF("vi:%d\t\ti:%d(0.01mA)\r\n", vo,value);
            break;
        case T_V:
            rootMeanSquare = RootMeanSquareCalc((uint16_t *)&adcSampleBuffer[2+ch], ADC_SAMPLE_BUFFER_SIZE);
            PRINTF("ADC:%f\r\n", rootMeanSquare);
            vo = 2500*rootMeanSquare/rootMeanSquareVref;
            vi = 1000*vo/452; /* vo=0.452 x vi */
            value = vi;
            PRINTF("vo:%d\t\tvi:%d(1mV)\r\n", vo, vi);
            break;
    }

    RxPacketRes_u resPacket;
    memset(&resPacket, 0x0, sizeof(RxPacketRes_u));
    resPacket.packet.header[0] = 0xAA;
    resPacket.packet.header[1] = 0x55;
    resPacket.packet.type = type;
    resPacket.packet.channel = ch;
    resPacket.packet.value = value;
    resPacket.packet.crc = CRC16(resPacket.buffer, sizeof(RxPacketRes_u)-2);
    
    PRINTF("Send:");
    PrintHex((const unsigned char *)resPacket.buffer, sizeof(RxPacketRes_u));
    Board_USART2Send(resPacket.buffer, sizeof(RxPacketRes_u));
}

static int ParserRecvPacket(uint8_t *buffer, uint8_t len, RxPacket_u *data)
{
    PRINTF("Receive:");
    PrintHex((const unsigned char *)buffer, len);

    if (len != sizeof(RxPacket_u))
        return -1;
    
    RxPacket_u *packet = (RxPacket_u *)buffer;
    if (packet->packet.header[0] != 0xAA && packet->packet.header[1] != 0x55)
        return -1;

    uint16_t crc = packet->packet.crc;
    uint16_t calCrc = CRC16((const uint8_t *)buffer, RX_PACKET_SIZE-2);
    if (crc != calCrc)
        return -1;
    if (adcDataReadable)
        ReportChannelData(packet->packet.type, packet->packet.channel);

    return 0;
}


int8_t Board_USART_Process(void)
{
    uint8_t u8Rx = 0;
    uint32_t u32TestTimeOut = jiffies + 5000;
    uint32_t u32RecvTimeOut = jiffies + 200;
    const uint8_t u8SendBuffer[32] = "Recv OK\r\n";
    uint8_t u8RecvBuffer[32] = {0};
    uint8_t u8Index = 0;

    RxPacket_u data;
    memset(&data, 0x0, sizeof(RxPacket_u));
    while(1)
    {
        while( !Timeout_Happened(u32RecvTimeOut))
        {
            if (!Board_USART2Recv(&u8Rx, 200))
            {
                u8RecvBuffer[u8Index] = u8Rx;
                if (u8Index <= (sizeof(u8RecvBuffer)-1))
                    u8Index++;
                else
                    break;
            }
        }
        
        if(u8Index > 0)
        {
            ParserRecvPacket(u8RecvBuffer, u8Index, &data);
        }
        u8Index = 0;
        memset(u8RecvBuffer, 0, sizeof(u8RecvBuffer));
        u32RecvTimeOut = jiffies + 200;
    }
    return -1;
}