CO_driver.h

Go to the documentation of this file.

 
#ifndef CO_DRIVER_H
#define CO_DRIVER_H
 
#include <string.h>
 
#include "CO_config.h"
#include "CO_driver_target.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Stack configuration default global values. For more information see file CO_config.h. */
#ifndef CO_CONFIG_GLOBAL_FLAG_CALLBACK_PRE
#define CO_CONFIG_GLOBAL_FLAG_CALLBACK_PRE (0)
#endif
#ifndef CO_CONFIG_GLOBAL_RT_FLAG_CALLBACK_PRE
#define CO_CONFIG_GLOBAL_RT_FLAG_CALLBACK_PRE (0)
#endif
#ifndef CO_CONFIG_GLOBAL_FLAG_TIMERNEXT
#define CO_CONFIG_GLOBAL_FLAG_TIMERNEXT (0)
#endif
#ifndef CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC
#define CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC CO_CONFIG_FLAG_OD_DYNAMIC
#endif
#ifdef CO_DEBUG_COMMON
#if (CO_CONFIG_DEBUG) & CO_CONFIG_DEBUG_SDO_CLIENT
#define CO_DEBUG_SDO_CLIENT(msg) CO_DEBUG_COMMON(msg)
#endif
#if (CO_CONFIG_DEBUG) & CO_CONFIG_DEBUG_SDO_SERVER
#define CO_DEBUG_SDO_SERVER(msg) CO_DEBUG_COMMON(msg)
#endif
#endif
 
#define CO_VERSION_MAJOR 4
#define CO_VERSION_MINOR 0
 
/* Macros and declarations in following part are only used for documentation. */
#ifdef CO_DOXYGEN
#define CO_LITTLE_ENDIAN                 
#define CO_SWAP_16(x)    x               
#define CO_SWAP_32(x)    x               
#define CO_SWAP_64(x)    x               
#define NULL             (0)             
#define true             1               
#define false            0               
typedef uint_fast8_t bool_t;             
typedef signed char int8_t;              
typedef signed int int16_t;              
typedef signed long int int32_t;         
typedef signed long long int int64_t;    
typedef unsigned char uint8_t;           
typedef unsigned int uint16_t;           
typedef unsigned long int uint32_t;      
typedef unsigned long long int uint64_t; 
typedef float float32_t;  
typedef double float64_t; 
void CANrx_callback(void* object, void* rxMsg);
 
static inline uint16_t
CO_CANrxMsg_readIdent(void* rxMsg) {
    return 0;
}
 
static inline uint8_t
CO_CANrxMsg_readDLC(void* rxMsg) {
    return 0;
}
 
static inline const uint8_t*
CO_CANrxMsg_readData(void* rxMsg) {
    return NULL;
}
 
typedef struct {
    uint16_t ident; 
    uint16_t mask;  
    void* object;   
    void (*pCANrx_callback)(void* object,
                            void* message); 
} CO_CANrx_t;
 
typedef struct {
    uint32_t ident;             
    uint8_t DLC;                
    uint8_t data[8];            
    volatile bool_t bufferFull; 
    volatile bool_t syncFlag;   
} CO_CANtx_t;
 
typedef struct {
    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; 
} CO_CANmodule_t;
 
typedef struct {
    void* addr;         
    size_t len;         
    uint8_t subIndexOD; 
    uint8_t attr;       
    void* storageModule; 
    uint16_t crc; 
    size_t eepromAddrSignature; 
    size_t eepromAddr; 
    size_t offset; 
    void* additionalParameters; 
} CO_storage_entry_t;
 
#define CO_LOCK_CAN_SEND(CAN_MODULE)   
#define CO_UNLOCK_CAN_SEND(CAN_MODULE) 
#define CO_LOCK_EMCY(CAN_MODULE)       
#define CO_UNLOCK_EMCY(CAN_MODULE)     
#define CO_LOCK_OD(CAN_MODULE)         
#define CO_UNLOCK_OD(CAN_MODULE)       
#define CO_FLAG_READ(rxNew)            ((rxNew) != NULL)
#define CO_FLAG_SET(rxNew)                                                                                             \
    {                                                                                                                  \
        __sync_synchronize();                                                                                          \
        rxNew = (void*)1L;                                                                                             \
    }
#define CO_FLAG_CLEAR(rxNew)                                                                                           \
    {                                                                                                                  \
        __sync_synchronize();                                                                                          \
        rxNew = NULL;                                                                                                  \
    }
 
#endif /* CO_DOXYGEN */
 
#define CO_CAN_ID_NMT_SERVICE 0x000U 
#define CO_CAN_ID_GFC         0x001U 
#define CO_CAN_ID_SYNC        0x080U 
#define CO_CAN_ID_EMERGENCY   0x080U 
#define CO_CAN_ID_TIME        0x100U 
#define CO_CAN_ID_SRDO_1      0x0FFU 
#define CO_CAN_ID_TPDO_1      0x180U 
#define CO_CAN_ID_RPDO_1      0x200U 
#define CO_CAN_ID_TPDO_2      0x280U 
#define CO_CAN_ID_RPDO_2      0x300U 
#define CO_CAN_ID_TPDO_3      0x380U 
#define CO_CAN_ID_RPDO_3      0x400U 
#define CO_CAN_ID_TPDO_4      0x480U 
#define CO_CAN_ID_RPDO_4      0x500U 
#define CO_CAN_ID_SDO_SRV     0x580U 
#define CO_CAN_ID_SDO_CLI     0x600U 
#define CO_CAN_ID_HEARTBEAT   0x700U 
#define CO_CAN_ID_LSS_SLV     0x7E4U 
#define CO_CAN_ID_LSS_MST     0x7E5U 
 /* CO_Default_CAN_ID_t */
 
#ifndef CO_IS_RESTRICTED_CAN_ID
#define CO_IS_RESTRICTED_CAN_ID(CAN_ID)                                                                                \
    (((CAN_ID) <= 0x7FU) || (((CAN_ID) >= 0x101U) && ((CAN_ID) <= 0x180U))                                             \
     || (((CAN_ID) >= 0x581U) && ((CAN_ID) <= 0x5FFU)) || (((CAN_ID) >= 0x601U) && ((CAN_ID) <= 0x67FU))               \
     || (((CAN_ID) >= 0x6E0U) && ((CAN_ID) <= 0x6FFU)) || ((CAN_ID) >= 0x701U))
#endif
 
#define CO_CAN_ERRTX_WARNING    0x0001U 
#define CO_CAN_ERRTX_PASSIVE    0x0002U 
#define CO_CAN_ERRTX_BUS_OFF    0x0004U 
#define CO_CAN_ERRTX_OVERFLOW   0x0008U 
#define CO_CAN_ERRTX_PDO_LATE   0x0080U 
#define CO_CAN_ERRRX_WARNING    0x0100U 
#define CO_CAN_ERRRX_PASSIVE    0x0200U 
#define CO_CAN_ERRRX_OVERFLOW   0x0800U 
#define CO_CAN_ERR_WARN_PASSIVE 0x0303U 
 /* CO_CAN_ERR_status_t */
 
typedef enum {
    CO_ERROR_NO = 0,                
    CO_ERROR_ILLEGAL_ARGUMENT = -1, 
    CO_ERROR_OUT_OF_MEMORY = -2,    
    CO_ERROR_TIMEOUT = -3,          
    CO_ERROR_ILLEGAL_BAUDRATE = -4, 
    CO_ERROR_RX_OVERFLOW = -5,      
    CO_ERROR_RX_PDO_OVERFLOW = -6,  
    CO_ERROR_RX_MSG_LENGTH = -7,    
    CO_ERROR_RX_PDO_LENGTH = -8,    
    CO_ERROR_TX_OVERFLOW = -9,      
    CO_ERROR_TX_PDO_WINDOW = -10,   
    CO_ERROR_TX_UNCONFIGURED = -11, 
    CO_ERROR_OD_PARAMETERS = -12,   
    CO_ERROR_DATA_CORRUPT = -13,    
    CO_ERROR_CRC = -14,             
    CO_ERROR_TX_BUSY = -15,         
    CO_ERROR_WRONG_NMT_STATE = -16, 
    CO_ERROR_SYSCALL = -17,         
    CO_ERROR_INVALID_STATE = -18,   
    CO_ERROR_NODE_ID_UNCONFIGURED_LSS =
        -19 
} CO_ReturnError_t;
 
void CO_CANsetConfigurationMode(void* CANptr);
 
void CO_CANsetNormalMode(CO_CANmodule_t* CANmodule);
 
CO_ReturnError_t CO_CANmodule_init(CO_CANmodule_t* CANmodule, void* CANptr, CO_CANrx_t rxArray[], uint16_t rxSize,
                                   CO_CANtx_t txArray[], uint16_t txSize, uint16_t CANbitRate);
 
void CO_CANmodule_disable(CO_CANmodule_t* CANmodule);
 
CO_ReturnError_t CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, uint16_t mask,
                                    bool_t rtr, void* object, void (*CANrx_callback)(void* object, void* message));
 
CO_CANtx_t* CO_CANtxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, bool_t rtr, uint8_t noOfBytes,
                               bool_t syncFlag);
 
CO_ReturnError_t CO_CANsend(CO_CANmodule_t* CANmodule, CO_CANtx_t* buffer);
 
void CO_CANclearPendingSyncPDOs(CO_CANmodule_t* CANmodule);
 
void CO_CANmodule_process(CO_CANmodule_t* CANmodule);
 
static inline uint8_t
CO_getUint8(const void* buf) {
    uint8_t value;
    (void)memmove((void*)&value, buf, sizeof(value));
    return value;
}
 
static inline uint16_t
CO_getUint16(const void* buf) {
    uint16_t value;
    (void)memmove((void*)&value, buf, sizeof(value));
    return value;
}
 
static inline uint32_t
CO_getUint32(const void* buf) {
    uint32_t value;
    (void)memmove((void*)&value, buf, sizeof(value));
    return value;
}
 
static inline uint8_t
CO_setUint8(void* buf, uint8_t value) {
    (void)memmove(buf, (const void*)&value, sizeof(value));
    return (uint8_t)(sizeof(value));
}
 
static inline uint8_t
CO_setUint16(void* buf, uint16_t value) {
    (void)memmove(buf, (const void*)&value, sizeof(value));
    return (uint8_t)(sizeof(value));
}
 
static inline uint8_t
CO_setUint32(void* buf, uint32_t value) {
    (void)memmove(buf, (const void*)&value, sizeof(value));
    return (uint8_t)(sizeof(value));
}
 
 /* CO_driver */
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* CO_DRIVER_H */