aixiao/Danger-alarm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
main
Danger-alarm/SOFTWARE-FreeRTOS/Common/drivers/Atmel/at91lib/peripherals/can/can.c

1043 lines
39 KiB
C
Raw Permalink Normal View History

initial
2024-06-03 16:27:41 +08:00
/* ----------------------------------------------------------------------------
* ATMEL Microcontroller Software Support
* ----------------------------------------------------------------------------
* Copyright (c) 2008, Atmel Corporation
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the disclaimer below.
*
* Atmel's name may not be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
* DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* ----------------------------------------------------------------------------
*/
//------------------------------------------------------------------------------
// Headers
//------------------------------------------------------------------------------
#include <board.h>
#include <pio/pio.h>
#include <utility/trace.h>
#include <aic/aic.h>
#include "can.h"
//------------------------------------------------------------------------------
// Local definitions
//------------------------------------------------------------------------------
// CAN state
#define CAN_DISABLED 0
#define CAN_HALTED 1
#define CAN_IDLE 2
#define CAN_SENDING 3
#define CAN_RECEIVING 4
// MOT: Mailbox Object Type
#define CAN_MOT_DISABLE 0 // Mailbox is disabled
#define CAN_MOT_RECEPT 1 // Reception Mailbox
#define CAN_MOT_RECEPT_OW 2 // Reception mailbox with overwrite
#define CAN_MOT_TRANSMIT 3 // Transmit mailbox
#define CAN_MOT_CONSUMER 4 // Consumer mailbox
#define CAN_MOT_PRODUCER 5 // Producer mailbox
//------------------------------------------------------------------------------
// Local variables
//------------------------------------------------------------------------------
#if defined (PINS_CAN_TRANSCEIVER_TXD)
static const Pin pins_can_transceiver_txd[] = {PINS_CAN_TRANSCEIVER_TXD};
#endif
#if defined (PINS_CAN_TRANSCEIVER_RXD)
static const Pin pins_can_transceiver_rxd[] = {PINS_CAN_TRANSCEIVER_RXD};
#endif
static const Pin pin_can_transceiver_rs = PIN_CAN_TRANSCEIVER_RS;
#if defined (PIN_CAN_TRANSCEIVER_RXEN)
static const Pin pin_can_transceiver_rxen = PIN_CAN_TRANSCEIVER_RXEN;
#endif
static CanTransfer *pCAN0Transfer=NULL;
#ifdef AT91C_BASE_CAN1
static CanTransfer *pCAN1Transfer=NULL;
#endif
//------------------------------------------------------------------------------
// Local functions
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
/// CAN Error Detection
/// \param status error type
/// \param can_number can nulber
//------------------------------------------------------------------------------
static void CAN_ErrorHandling( unsigned int status, unsigned char can_number)
{
if( (status&AT91C_CAN_ERRA) == AT91C_CAN_ERRA) {
trace_LOG( trace_ERROR, "-E- (CAN) CAN is in active Error Active mode\n\r");
}
else if( (status&AT91C_CAN_ERRP) == AT91C_CAN_ERRP) {
trace_LOG( trace_ERROR, "-E- (CAN) CAN is in Error Passive mode\n\r");
}
else if( (status&AT91C_CAN_BOFF) == AT91C_CAN_BOFF) {
trace_LOG( trace_ERROR, "-E- (CAN) CAN is in Buff Off mode\n\r");
// CAN reset
trace_LOG( trace_ERROR, "-E- (CAN) CAN%d reset\n\r", can_number);
// CAN Controller Disable
if (can_number == 0) {
AT91C_BASE_CAN0->CAN_MR &= ~AT91C_CAN_CANEN;
// CAN Controller Enable
AT91C_BASE_CAN0->CAN_MR |= AT91C_CAN_CANEN;
}
#ifdef AT91C_BASE_CAN1
else if (can_number == 1) {
AT91C_BASE_CAN1->CAN_MR &= ~AT91C_CAN_CANEN;
// CAN Controller Enable
AT91C_BASE_CAN1->CAN_MR |= AT91C_CAN_CANEN;
}
#endif
}
// Error for Frame dataframe
// CRC error
if( (status&AT91C_CAN_CERR) == AT91C_CAN_CERR) {
trace_LOG( trace_ERROR, "-E- (CAN) CRC Error\n\r");
}
// Bit-stuffing error
else if( (status&AT91C_CAN_SERR) == AT91C_CAN_SERR) {
trace_LOG( trace_ERROR, "-E- (CAN) Stuffing Error\n\r");
}
// Bit error
else if( (status&AT91C_CAN_BERR) == AT91C_CAN_BERR) {
trace_LOG( trace_ERROR, "-E- (CAN) Bit Error\n\r");
}
// Form error
else if( (status&AT91C_CAN_FERR) == AT91C_CAN_FERR) {
trace_LOG( trace_ERROR, "-E- (CAN) Form Error\n\r");
}
// Acknowledgment error
else if( (status&AT91C_CAN_AERR) == AT91C_CAN_AERR) {
trace_LOG( trace_ERROR, "-E- (CAN) Acknowledgment Error\n\r");
}
// Error interrupt handler
// Represent the current status of the CAN bus and are not latched.
// See CAN, par. Error Interrupt Handler
// AT91C_CAN_WARN
// AT91C_CAN_ERRA
}
//------------------------------------------------------------------------------
// Generic CAN Interrupt handler
/// \param can_number can nulber
//------------------------------------------------------------------------------
static void CAN_Handler( unsigned char can_number )
{
AT91PS_CAN base_can;
AT91PS_CAN_MB CAN_Mailbox;
unsigned int status;
unsigned int can_msr;
unsigned int* pCan_mcr;
unsigned int message_mode;
unsigned char numMailbox;
unsigned char state0;
unsigned char state1;
if( can_number == 0 ) {
base_can = AT91C_BASE_CAN0;
CAN_Mailbox = AT91C_BASE_CAN0_MB0;
state0 = pCAN0Transfer->state;
}
#ifdef AT91C_BASE_CAN1
else {
base_can = AT91C_BASE_CAN1;
CAN_Mailbox = AT91C_BASE_CAN1_MB0;
state1 = pCAN1Transfer->state;
}
#endif
status = (base_can->CAN_SR) & (base_can->CAN_IMR);
base_can->CAN_IDR = status;
trace_LOG( trace_DEBUG, "CAN0 status=0x%X\n\r", status);
if(status & AT91C_CAN_WAKEUP) {
if( can_number == 0 ) {
pCAN0Transfer->test_can = AT91C_TEST_OK;
pCAN0Transfer->state = CAN_IDLE;
}
#ifdef AT91C_BASE_CAN1
else {
pCAN1Transfer->test_can = AT91C_TEST_OK;
pCAN1Transfer->state = CAN_IDLE;
}
#endif
}
// Mailbox event ?
else if ((status&0x0000FFFF) != 0) {
trace_LOG( trace_DEBUG, "Mailbox event\n\r");
// Handle Mailbox interrupts
for (numMailbox = 0; numMailbox < NUM_MAILBOX_MAX; numMailbox++) {
can_msr = *(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x10+(0x20*numMailbox)));
if ((AT91C_CAN_MRDY & can_msr) == AT91C_CAN_MRDY) {
// Mailbox object type
message_mode = ((*(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x00+(0x20*numMailbox))))>>24)&0x7;
trace_LOG( trace_DEBUG, "message_mode 0x%X\n\r", message_mode);
trace_LOG( trace_DEBUG, "numMailbox 0x%X\n\r", numMailbox);
if( message_mode == 0 ) {
trace_LOG( trace_ERROR, "-E-Error in MOT\n\r");
}
else if( ( message_mode == CAN_MOT_RECEPT )
|| ( message_mode == CAN_MOT_RECEPT_OW )
|| ( message_mode == CAN_MOT_PRODUCER ) ) {
trace_LOG( trace_DEBUG, "Mailbox is in RECEPTION\n\r");
trace_LOG( trace_DEBUG, "Length 0x%X\n\r", (can_msr>>16)&0xF);
trace_LOG( trace_DEBUG, "CAN_MB_MID 0x%X\n\r", ((*(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x08+(0x20*numMailbox)))&AT91C_CAN_MIDvA)>>18));
trace_LOG( trace_DEBUG, "can_number %d\n\r", can_number);
if( can_number == 0 ) {
//CAN_MB_MDLx
pCAN0Transfer->data_low_reg =
(*(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x14+(0x20*numMailbox))));
//CAN_MB_MDHx
pCAN0Transfer->data_high_reg =
(*(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x18+(0x20*numMailbox))));
pCAN0Transfer->size = (can_msr>>16)&0xF;
pCAN0Transfer->mailbox_number = numMailbox;
state0 = CAN_IDLE;
}
#ifdef AT91C_BASE_CAN1
else {
//CAN_MB_MDLx
pCAN1Transfer->data_low_reg =
(*(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x14+(0x20*numMailbox))));
//CAN_MB_MDHx
pCAN1Transfer->data_high_reg =
(*(unsigned int*)((unsigned int)CAN_Mailbox+(unsigned int)(0x18+(0x20*numMailbox))));
pCAN1Transfer->size = (can_msr>>16)&0xF;
pCAN1Transfer->mailbox_number = numMailbox;
state1 = CAN_IDLE;
}
#endif
// Message Data has been received
pCan_mcr = (unsigned int*)((unsigned int)CAN_Mailbox+0x1C+(0x20*numMailbox));
*pCan_mcr = AT91C_CAN_MTCR;
}
else {
trace_LOG( trace_DEBUG, "Mailbox is in TRANSMIT\n\r");
trace_LOG( trace_DEBUG, "Length 0x%X\n\r", (can_msr>>16)&0xF);
trace_LOG( trace_DEBUG, "can_number %d\n\r", can_number);
if( can_number == 0 ) {
state0 = CAN_IDLE;
}
else {
state1 = CAN_IDLE;
}
}
}
}
if( can_number == 0 ) {
pCAN0Transfer->state = state0;
}
#ifdef AT91C_BASE_CAN1
else {
pCAN1Transfer->state = state1;
}
#endif
}
if ((status&0xFFCF0000) != 0) {
CAN_ErrorHandling(status, 0);
}
}
//------------------------------------------------------------------------------
/// CAN 0 Interrupt handler
//------------------------------------------------------------------------------
static void CAN0_Handler(void)
{
CAN_Handler( 0 );
}
//------------------------------------------------------------------------------
/// CAN 1 Interrupt handler
//------------------------------------------------------------------------------
#if defined AT91C_BASE_CAN1
static void CAN1_Handler(void)
{
CAN_Handler( 1 );
}
#endif
//------------------------------------------------------------------------------
// Global functions
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
/// Configure the corresponding mailbox
/// \param pTransfer can transfer structure
//------------------------------------------------------------------------------
void CAN_InitMailboxRegisters( CanTransfer *pTransfer )
{
AT91PS_CAN base_can;
AT91PS_CAN_MB CAN_Mailbox;
if( pTransfer->can_number == 0 ) {
base_can = AT91C_BASE_CAN0;
CAN_Mailbox = AT91C_BASE_CAN0_MB0;
}
#ifdef AT91C_BASE_CAN1
else {
base_can = AT91C_BASE_CAN1;
CAN_Mailbox = AT91C_BASE_CAN1_MB0;
}
#endif
CAN_Mailbox = (AT91PS_CAN_MB)((unsigned int)CAN_Mailbox+(unsigned int)(0x20*pTransfer->mailbox_number));
pTransfer->mailbox_in_use |= 1<<(pTransfer->mailbox_number);
// MailBox Control Register
CAN_Mailbox->CAN_MB_MCR = 0x0;
// MailBox Mode Register
CAN_Mailbox->CAN_MB_MMR = 0x00;
// CAN Message Acceptance Mask Register
CAN_Mailbox->CAN_MB_MAM = pTransfer->acceptance_mask_reg;
// MailBox ID Register
// Disable the mailbox before writing to CAN_MIDx registers
if( pTransfer->identifier != 0 ) {
CAN_Mailbox->CAN_MB_MAM |= AT91C_CAN_MIDE;
CAN_Mailbox->CAN_MB_MID = pTransfer->identifier;
}
else {
CAN_Mailbox->CAN_MB_MAM &= ~AT91C_CAN_MIDE;
}
// MailBox Mode Register
CAN_Mailbox->CAN_MB_MMR = pTransfer->mode_reg;
// MailBox Data Low Register
CAN_Mailbox->CAN_MB_MDL = pTransfer->data_low_reg;
// MailBox Data High Register
CAN_Mailbox->CAN_MB_MDH = pTransfer->data_high_reg;
// MailBox Control Register
CAN_Mailbox->CAN_MB_MCR = pTransfer->control_reg;
}
//------------------------------------------------------------------------------
/// Reset the MBx
//------------------------------------------------------------------------------
void CAN_ResetAllMailbox( void )
{
unsigned char i;
#if defined (AT91C_BASE_CAN0_MB0)
CAN_ResetTransfer( pCAN0Transfer );
for( i=0; i<8; i++ ) {
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = i;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_DIS;
pCAN0Transfer->acceptance_mask_reg = 0;
pCAN0Transfer->identifier = 0;
pCAN0Transfer->data_low_reg = 0x00000000;
pCAN0Transfer->data_high_reg = 0x00000000;
pCAN0Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN0Transfer );
}
#endif
#if defined (AT91C_BASE_CAN0_MB8)
for( i=0; i<8; i++ ) {
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = i+8;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_DIS;
pCAN0Transfer->acceptance_mask_reg = 0;
pCAN0Transfer->identifier = 0;
pCAN0Transfer->data_low_reg = 0x00000000;
pCAN0Transfer->data_high_reg = 0x00000000;
pCAN0Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN0Transfer );
}
#endif
#if defined (AT91C_BASE_CAN1_MB0)
if( pCAN1Transfer != NULL ) {
CAN_ResetTransfer( pCAN1Transfer );
for( i=0; i<8; i++ ) {
pCAN1Transfer->can_number = 1;
pCAN1Transfer->mailbox_number = i;
pCAN1Transfer->mode_reg = AT91C_CAN_MOT_DIS;
pCAN1Transfer->acceptance_mask_reg = 0;
pCAN1Transfer->identifier = 0;
pCAN1Transfer->data_low_reg = 0x00000000;
pCAN1Transfer->data_high_reg = 0x00000000;
pCAN1Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN1Transfer );
}
}
#endif
#if defined (AT91C_BASE_CAN1_MB8)
if( pCAN1Transfer != NULL ) {
for( i=0; i<8; i++ ) {
pCAN1Transfer->can_number = 1;
pCAN1Transfer->mailbox_number = i+8;
pCAN1Transfer->mode_reg = AT91C_CAN_MOT_DIS;
pCAN1Transfer->acceptance_mask_reg = 0;
pCAN1Transfer->identifier = 0;
pCAN1Transfer->data_low_reg = 0x00000000;
pCAN1Transfer->data_high_reg = 0x00000000;
pCAN1Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN1Transfer );
}
}
#endif
}
//------------------------------------------------------------------------------
/// CAN reset Transfer descriptor
/// \param pTransfer can transfer structure
//------------------------------------------------------------------------------
void CAN_ResetTransfer( CanTransfer *pTransfer )
{
pTransfer->state = CAN_IDLE;
pTransfer->can_number = 0;
pTransfer->mailbox_number = 0;
pTransfer->test_can = 0;
pTransfer->mode_reg = 0;
pTransfer->acceptance_mask_reg = 0;
pTransfer->identifier = 0;
pTransfer->data_low_reg = 0;
pTransfer->data_high_reg = 0;
pTransfer->control_reg = 0;
pTransfer->mailbox_in_use = 0;
pTransfer->size = 0;
}
//------------------------------------------------------------------------------
/// Wait for CAN synchronisation
/// \return return 1 for good initialisation, otherwise return 0
//------------------------------------------------------------------------------
static unsigned char CAN_Synchronisation( void )
{
unsigned int tick=0;
trace_LOG( trace_INFO, "CAN_Synchronisation\n\r");
pCAN0Transfer->test_can = AT91C_TEST_NOK;
#ifdef AT91C_BASE_CAN1
if( pCAN1Transfer != NULL ) {
pCAN1Transfer->test_can = AT91C_TEST_NOK;
}
#endif
// Enable CAN and Wait for WakeUp Interrupt
AT91C_BASE_CAN0->CAN_IER = AT91C_CAN_WAKEUP;
// CAN Controller Enable
AT91C_BASE_CAN0->CAN_MR = AT91C_CAN_CANEN;
// Enable Autobaud/Listen mode
// dangerous, CAN not answer in this mode
while( (pCAN0Transfer->test_can != AT91C_TEST_OK)
&& (tick < AT91C_CAN_TIMEOUT) ) {
tick++;
}
if (tick == AT91C_CAN_TIMEOUT) {
trace_LOG( trace_ERROR, "-E- CAN0 Initialisations FAILED\n\r");
return 0;
} else {
trace_LOG( trace_INFO, "-I- CAN0 Initialisations Completed\n\r");
}
#if defined AT91C_BASE_CAN1
if( pCAN1Transfer != NULL ) {
AT91C_BASE_CAN1->CAN_IER = AT91C_CAN_WAKEUP;
// CAN Controller Enable
AT91C_BASE_CAN1->CAN_MR = AT91C_CAN_CANEN;
tick = 0;
// Wait for WAKEUP flag raising <=> 11-recessive-bit were scanned by the transceiver
while( ((pCAN1Transfer->test_can != AT91C_TEST_OK))
&& (tick < AT91C_CAN_TIMEOUT) ) {
tick++;
}
if (tick == AT91C_CAN_TIMEOUT) {
trace_LOG( trace_ERROR, "-E- CAN1 Initialisations FAILED\n\r");
return 0;
} else {
trace_LOG( trace_INFO, "-I- CAN1 Initialisations Completed\n\r");
}
}
#endif
return 1;
}
//------------------------------------------------------------------------------
/// Write a CAN transfer
/// \param pTransfer can transfer structure
/// \return return CAN_STATUS_SUCCESS if command passed, otherwise
/// return CAN_STATUS_LOCKED
//------------------------------------------------------------------------------
unsigned char CAN_Write( CanTransfer *pTransfer )
{
AT91PS_CAN base_can;
if (pTransfer->state == CAN_RECEIVING) {
pTransfer->state = CAN_IDLE;
}
if (pTransfer->state != CAN_IDLE) {
return CAN_STATUS_LOCKED;
}
trace_LOG( trace_DEBUG, "CAN_Write\n\r");
pTransfer->state = CAN_SENDING;
if( pTransfer->can_number == 0 ) {
base_can = AT91C_BASE_CAN0;
}
#ifdef AT91C_BASE_CAN1
else {
base_can = AT91C_BASE_CAN1;
}
#endif
base_can->CAN_TCR = pTransfer->mailbox_in_use;
base_can->CAN_IER = pTransfer->mailbox_in_use;
return CAN_STATUS_SUCCESS;
}
//------------------------------------------------------------------------------
/// Read a CAN transfer
/// \param pTransfer can transfer structure
/// \return return CAN_STATUS_SUCCESS if command passed, otherwise
/// return CAN_STATUS_LOCKED
//------------------------------------------------------------------------------
unsigned char CAN_Read( CanTransfer *pTransfer )
{
AT91PS_CAN base_can;
if (pTransfer->state != CAN_IDLE) {
return CAN_STATUS_LOCKED;
}
trace_LOG( trace_DEBUG, "CAN_Read\n\r");
pTransfer->state = CAN_RECEIVING;
if( pTransfer->can_number == 0 ) {
base_can = AT91C_BASE_CAN0;
}
#ifdef AT91C_BASE_CAN1
else {
base_can = AT91C_BASE_CAN1;
}
#endif
// enable interrupt
base_can->CAN_IER = pTransfer->mailbox_in_use;
return CAN_STATUS_SUCCESS;
}
//------------------------------------------------------------------------------
/// Test if CAN is in IDLE state
/// \param pTransfer can transfer structure
/// \return return 0 if CAN is in IDLE, otherwise return 1
//------------------------------------------------------------------------------
unsigned char CAN_IsInIdle( CanTransfer *pTransfer )
{
return( pTransfer->state != CAN_IDLE );
}
//------------------------------------------------------------------------------
/// Basic CAN test without Interrupt
//------------------------------------------------------------------------------
void CAN_BasicTestSuiteWithoutInterrupt(void)
{
#if defined AT91C_BASE_CAN1
unsigned int status;
unsigned int tick=0;
trace_LOG( trace_INFO, "Without Interrupt ");
trace_LOG( trace_INFO, "CAN0 Mailbox 0 transmitting to CAN1 Mailbox 0\n\r");
// Init CAN0 Mailbox 0, transmit
CAN_ResetTransfer( pCAN0Transfer );
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = 0;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_TX | AT91C_CAN_PRIOR;
pCAN0Transfer->acceptance_mask_reg = 0x00000000;
pCAN0Transfer->identifier = AT91C_CAN_MIDvA & (0x07<<18);
pCAN0Transfer->data_low_reg = 0x11223344;
pCAN0Transfer->data_high_reg = 0x01234567;
pCAN0Transfer->control_reg = (AT91C_CAN_MDLC & (0x8<<16));
CAN_InitMailboxRegisters( pCAN0Transfer );
// Init CAN1 Mailbox 0, receive,
CAN_ResetTransfer( pCAN1Transfer );
pCAN1Transfer->can_number = 1;
pCAN1Transfer->mailbox_number = 0;
pCAN1Transfer->mode_reg = AT91C_CAN_MOT_RX;
pCAN1Transfer->acceptance_mask_reg = AT91C_CAN_MIDvA | AT91C_CAN_MIDvB;
pCAN1Transfer->identifier = AT91C_CAN_MIDvA & (0x07<<18);
pCAN1Transfer->data_low_reg = 0x00000000;
pCAN1Transfer->data_high_reg = 0x00000000;
pCAN1Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN1Transfer );
// Transfer Request for Mailbox 0
AT91C_BASE_CAN0->CAN_TCR = AT91C_CAN_MB0;
tick = 0;
do {
// CAN Message Status Register
status = AT91C_BASE_CAN0_MB0->CAN_MB_MSR;
}
while( !(status & AT91C_CAN_MRDY) && (++tick < AT91C_CAN_TIMEOUT) );
if (tick == AT91C_CAN_TIMEOUT) {
trace_LOG( trace_ERROR, "-E- Test FAILED\n\r");
}
else {
trace_LOG( trace_DEBUG, "-I- Transfer completed: CAN1 Mailbox 0 MRDY flag has raised\n\r");
if( AT91C_BASE_CAN0_MB0->CAN_MB_MDL != AT91C_BASE_CAN1_MB0->CAN_MB_MDL ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else if( AT91C_BASE_CAN0_MB0->CAN_MB_MDH != AT91C_BASE_CAN1_MB0->CAN_MB_MDH ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else {
trace_LOG( trace_INFO, "Test passed\n\r");
}
}
CAN_ResetAllMailbox();
trace_LOG( trace_INFO, "Without Interrupt ");
trace_LOG( trace_INFO, "CAN0 Mailboxes 1 & 2 transmitting to CAN1 Mailbox 15\n\r");
// Init CAN0 Mailbox 1, transmit
CAN_ResetTransfer( pCAN0Transfer );
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = 1;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_TX | AT91C_CAN_PRIOR;
pCAN0Transfer->acceptance_mask_reg = 0x00000000;
pCAN0Transfer->identifier = AT91C_CAN_MIDvA & (0x09<<18); // ID 9
pCAN0Transfer->data_low_reg = 0xAABBCCDD;
pCAN0Transfer->data_high_reg = 0xCAFEDECA;
pCAN0Transfer->control_reg = (AT91C_CAN_MDLC & (0x8<<16)); // Mailbox Data Length Code
CAN_InitMailboxRegisters( pCAN0Transfer );
// Init CAN0 Mailbox 2, transmit
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = 2;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_TX | (AT91C_CAN_PRIOR-(1<<16));
pCAN0Transfer->acceptance_mask_reg = 0x00000000;
pCAN0Transfer->identifier = AT91C_CAN_MIDvA & (0x0A<<18); // ID 10
pCAN0Transfer->data_low_reg = 0x55667788;
pCAN0Transfer->data_high_reg = 0x99AABBCC;
pCAN0Transfer->control_reg = (AT91C_CAN_MDLC & (0x8<<16)); // Mailbox Data Length Code
CAN_InitMailboxRegisters( pCAN0Transfer );
// Init CAN1 Mailbox 15, reception with overwrite
CAN_ResetTransfer( pCAN1Transfer );
pCAN1Transfer->can_number = 1;
pCAN1Transfer->mailbox_number = 15;
pCAN1Transfer->mode_reg = AT91C_CAN_MOT_RXOVERWRITE;
pCAN1Transfer->acceptance_mask_reg = 0;
pCAN1Transfer->identifier = 0x0;
pCAN1Transfer->data_low_reg = 0x00000000;
pCAN1Transfer->data_high_reg = 0x00000000;
pCAN1Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN1Transfer );
// Ask Transmissions on Mailbox 1 & 2 --> AT91C_CAN_MRDY & AT91C_CAN_MMI raises for Mailbox 15 CAN_MB_SR
AT91C_BASE_CAN0->CAN_TCR = AT91C_CAN_MB1 | AT91C_CAN_MB2;
// Wait for Last Transmit Mailbox
tick = 0;
do {
status = AT91C_BASE_CAN1_MB15->CAN_MB_MSR;
}
while( !(status & AT91C_CAN_MMI) && (++tick < AT91C_CAN_TIMEOUT) );
if (tick == AT91C_CAN_TIMEOUT) {
}
else {
trace_LOG( trace_DEBUG, "-I- Transfer completed: CAN1 Mailbox 15 MRDY and MMI flags have raised\n\r");
if( AT91C_BASE_CAN0_MB1->CAN_MB_MDL != AT91C_BASE_CAN1_MB15->CAN_MB_MDL ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else if( AT91C_BASE_CAN0_MB1->CAN_MB_MDH != AT91C_BASE_CAN1_MB15->CAN_MB_MDH ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else {
trace_LOG( trace_INFO, "Test passed\n\r");
}
}
CAN_ResetAllMailbox();
trace_LOG( trace_INFO, "Without Interrupt ");
trace_LOG( trace_INFO, "CAN0 Mailboxes 1 & 2 transmitting to CAN1 Mailbox 15\n\r");
// Init CAN0 Mailbox 1, transmit
CAN_ResetTransfer( pCAN0Transfer );
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = 1;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_TX | AT91C_CAN_PRIOR;
pCAN0Transfer->acceptance_mask_reg = 0x00000000;
pCAN0Transfer->identifier = AT91C_CAN_MIDvA & (0x09<<18); // ID 9
pCAN0Transfer->data_low_reg = 0xAABBCCDD;
pCAN0Transfer->data_high_reg = 0xCAFEDECA;
pCAN0Transfer->control_reg = (AT91C_CAN_MDLC & (0x8<<16)); // Mailbox Data Length Code
CAN_InitMailboxRegisters( pCAN0Transfer );
// Init CAN0 Mailbox 2, transmit
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = 2;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_TX | (AT91C_CAN_PRIOR-(1<<16));
pCAN0Transfer->acceptance_mask_reg = 0x00000000;
pCAN0Transfer->identifier = AT91C_CAN_MIDvA & (0x0A<<18); // ID 10
pCAN0Transfer->data_low_reg = 0x55667788;
pCAN0Transfer->data_high_reg = 0x99AABBCC;
pCAN0Transfer->control_reg = (AT91C_CAN_MDLC & (0x8<<16)); // Mailbox Data Length Code
CAN_InitMailboxRegisters( pCAN0Transfer );
// Init CAN1 Mailbox 15, reception with overwrite
CAN_ResetTransfer( pCAN1Transfer );
pCAN1Transfer->can_number = 1;
pCAN1Transfer->mailbox_number = 15;
pCAN1Transfer->mode_reg = AT91C_CAN_MOT_RX;
pCAN1Transfer->acceptance_mask_reg = 0;
pCAN1Transfer->identifier = 0x0;
pCAN1Transfer->data_low_reg = 0x00000000;
pCAN1Transfer->data_high_reg = 0x00000000;
pCAN1Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN1Transfer );
// Ask Transmissions on Mailbox 1 & 2 --> AT91C_CAN_MRDY & AT91C_CAN_MMI raises for Mailbox 15 CAN_MB_SR
AT91C_BASE_CAN0->CAN_TCR = AT91C_CAN_MB1 | AT91C_CAN_MB2;
// Wait for Last Transmit Mailbox
tick = 0;
do {
status = AT91C_BASE_CAN1_MB15->CAN_MB_MSR;
}
while( !(status & AT91C_CAN_MMI) && (++tick < AT91C_CAN_TIMEOUT) );
if (tick == AT91C_CAN_TIMEOUT) {
trace_LOG( trace_ERROR, "-E- Test FAILED\n\r");
}
else {
trace_LOG( trace_DEBUG, "Transfer completed: CAN1 Mailbox 15 MRDY and MMI flags have raised\n\r");
trace_LOG( trace_DEBUG, "MB_MDL: 0x%X\n\r", AT91C_BASE_CAN1_MB15->CAN_MB_MDL);
trace_LOG( trace_DEBUG, "MB_MDLH: 0x%X\n\r", AT91C_BASE_CAN1_MB15->CAN_MB_MDH);
if( AT91C_BASE_CAN0_MB2->CAN_MB_MDL != AT91C_BASE_CAN1_MB15->CAN_MB_MDL ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else if( AT91C_BASE_CAN0_MB2->CAN_MB_MDH != AT91C_BASE_CAN1_MB15->CAN_MB_MDH ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else {
trace_LOG( trace_INFO, "Test passed\n\r");
}
}
CAN_ResetAllMailbox();
trace_LOG( trace_INFO, "Without Interrupt ");
trace_LOG( trace_INFO, "CAN0 Mailbox 3 asking for CAN1 Mailbox 3 transmission\n\r");
// Init CAN0 Mailbox 3, consumer mailbox
// Sends a remote frame and waits for an answer
CAN_ResetTransfer( pCAN0Transfer );
pCAN0Transfer->can_number = 0;
pCAN0Transfer->mailbox_number = 3;
pCAN0Transfer->mode_reg = AT91C_CAN_MOT_CONSUMER | AT91C_CAN_PRIOR;
pCAN0Transfer->acceptance_mask_reg = AT91C_CAN_MIDvA | AT91C_CAN_MIDvB;
pCAN0Transfer->identifier = AT91C_CAN_MIDvA & (0x0B<<18); // ID 11
pCAN0Transfer->data_low_reg = 0x00000000;
pCAN0Transfer->data_high_reg = 0x00000000;
pCAN0Transfer->control_reg = 0x00000000;
CAN_InitMailboxRegisters( pCAN0Transfer );
// Init CAN1 Mailbox 3, porducer mailbox
// Waits to receive a Remote Frame before sending its contents
CAN_ResetTransfer( pCAN1Transfer );
pCAN1Transfer->can_number = 1;
pCAN1Transfer->mailbox_number = 3;
pCAN1Transfer->mode_reg = AT91C_CAN_MOT_PRODUCER | AT91C_CAN_PRIOR;
pCAN1Transfer->acceptance_mask_reg = 0;
pCAN1Transfer->identifier = AT91C_CAN_MIDvA & (0x0B<<18); // ID 11
pCAN1Transfer->data_low_reg = 0xEEDDFF00;
pCAN1Transfer->data_high_reg = 0x34560022;
pCAN1Transfer->control_reg = (AT91C_CAN_MDLC & (0x8<<16));
CAN_InitMailboxRegisters( pCAN1Transfer );
// Ask Transmissions on Mailbox 3 --> AT91C_CAN_MRDY raises for Mailbox 3 CAN_MB_SR
AT91C_BASE_CAN1->CAN_TCR = AT91C_CAN_MB3;
AT91C_BASE_CAN0->CAN_TCR = AT91C_CAN_MB3;
// Wait for Last Transmit Mailbox
tick = 0;
do {
status = AT91C_BASE_CAN0_MB3->CAN_MB_MSR;
}
while( !(status & AT91C_CAN_MRDY) && (++tick < AT91C_CAN_TIMEOUT) );
if (tick == AT91C_CAN_TIMEOUT) {
trace_LOG( trace_ERROR, "-E- Test FAILED\n\r");
}
else {
trace_LOG( trace_DEBUG, "-I- Transfer Completed: CAN0 & CAN1 Mailboxes 3 MRDY flags have raised\n\r");
if( AT91C_BASE_CAN0_MB3->CAN_MB_MDL != AT91C_BASE_CAN1_MB3->CAN_MB_MDL ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else if( AT91C_BASE_CAN0_MB3->CAN_MB_MDH != AT91C_BASE_CAN1_MB3->CAN_MB_MDH ) {
trace_LOG( trace_ERROR, "-E- Data Corrupted\n\r");
}
else {
trace_LOG( trace_INFO, "Test passed\n\r");
}
}
#endif // AT91C_BASE_CAN1
return;
}
//------------------------------------------------------------------------------
/// Disable CAN and enter in low power
//------------------------------------------------------------------------------
void CAN_disable( void )
{
// Disable the interrupt on the interrupt controller
AIC_DisableIT(AT91C_ID_CAN0);
// disable all IT
AT91C_BASE_CAN0->CAN_IDR = 0x1FFFFFFF;
#if defined AT91C_BASE_CAN1
AIC_DisableIT(AT91C_ID_CAN1);
// disable all IT
AT91C_BASE_CAN1->CAN_IDR = 0x1FFFFFFF;
#endif
// Enable Low Power mode
AT91C_BASE_CAN0->CAN_MR |= AT91C_CAN_LPM;
// Disable CANs Transceivers
// Enter standby mode
PIO_Set(&pin_can_transceiver_rs);
#if defined (PIN_CAN_TRANSCEIVER_RXEN)
// Enable ultra Low Power mode
PIO_Clear(&pin_can_transceiver_rxen);
#endif
// Disable clock for CAN PIO
AT91C_BASE_PMC->PMC_PCDR = (1 << AT91C_ID_PIOA);
// Disable the CAN0 controller peripheral clock
AT91C_BASE_PMC->PMC_PCDR = (1 << AT91C_ID_CAN0);
}
//------------------------------------------------------------------------------
/// baudrate calcul
/// \param base_CAN CAN base address
/// \param baudrate Baudrate value
/// allowed values: 1000, 800, 500, 250, 125, 50, 25, 10
/// \return return 1 in success, otherwise return 0
//------------------------------------------------------------------------------
unsigned char CAN_BaudRateCalculate( AT91PS_CAN base_CAN,
unsigned int baudrate )
{
unsigned int BRP;
unsigned int PROPAG;
unsigned int PHASE1;
unsigned int PHASE2;
unsigned int SJW;
unsigned int t1t2;
base_CAN->CAN_BR = 0;
BRP = (BOARD_MCK / (baudrate*1000*16))-1;
//trace_LOG( trace_DEBUG, "BRP = 0x%X\n\r", BRP);
// timing Delay:
// Delay Bus Driver: 50 ns
// Delay Receiver: 30 ns
// Delay Bus Line: 110 ns
if( (16*baudrate*2*(50+30+110)/1000000) >= 1) {
PROPAG = (16*baudrate*2*(50+30+110)/1000000)-1;
}
else {
PROPAG = 0;
}
//trace_LOG( trace_DEBUG, "PROPAG = 0x%X\n\r", PROPAG);
t1t2 = 15-(PROPAG+1);
//trace_LOG( trace_DEBUG, "t1t2 = 0x%X\n\r", t1t2);
if( (t1t2 & 0x01) == 0x01 ) {
// ODD
//trace_LOG( trace_DEBUG, "ODD\n\r");
PHASE1 = ((t1t2-1)/2)-1;
PHASE2 = PHASE1+1;
}
else {
// EVEN
//trace_LOG( trace_DEBUG, "EVEN\n\r");
PHASE1 = (t1t2/2)-1;
PHASE2 = PHASE1;
}
//trace_LOG( trace_DEBUG, "PHASE1 = 0x%X\n\r", PHASE1);
//trace_LOG( trace_DEBUG, "PHASE2 = 0x%X\n\r", PHASE2);
if( 1 > (4/(PHASE1+1)) ) {
//trace_LOG( trace_DEBUG, "4*Tcsc\n\r");
SJW = 3;
}
else {
//trace_LOG( trace_DEBUG, "Tphs1\n\r");
SJW = PHASE1;
}
//trace_LOG( trace_DEBUG, "SJW = 0x%X\n\r", SJW);
// Verif
if( BRP == 0 ) {
trace_LOG( trace_DEBUG, "BRP = 0 is not authorized\n\r");
return 0;
}
if( (PROPAG + PHASE1 + PHASE2) != 12 ) {
trace_LOG( trace_DEBUG, "(PROPAG + PHASE1 + PHASE2) != 12\n\r");
return 0;
}
base_CAN->CAN_BR = (AT91C_CAN_PHASE2 & (PHASE2 << 0))
+ (AT91C_CAN_PHASE1 & (PHASE1 << 4))
+ (AT91C_CAN_PROPAG & (PROPAG << 8))
+ (AT91C_CAN_SYNC & (SJW << 12))
+ (AT91C_CAN_BRP & (BRP << 16))
+ (AT91C_CAN_SMP & (0 << 24));
return 1;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
/// Init of the CAN peripheral
/// \param baudrate Baudrate value
/// allowed values: 1000, 800, 500, 250, 125, 50, 25, 10
/// \param canTransfer0 CAN0 structure transfer
/// \param canTransfer1 CAN1 structure transfer
/// \return return 1 if CAN has good baudrate and CAN is synchronized,
/// otherwise return 0
//------------------------------------------------------------------------------
unsigned char CAN_Init( unsigned int baudrate,
CanTransfer *canTransfer0,
CanTransfer *canTransfer1 )
{
unsigned char ret;
// CAN Transmit Serial Data
#if defined (PINS_CAN_TRANSCEIVER_TXD)
PIO_Configure(pins_can_transceiver_txd, PIO_LISTSIZE(pins_can_transceiver_txd));
#endif
#if defined (PINS_CAN_TRANSCEIVER_RXD)
// CAN Receive Serial Data
PIO_Configure(pins_can_transceiver_rxd, PIO_LISTSIZE(pins_can_transceiver_rxd));
#endif
// CAN RS
PIO_Configure(&pin_can_transceiver_rs, PIO_LISTSIZE(pin_can_transceiver_rs));
#if defined (PIN_CAN_TRANSCEIVER_RXEN)
// CAN RXEN
PIO_Configure(&pin_can_transceiver_rxen, PIO_LISTSIZE(pin_can_transceiver_rxen));
#endif
// Enable clock for CAN PIO
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOA);
// Enable the CAN0 controller peripheral clock
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_CAN0);
// disable all IT
AT91C_BASE_CAN0->CAN_IDR = 0x1FFFFFFF;
// Enable CANs Transceivers
#if defined (PIN_CAN_TRANSCEIVER_RXEN)
// Disable ultra Low Power mode
PIO_Set(&pin_can_transceiver_rxen);
#endif
// Normal Mode (versus Standby mode)
PIO_Clear(&pin_can_transceiver_rs);
// Configure the AIC for CAN interrupts
AIC_ConfigureIT(AT91C_ID_CAN0, AT91C_AIC_PRIOR_HIGHEST, CAN0_Handler);
// Enable the interrupt on the interrupt controller
AIC_EnableIT(AT91C_ID_CAN0);
if( CAN_BaudRateCalculate(AT91C_BASE_CAN0, baudrate) == 0 ) {
// Baudrate problem
trace_LOG( trace_DEBUG, "Baudrate CAN0 problem\n\r");
return 0;
}
pCAN0Transfer = canTransfer0;
#if defined AT91C_BASE_CAN1
if( canTransfer1 != NULL ) {
pCAN1Transfer = canTransfer1;
// Enable CAN1 Clocks
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_CAN1);
// disable all IT
AT91C_BASE_CAN1->CAN_IDR = 0x1FFFFFFF;
// Configure the AIC for CAN interrupts
AIC_ConfigureIT(AT91C_ID_CAN1, AT91C_AIC_PRIOR_HIGHEST, CAN1_Handler);
// Enable the interrupt on the interrupt controller
AIC_EnableIT(AT91C_ID_CAN1);
if( CAN_BaudRateCalculate(AT91C_BASE_CAN1, baudrate) == 0 ) {
// Baudrate problem
trace_LOG( trace_DEBUG, "Baudrate CAN1 problem\n\r");
return 0;
}
}
#endif
// Reset all mailbox
CAN_ResetAllMailbox();
// Enable the interrupt with all error cases
AT91C_BASE_CAN0->CAN_IER = AT91C_CAN_CERR // (CAN) CRC Error
| AT91C_CAN_SERR // (CAN) Stuffing Error
| AT91C_CAN_BERR // (CAN) Bit Error
| AT91C_CAN_FERR // (CAN) Form Error
| AT91C_CAN_AERR; // (CAN) Acknowledgment Error
#if defined AT91C_BASE_CAN1
if( canTransfer1 != NULL ) {
AT91C_BASE_CAN1->CAN_IER = AT91C_CAN_CERR // (CAN) CRC Error
| AT91C_CAN_SERR // (CAN) Stuffing Error
| AT91C_CAN_BERR // (CAN) Bit Error
| AT91C_CAN_FERR // (CAN) Form Error
| AT91C_CAN_AERR; // (CAN) Acknowledgment Error
}
#endif
// Wait for CAN synchronisation
if( CAN_Synchronisation( ) == 1 ) {
ret = 1;
}
else {
ret = 0;
}
return ret;
}
Reference in New Issue Copy Permalink