CO_driver_target.h

Go to the documentation of this file.

 
#ifndef CO_DRIVER_TARGET_H
#define CO_DRIVER_TARGET_H
 
#if defined(__has_include)
#if __has_include("hf_co_app_config.h")
#include "hf_co_app_config.h"
#endif
#endif
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "hf_co_driver.h"
 
#if defined(HF_CO_DRIVER_FREERTOS) && HF_CO_DRIVER_FREERTOS
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#define HF_CO_LOCK_FREERTOS 1
#elif defined(__unix__) || defined(__APPLE__)
#include <pthread.h>
#define HF_CO_LOCK_PTHREAD 1
#endif
 
#ifdef CO_DRIVER_CUSTOM
#include "CO_driver_custom.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CO_LITTLE_ENDIAN
#define CO_SWAP_16(x) (x)
#define CO_SWAP_32(x) (x)
#define CO_SWAP_64(x) (x)
 
typedef uint_fast8_t bool_t;
typedef float float32_t;
typedef double float64_t;
 
#define CO_CAN_MAX_LEN HF_CO_CAN_MAX_LEN
 
typedef struct {
  uint16_t ident;               
  uint8_t dlc;                  
  uint8_t data[CO_CAN_MAX_LEN];
} CO_CANrxMsg_t;
 
#define CO_CANrxMsg_readIdent(msg) ((uint16_t)(((const CO_CANrxMsg_t*)(msg))->ident & 0x07FFU))
#define CO_CANrxMsg_readDLC(msg) (((const CO_CANrxMsg_t*)(msg))->dlc)
#define CO_CANrxMsg_readData(msg) (((const CO_CANrxMsg_t*)(msg))->data)
 
typedef struct {
  uint16_t ident; 
  uint16_t mask;  
  void* object;   
  void (*CANrx_callback)(void* object, void* message);
} CO_CANrx_t;
 
typedef struct {
  uint32_t ident;                
  uint8_t DLC;                   
  uint8_t data[CO_CAN_MAX_LEN];
  volatile bool_t bufferFull;    
  volatile bool_t syncFlag;      
  uint8_t pendingPorts;          
} CO_CANtx_t;
 
typedef struct CO_CANmodule_s {
  void* CANptr;                  
  CO_CANrx_t* rxArray;
  uint16_t rxSize;
  CO_CANtx_t* txArray;
  uint16_t txSize;
  uint16_t CANerrorStatus;
  volatile bool_t CANnormal;
  volatile bool_t useCANrxFilters;
  volatile bool_t bufferInhibitFlag;
  volatile bool_t firstCANtxMessage;
  volatile uint16_t CANtxCount;
  uint32_t errOld;
  bool_t lockReady;              
#if defined(HF_CO_LOCK_FREERTOS)
  SemaphoreHandle_t lock;
  StaticSemaphore_t lockStorage;
#elif defined(HF_CO_LOCK_PTHREAD)
  pthread_mutex_t lock;
#endif
} CO_CANmodule_t;
 
typedef struct {
  void* addr;
  size_t len;
  uint8_t subIndexOD;
  uint8_t attr;
  void* addrNV;
} CO_storage_entry_t;
 
void hf_co_lock(CO_CANmodule_t* CANmodule);
void hf_co_unlock(CO_CANmodule_t* CANmodule);
 
#define CO_LOCK_CAN_SEND(CAN_MODULE) hf_co_lock(CAN_MODULE)
#define CO_UNLOCK_CAN_SEND(CAN_MODULE) hf_co_unlock(CAN_MODULE)
#define CO_LOCK_EMCY(CAN_MODULE) hf_co_lock(CAN_MODULE)
#define CO_UNLOCK_EMCY(CAN_MODULE) hf_co_unlock(CAN_MODULE)
#define CO_LOCK_OD(CAN_MODULE) hf_co_lock(CAN_MODULE)
#define CO_UNLOCK_OD(CAN_MODULE) hf_co_unlock(CAN_MODULE)
 
/* RX callbacks run in thread context (hf_co_driver_rx_drain); the flag is
 * read by the thread that processes the object, possibly another one. A full
 * barrier keeps the data written before the flag. */
#define CO_MemoryBarrier() __sync_synchronize()
#define CO_FLAG_READ(rxNew) ((rxNew) != NULL)
#define CO_FLAG_SET(rxNew)                                                                                             \
  do {                                                                                                                 \
    CO_MemoryBarrier();                                                                                                \
    (rxNew) = (void*)1L;                                                                                               \
  } while (0)
#define CO_FLAG_CLEAR(rxNew)                                                                                           \
  do {                                                                                                                 \
    CO_MemoryBarrier();                                                                                                \
    (rxNew) = NULL;                                                                                                    \
  } while (0)
 
#ifdef __cplusplus
}
#endif
 
#endif /* CO_DRIVER_TARGET_H */