hal_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 _HAL_CAN_H_
#define _HAL_CAN_H_
 
#ifdef __cplusplus
extern "C"{
#endif
 
#include "hal_target.h"
 
typedef struct
{
    handle_t *hal_can_handle; 
    handle_t *drv_can_handle; 
    bool init_state;          
} hal_can_handle_register_t;
 
typedef enum
{
    HAL_CAN_SUCCESS = 0,  
    HAL_CAN_WRONG_PINS,   
    HAL_CAN_MODULE_ERROR, 
    HAL_CAN_ERROR = (-1)  
} hal_can_err_t;
 
typedef enum
{
    /* Universal Modes. */
    HAL_CAN_MODE_NORMAL = 0,        
    HAL_CAN_MODE_LOOPBACK,          
    HAL_CAN_MODE_DISABLE,           
    /* STM32 and RISC-V Modes. */
    HAL_CAN_MODE_SILENT,            
    HAL_CAN_MODE_LOOPBACK_SILENT,   
    /* NXP Modes. */
    HAL_CAN_MODE_LISTENONLY,        
    HAL_CAN_MODE_DOZE,              
    HAL_CAN_MODE_STOP,              
    HAL_CAN_MODE_FREEZE,            
    /* dsPIC Modes.*/
    HAL_CAN_MODE_LISTENALL,         
    /* PIC/PIC32 Modes. */
    HAL_CAN_MODE_CONFIGURATION      
} hal_can_mode_t;
 
typedef enum
{
    HAL_CAN_STATE_RESET = 0,    
    HAL_CAN_STATE_READY,        
    HAL_CAN_STATE_LISTENING,    
    HAL_CAN_STATE_ERROR         
} hal_can_state_t;
 
typedef enum
{
    HAL_CAN_FRAME_FORMAT_STANDARD_11BITS = 0,  
    HAL_CAN_FRAME_FORMAT_EXTENDED_29BITS       
} hal_can_frame_format_t;
 
typedef enum
{
    HAL_CAN_FRAME_TYPE_DATA = 0,  
    HAL_CAN_FRAME_TYPE_RTR        
} hal_can_frame_type_t;
 
typedef enum
{
    HAL_CAN_FILTER_MODE_IDMASK = 0,  
    HAL_CAN_FILTER_MODE_IDLIST       
} hal_can_filter_mode_t;
 
typedef enum
{
    HAL_CAN_FILTER_SCALE_16BIT = 0,  
    HAL_CAN_FILTER_SCALE_32BIT       
} hal_can_filter_scale_t;
 
typedef enum
{
    HAL_CAN_FILTER_FIFO0 = 0,   
    HAL_CAN_FILTER_FIFO1,       
    HAL_CAN_FILTER_FIFO2,       
    HAL_CAN_FILTER_FIFO3,       
    HAL_CAN_FILTER_FIFO4,       
    HAL_CAN_FILTER_FIFO5,       
    HAL_CAN_FILTER_FIFO6,       
    HAL_CAN_FILTER_FIFO7,       
    HAL_CAN_FILTER_FIFO8,       
    HAL_CAN_FILTER_FIFO9,       
    HAL_CAN_FILTER_FIFO10,      
    HAL_CAN_FILTER_FIFO11,      
    HAL_CAN_FILTER_FIFO12,      
    HAL_CAN_FILTER_FIFO13,      
    HAL_CAN_FILTER_FIFO14,      
    HAL_CAN_FILTER_FIFO15,      
    HAL_CAN_FILTER_FIFO16,      
    HAL_CAN_FILTER_FIFO17,      
    HAL_CAN_FILTER_FIFO18,      
    HAL_CAN_FILTER_FIFO19,      
    HAL_CAN_FILTER_FIFO20,      
    HAL_CAN_FILTER_FIFO21,      
    HAL_CAN_FILTER_FIFO22,      
    HAL_CAN_FILTER_FIFO23,      
    HAL_CAN_FILTER_FIFO24,      
    HAL_CAN_FILTER_FIFO25,      
    HAL_CAN_FILTER_FIFO26,      
    HAL_CAN_FILTER_FIFO27,      
    HAL_CAN_FILTER_FIFO28,      
    HAL_CAN_FILTER_FIFO29,      
    HAL_CAN_FILTER_FIFO30,      
    HAL_CAN_FILTER_FIFO31       
} hal_can_filter_fifo_t;
 
typedef enum
{
    HAL_CAN_FILTER_DISABLE = 0,  
    HAL_CAN_FILTER_ENABLE        
} hal_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;                        
    hal_can_frame_type_t can_filter_frame_type[4];  
    hal_can_filter_activation_t can_filter_enable;  
    hal_can_filter_mode_t can_filter_mode;          
    hal_can_filter_scale_t can_filter_scale;        
    hal_can_filter_fifo_t can_filter_fifo;          
} hal_can_filter_config_t;
 
typedef struct
{
    hal_pin_name_t tx_pin;  
    hal_pin_name_t rx_pin;  
    hal_can_mode_t mode;    
    uint32_t frequency;     
} hal_can_config_t;
 
typedef struct
{
    handle_t handle;                       
    hal_can_config_t config;               
    hal_can_filter_config_t filter_config; 
} hal_can_t;
 
typedef struct
{
    union {
        struct {
            uint16_t std_id;                          
            uint16_t ext_id;                          
        };
        uint32_t id;
    };
    hal_can_frame_format_t frame_format;   
    hal_can_frame_type_t frame_type;       
    uint8_t data_len;                      
    uint8_t message_data[8];               
} hal_can_message_t;
 
typedef struct
{
    hal_can_message_t message;  /* CAN message structure. */
} hal_can_transmit_message_struct;
 
typedef struct
{
    hal_can_message_t message;  /* CAN message structure. */
    uint8_t rx_fifo_number;     /* Receive FIFO number. */
} hal_can_receive_message_struct;
 
void hal_can_configure_default( hal_can_config_t *config );
 
void hal_can_filter_configure_default( hal_can_filter_config_t *filter_config );
 
err_t hal_can_open( handle_t *handle, bool hal_obj_open_state );
 
err_t hal_can_init( handle_t *handle, hal_can_config_t *config, hal_can_filter_config_t *filter_config );
 
err_t hal_can_set_filter( handle_t *handle, hal_can_config_t *config, hal_can_filter_config_t *filter_config );
 
err_t hal_can_set_frequency( handle_t *handle, hal_can_config_t *config, hal_can_filter_config_t *filter_config );
 
err_t hal_can_get_frequency( handle_t *handle );
 
err_t hal_can_set_mode( handle_t *handle, hal_can_config_t *config, hal_can_filter_config_t *filter_config );
 
err_t hal_can_get_mode( handle_t *handle );
 
err_t hal_can_transmit( handle_t *handle, hal_can_transmit_message_struct *transmit_message );
 
void hal_can_transmission_stop( handle_t *handle );
 
err_t hal_can_receive( handle_t *handle, hal_can_receive_message_struct *receive_message );
 
err_t hal_can_close( handle_t *handle );
 
 
 // halcangroup
 // halgroup
 // pergroup
 
#ifdef __cplusplus
}
#endif
 
#endif // _HAL_CAN_H_
// ------------------------------------------------------------------------- END