jcanhcs12.c

在Freescale16位单片机MC9s12dp256上移植了J1939源码和操作系统（ucOSII）。

  } /* else */
}


/*!
  \brief Wake up from sleep mode.

  This call controls the recover from sleep mode.
*/
void gCan_WakeUpOccurred(void)
{
  /* initiate sleeping modus */
  if (gCan_ActivateMode(MODE_NORMAL) == TRUE) {
/* Don't be used in J1939 stack */
#   if 0
    ModuleInfo.bModuleState = STACK_WAKEUP;
#   endif
  } /* if */
}


/*!
  Put a CAN message on the bus.
  \param ptMsg pointer to buffer
  \return NO_ERR transmission in progress,
          WAIT_ERR no transmission cause of inhibit time,
          BUSY_ERR no transmission cause of other transmission in progress
*/
BYTE gCan_SendMsg(CAN_MSG MEM_AREA * ptMsg)
{
  BYTE i;                       /* counter                                  */
  BYTE bId[4];                  /* actually we support std/ext identifier   */

  if (ptMsg == 0) {
    return NO_ERR;
  } /* if */

  /*
   * construct identifier
   * The bytes are placed like the following:
   * bId[0] = CAN_MSG_ID_HIGH_HI
   * bId[1] = CAN_MSG_ID_HIGH_LO
   * bId[2] = CAN_MSG_ID_LOW_HI
   * bId[3] = CAN_MSG_ID_LOW_LO
   */
  if (ptMsg->Ext == 1) {
    bId[0] = (ptMsg->qbId.fb.b3 << 3)           /* ID28-ID24 */
           | (ptMsg->qbId.fb.b2 >> 5);          /* ID23-ID21 */
    bId[1] = (ptMsg->qbId.fb.b2 << 3)           /* ID20-ID18 */
           | 0x18                               /* SRR, IDE */
           | ((ptMsg->qbId.fb.b2 << 1) & 0x06)  /* ID17-ID16 */
           | (ptMsg->qbId.fb.b1 >> 7);          /* ID15 */
    bId[2] = (ptMsg->qbId.fb.b1 << 1)           /* ID14-ID8 */
           | (ptMsg->qbId.fb.b0 >> 7);          /* ID7 */
    bId[3] = (ptMsg->qbId.fb.b0 << 1)           /* ID6-ID0 */
           | ptMsg->Rtr;                        /* remote frame */
  } /* if */
  else {
    bId[0] = (ptMsg->qbId.fb.b1 << 5)           /* ID10-ID8 */
           | (ptMsg->qbId.fb.b0 >> 3);          /* ID7-ID3 */
    bId[1] = (ptMsg->qbId.fb.b0 << 5)           /* ID2-ID0 */
           | (ptMsg->Rtr << 4);                 /* remote frame */
    bId[2] = 0;
    bId[3] = 0;
  } /* else */

  /* controller busy ? */
  if (TestBitValue(CAN_TFLG + CAN_BASIC_ADR, CAN_FLAG_TXE0)) {
    /* set COB ID */
    WriteByte(CAN_IDR0 + CAN_TX_BUF + CAN_BASIC_ADR, bId[0]);
    WriteByte(CAN_IDR1 + CAN_TX_BUF + CAN_BASIC_ADR, bId[1]);
    WriteByte(CAN_IDR2 + CAN_TX_BUF + CAN_BASIC_ADR, bId[2]);
    WriteByte(CAN_IDR3 + CAN_TX_BUF + CAN_BASIC_ADR, bId[3]);
    /* set DLC */
    WriteByte(CAN_DLR + CAN_TX_BUF + CAN_BASIC_ADR, ptMsg->Dlc);
    /* copy message data bytes */
    for (i = 0; i < ptMsg->Dlc; i++) {
      WriteByte(CAN_DSR0 + CAN_TX_BUF + i + CAN_BASIC_ADR, ptMsg->bDb[i]);
    } /* for */
    /* set CAN controller transmission request */
    WriteByte(CAN_TFLG + CAN_BASIC_ADR, CAN_FLAG_TXE0);
    /* enable transmit interrupt */
    WriteByte(CAN_TIER + CAN_BASIC_ADR, CAN_FLAG_TXEIE0);
  } /* if */
  else {
    return BUSY_ERR;                    /* OUT: busy error              */
  } /* else */
  return NO_ERR;                        /* OUT: no error                */
}


/*!
  \brief CAN transmit ISR for J1939.

  The CAN transmit interrupt service routine.
*/
#pragma CODE_SEG NON_BANKED	 			

#ifdef COSMIC12
@interrupt void
#endif /* COSMIC1/2 */
//#ifdef __MWERKS__
#pragma TRAP_PROC
# if CAN_BASIC_ADR == CAN_0_ADR
void interrupt 39
# elif CAN_BASIC_ADR == CAN_1_ADR
void interrupt 43
# elif CAN_BASIC_ADR == CAN_2_ADR
void interrupt 47			
# elif CAN_BASIC_ADR == CAN_3_ADR
void interrupt 51
# elif CAN_BASIC_ADR == CAN_4_ADR
void interrupt 55
# endif
//#endif /* __MWERKS__ */

gCan_TxIntHadler(void)
{
// #if OS_CRITICAL_METHOD == 3          /* Allocate storage for CPU status register     */
   //  OS_CPU_SR  cpu_sr;
 //#endif
 // OS_ENTER_CRITICAL();
  
  /* disable transmit interrupt */
  ResetBitValue(CAN_TIER + CAN_BASIC_ADR, CAN_FLAG_TXEIE0);

  /* transmit interrupt - last transmission successful */
  bFirstMsgTrans = TRUE;
  bCanStatus |= CAN_STS_TX_OK;

  /* signal empty TX buffer */
  gCB_SignalTx();
 // OS_EXIT_CRITICAL();
  
}



/*!
  \brief CAN receive ISR.

  The CAN receive interrupt service routine.
*/
#ifdef COSMIC12
@interrupt void
#endif /* COSMIC12 */
//#ifdef __MWERKS__
#pragma TRAP_PROC
# if CAN_BASIC_ADR == CAN_0_ADR
void interrupt 38
# elif CAN_BASIC_ADR == CAN_1_ADR
void interrupt 42
# elif CAN_BASIC_ADR == CAN_2_ADR
void interrupt 46
# elif CAN_BASIC_ADR == CAN_3_ADR
void interrupt 50
# elif CAN_BASIC_ADR == CAN_4_ADR
void interrupt 54
# endif
//#endif /* __MWERKS__ */
gCan_RxIntHandler(void)
{
BYTE MessDataIndex;
//#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register     */
    //OS_CPU_SR  cpu_sr;
//#endif
#if ID_FILTER != 0
  WBYTE wId;                        /* received identifier              */
#endif /* ID_FILTER */
//OS_ENTER_CRITICAL();

#if ID_FILTER != 0
  /* 29 bit identifier not allowed */
  if (TestBitValue(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR, 0x08)) {
    /* release receive buffer */
    WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_RXF);
    return;
    //goto ISROut;
  } /* if */

  /* get identifier */
  wId.bc.lb = (ReadByte(CAN_IDR0 + CAN_RX_BUF + CAN_BASIC_ADR) << 3)
            | (ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) >> 5);
  wId.bc.mb = ReadByte(CAN_IDR0 + CAN_RX_BUF + CAN_BASIC_ADR) >> 5;

  /* check identifier */
  if (gCB_PreCheckXtdId(wId.wc) == FALSE) {
    /* release receive buffer */
    WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_RXF);
    return;
    //goto ISROut;
  } /* if */

  /* standard frame received */
  stCanMsgBuffer.Ext = 0;

  /* copy COB ID */
  stCanMsgBuffer.qbId.fb.b0 = wId.bc.lb;
  stCanMsgBuffer.qbId.fb.b1 = wId.bc.mb;
  stCanMsgBuffer.qbId.fb.b2 = 0;
  stCanMsgBuffer.qbId.fb.b3 = 0;

  /* get RTR */
  stCanMsgBuffer.Rtr = (ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) & 0x10) >> 4;
#else
  /* check 29 bit identifier */
  if (TestBitValue(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR, 0x08)) {
    /* extended frame received */
    stCanMsgBuffer.Ext = 1;

    /* get COB ID */
    stCanMsgBuffer.qbId.fb.b0 = (ReadByte(CAN_IDR2 + CAN_RX_BUF + CAN_BASIC_ADR) << 7)
                              | (ReadByte(CAN_IDR3 + CAN_RX_BUF + CAN_BASIC_ADR) >> 1);
    stCanMsgBuffer.qbId.fb.b1 = (ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) << 7)
                              | (ReadByte(CAN_IDR2 + CAN_RX_BUF + CAN_BASIC_ADR) >> 1);
    stCanMsgBuffer.qbId.fb.b2 = (ReadByte(CAN_IDR0 + CAN_RX_BUF + CAN_BASIC_ADR) << 5)
                              | ((ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) >> 3) & 0x1C)
                              | ((ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) >> 1) & 0x03);
    stCanMsgBuffer.qbId.fb.b3 = ReadByte(CAN_IDR0 + CAN_RX_BUF + CAN_BASIC_ADR) >> 3;

    if(gCB_PreCheckXtdId(stCanMsgBuffer.qbId.dw) == FALSE)
	{
      /* release receive buffer */
      WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_RXF);
      return;
      //goto ISROut;	
	} /* if */

    /* get RTR */
    stCanMsgBuffer.Rtr = ReadByte(CAN_IDR3 + CAN_RX_BUF + CAN_BASIC_ADR) & 0x01;
  } /* if */
  else {
    /* standard frame received */
    stCanMsgBuffer.Ext = 0;

    /* get COB ID */
    stCanMsgBuffer.qbId.fb.b0 = (ReadByte(CAN_IDR0 + CAN_RX_BUF + CAN_BASIC_ADR) << 3)
                              | (ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) >> 5);
    stCanMsgBuffer.qbId.fb.b1 = ReadByte(CAN_IDR0 + CAN_RX_BUF + CAN_BASIC_ADR) >> 5;
    stCanMsgBuffer.qbId.fb.b2 = 0;
    stCanMsgBuffer.qbId.fb.b3 = 0;

    /* get RTR */
    stCanMsgBuffer.Rtr = (ReadByte(CAN_IDR1 + CAN_RX_BUF + CAN_BASIC_ADR) & 0x10) >> 4;
  } /* else */
#endif /* ID_FILTER */

  /* get DLC */
  stCanMsgBuffer.Dlc = ReadByte(CAN_DLR + CAN_RX_BUF + CAN_BASIC_ADR) & 0x0F;
    
  /* check DLC */
  if (stCanMsgBuffer.Dlc > 8) {
    stCanMsgBuffer.Dlc = 8;
  } /* if */
    
  /* copy message data bytes */
  for (MessDataIndex = 0; MessDataIndex < stCanMsgBuffer.Dlc; MessDataIndex++) {
    stCanMsgBuffer.bDb[MessDataIndex] = ReadByte(CAN_DSR0 + CAN_RX_BUF + MessDataIndex + CAN_BASIC_ADR);
  } /* for */

  /* release receive buffer */
  WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_RXF);

  /* put message to storage location */
  gCB_CanBufferMsg(&stCanMsgBuffer);
  
  //ISROut:OS_EXIT_CRITICAL();
  
  
}


/*!
  \brief CAN error ISR.

  The CAN error interrupt service routine.
*/
#ifdef COSMIC12
@interrupt void
#endif /* COSMIC12 */
//#ifdef __MWERKS__
#pragma TRAP_PROC
# if CAN_BASIC_ADR == CAN_0_ADR
void interrupt 37
# elif CAN_BASIC_ADR == CAN_1_ADR
void interrupt 41
# elif CAN_BASIC_ADR == CAN_2_ADR
void interrupt 45
# elif CAN_BASIC_ADR == CAN_3_ADR
void interrupt 49
# elif CAN_BASIC_ADR == CAN_4_ADR
void interrupt 53
# endif
//#endif /* __MWERKS__ */
gCan_ErrIntHandler(void)
{
 //#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register     */
    // OS_CPU_SR  cpu_sr;
// #endif
  //OS_ENTER_CRITICAL();
  /* status change interrupt */
  if (TestBitValue(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_CSCIF)) {
    /* looking for reason */
    switch (ReadByte(CAN_RFLG + CAN_BASIC_ADR) & 0x30) {
      case 0x00: /* RX OK */
        break;
      case 0x10: /* RX warning */
        break;
      case 0x20: /* RX error */
        break;
      case 0x30: /* BusOff */
        bCanStatus |= CAN_STS_BUS_OFF;
        break;
    } /* switch */
    switch (ReadByte(CAN_RFLG + CAN_BASIC_ADR) & 0x0C) {
      case 0x00: /* TX OK */
        break;
      case 0x04: /* TX warning */
        break;
      case 0x08: /* TX error */
        bCanStatus |= CAN_STS_WARNING;
        break;
      case 0x0C: /* BusOff */
        bCanStatus |= CAN_STS_BUS_OFF;
        break;
    } /* switch */
    /* clear status change interrupt flag */
    WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_CSCIF);
  } /* if */

  /* overrun interrupt */
  if (TestBitValue(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_OVRIF)) {
    /* clear overrun interrupt flag */
    WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_OVRIF);
    /* set EMCY overrun flag */
    /* Don't be used in J1939 stack */
#   if 0
    fEmcyOverrun = TRUE;
#   endif
  } /* if */
 // OS_EXIT_CRITICAL();
}


/*!
  \brief CAN wakeup ISR.

  The CAN wakeup interrupt service routine.
*/
#ifdef COSMIC12
@interrupt void
#endif /* COSMIC12 */
//#ifdef __MWERKS__
# pragma TRAP_PROC
# if CAN_BASIC_ADR == CAN_0_ADR
void interrupt 36
# elif CAN_BASIC_ADR == CAN_1_ADR
void interrupt 40
# elif CAN_BASIC_ADR == CAN_2_ADR
void interrupt 44
# elif CAN_BASIC_ADR == CAN_3_ADR
void interrupt 48
# elif CAN_BASIC_ADR == CAN_4_ADR
void interrupt 52
# endif
//#endif /* __MWERKS__ */
gCan_WuIntHandler(void)
{
// #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register     */
    // OS_CPU_SR  cpu_sr;
 //#endif
  //OS_ENTER_CRITICAL();
  /* clear wake up interrupt flag */
  WriteByte(CAN_RFLG + CAN_BASIC_ADR, CAN_FLAG_WUPIF);
/* Don't be used in J1939 stack */
# if 0
  ModuleInfo.bModuleState = STACK_WAKEUP;
# endif