usercode.c

包含了NXP众多的MCU的例子程序

    /*--- Handle LEDs ---*/
    IO0CLR_bit.P0_12 = 1;   /* Yellow led ON */
    IO0CLR_bit.P0_13 = 1;   /* Green led ON */

    /*
    **----------------------------
    ** Setup interrupt controller
    **----------------------------
    */
    /*--- Disable interrupts ---*/
    __disable_interrupt();

    /*--- Enable VIC registers access ---*/
    VICProtection = 0;

    /*--- Enable CAN1 Rx (=bit 26 0x04000000L ) ---*/
    /*--- Enable CAN2 Rx (=bit 27 0x08000000L ) ---*/
    VICIntEnable = 0x0C000000L;  /* CAN1 interrupt is enabled but not used */

    /*--- Select interrupt type, all are IRQ type, no FIQ type ---*/
    VICIntSelect = 0;

    /*
    **---------------------------------------------
    ** Enable vector IRQ slot
    ** Bit5    Enabled if =1 (0x20)
    ** Bit4:0  The number of the interrupt request
    **          CAN1 Rx 0x1A
    **          CAN2 Rx 0x1B
    **---------------------------------------------
    */
    /*--- Slot 1, Assign vector CAN1 Rx to this slot ---*/
    /*
    ** This vector is not used
    ** VICVectCntl1 = 0x3A;
    */

    /*--- Slot 2, Assign vector CAN2 Rx to this slot ---*/
    VICVectCntl2 = 0x3B;

    /*
    **--------------------------------------------
    ** Initialise used interrupt service routines
    ** Load registers with the ISR start address
    **--------------------------------------------
    */
    /*--- Slot 1 ---*/
    /*
    ** This slot is not used
    ** pAddrReg = &VICVectAddr0 + 1;
    ** *pAddrReg = (unsigned int)&EW_IntHandler_RX_CAN1;
    */

    /*--- Slot 2 ---*/
    pAddrReg = &VICVectAddr0 + 2;
    *pAddrReg = (unsigned int)&EW_IntHandler_RX_CAN2;

    /*--- Enable interrupts ---*/
    __enable_interrupt();

    /*
    **------------------
    ** Load CAN filters
    **------------------
    */
    ii= 0;
    while ( CAN1Filter[ii].FilterType )
    {
        /*--- Add new filter, new ID is sorted into filter table ---*/
        EW_AddFilter_CAN( &CAN1Filter[ii] );
        ii++;
    }
    ii= 0;
    while ( CAN2Filter[ii].FilterType )
    {
        /*--- Add new filter, new ID is sorted into filter table ---*/
        EW_AddFilter_CAN( &CAN2Filter[ii] );
        ii++;
    }

    /*
    **---------------------------------------
    ** Initialize and send first CAN message
    **---------------------------------------
    */
    TxMsg.CTRL = Can1Test[0].CTRL;
    TxMsg = Can1Test[0];
    EW_SendData_CAN( 1, &TxMsg );

    /*--- Initialize variables ---*/
    CANRunFlag = 1;
    CAN2ii = 1;
    CAN1msg = 0;
    CAN2msg = 0;

    /*
    **------------------
    ** Application code
    **------------------
    */
    while( 1 )
    {
        /*
        **------------------------
        ** Read button B1 and B2
        ** B1 stops CAN messages
        ** B2 starts CAN messages
        **------------------------
        */
        /*--- stop CAN? ---*/
        if(!IO0PIN_bit.P0_15)
        {
            /*--- B1 pressed - Bounce delay ---*/
            for (jj=0; jj<0x100; jj++)
            {
                ;
            }
            if(!IO0PIN_bit.P0_15)
            {
                /*--- B1 pressed - stop CAN message ---*/
                CANRunFlag = 0;
            }
        }

        /*--- start CAN? ---*/
        if(!IO0PIN_bit.P0_16)
        {
            /*--- B2 pressed - Bounce delay ---*/
            for (jj=0; jj<0x100; jj++)
            {
                ;
            }
            if(!IO0PIN_bit.P0_16)
            {
                /*--- B2 pressed - start CAN message ---*/
                CANRunFlag = 1;
            }
        }

        /*
        **-------------------------------------------------------
        ** Poll CAN controller 1 to find if new message received
        ** CAN controller 2 is handled via interrupt
        **-------------------------------------------------------
        */
        Status = EW_Manage_CAN(1);

        /*--- Error?  ---*/
        if( Status & ( EW_CAN_OVERRUN |
                       EW_CAN_ERROR |
                       EW_CAN_BUS_ERROR |
                       EW_CAN_FILTER_ERROR ))
        {
            /*--- Yes, some error, loop forever ---*/
            while (1)
            {
                ;
            }
        }
        /*--- CAN1 received message? ---*/
        if (Status & EW_CAN_RECEIVED )
        {
            /*--- CAN 1 has received data ---*/
            Status = EW_ReceiveData_CAN( 1, &RxMsg1 );
            if( Status == EW_DATA)
            {
                /*--- CAN1 Received data ---*/
                CAN1ii--;
            }
        }

        /*
        **----------------------------------
        ** Test if fullCAN message received
        ** via CAN1 or CAN2 filters
        **----------------------------------
        */
        Status = EW_ReceiveData_CAN( 0, &RxMsg0 );
        if( Status == EW_DATA)
        {
            /*--- Yes, new fullCAN message detected ---*/
            if(( RxMsg0.CTRL & 0x7000000L ) == 0x1000000L )
            {
                /*--- New message received and filtered by CAN1 ---*/
                __disable_interrupt();
                CAN1ii--;
                __enable_interrupt();
            }
            else if(( RxMsg0.CTRL & 0x7000000L ) == 0x2000000L )
            {
                /*--- New message received and filtered by CAN2 ---*/
                __disable_interrupt();
                CAN2ii--;
                __enable_interrupt();
            }
            else
            {
                /*--- ERROR - wrong Controller detected, loop forever ---*/
                while (1)
                {
                    ;
                }
            }
        }

        /*
        **----------------------------------
        ** Send new CAN messages?
        **----------------------------------
        */
        if( CANRunFlag )
        {
            if( CAN1ii == 0 )
            {
                /*
                **-------------------------------------
                ** CAN2 has received all messages
                ** Send new messages from CAN1 to CAN2
                **-------------------------------------
                */
                CAN1ii = 0xff;
                CAN2ii = 0;

                CAN1msg++;
                TxMsg = Can1Test[(CAN1msg & 0xf)];
                TxMsg.Data1 = CAN1msg;
                TxMsg.Data1 = CAN2ii-1;
                TxMsg.Data2 = CAN2ii++;
                EW_SendData_CAN( 1, &TxMsg );

#ifdef USE_THREE_TX_BUFFERS
                CAN1msg++;
                TxMsg = Can1Test[(CAN1msg & 0xf)];
                TxMsg.Data1 = CAN1msg;
                TxMsg.Data1 = CAN2ii-1;
                TxMsg.Data2 = CAN2ii++;
                EW_SendData_CAN( 1, &TxMsg );

                CAN1msg++;
                TxMsg = Can1Test[(CAN1msg & 0xf)];
                TxMsg.Data1 = CAN1msg;
                TxMsg.Data1 = CAN2ii-1;
                TxMsg.Data2 = CAN2ii++;
                EW_SendData_CAN( 1, &TxMsg );
#endif
                /*--- LED toggle ---*/
                if(CAN1msg & 0x1)
                {
                    /*--- YELLOW LED ON ---*/
                    IO0CLR_bit.P0_12 = 1;
                }
                else
                {
                    /*--- YELLOW LED OFF ---*/
                    IO0SET_bit.P0_12 = 1;
                }
            }

            if( CAN2ii == 0 )
            {
                /*
                **-------------------------------------
                ** CAN1 has received all messages
                ** Send new messages from CAN2 to CAN1
                **-------------------------------------
                */
                CAN2ii = 0xff;
                CAN1ii = 0;

                CAN2msg++;

                TxMsg = Can2Test[(CAN2msg & 0xf)];
                TxMsg.Data1 = CAN2msg;
                TxMsg.Data1 = CAN1ii-1;
                TxMsg.Data2 = CAN1ii++;
                EW_SendData_CAN( 2, &TxMsg );

#ifdef USE_THREE_TX_BUFFERS
                CAN2msg++;
                TxMsg = Can2Test[(CAN2msg & 0xf)];
                TxMsg.Data1 = CAN2msg;
                TxMsg.Data1 = CAN1ii-1;
                TxMsg.Data2 = CAN1ii++;
                EW_SendData_CAN( 2, &TxMsg );

                CAN2msg++;
                TxMsg = Can2Test[(CAN2msg & 0xf)];
                TxMsg.Data1 = CAN2msg;
                TxMsg.Data1 = CAN1ii-1;
                TxMsg.Data2 = CAN1ii++;
                EW_SendData_CAN( 2, &TxMsg );
#endif

                /*--- LED toggle ---*/
                if(CAN2msg & 0x1)
                {
                    /*--- GREEN LED ON ---*/
                    IO0CLR_bit.P0_13 = 1;
                }
                else
                {
                    /*--- GREEN LED OFF ---*/
                    IO0SET_bit.P0_13 = 1;
                }
            }
        }
    }

} /* main */


/*
**===========================================================================
**  5.      INTERNAL FUNCTIONS (declared in Section 3.5)
**===========================================================================
*/

__irq __arm void irq_handler(void)
/*
**---------------------------------------------------------------------------
**
**  Abstract:
**      IRQ service interrupt handler.
**      Reads the VICVectAddr register and jump to the value read.
**
**  Parameters:
**      None
**
**  Returns:
**      None
**
**---------------------------------------------------------------------------
*/

{
  void (*interrupt_function)();
  unsigned int vector;

  vector = VICVectAddr; /* Get interrupt vector. */
  interrupt_function = (void(*)())vector;
  (*interrupt_function)();  /* Call vectored interrupt function. */

  VICVectAddr = 0; /* Clear interrupt in VIC. */
}

/*
**===========================================================================
** END OF FILE
**===========================================================================
*/