bsp_can.c

IAR 平台ATMEL 的例程, 和说明

            CSP_CAN_SET_CISR(CAN1,(1 << i));

            /* Get packet length */
            can_pkt.length = CSP_CAN_CHANNEL_GET_CR(CAN1, i) & 0x0F ;

            /* Copy Data  */
            memcpy((U8_T*)(&(can_pkt.data[0])), (U8_T *)(&(CSP_CAN_CHANNEL_GET_DRA(CAN1, i))), (8 * sizeof(U8_T)) );
             
            /* Get Idetifier Field */
            can_pkt.identifier = (( CSP_CAN_CHANNEL_GET_IR(CAN1, i) & 0x7FF ) << 18) | ((CSP_CAN_CHANNEL_GET_IR(CAN1, i) & 0x1FFFF800)  >> 11);
         
            /* Set Message Waiting Flag */
            BSP_CanStatus_a_s[CAN1_IO].mailbox_status[i].message_waiting = 1;
            memcpy((U8_T*)(&(BSP_CanStatus_a_s[CAN1_IO].mailbox_status[i].data[0])), (U8_T *)(&(CSP_CAN_CHANNEL_GET_DRA(CAN1, i))), (8 * sizeof(U8_T)));
            
            /* Call BIOS CAN Mailbox Callback */
            (BSP_CanStatus_a_s[CAN1_IO].mailbox_status[i].mailbox_function)(&can_pkt);

            /* Restart Reception */
            CSP_CAN_CHANNEL_SET_CR(CAN1, i, 0x98);
         }
      }
   }
}

/****************************************************************************
Function    : BSP_CAN2InterruptHandler
Description : 
Inputs      : 
Returns     : None
****************************************************************************/
void BSP_CAN2InterruptHandler(void)
{
   /* Local Variables */
   BSP_CAN_PKT_T   can_pkt;
   U8_T            i;

  /* Check Bus Off Interrupt */
  if( (CSP_CAN_GET_SR(CAN2) & BUSOFF & CSP_CAN_GET_IMR(CAN2)) != 0 )
  {
    CSP_CAN_SET_CSR(CAN2, BUSOFF);
//    BIOS_CanStatus_a_s[J1939].bus_off = 1;
  }
  else
  {
     /* Check General Receive Interrupt */
     if( (CSP_CAN_GET_ISSR(CAN2) & (0x80000000) & CSP_CAN_GET_SIMR(CAN2)) != 0 )
     {
        CSP_CAN_SET_CISR(CAN2,(0x80000000));
        BSP_CAN2MBX31InterruptHandler();
     }
   
     /* Check General Transmit Interrupt */
     if( (CSP_CAN_GET_ISSR(CAN2) & (1 << 0) & CSP_CAN_GET_SIMR(CAN2)) != 0 )
     {
        CSP_CAN_SET_CISR(CAN2,(1 << 0));
        BSP_CAN2MBX0InterruptHandler();
     }

     /* Check Which Channel Produce an Interrupt */
     for(i=1; i<31; i++)
     {
        if( (CSP_CAN_GET_ISSR(CAN2) & (1 << i) & CSP_CAN_GET_SIMR(CAN2)) != 0 )
        {
           /* Clear Interrupt Flag */
           CSP_CAN_SET_CISR(CAN2,(1 << i));

           /* Get packet length */
           can_pkt.length = CSP_CAN_CHANNEL_GET_CR(CAN2, i) & 0x0F ;

           /* Copy Data  */
           memcpy((U8_T*)(&(can_pkt.data[0])), (U8_T*)(&(CSP_CAN_CHANNEL_GET_DRA(CAN2, i))), (8 * sizeof(U8_T)) );
             
           /* Get Idetifier Field */
           can_pkt.identifier = (( CSP_CAN_CHANNEL_GET_IR(CAN2, i) & 0x7FF ) << 18) | ((CSP_CAN_CHANNEL_GET_IR(CAN2, i) & 0x1FFFF800)  >> 11);
         
           /* Set Message Waiting Flag */
           BSP_CanStatus_a_s[CAN2_IO].mailbox_status[i].message_waiting = 1;
           memcpy((U8_T*)(&(BSP_CanStatus_a_s[CAN2_IO].mailbox_status[i].data[0])), (U8_T*)(&(CSP_CAN_CHANNEL_GET_DRA(CAN2, i))), (8 * sizeof(U8_T)));

           /* Call BIOS CAN Mailbox Callback */
           (BSP_CanStatus_a_s[CAN2_IO].mailbox_status[i].mailbox_function)(&can_pkt);

           /* Restart Reception */
           CSP_CAN_CHANNEL_SET_CR(CAN2, i, 0x98);
        }                 
     }
   }
}

/****************************************************************************
Function    : BSP_CAN0MBX0InterruptHandler
Description : CAN0 General Transmit Interrupt
            : 
Inputs      : None
Returns     : None
****************************************************************************/
void BSP_CAN0MBX0InterruptHandler(void)
{
   /* Local Variables */
   BSP_CAN_PKT_T   *can_pkt;
   U8_T            *tx_tailptr;
   U8_T            *tx_headptr;
   
   /* Get Current head & tail pointers in Tx Queue */
   tx_tailptr = &(BSP_CanStatus_a_s[0].queue.tx_tailptr);
   tx_headptr = &(BSP_CanStatus_a_s[0].queue.tx_headptr);
   
   /* Get Current Tx Packet in Tx Queue */
   can_pkt  = &(BSP_CanStatus_a_s[0].queue.tx_queue[*tx_tailptr]);
   
   /* Check if ACK is an Interrupt Source */
   if( (CSP_CAN_CHANNEL_GET_SR(CAN0, GENERAL_TRANSMIT) & ACK & CSP_CAN_CHANNEL_GET_IMR(CAN0, GENERAL_TRANSMIT) ) != 0 )
   {
      while(CSP_CAN_CHANNEL_GET_SR(CAN0, GENERAL_TRANSMIT) & ACK)
             CSP_CAN_CHANNEL_SET_CSR(CAN0, GENERAL_TRANSMIT, ACK);

      /* Increment Ack Counter */
      BSP_CanStatus_a_s[0].ack_counter_u8++;
      
      /* If Ack Limit */
      if( BSP_CanStatus_a_s[0].ack_counter_u8 == BSP_CanStatus_a_s[0].ack_limit_u8 )     
      {
         /* Disable Transission */
         CSP_CAN_CHANNEL_SET_CR(CAN0, GENERAL_TRANSMIT, 0);
         
         /* Clear Ack Counter */
         BSP_CanStatus_a_s[0].ack_counter_u8 = 0;
         
         /* Check if the Trasmit Queue is Empty (no more frame to send) */
         if( *tx_headptr != *tx_tailptr )
         {
            /* Copy Data to Send In CAN Mailbox*/
            CSP_CAN_CHANNEL_SET_DRA(CAN0, GENERAL_TRANSMIT, *(U32_T *)(&(can_pkt->data[0])));
            CSP_CAN_CHANNEL_SET_DRB(CAN0, GENERAL_TRANSMIT, *(U32_T *)(&(can_pkt->data[4])));

            /* Set Idetifier Field */
            CSP_CAN_CHANNEL_SET_IR(CAN0, GENERAL_TRANSMIT, (( can_pkt->identifier & 0x1FFC0000 ) >> 18) | ((can_pkt->identifier & 0x3FFFF) << 11));        
         
            /* Send Data (Extended Format) */
            CSP_CAN_CHANNEL_SET_CR(CAN0, GENERAL_TRANSMIT, ( CHANEN | IDE | PCB | ( can_pkt->length & DLC_MASK)));

            /* Increment Tail Pointer to the next packet to send*/
            (*tx_tailptr)++;
            (*tx_tailptr) %= BSP_CAN_TX_QUEUE_SIZE;
         }
         /* Tx Queue is Empty */     
         else
         {
            BSP_CanStatus_a_s[0].transmit_u8  = 0;
         }
      }   
   }
   /* Check if TXOK is an Interrupt Source */
   else if( (CSP_CAN_CHANNEL_GET_SR(CAN0, GENERAL_TRANSMIT) & TXOK & CSP_CAN_CHANNEL_GET_IMR(CAN0, GENERAL_TRANSMIT)) != 0 )
   {
      /* Clear TXOK Error Interrupt Flag*/
      while(CSP_CAN_CHANNEL_GET_SR(CAN0, GENERAL_TRANSMIT) & TXOK )
             CSP_CAN_CHANNEL_SET_CSR(CAN0, GENERAL_TRANSMIT, TXOK);
      
      /* Check if the Trasmit Queue is Empty (no more frame to send) */
      if( *tx_headptr != *tx_tailptr )
      {
         /* Copy Data to Send In CAN Mailbox*/
            CSP_CAN_CHANNEL_SET_DRA(CAN0, GENERAL_TRANSMIT, *(U32_T *)(&(can_pkt->data[0])));
            CSP_CAN_CHANNEL_SET_DRB(CAN0, GENERAL_TRANSMIT, *(U32_T *)(&(can_pkt->data[4])));                
         
         /* Set Idetifier Field */
          CSP_CAN_CHANNEL_SET_IR(CAN0, GENERAL_TRANSMIT, (( can_pkt->identifier & 0x1FFC0000 ) >> 18) | ((can_pkt->identifier & 0x3FFFF) << 11));
         
         /* Send Data (Extended Format) */
         CSP_CAN_CHANNEL_SET_CR(CAN0, GENERAL_TRANSMIT, ( CHANEN | IDE | PCB | ( can_pkt->length & DLC_MASK))); 

         /* Increment Tail Pointer to the next packet to send*/
         (*tx_tailptr)++;
         (*tx_tailptr) %= BSP_CAN_TX_QUEUE_SIZE;
      }
      /* Tx Queue is Empty */     
      else
      {
         BSP_CanStatus_a_s[0].transmit_u8  = 0;
      }
   }
}

/****************************************************************************
Function    : BSP_CAN0MBX15InterruptHandler
Description : CAN0 General Receive Interrupt Handler
Inputs      : None
Returns     : None
****************************************************************************/
void BSP_CAN0MBX15InterruptHandler(void)
{
   /* Local Variables */
   BSP_CAN_PKT_T  *can_pkt;
   U8_T           *rx_headptr;
   
   /* Get Current head pointers in Rx Queue */
   rx_headptr = &(BSP_CanStatus_a_s[0].queue.rx_headptr);
   
   /* Get Current CAN Packet in Rx Queue */
   can_pkt = &(BSP_CanStatus_a_s[0].queue.rx_queue[*rx_headptr]);
   
   /* Check if RXOK is an Interrupt Source */
   if( (CSP_CAN_CHANNEL_GET_SR(CAN0, MBX15) & RXOK & CSP_CAN_CHANNEL_GET_IMR(CAN0, MBX15)) != 0 )
   {
      /* Clear ACK Error Interrupt Flag*/
      CSP_CAN_CHANNEL_SET_CSR(CAN0, MBX15, RXOK);

      /* Get packet length */
      can_pkt->length = CSP_CAN_CHANNEL_GET_CR(CAN0, MBX15) & 0x0F ;

      /* Copy Data In Rx Queue */
      memcpy((U8_T*)(&(can_pkt->data[0])), (U8_T*)(&(CSP_CAN_CHANNEL_GET_DRA(CAN0, MBX15))), (8 * sizeof(U8_T)) );
             
      /* Get Idetifier Field */
      can_pkt->identifier = (( CSP_CAN_CHANNEL_GET_IR(CAN0, MBX15) & 0x7FF ) << 18) | ((CSP_CAN_CHANNEL_GET_IR(CAN0, MBX15) & 0x1FFFF800)  >> 11);
      can_pkt->msecs      = CSP_CAN_CHANNEL_GET_STP(CAN0, MBX15);
         
      /* Increment head Pointer to the next packet to receive */
      (*rx_headptr)++;
      (*rx_headptr) %= BSP_CAN_RX_QUEUE_SIZE;
   }
}

/****************************************************************************
Function    : BSP_CAN1MBX0InterruptHandler
Description : CAN1 General Transmit Interrupt
            : 
Inputs      : None
Returns     : None
****************************************************************************/
void BSP_CAN1MBX0InterruptHandler(void)
{
   /* Local Variables */
   BSP_CAN_PKT_T   *can_pkt;
   U8_T            *tx_tailptr;
   U8_T            *tx_headptr;
   
   /* Get Current head & tail pointers in Tx Queue */
   tx_tailptr = &(BSP_CanStatus_a_s[1].queue.tx_tailptr);
   tx_headptr = &(BSP_CanStatus_a_s[1].queue.tx_headptr);
   
   /* Get Current Tx Packet in Tx Queue */
   can_pkt  = &(BSP_CanStatus_a_s[1].queue.tx_queue[*tx_tailptr]);
   
   /* Check if ACK is an Interrupt Source */
   if(CSP_CAN_CHANNEL_GET_SR(CAN1, GENERAL_TRANSMIT) & ACK & CSP_CAN_CHANNEL_GET_IMR(CAN1, GENERAL_TRANSMIT) != 0 )
   {
      while( CSP_CAN_CHANNEL_GET_SR(CAN1, GENERAL_TRANSMIT) & ACK )
         CSP_CAN_CHANNEL_SET_CSR(CAN1, GENERAL_TRANSMIT, ACK);

      /* Increment Ack Counter */
      BSP_CanStatus_a_s[1].ack_counter_u8++;
      
      /* If Ack Limit */
      if( BSP_CanStatus_a_s[1].ack_counter_u8 == BSP_CanStatus_a_s[1].ack_limit_u8 )     
      {
         /* Disable Transission */
         CSP_CAN_CHANNEL_SET_CR(CAN1, GENERAL_TRANSMIT, 0);
         
         /* Clear Ack Counter */
         BSP_CanStatus_a_s[1].ack_counter_u8 = 0;
         
         /* Check if the Trasmit Queue is Empty (no more frame to send) */
         if( *tx_headptr != *tx_tailptr )
         {
            /* Copy Data to Send In CAN Mailbox*/
            CSP_CAN_CHANNEL_SET_DRA(CAN1, GENERAL_TRANSMIT, *(U32_T *)(&(can_pkt->data[0])));
            CSP_CAN_CHANNEL_SET_DRB(CAN1, GENERAL_TRANSMIT, *(U32_T *)(&(can_pkt->data[4])));             

            /* Set Idetifier Field */
            CSP_CAN_CHANNEL_SET_IR(CAN1, GENERAL_TRANSMIT,(( can_pkt->identifier & 0x1FFC0000 ) >> 18) | ((can_pkt->identifier & 0x3FFFF) << 11));