cpfifo.c

Controller Area Network Programming Interface Environment Ver0.8。 CanPie版本0.8. CAN总线通讯编程接口源代码。

      if(CpVar_FifoStatus[channel] & RCV_FIFO_FULL)
      {
         CpVar_FifoStatus[channel]  &= ~RCV_FIFO_FULL;

         //--- move tail to next free entry ---------------
         uwFifoTailT += 1;
         if(uwFifoTailT == uwFifoSizeT) uwFifoTailT = 0;
         CpVar_FifoRcvTail[channel] = uwFifoTailT;
      }
      
   }
   else
   {
      CpVar_FifoTrmHead[channel] = uwFifoHeadT;

      //---------------------------------------------------
      // if there is a FIFO full condition: clear it
      //
      if(CpVar_FifoStatus[channel] & TRM_FIFO_FULL)
      {
         CpVar_FifoStatus[channel]  &= ~TRM_FIFO_FULL;

         //--- move tail to next free entry ---------------
         uwFifoTailT += 1;
         if(uwFifoTailT == uwFifoSizeT) uwFifoTailT = 0;
         CpVar_FifoTrmTail[channel] = uwFifoTailT;
      }
   }

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
//                                                                            //
// Fixed memory size FIFO implementation                                      //
//                                                                            //
//----------------------------------------------------------------------------//


#elif CP_FIFO_TYPE == 1



/*------------------------------------------------------------------------
** variables used for the FIFO functions
**
*/

CpStruct_CAN   CpVar_FifoRcv[CP_CHANNEL_MAX][CP_FIFO_TRM_SIZE];
_U08           CpVar_FifoRcvHead[CP_CHANNEL_MAX];
_U08           CpVar_FifoRcvTail[CP_CHANNEL_MAX];

CpStruct_CAN   CpVar_FifoTrm[CP_CHANNEL_MAX][CP_FIFO_RCV_SIZE];
_U08           CpVar_FifoTrmHead[CP_CHANNEL_MAX];
_U08           CpVar_FifoTrmTail[CP_CHANNEL_MAX];


//----------------------------------------------------------------------------//
// CpFifoSetup()                                                              //
// Setup FIFO size                                                            //
//----------------------------------------------------------------------------//
_U08 Cp_PREFIX CpFifoSetup(_U08 channel, _U08 buffer, _U16 size)
{
#if   CP_SMALL_CODE == 0
   //--- test the channel number --------------------------
   if( (channel + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);
#endif

   //--- setup Receive FIFO -----------------------------------------
   if(buffer == CP_FIFO_RCV)
   {

      /*----------------------------------
      ** store FIFO size and make it
      ** empty (head = tail = 0)
      */
      CpVar_FifoRcvHead[channel] = 0;
      CpVar_FifoRcvTail[channel] = 0;
   }

   //--- setup Transmit FIFO ----------------------------------------
   if(buffer == CP_FIFO_TRM)
   {

      /*----------------------------------
      ** store FIFO size and make it
      ** empty (head = tail = 0)
      */
      CpVar_FifoTrmHead[channel] = 0;
      CpVar_FifoTrmTail[channel] = 0;
   }

   //--- FIFOs are not full -----------------------------------------
   CpVar_FifoStatus[channel] = 0;

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpFifoRemove()                                                             //
// remove FIFO and free memory                                                //
//----------------------------------------------------------------------------//
_U08 Cp_PREFIX CpFifoRemove(_U08 channel, _U08 buffer)
{
   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpFifoClear()                                                              //
// clear contents of FIFO                                                     //
//----------------------------------------------------------------------------//
_U08 Cp_PREFIX CpFifoClear(_U08 channel, _U08 buffer)
{
#if   CP_SMALL_CODE == 0
   //--- test the channel number ------------------------------------
   if( (channel + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);
#endif

   //--- delete messages from Receive FIFO --------------------------
   if(buffer == CP_FIFO_RCV) 
   {
      CpVar_FifoRcvHead[channel] = 0;
      CpVar_FifoRcvTail[channel] = 0;
   }

   //--- delete messages from Transmit FIFO -------------------------
   if(buffer == CP_FIFO_TRM) 
   {
      CpVar_FifoTrmHead[channel] = 0;
      CpVar_FifoTrmTail[channel] = 0;
   }

   
   //--- FIFOs are not full -----------------------------------------
   CpVar_FifoStatus[channel] = 0;

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpFifoPush()                                                               //
// push message to FIFO                                                       //
//----------------------------------------------------------------------------//
_U08 Cp_PREFIX CpFifoPush(_U08 channel, _U08 buffer, CpStruct_CAN * msg)
{
   CpStruct_CAN * fifoPtr = 0;
   register _U08  cnt;
   register _U08  ubFifoHeadT;   // head position of FIFO
   register _U08  ubFifoTailT;   // tail position of FIFO
   register _U08  ubFifoSizeT;   // max number of entries in FIFO


#if   CP_SMALL_CODE == 0
   //--- test the channel number ------------------------------------
   if( (channel + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);
#endif

   //--- setup variables for Receive/Transmit FIFOs------------------
   if(buffer == CP_FIFO_RCV)
   {
      //--- test if FIFO is full --------------------------
      if(CpVar_FifoStatus[channel] & RCV_FIFO_FULL) return (CpErr_FIFO_FULL);

      ubFifoHeadT = CpVar_FifoRcvHead[channel];
      ubFifoTailT = CpVar_FifoRcvTail[channel];
      ubFifoSizeT = CP_FIFO_RCV_SIZE;

      fifoPtr = CpVar_FifoRcv[channel];
   }
   else
   {
      //--- test if FIFO is full --------------------------
      if(CpVar_FifoStatus[channel] & TRM_FIFO_FULL) return (CpErr_FIFO_FULL);

      ubFifoHeadT = CpVar_FifoTrmHead[channel];
      ubFifoTailT = CpVar_FifoTrmTail[channel];
      ubFifoSizeT = CP_FIFO_TRM_SIZE;

      fifoPtr = CpVar_FifoTrm[channel];
   }


   //----------------------------------------------------------------
   // FIFO is not full, insert the message
   //

   fifoPtr = fifoPtr + ubFifoTailT;

   fifoPtr->v_MsgId     = msg->v_MsgId;
   fifoPtr->v_MsgFlags  = msg->v_MsgFlags;
   for (cnt = 0; cnt < 8; cnt++)
   {
      fifoPtr->v_MsgData[cnt] = msg->v_MsgData[cnt];
   }

#if CP_MSG_TIME == 1
   fifoPtr->v_MsgTime   = msg->v_MsgTime;
#endif

#if CP_USR_DATA == 1
   fifoPtr->v_UsrData   = msg->v_UsrData;
#endif

   //----------------------------------------------------------------
   // test if FIFO is full:
   //
   if(ubFifoHeadT == ubFifoTailT + 1)
   {
      if(buffer == CP_FIFO_RCV) CpVar_FifoStatus[channel] |= RCV_FIFO_FULL;
      else CpVar_FifoStatus[channel] |= TRM_FIFO_FULL; 

      return (CpErr_OK);
   }

   if( (ubFifoHeadT == 0) && (ubFifoTailT == ubFifoSizeT - 1) )
   {
      if(buffer == CP_FIFO_RCV) CpVar_FifoStatus[channel] |= RCV_FIFO_FULL;
      else CpVar_FifoStatus[channel] |= TRM_FIFO_FULL; 

      return (CpErr_OK);
   }

   //----------------------------------------------------------------
   // increment tail position and save it
   // test overflow condition
   ubFifoTailT += 1;
   if(ubFifoTailT == ubFifoSizeT) ubFifoTailT = 0;

   if(buffer == CP_FIFO_RCV)
   {
      CpVar_FifoRcvTail[channel] = ubFifoTailT;
   }
   else
   {
      CpVar_FifoTrmTail[channel] = ubFifoTailT;
   }

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpFifoPop()                                                                //
// pop message from FIFO                                                      //
//----------------------------------------------------------------------------//
_U08 Cp_PREFIX CpFifoPop(_U08 channel, _U08 buffer, CpStruct_CAN * msg)
{
   CpStruct_CAN * fifoPtr = 0;
   register _U08  cnt;
   register _U08  ubFifoHeadT;   // head position of FIFO
   register _U08  ubFifoTailT;   // tail position of FIFO
   register _U08  ubFifoSizeT;   // max number of entries in FIFO


#if   CP_SMALL_CODE == 0
   //--- test the channel number ------------------------------------
   if( (channel + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);
#endif


   //--- setup variables for Receive/Transmit FIFOs------------------
   if(buffer == CP_FIFO_RCV)

   {
      ubFifoHeadT = CpVar_FifoRcvHead[channel];
      ubFifoTailT = CpVar_FifoRcvTail[channel];
      ubFifoSizeT = CP_FIFO_RCV_SIZE;

      fifoPtr = CpVar_FifoRcv[channel];
   }
   else
   {
      ubFifoHeadT = CpVar_FifoTrmHead[channel];
      ubFifoTailT = CpVar_FifoTrmTail[channel];
      ubFifoSizeT = CP_FIFO_TRM_SIZE;

      fifoPtr = CpVar_FifoTrm[channel];
   }


   //----------------------------------------------------------------
   // test if FIFO is empty
   //
   if(ubFifoHeadT == ubFifoTailT)
   {
      return (CpErr_FIFO_EMPTY);
   }


   //--- get message from FIFO --------------------------------------
   fifoPtr = fifoPtr + ubFifoHeadT;


   msg->v_MsgId      = fifoPtr->v_MsgId;
   msg->v_MsgFlags   = fifoPtr->v_MsgFlags;
   for (cnt = 0; cnt < 8; cnt++)
   {
      msg->v_MsgData[cnt] = fifoPtr->v_MsgData[cnt];
   }

#if CP_MSG_TIME == 1
   msg->v_MsgTime = fifoPtr->v_MsgTime;
#endif

#if CP_USR_DATA == 1
   msg->v_UsrData = fifoPtr->v_UsrData;
#endif

   //----------------------------------------------------------------
   // increment head position and save it 
   //

   ubFifoHeadT += 1;
   if(ubFifoHeadT == ubFifoSizeT) ubFifoHeadT = 0;

   if(buffer == CP_FIFO_RCV)
   {
      CpVar_FifoRcvHead[channel] = ubFifoHeadT;

      //---------------------------------------------------
      // if there is a FIFO full condition: clear it
      //
      if(CpVar_FifoStatus[channel] & RCV_FIFO_FULL)
      {
         CpVar_FifoStatus[channel]  &= ~RCV_FIFO_FULL;

         //--- move tail to next free entry ---------------
         ubFifoTailT += 1;
         if(ubFifoTailT == ubFifoSizeT) ubFifoTailT = 0;
         CpVar_FifoRcvTail[channel] = ubFifoTailT;
      }
      
   }
   else
   {
      CpVar_FifoTrmHead[channel] = ubFifoHeadT;

      //---------------------------------------------------
      // if there is a FIFO full condition: clear it
      //
      if(CpVar_FifoStatus[channel] & TRM_FIFO_FULL)
      {
         CpVar_FifoStatus[channel]  &= ~TRM_FIFO_FULL;

         //--- move tail to next free entry ---------------
         ubFifoTailT += 1;
         if(ubFifoTailT == ubFifoSizeT) ubFifoTailT = 0;
         CpVar_FifoTrmTail[channel] = ubFifoTailT;
      }
   }

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// Error for definition CP_FIFO_TYPE                                                                           //
//----------------------------------------------------------------------------//
#else
#error Unsupported definition for CP_FIFO_TYPE. Please check cpconfig.h!
#endif