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 "PBV_UART.h"
// MCC header files
 
#include "uart/uart1.h"
#include "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       
 
 
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 pbvUartObjectTx;
 
 
UART_MSG_RX_OBJ_t pbvUartObjectRx;
 
 
UART_MSG_TX_OBJ_t pbvUartObjectAscii; 
 
 
void PBV_UART_Init(PBV_Datatype_TX_t * boardToPbv, PBV_Datatype_TX_t * boardToPbvAscii, PBV_Datatype_RX_t * pbvToBoard)
{
    pbvUartObjectTx.Protocol_ID = boardToPbv->PBV_Protcol_ID;
    pbvUartObjectTx.Offset = 0;
    pbvUartObjectTx.Length_in_Bytes = boardToPbv->Length;
    pbvUartObjectTx.data = boardToPbv->Data_Buffer;
 
    pbvUartObjectRx.Offset = 0;
 
    pbvUartObjectAscii.Protocol_ID = boardToPbvAscii->PBV_Protcol_ID;
    pbvUartObjectAscii.Offset = 0;
    pbvUartObjectAscii.Length_in_Bytes = boardToPbvAscii->Length;
    pbvUartObjectAscii.data = boardToPbvAscii->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;
                pbvUartObjectRx.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 (pbvUartObjectRx.UART_Frame_State)
        {
        case RCV_WAIT_FOR_STARTBYTE:
            if (data == PBV_START_OF_FRAME)
            {
                pbvUartObjectRx.UART_Frame_State = RCV_READ_ID_HIGHBYTE;
                pbvUartObjectRx.Offset = 0;
                pbvUartObjectRx.PBV_Header[pbvUartObjectRx.Offset] = data; 
                rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
                rcv_data_index++;                                               // for CRC
                pbvUartObjectRx.Offset++;
            }
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_ID_HIGHBYTE:
            pbvUartObjectRx.Protocol_ID = data << 8;
            pbvUartObjectRx.UART_Frame_State = RCV_READ_ID_LOWBYTE;
            pbvUartObjectRx.PBV_Header[pbvUartObjectRx.Offset] = data; 
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            pbvUartObjectRx.Offset++;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_ID_LOWBYTE:
            pbvUartObjectRx.Protocol_ID |= data;
            pbvUartObjectRx.UART_Frame_State = RCV_READ_LENGTH_HIGHBYTE;
            pbvUartObjectRx.PBV_Header[pbvUartObjectRx.Offset] = data; 
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            pbvUartObjectRx.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
            pbvUartObjectRx.PBV_Header[pbvUartObjectRx.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) 
            pbvUartObjectRx.Length_in_Bytes = data << 8;
            pbvUartObjectRx.UART_Frame_State = RCV_READ_LENGTH_LOWBYTE;
            pbvUartObjectRx.Offset++;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_LENGTH_LOWBYTE:
            pbvUartObjectRx.PBV_Header[pbvUartObjectRx.Offset] = data;
            pbvUartObjectRx.Length_in_Bytes |= data;
            rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
            rcv_data_index++;                                               // for CRC
            pbvUartObjectRx.UART_Frame_State = RCV_READ_DATA;
            pbvUartObjectRx.Offset = 0;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_DATA:
            if (pbvUartObjectRx.Offset < (PBV_RCV_DATABUFFER_SIZE + PBV_HEADER_SIZE)) // MAX
            {
                pbvUartObjectRx.data[pbvUartObjectRx.Offset] = data;
                pbvUartObjectRx.Offset++;
                
                rcv_copy_for_CRC[rcv_data_index] = data;                        // for CRC
                rcv_data_index++;                                               // for CRC
            }
            if (pbvUartObjectRx.Offset >= pbvUartObjectRx.Length_in_Bytes) //are we finished receiving data???
            {
                pbvUartObjectRx.UART_Frame_State = RCV_READ_CRC_HIGHBYTE;
            }
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_CRC_HIGHBYTE:
            rcv_CRC = data << 8;
            pbvUartObjectRx.UART_Frame_State = RCV_READ_CRC_LOWBYTE;
            return PBV_STATE_RECEIVING;
 
        case RCV_READ_CRC_LOWBYTE:
            rcv_CRC |= data;
            pbvUartObjectRx.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, pbvUartObjectRx.Length_in_Bytes + PBV_HEADER_SIZE);
                if (PBV_calculated_CRC == rcv_CRC)
                {
                    rcv_data_index = 0;
                    rcv_CRC = 0;
                    PBV_calculated_CRC = 0;
                    pbvUartObjectRx.UART_Frame_State = RCV_MESSAGE_RECEIVED;
                    return PBV_MESSAGE_RECEIVED;
                }
                else {
                    rcv_data_index = 0;         //for CRC
                    return PBV_MESSAGE_RX_ERROR;
                }
            }
        default:
            break;
        }
    }
}
 
 
uint8_t PBV_UART_Transmit_Ascii_to_GUI()
{
    uint8_t retval = PBV_MESSAGE_TX_ERROR;
    
    if (uartActiveTx == true)
    {
        retval = PBV_MESSAGE_TX_ERROR;
    }
    else
    {
        switch (pbvUartObjectAscii.UART_Frame_State)
        {
            case 0:
                pbvUartObjectAscii.PBV_Header[0] = PBV_START_OF_FRAME;
                pbvUartObjectAscii.PBV_Header[1] = pbvUartObjectAscii.Protocol_ID >> 8;
                pbvUartObjectAscii.PBV_Header[2] = pbvUartObjectAscii.Protocol_ID & 0xff;
                pbvUartObjectAscii.PBV_Header[3] = pbvUartObjectAscii.Length_in_Bytes >> 8;
                pbvUartObjectAscii.PBV_Header[4] = pbvUartObjectAscii.Length_in_Bytes & 0xff;
                pbvUartObjectAscii.Offset = 0;
                pbvUartObjectAscii.UART_Frame_State = 1;
                uartActiveTxAscii = true;
                retval =  PBV_MESSAGE_TRANSMITTING;
            break;
 
            case 1: //transfer header
                if (PBV_ReadyToSend())//    && (MsCounter_++ > 1)) //@ftx
                {
                    uint8_t temp = pbvUartObjectAscii.PBV_Header[pbvUartObjectAscii.Offset];
                    PBV_Write(temp);
                    pbvUartObjectAscii.Offset++;
                    if (pbvUartObjectAscii.Offset > 4)
                    {
                        pbvUartObjectAscii.Offset = 0;
                        pbvUartObjectAscii.UART_Frame_State = 2;
                        retval = PBV_MESSAGE_TRANSMITTING; // Why is this here?
                    }
                }
                else
                {
                    retval =  PBV_MESSAGE_TRANSMITTING;   
                }
                break;
 
            case 2: //transfer data 
                if (PBV_ReadyToSend())// && (MsCounter_++ > 1)) //@ftx
                {
                    PBV_Write(pbvUartObjectAscii.data[pbvUartObjectAscii.Offset]);
                    pbvUartObjectAscii.Offset++;
                    if (pbvUartObjectAscii.Offset >= pbvUartObjectAscii.Length_in_Bytes)
                    {
                        pbvUartObjectAscii.UART_Frame_State = 3;
                        pbvUartObjectAscii.Offset = 0;
                        retval = PBV_MESSAGE_TRANSMITTING;
                    }
                }
                else
                {
                    retval =  PBV_MESSAGE_TRANSMITTING;
                }
                break;
                
            case 3: //calculate CRC make end header
                //IMPORTANT calculate crc before reusing PBV_HEADER
                pbvUartObjectAscii.PBV_Header[0] = 0; //
                pbvUartObjectAscii.PBV_Header[1] = 0; //add crc
                pbvUartObjectAscii.PBV_Header[2] = PBV_END_OF_FRAME;
                pbvUartObjectAscii.UART_Frame_State = 4;
                retval = PBV_MESSAGE_TRANSMITTING;
                break;
 
            case 4: //transfer header
                if (PBV_ReadyToSend())
                {
                    PBV_Write(pbvUartObjectAscii.PBV_Header[pbvUartObjectAscii.Offset]);
                    pbvUartObjectAscii.Offset++;
                    if (pbvUartObjectAscii.Offset >= 3)
                    {
                        pbvUartObjectAscii.UART_Frame_State = 0;
                        pbvUartObjectAscii.Offset = 0;
                        uartActiveTxAscii = false;
                        retval =  PBV_MESSAGE_TRANSMITTED;
                    }
                }
                else
                {
                    retval = PBV_MESSAGE_TRANSMITTING;
                }
                break;
            
            default:
                retval = PBV_MESSAGE_TRANSMITTING;
                break;
        }
    }
    return retval;
}
 
 
uint8_t PBV_UART_Transmit_to_GUI()
{
    uint8_t retval = PBV_MESSAGE_TX_ERROR;
    if (uartActiveTxAscii == true)
    {
        retval =  PBV_MESSAGE_TX_ERROR;
    }
    else
    {
        switch (pbvUartObjectTx.UART_Frame_State)
        {
            case 0:
                pbvUartObjectTx.PBV_Header[0] = PBV_START_OF_FRAME;
                pbvUartObjectTx.PBV_Header[1] = pbvUartObjectTx.Protocol_ID >> 8;
                pbvUartObjectTx.PBV_Header[2] = pbvUartObjectTx.Protocol_ID & 0xff;
                pbvUartObjectTx.PBV_Header[3] = pbvUartObjectTx.Length_in_Bytes >> 8;
                pbvUartObjectTx.PBV_Header[4] = pbvUartObjectTx.Length_in_Bytes & 0xff;
                pbvUartObjectTx.Offset = 0;
                pbvUartObjectTx.UART_Frame_State = 1;
                uartActiveTx = true;
                retval = PBV_MESSAGE_TRANSMITTING;
                break;
 
            case 1: //transfer header
                if (PBV_ReadyToSend())//    && (MsCounter_++ > 1)) //@ftx
                {
                    uint16_t temp = pbvUartObjectTx.PBV_Header[pbvUartObjectTx.Offset];
                    PBV_Write(temp);
                    pbvUartObjectTx.Offset++;
                    if (pbvUartObjectTx.Offset > 4)
                    {
                        pbvUartObjectTx.Offset = 0;
                        pbvUartObjectTx.UART_Frame_State = 2;
                        retval = PBV_MESSAGE_TRANSMITTING;
                    }
                }
                else
                {
                    retval =  PBV_MESSAGE_TRANSMITTING;
                }
                break;
 
            case 2: //transfer data 
                if (PBV_ReadyToSend())// && (MsCounter_++ > 1)) //@ftx
                {
                    PBV_Write(pbvUartObjectTx.data[pbvUartObjectTx.Offset]);
                    pbvUartObjectTx.Offset++;
                    if (pbvUartObjectTx.Offset >= pbvUartObjectTx.Length_in_Bytes)
                    {
                        pbvUartObjectTx.UART_Frame_State = 3;
                        pbvUartObjectTx.Offset = 0;
                        retval = PBV_MESSAGE_TRANSMITTING;
                    }
                }
                else
                {
                    retval = PBV_MESSAGE_TRANSMITTING;
                }
                break;
 
            case 3: //calculate CRC make end header
                //IMPORTANT calculate crc before reusing PBV_HEADER
                pbvUartObjectTx.PBV_Header[0] = 0; //
                pbvUartObjectTx.PBV_Header[1] = 0; //add crc
                pbvUartObjectTx.PBV_Header[2] = PBV_END_OF_FRAME;
                pbvUartObjectTx.UART_Frame_State = 4;
                retval = PBV_MESSAGE_TRANSMITTING;
                break;
 
            case 4: //transfer header
                if (PBV_ReadyToSend())
                {
                    PBV_Write(pbvUartObjectTx.PBV_Header[pbvUartObjectTx.Offset]);
                    pbvUartObjectTx.Offset++;
                    if (pbvUartObjectTx.Offset >= 3)
                    {
                        pbvUartObjectTx.UART_Frame_State = 0;
                        pbvUartObjectTx.Offset = 0;
                        uartActiveTx = false;
                        retval = PBV_MESSAGE_TRANSMITTED;
                    }
                }
                else
                {
                    retval = PBV_MESSAGE_TRANSMITTING;
                }
                break;
            
            default:
                retval = PBV_MESSAGE_TRANSMITTING;
                break;
        }
    }
    return (retval);
}
 
 
void PBV_UART_Reinit(PBV_Datatype_TX_t * ptr)
{
    if (ptr->PBV_Signal_Ascii == PBV_SIGNAL_MODE)
        pbvUartObjectTx.Protocol_ID = ptr->PBV_Protcol_ID;
    else
        pbvUartObjectAscii.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)
    {
        pbvUartObjectTx.data             =    ptr->Data_Buffer;
        pbvUartObjectTx.Length_in_Bytes  =    ptr->Length;
    }
    else
    {
        pbvUartObjectAscii.data          =   ptr->Data_Buffer;
        pbvUartObjectTx.Length_in_Bytes  =   ptr->Length;
    }
}
 
 
int PBV_UART_Link_Data_RX(PBV_Datatype_RX_t * ptr)
{
    if (ptr->PBV_Message_State == PBV_MESSAGE_RECEIVED){
        ptr->PBV_Protcol_ID = pbvUartObjectRx.Protocol_ID;
        ptr->Data_Buffer = pbvUartObjectRx.data;
        ptr->Length = pbvUartObjectRx.Length_in_Bytes;
    } 
    return 0;
}
 
 
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;
}