mscandrvlite.c

freescale最新的16位单片机

                        MB_MSCAN[2] = buffer;                           /* write buffer # */
                        MSCAN_L_Load_Buff(TX_BUFF2, buffer, MB_ID_Ref);
                        CANTFLG = 0x04;                                 /* write 1 to TXE to schedule buffer */
                        CANTIER |= 0x04;                                /* enable interrupt for this buffer */
                  }
#if (NO_OF_MSCAN_TXBUFFER != 3)
#error msCAN buffer not checked
#endif
            }
      }     /* end: If all msCAN transmit buffers are already scheduled */
}


/******************************************************************************
Function Name     :     MSCAN_L_Load_Buff
Engineer          :     Stuart Robb
Date              :     1/7/98

Arguments         : msCAN buffer number
                          driver buffer number
                          address of message Identifier

Return            : none
Notes             : All interrupts must be disabled when this function is called
******************************************************************************/
void
MSCAN_L_Load_Buff (UINT8 TX_Buff, UINT8 buffer, UINT8 MO_ID_Ref)
{
      UINT8 *bufferData;                        
      UINT8 dataLength, 
              i;
      
      CANTBSEL = TX_Buff;                                    /* select TX buffer into register space */
      
      *TX_BUFF_IDR_Ptr = M_Identifier_CAN0[MO_ID_Ref];       /* copy 32-bit ID to msCAN buffer */
            
      if (BufferMode_CAN0[buffer] == TXRF)                   /* remote frame to be transmitted */
      {
            if (M_IdentifierType_CAN0[MO_ID_Ref] == STANDARD)
            {
                  TX_BUFF_IDR1 |= 0x10;                      /* set RTR in Standard Identifier */
            }
            else  /* extended ID */
            {
                  TX_BUFF_IDR3 |= 0x01;                      /* set RTR in Extended Identifier */
            }
      }  /* end: if remote frame */

      else            /* data frame to be transmitted */
      {
            dataLength = BufferDLC_CAN0[buffer];
            TX_BUFF_DLR = dataLength;                        /* copy DLC to msCAN buffer */

            bufferData = BufferData_CAN0[buffer];                 

            for (i = 0; i < dataLength; i++)
            {
                  TX_BUFF_DSR_Ptr[i] = bufferData[i];        /* copy data to msCAN buffer */
            }
      }               /* end: else data frame */


      TX_BUFF_TBPR = BufferID_Ref_CAN0[buffer];          /* set priority = ID_Ref */

      BufferStatus_CAN0[buffer] = QUEUED2;            
}

/******************************************************************************
Function Name     :     CAN_L_AbortMB
Engineer          :     Stuart Robb
Date              :     10/8/98

Arguments         :     buffer number 

Return            :     ERR_OK if no error, otherwise error code
******************************************************************************/
UINT8
CAN_L_AbortMB (UINT8 buffer)
{
      UINT8 currentCANTIER;

      if (CANCTL1 & INITAK)
      {
            return (ERR_INIT);
      }

      if (buffer >= NoOfMB)
      {
            return (ERR_MB);
      }

      if (BufferMode_CAN0[buffer] == RXDF)
      {
            return (ERR_CONFIG);
      }

      SEI;
      currentCANTIER = CANTIER;
      CANRIER &= ~RXFIE;                                     /* disable receive interrupt */
      CANTIER = 0;                                           /* disable transmit interrupts */
      if (!(CCRcopy & IMASK))
      {
            CLI;                                             /* restore interrupt mask */
      }

      switch (BufferStatus_CAN0[buffer])
      {
            case QUEUED:
                  BufferStatus_CAN0[buffer] = ABORTED;
                  break;

            case QUEUED2:
                  BufferStatus_CAN0[buffer] = ABORTREQ;

                  if (MB_MSCAN[0] == buffer)                 /* Message Buffer in msCAN buffer */
                  {
                        CANTARQ |= 0x01;              /* set ABTRQi for msCAN buffer */
                  }
                  
                  else
                  {
                        if (MB_MSCAN[1] == buffer)           /* Message Buffer in msCAN buffer */
                        {
                              CANTARQ |= 0x02;        /* set ABTRQi for msCAN buffer */
                        }
                        
                        else
                        {
                              CANTARQ |= 0x04;        /* set ABTRQi for msCAN buffer */
                        }

#if (NO_OF_MSCAN_TXBUFFER != 3)
#error msCAN buffer not checked
#endif
                  }
                  break;

            default:                                         /* not queued */
                  CANRIER |= RXFIE;                          /* restore receive interrupt */
                  CANTIER = currentCANTIER;                  /* restore transmit interrupts */
                  return (ERR_NOTQED);
      }

      CANRIER |= RXFIE;                                        /* restore receive interrupt */
      CANTIER = currentCANTIER;                              /* restore transmit interrupts */
      return (ERR_OK);
}

/******************************************************************************
Function Name     :     CAN_L_ReadDataMB
Engineer          :     Stuart Robb
Date              :     10/8/98

Arguments         :     buffer number
                        address for data 

Return            :     ERR_OK if no error, otherwise error code
******************************************************************************/
UINT8
CAN_L_ReadDataMB (UINT8 buffer, UINT8* dataPtr)
{
      UINT8 errorStatus;

      errorStatus = L_ReadDataMB (buffer, dataPtr);

      CANRIER |= RXFIE;                                        /* restore receive interrupt */
      return (errorStatus);   
}

/******************************************************************************
Function Name     :     L_ReadDataMB
Engineer          :     Stuart Robb
Date              :     10/8/98

Arguments         :     buffer number
                        address for data 

Return            :     ERR_OK if no error, otherwise error code
******************************************************************************/
UINT8
L_ReadDataMB (UINT8 buffer, UINT8* dataPtr)
{
      UINT8 *bufferPtr;       
      UINT8 dataLength, 
              i;

      if (buffer >= NoOfMB)
      {
            return (ERR_MB);
      }

      if (BufferMode_CAN0[buffer] != RXDF)
      {
            return (ERR_CONFIG);
      }

      if (BufferStatus_CAN0[buffer] == NODATA)
      {
            return (ERR_NODATA);
      }

      SEI;                                                   /* disable all interrupts */
      CANRIER &= ~RXFIE;                                       /* disable receive interrupt */
      if (!(CCRcopy & IMASK))
      {
            CLI;                                             /* restore interrupt mask */
      }

      dataLength = BufferDLC_CAN0[buffer];
      *dataPtr = dataLength;                                 /* copy DLC */
      dataPtr++;

      bufferPtr = BufferData_CAN0[buffer];                   /* BufferData_CAN0[buffer] is first dimension */

      for (i = 0; i < dataLength; i++)                       /* copy data */
      {
            dataPtr[i] = bufferPtr[i];
      }

      BufferStatus_CAN0[buffer] = READDATA;

      return (ERR_OK);
}

/******************************************************************************
Function Name     :     CAN_L_ReadMB
Engineer          :     Stuart Robb
Date              :     10/8/98

Arguments         :     buffer number
                        address for data 

Return            :     ERR_OK if no error, otherwise error code
******************************************************************************/
UINT8
CAN_L_ReadMB (UINT8 buffer, UINT8* dataPtr)
{
      UINT8 errorStatus;

      errorStatus = L_ReadDataMB (buffer, dataPtr);
      
      if (errorStatus == ERR_OK)
      {
            if (TimeStampOption)
            {
                  *(UINT16 *)(dataPtr + 9) = BufferTimeStamp_CAN0[buffer];     /* copy time stamp */
            }

            else
            {
                  errorStatus = ERR_TS;
            }
      }

      CANRIER |= RXFIE;                                        /* restore receive interrupt */
      return (errorStatus);
}

/******************************************************************************
Function Name     :     CAN_ReadTimeMB
Engineer          :     Stuart Robb
Date              :     10/8/98

Arguments         :     buffer number
                        address for data 

Return            :     ERR_OK if no error, otherwise error code
******************************************************************************/
UINT8
CAN_L_ReadTimeMB (UINT8 buffer, UINT16* dataPtr)
{
      if (!TimeStampOption)
      {
            return (ERR_TS);
      }

      if (buffer >= NoOfMB)
      {
            return (ERR_MB);
      }

      if (BufferMode_CAN0[buffer] == CLOSED)
      {
            return (ERR_CONFIG);
      }

      if (BufferStatus_CAN0[buffer] < TRANSMITTED)           /* NODATA, VALIDDATA, QUEUED, QUEUED2, ABORTREQ, ABORTED */
      {
            return (ERR_NODATA);
      }

      SEI;

      *dataPtr = BufferTimeStamp_CAN0[buffer];          /* copy time stamp */

      if (!(CCRcopy & IMASK))
      {
            CLI;                                             /* restore interrupt mask */
      }

      return (ERR_OK);

}

/******************************************************************************
Function Name     :     CAN0_TransmitISR
Engineer          :     Stuart Robb
Date              :     10/8/98

Arguments         :     none
Return            :     none
Notes             :     Hiware compiler version 5.0.7 fixes bug.
******************************************************************************/
#ifdef HICROSS
#pragma TRAP_PROC
#endif

#ifdef COSMIC
@interrupt
#endif

void
CAN0_TransmitISR (void)
{
      UINT8  TX_Buff;
      UINT8  interruptBufferBit,
             interruptBufferNo, 
             buffer, 
             highestPriority = 0xff, 
             highestPriorityBuffer,
             nextBuffer = LowestQueuedBuffer;

#ifdef BENCHMARK
      PORTB |= 0x02;                                          /* set bit 1 */
#endif

      /* Find buffer that caused interrupt, and write new status */

      interruptBufferBit = (CANTFLG & CANTIER);                       /* position of set bit indicates buffer */

      if (interruptBufferBit & 0x01)
      {
            interruptBufferNo = 0;
            TX_Buff = TX_BUFF0;
            CANTIER &= ~0x01;                                    /* disable interrupt */