Can.c

Go to the documentation of this file.

 
 
#include "tutti_gli_header.h"
 
 
/*****DOCUMENTAZIONE DOXYGEN*******/
/// \file
// \file GPIO_LPC17xx.c
// \file GPIO_LPC17xx.h
/// \file CAN_LPC17xx.c
// \file CAN_LPC17xx.h
// \file Driver_CAN.h
 
/*!  
\page CAN  The CAN bus
\brief <span style="color:red;"> <b> Can Bus operation </b> </span>
 
 \b SUMMARY:
*\arg \ref user_use_of_CAN_bus
 
 
*\section user_use_of_CAN_bus User use of CAN bus
<hr width="75%" size="10" align="left">
 
\n CAN bus, as well I2C, is a communication protocol based on the CMSIS drivers. Adaptation and use of some 
drivers is exploited, as it will be explained in the following.
First of all it needs to read the hw parte of the the address of the board at some pins of the microcontroller. 
The addresses are set by means of some switches and the function to be used within the initialization function is
lettura_indirizzi_CAN(). The function returns a char with the hw address.
\n After the communication is completed, either transmission or reception, the interrupt call the CAN_SignalObjectEvent() and 
CAN_SignalUnitEvent() that have as an input the var \b event that containes some flags.
\n The flags from CAN_SignalUnitEvent() are general from the CAN and are the following:
 
\n 
<center>
\anchor Table_interrupt_signal_event  \b Table \b signal \b Interrupt: Flags of the mask \b event from CAN_SignalUnitEvent()
Parameter event                   | Bit      | Description                                                           |
:-------------------------------  | :-----:  | :---------------------------------------------------------------------|
ARM_CAN_EVENT_UNIT_INACTIVE       |    0     | Unit entered Inactive state.                                          |
ARM_CAN_EVENT_UNIT_ACTIVE         |    1     | Unit entered Error Active state.                                      |
ARM_CAN_EVENT_UNIT_WARNING        |    2     | Unit entered Error Warning state (one or both error counters >= 96).  |
ARM_CAN_EVENT_UNIT_PASSIVE        |    3     | Unit entered Error Passive state.                                     |
ARM_CAN_EVENT_UNIT_BUS_OFF        |    4     | Unit entered Bus-off state.                                           |
</center>
 
\n CAN_SignalObjectEvent() merely marks the ened of operation and the \b event var that generates is replicated to the global #evento_CAN 
with the flags that summarazies the results from the objcet under consideration, reception or transmission. In addition to 
the var \b event also the var \b obj_idx is a mark of the data transmission or reception. 
\n The flags of #evento_CAN have the following meaning:
 
\n 
<center>
\anchor Table_interrupt_obj_event  \b Table \b object \b Interrput: Flags of the mask #evento_I2C from CAN_SignalObjectEvent().
<span style="color:red;"> The row highlighted in red marks the state expected after a successfully communication. </span>
Parameter event                   | Bit     | Description                                                          |
:-------------------------------  | :-----: | :--------------------------------------------------------------------|
<span style="color:red;"> ARM_CAN_EVENT_SEND_COMPLETE </span>       |    <span style="color:red;"> 1 << 0 </span>    | <span style="color:red;"> Message was sent successfully by the obj_idx object. </span>                 |
<span style="color:red;"> ARM_CAN_EVENT_RECEIVE </span>             |  <span style="color:red;">  1 << 1 </span>    | <span style="color:red;"> Message was received successfully by the obj_idx object. </span>             |
ARM_CAN_EVENT_RECEIVE_OVERRUN     |    1 << 2    | Message was overwritten before it was read on the obj_idx object.    |
</center>
 
\n The function CAN_Inizialize() is used once to set the CAN into operation. The speed of the bus is defined in #CAN_speed.
In CAN_Inizialize() the hw address is exploited to compose the final 29 bis long address.
 
\n To communicate with the CAN bus we exploit part of the structure of functions from CMSIS. The structure typedef is this:
<span style="color:orange;"> <I>
\code {.c}
typedef struct _ARM_DRIVER_CAN {
  ARM_DRIVER_VERSION       (*GetVersion)            (void);                             ///< Pointer to \ref ARM_CAN_GetVersion            : Get driver version.
  ARM_CAN_CAPABILITIES     (*GetCapabilities)       (void);                             ///< Pointer to \ref ARM_CAN_GetCapabilities       : Get driver capabilities.
  int32_t                  (*Initialize)            (ARM_CAN_SignalUnitEvent_t   cb_unit_event,                     
                                                     ARM_CAN_SignalObjectEvent_t cb_object_event); ///< Pointer to \ref ARM_CAN_Initialize : Initialize CAN interface.
  int32_t                  (*Uninitialize)          (void);                             ///< Pointer to \ref ARM_CAN_Uninitialize          : De-initialize CAN interface.
  int32_t                  (*PowerControl)          (ARM_POWER_STATE          state);   ///< Pointer to \ref ARM_CAN_PowerControl          : Control CAN interface power.
  uint32_t                 (*GetClock)              (void);                             ///< Pointer to \ref ARM_CAN_GetClock              : Retrieve CAN base clock frequency.
  int32_t                  (*SetBitrate)            (ARM_CAN_BITRATE_SELECT   select,
                                                     uint32_t                 bitrate,
                                                     uint32_t                 bit_segments);       ///< Pointer to \ref ARM_CAN_SetBitrate : Set bitrate for CAN interface.
  int32_t                  (*SetMode)               (ARM_CAN_MODE             mode);    ///< Pointer to \ref ARM_CAN_SetMode               : Set operating mode for CAN interface.
  ARM_CAN_OBJ_CAPABILITIES (*ObjectGetCapabilities) (uint32_t                 obj_idx); ///< Pointer to \ref ARM_CAN_ObjectGetCapabilities : Retrieve capabilities of an object.
  int32_t                  (*ObjectSetFilter)       (uint32_t                 obj_idx,
                                                     ARM_CAN_FILTER_OPERATION operation,
                                                     uint32_t                 id,
                                                     uint32_t                 arg);     ///< Pointer to \ref ARM_CAN_ObjectSetFilter       : Add or remove filter for message reception.
  int32_t                  (*ObjectConfigure)       (uint32_t                 obj_idx,
                                                     ARM_CAN_OBJ_CONFIG       obj_cfg); ///< Pointer to \ref ARM_CAN_ObjectConfigure       : Configure object.
  int32_t                  (*MessageSend)           (uint32_t                 obj_idx,
                                                     ARM_CAN_MSG_INFO        *msg_info,
                                                     const uint8_t           *data,
                                                     uint8_t                  size);    ///< Pointer to \ref ARM_CAN_MessageSend           : Send message on CAN bus.
  int32_t                  (*MessageRead)           (uint32_t                 obj_idx,
                                                     ARM_CAN_MSG_INFO        *msg_info,
                                                     uint8_t                 *data,
                                                     uint8_t                  size);    ///< Pointer to \ref ARM_CAN_MessageRead           : Read message received on CAN bus.
  int32_t                  (*Control)               (uint32_t                 control,
                                                     uint32_t                 arg);     ///< Pointer to \ref ARM_CAN_Control               : Control CAN interface.
  ARM_CAN_STATUS           (*GetStatus)             (void);                             ///< Pointer to \ref ARM_CAN_GetStatus             : Get CAN status.
} const ARM_DRIVER_CAN;
\endcode
</I> </span>
 
\n We use only CAN1 which is defined here:
 
<span style="color:orange;"> <I>
\code {.c}
ARM_DRIVER_CAN Driver_CAN1 = {
  CAN_GetVersion,
  CAN_GetCapabilities,
  CAN1_Initialize,
  CAN1_Uninitialize,
  CAN1_PowerControl,
  CAN1_GetClock,
  CAN1_SetBitrate,
  CAN1_SetMode,
  CAN1_ObjectGetCapabilities,
  CAN1_ObjectSetFilter,
  CAN1_ObjectConfigure,
  CAN1_MessageSend,   //This is the function exploited for transmission
  CAN1_MessageRead,   //This is the function exploited for reception
  CAN1_Control,
  CAN1_GetStatus      
};
\endcode
</I> </span>
 
\n We exploit mainly \b CAN1_MessageSend, for transmission, \b CAN1_MessageRead, for reception.
If a polling is needed tehere are 3 varaibles that can be used. The first was mentioned above and is #evento_CAN
that assumes value according to Table \ref Table_interrupt_obj_event. This variable marks a concluded reception or transmission.
Other 2 boolean variables have been introduced, #messaggio_CAN_arrivato and #messaggio_CAN_spedito that are set 
to true when the operation is conlcuded. In case these 2 variables are used they need to be set to false just before the 
CAN operation is started.
 
\remark There are several available functions. we exploit only a few of them. Some are exploited in CAN_Inizialize(). 
Two important functions we need to consider are the transmission and reception.
Although we use only one of the 2 available CAN bus, for generality an example of the suggested use is as it follows:
<span style="color:orange;"> <I>
 
 
\code {.c}
extern ARM_DRIVER_CAN   Driver_CAN1;                            // Viene inclusa la Periferica CAN1 
ARM_DRIVER_CAN *CANdrv= &Driver_CAN1;                           //!< Puntatore alla periferica CAN 
tx_msg_info.id = ARM_CAN_EXTENDED_ID(some_address);   //In case it needs to specify the address
 
messaggio_CAN_spedito =false;
CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);
while( messaggio_CAN_spedito==false );  // Wait transmission completes, if we need to wait
 
messaggio_CAN_arrivato =false;
CANdrv->MessageRead(rx_obj_idx, &rx_msg_info, (uint8_t *) rx_data, 8U);
while( messaggio_CAN_arrivato == false );  // Wait reception completes, if we need to wait
\endcode
</I> </span>
 
\note To the CAN a generic address is assigned. Every board will answer to this address. To identify the answer of the board of interest 
only the board should be connecte to the bus or oits switch is the "generic address" position. The generic address set is the following #indirizzo_generico_CAN:
\snippetlineno Can.h var_indirizzo_generico_CAN
 
\remark Another polling alternative is this:
<span style="color:orange;"> <I>
\code {.c}
CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);
while( evento_CAN !=ARM_CAN_EVENT_SEND_COMPLETE    ){}  // Wait transmission completes, if we need to wait
 
CANdrv->MessageRead(rx_obj_idx, &rx_msg_info, (uint8_t *) rx_data, 8U);
while( evento_CAN != ARM_CAN_EVENT_RECEIVE    );  // Wait reception completes, if we need to wait
\endcode
</I> </span>
 
\n
\n
\sa That shown above is an extraction of the documentation from CMSIS drivers. 
For a complete reference to the CAN bus driver from CMSIS see the webs at Keil or ARM (in case of failure of either): 
- <a href="https://arm-software.github.io/CMSIS_5/Driver/html/group__can__interface__gr.html"  target=_blank><b>CMSIS doc for CAN bus from ARM</b></a>, 
- <a href="https://www.keil.com/pack/doc/CMSIS/Driver/html/group__can__interface__gr.html"  target=_blank><b>CMSIS doc for CAN bus from KEIL</b></a>
 
\n The codes for CAN bus is at: 
- \ref Can.c
- \ref Can.h
 
*/
 
/*! <!-- La funzione driver I2C0 -->
<!-- ************************************************************************************************ -->
 
\fn CAN1_Initialize (ARM_CAN_SignalUnitEvent_t cb_unit_event, ARM_CAN_SignalObjectEvent_t cb_object_event)
\param[in]  cb_unit_event   Pointer to \b ARM_CAN_SignalUnitEvent callback function
\param[in]  cb_object_event Pointer to \b ARM_CAN_SignalObjectEvent callback function
\return #Status_Error_Codes_CAN
 
\brief Initialize CAN interface and register signal (callback) functions.
 
The function initializes the CAN interface.
 
The function performs the following operations:
 
Initializes the resources needed for the CAN interface, for example dynamic memory allocation, RTOS object allocation, and possibly hardware pin configuration.
Registers the \b ARM_CAN_SignalUnitEvent callback function.
Registers the \b ARM_CAN_SignalObjectEvent callback function.
The parameter cb_unit_event is a pointer to the \b ARM_CAN_SignalUnitEvent callback function; use a NULL pointer when no callback signals are required.
 
The parameter cb_object_event is a pointer to the \b ARM_CAN_SignalObjectEvent callback function; use a NULL pointer when no callback signals are required.
 
<!-- ************************************************************************************************ -->
\fn CAN1_Uninitialize(void)
\retrun #Status_Error_Codes_CAN
 
\brief De-initialize CAN interface.
 
The function CAN1_Uninitialize() de-initializes the resources of the CAN interface. 
It is called to release the software resources used by the interface such as deallocate any 
RTOS objects, dynamic memory and pin de-configuration.
 
<!-- ************************************************************************************************ -->
\fn CAN1_PowerControl(ARM_POWER_STATE state)
\param[in]  state   Power state
- \b ARM_POWER_OFF : power off: no operation possible
- \b ARM_POWER_LOW : low power mode: retain state, detect and signal wake-up events
- \b ARM_POWER_FULL : power on: full operation at maximum performance
\return #Status_Error_Codes_CAN
 
\brief Control CAN interface power.
The function ARM_CAN_PowerControl controls the power modes of the CAN interface.
 
<!-- ************************************************************************************************ -->
\fn CAN1_MessageSend(uint32_t obj_idx, ARM_CAN_MSG_INFO *msg_info, const uint8_t *data, uint8_t size)
\param[in]  obj_idx Object index
\param[in]  msg_info    Pointer to CAN message information
\param[in]  data    Pointer to data buffer
\param[in]  size    Number of data bytes to send
\return value >= 0 number of data bytes accepted to send, value < 0 #Status_Error_Codes_CAN
\brief Send message on CAN bus.
The function CAN1_MessageSend() sends a CAN message on the CAN bus, or sets data message that will be automatically returned upon RTR reception with matching CAN ID.
 
Only one message can be sent with a call to this function (for CAN up to 8 bytes; for CAN FD up to 64 bytes of data). A message transmission can be terminated with a 
call to the function \b ARM_CAN_Control with control = \b ARM_CAN_ABORT_MESSAGE_SEND.
 
The parameter obj_idx specifies the message object index.
 
The parameter msg_info is a pointer to the structure \b ARM_CAN_MSG_INFO, which contains the following relevant data fields for sending message:
 
- id: Identifier of the message; bit 31 specifies if this is an 11-bit or 29-bit identifier.
- rtr: Specifies if Remote Transmission Request should be sent (dlc is used for number of requested bytes), otherwise the data message will be sent. Refer to Remote Frame for details.
- edl: Specifies if Extended Data Length is used; for CAN FD, message can contain up to 64 data bytes.
- brs: Specifies if Bit Rate Switching is to be used; for CAN FD, the bit rate can be increased during data phase.
- dlc: Data Length Code of requested data bytes when sending Remote Transmission Request.
 
The parameter data is a pointer to the data buffer.
\n The parameter size is the number of data bytes to send.
\n The function returns the number of bytes accepted to be sent or \b ARM_DRIVER_ERROR_BUSY if the hardware is not ready to accept a new message for transmission.
 
\n When the message is sent, the callback function ARM_CAN_SignalObjectEvent is called signalling \b ARM_CAN_EVENT_SEND_COMPLETE on specified object.
 
<!-- ************************************************************************************************ -->
\fn CAN1_MessageRead(uint32_t obj_idx, ARM_CAN_MSG_INFO *msg_info, uint8_t *data, uint8_t size)
\param[in]  obj_idx Object index
\param[out] msg_info    Pointer to read CAN message information
\param[out] data    Pointer to data buffer for read data
\param[in]  size    Maximum number of data bytes to read
\return value >= 0 number of data bytes read, value < 0 #Status_Error_Codes_CAN
 
\brief Read message received on CAN bus.
The function CAN1_MessageRead() reads the message received on the CAN bus, if obj_idx was configured for reception 
or for automatic Data Message reception using RTR and the callback function \b ARM_CAN_SignalObjectEvent was called signalling 
\b ARM_CAN_EVENT_RECEIVE. If the message was overrun by another received message, then the callback function 
\b ARM_CAN_SignalObjectEvent will be called signalling \b ARM_CAN_EVENT_RECEIVE_OVERRUN.
 
The function can read a maximum of 8 data bytes for CAN and 64 bytes for CAN FD.
 
\n The parameter obj_idx specifies the message object index.
\n The parameter msg_info is a pointer to the CAN information structure.
\n The parameter data is a pointer to the data buffer for reading data.
\n The parameter size is data buffer size in bytes and indicates the maximum number of bytes that can be read.
 
The function returns the number of read data in bytes or the #Status_Error_Codes_CAN.
 
All data fields of the structure ARM_CAN_MSG_INFO are updated as described below:
 
- id: Identifier of the message that was received, bit 31 specifies if it is a 11-bit identifier or 29-bit identifier.
- rtr: 1 = Remote Frame Request was received (dlc is number of requested bytes). 0 = data message
- edl: 1 = CAN FD Extended Data Length message was received. 0 = not Extended Data Length message.
- brs: 1 = CAN FD Bit Rate Switching was used for message transfer. 0 = no Bit Rate Switching was used.
- esi: 1 = CAN FD Error State Indicator is active for received message. 0 = Error State Indicator is not active.
- dlc: Data Length Code is the number of data bytes in the received message or number of data bytes requested by RTR.
 
Message reception can be disabled by de-configuring the receive object with the function ARM_CAN_ObjectConfigure.
*/
 
// <!-- ************************************************************************************************ -->
// <!-- Definizione solo per creare un commento -->
/*! \brief 
Macros
- \b ARM_DRIVER_OK   0
    Operation succeeded.  
- \b ARM_DRIVER_ERROR   -1
    Unspecified error.  
- \b ARM_DRIVER_ERROR_BUSY   -2
    Driver is busy.  
- \b ARM_DRIVER_ERROR_TIMEOUT   -3
    Timeout occurred. 
- \b ARM_DRIVER_ERROR_UNSUPPORTED   -4
    Operation not supported.  
- \b ARM_DRIVER_ERROR_PARAMETER   -5
    Parameter error.  
- \b ARM_DRIVER_ERROR_SPECIFIC   -6
    Start of driver specific errors.
    
Description
Negative return values of functions indicate errors occurred during execution.
 
Most functions return a status information using negative return values. 
The following list provides the status error codes that are common in all drivers. 
The drivers may return also status error codes that are specific to the peripheral.
*/
int8_t Status_Error_Codes_CAN;  //Creata solo per generare un commento
 
// Vengono inizializzati alcuni parametri
int32_t                                                 status;          
volatile uint8_t                rx_data[8];   //!< Received data vector
ARM_CAN_MSG_INFO                rx_msg_info;    
uint32_t                        rx_obj_idx                  =   0U;
uint8_t                         tx_data[8];   //!< Transmission data vector
ARM_CAN_MSG_INFO                tx_msg_info;    
uint32_t                        tx_obj_idx                  = 1U;
 
//!< This is the variable which resembles the flags from the communication
uint32_t  volatile evento_CAN; //!< This is the variable which resembles the flags from the communication
 
bool    messaggio_CAN_arrivato  = false;    //!< This variable is set to true as soon as a reception have been concluded
bool    messaggio_CAN_spedito  = false;   //!< This variable is set to true as soon as a transmission have been concluded
 
 
extern ARM_DRIVER_CAN   Driver_CAN1;                            //!< Viene inclusa la Periferica CAN1 
ARM_DRIVER_CAN *CANdrv= &Driver_CAN1;                           /*!< Puntatore alla periferica CAN*/
                                                                                                    // Viene creato un puntatore a Driver_CAN1
unsigned int indirizzo_CAN_della_scheda=0x12345678; //!< Per ora lo assegnamo cos\i l'indirizzo della scheda
 
 
/*! \brief The CAN bus address
 
*\return A char with the hw CAN bus address
\callgraph
\showrefs
*\snippet{lineno} Can.c fun_lettura_indirizzi_CAN
 */
//! <!-- [fun_lettura_indirizzi_CAN] -->
unsigned char lettura_indirizzi_CAN(void){
    //Lettura indirizzo PIN
    uint8_t lettura,indirizzo;
    uint8_t iii;
 
//  lettura[0]=GPIO_PinRead(0,B0);
    indirizzo=0;
    for (iii=0;iii<8;iii++){
        lettura = GPIO_PinRead(CAN_indirizzo_hw[iii].porta_num, CAN_indirizzo_hw[iii].pin_num);
        if(lettura) indirizzo += 1 << iii;
    }
 
    return indirizzo;
}
//! <!-- [fun_lettura_indirizzi_CAN] -->
 
 
 /*****************************************************************************
  Callback della Periferica CAN
 ******************************************************************************/
/*! \brief After that CAN aneded operation eand the interrupt is generated this signal function is called which marks errors, if any
    
*\param[in]  event  
*\return No parameters
 \showrefby
\showrefs
*\snippet{lineno} Can.c fun_CAN_SignalUnitEvent
 */
//! <!-- [fun_CAN_SignalUnitEvent] -->
void CAN_SignalUnitEvent (uint32_t event) {}
    //! <!-- [fun_CAN_SignalUnitEvent] -->
 
/*! \brief After that CAN aneded operation eand the interrupt is generated this object function is called which marks which action completed
    
*\param[in]  obj_idx
*\param[in]  event  
*\return No parameters
\showrefby
\showrefs
*\snippet{lineno} Can.c fun_CAN_SignalObjectEvent
 */
//! <!-- [fun_CAN_SignalObjectEvent] -->
void CAN_SignalObjectEvent(uint32_t obj_idx, uint32_t event)
{
    uint8_t i;
 
    tempo=0;  //Si resetta il contatore per il powerdown
    evento_CAN= event;
    if(event==ARM_CAN_EVENT_RECEIVE)    // Se c'\'e un evento di ricezione
    {
    if (obj_idx == rx_obj_idx)     // Se si riceve l'evento dell'oggetto
        {              
            messaggio_CAN_arrivato=true;            // Se c'\'e un'istruzione dal can, il flag diventa true
            CANdrv->MessageRead(rx_obj_idx, &rx_msg_info, (uint8_t *) rx_data, 8U);                     // Viene letto il dato ricevuto
//          for(i=0;i<8;++i)
//                  {
//              tx_data[i]=rx_data[i];      // Viene copiato il dato nell'array di ricezione
//                      }
        }
    }
    
  if (event == ARM_CAN_EVENT_SEND_COMPLETE)                                                         // Se c'\'e un evento di trasmissione
    { 
    if (obj_idx == tx_obj_idx)
        {    
            messaggio_CAN_spedito=true;
            rx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);               // Viene impostato l'indirizzo esteso per il prossimo messaggio da ricevere
    }
  }
}
//! <!-- [fun_CAN_SignalObjectEvent] -->
 
 
/******************************************************************************
    Inizializzazione della Periferica CAN
*******************************************************************************/
 
/*! \brief The CAN initialization function
    
*\return No parameters
\showrefby
\showrefs
\showrefs
\callgraph
*\snippet{lineno} Can.c fun_CAN_Inizialize
 */
//! <!-- [fun_CAN_Inizialize] -->
void CAN_Inizialize(void)
{
    uint32_t test_addr;
    indirizzo_CAN_della_scheda=   lettura_indirizzi_CAN();  //Leggiamo l'indirizzo del CAN dagli interruttori
 
    EPROM_lettura_M24C32_64(0,I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_CAN_from_hw_switch_1_from_EPROM_0 <<2 , (uint8_t *)&test_addr);
    if (test_addr ==0) EPROM_lettura_M24C32_64(0,I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_address_CAN_own_filter <<2 , (uint8_t *)&indirizzo_CAN_della_scheda);
//  LED_accendi_spegni(LED_GREEN, accendi);
//  LED_accendi_spegni(LED_RED, spegni);
    
    status = CANdrv ->PowerControl(ARM_POWER_OFF);  //AL risveglio serve per resettare tutti i registri, altrimenti 
    status = CANdrv -> Uninitialize();  
                                //gli interrupt non li configura e bisogna farlo a mano.
    status = CANdrv->Initialize(CAN_SignalUnitEvent,CAN_SignalObjectEvent);
    status = CANdrv->PowerControl(ARM_POWER_FULL);                                                              // Viene accesa la periferica CAN
    status = CANdrv->SetMode(ARM_CAN_MODE_INITIALIZATION);                                              // Viene attivata la modalit\'a inizializzazione
 
    // Vengono impostati i valori per il BitRate    
    status = CANdrv->SetBitrate   (ARM_CAN_BITRATE_NOMINAL,                                 
                                CAN_speed,                                                
                                ARM_CAN_BIT_PROP_SEG(5U)   |                           
                                ARM_CAN_BIT_PHASE_SEG1(1U) |                            
                                ARM_CAN_BIT_PHASE_SEG2(1U) |                              
                                ARM_CAN_BIT_SJW(1U));    
    // Viene impostato il filtro per ricevere i messaggi con ID esteso 0x12345678 per ricevere l'oggetto 
    
    LPC_CANAF->ENDofTable =0; //Resettiamo la tabella dei filtri: se c'e' un semplice reset sw rimane quella precedente e si aggiungono
    LPC_CANAF->EFF_GRP_sa=0;
    
  status = CANdrv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda), 0U);
    status = CANdrv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_EXTENDED_ID(indirizzo_generico_CAN), 0U);
    
    
    status = CANdrv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX);                 // Viene configurata la trasmissione 
  status = CANdrv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX);                 // Viene configurata la ricezione
  status = CANdrv->SetMode (ARM_CAN_MODE_NORMAL);                               // Viene attivata la modalit\'a normale
}
//! <!-- [fun_CAN_Inizialize] -->