serial_line_probe.c

STM3240G-Eval_uCOS-III

/*
*********************************************************************************************************
*                                        SerialLine_RdOctet()
*
* Description : Get next octet to transmit.
*
* Argument(s) : pdev        Pointer to device .
*
*               pbuf        Pointer to buffer.
*
*               pdatum      Pointer to variable that will receive data octet.
*
*               perr        Pointer to variable that will receive the return error code from this function :
*
*                               SERIAL_ERR_NONE                 Octet supplied.
*                               SERIAL_ERR_UNDERFLOW            Buffer underflow.
*
* Return(s)   : None.
*
* Caller(s)   : Serial_IF_Tx().
*
* Note(s)     : (1) Interrupts are assumed to be disabled when this function is called.
*********************************************************************************************************
*/

static  void  SerialLine_RdOctet (SERIAL_DEV  *pdev,
                                  SERIAL_BUF  *pbuf,
                                  CPU_INT08U  *pdatum,
                                  SERIAL_ERR  *perr)
{
    CPU_BOOLEAN        empty;
    CPU_INT08U         datum;
    CPU_BOOLEAN        rd;
    CPU_INT08U         state;
    CPU_INT08U         state_next;
    SERIAL_LINE_INFO  *pinfo;


    pinfo = (SERIAL_LINE_INFO *)pdev->LineDrv_Data;

    state      = pinfo->TxState;
    state_next = state;

    switch (state) {
        case SERIAL_LINE_PROBE_TX_STATE_SD0:                    /* Tx start 1st start delimiter (SD0).                  */
             empty = SerialBuf_IsEmpty(pbuf);
             if (empty == DEF_YES) {
                *perr = SERIAL_ERR_UNDERFLOW;
                 return;
             }

             datum      = SERIAL_LINE_PROBE_PROTOCOL_TX_SD0;
             state_next = SERIAL_LINE_PROBE_TX_STATE_SD1;
             break;


        case SERIAL_LINE_PROBE_TX_STATE_SD1:                    /* Tx start 2nd start delimiter (SD1).                  */
             datum      = SERIAL_LINE_PROBE_PROTOCOL_TX_SD1;
             state_next = SERIAL_LINE_PROBE_TX_STATE_SD2;
             break;


        case SERIAL_LINE_PROBE_TX_STATE_SD2:                    /* Tx start 3rd start delimiter (SD2).                  */
             datum      = SERIAL_LINE_PROBE_PROTOCOL_TX_SD2;
             state_next = SERIAL_LINE_PROBE_TX_STATE_SD3;
             break;


        case SERIAL_LINE_PROBE_TX_STATE_SD3:                    /* Tx start 4th start delimiter (SD3).                  */
             datum      = SERIAL_LINE_PROBE_PROTOCOL_TX_SD3;
             state_next = SERIAL_LINE_PROBE_TX_STATE_LEN1;
             break;


        case SERIAL_LINE_PROBE_TX_STATE_LEN1:                   /* Tx 1st len byte.                                     */
             datum      = SerialBuf_Size(pbuf) & 0xFF;
             state_next = SERIAL_LINE_PROBE_TX_STATE_LEN2;
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->TxChkSum = datum;
#endif
             break;


        case SERIAL_LINE_PROBE_TX_STATE_LEN2:                   /* Tx 2nd len byte.                                     */
             datum      = (CPU_INT08U)(SerialBuf_Size(pbuf) >> 8);
             state_next =  SERIAL_LINE_PROBE_TX_STATE_CTR;
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->TxChkSum += datum;
#endif
             break;


        case SERIAL_LINE_PROBE_TX_STATE_CTR:                   /* Tx packet counter.                                    */                          
             datum      = pinfo->RxPktCtr;
             state_next = SERIAL_LINE_PROBE_TX_STATE_PAD;
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->TxChkSum += datum;
#endif
             break;


        case SERIAL_LINE_PROBE_TX_STATE_PAD:                    /* Tx padding byte.                                     */
             datum      = 0;
             state_next = SERIAL_LINE_PROBE_TX_STATE_DATA;
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->TxChkSum += datum;
#endif
             break;


        case SERIAL_LINE_PROBE_TX_STATE_DATA:                   /* Tx data.                                             */
             rd = SerialBuf_RdOctet(pbuf, &datum);
             if (rd == DEF_NO) {
                 datum      = 0;
                 state_next = SERIAL_LINE_PROBE_TX_STATE_ED;
             } else {
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
                 pinfo->TxChkSum += datum;
#endif
                 state_next = SERIAL_LINE_PROBE_TX_STATE_DATA;
             }
             break;


        case SERIAL_LINE_PROBE_TX_STATE_CHKSUM:                 /* Tx checksum.                                         */
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             datum      = pinfo->TxChkSum;
#else
             datum      = 0;
#endif
             state_next = SERIAL_LINE_PROBE_TX_STATE_ED;
             break;


        case SERIAL_LINE_PROBE_TX_STATE_ED:                     /* Tx end delimiter.                                    */
             datum      = SERIAL_LINE_PROBE_PROTOCOL_TX_ED;
             state_next = SERIAL_LINE_PROBE_TX_STATE_LAST;
             break;


        default:
        case SERIAL_LINE_PROBE_TX_STATE_LAST:
             pinfo->TxState = SERIAL_LINE_PROBE_TX_STATE_SD0;
            *pdatum         = 0;
            *perr = SERIAL_ERR_UNDERFLOW;
             return;
    }

    pinfo->TxState = state_next;
   *pdatum         = datum;
   *perr = SERIAL_ERR_NONE;
}


/*$PAGE*/
/*
*********************************************************************************************************
*                                        SerialLine_WrOctet()
*
* Description : Handle octet received from serial port.
*
* Argument(s) : pdev        Pointer to device.
*
*               pbuf        Pointer to buffer.
*
*               datum       Data octet to write.
*
*               perr        Pointer to variable that will receive the return error code from this function :
*
*                               SERIAL_ERR_NONE                 Octet handled.
*                               SERIAL_ERR_OVERFLOW             Buffer overflow.
*                               SERIAL_ERR_LINE_END             End of line detected.
*
* Return(s)   : None.
*
* Caller(s)   : Serial_IF_Rx().
*
* Note(s)     : (1) Interrupts are assumed to be disabled when this function is called.
*********************************************************************************************************
*/

static  void  SerialLine_WrOctet (SERIAL_DEV  *pdev,
                                  SERIAL_BUF  *pbuf,
                                  CPU_INT08U   datum,
                                  SERIAL_ERR  *perr)
{
    CPU_SIZE_T         len_rem;
    CPU_INT08U         state_next;
    CPU_BOOLEAN        wr;
    CPU_SIZE_T         len;
    SERIAL_LINE_INFO  *pinfo;


    pinfo = (SERIAL_LINE_INFO *)pdev->LineDrv_Data;

    switch (pinfo->RxState) {
        case SERIAL_LINE_PROBE_RX_STATE_SD0:                    /* Receive the start first  start delimiter (SD0).      */
             if (datum == SERIAL_LINE_PROBE_PROTOCOL_RX_SD0) {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD1;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
             }
             break;


        case SERIAL_LINE_PROBE_RX_STATE_SD1:                    /* Receive the start second start delimiter (SD1).      */
             if (datum == SERIAL_LINE_PROBE_PROTOCOL_RX_SD1) {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD2;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
             }
             break;


        case SERIAL_LINE_PROBE_RX_STATE_SD2:                    /* Receive the start third  start delimiter (SD2).      */
             if (datum == SERIAL_LINE_PROBE_PROTOCOL_RX_SD2) {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD3;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
             }
             break;


        case SERIAL_LINE_PROBE_RX_STATE_SD3:                    /* Receive the start fourth start delimiter (SD3).      */
             if (datum == SERIAL_LINE_PROBE_PROTOCOL_RX_SD3) {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_LEN1;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
             }
             break;


        case SERIAL_LINE_PROBE_RX_STATE_LEN1:                   /* Receive the first  length byte.                      */
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->RxChkSum = datum;
#endif
             pinfo->RxLenRem = datum;
             state_next      = SERIAL_LINE_PROBE_RX_STATE_LEN2;
             break;


        case SERIAL_LINE_PROBE_RX_STATE_LEN2:                   /* Receive the second length byte.                      */
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->RxChkSum += datum;
#endif
             pinfo->RxLenRem |= datum << 8;

             len = SerialBuf_Size(pbuf);

             if ((pinfo->RxLenRem == 0) ||
                 (pinfo->RxLenRem > len)) {
                                                                /* ... Cannot handle a packet of this size.             */
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_CTR;
             }
             break;


        case SERIAL_LINE_PROBE_RX_STATE_CTR:                    /* Receive packet counter.                              */
             pinfo->RxPktCtr = datum;             
             state_next      = SERIAL_LINE_PROBE_RX_STATE_PAD;
             break;


        case SERIAL_LINE_PROBE_RX_STATE_PAD:                    /* Receive the padding byte.                            */
             state_next = SERIAL_LINE_PROBE_RX_STATE_DATA;
             break;


        case SERIAL_LINE_PROBE_RX_STATE_DATA:                   /* Receive the data.                                    */
             wr = SerialBuf_WrOctet(pbuf, datum);
             if (wr == DEF_NO) {
                 pinfo->RxState = SERIAL_LINE_PROBE_RX_STATE_SD0;
                *perr = SERIAL_ERR_OVERFLOW;
                 return;
             }

#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->RxChkSum += datum;
#endif
             len_rem = pinfo->RxLenRem - 1;
             if (len_rem == 0) {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_CHKSUM;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_DATA;
             }
             pinfo->RxLenRem = len_rem;
             break;


        case SERIAL_LINE_PROBE_RX_STATE_CHKSUM:             /* Receive the checksum.                                */
#if (SERIAL_LINE_PROBE_USE_CHECKSUM == DEF_TRUE)
             pinfo->RxChkSum += datum;
             if ((pinfo->RxChkSum & 0xFF) == 0x00) {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_ED;
             } else {
                 state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
                *perr = SERIAL_ERR_LINE_INVALID;
                 return;
             }
#else
             state_next = SERIAL_LINE_PROBE_RX_STATE_ED;
#endif
             break;


        case SERIAL_LINE_PROBE_RX_STATE_ED:                     /* Receive the end delimiter.                           */
             if (datum == SERIAL_LINE_PROBE_PROTOCOL_RX_ED) {
                *perr = SERIAL_ERR_LINE_END;
             } else {
                *perr = SERIAL_ERR_LINE_INVALID;
             }
             pinfo->RxState = SERIAL_LINE_PROBE_RX_STATE_SD0;
             return;


        default:
             state_next = SERIAL_LINE_PROBE_RX_STATE_SD0;
             break;
    }

    pinfo->RxState = state_next;
   *perr = SERIAL_ERR_NONE;
}