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
 
#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 unsigned char 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;
typedef char char_t;
typedef unsigned char oChar_t;
typedef unsigned char domain_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 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;                   
    int32_t errinfo;                   
} CO_CANmodule_t;
 
 
#define CO_LOCK_CAN_SEND()
 
#define CO_UNLOCK_CAN_SEND()
 
#define CO_LOCK_EMCY()
 
#define CO_UNLOCK_EMCY()
 
#define CO_LOCK_OD()
 
#define CO_UNLOCK_OD()
 
#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 */
 
 
#ifndef CO_errinfo
#define CO_errinfo(CANmodule, err)
#endif
 
 
typedef enum {
    CO_CAN_ID_NMT_SERVICE = 0x000, 
    CO_CAN_ID_GFC = 0x001,         
    CO_CAN_ID_SYNC = 0x080,        
    CO_CAN_ID_EMERGENCY = 0x080,   
    CO_CAN_ID_TIME = 0x100,        
    CO_CAN_ID_SRDO_1 = 0x0FF,      
    CO_CAN_ID_TPDO_1 = 0x180,      
    CO_CAN_ID_RPDO_1 = 0x200,      
    CO_CAN_ID_TPDO_2 = 0x280,      
    CO_CAN_ID_RPDO_2 = 0x300,      
    CO_CAN_ID_TPDO_3 = 0x380,      
    CO_CAN_ID_RPDO_3 = 0x400,      
    CO_CAN_ID_TPDO_4 = 0x480,      
    CO_CAN_ID_RPDO_4 = 0x500,      
    CO_CAN_ID_SDO_SRV = 0x580, 
    CO_CAN_ID_SDO_CLI = 0x600, 
    CO_CAN_ID_HEARTBEAT = 0x700,   
    CO_CAN_ID_LSS_SLV = 0x7E4,     
    CO_CAN_ID_LSS_MST = 0x7E5      
} CO_Default_CAN_ID_t;
 
 
typedef enum {
    CO_CAN_ERRTX_WARNING = 0x0001,  
    CO_CAN_ERRTX_PASSIVE = 0x0002,  
    CO_CAN_ERRTX_BUS_OFF = 0x0004,  
    CO_CAN_ERRTX_OVERFLOW = 0x0008, 
    CO_CAN_ERRTX_PDO_LATE = 0x0080, 
    CO_CAN_ERRRX_WARNING = 0x0100,  
    CO_CAN_ERRRX_PASSIVE = 0x0200,  
    CO_CAN_ERRRX_OVERFLOW = 0x0800, 
    CO_CAN_ERR_WARN_PASSIVE = 0x0303
} 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; memmove(&value, buf, sizeof(value)); return value;
}
static inline uint16_t CO_getUint16(const void *buf) {
    uint16_t value; memmove(&value, buf, sizeof(value)); return value;
}
static inline uint32_t CO_getUint32(const void *buf) {
    uint32_t value; memmove(&value, buf, sizeof(value)); return value;
}
 
static inline uint8_t CO_setUint8(void *buf, uint8_t value) {
    memmove(buf, &value, sizeof(value)); return sizeof(value);
}
static inline uint8_t CO_setUint16(void *buf, uint16_t value) {
    memmove(buf, &value, sizeof(value)); return sizeof(value);
}
static inline uint8_t CO_setUint32(void *buf, uint32_t value) {
    memmove(buf, &value, sizeof(value)); return sizeof(value);
}
 /* CO_driver */
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* CO_DRIVER_H */