fesc_5554_spicomm.c

MPC5554处理器的初始化例程

   SBPbufPt->SBP_RTSTUS_OverTimeCnt--;
   if(SBPbufPt->SBP_RTSTUS_OverTimeCnt<4)
   { if(SBPbufPt->SBP_RTSTUS_OverTimeCnt==0)
    {  
      SBPbufPt->returnStat = SBP_RTSTUS_OverTime;
      SBPbufPt->isFinished = 1;
     }
     return(ESC);
   }
  
  //feedback verification
  if( (SBPbufPt->feedback_verify == 1)
    &&(cRx != SBPbufPt->cTxLast))
  {  SBPbufPt->cTx = ESC;
     SBPbufPt->returnStat = SBP_RTSTUS_FEEDBACK_ERROR;
     SBPbufPt->isFinished = 1; 
   }
  
  SBPbufPt->cTxLast   = SBPbufPt->cTx;
  
  SBPbufPt->isLastESC = SBPbufPt->isCurrentESC;   
  if(cRx == ESC)  SBPbufPt->isCurrentESC = 1;
  else            SBPbufPt->isCurrentESC = 0;


  /////continueus ECS 
  if(    (SBPbufPt->ssSPIStat != spistIdle)  //在空闲状态下忽略连续ESC
      && (SBPbufPt->isCurrentESC == 1) 
      && (SBPbufPt->isLastESC == 1)      )
  {  SBPbufPt->returnStat = SBP_RTSTUS_DUAL_ESC;
     SBPbufPt->isFinished = 1;
     return(ESC);
  }

    switch (SBPbufPt->ssSPIStat)
    {
      case spistIdle: //the first input byte is ignored
                      if (SBPbufPt->isLastESC && (cRx == ESC_FLUSH))
                      {   SBPbufPt->cTx  =  cRx;
                          SBPbufPt->ssSPIStat = spistInsTx;
                          SBPbufPt->InstrBuffer[0] = cRx;
                          SBPbufPt->iInstrBufPos = 1;
                      }
                      else SBPbufPt->cTx  =  ESC;
                      SBPbufPt->feedback_verify = 0;
                      break;
      case spistInsTx:
                      if (cRx & 0x80)
                      {
                        SBPbufPt->cTx = ESC;   
                        SBPbufPt->returnStat = SBP_RTSTUS_ILLEGAL_INSTRC_CHAR;
                        SBPbufPt->isFinished = 1;
                      }
                      else
                      {  SBPbufPt->cTx  =  cRx;
                         SBPbufPt->InstrBuffer[SBPbufPt->iInstrBufPos] = cRx;
                         SBPbufPt->iInstrBufPos++;
                         if( SBPbufPt->iInstrBufPos == 5)
                         {   if(cRx == CHAR_BUSY)
                             {
                                SBPbufPt->ssSPIStat = spistBusy;
                                SBPbufPt->cTx = CHAR_BUSY; 
                                SBPbufPt->returnStat = SBP_RTSTUS_INSTRC_RX_OK;
                              }
                              else
                              {
                                SBPbufPt->cTx = ESC; 
                                SBPbufPt->returnStat = SBP_RTSTUS_INSTRC_WRONG;
                                SBPbufPt->isFinished = 1;
                              }
                         }
                      }
                     SBPbufPt->feedback_verify = 0;
                     break;
      case spistBusy  :
                     if(cRx  ==  CHAR_NULL)
                        SBPbufPt->cTx = CHAR_BUSY;   
                     else
                     {
                        SBPbufPt->cTx = ESC; 
                        SBPbufPt->returnStat = SBP_RTSTUS_ILLEGAL_NULL_CHAR;
                        SBPbufPt->isFinished = 1;
                     }
                     SBPbufPt->feedback_verify = 0;
                     break;   
      case spistRxReady:
                    if (cRx == END)
                    {
                      SBPbufPt->cTx = cRx;
                      SBPbufPt->iRxBufferLen = 0; 
                      SBPbufPt->ssSPIStat = spistDataRX;
                    }
                    else if(cRx  ==  CHAR_NULL)
                      SBPbufPt->cTx = CHAR_READY; 
                    else
                    {
                      SBPbufPt->cTx        = ESC; 
                      SBPbufPt->returnStat = SBP_RTSTUS_ILLEGAL_NULL_CHAR;
                      SBPbufPt->isFinished = 1;
                    }
                    SBPbufPt->feedback_verify = 0;
                    break;
      case spistDataRX:
                    SBPbufPt->cTx = cRx;
                    if(SBPbufPt->isCurrentESC)
                    {
                      //do nothing
                    }
                    else if (SBPbufPt->isLastESC)
                    {
                        switch(cRx)
                        { case ESC_IDLE: SBPbufPt->ssSPIStat = spistDone;
                                         break;
                          case ESC_ESC:  SBPbufPt->RxBuffer[SBPbufPt->iRxBufferLen] = ESC;
                                         SBPbufPt->iRxBufferLen++;
                                         break;
                          case ESC_END:  SBPbufPt->RxBuffer[SBPbufPt->iRxBufferLen] = END;
                                         SBPbufPt->iRxBufferLen++;
                                         break;
                          default:       SBPbufPt->returnStat = SBP_RTSTUS_ESC_ILLEGAL_BYTE;
                                         SBPbufPt->isFinished = 1;
                                         break;
                        }
                    }
                    else
                    { 
                      SBPbufPt->RxBuffer[SBPbufPt->iRxBufferLen] = cRx;
                      SBPbufPt->iRxBufferLen++;
                    }  
                    SBPbufPt->feedback_verify = 0;
                    break;      
      case spistTxReady:
                    // transmitt first byte
                    SBPbufPt->cTx = END;
                    SBPbufPt->ssSPIStat = spistDataTX;
                    SBPbufPt->iTxBufPos = 0;
                    SBPbufPt->feedback_verify = 0;
                  break;
      case spistDataTX:
                     if(SBPbufPt->iTxBufPos < SBPbufPt->iTxBufferLen)
                     {
                        SBPbufPt->cTx = SBPbufPt->TxBuffer[SBPbufPt->iTxBufPos];
                        switch (SBPbufPt->cTx)
                        {
                          case ESC:
                            if (SBPbufPt->cTxLast == ESC)
                            { SBPbufPt->cTx = ESC_ESC;
                              SBPbufPt->iTxBufPos++;
                            }
                            else
                            { SBPbufPt->cTx = ESC;
                            }
                            break;
                          case END:
                            if (SBPbufPt->cTxLast == ESC)
                            { SBPbufPt->cTx = ESC_END;
                              SBPbufPt->iTxBufPos++;
                            }
                            else
                            { SBPbufPt->cTx = ESC;
                            }
                            break;
                        default:
                          SBPbufPt->iTxBufPos++;
                        break;
                      }
                     } // payload
                     if(SBPbufPt->iTxBufPos == SBPbufPt->iTxBufferLen)
                      SBPbufPt->ssSPIStat = spistDataTXTailESC;
                     
                     SBPbufPt->feedback_verify = 1; 
                    break;
      case spistDataTXTailESC:
                    SBPbufPt->cTx = ESC;
                    SBPbufPt->ssSPIStat = spistDataTXTailIDLE;
                    SBPbufPt->feedback_verify = 1;
                    break;
      case spistDataTXTailIDLE:
                    SBPbufPt->cTx = ESC_IDLE; 
                    SBPbufPt->ssSPIStat = spistDataTXTailESC2;
                    SBPbufPt->feedback_verify = 1;
                    break;
      case spistDataTXTailESC2:
                    SBPbufPt->cTx = ESC;
                    SBPbufPt->ssSPIStat = spistDone;
                    SBPbufPt->feedback_verify = 1;
                    break;
      case spistDone:
                    SBPbufPt->cTx = ESC;   //the last byte
                    SBPbufPt->returnStat = SBP_RTSTUS_OK;
                    SBPbufPt->isFinished = 1;
                    SBPbufPt->ssSPIStat  = spistIdle;
                    break;
      default:
                   //reset to default status
                   SBPbufPt->ssSPIStat = spistIdle;
                   break;                                       
    }
  return(SBPbufPt->cTx);
}