app_PBV_UART.c

/* 
 * @file    app_PBV_UART.c
 * @ingroup PBV_UART
 * @brief   Power Board Visualizer UART interface 
 */
 
//includes
#include <stdint.h>
#include <stdbool.h>
 
#include "app_PBV_UART.h"
// MCC header files
 
#include "../../mcc_generated_files/uart/uart1.h"
#include "../../mcc_generated_files/crc/crc.h"
 
 
#define PBV_CRC_POLYNOM             0x8005
 
 
#define PBV_CRC_POLYNOM_REV         0xA001
 
 
#define PBV_ReadyToSend             UART1_IsTxReady
 
 
#define PBV_Write                   UART1_Write
 
 
#define PBV_IsRxReady               UART1_IsRxReady
 
 
#define PBV_Read                    UART1_Read
 
 
#define PBV_START_OF_FRAME          0x55
 
 
#define PBV_END_OF_FRAME            0x0d
 
 
#define RCV_WAIT_FOR_STARTBYTE      0
#define RCV_READ_ID_HIGHBYTE        1
#define RCV_READ_ID_LOWBYTE         2
#define RCV_READ_LENGTH_HIGHBYTE    3
#define RCV_READ_LENGTH_LOWBYTE     4
#define RCV_READ_DATA               5
#define RCV_READ_CRC_HIGHBYTE       6
#define RCV_READ_CRC_LOWBYTE        7
#define RCV_READ_EOF                8
#define RCV_MESSAGE_RECEIVED        9
 
 
#define PBV_RCV_DATABUFFER_SIZE     64      // MAX.. 
 
 
#define PBV_HEADER_SIZE             5       // in bytes 0x55 + protocol ID (2 bytes) + length (2 bytes)?
 
 
typedef struct UART_MSG_RX_OBJ
{
    uint8_t UART_Frame_State;               
    uint8_t Length_in_Bytes;                
    uint16_t Protocol_ID;                   
    uint16_t offset;                        
    uint16_t CRC;                           
    uint8_t PBV_Header[PBV_HEADER_SIZE];    
    uint8_t data[PBV_RCV_DATABUFFER_SIZE];  
} UART_MSG_RX_OBJ_t; 
 
 
typedef struct UART_MSG_TX_OBJ
{
    uint8_t UART_Frame_State;               
    uint8_t Length_in_Bytes;                
    uint16_t Protocol_ID;                   
    uint16_t offset;                        
    uint16_t CRC;                           
    uint8_t PBV_Header[PBV_HEADER_SIZE];    
    uint8_t * data;                         
} UART_MSG_TX_OBJ_t; 
 
uint32_t PBV_calculated_CRC = 0;            
 
static bool uartActiveTx;                   
static bool uartActiveTxAscii;              
 
// private function declaration
uint16_t PBV_Calculate_CRC(uint8_t *message, uint16_t length);
 
 
UART_MSG_TX_OBJ_t PBV_UART_Object_TX;
 
 
UART_MSG_RX_OBJ_t PBV_UART_Object_RX;
 
 
UART_MSG_TX_OBJ_t PBV_UART_Object_ASCII; //
 
 
void PBV_UART_Init(PBV_Datatype_TX_t * Board_To_PBV, PBV_Datatype_TX_t * Board_To_PBVAscii, PBV_Datatype_RX_t * Pbv_To_Board)
{
    PBV_UART_Object_TX.Protocol_ID = Board_To_PBV->PBV_Protcol_ID;
    PBV_UART_Object_TX.offset = 0;
    PBV_UART_Object_TX.Length_in_Bytes = Board_To_PBV->Length;
    PBV_UART_Object_TX.data = Board_To_PBV->Data_Buffer;
 
    PBV_UART_Object_RX.offset = 0;
 
    PBV_UART_Object_ASCII.Protocol_ID = Board_To_PBVAscii->PBV_Protcol_ID;
    PBV_UART_Object_ASCII.offset = 0;
    PBV_UART_Object_ASCII.Length_in_Bytes = Board_To_PBVAscii->Length;
    PBV_UART_Object_ASCII.data = Board_To_PBVAscii->Data_Buffer;
 
    uartActiveTx = false;
    uartActiveTxAscii = false;
}
 
 
uint8_t PBV_UART_Receive_from_GUI()
{ 
    static uint16_t rcv_data_index = 0;
    static uint16_t rcv_CRC = 0;
    static uint16_t rcv_timeout = 0;
    static  uint8_t rcv_copy_for_CRC[PBV_RCV_DATABUFFER_SIZE + PBV_HEADER_SIZE];     
    uint8_t data;
 
    while (1)
    {
        if (PBV_IsRxReady() == false)
        {
            if (++rcv_timeout >= 10000)
            {
                rcv_timeout = 0;
                PBV_UART_Object_RX.UART_Frame_State = RCV_WAIT_FOR_STARTBYTE;
            }
            return PBV_MESSAGE_READY_TO_RECEIVE;
        }
        // ok, we have some data coming in, lets read and process
        rcv_timeout = 0;
        data = PBV_Read();
        switch (PBV_UART_Object_RX.UART_Frame_State)
        {
        case RCV_WAIT_FOR_STARTBYTE:
            if (data == PBV_START_OF_FRAME)
            {
                PBV_UART_Object_RX.UART_Frame_State = RCV_READ_ID_HIGHBYTE;
                PBV_UART_Object_RX.offset = 0;
                PBV_UART_Object_RX.PBV_Header[PBV_UART_Object_RX.offset] = data; 
                rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
                rcv_data_index++;                                               // for CRC
                PBV_UART_Object_RX.offset++;
            }
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_ID_HIGHBYTE:
            PBV_UART_Object_RX.Protocol_ID = data << 8;
            PBV_UART_Object_RX.UART_Frame_State = RCV_READ_ID_LOWBYTE;
            PBV_UART_Object_RX.PBV_Header[PBV_UART_Object_RX.offset] = data; 
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            PBV_UART_Object_RX.offset++;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_ID_LOWBYTE:
            PBV_UART_Object_RX.Protocol_ID |= data;
            PBV_UART_Object_RX.UART_Frame_State = RCV_READ_LENGTH_HIGHBYTE;
            PBV_UART_Object_RX.PBV_Header[PBV_UART_Object_RX.offset] = data; 
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            PBV_UART_Object_RX.offset++;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_LENGTH_HIGHBYTE:
            // clear CRC flag, for now, as the firmware doesn't support it
            // With PBV version 2.0.0, dsPIC cannot receive
            // messages from the GUI if this flag is not cleared
            PBV_UART_Object_RX.PBV_Header[PBV_UART_Object_RX.offset] = data;
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            data = data & 0x7F; // clear bit 7 (CRC flag) 
            PBV_UART_Object_RX.Length_in_Bytes = data << 8;
            PBV_UART_Object_RX.UART_Frame_State = RCV_READ_LENGTH_LOWBYTE;
            PBV_UART_Object_RX.offset++;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_LENGTH_LOWBYTE:
            PBV_UART_Object_RX.PBV_Header[PBV_UART_Object_RX.offset] = data;
            PBV_UART_Object_RX.Length_in_Bytes |= data;
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            PBV_UART_Object_RX.UART_Frame_State = RCV_READ_DATA;
            PBV_UART_Object_RX.offset = 0;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_DATA:
            if (PBV_UART_Object_RX.offset < PBV_RCV_DATABUFFER_SIZE + PBV_HEADER_SIZE ) // MAX
            {
                PBV_UART_Object_RX.data[PBV_UART_Object_RX.offset] = data;
                PBV_UART_Object_RX.offset++;
                
                rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
                rcv_data_index++;                                               // for CRC
            }
            if (PBV_UART_Object_RX.offset >= PBV_UART_Object_RX.Length_in_Bytes) //are we finished receiving data???
            {
                PBV_UART_Object_RX.UART_Frame_State = RCV_READ_CRC_HIGHBYTE;
            }
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_CRC_HIGHBYTE:
            rcv_CRC = data << 8;
            PBV_UART_Object_RX.UART_Frame_State = RCV_READ_CRC_LOWBYTE;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_CRC_LOWBYTE:
            rcv_CRC |= data;
            PBV_UART_Object_RX.UART_Frame_State = RCV_READ_EOF;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_EOF:
            if (data == 0x0d)
            {
                PBV_calculated_CRC = PBV_Calculate_CRC(rcv_copy_for_CRC, PBV_UART_Object_RX.Length_in_Bytes + PBV_HEADER_SIZE);
                if (PBV_calculated_CRC == rcv_CRC)
                {
                    rcv_data_index = 0;
                    rcv_CRC = 0;
                    PBV_calculated_CRC = 0;
                    PBV_UART_Object_RX.UART_Frame_State = RCV_MESSAGE_RECEIVED;
                    return PBV_MESSAGE_RECEIVED;
                }
                else {
                    rcv_data_index = 0;         //for CRC
                    return PBV_MESSAGE_RX_ERROR;
                }
            }
        }
    }
}
 
 
uint8_t PBV_UART_Transmit_Ascii_to_GUI()
{
    uint8_t temp;
    if (uartActiveTx == true)
    {
        return PBV_MESSAGE_TX_ERROR;
    }
 
    switch (PBV_UART_Object_ASCII.UART_Frame_State)
    {
    case 0:
        PBV_UART_Object_ASCII.PBV_Header[0] = PBV_START_OF_FRAME;
        PBV_UART_Object_ASCII.PBV_Header[1] = PBV_UART_Object_ASCII.Protocol_ID >> 8;
        PBV_UART_Object_ASCII.PBV_Header[2] = PBV_UART_Object_ASCII.Protocol_ID & 0xff;
        PBV_UART_Object_ASCII.PBV_Header[3] = PBV_UART_Object_ASCII.Length_in_Bytes >> 8;
        PBV_UART_Object_ASCII.PBV_Header[4] = PBV_UART_Object_ASCII.Length_in_Bytes & 0xff;
        PBV_UART_Object_ASCII.offset = 0;
        PBV_UART_Object_ASCII.UART_Frame_State = 1;
        uartActiveTxAscii = true;
        //break;
        return PBV_MESSAGE_TRANSMITTING;
 
    case 1: //transfer header
        while (PBV_ReadyToSend())//    && (MsCounter_++ > 1)) //@ftx
        {
            temp = PBV_UART_Object_ASCII.PBV_Header[PBV_UART_Object_ASCII.offset];
            PBV_Write(temp);
            PBV_UART_Object_ASCII.offset++;
            if (PBV_UART_Object_ASCII.offset > 4)
            {
                PBV_UART_Object_ASCII.offset = 0;
                PBV_UART_Object_ASCII.UART_Frame_State = 2;
                return PBV_MESSAGE_TRANSMITTING; // Why is this here?
            }
        }
        return PBV_MESSAGE_TRANSMITTING;   
        //break;
 
    case 2: //transfer data 
        while (PBV_ReadyToSend())// && (MsCounter_++ > 1)) //@ftx
        {
            PBV_Write(PBV_UART_Object_ASCII.data[PBV_UART_Object_ASCII.offset]);
            PBV_UART_Object_ASCII.offset++;
            if (PBV_UART_Object_ASCII.offset >= PBV_UART_Object_ASCII.Length_in_Bytes)
            {
                PBV_UART_Object_ASCII.UART_Frame_State = 3;
                PBV_UART_Object_ASCII.offset = 0;
                return PBV_MESSAGE_TRANSMITTING;
            }
        }
        return PBV_MESSAGE_TRANSMITTING;
    case 3: //calculate CRC make end header
        //IMPORTANT calculate crc before reusing PBV_HEADER
        PBV_UART_Object_ASCII.PBV_Header[0] = 0; //
        PBV_UART_Object_ASCII.PBV_Header[1] = 0; //add crc
        PBV_UART_Object_ASCII.PBV_Header[2] = PBV_END_OF_FRAME;
        PBV_UART_Object_ASCII.UART_Frame_State = 4;
        return PBV_MESSAGE_TRANSMITTING;
 
    case 4: //transfer header
        while (PBV_ReadyToSend())
        {
            PBV_Write(PBV_UART_Object_ASCII.PBV_Header[PBV_UART_Object_ASCII.offset]);
            PBV_UART_Object_ASCII.offset++;
            if (PBV_UART_Object_ASCII.offset >= 3)
            {
                PBV_UART_Object_ASCII.UART_Frame_State = 0;
                PBV_UART_Object_ASCII.offset = 0;
                uartActiveTxAscii = false;
                return PBV_MESSAGE_TRANSMITTED;
            }
        }
        return PBV_MESSAGE_TRANSMITTING;
    }
}
 
 
uint8_t PBV_UART_Transmit_to_GUI()
{
    uint16_t temp;
    if (uartActiveTxAscii == true)
    {
        return PBV_MESSAGE_TX_ERROR;
    }
 
    switch (PBV_UART_Object_TX.UART_Frame_State)
    {
    case 0:
        PBV_UART_Object_TX.PBV_Header[0] = PBV_START_OF_FRAME;
        PBV_UART_Object_TX.PBV_Header[1] = PBV_UART_Object_TX.Protocol_ID >> 8;
        PBV_UART_Object_TX.PBV_Header[2] = PBV_UART_Object_TX.Protocol_ID & 0xff;
        PBV_UART_Object_TX.PBV_Header[3] = PBV_UART_Object_TX.Length_in_Bytes >> 8;
        PBV_UART_Object_TX.PBV_Header[4] = PBV_UART_Object_TX.Length_in_Bytes & 0xff;
        PBV_UART_Object_TX.offset = 0;
        PBV_UART_Object_TX.UART_Frame_State = 1;
        uartActiveTx = true;
        //break;
        return PBV_MESSAGE_TRANSMITTING;
 
    case 1: //transfer header
        while (PBV_ReadyToSend())//    && (MsCounter_++ > 1)) //@ftx
        {
            temp = PBV_UART_Object_TX.PBV_Header[PBV_UART_Object_TX.offset];
            PBV_Write(temp);
            PBV_UART_Object_TX.offset++;
            if (PBV_UART_Object_TX.offset > 4)
            {
                PBV_UART_Object_TX.offset = 0;
                PBV_UART_Object_TX.UART_Frame_State = 2;
                return PBV_MESSAGE_TRANSMITTING;
            }
        }
        return PBV_MESSAGE_TRANSMITTING;
        //break;
 
    case 2: //transfer data 
        while (PBV_ReadyToSend())// && (MsCounter_++ > 1)) //@ftx
        {
            PBV_Write(PBV_UART_Object_TX.data[PBV_UART_Object_TX.offset]);
            PBV_UART_Object_TX.offset++;
            if (PBV_UART_Object_TX.offset >= PBV_UART_Object_TX.Length_in_Bytes)
            {
                PBV_UART_Object_TX.UART_Frame_State = 3;
                PBV_UART_Object_TX.offset = 0;
                return PBV_MESSAGE_TRANSMITTING;
            }
        }
        return PBV_MESSAGE_TRANSMITTING;
    case 3: //calculate CRC make end header
        //IMPORTANT calculate crc before reusing PBV_HEADER
        PBV_UART_Object_TX.PBV_Header[0] = 0; //
        PBV_UART_Object_TX.PBV_Header[1] = 0; //add crc
        PBV_UART_Object_TX.PBV_Header[2] = PBV_END_OF_FRAME;
        PBV_UART_Object_TX.UART_Frame_State = 4;
        return PBV_MESSAGE_TRANSMITTING;
 
    case 4: //transfer header
        while (PBV_ReadyToSend())
        {
            PBV_Write(PBV_UART_Object_TX.PBV_Header[PBV_UART_Object_TX.offset]);
            PBV_UART_Object_TX.offset++;
            if (PBV_UART_Object_TX.offset >= 3)
            {
                PBV_UART_Object_TX.UART_Frame_State = 0;
                PBV_UART_Object_TX.offset = 0;
                uartActiveTx = false;
                return PBV_MESSAGE_TRANSMITTED;
            }
        }
        return PBV_MESSAGE_TRANSMITTING;
    }
}
 
 
void PBV_UART_Reinit(PBV_Datatype_TX_t * ptr)
{
    if (ptr->PBV_Signal_Ascii == PBV_SIGNAL_MODE)
        PBV_UART_Object_TX.Protocol_ID = ptr->PBV_Protcol_ID;
    else
        PBV_UART_Object_ASCII.Protocol_ID = ptr->PBV_Protcol_ID;
}
 
 
void PBV_UART_Link_Data_TX(PBV_Datatype_TX_t * ptr)
{
    if (ptr->PBV_Signal_Ascii == PBV_SIGNAL_MODE)
    {
        PBV_UART_Object_TX.data             =    ptr->Data_Buffer;
        PBV_UART_Object_TX.Length_in_Bytes  =    ptr->Length;
    }
    else
    {
        PBV_UART_Object_ASCII.data          =   ptr->Data_Buffer;
        PBV_UART_Object_TX.Length_in_Bytes  =   ptr->Length;
    }
}
 
 
void PBV_UART_Link_Data_RX(PBV_Datatype_RX_t * ptr)
{
    if (ptr->PBV_Message_State == PBV_MESSAGE_RECEIVED){
        ptr->PBV_Protcol_ID = PBV_UART_Object_RX.Protocol_ID;
        ptr->Data_Buffer = PBV_UART_Object_RX.data;
        ptr->Length = PBV_UART_Object_RX.Length_in_Bytes;
    } 
}
 
 
uint16_t PBV_Calculate_CRC(uint8_t *message, uint16_t length)
{
    //CRC_Initialize();
    uint8_t message_odd = (uint8_t) (length & 0x01);
    uint16_t length_t = 0;
    uint16_t i, j;
    //uint16_t * message16bit;
    uint32_t trycount = 0;
    uint16_t resultCRC = 0;
    uint16_t message16bit[PBV_RCV_DATABUFFER_SIZE]; 
 
    //calCRCTEMP = 0; //
 
    if (message_odd)
        length_t = (length & 0xFFFE);
    else
        length_t = length;
 
    for (i = 0, j = 0; i < length_t; i += 2, j++)
    {
        //*(message16bit + j) = (message[i + 1 ] << 8 ) | message[i] ; 
        message16bit[j] = (message[i + 1 ] << 8) | message[i];
    }
 
    CRC_CalculateBufferStart(message16bit, length_t);
 
    while (!CRC_CalculationIsDone() && trycount < 2000)
    {
        CRC_Tasks();
        trycount++;
    }
 
    resultCRC = CRC_CalculationResultReverseGet();
 
    if (message_odd)
    {
        resultCRC ^= message[length - 1];
        for (i = 0; i < 8; ++i)
        {
            if (resultCRC & 0x0001)
            {
                resultCRC = (resultCRC >> 1)^ PBV_CRC_POLYNOM_REV;
            }
            else
            {
                resultCRC = (resultCRC >> 1);
            }
        }
    }
    // clearing shift registers.
    CRCWDATL = 0x0;
    CRCWDATH = 0x0;
    
    return resultCRC;
}