drv_can.h

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2024 MikroElektronika d.o.o.
** Contact: https://www.mikroe.com/contact
**
** This file is part of the mikroSDK package
**
** Commercial License Usage
**
** Licensees holding valid commercial NECTO compilers AI licenses may use this
** file in accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The MikroElektronika Company.
** For licensing terms and conditions see
** https://www.mikroe.com/legal/software-license-agreement.
** For further information use the contact form at
** https://www.mikroe.com/contact.
**
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used for
** non-commercial projects under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** OF MERCHANTABILITY, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
** TO THE WARRANTIES FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
** DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
** OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
** OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
#ifndef _DRV_CAN_H_
#define _DRV_CAN_H_
 
#ifdef __cplusplus
extern "C"{
#endif
 
#include "drv_name.h"
#include "hal_can.h"
 
typedef enum
{
    CAN_SUCCESS = 0,  
    CAN_ERROR = (-1)  
} can_err_t;
 
typedef enum
{
    /* Universal Modes. */
    CAN_MODE_NORMAL = 0,        
    CAN_MODE_LOOPBACK,          
    CAN_MODE_DISABLE,           
    /* STM32 and RISC-V Modes. */
    CAN_MODE_SILENT,            
    CAN_MODE_LOOPBACK_SILENT,   
    /* NXP Modes. */
    CAN_MODE_LISTENONLY,        
    CAN_MODE_DOZE,              
    CAN_MODE_STOP,              
    CAN_MODE_FREEZE,            
    /* dsPIC Modes.*/
    CAN_MODE_LISTENALL,         
    /* PIC/PIC32 Modes. */
    CAN_MODE_CONFIGURATION      
} can_mode_t;
 
typedef enum
{
    CAN_STATE_RESET = 0,    
    CAN_STATE_READY,        
    CAN_STATE_LISTENING,    
    CAN_STATE_ERROR         
} can_state_t;
 
typedef enum
{
    CAN_FRAME_FORMAT_STANDARD_11BITS = 0,  
    CAN_FRAME_FORMAT_EXTENDED_29BITS       
} can_frame_format_t;
 
typedef enum
{
    CAN_FRAME_TYPE_DATA = 0,  
    CAN_FRAME_TYPE_RTR        
} can_frame_type_t;
 
typedef enum
{
    CAN_FILTER_MODE_IDMASK = 0,  
    CAN_FILTER_MODE_IDLIST       
} can_filter_mode_t;
 
typedef enum
{
    CAN_FILTER_SCALE_16BIT = 0,  
    CAN_FILTER_SCALE_32BIT       
} can_filter_scale_t;
 
typedef enum
{
    CAN_FILTER_FIFO0 = 0,   
    CAN_FILTER_FIFO1,       
    CAN_FILTER_FIFO2,       
    CAN_FILTER_FIFO3,       
    CAN_FILTER_FIFO4,       
    CAN_FILTER_FIFO5,       
    CAN_FILTER_FIFO6,       
    CAN_FILTER_FIFO7,       
    CAN_FILTER_FIFO8,       
    CAN_FILTER_FIFO9,       
    CAN_FILTER_FIFO10,      
    CAN_FILTER_FIFO11,      
    CAN_FILTER_FIFO12,      
    CAN_FILTER_FIFO13,      
    CAN_FILTER_FIFO14,      
    CAN_FILTER_FIFO15,      
    CAN_FILTER_FIFO16,      
    CAN_FILTER_FIFO17,      
    CAN_FILTER_FIFO18,      
    CAN_FILTER_FIFO19,      
    CAN_FILTER_FIFO20,      
    CAN_FILTER_FIFO21,      
    CAN_FILTER_FIFO22,      
    CAN_FILTER_FIFO23,      
    CAN_FILTER_FIFO24,      
    CAN_FILTER_FIFO25,      
    CAN_FILTER_FIFO26,      
    CAN_FILTER_FIFO27,      
    CAN_FILTER_FIFO28,      
    CAN_FILTER_FIFO29,      
    CAN_FILTER_FIFO30,      
    CAN_FILTER_FIFO31       
} can_filter_fifo_t;
 
typedef enum
{
    CAN_FILTER_DISABLE = 0,  
    CAN_FILTER_ENABLE        
} can_filter_activation_t;
 
typedef struct
{
    union {
        struct {
            uint16_t can_filter_id_low;         
            uint16_t can_filter_id_high;        
        };
        uint32_t can_filter_id;                 
    };
    union {
        struct {
            uint16_t can_filter_mask_id_low;    
            uint16_t can_filter_mask_id_high;   
        };
        uint32_t can_filter_mask_id;            
    };
    uint8_t can_filter_bank;                    
    can_frame_type_t can_filter_frame_type[4];  
    can_filter_activation_t can_filter_enable;  
    can_filter_mode_t can_filter_mode;          
    can_filter_scale_t can_filter_scale;        
    can_filter_fifo_t can_filter_fifo;          
} can_filter_config_t;
 
typedef struct
{
    pin_name_t tx_pin;  
    pin_name_t rx_pin;  
    can_mode_t mode;    
    uint32_t frequency; 
} can_config_t;
 
typedef struct
{
    handle_t handle;                   
    can_config_t config;               
    can_filter_config_t filter_config; 
} can_t;
 
typedef struct
{
    union {
        struct {
            uint16_t std_id;                          
            uint16_t ext_id;                          
        };
        uint32_t id;
    };
    can_frame_format_t frame_format;   
    can_frame_type_t frame_type;       
    uint8_t data_len;                  
    uint8_t message_data[8];           
} can_message_t;
 
typedef struct
{
    can_message_t message;  /* CAN message structure. */
} can_transmit_message_struct;
 
typedef struct
{
    can_message_t message;  /* CAN message structure. */
    uint8_t rx_fifo_number; /* Receive FIFO number. */
} can_receive_message_struct;
 
void can_configure_default( can_config_t *config );
 
void can_filter_configure_default( can_filter_config_t *filter_config );
 
err_t can_open( can_t *obj, can_config_t *config );
 
err_t can_init( can_t *obj );
 
err_t can_set_filter( can_t *obj, can_filter_config_t *filter_config );
 
err_t can_set_frequency( can_t *obj, uint32_t frequency );
 
err_t can_get_frequency( can_t *obj );
 
err_t can_set_mode( can_t *obj, can_mode_t mode );
 
err_t can_get_mode( can_t *obj );
 
err_t can_transmit( can_t *obj, can_transmit_message_struct *transmit_message );
 
void can_transmission_stop( can_t *obj );
 
err_t can_receive( can_t *obj, can_receive_message_struct *receive_message );
 
err_t can_close( can_t *obj );
 
 // drvcangroup
 // drvgroup
 // pergroup
 
#ifdef __cplusplus
}
#endif
 
#endif // _DRV_CAN_H_
// ------------------------------------------------------------------------- END