docs/hal_html/hal__can_8h_source.html

#ifndef HAL_CAN_H

#define HAL_CAN_H


#ifdef __cplusplus

extern "C" {

#endif


#include "hal_common.h"


#define HAL_CAN_DRIVER_VERSION (MAKE_VERSION(1, 1, 0))


typedef enum _can_status {

    CAN_Status_Ok              = 0U,

    CAN_Status_Fail            = 1U,

    CAN_Status_InvalidArgument = 2U,

    CAN_Status_TxBusy          = 3U,

    CAN_Status_RxEmpty         = 4U,

    CAN_Status_TxIdle          = 5U,

    CAN_Status_RxIdle          = 6U,

    CAN_Status_RxBusy          = 7U,

} can_status_t;


typedef enum _can_kind_of_error {

    CAN_ErrorNone       = 0U,

    CAN_ErrorBitError   = 1U,

    CAN_ErrorFormError  = 2U,

    CAN_ErrorStuffError = 3U,

    CAN_ErrorAckError   = 4U,

    CAN_ErrorCrcError   = 5U,

    CAN_ErrorOtherError = 6U,

    CAN_ErrorReserved   = 7U,

} can_kind_of_error_t;


typedef enum _can_flag {

    CAN_FlagAbortState            =  0U,

    CAN_FlagError                 =  1U,

    CAN_FlagTransmissionSecondary =  2U,

    CAN_FlagTransmissionPrimary   =  3U,

    CAN_FlagTransmitBufferFull    =  4U,

    CAN_FlagRBAlmostFull          =  5U,

    CAN_FlagRBFull                =  6U,

    CAN_FlagRBOverrun             =  7U,

    CAN_FlagReceive               =  8U,

    CAN_FlagBusError              =  9U,

    CAN_FlagArbitrationLost       = 10U,

    CAN_FlagErrorPassiveInterrupt = 11U,

    CAN_FlagErrorPassiveState     = 12U,

    CAN_FlagErrorWarningState     = 13U,

    CAN_FlagTimeTriggered         = 14U,

    CAN_FlagTriggerError          = 15U,

    CAN_FlagWatchTriggerError     = 16U,

    CAN_FlagsNumber

} can_flag_t;


typedef enum _canfd_mode {

    CAN_BoschFd = 0U,

    CAN_IsoFd   = 1U,

} canfd_mode_t;


typedef enum _can_stb_discipline {

    CAN_Fifo     = 0U,

    CAN_Priority = 1U,

} can_stb_discipline_t;


typedef enum _can_bytes_in_datafield {

    CAN_0ByteDatafield  =  0U,

    CAN_1ByteDatafield  =  1U,

    CAN_2ByteDatafield  =  2U,

    CAN_3ByteDatafield  =  3U,

    CAN_4ByteDatafield  =  4U,

    CAN_5ByteDatafield  =  5U,

    CAN_6ByteDatafield  =  6U,

    CAN_7ByteDatafield  =  7U,

    CAN_8ByteDatafield  =  8U,

    CAN_12ByteDatafield =  9U,

    CAN_16ByteDatafield = 10U,

    CAN_20ByteDatafield = 11U,

    CAN_24ByteDatafield = 12U,

    CAN_32ByteDatafield = 13U,

    CAN_48ByteDatafield = 14U,

    CAN_64ByteDatafield = 15U,

} can_bytes_in_datafield_t;


#if defined(__CC_ARM)

#pragma anon_unions

#endif


typedef struct _can_tx_buffer_frame {

    struct {

        uint32_t                 id    : 29;

        uint32_t                       :  2;

        bool                     ttsen :  1;

    };

    struct {

        can_bytes_in_datafield_t dlc   :  4;

        bool                     brs   :  1;

        bool                     fdf   :  1;

        bool                     rtr   :  1;

        bool                     ide   :  1;

        uint32_t                       : 24;

    };

    uint8_t                      data[64];

} can_tx_buffer_frame_t;


typedef struct _can_rx_buffer_frame {

    struct {

        uint32_t                 id         : 29;

        uint32_t                            :  2;

        bool                     esi        :  1;

    };

    struct {

        can_bytes_in_datafield_t dlc        :  4;

        bool                     brs        :  1;

        bool                     fdf        :  1;

        bool                     rtr        :  1;

        bool                     ide        :  1;

        uint32_t                            :  4;

        bool                     tx         :  1;

        can_kind_of_error_t      koer       :  3;

        uint32_t                 cycle_time : 16;

    };

    uint8_t                      data[64];

    uint64_t                     rts;

} can_rx_buffer_frame_t;


typedef struct _can_frame_filter {

    uint32_t id               : 29;

    uint32_t                  :  3;

    uint32_t mask             : 29;

    uint32_t accepted_ide     :  1;

    uint32_t enable_ide_check :  1;

    uint32_t                  :  1;

} can_frame_filter_t;


#define CAN_NB_OF_FILTERS 4


typedef struct _can_frame_filter_config {

    can_frame_filter_t filter[CAN_NB_OF_FILTERS];

    uint8_t            nb_filters_used;

} can_frame_filter_config_t;


typedef enum _ttcan_timer_prescaler {

    CAN_TTCANDiv1 = 0U,

    CAN_TTCANDiv2 = 1U,

    CAN_TTCANDiv4 = 2U,

    CAN_TTCANDiv8 = 3U,

} ttcan_timer_prescaler_t;


typedef enum _ttcan_trigger_type {

    CAN_TriggerImmediate          = 0U,

    CAN_TriggerTime               = 1U,

    CAN_TriggerSingleShotTransmit = 2U,

    CAN_TriggerTransmitStart      = 3U,

    CAN_TriggerTransmitStop       = 4U,

} ttcan_trigger_type_t;


typedef struct _ttcan_config {

    ttcan_timer_prescaler_t prescaler;

    uint8_t                 transmit_trigger_pointer;

    ttcan_trigger_type_t    trigger_type;

    uint8_t                 transmit_enable_window;

    uint8_t                 trigger_time0;

    uint8_t                 trigger_time1;

    uint8_t                 watch_trigger_time0;

    uint8_t                 watch_trigger_time1;

    uint32_t                reference_id;

    bool                    reference_ide;

} ttcan_config_t;


typedef struct _can_timing_config {

    uint8_t prescaler;

    uint8_t sjw;

    uint8_t seg1;

    uint8_t seg2;

    uint8_t data_prescaler;

    uint8_t data_sjw;

    uint8_t data_seg1;

    uint8_t data_seg2;

    uint8_t delay_compensation_enable;

    uint8_t secondary_sample_point_offset;

} can_timing_config_t;


typedef struct _can_ptb_config {

    bool tx_single_shot;

} can_ptb_config_t;


typedef struct _can_stb_config {

    bool                 tx_single_shot;

    can_stb_discipline_t tx_discipline;

} can_stb_config_t;


typedef struct _can_rxb_config {

    uint32_t almost_full_level;

    bool     self_acknowledge;

    bool     prohibit_overflow;

} can_rxb_config_t;


typedef struct _can_config {

    bool                      enable_listen_only;

    bool                      enable_loopback_int;

    bool                      enable_loopback_ext;

    can_ptb_config_t          ptb_config;

    can_stb_config_t          stb_config;

    can_rxb_config_t          rxb_config;

    can_timing_config_t       timing_config;

    canfd_mode_t              can_fd_mode;

    can_frame_filter_config_t filter_config;

} can_config_t;


typedef struct _can_tx_transfer {

    can_tx_buffer_frame_t   *frames;

    size_t                  nb_frames;

} can_tx_transfer_t;


typedef struct _can_rx_transfer {

    can_rx_buffer_frame_t   *frames;

    size_t                  nb_frames;

} can_rx_transfer_t;


typedef struct _can_handle can_handle_t;


typedef void (*can_transfer_callback_t)(CAN_Type *base, can_handle_t *handle,

    can_status_t status, can_flag_t interrupt_flag, void *user_data);


struct _can_handle {

    volatile const can_tx_buffer_frame_t *tx_frames_prim;

    volatile size_t                      tx_nb_frames_rest_prim;

    size_t                               tx_nb_frames_all_prim;

    volatile const can_tx_buffer_frame_t *tx_frames_sec;

    volatile size_t                      tx_nb_frames_rest_sec;

    size_t                               tx_nb_frames_all_sec;

    volatile can_rx_buffer_frame_t       *rx_frames;

    volatile size_t                      rx_nb_frames_rest;

    size_t                               rx_nb_frames_all;

    can_transfer_callback_t              callback;

    void                                 *user_data;

};


can_status_t CAN_Init(CAN_Type *base, const can_config_t *config);


void CAN_Deinit(CAN_Type *base);


void CAN_GetDefaultConfig(can_config_t *config, uint32_t source_clock_hz);


void CAN_EnterNormalMode(CAN_Type *base);


void CAN_EnterStandbyMode(CAN_Type *base);


bool CAN_CalculateImprovedTimingValues(uint32_t baudrate,

    uint32_t baudrate_data, uint32_t source_clock_hz,

    can_timing_config_t *pconfig);


void CAN_SetArbitrationTimingConfig(CAN_Type *base,

    const can_timing_config_t *config);


void CAN_SetPrimaryTxBufferConfig(CAN_Type *base,

    const can_ptb_config_t *config);


void CAN_SetSecondaryTxBufferConfig(CAN_Type *base,

    const can_stb_config_t *config);


void CAN_SetRxBufferConfig(CAN_Type *base, const can_rxb_config_t *config);


void CAN_SetFilterConfig(CAN_Type *base,

    const can_frame_filter_config_t *config);


void CAN_SetTTCANConfig(CAN_Type *base, const ttcan_config_t *config);


bool CAN_GetStatusFlag(CAN_Type *base, can_flag_t idx, can_status_t *status);


uint32_t CAN_GetStatusFlagMask(CAN_Type *base);


can_status_t CAN_ClearStatusFlag(CAN_Type *base, can_flag_t idx);


void CAN_ClearStatusFlagMask(CAN_Type *base, uint32_t mask);


can_status_t CAN_EnableInterrupt(CAN_Type *base, can_flag_t idx);


void CAN_EnableInterruptMask(CAN_Type *base, uint32_t mask);


bool CAN_IsInterruptEnabled(CAN_Type *base, can_flag_t idx,

    can_status_t *status);


uint32_t CAN_GetEnabledInterruptMask(CAN_Type *base);


can_status_t CAN_DisableInterrupt(CAN_Type *base, can_flag_t idx);


void CAN_DisableInterruptMask(CAN_Type *base, uint32_t mask);


bool CAN_IsPrimaryTransmitRequestPending(CAN_Type *base);


bool CAN_IsSecondaryTransmitRequestPending(CAN_Type *base);


bool CAN_IsSecondaryTxBufferEmpty(CAN_Type *base);


bool CAN_IsSecondaryTxBufferMoreThanHalfFull(CAN_Type *base);


bool CAN_IsSecondaryTxBufferFull(CAN_Type *base);


can_status_t CAN_WritePrimaryTxBuffer(CAN_Type *base,

    const can_tx_buffer_frame_t *ptxframe);


can_status_t CAN_WriteSecondaryTxBuffer(CAN_Type *base,

    const can_tx_buffer_frame_t *ptxframe);


void CAN_AbortPrimaryTxBuffer(CAN_Type *base);


void CAN_AbortSecondaryTxBuffer(CAN_Type *base);


bool CAN_IsRxBufferEmpty(CAN_Type *base);


bool CAN_IsRxBufferAlmostFull(CAN_Type *base);


bool CAN_IsRxBufferFull(CAN_Type *base);


can_status_t CAN_ReadRxBuffer(CAN_Type *base, can_rx_buffer_frame_t *prxframe);


can_status_t CAN_TransferSendPrimaryBlocking(CAN_Type *base,

    can_tx_buffer_frame_t *ptxframe, size_t nb_frames);


can_status_t CAN_TransferSendSecondaryBlocking(CAN_Type *base,

    can_tx_buffer_frame_t *ptxframe, size_t nb_frames);


can_status_t CAN_TransferReceiveFifoBlocking(CAN_Type *base,

    can_rx_buffer_frame_t *prxframe, size_t nb_frames);


can_status_t CAN_TransferCreateHandle(CAN_Type *base, can_handle_t *handle,

    can_transfer_callback_t callback, void *user_data);


can_status_t CAN_TransferSendPrimaryNonBlocking(CAN_Type *base,

    can_handle_t *handle, can_tx_transfer_t *xfer);


can_status_t CAN_TransferGetSentPrimaryCount(CAN_Type *base,

    can_handle_t *handle, uint32_t *nb_frames);


void CAN_TransferAbortSendPrimary(CAN_Type *base, can_handle_t *handle);


can_status_t CAN_TransferSendSecondaryNonBlocking(CAN_Type *base,

    can_handle_t *handle, can_tx_transfer_t *xfer);


can_status_t CAN_TransferGetSentSecondaryCount(CAN_Type *base,

    can_handle_t *handle, uint32_t *nb_frames);


void CAN_TransferAbortSendSecondary(CAN_Type *base, can_handle_t *handle);


can_status_t CAN_TransferReceiveFifoNonBlocking(CAN_Type *base,

    can_handle_t *handle, can_rx_transfer_t *xfer);


can_status_t CAN_TransferGetReceivedCount(CAN_Type *base,

    can_handle_t *handle, uint32_t *nb_frames);


void CAN_TransferAbortReceive(CAN_Type *base, can_handle_t *handle);


void CAN_TransferHandleIRQ(CAN_Type *base, can_handle_t *handle);


#ifdef __cplusplus

}

#endif


#endif /* HAL_CAN_H */


CAN_IsPrimaryTransmitRequestPending
bool CAN_IsPrimaryTransmitRequestPending(CAN_Type *base)
Получение признака требования выдачи для высокоприоритетного буфера

_canfd_mode
_canfd_mode
Режимы работы по протоколу CAN FD (есть отличия в расчете контрольной суммы и формировании битов стаф...
Definition hal_can.h:100

_can_bytes_in_datafield
_can_bytes_in_datafield
Размер данных кадра CAN, указываемый в поле DLC.
Definition hal_can.h:116

CAN_TransferHandleIRQ
void CAN_TransferHandleIRQ(CAN_Type *base, can_handle_t *handle)
Установка обработчика на прерывания от CAN, не связанные с приемом/выдачей

CAN_TransferReceiveFifoBlocking
can_status_t CAN_TransferReceiveFifoBlocking(CAN_Type *base, can_rx_buffer_frame_t *prxframe, size_t nb_frames)
Блокирующий прием кадра

CAN_TransferGetReceivedCount
can_status_t CAN_TransferGetReceivedCount(CAN_Type *base, can_handle_t *handle, uint32_t *nb_frames)
Возвращает количество принятых кадров по прерыванию

ttcan_trigger_type_t
enum _ttcan_trigger_type ttcan_trigger_type_t
Тип триггера TTCAN.

CAN_EnableInterruptMask
void CAN_EnableInterruptMask(CAN_Type *base, uint32_t mask)
Разрешение прерываний по маске

can_transfer_callback_t
void(* can_transfer_callback_t)(CAN_Type *base, can_handle_t *handle, can_status_t status, can_flag_t interrupt_flag, void *user_data)
Функция обратного вызова CAN.
Definition hal_can.h:325

can_bytes_in_datafield_t
enum _can_bytes_in_datafield can_bytes_in_datafield_t
Размер данных кадра CAN, указываемый в поле DLC.

CAN_SetRxBufferConfig
void CAN_SetRxBufferConfig(CAN_Type *base, const can_rxb_config_t *config)
Установка параметров буфера приема

CAN_EnterStandbyMode
void CAN_EnterStandbyMode(CAN_Type *base)
Переключение контроллера CAN в режим ожидания

CAN_ClearStatusFlagMask
void CAN_ClearStatusFlagMask(CAN_Type *base, uint32_t mask)
Сброс флагов прерываний по маске

CAN_DisableInterruptMask
void CAN_DisableInterruptMask(CAN_Type *base, uint32_t mask)
Запрет прерываний по маске

can_frame_filter_config_t
struct _can_frame_filter_config can_frame_filter_config_t
Конфигурация фильтрации принятых кадров CAN.

CAN_EnterNormalMode
void CAN_EnterNormalMode(CAN_Type *base)
Переключение контроллера CAN в рабочий режим

CAN_IsSecondaryTransmitRequestPending
bool CAN_IsSecondaryTransmitRequestPending(CAN_Type *base)
Получение признака требования выдачи для низкоприоритетного буфера

_ttcan_timer_prescaler
_ttcan_timer_prescaler
Символьные константы значений делителя блока TTCAN.
Definition hal_can.h:211

CAN_TransferGetSentPrimaryCount
can_status_t CAN_TransferGetSentPrimaryCount(CAN_Type *base, can_handle_t *handle, uint32_t *nb_frames)
Возвращает количество кадров, отправленных в шину данных через высокоприоритетный буфер

CAN_AbortSecondaryTxBuffer
void CAN_AbortSecondaryTxBuffer(CAN_Type *base)
Отмена выдачи кадров из низкоприоритетного буфера

CAN_IsRxBufferEmpty
bool CAN_IsRxBufferEmpty(CAN_Type *base)
Получение признака опустошения буфера приема

ttcan_timer_prescaler_t
enum _ttcan_timer_prescaler ttcan_timer_prescaler_t
Символьные константы значений делителя блока TTCAN.

can_config_t
struct _can_config can_config_t
Структура конфигурации контроллера CAN.

CAN_WritePrimaryTxBuffer
can_status_t CAN_WritePrimaryTxBuffer(CAN_Type *base, const can_tx_buffer_frame_t *ptxframe)
Запись кадра в высокоприоритетный буфер передачи.

_can_stb_discipline
_can_stb_discipline
Дисциплина выдачи из низкоприоритетного буфера
Definition hal_can.h:108

CAN_NB_OF_FILTERS
#define CAN_NB_OF_FILTERS
Количество входных фильтров CAN.
Definition hal_can.h:198

CAN_IsRxBufferAlmostFull
bool CAN_IsRxBufferAlmostFull(CAN_Type *base)
Получение признака заполнения буфера приема до границы "почти полный".

can_ptb_config_t
struct _can_ptb_config can_ptb_config_t
Параметры высокоприоритетного буфера выдачи

CAN_TransferGetSentSecondaryCount
can_status_t CAN_TransferGetSentSecondaryCount(CAN_Type *base, can_handle_t *handle, uint32_t *nb_frames)
Возвращает количество кадров, отправленных в шину данных через низкоприоритетный буфер

CAN_TransferAbortReceive
void CAN_TransferAbortReceive(CAN_Type *base, can_handle_t *handle)
Отмена приема

CAN_GetDefaultConfig
void CAN_GetDefaultConfig(can_config_t *config, uint32_t source_clock_hz)
Получение параметров драйвера CAN по умолчанию

CAN_SetSecondaryTxBufferConfig
void CAN_SetSecondaryTxBufferConfig(CAN_Type *base, const can_stb_config_t *config)
Установка параметров низкоприоритетного буфера выдачи

CAN_TransferCreateHandle
can_status_t CAN_TransferCreateHandle(CAN_Type *base, can_handle_t *handle, can_transfer_callback_t callback, void *user_data)
Инициализация обработчика событий CAN.

CAN_ReadRxBuffer
can_status_t CAN_ReadRxBuffer(CAN_Type *base, can_rx_buffer_frame_t *prxframe)
Чтение принятого кадра из приемной очереди

CAN_GetEnabledInterruptMask
uint32_t CAN_GetEnabledInterruptMask(CAN_Type *base)
Запрос маски разрешенных прерываний CAN.

CAN_AbortPrimaryTxBuffer
void CAN_AbortPrimaryTxBuffer(CAN_Type *base)
Отмена выдачи кадра из высокоприоритетного буфера

CAN_SetArbitrationTimingConfig
void CAN_SetArbitrationTimingConfig(CAN_Type *base, const can_timing_config_t *config)
Установка временных параметров (битовых таймингов) CAN.

CAN_IsInterruptEnabled
bool CAN_IsInterruptEnabled(CAN_Type *base, can_flag_t idx, can_status_t *status)
Запрос - разрешено ли прерывание CAN.

_can_kind_of_error
_can_kind_of_error
Виды ошибок на линии CAN.
Definition hal_can.h:55

can_timing_config_t
struct _can_timing_config can_timing_config_t
Временные параметры передачи битов CAN.

ttcan_config_t
struct _ttcan_config ttcan_config_t
Временные параметры передачи битов CAN.

CAN_GetStatusFlag
bool CAN_GetStatusFlag(CAN_Type *base, can_flag_t idx, can_status_t *status)
Получение состояния флага состояния/прерывания

CAN_SetPrimaryTxBufferConfig
void CAN_SetPrimaryTxBufferConfig(CAN_Type *base, const can_ptb_config_t *config)
Установка параметров высокоприоритетного буфера выдачи

CAN_IsRxBufferFull
bool CAN_IsRxBufferFull(CAN_Type *base)
Получение признака заполнения буфера приема

CAN_SetFilterConfig
void CAN_SetFilterConfig(CAN_Type *base, const can_frame_filter_config_t *config)
Установка параметров фильтрации кадров при приеме

can_frame_filter_t
struct _can_frame_filter can_frame_filter_t
Фильтр принятых кадров CAN.

CAN_SetTTCANConfig
void CAN_SetTTCANConfig(CAN_Type *base, const ttcan_config_t *config)
Установка параметров работы контроллера в режиме TTCAN.

CAN_TransferReceiveFifoNonBlocking
can_status_t CAN_TransferReceiveFifoNonBlocking(CAN_Type *base, can_handle_t *handle, can_rx_transfer_t *xfer)
Неблокирующий прием

CAN_ClearStatusFlag
can_status_t CAN_ClearStatusFlag(CAN_Type *base, can_flag_t idx)
Сброс флага состояния/прерывания

CAN_GetStatusFlagMask
uint32_t CAN_GetStatusFlagMask(CAN_Type *base)
Получение маски активных прерываний

CAN_IsSecondaryTxBufferEmpty
bool CAN_IsSecondaryTxBufferEmpty(CAN_Type *base)
Получение признака опустошения низкоприоритетного буфера

_ttcan_trigger_type
_ttcan_trigger_type
Тип триггера TTCAN.
Definition hal_can.h:221

CAN_TransferSendSecondaryBlocking
can_status_t CAN_TransferSendSecondaryBlocking(CAN_Type *base, can_tx_buffer_frame_t *ptxframe, size_t nb_frames)
Блокирующая выдача кадра через низкоприоритетный буфер выдачи

CAN_Deinit
void CAN_Deinit(CAN_Type *base)
Деинициализация драйвера CAN.

can_stb_discipline_t
enum _can_stb_discipline can_stb_discipline_t
Дисциплина выдачи из низкоприоритетного буфера

CAN_TransferAbortSendSecondary
void CAN_TransferAbortSendSecondary(CAN_Type *base, can_handle_t *handle)
Отмена выдачи из низкоприоритетного буфера

CAN_IsSecondaryTxBufferMoreThanHalfFull
bool CAN_IsSecondaryTxBufferMoreThanHalfFull(CAN_Type *base)
Получение признака заполнения низкоприоритетного буфера выше середины

can_stb_config_t
struct _can_stb_config can_stb_config_t
Параметры низкоприоритетного буфера выдачи

canfd_mode_t
enum _canfd_mode canfd_mode_t
Режимы работы по протоколу CAN FD (есть отличия в расчете контрольной суммы и формировании битов стаф...

CAN_EnableInterrupt
can_status_t CAN_EnableInterrupt(CAN_Type *base, can_flag_t idx)
Разрешение прерывания

CAN_IsSecondaryTxBufferFull
bool CAN_IsSecondaryTxBufferFull(CAN_Type *base)
Получение признака заполнения низкоприоритетного буфера.

can_kind_of_error_t
enum _can_kind_of_error can_kind_of_error_t
Виды ошибок на линии CAN.

CAN_CalculateImprovedTimingValues
bool CAN_CalculateImprovedTimingValues(uint32_t baudrate, uint32_t baudrate_data, uint32_t source_clock_hz, can_timing_config_t *pconfig)
Расчет рекомендуемых временных параметров (битовых таймингов) для указанных скоростей обмена в сегмен...

can_status_t
enum _can_status can_status_t
Коды возврата функций драйвера CAN.

CAN_DisableInterrupt
can_status_t CAN_DisableInterrupt(CAN_Type *base, can_flag_t idx)
Запрет прерывания

CAN_TransferSendSecondaryNonBlocking
can_status_t CAN_TransferSendSecondaryNonBlocking(CAN_Type *base, can_handle_t *handle, can_tx_transfer_t *xfer)
Неблокирующая выдача через низкоприоритетный буфер

can_rx_buffer_frame_t
struct _can_rx_buffer_frame can_rx_buffer_frame_t
Структура буфера приема кадра CAN.

can_flag_t
enum _can_flag can_flag_t
Флаги прерываний и состояний CAN.

can_rx_transfer_t
struct _can_rx_transfer can_rx_transfer_t
Структура для приема кадра CAN в неблокирующем режиме (по прерыванию)

can_tx_buffer_frame_t
struct _can_tx_buffer_frame can_tx_buffer_frame_t
Структура буфера передачи кадра CAN.

CAN_Init
can_status_t CAN_Init(CAN_Type *base, const can_config_t *config)
Инициализация драйвера CAN.

CAN_TransferSendPrimaryBlocking
can_status_t CAN_TransferSendPrimaryBlocking(CAN_Type *base, can_tx_buffer_frame_t *ptxframe, size_t nb_frames)
Блокирующая выдача кадра через высокоприоритетный буфер выдачи

_can_flag
_can_flag
Флаги прерываний и состояний CAN.
Definition hal_can.h:75

CAN_TransferAbortSendPrimary
void CAN_TransferAbortSendPrimary(CAN_Type *base, can_handle_t *handle)
Отмена выдачи из высокоприоритетного буфера

CAN_TransferSendPrimaryNonBlocking
can_status_t CAN_TransferSendPrimaryNonBlocking(CAN_Type *base, can_handle_t *handle, can_tx_transfer_t *xfer)
Неблокирующая выдача через высокоприоритетный буфер

CAN_WriteSecondaryTxBuffer
can_status_t CAN_WriteSecondaryTxBuffer(CAN_Type *base, const can_tx_buffer_frame_t *ptxframe)
Запись кадра в низкоприоритетный буфер передачи

_can_status
_can_status
Коды возврата функций драйвера CAN.
Definition hal_can.h:37

can_rxb_config_t
struct _can_rxb_config can_rxb_config_t
Параметры буфера приема

can_tx_transfer_t
struct _can_tx_transfer can_tx_transfer_t
Структура для передачи кадра CAN в неблокирующем режиме (по прерыванию)

CAN_IsoFd
@ CAN_IsoFd
Definition hal_can.h:102

CAN_BoschFd
@ CAN_BoschFd
Definition hal_can.h:101

CAN_24ByteDatafield
@ CAN_24ByteDatafield
Definition hal_can.h:129

CAN_2ByteDatafield
@ CAN_2ByteDatafield
Definition hal_can.h:119

CAN_3ByteDatafield
@ CAN_3ByteDatafield
Definition hal_can.h:120

CAN_16ByteDatafield
@ CAN_16ByteDatafield
Definition hal_can.h:127

CAN_4ByteDatafield
@ CAN_4ByteDatafield
Definition hal_can.h:121

CAN_5ByteDatafield
@ CAN_5ByteDatafield
Definition hal_can.h:122

CAN_7ByteDatafield
@ CAN_7ByteDatafield
Definition hal_can.h:124

CAN_48ByteDatafield
@ CAN_48ByteDatafield
Definition hal_can.h:131

CAN_8ByteDatafield
@ CAN_8ByteDatafield
Definition hal_can.h:125

CAN_6ByteDatafield
@ CAN_6ByteDatafield
Definition hal_can.h:123

CAN_20ByteDatafield
@ CAN_20ByteDatafield
Definition hal_can.h:128

CAN_32ByteDatafield
@ CAN_32ByteDatafield
Definition hal_can.h:130

CAN_64ByteDatafield
@ CAN_64ByteDatafield
Definition hal_can.h:132

CAN_1ByteDatafield
@ CAN_1ByteDatafield
Definition hal_can.h:118

CAN_12ByteDatafield
@ CAN_12ByteDatafield
Definition hal_can.h:126

CAN_0ByteDatafield
@ CAN_0ByteDatafield
Definition hal_can.h:117

CAN_TTCANDiv4
@ CAN_TTCANDiv4
Definition hal_can.h:214

CAN_TTCANDiv1
@ CAN_TTCANDiv1
Definition hal_can.h:212

CAN_TTCANDiv8
@ CAN_TTCANDiv8
Definition hal_can.h:215

CAN_TTCANDiv2
@ CAN_TTCANDiv2
Definition hal_can.h:213

CAN_Fifo
@ CAN_Fifo
Definition hal_can.h:109

CAN_Priority
@ CAN_Priority
Definition hal_can.h:110

CAN_ErrorCrcError
@ CAN_ErrorCrcError
Definition hal_can.h:61

CAN_ErrorFormError
@ CAN_ErrorFormError
Definition hal_can.h:58

CAN_ErrorBitError
@ CAN_ErrorBitError
Definition hal_can.h:57

CAN_ErrorAckError
@ CAN_ErrorAckError
Definition hal_can.h:60

CAN_ErrorNone
@ CAN_ErrorNone
Definition hal_can.h:56

CAN_ErrorOtherError
@ CAN_ErrorOtherError
Definition hal_can.h:62

CAN_ErrorReserved
@ CAN_ErrorReserved
Definition hal_can.h:63

CAN_ErrorStuffError
@ CAN_ErrorStuffError
Definition hal_can.h:59

CAN_TriggerTime
@ CAN_TriggerTime
Definition hal_can.h:223

CAN_TriggerTransmitStop
@ CAN_TriggerTransmitStop
Definition hal_can.h:226

CAN_TriggerImmediate
@ CAN_TriggerImmediate
Definition hal_can.h:222

CAN_TriggerSingleShotTransmit
@ CAN_TriggerSingleShotTransmit
Definition hal_can.h:224

CAN_TriggerTransmitStart
@ CAN_TriggerTransmitStart
Definition hal_can.h:225

CAN_FlagTransmitBufferFull
@ CAN_FlagTransmitBufferFull
Definition hal_can.h:80

CAN_FlagsNumber
@ CAN_FlagsNumber
Definition hal_can.h:93

CAN_FlagTimeTriggered
@ CAN_FlagTimeTriggered
Definition hal_can.h:90

CAN_FlagError
@ CAN_FlagError
Definition hal_can.h:77

CAN_FlagRBOverrun
@ CAN_FlagRBOverrun
Definition hal_can.h:83

CAN_FlagAbortState
@ CAN_FlagAbortState
Definition hal_can.h:76

CAN_FlagTransmissionPrimary
@ CAN_FlagTransmissionPrimary
Definition hal_can.h:79

CAN_FlagErrorPassiveInterrupt
@ CAN_FlagErrorPassiveInterrupt
Definition hal_can.h:87

CAN_FlagReceive
@ CAN_FlagReceive
Definition hal_can.h:84

CAN_FlagWatchTriggerError
@ CAN_FlagWatchTriggerError
Definition hal_can.h:92

CAN_FlagRBAlmostFull
@ CAN_FlagRBAlmostFull
Definition hal_can.h:81

CAN_FlagTransmissionSecondary
@ CAN_FlagTransmissionSecondary
Definition hal_can.h:78

CAN_FlagArbitrationLost
@ CAN_FlagArbitrationLost
Definition hal_can.h:86

CAN_FlagRBFull
@ CAN_FlagRBFull
Definition hal_can.h:82

CAN_FlagErrorPassiveState
@ CAN_FlagErrorPassiveState
Definition hal_can.h:88

CAN_FlagErrorWarningState
@ CAN_FlagErrorWarningState
Definition hal_can.h:89

CAN_FlagBusError
@ CAN_FlagBusError
Definition hal_can.h:85

CAN_FlagTriggerError
@ CAN_FlagTriggerError
Definition hal_can.h:91

CAN_Status_RxIdle
@ CAN_Status_RxIdle
Definition hal_can.h:44

CAN_Status_Ok
@ CAN_Status_Ok
Definition hal_can.h:38

CAN_Status_RxEmpty
@ CAN_Status_RxEmpty
Definition hal_can.h:42

CAN_Status_InvalidArgument
@ CAN_Status_InvalidArgument
Definition hal_can.h:40

CAN_Status_RxBusy
@ CAN_Status_RxBusy
Definition hal_can.h:45

CAN_Status_TxIdle
@ CAN_Status_TxIdle
Definition hal_can.h:43

CAN_Status_Fail
@ CAN_Status_Fail
Definition hal_can.h:39

CAN_Status_TxBusy
@ CAN_Status_TxBusy
Definition hal_can.h:41

_can_config
Структура конфигурации контроллера CAN.
Definition hal_can.h:288

_can_config::enable_listen_only
bool enable_listen_only
Definition hal_can.h:289

_can_config::timing_config
can_timing_config_t timing_config
Definition hal_can.h:295

_can_config::can_fd_mode
canfd_mode_t can_fd_mode
Definition hal_can.h:296

_can_config::stb_config
can_stb_config_t stb_config
Definition hal_can.h:293

_can_config::filter_config
can_frame_filter_config_t filter_config
Definition hal_can.h:297

_can_config::enable_loopback_ext
bool enable_loopback_ext
Definition hal_can.h:291

_can_config::rxb_config
can_rxb_config_t rxb_config
Definition hal_can.h:294

_can_config::enable_loopback_int
bool enable_loopback_int
Definition hal_can.h:290

_can_config::ptb_config
can_ptb_config_t ptb_config
Definition hal_can.h:292

_can_frame_filter_config
Конфигурация фильтрации принятых кадров CAN.
Definition hal_can.h:203

_can_frame_filter_config::filter
can_frame_filter_t filter[CAN_NB_OF_FILTERS]
Definition hal_can.h:204

_can_frame_filter_config::nb_filters_used
uint8_t nb_filters_used
Definition hal_can.h:205

_can_frame_filter
Фильтр принятых кадров CAN.
Definition hal_can.h:186

_can_frame_filter::id
uint32_t id
Definition hal_can.h:187

_can_frame_filter::accepted_ide
uint32_t accepted_ide
Definition hal_can.h:190

_can_frame_filter::enable_ide_check
uint32_t enable_ide_check
Definition hal_can.h:191

_can_frame_filter::mask
uint32_t mask
Definition hal_can.h:189

_can_handle
Структура дескриптора драйвера CAN.
Definition hal_can.h:331

_can_handle::user_data
void * user_data
Definition hal_can.h:345

_can_handle::tx_nb_frames_rest_prim
volatile size_t tx_nb_frames_rest_prim
Definition hal_can.h:333

_can_handle::tx_nb_frames_all_prim
size_t tx_nb_frames_all_prim
Definition hal_can.h:334

_can_handle::rx_nb_frames_all
size_t rx_nb_frames_all
Definition hal_can.h:342

_can_handle::tx_nb_frames_rest_sec
volatile size_t tx_nb_frames_rest_sec
Definition hal_can.h:337

_can_handle::tx_frames_sec
volatile const can_tx_buffer_frame_t * tx_frames_sec
Definition hal_can.h:336

_can_handle::rx_nb_frames_rest
volatile size_t rx_nb_frames_rest
Definition hal_can.h:341

_can_handle::tx_frames_prim
volatile const can_tx_buffer_frame_t * tx_frames_prim
Definition hal_can.h:332

_can_handle::callback
can_transfer_callback_t callback
Definition hal_can.h:344

_can_handle::tx_nb_frames_all_sec
size_t tx_nb_frames_all_sec
Definition hal_can.h:338

_can_handle::rx_frames
volatile can_rx_buffer_frame_t * rx_frames
Definition hal_can.h:340

_can_ptb_config
Параметры высокоприоритетного буфера выдачи
Definition hal_can.h:264

_can_ptb_config::tx_single_shot
bool tx_single_shot
Definition hal_can.h:265

_can_rx_buffer_frame
Структура буфера приема кадра CAN.
Definition hal_can.h:162

_can_rx_buffer_frame::cycle_time
uint32_t cycle_time
Definition hal_can.h:177

_can_rx_buffer_frame::rts
uint64_t rts
Definition hal_can.h:180

_can_rx_buffer_frame::ide
bool ide
Definition hal_can.h:173

_can_rx_buffer_frame::id
uint32_t id
Definition hal_can.h:164

_can_rx_buffer_frame::brs
bool brs
Definition hal_can.h:170

_can_rx_buffer_frame::rtr
bool rtr
Definition hal_can.h:172

_can_rx_buffer_frame::data
uint8_t data[64]
Definition hal_can.h:179

_can_rx_buffer_frame::tx
bool tx
Definition hal_can.h:175

_can_rx_buffer_frame::esi
bool esi
Definition hal_can.h:166

_can_rx_buffer_frame::koer
can_kind_of_error_t koer
Definition hal_can.h:176

_can_rx_buffer_frame::fdf
bool fdf
Definition hal_can.h:171

_can_rx_buffer_frame::dlc
can_bytes_in_datafield_t dlc
Definition hal_can.h:169

_can_rx_transfer
Структура для приема кадра CAN в неблокирующем режиме (по прерыванию)
Definition hal_can.h:312

_can_rx_transfer::frames
can_rx_buffer_frame_t * frames
Definition hal_can.h:313

_can_rx_transfer::nb_frames
size_t nb_frames
Definition hal_can.h:314

_can_rxb_config
Параметры буфера приема
Definition hal_can.h:279

_can_rxb_config::self_acknowledge
bool self_acknowledge
Definition hal_can.h:281

_can_rxb_config::almost_full_level
uint32_t almost_full_level
Definition hal_can.h:280

_can_rxb_config::prohibit_overflow
bool prohibit_overflow
Definition hal_can.h:282

_can_stb_config
Параметры низкоприоритетного буфера выдачи
Definition hal_can.h:271

_can_stb_config::tx_discipline
can_stb_discipline_t tx_discipline
Definition hal_can.h:273

_can_stb_config::tx_single_shot
bool tx_single_shot
Definition hal_can.h:272

_can_timing_config
Временные параметры передачи битов CAN.
Definition hal_can.h:248

_can_timing_config::sjw
uint8_t sjw
Definition hal_can.h:250

_can_timing_config::data_sjw
uint8_t data_sjw
Definition hal_can.h:254

_can_timing_config::delay_compensation_enable
uint8_t delay_compensation_enable
Definition hal_can.h:257

_can_timing_config::seg2
uint8_t seg2
Definition hal_can.h:252

_can_timing_config::prescaler
uint8_t prescaler
Definition hal_can.h:249

_can_timing_config::seg1
uint8_t seg1
Definition hal_can.h:251

_can_timing_config::data_seg2
uint8_t data_seg2
Definition hal_can.h:256

_can_timing_config::secondary_sample_point_offset
uint8_t secondary_sample_point_offset
Definition hal_can.h:258

_can_timing_config::data_prescaler
uint8_t data_prescaler
Definition hal_can.h:253

_can_timing_config::data_seg1
uint8_t data_seg1
Definition hal_can.h:255

_can_tx_buffer_frame
Структура буфера передачи кадра CAN.
Definition hal_can.h:142

_can_tx_buffer_frame::rtr
bool rtr
Definition hal_can.h:152

_can_tx_buffer_frame::ide
bool ide
Definition hal_can.h:153

_can_tx_buffer_frame::id
uint32_t id
Definition hal_can.h:144

_can_tx_buffer_frame::ttsen
bool ttsen
Definition hal_can.h:146

_can_tx_buffer_frame::brs
bool brs
Definition hal_can.h:150

_can_tx_buffer_frame::dlc
can_bytes_in_datafield_t dlc
Definition hal_can.h:149

_can_tx_buffer_frame::data
uint8_t data[64]
Definition hal_can.h:156

_can_tx_buffer_frame::fdf
bool fdf
Definition hal_can.h:151

_can_tx_transfer
Структура для передачи кадра CAN в неблокирующем режиме (по прерыванию)
Definition hal_can.h:304

_can_tx_transfer::nb_frames
size_t nb_frames
Definition hal_can.h:306

_can_tx_transfer::frames
can_tx_buffer_frame_t * frames
Definition hal_can.h:305

_ttcan_config
Временные параметры передачи битов CAN.
Definition hal_can.h:232

_ttcan_config::watch_trigger_time0
uint8_t watch_trigger_time0
Definition hal_can.h:239

_ttcan_config::transmit_enable_window
uint8_t transmit_enable_window
Definition hal_can.h:236

_ttcan_config::reference_ide
bool reference_ide
Definition hal_can.h:242

_ttcan_config::trigger_time0
uint8_t trigger_time0
Definition hal_can.h:237

_ttcan_config::watch_trigger_time1
uint8_t watch_trigger_time1
Definition hal_can.h:240

_ttcan_config::prescaler
ttcan_timer_prescaler_t prescaler
Definition hal_can.h:233

_ttcan_config::reference_id
uint32_t reference_id
Definition hal_can.h:241

_ttcan_config::trigger_type
ttcan_trigger_type_t trigger_type
Definition hal_can.h:235

_ttcan_config::trigger_time1
uint8_t trigger_time1
Definition hal_can.h:238

_ttcan_config::transmit_trigger_pointer
uint8_t transmit_trigger_pointer
Definition hal_can.h:234