#define _ec_base_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
int ecx_setupdatagram(ecx_portt *port, void *frame, uint8 com, uint8 idx, uint16 ADP, uint16 ADO, uint16 length, void *data);
uint16 ecx_adddatagram(ecx_portt *port, void *frame, uint8 com, uint8 idx, boolean more, uint16 ADP, uint16 ADO, uint16 length, void *data);
-int ecx_BWR(ecx_portt *port, uint16 ADP,uint16 ADO,uint16 length,void *data,int timeout);
-int ecx_BRD(ecx_portt *port, uint16 ADP,uint16 ADO,uint16 length,void *data,int timeout);
+int ecx_BWR(ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout);
+int ecx_BRD(ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout);
int ecx_APRD(ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout);
int ecx_ARMW(ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout);
int ecx_FRMW(ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout);
#define _ec_coe_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
/** max entries in Object Description list */
-#define EC_MAXODLIST 1024
+#define EC_MAXODLIST 1024
/** max entries in Object Entry list */
-#define EC_MAXOELIST 256
+#define EC_MAXOELIST 256
/* Storage for object description list */
typedef struct
{
/** slave number */
- uint16 Slave;
+ uint16 Slave;
/** number of entries in list */
- uint16 Entries;
+ uint16 Entries;
/** array of indexes */
- uint16 Index[EC_MAXODLIST];
+ uint16 Index[EC_MAXODLIST];
/** array of datatypes, see EtherCAT specification */
- uint16 DataType[EC_MAXODLIST];
+ uint16 DataType[EC_MAXODLIST];
/** array of object codes, see EtherCAT specification */
- uint8 ObjectCode[EC_MAXODLIST];
+ uint8 ObjectCode[EC_MAXODLIST];
/** number of subindexes for each index */
- uint8 MaxSub[EC_MAXODLIST];
+ uint8 MaxSub[EC_MAXODLIST];
/** textual description of each index */
- char Name[EC_MAXODLIST][EC_MAXNAME+1];
+ char Name[EC_MAXODLIST][EC_MAXNAME + 1];
} ec_ODlistt;
/* storage for object list entry information */
/** number of entries in list */
uint16 Entries;
/** array of value infos, see EtherCAT specification */
- uint8 ValueInfo[EC_MAXOELIST];
+ uint8 ValueInfo[EC_MAXOELIST];
/** array of value infos, see EtherCAT specification */
uint16 DataType[EC_MAXOELIST];
/** array of bit lengths, see EtherCAT specification */
/** array of object access bits, see EtherCAT specification */
uint16 ObjAccess[EC_MAXOELIST];
/** textual description of each index */
- char Name[EC_MAXOELIST][EC_MAXNAME+1];
+ char Name[EC_MAXOELIST][EC_MAXNAME + 1];
} ec_OElistt;
void ecx_SDOerror(ecx_contextt *context, uint16 Slave, uint16 Index, uint8 SubIdx, int32 AbortCode);
boolean CA, int *psize, void *p, int timeout);
int ecx_SDOwrite(ecx_contextt *context, uint16 Slave, uint16 Index, uint8 SubIndex,
boolean CA, int psize, const void *p, int Timeout);
-int ecx_RxPDO(ecx_contextt *context, uint16 Slave, uint16 RxPDOnumber , int psize, const void *p);
-int ecx_TxPDO(ecx_contextt *context, uint16 slave, uint16 TxPDOnumber , int *psize, void *p, int timeout);
+int ecx_RxPDO(ecx_contextt *context, uint16 Slave, uint16 RxPDOnumber, int psize, const void *p);
+int ecx_TxPDO(ecx_contextt *context, uint16 slave, uint16 TxPDOnumber, int *psize, void *p, int timeout);
int ecx_readPDOmap(ecx_contextt *context, uint16 Slave, uint32 *Osize, uint32 *Isize);
int ecx_readPDOmapCA(ecx_contextt *context, uint16 Slave, int Thread_n, uint32 *Osize, uint32 *Isize);
int ecx_readODlist(ecx_contextt *context, uint16 Slave, ec_ODlistt *pODlist);
#define _ec_config_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
-#define EC_NODEOFFSET 0x1000
-#define EC_TEMPNODE 0xffff
+#define EC_NODEOFFSET 0x1000
+#define EC_TEMPNODE 0xffff
int ecx_config_init(ecx_contextt *context, uint8 usetable);
int ecx_config_map_group(ecx_contextt *context, void *pIOmap, uint8 group);
#define _EC_ECATDC_H
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
boolean ecx_configdc(ecx_contextt *context);
#define _ec_eoe_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include "soem/soem.h"
/* use maximum size for EOE mailbox data - mbxheader and 2x frameinfo */
-#define EC_MAXEOEDATA (EC_MAXMBX - (sizeof(ec_mbxheadert) +\
- sizeof(uint16_t) +\
+#define EC_MAXEOEDATA (EC_MAXMBX - (sizeof(ec_mbxheadert) + \
+ sizeof(uint16_t) + \
sizeof(uint16_t)))
/** DNS length according to ETG 1000.6 */
-#define EOE_DNS_NAME_LENGTH 32
+#define EOE_DNS_NAME_LENGTH 32
/** Ethernet address length not including VLAN */
-#define EOE_ETHADDR_LENGTH 6
+#define EOE_ETHADDR_LENGTH 6
/** IPv4 address length */
-#define EOE_IP4_LENGTH sizeof(uint32_t)
+#define EOE_IP4_LENGTH sizeof(uint32_t)
-#define EOE_MAKEU32(a,b,c,d) (((uint32_t)((a) & 0xff) << 24) | \
- ((uint32_t)((b) & 0xff) << 16) | \
- ((uint32_t)((c) & 0xff) << 8) | \
- (uint32_t)((d) & 0xff))
+#define EOE_MAKEU32(a, b, c, d) (((uint32_t)((a) & 0xff) << 24) | \
+ ((uint32_t)((b) & 0xff) << 16) | \
+ ((uint32_t)((c) & 0xff) << 8) | \
+ (uint32_t)((d) & 0xff))
#if !defined(EC_BIG_ENDIAN) && defined(EC_LITTLE_ENDIAN)
#define EOE_HTONS(x) ((((x) & 0x00ffUL) << 8) | (((x) & 0xff00UL) >> 8))
#define EOE_NTOHS(x) EOE_HTONS(x)
#define EOE_HTONL(x) ((((x) & 0x000000ffUL) << 24) | \
- (((x) & 0x0000ff00UL) << 8) | \
- (((x) & 0x00ff0000UL) >> 8) | \
- (((x) & 0xff000000UL) >> 24))
+ (((x) & 0x0000ff00UL) << 8) | \
+ (((x) & 0x00ff0000UL) >> 8) | \
+ (((x) & 0xff000000UL) >> 24))
#define EOE_NTOHL(x) EOE_HTONL(x)
#else
#define EOE_HTONS(x) (x)
#endif /* !defined(EC_BIG_ENDIAN) && defined(EC_LITTLE_ENDIAN) */
/** Get one byte from the 4-byte address */
-#define eoe_ip4_addr1(ipaddr) (((const uint8_t*)(&(ipaddr)->addr))[0])
-#define eoe_ip4_addr2(ipaddr) (((const uint8_t*)(&(ipaddr)->addr))[1])
-#define eoe_ip4_addr3(ipaddr) (((const uint8_t*)(&(ipaddr)->addr))[2])
-#define eoe_ip4_addr4(ipaddr) (((const uint8_t*)(&(ipaddr)->addr))[3])
+#define eoe_ip4_addr1(ipaddr) (((const uint8_t *)(&(ipaddr)->addr))[0])
+#define eoe_ip4_addr2(ipaddr) (((const uint8_t *)(&(ipaddr)->addr))[1])
+#define eoe_ip4_addr3(ipaddr) (((const uint8_t *)(&(ipaddr)->addr))[2])
+#define eoe_ip4_addr4(ipaddr) (((const uint8_t *)(&(ipaddr)->addr))[3])
/** Set an IP address given by the four byte-parts */
-#define EOE_IP4_ADDR_TO_U32(ipaddr,a,b,c,d) \
- (ipaddr)->addr = EOE_HTONL(EOE_MAKEU32(a,b,c,d))
+#define EOE_IP4_ADDR_TO_U32(ipaddr, a, b, c, d) \
+ (ipaddr)->addr = EOE_HTONL(EOE_MAKEU32(a, b, c, d))
/** Header frame info 1 */
-#define EOE_HDR_FRAME_TYPE_OFFSET 0
-#define EOE_HDR_FRAME_TYPE (0xF << 0)
-#define EOE_HDR_FRAME_TYPE_SET(x) (((x) & 0xF) << 0)
-#define EOE_HDR_FRAME_TYPE_GET(x) (((x) >> 0) & 0xF)
-#define EOE_HDR_FRAME_PORT_OFFSET 4
-#define EOE_HDR_FRAME_PORT (0xF << 4)
-#define EOE_HDR_FRAME_PORT_SET(x) ((uint16)(((x) & 0xF) << 4))
-#define EOE_HDR_FRAME_PORT_GET(x) (((x) >> 4) & 0xF)
-#define EOE_HDR_LAST_FRAGMENT_OFFSET 8
-#define EOE_HDR_LAST_FRAGMENT (0x1 << 8)
-#define EOE_HDR_LAST_FRAGMENT_SET(x) (((x) & 0x1) << 8)
-#define EOE_HDR_LAST_FRAGMENT_GET(x) (((x) >> 8) & 0x1)
-#define EOE_HDR_TIME_APPEND_OFFSET 9
-#define EOE_HDR_TIME_APPEND (0x1 << 9)
-#define EOE_HDR_TIME_APPEND_SET(x) (((x) & 0x1) << 9)
-#define EOE_HDR_TIME_APPEND_GET(x) (((x) >> 9) & 0x1)
-#define EOE_HDR_TIME_REQUEST_OFFSET 10
-#define EOE_HDR_TIME_REQUEST (0x1 << 10)
-#define EOE_HDR_TIME_REQUEST_SET(x) (((x) & 0x1) << 10)
-#define EOE_HDR_TIME_REQUEST_GET(x) (((x) >> 10) & 0x1)
+#define EOE_HDR_FRAME_TYPE_OFFSET 0
+#define EOE_HDR_FRAME_TYPE (0xF << 0)
+#define EOE_HDR_FRAME_TYPE_SET(x) (((x) & 0xF) << 0)
+#define EOE_HDR_FRAME_TYPE_GET(x) (((x) >> 0) & 0xF)
+#define EOE_HDR_FRAME_PORT_OFFSET 4
+#define EOE_HDR_FRAME_PORT (0xF << 4)
+#define EOE_HDR_FRAME_PORT_SET(x) ((uint16)(((x) & 0xF) << 4))
+#define EOE_HDR_FRAME_PORT_GET(x) (((x) >> 4) & 0xF)
+#define EOE_HDR_LAST_FRAGMENT_OFFSET 8
+#define EOE_HDR_LAST_FRAGMENT (0x1 << 8)
+#define EOE_HDR_LAST_FRAGMENT_SET(x) (((x) & 0x1) << 8)
+#define EOE_HDR_LAST_FRAGMENT_GET(x) (((x) >> 8) & 0x1)
+#define EOE_HDR_TIME_APPEND_OFFSET 9
+#define EOE_HDR_TIME_APPEND (0x1 << 9)
+#define EOE_HDR_TIME_APPEND_SET(x) (((x) & 0x1) << 9)
+#define EOE_HDR_TIME_APPEND_GET(x) (((x) >> 9) & 0x1)
+#define EOE_HDR_TIME_REQUEST_OFFSET 10
+#define EOE_HDR_TIME_REQUEST (0x1 << 10)
+#define EOE_HDR_TIME_REQUEST_SET(x) (((x) & 0x1) << 10)
+#define EOE_HDR_TIME_REQUEST_GET(x) (((x) >> 10) & 0x1)
/** Header frame info 2 */
-#define EOE_HDR_FRAG_NO_OFFSET 0
-#define EOE_HDR_FRAG_NO (0x3F << 0)
-#define EOE_HDR_FRAG_NO_SET(x) ((uint16)(((x) & 0x3F) << 0))
-#define EOE_HDR_FRAG_NO_GET(x) (((x) >> 0) & 0x3F)
-#define EOE_HDR_FRAME_OFFSET_OFFSET 6
-#define EOE_HDR_FRAME_OFFSET (0x3F << 6)
-#define EOE_HDR_FRAME_OFFSET_SET(x) ((uint16)(((x) & 0x3F) << 6))
-#define EOE_HDR_FRAME_OFFSET_GET(x) (((x) >> 6) & 0x3F)
-#define EOE_HDR_FRAME_NO_OFFSET 12
-#define EOE_HDR_FRAME_NO (0xF << 12)
-#define EOE_HDR_FRAME_NO_SET(x) ((uint16)(((x) & 0xF) << 12))
-#define EOE_HDR_FRAME_NO_GET(x) (((x) >> 12) & 0xF)
+#define EOE_HDR_FRAG_NO_OFFSET 0
+#define EOE_HDR_FRAG_NO (0x3F << 0)
+#define EOE_HDR_FRAG_NO_SET(x) ((uint16)(((x) & 0x3F) << 0))
+#define EOE_HDR_FRAG_NO_GET(x) (((x) >> 0) & 0x3F)
+#define EOE_HDR_FRAME_OFFSET_OFFSET 6
+#define EOE_HDR_FRAME_OFFSET (0x3F << 6)
+#define EOE_HDR_FRAME_OFFSET_SET(x) ((uint16)(((x) & 0x3F) << 6))
+#define EOE_HDR_FRAME_OFFSET_GET(x) (((x) >> 6) & 0x3F)
+#define EOE_HDR_FRAME_NO_OFFSET 12
+#define EOE_HDR_FRAME_NO (0xF << 12)
+#define EOE_HDR_FRAME_NO_SET(x) ((uint16)(((x) & 0xF) << 12))
+#define EOE_HDR_FRAME_NO_GET(x) (((x) >> 12) & 0xF)
/** EOE param */
#define EOE_PARAM_OFFSET 4
#define EOE_PARAM_DNS_NAME_INCLUDE (0x1 << 5)
/** EoE frame types */
-#define EOE_FRAG_DATA 0
-#define EOE_INIT_RESP_TIMESTAMP 1
-#define EOE_INIT_REQ 2 /* Spec SET IP REQ */
-#define EOE_INIT_RESP 3 /* Spec SET IP RESP */
-#define EOE_SET_ADDR_FILTER_REQ 4
-#define EOE_SET_ADDR_FILTER_RESP 5
-#define EOE_GET_IP_PARAM_REQ 6
-#define EOE_GET_IP_PARAM_RESP 7
-#define EOE_GET_ADDR_FILTER_REQ 8
-#define EOE_GET_ADDR_FILTER_RESP 9
+#define EOE_FRAG_DATA 0
+#define EOE_INIT_RESP_TIMESTAMP 1
+#define EOE_INIT_REQ 2 /* Spec SET IP REQ */
+#define EOE_INIT_RESP 3 /* Spec SET IP RESP */
+#define EOE_SET_ADDR_FILTER_REQ 4
+#define EOE_SET_ADDR_FILTER_RESP 5
+#define EOE_GET_IP_PARAM_REQ 6
+#define EOE_GET_IP_PARAM_RESP 7
+#define EOE_GET_ADDR_FILTER_REQ 8
+#define EOE_GET_ADDR_FILTER_RESP 9
/** EoE parameter result codes */
-#define EOE_RESULT_SUCCESS 0x0000
-#define EOE_RESULT_UNSPECIFIED_ERROR 0x0001
-#define EOE_RESULT_UNSUPPORTED_FRAME_TYPE 0x0002
-#define EOE_RESULT_NO_IP_SUPPORT 0x0201
-#define EOE_RESULT_NO_DHCP_SUPPORT 0x0202
-#define EOE_RESULT_NO_FILTER_SUPPORT 0x0401
-
+#define EOE_RESULT_SUCCESS 0x0000
+#define EOE_RESULT_UNSPECIFIED_ERROR 0x0001
+#define EOE_RESULT_UNSUPPORTED_FRAME_TYPE 0x0002
+#define EOE_RESULT_NO_IP_SUPPORT 0x0201
+#define EOE_RESULT_NO_DHCP_SUPPORT 0x0202
+#define EOE_RESULT_NO_FILTER_SUPPORT 0x0401
/** EOE ip4 address in network order */
-typedef struct eoe_ip4_addr {
+typedef struct eoe_ip4_addr
+{
uint32_t addr;
-}eoe_ip4_addr_t;
+} eoe_ip4_addr_t;
/** EOE ethernet address */
PACKED_BEGIN
} eoe_param_t;
/** EOE structure.
-* Used to interpret EoE mailbox packets.
-*/
+ * Used to interpret EoE mailbox packets.
+ */
PACKED_BEGIN
typedef struct PACKED
{
PACKED_END
int ecx_EOEdefinehook(ecx_contextt *context, void *hook);
-int ecx_EOEsetIp(ecx_contextt *context,
- uint16 slave,
- uint8 port,
- eoe_param_t * ipparam,
- int timeout);
-int ecx_EOEgetIp(ecx_contextt *context,
- uint16 slave,
- uint8 port,
- eoe_param_t * ipparam,
- int timeout);
-int ecx_EOEsend(ecx_contextt *context,
- uint16 slave,
- uint8 port,
- int psize,
- void *p,
- int timeout);
-int ecx_EOErecv(ecx_contextt *context,
- uint16 slave,
- uint8 port,
- int * psize,
- void *p,
- int timeout);
+int ecx_EOEsetIp(ecx_contextt *context,
+ uint16 slave,
+ uint8 port,
+ eoe_param_t *ipparam,
+ int timeout);
+int ecx_EOEgetIp(ecx_contextt *context,
+ uint16 slave,
+ uint8 port,
+ eoe_param_t *ipparam,
+ int timeout);
+int ecx_EOEsend(ecx_contextt *context,
+ uint16 slave,
+ uint8 port,
+ int psize,
+ void *p,
+ int timeout);
+int ecx_EOErecv(ecx_contextt *context,
+ uint16 slave,
+ uint8 port,
+ int *psize,
+ void *p,
+ int timeout);
int ecx_EOEreadfragment(
- ec_mbxbuft * MbxIn,
- uint8 * rxfragmentno,
- uint16 * rxframesize,
- uint16 * rxframeoffset,
- uint16 * rxframeno,
- int * psize,
- void *p);
+ ec_mbxbuft *MbxIn,
+ uint8 *rxfragmentno,
+ uint16 *rxframesize,
+ uint16 *rxframeoffset,
+ uint16 *rxframeno,
+ int *psize,
+ void *p);
#ifdef __cplusplus
}
#define _ec_foe_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
int ecx_FOEdefinehook(ecx_contextt *context, void *hook);
#ifndef _ec_main_
#define _ec_main_
-
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
/** max. entries in EtherCAT error list */
-#define EC_MAXELIST 64
+#define EC_MAXELIST 64
/** max. length of readable name in slavelist and Object Description List */
-#define EC_MAXNAME 40
+#define EC_MAXNAME 40
/** max. number of slaves in array */
-#define EC_MAXSLAVE 200
+#define EC_MAXSLAVE 200
/** max. number of groups */
-#define EC_MAXGROUP 2
+#define EC_MAXGROUP 2
/** max. number of IO segments per group */
-#define EC_MAXIOSEGMENTS 64
+#define EC_MAXIOSEGMENTS 64
/** max. mailbox size */
-#define EC_MAXMBX 1486
+#define EC_MAXMBX 1486
/** max. eeprom PDO entries */
-#define EC_MAXEEPDO 0x200
+#define EC_MAXEEPDO 0x200
/** max. SM used */
-#define EC_MAXSM 8
+#define EC_MAXSM 8
/** max. FMMU used */
-#define EC_MAXFMMU 4
+#define EC_MAXFMMU 4
/** max. Adapter */
-#define EC_MAXLEN_ADAPTERNAME 128
+#define EC_MAXLEN_ADAPTERNAME 128
/** define maximum number of concurrent threads in mapping */
#define EC_MAX_MAPT 1
typedef struct ec_adapter ec_adaptert;
struct ec_adapter
{
- char name[EC_MAXLEN_ADAPTERNAME];
- char desc[EC_MAXLEN_ADAPTERNAME];
+ char name[EC_MAXLEN_ADAPTERNAME];
+ char desc[EC_MAXLEN_ADAPTERNAME];
ec_adaptert *next;
};
PACKED_BEGIN
typedef struct PACKED ec_fmmu
{
- uint32 LogStart;
- uint16 LogLength;
- uint8 LogStartbit;
- uint8 LogEndbit;
- uint16 PhysStart;
- uint8 PhysStartBit;
- uint8 FMMUtype;
- uint8 FMMUactive;
- uint8 unused1;
- uint16 unused2;
-} ec_fmmut;
+ uint32 LogStart;
+ uint16 LogLength;
+ uint8 LogStartbit;
+ uint8 LogEndbit;
+ uint16 PhysStart;
+ uint8 PhysStartBit;
+ uint8 FMMUtype;
+ uint8 FMMUactive;
+ uint8 unused1;
+ uint16 unused2;
+} ec_fmmut;
PACKED_END
/** record for sync manager */
PACKED_BEGIN
typedef struct PACKED ec_sm
{
- uint16 StartAddr;
- uint16 SMlength;
- uint32 SMflags;
+ uint16 StartAddr;
+ uint16 SMlength;
+ uint32 SMflags;
} ec_smt;
PACKED_END
PACKED_BEGIN
typedef struct PACKED ec_state_status
{
- uint16 State;
- uint16 Unused;
- uint16 ALstatuscode;
+ uint16 State;
+ uint16 Unused;
+ uint16 ALstatuscode;
} ec_state_status;
PACKED_END
/** mailbox buffer array */
typedef uint8 ec_mbxbuft[EC_MAXMBX + 1];
-#define EC_MBXPOOLSIZE 32
-#define EC_MBXINENABLE (uint8 *)1
+#define EC_MBXPOOLSIZE 32
+#define EC_MBXINENABLE (uint8 *)1
typedef struct
{
- int listhead, listtail, listcount;
- int mbxemptylist[EC_MBXPOOLSIZE];
+ int listhead, listtail, listcount;
+ int mbxemptylist[EC_MBXPOOLSIZE];
osal_mutext *mbxmutex;
- ec_mbxbuft mbx[EC_MBXPOOLSIZE];
+ ec_mbxbuft mbx[EC_MBXPOOLSIZE];
} ec_mbxpoolt;
-#define EC_MBXQUEUESTATE_NONE 0
-#define EC_MBXQUEUESTATE_REQ 1
-#define EC_MBXQUEUESTATE_FAIL 2
-#define EC_MBXQUEUESTATE_DONE 3
+#define EC_MBXQUEUESTATE_NONE 0
+#define EC_MBXQUEUESTATE_REQ 1
+#define EC_MBXQUEUESTATE_FAIL 2
+#define EC_MBXQUEUESTATE_DONE 3
typedef struct
{
- int listhead, listtail, listcount;
- ec_mbxbuft *mbx[EC_MBXPOOLSIZE];
- int mbxstate[EC_MBXPOOLSIZE];
- int mbxremove[EC_MBXPOOLSIZE];
- int mbxticket[EC_MBXPOOLSIZE];
- uint16 mbxslave[EC_MBXPOOLSIZE];
+ int listhead, listtail, listcount;
+ ec_mbxbuft *mbx[EC_MBXPOOLSIZE];
+ int mbxstate[EC_MBXPOOLSIZE];
+ int mbxremove[EC_MBXPOOLSIZE];
+ int mbxticket[EC_MBXPOOLSIZE];
+ uint16 mbxslave[EC_MBXPOOLSIZE];
osal_mutext *mbxmutex;
} ec_mbxqueuet;
typedef struct ecx_context ecx_contextt;
-#define ECT_MBXH_NONE 0
-#define ECT_MBXH_CYCLIC 1
-#define ECT_MBXH_LOST 2
+#define ECT_MBXH_NONE 0
+#define ECT_MBXH_CYCLIC 1
+#define ECT_MBXH_LOST 2
/** for list of ethercat slaves detected */
typedef struct ec_slave
{
/** state of slave */
- uint16 state;
+ uint16 state;
/** AL status code */
- uint16 ALstatuscode;
+ uint16 ALstatuscode;
/** Configured address */
- uint16 configadr;
+ uint16 configadr;
/** Alias address */
- uint16 aliasadr;
+ uint16 aliasadr;
/** Manufacturer from EEprom */
- uint32 eep_man;
+ uint32 eep_man;
/** ID from EEprom */
- uint32 eep_id;
+ uint32 eep_id;
/** revision from EEprom */
- uint32 eep_rev;
+ uint32 eep_rev;
/** serial number from EEprom */
- uint32 eep_ser;
+ uint32 eep_ser;
/** Interface type */
- uint16 Itype;
+ uint16 Itype;
/** Device type */
- uint16 Dtype;
+ uint16 Dtype;
/** output bits */
- uint16 Obits;
+ uint16 Obits;
/** output bytes, if Obits < 8 then Obytes = 0 */
- uint32 Obytes;
+ uint32 Obytes;
/** output pointer in IOmap buffer */
- uint8 *outputs;
+ uint8 *outputs;
/** output offset in IOmap buffer */
- uint32 Ooffset;
+ uint32 Ooffset;
/** startbit in first output byte */
- uint8 Ostartbit;
+ uint8 Ostartbit;
/** input bits */
- uint16 Ibits;
+ uint16 Ibits;
/** input bytes, if Ibits < 8 then Ibytes = 0 */
- uint32 Ibytes;
+ uint32 Ibytes;
/** input pointer in IOmap buffer */
- uint8 *inputs;
+ uint8 *inputs;
/** input offset in IOmap buffer */
- uint32 Ioffset;
+ uint32 Ioffset;
/** startbit in first input byte */
- uint8 Istartbit;
+ uint8 Istartbit;
/** SM structure */
- ec_smt SM[EC_MAXSM];
+ ec_smt SM[EC_MAXSM];
/** SM type 0=unused 1=MbxWr 2=MbxRd 3=Outputs 4=Inputs */
- uint8 SMtype[EC_MAXSM];
+ uint8 SMtype[EC_MAXSM];
/** FMMU structure */
- ec_fmmut FMMU[EC_MAXFMMU];
+ ec_fmmut FMMU[EC_MAXFMMU];
/** FMMU0 function 0=unused 1=outputs 2=inputs 3=SM status*/
- uint8 FMMU0func;
+ uint8 FMMU0func;
/** FMMU1 function */
- uint8 FMMU1func;
+ uint8 FMMU1func;
/** FMMU2 function */
- uint8 FMMU2func;
+ uint8 FMMU2func;
/** FMMU3 function */
- uint8 FMMU3func;
+ uint8 FMMU3func;
/** length of write mailbox in bytes, if no mailbox then 0 */
- uint16 mbx_l;
+ uint16 mbx_l;
/** mailbox write offset */
- uint16 mbx_wo;
+ uint16 mbx_wo;
/** length of read mailbox in bytes */
- uint16 mbx_rl;
+ uint16 mbx_rl;
/** mailbox read offset */
- uint16 mbx_ro;
+ uint16 mbx_ro;
/** mailbox supported protocols */
- uint16 mbx_proto;
+ uint16 mbx_proto;
/** Counter value of mailbox link layer protocol 1..7 */
- uint8 mbx_cnt;
+ uint8 mbx_cnt;
/** has DC capability */
- boolean hasdc;
+ boolean hasdc;
/** Physical type; Ebus, EtherNet combinations */
- uint8 ptype;
+ uint8 ptype;
/** topology: 1 to 3 links */
- uint8 topology;
+ uint8 topology;
/** active ports bitmap : ....3210 , set if respective port is active **/
- uint8 activeports;
+ uint8 activeports;
/** consumed ports bitmap : ....3210, used for internal delay measurement **/
- uint8 consumedports;
+ uint8 consumedports;
/** slave number for parent, 0=master */
- uint16 parent;
+ uint16 parent;
/** port number on parent this slave is connected to **/
- uint8 parentport;
+ uint8 parentport;
/** port number on this slave the parent is connected to **/
- uint8 entryport;
+ uint8 entryport;
/** DC receivetimes on port A */
- int32 DCrtA;
+ int32 DCrtA;
/** DC receivetimes on port B */
- int32 DCrtB;
+ int32 DCrtB;
/** DC receivetimes on port C */
- int32 DCrtC;
+ int32 DCrtC;
/** DC receivetimes on port D */
- int32 DCrtD;
+ int32 DCrtD;
/** propagation delay */
- int32 pdelay;
+ int32 pdelay;
/** next DC slave */
- uint16 DCnext;
+ uint16 DCnext;
/** previous DC slave */
- uint16 DCprevious;
+ uint16 DCprevious;
/** DC cycle time in ns */
- int32 DCcycle;
+ int32 DCcycle;
/** DC shift from clock modulus boundary */
- int32 DCshift;
+ int32 DCshift;
/** DC sync activation, 0=off, 1=on */
uint8 DCactive;
/** link to SII config */
- uint16 SIIindex;
+ uint16 SIIindex;
/** 1 = 8 bytes per read, 0 = 4 bytes per read */
- uint8 eep_8byte;
+ uint8 eep_8byte;
/** 0 = eeprom to master , 1 = eeprom to PDI */
- uint8 eep_pdi;
+ uint8 eep_pdi;
/** CoE details */
- uint8 CoEdetails;
+ uint8 CoEdetails;
/** FoE details */
- uint8 FoEdetails;
+ uint8 FoEdetails;
/** EoE details */
- uint8 EoEdetails;
+ uint8 EoEdetails;
/** SoE details */
- uint8 SoEdetails;
+ uint8 SoEdetails;
/** E-bus current */
- int16 Ebuscurrent;
+ int16 Ebuscurrent;
/** if >0 block use of LRW in processdata */
- uint8 blockLRW;
+ uint8 blockLRW;
/** group */
- uint8 group;
+ uint8 group;
/** first unused FMMU */
- uint8 FMMUunused;
+ uint8 FMMUunused;
/** Boolean for tracking whether the slave is (not) responding, not used/set by the SOEM library */
- boolean islost;
+ boolean islost;
/** registered configuration function PO->SO */
int (*PO2SOconfig)(ecx_contextt *context, uint16 slave);
/** mailbox handler state, 0 = no handler, 1 = cyclic task mbx handler, 2 = slave lost */
- int mbxhandlerstate;
+ int mbxhandlerstate;
/** mailbox handler robust mailbox protocol state */
- int mbxrmpstate;
+ int mbxrmpstate;
/** mailbox handler RMP extended mbx in state */
- uint16 mbxinstateex;
+ uint16 mbxinstateex;
/** pointer to CoE mailbox in buffer */
- uint8 *coembxin;
+ uint8 *coembxin;
/** CoE mailbox in flag, true = mailbox full */
- boolean coembxinfull;
+ boolean coembxinfull;
/** CoE mailbox in overrun counter */
- int coembxoverrun;
+ int coembxoverrun;
/** pointer to SoE mailbox in buffer */
- uint8 *soembxin;
+ uint8 *soembxin;
/** SoE mailbox in flag, true = mailbox full */
- boolean soembxinfull;
+ boolean soembxinfull;
/** SoE mailbox in overrun counter */
- int soembxoverrun;
+ int soembxoverrun;
/** pointer to FoE mailbox in buffer */
- uint8 *foembxin;
+ uint8 *foembxin;
/** FoE mailbox in flag, true = mailbox full */
- boolean foembxinfull;
+ boolean foembxinfull;
/** FoE mailbox in overrun counter */
- int foembxoverrun;
+ int foembxoverrun;
/** pointer to EoE mailbox in buffer */
- uint8 *eoembxin;
+ uint8 *eoembxin;
/** EoE mailbox in flag, true = mailbox full */
- boolean eoembxinfull;
+ boolean eoembxinfull;
/** EoE mailbox in overrun counter */
- int eoembxoverrun;
+ int eoembxoverrun;
/** pointer to VoE mailbox in buffer */
- uint8 *voembxin;
+ uint8 *voembxin;
/** VoE mailbox in flag, true = mailbox full */
- boolean voembxinfull;
+ boolean voembxinfull;
/** VoE mailbox in overrun counter */
- int voembxoverrun;
+ int voembxoverrun;
/** pointer to AoE mailbox in buffer */
- uint8 *aoembxin;
+ uint8 *aoembxin;
/** AoE mailbox in flag, true = mailbox full */
- boolean aoembxinfull;
+ boolean aoembxinfull;
/** AoE mailbox in overrun counter */
- int aoembxoverrun;
+ int aoembxoverrun;
/** pointer to out mailbox status register buffer */
- uint8 *mbxstatus;
+ uint8 *mbxstatus;
/** readable name */
- char name[EC_MAXNAME + 1];
+ char name[EC_MAXNAME + 1];
} ec_slavet;
/** for list of ethercat slave groups */
typedef struct ec_group
{
/** logical start address for this group */
- uint32 logstartaddr;
+ uint32 logstartaddr;
/** output bytes, if Obits < 8 then Obytes = 0 */
- uint32 Obytes;
+ uint32 Obytes;
/** output pointer in IOmap buffer */
- uint8 *outputs;
+ uint8 *outputs;
/** input bytes, if Ibits < 8 then Ibytes = 0 */
- uint32 Ibytes;
+ uint32 Ibytes;
/** input pointer in IOmap buffer */
- uint8 *inputs;
+ uint8 *inputs;
/** has DC capabillity */
- boolean hasdc;
+ boolean hasdc;
/** next DC slave */
- uint16 DCnext;
+ uint16 DCnext;
/** E-bus current */
- int16 Ebuscurrent;
+ int16 Ebuscurrent;
/** if >0 block use of LRW in processdata */
- uint8 blockLRW;
+ uint8 blockLRW;
/** IO segments used */
- uint16 nsegments;
+ uint16 nsegments;
/** 1st input segment */
- uint16 Isegment;
+ uint16 Isegment;
/** Offset in input segment */
- uint16 Ioffset;
+ uint16 Ioffset;
/** Expected workcounter outputs */
- uint16 outputsWKC;
+ uint16 outputsWKC;
/** Expected workcounter inputs */
- uint16 inputsWKC;
+ uint16 inputsWKC;
/** check slave states */
- boolean docheckstate;
+ boolean docheckstate;
/** IO segmentation list. Datagrams must not break SM in two. */
- uint32 IOsegment[EC_MAXIOSEGMENTS];
+ uint32 IOsegment[EC_MAXIOSEGMENTS];
/** pointer to out mailbox status register buffer */
- uint8 *mbxstatus;
+ uint8 *mbxstatus;
/** mailbox status register buffer length */
- int32 mbxstatuslength;
+ int32 mbxstatuslength;
/** mailbox status lookup table */
- uint16 mbxstatuslookup[EC_MAXSLAVE];
+ uint16 mbxstatuslookup[EC_MAXSLAVE];
/** mailbox last handled in mxbhandler */
- uint16 lastmbxpos;
+ uint16 lastmbxpos;
/** mailbox transmit queue struct */
- ec_mbxqueuet mbxtxqueue;
+ ec_mbxqueuet mbxtxqueue;
} ec_groupt;
/** SII FMMU structure */
typedef struct ec_eepromFMMU
{
- uint16 Startpos;
- uint8 nFMMU;
- uint8 FMMU0;
- uint8 FMMU1;
- uint8 FMMU2;
- uint8 FMMU3;
+ uint16 Startpos;
+ uint8 nFMMU;
+ uint8 FMMU0;
+ uint8 FMMU1;
+ uint8 FMMU2;
+ uint8 FMMU3;
} ec_eepromFMMUt;
/** SII SM structure */
typedef struct ec_eepromSM
{
- uint16 Startpos;
- uint8 nSM;
- uint16 PhStart;
- uint16 Plength;
- uint8 Creg;
- uint8 Sreg; /* don't care */
- uint8 Activate;
- uint8 PDIctrl; /* don't care */
+ uint16 Startpos;
+ uint8 nSM;
+ uint16 PhStart;
+ uint16 Plength;
+ uint8 Creg;
+ uint8 Sreg; /* don't care */
+ uint8 Activate;
+ uint8 PDIctrl; /* don't care */
} ec_eepromSMt;
/** record to store rxPDO and txPDO table from eeprom */
typedef struct ec_eepromPDO
{
- uint16 Startpos;
- uint16 Length;
- uint16 nPDO;
- uint16 Index[EC_MAXEEPDO];
- uint16 SyncM[EC_MAXEEPDO];
- uint16 BitSize[EC_MAXEEPDO];
- uint16 SMbitsize[EC_MAXSM];
+ uint16 Startpos;
+ uint16 Length;
+ uint16 nPDO;
+ uint16 Index[EC_MAXEEPDO];
+ uint16 SyncM[EC_MAXEEPDO];
+ uint16 BitSize[EC_MAXEEPDO];
+ uint16 SMbitsize[EC_MAXSM];
} ec_eepromPDOt;
/** standard ethercat mailbox header */
PACKED_BEGIN
typedef struct PACKED ec_mbxheader
{
- uint16 length;
- uint16 address;
- uint8 priority;
- uint8 mbxtype;
+ uint16 length;
+ uint16 address;
+ uint8 priority;
+ uint8 mbxtype;
} ec_mbxheadert;
PACKED_END
PACKED_BEGIN
typedef struct PACKED ec_alstatus
{
- uint16 alstatus;
- uint16 unused;
- uint16 alstatuscode;
+ uint16 alstatus;
+ uint16 unused;
+ uint16 alstatuscode;
} ec_alstatust;
PACKED_END
/** stack structure to store segmented LRD/LWR/LRW constructs */
typedef struct ec_idxstack
{
- uint8 pushed;
- uint8 pulled;
- uint8 idx[EC_MAXBUF];
- void *data[EC_MAXBUF];
- uint16 length[EC_MAXBUF];
- uint16 dcoffset[EC_MAXBUF];
- uint8 type[EC_MAXBUF];
+ uint8 pushed;
+ uint8 pulled;
+ uint8 idx[EC_MAXBUF];
+ void *data[EC_MAXBUF];
+ uint16 length[EC_MAXBUF];
+ uint16 dcoffset[EC_MAXBUF];
+ uint8 type[EC_MAXBUF];
} ec_idxstackT;
/** ringbuf for error storage */
typedef struct ec_ering
{
- int16 head;
- int16 tail;
+ int16 head;
+ int16 tail;
ec_errort Error[EC_MAXELIST + 1];
} ec_eringt;
PACKED_BEGIN
typedef struct PACKED ec_SMcommtype
{
- uint8 n;
- uint8 nu1;
- uint8 SMtype[EC_MAXSM];
+ uint8 n;
+ uint8 nu1;
+ uint8 SMtype[EC_MAXSM];
} ec_SMcommtypet;
PACKED_END
PACKED_BEGIN
typedef struct PACKED ec_PDOassign
{
- uint8 n;
- uint8 nu1;
- uint16 index[256];
+ uint8 n;
+ uint8 nu1;
+ uint16 index[256];
} ec_PDOassignt;
PACKED_END
PACKED_BEGIN
typedef struct PACKED ec_PDOdesc
{
- uint8 n;
- uint8 nu1;
- uint32 PDO[256];
+ uint8 n;
+ uint8 nu1;
+ uint32 PDO[256];
} ec_PDOdesct;
PACKED_END
struct ecx_context
{
/** port reference, may include red_port */
- ecx_portt *port;
+ ecx_portt *port;
/** slavelist reference */
- ec_slavet *slavelist;
+ ec_slavet *slavelist;
/** number of slaves found in configuration */
- int *slavecount;
+ int *slavecount;
/** maximum number of slaves allowed in slavelist */
- int maxslave;
+ int maxslave;
/** grouplist reference */
- ec_groupt *grouplist;
+ ec_groupt *grouplist;
/** maximum number of groups allowed in grouplist */
- int maxgroup;
+ int maxgroup;
/** internal, reference to eeprom cache buffer */
- uint8 *esibuf;
+ uint8 *esibuf;
/** internal, reference to eeprom cache map */
- uint32 *esimap;
+ uint32 *esimap;
/** internal, current slave for eeprom cache */
- uint16 esislave;
+ uint16 esislave;
/** internal, reference to error list */
- ec_eringt *elist;
+ ec_eringt *elist;
/** internal, reference to processdata stack buffer info */
- ec_idxstackT *idxstack;
+ ec_idxstackT *idxstack;
/** reference to ecaterror state */
- boolean *ecaterror;
+ boolean *ecaterror;
/** reference to last DC time from slaves */
- int64 *DCtime;
+ int64 *DCtime;
/** internal, SM buffer */
ec_SMcommtypet *SMcommtype;
/** internal, PDO assign list */
- ec_PDOassignt *PDOassign;
+ ec_PDOassignt *PDOassign;
/** internal, PDO description list */
- ec_PDOdesct *PDOdesc;
+ ec_PDOdesct *PDOdesc;
/** internal, SM list from eeprom */
- ec_eepromSMt *eepSM;
+ ec_eepromSMt *eepSM;
/** internal, FMMU list from eeprom */
ec_eepromFMMUt *eepFMMU;
/** internal, mailbox pool */
- ec_mbxpoolt *mbxpool;
+ ec_mbxpoolt *mbxpool;
/** registered FoE hook */
- int (*FOEhook)(uint16 slave, int packetnumber, int datasize);
+ int (*FOEhook)(uint16 slave, int packetnumber, int datasize);
/** registered EoE hook */
- int (*EOEhook)(ecx_contextt * context, uint16 slave, void * eoembx);
+ int (*EOEhook)(ecx_contextt *context, uint16 slave, void *eoembx);
/** flag to control legacy automatic state change or manual state change */
- int manualstatechange;
+ int manualstatechange;
/** opaque pointer to application userdata, never used by SOEM. */
- void *userdata;
+ void *userdata;
};
-ec_adaptert * ec_find_adapters(void);
-void ec_free_adapters(ec_adaptert * adapter);
+ec_adaptert *ec_find_adapters(void);
+void ec_free_adapters(ec_adaptert *adapter);
uint8 ec_nextmbxcnt(uint8 cnt);
void ec_clearmbx(ec_mbxbuft *Mbx);
void ecx_pusherror(ecx_contextt *context, const ec_errort *Ec);
boolean ecx_poperror(ecx_contextt *context, ec_errort *Ec);
boolean ecx_iserror(ecx_contextt *context);
void ecx_packeterror(ecx_contextt *context, uint16 Slave, uint16 Index, uint8 SubIdx, uint16 ErrorCode);
-int ecx_init(ecx_contextt *context, const char * ifname);
+int ecx_init(ecx_contextt *context, const char *ifname);
int ecx_init_redundant(ecx_contextt *context, ecx_redportt *redport, const char *ifname, char *if2name);
void ecx_close(ecx_contextt *context);
uint8 ecx_siigetbyte(ecx_contextt *context, uint16 slave, uint16 address);
int16 ecx_siifind(ecx_contextt *context, uint16 slave, uint16 cat);
void ecx_siistring(ecx_contextt *context, char *str, uint16 slave, uint16 Sn);
-uint16 ecx_siiFMMU(ecx_contextt *context, uint16 slave, ec_eepromFMMUt* FMMU);
-uint16 ecx_siiSM(ecx_contextt *context, uint16 slave, ec_eepromSMt* SM);
-uint16 ecx_siiSMnext(ecx_contextt *context, uint16 slave, ec_eepromSMt* SM, uint16 n);
-uint32 ecx_siiPDO(ecx_contextt *context, uint16 slave, ec_eepromPDOt* PDO, uint8 t);
+uint16 ecx_siiFMMU(ecx_contextt *context, uint16 slave, ec_eepromFMMUt *FMMU);
+uint16 ecx_siiSM(ecx_contextt *context, uint16 slave, ec_eepromSMt *SM);
+uint16 ecx_siiSMnext(ecx_contextt *context, uint16 slave, ec_eepromSMt *SM, uint16 n);
+uint32 ecx_siiPDO(ecx_contextt *context, uint16 slave, ec_eepromPDOt *PDO, uint8 t);
int ecx_readstate(ecx_contextt *context);
int ecx_writestate(ecx_contextt *context, uint16 slave);
uint16 ecx_statecheck(ecx_contextt *context, uint16 slave, uint16 reqstate, int timeout);
int ecx_mbxhandler(ecx_contextt *context, uint8 group, int limit);
int ecx_mbxempty(ecx_contextt *context, uint16 slave, int timeout);
-int ecx_mbxsend(ecx_contextt *context, uint16 slave,ec_mbxbuft *mbx, int timeout);
+int ecx_mbxsend(ecx_contextt *context, uint16 slave, ec_mbxbuft *mbx, int timeout);
int ecx_mbxreceive(ecx_contextt *context, uint16 slave, ec_mbxbuft **mbx, int timeout);
void ecx_esidump(ecx_contextt *context, uint16 slave, uint8 *esibuf);
uint32 ecx_readeeprom(ecx_contextt *context, uint16 slave, uint16 eeproma, int timeout);
#define _ec_print_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
-const char* ec_sdoerror2string( uint32 sdoerrorcode);
-char* ec_ALstatuscode2string( uint16 ALstatuscode);
-char* ec_soeerror2string( uint16 errorcode);
-char* ec_mbxerror2string( uint16 errorcode);
-char* ecx_err2string(const ec_errort Ec);
-char* ecx_elist2string(ecx_contextt *context);
+const char *ec_sdoerror2string(uint32 sdoerrorcode);
+char *ec_ALstatuscode2string(uint16 ALstatuscode);
+char *ec_soeerror2string(uint16 errorcode);
+char *ec_mbxerror2string(uint16 errorcode);
+char *ecx_err2string(const ec_errort Ec);
+char *ecx_elist2string(ecx_contextt *context);
#ifdef __cplusplus
}
#define _ec_soe_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
-#define EC_SOE_DATASTATE_B 0x01
-#define EC_SOE_NAME_B 0x02
-#define EC_SOE_ATTRIBUTE_B 0x04
-#define EC_SOE_UNIT_B 0x08
-#define EC_SOE_MIN_B 0x10
-#define EC_SOE_MAX_B 0x20
-#define EC_SOE_VALUE_B 0x40
-#define EC_SOE_DEFAULT_B 0x80
+#define EC_SOE_DATASTATE_B 0x01
+#define EC_SOE_NAME_B 0x02
+#define EC_SOE_ATTRIBUTE_B 0x04
+#define EC_SOE_UNIT_B 0x08
+#define EC_SOE_MIN_B 0x10
+#define EC_SOE_MAX_B 0x20
+#define EC_SOE_VALUE_B 0x40
+#define EC_SOE_DEFAULT_B 0x80
-#define EC_SOE_MAXNAME 60
-#define EC_SOE_MAXMAPPING 64
+#define EC_SOE_MAXNAME 60
+#define EC_SOE_MAXMAPPING 64
-#define EC_IDN_MDTCONFIG 24
-#define EC_IDN_ATCONFIG 16
+#define EC_IDN_MDTCONFIG 24
+#define EC_IDN_ATCONFIG 16
/** SoE name structure */
PACKED_BEGIN
typedef struct PACKED
{
/** current length in bytes of list */
- uint16 currentlength;
+ uint16 currentlength;
/** maximum length in bytes of list */
- uint16 maxlength;
- char name[EC_SOE_MAXNAME];
+ uint16 maxlength;
+ char name[EC_SOE_MAXNAME];
} ec_SoEnamet;
PACKED_END
typedef struct PACKED
{
/** current length in bytes of list */
- uint16 currentlength;
+ uint16 currentlength;
/** maximum length in bytes of list */
- uint16 maxlength;
+ uint16 maxlength;
union
{
- uint8 byte[8];
- uint16 word[4];
- uint32 dword[2];
- uint64 lword[1];
+ uint8 byte[8];
+ uint16 word[4];
+ uint32 dword[2];
+ uint64 lword[1];
};
} ec_SoElistt;
PACKED_END
typedef struct PACKED
{
/** current length in bytes of list */
- uint16 currentlength;
+ uint16 currentlength;
/** maximum length in bytes of list */
- uint16 maxlength;
- uint16 idn[EC_SOE_MAXMAPPING];
+ uint16 maxlength;
+ uint16 idn[EC_SOE_MAXMAPPING];
} ec_SoEmappingt;
PACKED_END
-#define EC_SOE_LENGTH_1 0x00
-#define EC_SOE_LENGTH_2 0x01
-#define EC_SOE_LENGTH_4 0x02
-#define EC_SOE_LENGTH_8 0x03
-#define EC_SOE_TYPE_BINARY 0x00
-#define EC_SOE_TYPE_UINT 0x01
-#define EC_SOE_TYPE_INT 0x02
-#define EC_SOE_TYPE_HEX 0x03
-#define EC_SOE_TYPE_STRING 0x04
-#define EC_SOE_TYPE_IDN 0x05
-#define EC_SOE_TYPE_FLOAT 0x06
-#define EC_SOE_TYPE_PARAMETER 0x07
+#define EC_SOE_LENGTH_1 0x00
+#define EC_SOE_LENGTH_2 0x01
+#define EC_SOE_LENGTH_4 0x02
+#define EC_SOE_LENGTH_8 0x03
+#define EC_SOE_TYPE_BINARY 0x00
+#define EC_SOE_TYPE_UINT 0x01
+#define EC_SOE_TYPE_INT 0x02
+#define EC_SOE_TYPE_HEX 0x03
+#define EC_SOE_TYPE_STRING 0x04
+#define EC_SOE_TYPE_IDN 0x05
+#define EC_SOE_TYPE_FLOAT 0x06
+#define EC_SOE_TYPE_PARAMETER 0x07
/** SoE attribute structure */
PACKED_BEGIN
typedef struct PACKED
{
/** evaluation factor for display purposes */
- uint32 evafactor :16;
+ uint32 evafactor : 16;
/** length of IDN element(s) */
- uint32 length :2;
+ uint32 length : 2;
/** IDN is list */
- uint32 list :1;
+ uint32 list : 1;
/** IDN is command */
- uint32 command :1;
+ uint32 command : 1;
/** datatype */
- uint32 datatype :3;
- uint32 reserved1 :1;
+ uint32 datatype : 3;
+ uint32 reserved1 : 1;
/** decimals to display if float datatype */
- uint32 decimals :4;
+ uint32 decimals : 4;
/** write protected in pre-op */
- uint32 wppreop :1;
+ uint32 wppreop : 1;
/** write protected in safe-op */
- uint32 wpsafeop :1;
+ uint32 wpsafeop : 1;
/** write protected in op */
- uint32 wpop :1;
- uint32 reserved2 :1;
+ uint32 wpop : 1;
+ uint32 reserved2 : 1;
} ec_SoEattributet;
PACKED_END
#define _EC_TYPE_H
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include "osal.h"
/** Define little endian target by default if no endian is set */
#if !defined(EC_LITTLE_ENDIAN) && !defined(EC_BIG_ENDIAN)
-# define EC_LITTLE_ENDIAN
+#define EC_LITTLE_ENDIAN
#endif
/** return value no frame returned */
/** return value request timeout */
#define EC_TIMEOUT -5
/** maximum EtherCAT frame length in bytes */
-#define EC_MAXECATFRAME 1518
+#define EC_MAXECATFRAME 1518
/** maximum EtherCAT LRW frame length in bytes */
/* MTU - Ethernet header - length - datagram header - WCK - FCS */
-#define EC_MAXLRWDATA (EC_MAXECATFRAME - 14 - 2 - 10 - 2 - 4)
+#define EC_MAXLRWDATA (EC_MAXECATFRAME - 14 - 2 - 10 - 2 - 4)
/** size of DC datagram used in first LRW frame */
-#define EC_FIRSTDCDATAGRAM 20
+#define EC_FIRSTDCDATAGRAM 20
/** standard frame buffer size in bytes */
-#define EC_BUFSIZE EC_MAXECATFRAME
+#define EC_BUFSIZE EC_MAXECATFRAME
/** datagram type EtherCAT */
-#define EC_ECATTYPE 0x1000
+#define EC_ECATTYPE 0x1000
/** number of frame buffers per channel (tx, rx1 rx2) */
-#define EC_MAXBUF 16
+#define EC_MAXBUF 16
/** timeout value in us for tx frame to return to rx */
-#define EC_TIMEOUTRET 2000
+#define EC_TIMEOUTRET 2000
/** timeout value in us for safe data transfer, max. triple retry */
-#define EC_TIMEOUTRET3 (EC_TIMEOUTRET * 3)
+#define EC_TIMEOUTRET3 (EC_TIMEOUTRET * 3)
/** timeout value in us for return "safe" variant (f.e. wireless) */
-#define EC_TIMEOUTSAFE 20000
+#define EC_TIMEOUTSAFE 20000
/** timeout value in us for EEPROM access */
-#define EC_TIMEOUTEEP 20000
+#define EC_TIMEOUTEEP 20000
/** timeout value in us for tx mailbox cycle */
-#define EC_TIMEOUTTXM 20000
+#define EC_TIMEOUTTXM 20000
/** timeout value in us for rx mailbox cycle */
-#define EC_TIMEOUTRXM 700000
+#define EC_TIMEOUTRXM 700000
/** timeout value in us for check statechange */
-#define EC_TIMEOUTSTATE 2000000
+#define EC_TIMEOUTSTATE 2000000
/** size of EEPROM bitmap cache */
-#define EC_MAXEEPBITMAP 128
+#define EC_MAXEEPBITMAP 128
/** size of EEPROM cache buffer */
-#define EC_MAXEEPBUF EC_MAXEEPBITMAP << 5
+#define EC_MAXEEPBUF EC_MAXEEPBITMAP << 5
/** default number of retries if wkc <= 0 */
-#define EC_DEFAULTRETRIES 3
+#define EC_DEFAULTRETRIES 3
/** default group size in 2^x */
-#define EC_LOGGROUPOFFSET 16
+#define EC_LOGGROUPOFFSET 16
/** definition for frame buffers */
typedef uint8 ec_bufT[EC_BUFSIZE];
typedef struct PACKED
{
/** destination MAC */
- uint16 da0,da1,da2;
+ uint16 da0, da1, da2;
/** source MAC */
- uint16 sa0,sa1,sa2;
+ uint16 sa0, sa1, sa2;
/** ethernet type */
- uint16 etype;
+ uint16 etype;
} ec_etherheadert;
PACKED_END
/** ethernet header size */
-#define ETH_HEADERSIZE sizeof(ec_etherheadert)
+#define ETH_HEADERSIZE sizeof(ec_etherheadert)
/** EtherCAT datagram header definition */
PACKED_BEGIN
typedef struct PACKED
{
/** length of EtherCAT datagram */
- uint16 elength;
+ uint16 elength;
/** EtherCAT command, see ec_cmdtype */
- uint8 command;
+ uint8 command;
/** index, used in SOEM for Tx to Rx recombination */
- uint8 index;
+ uint8 index;
/** ADP */
- uint16 ADP;
+ uint16 ADP;
/** ADO */
- uint16 ADO;
+ uint16 ADO;
/** length of data portion in datagram */
- uint16 dlength;
+ uint16 dlength;
/** interrupt, currently unused */
- uint16 irpt;
+ uint16 irpt;
} ec_comt;
PACKED_END
/** EtherCAT header size */
-#define EC_HEADERSIZE sizeof(ec_comt)
+#define EC_HEADERSIZE sizeof(ec_comt)
/** size of ec_comt.elength item in EtherCAT header */
-#define EC_ELENGTHSIZE sizeof(uint16)
+#define EC_ELENGTHSIZE sizeof(uint16)
/** offset position of command in EtherCAT header */
-#define EC_CMDOFFSET EC_ELENGTHSIZE
+#define EC_CMDOFFSET EC_ELENGTHSIZE
/** size of workcounter item in EtherCAT datagram */
-#define EC_WKCSIZE sizeof(uint16)
+#define EC_WKCSIZE sizeof(uint16)
/** definition of datagram follows bit in ec_comt.dlength */
-#define EC_DATAGRAMFOLLOWS (1 << 15)
+#define EC_DATAGRAMFOLLOWS (1 << 15)
/** Possible error codes returned. */
typedef enum
{
/** No error */
- EC_ERR_OK = 0,
+ EC_ERR_OK = 0,
/** Library already initialized. */
EC_ERR_ALREADY_INITIALIZED,
/** Library not initialized. */
typedef enum
{
/** No valid state. */
- EC_STATE_NONE = 0x00,
+ EC_STATE_NONE = 0x00,
/** Init state*/
- EC_STATE_INIT = 0x01,
+ EC_STATE_INIT = 0x01,
/** Pre-operational. */
- EC_STATE_PRE_OP = 0x02,
+ EC_STATE_PRE_OP = 0x02,
/** Boot state*/
- EC_STATE_BOOT = 0x03,
+ EC_STATE_BOOT = 0x03,
/** Safe-operational. */
- EC_STATE_SAFE_OP = 0x04,
+ EC_STATE_SAFE_OP = 0x04,
/** Operational */
- EC_STATE_OPERATIONAL = 0x08,
+ EC_STATE_OPERATIONAL = 0x08,
/** Error or ACK error */
- EC_STATE_ACK = 0x10,
- EC_STATE_ERROR = 0x10
+ EC_STATE_ACK = 0x10,
+ EC_STATE_ERROR = 0x10
} ec_state;
/** Possible buffer states */
typedef enum
{
/** Empty */
- EC_BUF_EMPTY = 0x00,
+ EC_BUF_EMPTY = 0x00,
/** Allocated, but not filled */
- EC_BUF_ALLOC = 0x01,
+ EC_BUF_ALLOC = 0x01,
/** Transmitted */
- EC_BUF_TX = 0x02,
+ EC_BUF_TX = 0x02,
/** Received, but not consumed */
- EC_BUF_RCVD = 0x03,
+ EC_BUF_RCVD = 0x03,
/** Cycle completed */
- EC_BUF_COMPLETE = 0x04
+ EC_BUF_COMPLETE = 0x04
} ec_bufstate;
/** Ethercat data types */
typedef enum
{
- ECT_BOOLEAN = 0x0001,
- ECT_INTEGER8 = 0x0002,
- ECT_INTEGER16 = 0x0003,
- ECT_INTEGER32 = 0x0004,
- ECT_UNSIGNED8 = 0x0005,
- ECT_UNSIGNED16 = 0x0006,
- ECT_UNSIGNED32 = 0x0007,
- ECT_REAL32 = 0x0008,
- ECT_VISIBLE_STRING = 0x0009,
- ECT_OCTET_STRING = 0x000A,
- ECT_UNICODE_STRING = 0x000B,
- ECT_TIME_OF_DAY = 0x000C,
+ ECT_BOOLEAN = 0x0001,
+ ECT_INTEGER8 = 0x0002,
+ ECT_INTEGER16 = 0x0003,
+ ECT_INTEGER32 = 0x0004,
+ ECT_UNSIGNED8 = 0x0005,
+ ECT_UNSIGNED16 = 0x0006,
+ ECT_UNSIGNED32 = 0x0007,
+ ECT_REAL32 = 0x0008,
+ ECT_VISIBLE_STRING = 0x0009,
+ ECT_OCTET_STRING = 0x000A,
+ ECT_UNICODE_STRING = 0x000B,
+ ECT_TIME_OF_DAY = 0x000C,
ECT_TIME_DIFFERENCE = 0x000D,
- ECT_DOMAIN = 0x000F,
- ECT_INTEGER24 = 0x0010,
- ECT_REAL64 = 0x0011,
- ECT_INTEGER64 = 0x0015,
- ECT_UNSIGNED24 = 0x0016,
- ECT_UNSIGNED64 = 0x001B,
- ECT_BIT1 = 0x0030,
- ECT_BIT2 = 0x0031,
- ECT_BIT3 = 0x0032,
- ECT_BIT4 = 0x0033,
- ECT_BIT5 = 0x0034,
- ECT_BIT6 = 0x0035,
- ECT_BIT7 = 0x0036,
- ECT_BIT8 = 0x0037
+ ECT_DOMAIN = 0x000F,
+ ECT_INTEGER24 = 0x0010,
+ ECT_REAL64 = 0x0011,
+ ECT_INTEGER64 = 0x0015,
+ ECT_UNSIGNED24 = 0x0016,
+ ECT_UNSIGNED64 = 0x001B,
+ ECT_BIT1 = 0x0030,
+ ECT_BIT2 = 0x0031,
+ ECT_BIT3 = 0x0032,
+ ECT_BIT4 = 0x0033,
+ ECT_BIT5 = 0x0034,
+ ECT_BIT6 = 0x0035,
+ ECT_BIT7 = 0x0036,
+ ECT_BIT8 = 0x0037
} ec_datatype;
/** Ethercat command types */
typedef enum
{
/** No operation */
- EC_CMD_NOP = 0x00,
+ EC_CMD_NOP = 0x00,
/** Auto Increment Read */
EC_CMD_APRD,
/** Auto Increment Write */
typedef enum
{
/** No operation */
- EC_ECMD_NOP = 0x0000,
+ EC_ECMD_NOP = 0x0000,
/** Read */
- EC_ECMD_READ = 0x0100,
+ EC_ECMD_READ = 0x0100,
/** Write */
- EC_ECMD_WRITE = 0x0201,
+ EC_ECMD_WRITE = 0x0201,
/** Reload */
- EC_ECMD_RELOAD = 0x0300
+ EC_ECMD_RELOAD = 0x0300
} ec_ecmdtype;
/** EEprom state machine read size */
-#define EC_ESTAT_R64 0x0040
+#define EC_ESTAT_R64 0x0040
/** EEprom state machine busy flag */
-#define EC_ESTAT_BUSY 0x8000
+#define EC_ESTAT_BUSY 0x8000
/** EEprom state machine error flag mask */
-#define EC_ESTAT_EMASK 0x7800
+#define EC_ESTAT_EMASK 0x7800
/** EEprom state machine error acknowledge */
-#define EC_ESTAT_NACK 0x2000
+#define EC_ESTAT_NACK 0x2000
/* Ethercat SSI (Slave Information Interface) */
/** Start address SII sections in Eeprom */
-#define ECT_SII_START 0x0040
+#define ECT_SII_START 0x0040
enum
{
/** SII category strings */
- ECT_SII_STRING = 10,
+ ECT_SII_STRING = 10,
/** SII category general */
- ECT_SII_GENERAL = 30,
+ ECT_SII_GENERAL = 30,
/** SII category FMMU */
- ECT_SII_FMMU = 40,
+ ECT_SII_FMMU = 40,
/** SII category SM */
- ECT_SII_SM = 41,
+ ECT_SII_SM = 41,
/** SII category PDO */
- ECT_SII_PDO = 50
+ ECT_SII_PDO = 50
};
/** Item offsets in SII general section */
enum
{
- ECT_SII_MANUF = 0x0008,
- ECT_SII_ID = 0x000a,
- ECT_SII_REV = 0x000c,
- ECT_SII_SER = 0x000e,
- ECT_SII_BOOTRXMBX = 0x0014,
- ECT_SII_BOOTTXMBX = 0x0016,
- ECT_SII_MBXSIZE = 0x0019,
- ECT_SII_TXMBXADR = 0x001a,
- ECT_SII_RXMBXADR = 0x0018,
- ECT_SII_MBXPROTO = 0x001c
+ ECT_SII_MANUF = 0x0008,
+ ECT_SII_ID = 0x000a,
+ ECT_SII_REV = 0x000c,
+ ECT_SII_SER = 0x000e,
+ ECT_SII_BOOTRXMBX = 0x0014,
+ ECT_SII_BOOTTXMBX = 0x0016,
+ ECT_SII_MBXSIZE = 0x0019,
+ ECT_SII_TXMBXADR = 0x001a,
+ ECT_SII_RXMBXADR = 0x0018,
+ ECT_SII_MBXPROTO = 0x001c
};
/** Mailbox types definitions */
enum
{
/** Error mailbox type */
- ECT_MBXT_ERR = 0x00,
+ ECT_MBXT_ERR = 0x00,
/** ADS over EtherCAT mailbox type */
ECT_MBXT_AOE,
/** Ethernet over EtherCAT mailbox type */
/** Servo over EtherCAT mailbox type */
ECT_MBXT_SOE,
/** Vendor over EtherCAT mailbox type */
- ECT_MBXT_VOE = 0x0f
+ ECT_MBXT_VOE = 0x0f
};
/** CoE mailbox types */
enum
{
- ECT_COES_EMERGENCY = 0x01,
+ ECT_COES_EMERGENCY = 0x01,
ECT_COES_SDOREQ,
ECT_COES_SDORES,
ECT_COES_TXPDO,
/** CoE SDO commands */
enum
{
- ECT_SDO_DOWN_INIT = 0x21,
- ECT_SDO_DOWN_EXP = 0x23,
+ ECT_SDO_DOWN_INIT = 0x21,
+ ECT_SDO_DOWN_EXP = 0x23,
ECT_SDO_DOWN_INIT_CA = 0x31,
- ECT_SDO_UP_REQ = 0x40,
- ECT_SDO_UP_REQ_CA = 0x50,
- ECT_SDO_SEG_UP_REQ = 0x60,
- ECT_SDO_ABORT = 0x80
+ ECT_SDO_UP_REQ = 0x40,
+ ECT_SDO_UP_REQ_CA = 0x50,
+ ECT_SDO_SEG_UP_REQ = 0x60,
+ ECT_SDO_ABORT = 0x80
};
/** CoE Object Description commands */
enum
{
- ECT_GET_ODLIST_REQ = 0x01,
- ECT_GET_ODLIST_RES = 0x02,
- ECT_GET_OD_REQ = 0x03,
- ECT_GET_OD_RES = 0x04,
- ECT_GET_OE_REQ = 0x05,
- ECT_GET_OE_RES = 0x06,
- ECT_SDOINFO_ERROR = 0x07
+ ECT_GET_ODLIST_REQ = 0x01,
+ ECT_GET_ODLIST_RES = 0x02,
+ ECT_GET_OD_REQ = 0x03,
+ ECT_GET_OD_RES = 0x04,
+ ECT_GET_OE_REQ = 0x05,
+ ECT_GET_OE_RES = 0x06,
+ ECT_SDOINFO_ERROR = 0x07
};
/** FoE opcodes */
enum
{
- ECT_FOE_READ = 0x01,
+ ECT_FOE_READ = 0x01,
ECT_FOE_WRITE,
ECT_FOE_DATA,
ECT_FOE_ACK,
/** SoE opcodes */
enum
{
- ECT_SOE_READREQ = 0x01,
+ ECT_SOE_READREQ = 0x01,
ECT_SOE_READRES,
ECT_SOE_WRITEREQ,
ECT_SOE_WRITERES,
/** Ethercat registers */
enum
{
- ECT_REG_TYPE = 0x0000,
- ECT_REG_PORTDES = 0x0007,
- ECT_REG_ESCSUP = 0x0008,
- ECT_REG_STADR = 0x0010,
- ECT_REG_ALIAS = 0x0012,
- ECT_REG_DLCTL = 0x0100,
- ECT_REG_DLPORT = 0x0101,
- ECT_REG_DLALIAS = 0x0103,
- ECT_REG_DLSTAT = 0x0110,
- ECT_REG_ALCTL = 0x0120,
- ECT_REG_ALSTAT = 0x0130,
- ECT_REG_ALSTATCODE = 0x0134,
- ECT_REG_PDICTL = 0x0140,
- ECT_REG_IRQMASK = 0x0200,
- ECT_REG_RXERR = 0x0300,
- ECT_REG_FRXERR = 0x0308,
- ECT_REG_EPUECNT = 0x030C,
- ECT_REG_PECNT = 0x030D,
- ECT_REG_PECODE = 0x030E,
- ECT_REG_LLCNT = 0x0310,
- ECT_REG_WDCNT = 0x0442,
- ECT_REG_EEPCFG = 0x0500,
- ECT_REG_EEPCTL = 0x0502,
- ECT_REG_EEPSTAT = 0x0502,
- ECT_REG_EEPADR = 0x0504,
- ECT_REG_EEPDAT = 0x0508,
- ECT_REG_FMMU0 = 0x0600,
- ECT_REG_FMMU1 = ECT_REG_FMMU0 + 0x10,
- ECT_REG_FMMU2 = ECT_REG_FMMU1 + 0x10,
- ECT_REG_FMMU3 = ECT_REG_FMMU2 + 0x10,
- ECT_REG_SM0 = 0x0800,
- ECT_REG_SM1 = ECT_REG_SM0 + 0x08,
- ECT_REG_SM2 = ECT_REG_SM1 + 0x08,
- ECT_REG_SM3 = ECT_REG_SM2 + 0x08,
- ECT_REG_SM0STAT = ECT_REG_SM0 + 0x05,
- ECT_REG_SM1STAT = ECT_REG_SM1 + 0x05,
- ECT_REG_SM1ACT = ECT_REG_SM1 + 0x06,
- ECT_REG_SM1CONTR = ECT_REG_SM1 + 0x07,
- ECT_REG_DCTIME0 = 0x0900,
- ECT_REG_DCTIME1 = 0x0904,
- ECT_REG_DCTIME2 = 0x0908,
- ECT_REG_DCTIME3 = 0x090C,
- ECT_REG_DCSYSTIME = 0x0910,
- ECT_REG_DCSOF = 0x0918,
+ ECT_REG_TYPE = 0x0000,
+ ECT_REG_PORTDES = 0x0007,
+ ECT_REG_ESCSUP = 0x0008,
+ ECT_REG_STADR = 0x0010,
+ ECT_REG_ALIAS = 0x0012,
+ ECT_REG_DLCTL = 0x0100,
+ ECT_REG_DLPORT = 0x0101,
+ ECT_REG_DLALIAS = 0x0103,
+ ECT_REG_DLSTAT = 0x0110,
+ ECT_REG_ALCTL = 0x0120,
+ ECT_REG_ALSTAT = 0x0130,
+ ECT_REG_ALSTATCODE = 0x0134,
+ ECT_REG_PDICTL = 0x0140,
+ ECT_REG_IRQMASK = 0x0200,
+ ECT_REG_RXERR = 0x0300,
+ ECT_REG_FRXERR = 0x0308,
+ ECT_REG_EPUECNT = 0x030C,
+ ECT_REG_PECNT = 0x030D,
+ ECT_REG_PECODE = 0x030E,
+ ECT_REG_LLCNT = 0x0310,
+ ECT_REG_WDCNT = 0x0442,
+ ECT_REG_EEPCFG = 0x0500,
+ ECT_REG_EEPCTL = 0x0502,
+ ECT_REG_EEPSTAT = 0x0502,
+ ECT_REG_EEPADR = 0x0504,
+ ECT_REG_EEPDAT = 0x0508,
+ ECT_REG_FMMU0 = 0x0600,
+ ECT_REG_FMMU1 = ECT_REG_FMMU0 + 0x10,
+ ECT_REG_FMMU2 = ECT_REG_FMMU1 + 0x10,
+ ECT_REG_FMMU3 = ECT_REG_FMMU2 + 0x10,
+ ECT_REG_SM0 = 0x0800,
+ ECT_REG_SM1 = ECT_REG_SM0 + 0x08,
+ ECT_REG_SM2 = ECT_REG_SM1 + 0x08,
+ ECT_REG_SM3 = ECT_REG_SM2 + 0x08,
+ ECT_REG_SM0STAT = ECT_REG_SM0 + 0x05,
+ ECT_REG_SM1STAT = ECT_REG_SM1 + 0x05,
+ ECT_REG_SM1ACT = ECT_REG_SM1 + 0x06,
+ ECT_REG_SM1CONTR = ECT_REG_SM1 + 0x07,
+ ECT_REG_DCTIME0 = 0x0900,
+ ECT_REG_DCTIME1 = 0x0904,
+ ECT_REG_DCTIME2 = 0x0908,
+ ECT_REG_DCTIME3 = 0x090C,
+ ECT_REG_DCSYSTIME = 0x0910,
+ ECT_REG_DCSOF = 0x0918,
ECT_REG_DCSYSOFFSET = 0x0920,
- ECT_REG_DCSYSDELAY = 0x0928,
- ECT_REG_DCSYSDIFF = 0x092C,
- ECT_REG_DCSPEEDCNT = 0x0930,
- ECT_REG_DCTIMEFILT = 0x0934,
- ECT_REG_DCCUC = 0x0980,
- ECT_REG_DCSYNCACT = 0x0981,
- ECT_REG_DCSTART0 = 0x0990,
- ECT_REG_DCCYCLE0 = 0x09A0,
- ECT_REG_DCCYCLE1 = 0x09A4
+ ECT_REG_DCSYSDELAY = 0x0928,
+ ECT_REG_DCSYSDIFF = 0x092C,
+ ECT_REG_DCSPEEDCNT = 0x0930,
+ ECT_REG_DCTIMEFILT = 0x0934,
+ ECT_REG_DCCUC = 0x0980,
+ ECT_REG_DCSYNCACT = 0x0981,
+ ECT_REG_DCSTART0 = 0x0990,
+ ECT_REG_DCCYCLE0 = 0x09A0,
+ ECT_REG_DCCYCLE1 = 0x09A4
};
/** standard SDO Sync Manager Communication Type */
-#define ECT_SDO_SMCOMMTYPE 0x1c00
+#define ECT_SDO_SMCOMMTYPE 0x1c00
/** standard SDO PDO assignment */
-#define ECT_SDO_PDOASSIGN 0x1c10
+#define ECT_SDO_PDOASSIGN 0x1c10
/** standard SDO RxPDO assignment */
-#define ECT_SDO_RXPDOASSIGN 0x1c12
+#define ECT_SDO_RXPDOASSIGN 0x1c12
/** standard SDO TxPDO assignment */
-#define ECT_SDO_TXPDOASSIGN 0x1c13
+#define ECT_SDO_TXPDOASSIGN 0x1c13
/** Ethercat packet type */
-#define ETH_P_ECAT 0x88A4
+#define ETH_P_ECAT 0x88A4
/** Error types */
typedef enum
{
- EC_ERR_TYPE_SDO_ERROR = 0,
- EC_ERR_TYPE_EMERGENCY = 1,
- EC_ERR_TYPE_PACKET_ERROR = 3,
- EC_ERR_TYPE_SDOINFO_ERROR = 4,
- EC_ERR_TYPE_FOE_ERROR = 5,
- EC_ERR_TYPE_FOE_BUF2SMALL = 6,
- EC_ERR_TYPE_FOE_PACKETNUMBER = 7,
- EC_ERR_TYPE_SOE_ERROR = 8,
- EC_ERR_TYPE_MBX_ERROR = 9,
- EC_ERR_TYPE_FOE_FILE_NOTFOUND = 10,
- EC_ERR_TYPE_EOE_INVALID_RX_DATA = 11
+ EC_ERR_TYPE_SDO_ERROR = 0,
+ EC_ERR_TYPE_EMERGENCY = 1,
+ EC_ERR_TYPE_PACKET_ERROR = 3,
+ EC_ERR_TYPE_SDOINFO_ERROR = 4,
+ EC_ERR_TYPE_FOE_ERROR = 5,
+ EC_ERR_TYPE_FOE_BUF2SMALL = 6,
+ EC_ERR_TYPE_FOE_PACKETNUMBER = 7,
+ EC_ERR_TYPE_SOE_ERROR = 8,
+ EC_ERR_TYPE_MBX_ERROR = 9,
+ EC_ERR_TYPE_FOE_FILE_NOTFOUND = 10,
+ EC_ERR_TYPE_EOE_INVALID_RX_DATA = 11
} ec_err_type;
/** Struct to retrieve errors. */
/** Time at which the error was generated. */
ec_timet Time;
/** Signal bit, error set but not read */
- boolean Signal;
+ boolean Signal;
/** Slave number that generated the error */
- uint16 Slave;
+ uint16 Slave;
/** CoE SDO index that generated the error */
- uint16 Index;
+ uint16 Index;
/** CoE SDO subindex that generated the error */
- uint8 SubIdx;
+ uint8 SubIdx;
/** Type of error */
ec_err_type Etype;
union
{
/** General abortcode */
- int32 AbortCode;
+ int32 AbortCode;
/** Specific error for Emergency mailbox */
struct
{
- uint16 ErrorCode;
- uint8 ErrorReg;
- uint8 b1;
- uint16 w1;
- uint16 w2;
+ uint16 ErrorCode;
+ uint8 ErrorReg;
+ uint8 b1;
+ uint16 w1;
+ uint16 w2;
};
};
} ec_errort;
#define MBX_HDR_SET_CNT(cnt) ((uint8)((cnt) << 4))
/** Macro to make a word from 2 bytes */
-#define MK_WORD(msb, lsb) ((((uint16)(msb))<<8) | (lsb))
+#define MK_WORD(msb, lsb) ((((uint16)(msb)) << 8) | (lsb))
/** Macro to get hi byte of a word */
-#define HI_BYTE(w) ((w) >> 8)
+#define HI_BYTE(w) ((w) >> 8)
/** Macro to get low byte of a word */
-#define LO_BYTE(w) ((w) & 0x00ff)
+#define LO_BYTE(w) ((w) & 0x00ff)
/** Macro to swap hi and low byte of a word */
-#define SWAP(w) ((((w)& 0xff00) >> 8) | (((w) & 0x00ff) << 8))
+#define SWAP(w) ((((w) & 0xff00) >> 8) | (((w) & 0x00ff) << 8))
/** Macro to get hi word of a dword */
-#define LO_WORD(l) ((l) & 0xffff)
+#define LO_WORD(l) ((l) & 0xffff)
/** Macro to get hi word of a dword */
-#define HI_WORD(l) ((l) >> 16)
+#define HI_WORD(l) ((l) >> 16)
#define get_unaligned(ptr) \
- ({ __typeof__(*(ptr)) __tmp; memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
+ ({ __typeof__(*(ptr)) __tmp; memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
-#define put_unaligned32(val, ptr) \
- (memcpy((ptr), &(val), 4))
+#define put_unaligned32(val, ptr) \
+ (memcpy((ptr), &(val), 4))
-#define put_unaligned64(val, ptr) \
- (memcpy((ptr), &(val), 8))
+#define put_unaligned64(val, ptr) \
+ (memcpy((ptr), &(val), 8))
#if !defined(EC_BIG_ENDIAN) && defined(EC_LITTLE_ENDIAN)
- #define htoes(A) (A)
- #define htoel(A) (A)
- #define htoell(A) (A)
- #define etohs(A) (A)
- #define etohl(A) (A)
- #define etohll(A) (A)
+#define htoes(A) (A)
+#define htoel(A) (A)
+#define htoell(A) (A)
+#define etohs(A) (A)
+#define etohl(A) (A)
+#define etohll(A) (A)
#elif !defined(EC_LITTLE_ENDIAN) && defined(EC_BIG_ENDIAN)
- #define htoes(A) ((((uint16)(A) & 0xff00) >> 8) | \
- (((uint16)(A) & 0x00ff) << 8))
- #define htoel(A) ((((uint32)(A) & 0xff000000) >> 24) | \
- (((uint32)(A) & 0x00ff0000) >> 8) | \
- (((uint32)(A) & 0x0000ff00) << 8) | \
- (((uint32)(A) & 0x000000ff) << 24))
- #define htoell(A) ((((uint64)(A) & (uint64)0xff00000000000000ULL) >> 56) | \
- (((uint64)(A) & (uint64)0x00ff000000000000ULL) >> 40) | \
- (((uint64)(A) & (uint64)0x0000ff0000000000ULL) >> 24) | \
- (((uint64)(A) & (uint64)0x000000ff00000000ULL) >> 8) | \
- (((uint64)(A) & (uint64)0x00000000ff000000ULL) << 8) | \
- (((uint64)(A) & (uint64)0x0000000000ff0000ULL) << 24) | \
- (((uint64)(A) & (uint64)0x000000000000ff00ULL) << 40) | \
- (((uint64)(A) & (uint64)0x00000000000000ffULL) << 56))
-
- #define etohs htoes
- #define etohl htoel
- #define etohll htoell
+#define htoes(A) ((((uint16)(A) & 0xff00) >> 8) | \
+ (((uint16)(A) & 0x00ff) << 8))
+#define htoel(A) ((((uint32)(A) & 0xff000000) >> 24) | \
+ (((uint32)(A) & 0x00ff0000) >> 8) | \
+ (((uint32)(A) & 0x0000ff00) << 8) | \
+ (((uint32)(A) & 0x000000ff) << 24))
+#define htoell(A) ((((uint64)(A) & (uint64)0xff00000000000000ULL) >> 56) | \
+ (((uint64)(A) & (uint64)0x00ff000000000000ULL) >> 40) | \
+ (((uint64)(A) & (uint64)0x0000ff0000000000ULL) >> 24) | \
+ (((uint64)(A) & (uint64)0x000000ff00000000ULL) >> 8) | \
+ (((uint64)(A) & (uint64)0x00000000ff000000ULL) << 8) | \
+ (((uint64)(A) & (uint64)0x0000000000ff0000ULL) << 24) | \
+ (((uint64)(A) & (uint64)0x000000000000ff00ULL) << 40) | \
+ (((uint64)(A) & (uint64)0x00000000000000ffULL) << 56))
+
+#define etohs htoes
+#define etohl htoel
+#define etohll htoell
#else
- #error "Must define one of EC_BIG_ENDIAN or EC_LITTLE_ENDIAN"
+#error "Must define one of EC_BIG_ENDIAN or EC_LITTLE_ENDIAN"
#endif
#include "ee_x86_64_tsc.h"
-#define USECS_PER_SEC 1000000
-#define NSECS_PER_SEC 1000000000
+#define USECS_PER_SEC 1000000
+#define NSECS_PER_SEC 1000000000
uint64_t osEE_x86_64_tsc_read(void);
void ee_usleep(uint32 usec);
-inline int osal_usleep (uint32 usec)
+inline int osal_usleep(uint32 usec)
{
- ee_usleep(usec);
- return 0;
+ ee_usleep(usec);
+ return 0;
}
int osal_gettimeofday(struct timeval *tv, struct timezone *tz)
{
- uint64_t time = osEE_x86_64_tsc_read();
- tv->tv_sec = time/NSECS_PER_SEC;
- tv->tv_sec += 946684800UL; /* EtherCAT uses 2000-01-01 as epoch start */
- tv->tv_usec = (time%NSECS_PER_SEC)/1000;
- return 0;
+ uint64_t time = osEE_x86_64_tsc_read();
+ tv->tv_sec = time / NSECS_PER_SEC;
+ tv->tv_sec += 946684800UL; /* EtherCAT uses 2000-01-01 as epoch start */
+ tv->tv_usec = (time % NSECS_PER_SEC) / 1000;
+ return 0;
}
ec_timet osal_current_time(void)
{
- struct timeval current_time;
- ec_timet ret;
+ struct timeval current_time;
+ ec_timet ret;
- osal_gettimeofday(¤t_time, 0);
- ret.sec = current_time.tv_sec;
- ret.usec = current_time.tv_usec;
- return ret;
+ osal_gettimeofday(¤t_time, 0);
+ ret.sec = current_time.tv_sec;
+ ret.usec = current_time.tv_usec;
+ return ret;
}
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
- diff->sec = end->sec - start->sec - 1;
- diff->usec = end->usec + USECS_PER_SEC - start->usec;
- } else {
- diff->sec = end->sec - start->sec;
- diff->usec = end->usec - start->usec;
- }
+ if (end->usec < start->usec)
+ {
+ diff->sec = end->sec - start->sec - 1;
+ diff->usec = end->usec + USECS_PER_SEC - start->usec;
+ }
+ else
+ {
+ diff->sec = end->sec - start->sec;
+ diff->usec = end->usec - start->usec;
+ }
}
void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
- struct timeval start_time;
- struct timeval timeout;
- struct timeval stop_time;
+ struct timeval start_time;
+ struct timeval timeout;
+ struct timeval stop_time;
- osal_gettimeofday(&start_time, 0);
- timeout.tv_sec = timeout_usec / USECS_PER_SEC;
- timeout.tv_usec = timeout_usec % USECS_PER_SEC;
- timeradd(&start_time, &timeout, &stop_time);
+ osal_gettimeofday(&start_time, 0);
+ timeout.tv_sec = timeout_usec / USECS_PER_SEC;
+ timeout.tv_usec = timeout_usec % USECS_PER_SEC;
+ timeradd(&start_time, &timeout, &stop_time);
- self->stop_time.sec = stop_time.tv_sec;
- self->stop_time.usec = stop_time.tv_usec;
+ self->stop_time.sec = stop_time.tv_sec;
+ self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert *self)
+boolean osal_timer_is_expired(osal_timert *self)
{
- struct timeval current_time;
- struct timeval stop_time;
- int is_not_yet_expired;
-
- osal_gettimeofday (¤t_time, 0);
- stop_time.tv_sec = self->stop_time.sec;
- stop_time.tv_usec = self->stop_time.usec;
- is_not_yet_expired = timercmp (¤t_time, &stop_time, <);
-/* OSEE_PRINT("current: %d:%d -- expire: %d:%d -- result: %d\n", */
-/* current_time.tv_sec, */
-/* current_time.tv_usec, */
-/* stop_time.tv_sec, */
-/* stop_time.tv_usec, */
-/* is_not_yet_expired); */
-
- return is_not_yet_expired == FALSE;
+ struct timeval current_time;
+ struct timeval stop_time;
+ int is_not_yet_expired;
+
+ osal_gettimeofday(¤t_time, 0);
+ stop_time.tv_sec = self->stop_time.sec;
+ stop_time.tv_usec = self->stop_time.usec;
+ is_not_yet_expired = timercmp(¤t_time, &stop_time, <);
+ /* OSEE_PRINT("current: %d:%d -- expire: %d:%d -- result: %d\n", */
+ /* current_time.tv_sec, */
+ /* current_time.tv_usec, */
+ /* stop_time.tv_sec, */
+ /* stop_time.tv_usec, */
+ /* is_not_yet_expired); */
+
+ return is_not_yet_expired == FALSE;
}
void *osal_malloc(size_t size)
{
- return malloc(size);
+ return malloc(size);
}
void osal_free(void *ptr)
{
- free(ptr);
+ free(ptr);
}
-
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include <sys/time.h>
#ifdef EC_DEBUG
#define EC_PRINT OSEE_PRINT
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED_BEGIN
-#define PACKED __attribute__((__packed__))
+#define PACKED __attribute__((__packed__))
#define PACKED_END
#endif
static int64_t sysfrequency;
static double qpc2usec;
-#define USECS_PER_SEC 1000000
+#define USECS_PER_SEC 1000000
-int osal_gettimeofday (struct timeval *tv, struct timezone *tz)
+int osal_gettimeofday(struct timeval *tv, struct timezone *tz)
{
- return gettimeofday (tv, tz);
+ return gettimeofday(tv, tz);
}
-ec_timet osal_current_time (void)
+ec_timet osal_current_time(void)
{
struct timeval current_time;
ec_timet return_value;
- osal_gettimeofday (¤t_time, 0);
+ osal_gettimeofday(¤t_time, 0);
return_value.sec = current_time.tv_sec;
return_value.usec = current_time.tv_usec;
return return_value;
}
-void osal_timer_start (osal_timert * self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
struct timeval stop_time;
- osal_gettimeofday (&start_time, 0);
+ osal_gettimeofday(&start_time, 0);
timeout.tv_sec = timeout_usec / USECS_PER_SEC;
timeout.tv_usec = timeout_usec % USECS_PER_SEC;
- timeradd (&start_time, &timeout, &stop_time);
+ timeradd(&start_time, &timeout, &stop_time);
self->stop_time.sec = stop_time.tv_sec;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert * self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int is_not_yet_expired;
- osal_gettimeofday (¤t_time, 0);
+ osal_gettimeofday(¤t_time, 0);
stop_time.tv_sec = self->stop_time.sec;
stop_time.tv_usec = self->stop_time.usec;
- is_not_yet_expired = timercmp (¤t_time, &stop_time, <);
+ is_not_yet_expired = timercmp(¤t_time, &stop_time, <);
return is_not_yet_expired == FALSE;
}
int osal_usleep(uint32 usec)
{
- RtSleepEx (usec / 1000);
+ RtSleepEx(usec / 1000);
return 1;
}
/* Mutex is not needed when running single threaded */
-void osal_mtx_lock(osal_mutex_t * mtx)
+void osal_mtx_lock(osal_mutex_t *mtx)
{
- /* RtWaitForSingleObject((HANDLE)mtx, INFINITE); */
+ /* RtWaitForSingleObject((HANDLE)mtx, INFINITE); */
}
-void osal_mtx_unlock(osal_mutex_t * mtx)
+void osal_mtx_unlock(osal_mutex_t *mtx)
{
- /* RtReleaseMutex((HANDLE)mtx); */
+ /* RtReleaseMutex((HANDLE)mtx); */
}
-int osal_mtx_lock_timeout(osal_mutex_t * mtx, uint32_t time_ms)
+int osal_mtx_lock_timeout(osal_mutex_t *mtx, uint32_t time_ms)
{
- /* return RtWaitForSingleObject((HANDLE)mtx, time_ms); */
- return 0;
+ /* return RtWaitForSingleObject((HANDLE)mtx, time_ms); */
+ return 0;
}
-osal_mutex_t * osal_mtx_create(void)
+osal_mutex_t *osal_mtx_create(void)
{
- /* return (void*)RtCreateMutex(NULL, FALSE, NULL); */
- return (void *)0;
+ /* return (void*)RtCreateMutex(NULL, FALSE, NULL); */
+ return (void *)0;
}
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
- #ifdef _MSC_VER
- #define PACKED_BEGIN __pragma(pack(push, 1))
- #define PACKED
- #define PACKED_END __pragma(pack(pop))
- #elif defined(__GNUC__)
- #define PACKED_BEGIN
- #define PACKED __attribute__((__packed__))
- #define PACKED_END
- #endif
+#ifdef _MSC_VER
+#define PACKED_BEGIN __pragma(pack(push, 1))
+#define PACKED
+#define PACKED_END __pragma(pack(pop))
+#elif defined(__GNUC__)
+#define PACKED_BEGIN
+#define PACKED __attribute__((__packed__))
+#define PACKED_END
+#endif
#endif
-#define OSAL_THREAD_HANDLE RTHANDLE
-#define OSAL_THREAD_FUNC void
-#define OSAL_THREAD_FUNC_RT void
+#define OSAL_THREAD_HANDLE RTHANDLE
+#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_FUNC_RT void
#ifdef __cplusplus
}
#include <string.h>
#include <osal.h>
-#define USECS_PER_SEC 1000000
+#define USECS_PER_SEC 1000000
-int osal_usleep (uint32 usec)
+int osal_usleep(uint32 usec)
{
struct timespec ts;
ts.tv_sec = usec / USECS_PER_SEC;
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
+ if (end->usec < start->usec)
+ {
diff->sec = end->sec - start->sec - 1;
diff->usec = end->usec + 1000000 - start->usec;
}
- else {
+ else
+ {
diff->sec = end->sec - start->sec;
diff->usec = end->usec - start->usec;
}
tv->tv_usec = ts.tv_nsec / 1000;
}
-void osal_timer_start(osal_timert * self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert * self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int osal_thread_create(void *thandle, int stacksize, void *func, void *param)
{
- int ret;
- pthread_attr_t attr;
- pthread_t *threadp;
+ int ret;
+ pthread_attr_t attr;
+ pthread_t *threadp;
threadp = thandle;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, stacksize);
ret = pthread_create(threadp, &attr, func, param);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
int osal_thread_create_rt(void *thandle, int stacksize, void *func, void *param)
{
- int ret;
- pthread_attr_t attr;
- struct sched_param schparam;
- pthread_t *threadp;
+ int ret;
+ pthread_attr_t attr;
+ struct sched_param schparam;
+ pthread_t *threadp;
threadp = thandle;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, stacksize);
ret = pthread_create(threadp, &attr, func, param);
pthread_attr_destroy(&attr);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
memset(&schparam, 0, sizeof(schparam));
schparam.sched_priority = 40;
ret = pthread_setschedparam(*threadp, SCHED_FIFO, &schparam);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
{
pthread_mutexattr_t mutexattr;
osal_mutext *mutex;
- mutex = (osal_mutext *)osal_malloc (sizeof(osal_mutext));
- if(mutex)
+ mutex = (osal_mutext *)osal_malloc(sizeof(osal_mutext));
+ if (mutex)
{
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
void osal_mutex_lock(void *mutex)
{
- pthread_mutex_lock((osal_mutext *) mutex);
+ pthread_mutex_lock((osal_mutext *)mutex);
}
void osal_mutex_unlock(void *mutex)
{
- pthread_mutex_unlock((osal_mutext *) mutex);
+ pthread_mutex_unlock((osal_mutext *)mutex);
}
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED_BEGIN
-#define PACKED __attribute__((__packed__))
+#define PACKED __attribute__((__packed__))
#define PACKED_END
#endif
#include <pthread.h>
-#define OSAL_THREAD_HANDLE pthread_t *
-#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_HANDLE pthread_t *
+#define OSAL_THREAD_FUNC void
#define OSAL_THREAD_FUNC_RT void
-#define osal_mutext pthread_mutex_t
+#define osal_mutext pthread_mutex_t
#ifdef __cplusplus
}
#include <string.h>
#include <osal.h>
-#define USECS_PER_SEC 1000000
+#define USECS_PER_SEC 1000000
-int osal_usleep (uint32 usec)
+int osal_usleep(uint32 usec)
{
struct timespec ts;
ts.tv_sec = usec / USECS_PER_SEC;
{
struct timespec ts;
int return_value;
- (void)tz; /* Not used */
+ (void)tz; /* Not used */
/* Use clock_gettime to prevent possible live-lock.
* Gettimeofday uses CLOCK_REALTIME that can get NTP timeadjust.
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
+ if (end->usec < start->usec)
+ {
diff->sec = end->sec - start->sec - 1;
diff->usec = end->usec + 1000000 - start->usec;
}
- else {
+ else
+ {
diff->sec = end->sec - start->sec;
diff->usec = end->usec - start->usec;
}
}
-void osal_timer_start(osal_timert * self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert * self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int osal_thread_create(void *thandle, int stacksize, void *func, void *param)
{
- int ret;
- pthread_attr_t attr;
- pthread_t *threadp;
+ int ret;
+ pthread_attr_t attr;
+ pthread_t *threadp;
threadp = thandle;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, stacksize);
ret = pthread_create(threadp, &attr, func, param);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
int osal_thread_create_rt(void *thandle, int stacksize, void *func, void *param)
{
- int ret;
- pthread_attr_t attr;
- struct sched_param schparam;
- pthread_t *threadp;
+ int ret;
+ pthread_attr_t attr;
+ struct sched_param schparam;
+ pthread_t *threadp;
threadp = thandle;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, stacksize);
ret = pthread_create(threadp, &attr, func, param);
pthread_attr_destroy(&attr);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
memset(&schparam, 0, sizeof(schparam));
schparam.sched_priority = 40;
ret = pthread_setschedparam(*threadp, SCHED_FIFO, &schparam);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED_BEGIN
-#define PACKED __attribute__((__packed__))
+#define PACKED __attribute__((__packed__))
#define PACKED_END
#endif
#include <pthread.h>
-#define OSAL_THREAD_HANDLE pthread_t *
-#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_HANDLE pthread_t *
+#define OSAL_THREAD_FUNC void
#define OSAL_THREAD_FUNC_RT void
#ifdef __cplusplus
#define _osal_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include "osal_defs.h"
/* General types */
#ifndef TRUE
-#define TRUE 1
+#define TRUE 1
#endif
#ifndef FALSE
-#define FALSE 0
+#define FALSE 0
#endif
-typedef uint8_t boolean;
-typedef int8_t int8;
-typedef int16_t int16;
-typedef int32_t int32;
-typedef uint8_t uint8;
-typedef uint16_t uint16;
-typedef uint32_t uint32;
-typedef int64_t int64;
-typedef uint64_t uint64;
-typedef float float32;
-typedef double float64;
+typedef uint8_t boolean;
+typedef int8_t int8;
+typedef int16_t int16;
+typedef int32_t int32;
+typedef uint8_t uint8;
+typedef uint16_t uint16;
+typedef uint32_t uint32;
+typedef int64_t int64;
+typedef uint64_t uint64;
+typedef float float32;
+typedef double float64;
typedef struct
{
- uint32 sec; /*< Seconds elapsed since the Epoch (Jan 1, 1970) */
- uint32 usec; /*< Microseconds elapsed since last second boundary */
+ uint32 sec; /*< Seconds elapsed since the Epoch (Jan 1, 1970) */
+ uint32 usec; /*< Microseconds elapsed since last second boundary */
} ec_timet;
typedef struct osal_timer
{
- ec_timet stop_time;
+ ec_timet stop_time;
} osal_timert;
-void osal_timer_start(osal_timert * self, uint32 timeout_us);
-boolean osal_timer_is_expired(osal_timert * self);
+void osal_timer_start(osal_timert *self, uint32 timeout_us);
+boolean osal_timer_is_expired(osal_timert *self);
int osal_usleep(uint32 usec);
ec_timet osal_current_time(void);
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff);
#include <string.h>
#include <osal.h>
-#define USECS_PER_SEC 1000000
+#define USECS_PER_SEC 1000000
-int osal_usleep (uint32 usec)
+int osal_usleep(uint32 usec)
{
struct timespec ts;
ts.tv_sec = usec / USECS_PER_SEC;
{
struct timespec ts;
int return_value;
- (void)tz; /* Not used */
+ (void)tz; /* Not used */
/* Use clock_gettime to prevent possible live-lock.
* Gettimeofday uses CLOCK_REALTIME that can get NTP timeadjust.
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
+ if (end->usec < start->usec)
+ {
diff->sec = end->sec - start->sec - 1;
diff->usec = end->usec + 1000000 - start->usec;
}
- else {
+ else
+ {
diff->sec = end->sec - start->sec;
diff->usec = end->usec - start->usec;
}
}
-void osal_timer_start(osal_timert * self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert * self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int osal_thread_create(void *thandle, int stacksize, void *func, void *param)
{
- int ret;
- pthread_attr_t attr;
- pthread_t *threadp;
+ int ret;
+ pthread_attr_t attr;
+ pthread_t *threadp;
threadp = thandle;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, stacksize);
ret = pthread_create(threadp, &attr, func, param);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
int osal_thread_create_rt(void *thandle, int stacksize, void *func, void *param)
{
- int ret;
- pthread_attr_t attr;
- struct sched_param schparam;
- pthread_t *threadp;
+ int ret;
+ pthread_attr_t attr;
+ struct sched_param schparam;
+ pthread_t *threadp;
threadp = thandle;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, stacksize);
ret = pthread_create(threadp, &attr, func, param);
pthread_attr_destroy(&attr);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
memset(&schparam, 0, sizeof(schparam));
schparam.sched_priority = 40;
ret = pthread_setschedparam(*threadp, SCHED_FIFO, &schparam);
- if(ret < 0)
+ if (ret < 0)
{
return 0;
}
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED_BEGIN
-#define PACKED __attribute__((__packed__))
+#define PACKED __attribute__((__packed__))
#define PACKED_END
#endif
#include <pthread.h>
-#define OSAL_THREAD_HANDLE pthread_t *
-#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_HANDLE pthread_t *
+#define OSAL_THREAD_FUNC void
#define OSAL_THREAD_FUNC_RT void
#ifdef __cplusplus
#include <sys/time.h>
#include <config.h>
-#define USECS_PER_SEC 1000000
-#define USECS_PER_TICK (USECS_PER_SEC / CFG_TICKS_PER_SECOND)
+#define USECS_PER_SEC 1000000
+#define USECS_PER_TICK (USECS_PER_SEC / CFG_TICKS_PER_SECOND)
int gettimeofday(struct timeval *tp, void *tzp)
{
tick_t tick = tick_get();
tick_t ticks_left;
- ASSERT (tp != NULL);
+ ASSERT(tp != NULL);
tp->tv_sec = tick / CFG_TICKS_PER_SECOND;
ticks_left = tick % CFG_TICKS_PER_SECOND;
tp->tv_usec = ticks_left * USECS_PER_TICK;
- ASSERT (tp->tv_usec < USECS_PER_SEC);
+ ASSERT(tp->tv_usec < USECS_PER_SEC);
return 0;
}
-int osal_usleep (uint32 usec)
+int osal_usleep(uint32 usec)
{
tick_t ticks = (usec / USECS_PER_TICK) + 1;
- task_delay (ticks);
+ task_delay(ticks);
return 0;
}
return gettimeofday(tv, tz);
}
-ec_timet osal_current_time (void)
+ec_timet osal_current_time(void)
{
struct timeval current_time;
ec_timet return_value;
- gettimeofday (¤t_time, 0);
+ gettimeofday(¤t_time, 0);
return_value.sec = current_time.tv_sec;
return_value.usec = current_time.tv_usec;
return return_value;
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
+ if (end->usec < start->usec)
+ {
diff->sec = end->sec - start->sec - 1;
diff->usec = end->usec + 1000000 - start->usec;
}
- else {
+ else
+ {
diff->sec = end->sec - start->sec;
diff->usec = end->usec - start->usec;
}
}
-void osal_timer_start (osal_timert * self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
struct timeval stop_time;
- gettimeofday (&start_time, 0);
+ gettimeofday(&start_time, 0);
timeout.tv_sec = timeout_usec / USECS_PER_SEC;
timeout.tv_usec = timeout_usec % USECS_PER_SEC;
- timeradd (&start_time, &timeout, &stop_time);
+ timeradd(&start_time, &timeout, &stop_time);
self->stop_time.sec = stop_time.tv_sec;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert * self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int is_not_yet_expired;
- gettimeofday (¤t_time, 0);
+ gettimeofday(¤t_time, 0);
stop_time.tv_sec = self->stop_time.sec;
stop_time.tv_usec = self->stop_time.usec;
- is_not_yet_expired = timercmp (¤t_time, &stop_time, <);
+ is_not_yet_expired = timercmp(¤t_time, &stop_time, <);
return is_not_yet_expired == false;
}
int osal_thread_create(void *thandle, int stacksize, void *func, void *param)
{
- thandle = task_spawn ("worker", func, 6,stacksize, param);
- if(!thandle)
+ thandle = task_spawn("worker", func, 6, stacksize, param);
+ if (!thandle)
{
return 0;
}
int osal_thread_create_rt(void *thandle, int stacksize, void *func, void *param)
{
- thandle = task_spawn ("worker_rt", func, 15 ,stacksize, param);
- if(!thandle)
+ thandle = task_spawn("worker_rt", func, 15, stacksize, param);
+ if (!thandle)
{
return 0;
}
void osal_mutex_destroy(void *mutex)
{
- mtx_destroy (mutex);
+ mtx_destroy(mutex);
}
void osal_mutex_lock(void *mutex)
{
- mtx_lock (mutex);
+ mtx_lock(mutex);
}
void osal_mutex_unlock(void *mutex)
{
- mtx_unlock (mutex);
+ mtx_unlock(mutex);
}
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED_BEGIN
-#define PACKED __attribute__((__packed__))
+#define PACKED __attribute__((__packed__))
#define PACKED_END
#endif
-#define OSAL_THREAD_HANDLE task_t *
-#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_HANDLE task_t *
+#define OSAL_THREAD_FUNC void
#define OSAL_THREAD_FUNC_RT void
-#define osal_mutext mtx_t *
+#define osal_mutext mtx_t *
#ifdef __cplusplus
}
#include <vxWorks.h>
#include <taskLib.h>
-
-#define timercmp(a, b, CMP) \
- (((a)->tv_sec == (b)->tv_sec) ? \
- ((a)->tv_usec CMP (b)->tv_usec) : \
- ((a)->tv_sec CMP (b)->tv_sec))
-#define timeradd(a, b, result) \
- do { \
- (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
- (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
- if ((result)->tv_usec >= 1000000) \
- { \
- ++(result)->tv_sec; \
- (result)->tv_usec -= 1000000; \
- } \
- } while (0)
-#define timersub(a, b, result) \
- do { \
- (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
- (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
- if ((result)->tv_usec < 0) { \
- --(result)->tv_sec; \
- (result)->tv_usec += 1000000; \
- } \
- } while (0)
-
-#define USECS_PER_SEC 1000000
+#define timercmp(a, b, CMP) \
+ (((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_usec CMP(b)->tv_usec) : ((a)->tv_sec CMP(b)->tv_sec))
+#define timeradd(a, b, result) \
+ do \
+ { \
+ (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
+ (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
+ if ((result)->tv_usec >= 1000000) \
+ { \
+ ++(result)->tv_sec; \
+ (result)->tv_usec -= 1000000; \
+ } \
+ } while (0)
+#define timersub(a, b, result) \
+ do \
+ { \
+ (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+ (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+ if ((result)->tv_usec < 0) \
+ { \
+ --(result)->tv_sec; \
+ (result)->tv_usec += 1000000; \
+ } \
+ } while (0)
+
+#define USECS_PER_SEC 1000000
/* OBS! config worker threads must have higher prio that task running ec_configuration */
-#define ECAT_TASK_PRIO_HIGH 20 /* Priority for high performance network task */
-#define ECAT_TASK_PRIO_LOW 80 /* Priority for high performance network task */
-#define ECAT_STACK_SIZE 10000 /* Stack size for high performance task */
-static int ecatTaskOptions = VX_SUPERVISOR_MODE | VX_UNBREAKABLE;
-static int ecatTaskIndex = 0;
+#define ECAT_TASK_PRIO_HIGH 20 /* Priority for high performance network task */
+#define ECAT_TASK_PRIO_LOW 80 /* Priority for high performance network task */
+#define ECAT_STACK_SIZE 10000 /* Stack size for high performance task */
+static int ecatTaskOptions = VX_SUPERVISOR_MODE | VX_UNBREAKABLE;
+static int ecatTaskIndex = 0;
#ifndef use_task_delay
#define use_task_delay 1
#endif
-int osal_usleep (uint32 usec)
+int osal_usleep(uint32 usec)
{
#if (use_task_delay == 1)
- /* Task delay 0 only yields */
+ /* Task delay 0 only yields */
taskDelay(usec / 1000);
return 0;
#else
- /* The suspension may be longer than requested due to the rounding up of
- * the request to the timer's resolution or to other scheduling activities
- * (e.g., a higher priority task intervenes).
- */
+ /* The suspension may be longer than requested due to the rounding up of
+ * the request to the timer's resolution or to other scheduling activities
+ * (e.g., a higher priority task intervenes).
+ */
struct timespec ts;
ts.tv_sec = usec / USECS_PER_SEC;
ts.tv_nsec = (usec % USECS_PER_SEC) * 1000;
return nanosleep(&ts, NULL);
#endif
-
}
int osal_gettimeofday(struct timeval *tv, struct timezone *tz)
{
struct timespec ts;
int return_value;
- (void)tz; /* Not used */
+ (void)tz; /* Not used */
/* Use clock_gettime CLOCK_MONOTONIC to a avoid NTP time adjustments */
return_value = clock_gettime(CLOCK_MONOTONIC, &ts);
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
+ if (end->usec < start->usec)
+ {
diff->sec = end->sec - start->sec - 1;
diff->usec = end->usec + 1000000 - start->usec;
}
- else {
+ else
+ {
diff->sec = end->sec - start->sec;
diff->usec = end->usec - start->usec;
}
}
-void osal_timer_start(osal_timert * self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert * self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int osal_thread_create(void *thandle, int stacksize, void *func, void *param)
{
char task_name[20];
- TASK_ID * tid = (TASK_ID *)thandle;
- FUNCPTR func_ptr = func;
+ TASK_ID *tid = (TASK_ID *)thandle;
+ FUNCPTR func_ptr = func;
_Vx_usr_arg_t arg1 = (_Vx_usr_arg_t)param;
- snprintf(task_name,sizeof(task_name),"worker_%d",ecatTaskIndex++);
+ snprintf(task_name, sizeof(task_name), "worker_%d", ecatTaskIndex++);
- *tid = taskSpawn (task_name, ECAT_TASK_PRIO_LOW,
- ecatTaskOptions, ECAT_STACK_SIZE,
- func_ptr, arg1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
- if(*tid == TASK_ID_ERROR)
+ *tid = taskSpawn(task_name, ECAT_TASK_PRIO_LOW,
+ ecatTaskOptions, ECAT_STACK_SIZE,
+ func_ptr, arg1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ if (*tid == TASK_ID_ERROR)
{
return 0;
}
-
+
return 1;
}
int osal_thread_create_rt(void *thandle, int stacksize, void *func, void *param)
{
char task_name[20];
- TASK_ID * tid = (TASK_ID *)thandle;
- FUNCPTR func_ptr = func;
+ TASK_ID *tid = (TASK_ID *)thandle;
+ FUNCPTR func_ptr = func;
_Vx_usr_arg_t arg1 = (_Vx_usr_arg_t)param;
- snprintf(task_name,sizeof(task_name),"worker_rt_%d",ecatTaskIndex++);
+ snprintf(task_name, sizeof(task_name), "worker_rt_%d", ecatTaskIndex++);
- *tid = taskSpawn (task_name, ECAT_TASK_PRIO_HIGH,
- ecatTaskOptions, ECAT_STACK_SIZE,
- func_ptr, arg1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ *tid = taskSpawn(task_name, ECAT_TASK_PRIO_HIGH,
+ ecatTaskOptions, ECAT_STACK_SIZE,
+ func_ptr, arg1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
- if(*tid == TASK_ID_ERROR)
+ if (*tid == TASK_ID_ERROR)
{
return 0;
}
return 1;
}
-
#define _osal_defs_
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED_BEGIN
-#define PACKED __attribute__((__packed__))
+#define PACKED __attribute__((__packed__))
#define PACKED_END
#endif
-#define OSAL_THREAD_HANDLE TASK_ID
-#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_HANDLE TASK_ID
+#define OSAL_THREAD_FUNC void
#define OSAL_THREAD_FUNC_RT void
#endif
static int64_t sysfrequency;
static double qpc2usec;
-#define USECS_PER_SEC 1000000
+#define USECS_PER_SEC 1000000
static int osal_getrelativetime(struct timeval *tv, struct timezone *tz)
{
int64_t wintime, usecs;
(void)tz;
- if(!sysfrequency)
+ if (!sysfrequency)
{
timeBeginPeriod(1);
QueryPerformanceFrequency((LARGE_INTEGER *)&sysfrequency);
* following factors are required for the conversion from days to 100 ns steps:
*
* 86.400 seconds per day; 1.000.000 microseconds per second; 10 * 100 ns per microsecond
- */
+ */
int64 offset = -134774LL * 86400LL * 1000000LL * 10LL;
GetSystemTimeAsFileTime(&system_time);
return 1;
}
-ec_timet osal_current_time (void)
+ec_timet osal_current_time(void)
{
struct timeval current_time;
ec_timet return_value;
- osal_gettimeofday (¤t_time, 0);
+ osal_gettimeofday(¤t_time, 0);
return_value.sec = current_time.tv_sec;
return_value.usec = current_time.tv_usec;
return return_value;
void osal_time_diff(ec_timet *start, ec_timet *end, ec_timet *diff)
{
- if (end->usec < start->usec) {
+ if (end->usec < start->usec)
+ {
diff->sec = end->sec - start->sec - 1;
diff->usec = end->usec + 1000000 - start->usec;
}
- else {
+ else
+ {
diff->sec = end->sec - start->sec;
diff->usec = end->usec - start->usec;
}
}
-void osal_timer_start (osal_timert *self, uint32 timeout_usec)
+void osal_timer_start(osal_timert *self, uint32 timeout_usec)
{
struct timeval start_time;
struct timeval timeout;
struct timeval stop_time;
- osal_getrelativetime (&start_time, 0);
+ osal_getrelativetime(&start_time, 0);
timeout.tv_sec = timeout_usec / USECS_PER_SEC;
timeout.tv_usec = timeout_usec % USECS_PER_SEC;
- timeradd (&start_time, &timeout, &stop_time);
+ timeradd(&start_time, &timeout, &stop_time);
self->stop_time.sec = stop_time.tv_sec;
self->stop_time.usec = stop_time.tv_usec;
}
-boolean osal_timer_is_expired (osal_timert *self)
+boolean osal_timer_is_expired(osal_timert *self)
{
struct timeval current_time;
struct timeval stop_time;
int is_not_yet_expired;
- osal_getrelativetime (¤t_time, 0);
+ osal_getrelativetime(¤t_time, 0);
stop_time.tv_sec = self->stop_time.sec;
stop_time.tv_usec = self->stop_time.usec;
- is_not_yet_expired = timercmp (¤t_time, &stop_time, <);
+ is_not_yet_expired = timercmp(¤t_time, &stop_time, <);
return is_not_yet_expired == FALSE;
}
{
osal_timert qtime;
osal_timer_start(&qtime, usec);
- if(usec >= 1000)
+ if (usec >= 1000)
{
SleepEx(usec / 1000, FALSE);
}
- while(!osal_timer_is_expired(&qtime));
+ while (!osal_timer_is_expired(&qtime))
+ ;
return 1;
}
int osal_thread_create(void *thandle, int stacksize, void *func, void *param)
{
- *(OSAL_THREAD_HANDLE*)thandle = CreateThread(NULL, stacksize, func, param, 0, NULL);
- if(!thandle)
+ *(OSAL_THREAD_HANDLE *)thandle = CreateThread(NULL, stacksize, func, param, 0, NULL);
+ if (!thandle)
{
return 0;
}
void *osal_mutex_create(void)
{
- return CreateMutex (NULL, FALSE, NULL);
+ return CreateMutex(NULL, FALSE, NULL);
}
void osal_mutex_destroy(void *mutex)
{
- CloseHandle (mutex);
+ CloseHandle(mutex);
}
void osal_mutex_lock(void *mutex)
{
- WaitForSingleObject (mutex, INFINITE);
+ WaitForSingleObject(mutex, INFINITE);
}
void osal_mutex_unlock(void *mutex)
{
- ReleaseMutex (mutex);
+ ReleaseMutex(mutex);
}
#define _osal_defs_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#define WIN32_LEAN_AND_MEAN // Exclude some conflicting definitions in windows header
#include <windows.h>
// define if debug printf is needed
-//#define EC_DEBUG
+// #define EC_DEBUG
#ifdef EC_DEBUG
#define EC_PRINT printf
#else
-#define EC_PRINT(...) do {} while (0)
+#define EC_PRINT(...) \
+ do \
+ { \
+ } while (0)
#endif
#ifndef PACKED
#define PACKED
#ifdef __GNUC__
#define PACKED_BEGIN _Pragma("pack(push,1)")
-#define PACKED_END _Pragma("pack(pop)")
+#define PACKED_END _Pragma("pack(pop)")
#else
#define PACKED_BEGIN __pragma(pack(push, 1))
-#define PACKED_END __pragma(pack(pop))
+#define PACKED_END __pragma(pack(pop))
#endif
#endif
-#define OSAL_THREAD_HANDLE HANDLE
-#define OSAL_THREAD_FUNC void
+#define OSAL_THREAD_HANDLE HANDLE
+#define OSAL_THREAD_FUNC void
#define OSAL_THREAD_FUNC_RT void
-#define osal_mutext CRITICAL_SECTION
+#define osal_mutext CRITICAL_SECTION
#ifdef __cplusplus
}
/* Convenience macros for operations on timevals.
NOTE: `timercmp' does not work for >= or <=. */
-# define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
-# define timeradd(a, b, result) \
- do { \
- (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
- (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
- if ((result)->tv_usec >= 1000000) \
- { \
- ++(result)->tv_sec; \
- (result)->tv_usec -= 1000000; \
- } \
- } while (0)
-# define timersub(a, b, result) \
- do { \
- (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
- (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
- if ((result)->tv_usec < 0) { \
- --(result)->tv_sec; \
- (result)->tv_usec += 1000000; \
- } \
- } while (0)
+#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
+#define timeradd(a, b, result) \
+ do \
+ { \
+ (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
+ (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
+ if ((result)->tv_usec >= 1000000) \
+ { \
+ ++(result)->tv_sec; \
+ (result)->tv_usec -= 1000000; \
+ } \
+ } while (0)
+#define timersub(a, b, result) \
+ do \
+ { \
+ (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+ (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+ if ((result)->tv_usec < 0) \
+ { \
+ --(result)->tv_sec; \
+ (result)->tv_usec += 1000000; \
+ } \
+ } while (0)
struct timezone;
// currently the tz parameter is ignored in the win32 implmentation.
-int osal_gettimeofday (struct timeval *tv, struct timezone *tz);
+int osal_gettimeofday(struct timeval *tv, struct timezone *tz);
#endif
/** Redundancy modes */
enum
{
- /** No redundancy, single NIC mode */
- ECT_RED_NONE,
- /** Double redundant NIC connection */
- ECT_RED_DOUBLE
+ /** No redundancy, single NIC mode */
+ ECT_RED_NONE,
+ /** Double redundant NIC connection */
+ ECT_RED_DOUBLE
};
-
/** Primary source MAC address used for EtherCAT.
* This address is not the MAC address used from the NIC.
* EtherCAT does not care about MAC addressing, but it is used here to
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to find out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0201, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0201, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0604, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0604, 0x0404, 0x0404};
/** second MAC word is used for identification */
#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
void ee_port_lock(void);
void ee_port_unlock(void);
static inline void ecx_clear_rxbufstat(int *rxbufstat)
{
- int i;
- for(i = 0; i < EC_MAXBUF; i++)
- rxbufstat[i] = EC_BUF_EMPTY;
+ int i;
+ for (i = 0; i < EC_MAXBUF; i++)
+ rxbufstat[i] = EC_BUF_EMPTY;
}
/** Basic setup to connect NIC to socket.
*/
int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary)
{
- int d;
- struct eth_device *dev;
- OSEE_PRINT("ecx_setupnic() searching %s...\n", ifname);
-
- for (d = 0;; ++d) {
- dev = eth_get_device(d);
-
- if (dev == NULL)
- break; // ERROR: device not found
-
- if (!strncmp(dev->name, ifname, MAX_DEVICE_NAME)){
- // Device found
- int i;
-
- eth_setup_device(d, 1, 100);
- port->dev_id = d;
-
- port->sockhandle = -1;
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.sock = &(port->sockhandle);
- port->stack.txbuf = &(port->txbuf);
- port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
- ecx_clear_rxbufstat(&(port->rxbufstat[0]));
-
- /* setup ethernet headers in tx buffers so we don't have to repeat it */
- for (i = 0; i < EC_MAXBUF; i++)
- {
- ec_setupheader(&(port->txbuf[i]));
- port->rxbufstat[i] = EC_BUF_EMPTY;
- }
- ec_setupheader(&(port->txbuf2));
-
- break; // device found
- }
- }
-
- return (dev != NULL);
+ int d;
+ struct eth_device *dev;
+ OSEE_PRINT("ecx_setupnic() searching %s...\n", ifname);
+
+ for (d = 0;; ++d)
+ {
+ dev = eth_get_device(d);
+
+ if (dev == NULL)
+ break; // ERROR: device not found
+
+ if (!strncmp(dev->name, ifname, MAX_DEVICE_NAME))
+ {
+ // Device found
+ int i;
+
+ eth_setup_device(d, 1, 100);
+ port->dev_id = d;
+
+ port->sockhandle = -1;
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.sock = &(port->sockhandle);
+ port->stack.txbuf = &(port->txbuf);
+ port->stack.txbuflength = &(port->txbuflength);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
+ ecx_clear_rxbufstat(&(port->rxbufstat[0]));
+
+ /* setup ethernet headers in tx buffers so we don't have to repeat it */
+ for (i = 0; i < EC_MAXBUF; i++)
+ {
+ ec_setupheader(&(port->txbuf[i]));
+ port->rxbufstat[i] = EC_BUF_EMPTY;
+ }
+ ec_setupheader(&(port->txbuf2));
+
+ break; // device found
+ }
+ }
+
+ return (dev != NULL);
}
/** Close sockets used
*/
inline int ecx_closenic(ecx_portt *port)
{
- // Nothing to do
- return 0;
+ // Nothing to do
+ return 0;
}
/** Fill buffer with ethernet header structure.
*/
void ec_setupheader(void *p)
{
- ec_etherheadert *bp;
- bp = p;
- bp->da0 = oshw_htons(0xffff);
- bp->da1 = oshw_htons(0xffff);
- bp->da2 = oshw_htons(0xffff);
- bp->sa0 = oshw_htons(priMAC[0]);
- bp->sa1 = oshw_htons(priMAC[1]);
- bp->sa2 = oshw_htons(priMAC[2]);
- bp->etype = oshw_htons(ETH_P_ECAT);
+ ec_etherheadert *bp;
+ bp = p;
+ bp->da0 = oshw_htons(0xffff);
+ bp->da1 = oshw_htons(0xffff);
+ bp->da2 = oshw_htons(0xffff);
+ bp->sa0 = oshw_htons(priMAC[0]);
+ bp->sa1 = oshw_htons(priMAC[1]);
+ bp->sa2 = oshw_htons(priMAC[2]);
+ bp->etype = oshw_htons(ETH_P_ECAT);
}
/** Get new frame identifier index and allocate corresponding rx buffer.
*/
uint8 ecx_getindex(ecx_portt *port)
{
- uint8 idx;
- uint8 cnt = 0;
-
- ee_port_lock();
-
- idx = port->lastidx + 1;
- /* index can't be larger than buffer array */
- if (idx >= EC_MAXBUF)
- idx = 0;
-
- /* try to find unused index */
- while ((port->rxbufstat[idx] != EC_BUF_EMPTY) && (cnt < EC_MAXBUF)) {
- idx++;
- cnt++;
- if (idx >= EC_MAXBUF)
- idx = 0;
- }
- port->rxbufstat[idx] = EC_BUF_ALLOC;
- if (port->redstate != ECT_RED_NONE)
- port->redport->rxbufstat[idx] = EC_BUF_ALLOC;
- port->lastidx = idx;
-
- ee_port_unlock();
-
- return idx;
+ uint8 idx;
+ uint8 cnt = 0;
+
+ ee_port_lock();
+
+ idx = port->lastidx + 1;
+ /* index can't be larger than buffer array */
+ if (idx >= EC_MAXBUF)
+ idx = 0;
+
+ /* try to find unused index */
+ while ((port->rxbufstat[idx] != EC_BUF_EMPTY) && (cnt < EC_MAXBUF))
+ {
+ idx++;
+ cnt++;
+ if (idx >= EC_MAXBUF)
+ idx = 0;
+ }
+ port->rxbufstat[idx] = EC_BUF_ALLOC;
+ if (port->redstate != ECT_RED_NONE)
+ port->redport->rxbufstat[idx] = EC_BUF_ALLOC;
+ port->lastidx = idx;
+
+ ee_port_unlock();
+
+ return idx;
}
/** Set rx buffer status.
*/
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat)
{
- port->rxbufstat[idx] = bufstat;
- if (port->redstate != ECT_RED_NONE)
- port->redport->rxbufstat[idx] = bufstat;
+ port->rxbufstat[idx] = bufstat;
+ if (port->redstate != ECT_RED_NONE)
+ port->redport->rxbufstat[idx] = bufstat;
}
/** Transmit buffer over socket (non blocking).
*/
int ecx_outframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- int lp;
- ec_stackT *stack;
+ int lp;
+ ec_stackT *stack;
- if (!stacknumber)
- stack = &(port->stack);
- else
- stack = &(port->redport->stack);
- lp = (*stack->txbuflength)[idx];
- (*stack->rxbufstat)[idx] = EC_BUF_TX;
+ if (!stacknumber)
+ stack = &(port->stack);
+ else
+ stack = &(port->redport->stack);
+ lp = (*stack->txbuflength)[idx];
+ (*stack->rxbufstat)[idx] = EC_BUF_TX;
- eth_send_packet(port->dev_id, (*stack->txbuf)[idx], lp, 1);
+ eth_send_packet(port->dev_id, (*stack->txbuf)[idx], lp, 1);
- return 1;
+ return 1;
}
/** Transmit buffer over socket (non blocking).
*/
int ecx_outframe_red(ecx_portt *port, uint8 idx)
{
- ec_comt *datagramP;
- ec_etherheadert *ehp;
- int rval;
-
- ehp = (ec_etherheadert *)&(port->txbuf[idx]);
- /* rewrite MAC source address 1 to primary */
- ehp->sa1 = oshw_htons(priMAC[1]);
- /* transmit over primary socket*/
- rval = ecx_outframe(port, idx, 0);
- if (port->redstate != ECT_RED_NONE) {
- ee_port_lock();
- ehp = (ec_etherheadert *)&(port->txbuf2);
- /* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
- /* write index to frame */
- datagramP->index = idx;
- /* rewrite MAC source address 1 to secondary */
- ehp->sa1 = oshw_htons(secMAC[1]);
- /* transmit over secondary socket */
- port->redport->rxbufstat[idx] = EC_BUF_TX;
- eth_send_packet(port->dev_id, &(port->txbuf2), port->txbuflength2, 1);
- ee_port_unlock();
- }
-
- return rval;
+ ec_comt *datagramP;
+ ec_etherheadert *ehp;
+ int rval;
+
+ ehp = (ec_etherheadert *)&(port->txbuf[idx]);
+ /* rewrite MAC source address 1 to primary */
+ ehp->sa1 = oshw_htons(priMAC[1]);
+ /* transmit over primary socket*/
+ rval = ecx_outframe(port, idx, 0);
+ if (port->redstate != ECT_RED_NONE)
+ {
+ ee_port_lock();
+ ehp = (ec_etherheadert *)&(port->txbuf2);
+ /* use dummy frame for secondary socket transmit (BRD) */
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
+ /* write index to frame */
+ datagramP->index = idx;
+ /* rewrite MAC source address 1 to secondary */
+ ehp->sa1 = oshw_htons(secMAC[1]);
+ /* transmit over secondary socket */
+ port->redport->rxbufstat[idx] = EC_BUF_TX;
+ eth_send_packet(port->dev_id, &(port->txbuf2), port->txbuflength2, 1);
+ ee_port_unlock();
+ }
+
+ return rval;
}
/** Non blocking read of socket. Put frame in temporary buffer.
*/
static int ecx_recvpkt(ecx_portt *port, int stacknumber)
{
- int lp, bytesrx;
- ec_stackT *stack;
-
- if (!stacknumber)
- stack = &(port->stack);
- else
- stack = &(port->redport->stack);
- lp = sizeof(port->tempinbuf);
- bytesrx = eth_receive_packet(port->dev_id, (*stack->tempbuf), lp, 1, 0);
- port->tempinbufs = bytesrx;
-
- return (bytesrx > 0);
+ int lp, bytesrx;
+ ec_stackT *stack;
+
+ if (!stacknumber)
+ stack = &(port->stack);
+ else
+ stack = &(port->redport->stack);
+ lp = sizeof(port->tempinbuf);
+ bytesrx = eth_receive_packet(port->dev_id, (*stack->tempbuf), lp, 1, 0);
+ port->tempinbufs = bytesrx;
+
+ return (bytesrx > 0);
}
/** Non blocking receive frame function. Uses RX buffer and index to combine
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
- ec_etherheadert *ehp;
- ec_comt *ecp;
- ec_stackT *stack;
- ec_bufT *rxbuf;
-
- if (!stacknumber)
- stack = &(port->stack);
- else
- stack = &(port->redport->stack);
- rval = EC_NOFRAME;
- rxbuf = &(*stack->rxbuf)[idx];
- /* check if requested index is already in buffer ? */
- if ((idx < EC_MAXBUF) && ((*stack->rxbufstat)[idx] == EC_BUF_RCVD)) {
- l = (*rxbuf)[0] + ((uint16)((*rxbuf)[1] & 0x0f) << 8);
- /* return WKC */
- rval = ((*rxbuf)[l] + ((uint16)(*rxbuf)[l + 1] << 8));
- /* mark as completed */
- (*stack->rxbufstat)[idx] = EC_BUF_COMPLETE;
- } else {
- ee_port_lock();
- /* non blocking call to retrieve frame from socket */
-
-
- while (1) {
- if (ecx_recvpkt(port, stacknumber)) {
- rval = EC_OTHERFRAME;
- ehp =(ec_etherheadert*)(stack->tempbuf);
- /* check if it is an EtherCAT frame */
- if (ehp->etype == oshw_htons(ETH_P_ECAT)) {
- ecp =(ec_comt*)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
- l = etohs(ecp->elength) & 0x0fff;
- idxf = ecp->index;
- /* found index equals requested index ? */
- if (idxf == idx) {
- /* yes, put it in the buffer array (strip ethernet header) */
- memcpy(rxbuf, &(*stack->tempbuf)[ETH_HEADERSIZE], (*stack->txbuflength)[idx] - ETH_HEADERSIZE);
- /* return WKC */
- rval = ((*rxbuf)[l] + ((uint16)((*rxbuf)[l + 1]) << 8));
- /* mark as completed */
- (*stack->rxbufstat)[idx] = EC_BUF_COMPLETE;
- /* store MAC source word 1 for redundant routing info */
- (*stack->rxsa)[idx] = oshw_ntohs(ehp->sa1);
- break;
- } else if (idxf < EC_MAXBUF && (*stack->rxbufstat)[idxf] == EC_BUF_TX) {
- rxbuf = &(*stack->rxbuf)[idxf];
- /* put it in the buffer array (strip ethernet header) */
- memcpy(rxbuf, &(*stack->tempbuf)[ETH_HEADERSIZE], (*stack->txbuflength)[idxf] - ETH_HEADERSIZE);
- /* mark as received */
- (*stack->rxbufstat)[idxf] = EC_BUF_RCVD;
- (*stack->rxsa)[idxf] = oshw_ntohs(ehp->sa1);
- break;
- } else {
- OSEE_PRINT("ecx_inframe(): WARNING: strange things happened\n");
- /* strange things happened */
- }
- } else {
- OSEE_PRINT("ecx_inframe(): WARNING it is NOT an EtherCAT frame!\n");
- }
- } else {
- // WARNING: no messages received.
- break;
- }
- }
-
- ee_port_unlock();
-
- }
-
- /* WKC if matching frame found */
- return rval;
+ uint16 l;
+ int rval;
+ uint8 idxf;
+ ec_etherheadert *ehp;
+ ec_comt *ecp;
+ ec_stackT *stack;
+ ec_bufT *rxbuf;
+
+ if (!stacknumber)
+ stack = &(port->stack);
+ else
+ stack = &(port->redport->stack);
+ rval = EC_NOFRAME;
+ rxbuf = &(*stack->rxbuf)[idx];
+ /* check if requested index is already in buffer ? */
+ if ((idx < EC_MAXBUF) && ((*stack->rxbufstat)[idx] == EC_BUF_RCVD))
+ {
+ l = (*rxbuf)[0] + ((uint16)((*rxbuf)[1] & 0x0f) << 8);
+ /* return WKC */
+ rval = ((*rxbuf)[l] + ((uint16)(*rxbuf)[l + 1] << 8));
+ /* mark as completed */
+ (*stack->rxbufstat)[idx] = EC_BUF_COMPLETE;
+ }
+ else
+ {
+ ee_port_lock();
+ /* non blocking call to retrieve frame from socket */
+
+ while (1)
+ {
+ if (ecx_recvpkt(port, stacknumber))
+ {
+ rval = EC_OTHERFRAME;
+ ehp = (ec_etherheadert *)(stack->tempbuf);
+ /* check if it is an EtherCAT frame */
+ if (ehp->etype == oshw_htons(ETH_P_ECAT))
+ {
+ ecp = (ec_comt *)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
+ l = etohs(ecp->elength) & 0x0fff;
+ idxf = ecp->index;
+ /* found index equals requested index ? */
+ if (idxf == idx)
+ {
+ /* yes, put it in the buffer array (strip ethernet header) */
+ memcpy(rxbuf, &(*stack->tempbuf)[ETH_HEADERSIZE], (*stack->txbuflength)[idx] - ETH_HEADERSIZE);
+ /* return WKC */
+ rval = ((*rxbuf)[l] + ((uint16)((*rxbuf)[l + 1]) << 8));
+ /* mark as completed */
+ (*stack->rxbufstat)[idx] = EC_BUF_COMPLETE;
+ /* store MAC source word 1 for redundant routing info */
+ (*stack->rxsa)[idx] = oshw_ntohs(ehp->sa1);
+ break;
+ }
+ else if (idxf < EC_MAXBUF && (*stack->rxbufstat)[idxf] == EC_BUF_TX)
+ {
+ rxbuf = &(*stack->rxbuf)[idxf];
+ /* put it in the buffer array (strip ethernet header) */
+ memcpy(rxbuf, &(*stack->tempbuf)[ETH_HEADERSIZE], (*stack->txbuflength)[idxf] - ETH_HEADERSIZE);
+ /* mark as received */
+ (*stack->rxbufstat)[idxf] = EC_BUF_RCVD;
+ (*stack->rxsa)[idxf] = oshw_ntohs(ehp->sa1);
+ break;
+ }
+ else
+ {
+ OSEE_PRINT("ecx_inframe(): WARNING: strange things happened\n");
+ /* strange things happened */
+ }
+ }
+ else
+ {
+ OSEE_PRINT("ecx_inframe(): WARNING it is NOT an EtherCAT frame!\n");
+ }
+ }
+ else
+ {
+ // WARNING: no messages received.
+ break;
+ }
+ }
+
+ ee_port_unlock();
+ }
+
+ /* WKC if matching frame found */
+ return rval;
}
/** Blocking redundant receive frame function. If redundant mode is not active then
*/
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer)
{
- osal_timert timer2;
- int wkc = EC_NOFRAME;
- int wkc2 = EC_NOFRAME;
- int primrx, secrx;
-
- /* if not in redundant mode then always assume secondary is OK */
- if (port->redstate == ECT_RED_NONE)
- wkc2 = 0;
- do {
- /* only read frame if not already in */
- if (wkc <= EC_NOFRAME)
- wkc = ecx_inframe(port, idx, 0);
- /* only try secondary if in redundant mode */
- if (port->redstate != ECT_RED_NONE) {
- /* only read frame if not already in */
- if (wkc2 <= EC_NOFRAME)
- wkc2 = ecx_inframe(port, idx, 1);
- }
- /* wait for both frames to arrive or timeout */
- } while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
- /* only do redundant functions when in redundant mode */
- if (port->redstate != ECT_RED_NONE) {
- /* primrx if the received MAC source on primary socket */
- primrx = 0;
- if (wkc > EC_NOFRAME) primrx = port->rxsa[idx];
- /* secrx if the received MAC source on psecondary socket */
- secrx = 0;
- if (wkc2 > EC_NOFRAME) secrx = port->redport->rxsa[idx];
-
- /* primary socket got secondary frame and secondary socket got primary frame */
- /* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) ) {
- /* copy secondary buffer to primary */
- memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
- wkc = wkc2;
- }
- /* primary socket got nothing or primary frame, and secondary socket got secondary frame */
- /* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) ) {
- /* If both primary and secondary have partial connection retransmit the primary received
- * frame over the secondary socket. The result from the secondary received frame is a combined
- * frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) ) {
- /* copy primary rx to tx buffer */
- memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
- }
- osal_timer_start (&timer2, EC_TIMEOUTRET);
- /* resend secondary tx */
- ecx_outframe(port, idx, 1);
- do {
- /* retrieve frame */
- wkc2 = ecx_inframe(port, idx, 1);
- } while ((wkc2 <= EC_NOFRAME) && !osal_timer_is_expired(&timer2));
- if (wkc2 > EC_NOFRAME) {
- /* copy secondary result to primary rx buffer */
- memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
- wkc = wkc2;
- }
- }
- }
-
- /* return WKC or EC_NOFRAME */
- return wkc;
+ osal_timert timer2;
+ int wkc = EC_NOFRAME;
+ int wkc2 = EC_NOFRAME;
+ int primrx, secrx;
+
+ /* if not in redundant mode then always assume secondary is OK */
+ if (port->redstate == ECT_RED_NONE)
+ wkc2 = 0;
+ do
+ {
+ /* only read frame if not already in */
+ if (wkc <= EC_NOFRAME)
+ wkc = ecx_inframe(port, idx, 0);
+ /* only try secondary if in redundant mode */
+ if (port->redstate != ECT_RED_NONE)
+ {
+ /* only read frame if not already in */
+ if (wkc2 <= EC_NOFRAME)
+ wkc2 = ecx_inframe(port, idx, 1);
+ }
+ /* wait for both frames to arrive or timeout */
+ } while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
+ /* only do redundant functions when in redundant mode */
+ if (port->redstate != ECT_RED_NONE)
+ {
+ /* primrx if the received MAC source on primary socket */
+ primrx = 0;
+ if (wkc > EC_NOFRAME) primrx = port->rxsa[idx];
+ /* secrx if the received MAC source on psecondary socket */
+ secrx = 0;
+ if (wkc2 > EC_NOFRAME) secrx = port->redport->rxsa[idx];
+
+ /* primary socket got secondary frame and secondary socket got primary frame */
+ /* normal situation in redundant mode */
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
+ {
+ /* copy secondary buffer to primary */
+ memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
+ wkc = wkc2;
+ }
+ /* primary socket got nothing or primary frame, and secondary socket got secondary frame */
+ /* we need to resend TX packet */
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
+ {
+ /* If both primary and secondary have partial connection retransmit the primary received
+ * frame over the secondary socket. The result from the secondary received frame is a combined
+ * frame that traversed all slaves in standard order. */
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
+ {
+ /* copy primary rx to tx buffer */
+ memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
+ }
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
+ /* resend secondary tx */
+ ecx_outframe(port, idx, 1);
+ do
+ {
+ /* retrieve frame */
+ wkc2 = ecx_inframe(port, idx, 1);
+ } while ((wkc2 <= EC_NOFRAME) && !osal_timer_is_expired(&timer2));
+ if (wkc2 > EC_NOFRAME)
+ {
+ /* copy secondary result to primary rx buffer */
+ memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
+ wkc = wkc2;
+ }
+ }
+ }
+
+ /* return WKC or EC_NOFRAME */
+ return wkc;
}
/** Blocking receive frame function. Calls ec_waitinframe_red().
*/
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout)
{
- int wkc;
- osal_timert timer;
+ int wkc;
+ osal_timert timer;
- osal_timer_start (&timer, timeout);
- wkc = ecx_waitinframe_red(port, idx, &timer);
+ osal_timer_start(&timer, timeout);
+ wkc = ecx_waitinframe_red(port, idx, &timer);
- return wkc;
+ return wkc;
}
/** Blocking send and receive frame function. Used for non processdata frames.
*/
int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout)
{
- int wkc = EC_NOFRAME;
- osal_timert timer1, timer2;
-
- osal_timer_start (&timer1, timeout);
- do {
- /* tx frame on primary and if in redundant mode a dummy on secondary */
- ecx_outframe_red(port, idx);
- if (timeout < EC_TIMEOUTRET) {
- osal_timer_start (&timer2, timeout);
- } else {
- /* normally use partial timeout for rx */
- osal_timer_start (&timer2, EC_TIMEOUTRET);
- }
- /* get frame from primary or if in redundant mode possibly
- from secondary */
- wkc = ecx_waitinframe_red(port, idx, &timer2);
- /* wait for answer with WKC>=0 or otherwise retry until timeout */
- } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired (&timer1));
-
-
- return wkc;
+ int wkc = EC_NOFRAME;
+ osal_timert timer1, timer2;
+
+ osal_timer_start(&timer1, timeout);
+ do
+ {
+ /* tx frame on primary and if in redundant mode a dummy on secondary */
+ ecx_outframe_red(port, idx);
+ if (timeout < EC_TIMEOUTRET)
+ {
+ osal_timer_start(&timer2, timeout);
+ }
+ else
+ {
+ /* normally use partial timeout for rx */
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
+ }
+ /* get frame from primary or if in redundant mode possibly
+ from secondary */
+ wkc = ecx_waitinframe_red(port, idx, &timer2);
+ /* wait for answer with WKC>=0 or otherwise retry until timeout */
+ } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired(&timer1));
+
+ return wkc;
}
#define _nicdrvh_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
typedef struct
{
- /** socket connection used */
- int *sock;
- /** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
- /** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
- /** temporary receive buffer */
- ec_bufT *tempbuf;
- /** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
- /** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
- /** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
+ /** socket connection used */
+ int *sock;
+ /** tx buffer */
+ ec_bufT (*txbuf)[EC_MAXBUF];
+ /** tx buffer lengths */
+ int (*txbuflength)[EC_MAXBUF];
+ /** temporary receive buffer */
+ ec_bufT *tempbuf;
+ /** rx buffers */
+ ec_bufT (*rxbuf)[EC_MAXBUF];
+ /** rx buffer status fields */
+ int (*rxbufstat)[EC_MAXBUF];
+ /** received MAC source address (middle word) */
+ int (*rxsa)[EC_MAXBUF];
} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
- /** rx buffers */
- ec_bufT rxbuf[EC_MAXBUF];
- /** rx buffer status */
- int rxbufstat[EC_MAXBUF];
- /** rx MAC source address */
- int rxsa[EC_MAXBUF];
- /** temporary rx buffer */
- ec_bufT tempinbuf;
+ ec_stackT stack;
+ int sockhandle;
+ /** rx buffers */
+ ec_bufT rxbuf[EC_MAXBUF];
+ /** rx buffer status */
+ int rxbufstat[EC_MAXBUF];
+ /** rx MAC source address */
+ int rxsa[EC_MAXBUF];
+ /** temporary rx buffer */
+ ec_bufT tempinbuf;
} ecx_redportt;
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
- /** rx buffers */
- ec_bufT rxbuf[EC_MAXBUF];
- /** rx buffer status */
- int rxbufstat[EC_MAXBUF];
- /** rx MAC source address */
- int rxsa[EC_MAXBUF];
- /** temporary rx buffer */
- ec_bufT tempinbuf;
- /** temporary rx buffer status */
- int tempinbufs;
- /** transmit buffers */
- ec_bufT txbuf[EC_MAXBUF];
- /** transmit buffer lengths */
- int txbuflength[EC_MAXBUF];
- /** temporary tx buffer */
- ec_bufT txbuf2;
- /** temporary tx buffer length */
- int txbuflength2;
- /** last used frame index */
- uint8 lastidx;
- /** current redundancy state */
- int redstate;
- /** pointer to redundancy port and buffers */
- ecx_redportt *redport;
+ ec_stackT stack;
+ int sockhandle;
+ /** rx buffers */
+ ec_bufT rxbuf[EC_MAXBUF];
+ /** rx buffer status */
+ int rxbufstat[EC_MAXBUF];
+ /** rx MAC source address */
+ int rxsa[EC_MAXBUF];
+ /** temporary rx buffer */
+ ec_bufT tempinbuf;
+ /** temporary rx buffer status */
+ int tempinbufs;
+ /** transmit buffers */
+ ec_bufT txbuf[EC_MAXBUF];
+ /** transmit buffer lengths */
+ int txbuflength[EC_MAXBUF];
+ /** temporary tx buffer */
+ ec_bufT txbuf2;
+ /** temporary tx buffer length */
+ int txbuflength2;
+ /** last used frame index */
+ uint8 lastidx;
+ /** current redundancy state */
+ int redstate;
+ /** pointer to redundancy port and buffers */
+ ecx_redportt *redport;
- /** Device id in the device pool */
- int dev_id;
+ /** Device id in the device pool */
+ int dev_id;
- // TODO: add mutex support
+ // TODO: add mutex support
} ecx_portt;
extern const uint16 priMAC[3];
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber);
#define __ntohs(x) be16toh(x)
#endif
-ec_adaptert adapters [DEVS_MAX_NB];
+ec_adaptert adapters[DEVS_MAX_NB];
/**
* Host to Network byte order (i.e. to big endian).
*/
inline uint16 oshw_htons(uint16 host)
{
- // __htons() is provided by the bare-metal x86 compiler
- return __htons(host);
+ // __htons() is provided by the bare-metal x86 compiler
+ return __htons(host);
}
/**
*/
inline uint16 oshw_ntohs(uint16 network)
{
- // __ntohs() is provided by the bare-metal x86 compiler
- return __ntohs(network);
+ // __ntohs() is provided by the bare-metal x86 compiler
+ return __ntohs(network);
}
/** Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert* oshw_find_adapters(void)
+ec_adaptert *oshw_find_adapters(void)
{
- ec_adaptert *ret = NULL;
- if (eth_discover_devices() >= 0) {
- for (int i = 0;; ++i) {
- struct eth_device *dev = eth_get_device(i);
- if (dev == NULL) {
- adapters[i-1].next = NULL;
- break;
- }
- strncpy(adapters[i].name, dev->name, MAX_DEVICE_NAME);
- adapters[i].next = &adapters[i+1];
- }
- ret = &(adapters[0]);
- }
- return ret;
+ ec_adaptert *ret = NULL;
+ if (eth_discover_devices() >= 0)
+ {
+ for (int i = 0;; ++i)
+ {
+ struct eth_device *dev = eth_get_device(i);
+ if (dev == NULL)
+ {
+ adapters[i - 1].next = NULL;
+ break;
+ }
+ strncpy(adapters[i].name, dev->name, MAX_DEVICE_NAME);
+ adapters[i].next = &adapters[i + 1];
+ }
+ ret = &(adapters[0]);
+ }
+ return ret;
}
/** Free memory allocated memory used by adapter collection.
}
extern int ec_slavecount;
-
uint16 oshw_htons(uint16 hostshort);
uint16 oshw_ntohs(uint16 networkshort);
-ec_adaptert* oshw_find_adapters(void);
-void oshw_free_adapters(ec_adaptert * adapter);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
ECT_RED_DOUBLE
};
-
/** Primary source MAC address used for EtherCAT.
* This address is not the MAC address used from the NIC.
* EtherCAT does not care about MAC addressing, but it is used here to
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to find out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0101, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0101, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0404, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0404, 0x0404, 0x0404};
/** second MAC word is used for identification */
-#define RX_PRIM priMAC[1]
+#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
-#define ECAT_PRINT_INFO printf
-#define ECAT_PRINT_WARN printf
-#define ECAT_PRINT_ERROR printf
+#define ECAT_PRINT_INFO printf
+#define ECAT_PRINT_WARN printf
+#define ECAT_PRINT_ERROR printf
/* HPE port settings */
const unsigned long interrupt_mode = NO_INTERRUPT;
-const unsigned long phy_settings = SPEED_100 | DUPLEX_FULL;
+const unsigned long phy_settings = SPEED_100 | DUPLEX_FULL;
/** Basic setup to connect NIC to socket.
* @param[in] ifname = Name of NIC device, f.e. "eth0"
int i;
int dontWaitForLink = 0;
int result = 1;
- HPE_CONFIG_OPTIONS conf = { 0, 0, NULL};
+ HPE_CONFIG_OPTIONS conf = {0, 0, NULL};
status = hpeOpen(ifname, phy_settings, interrupt_mode, &(port->handle));
if (status != E_OK)
{
ECAT_PRINT_ERROR("hpeOpen failed with status %04x ", status);
- if(status == E_EXIST) ECAT_PRINT_ERROR("E_EXIST\n");
- else if(status == E_STATE) ECAT_PRINT_ERROR("E_STATE\n");
- else if(status == E_PARAM) ECAT_PRINT_ERROR("E_PARAM\n");
- else if(status == E_INVALID_ADDR) ECAT_PRINT_ERROR("E_INVALID_ADDR\n");
- else if(status == E_IO) ECAT_PRINT_ERROR("E_IO\n");
- else if(status == E_TIME) ECAT_PRINT_ERROR("E_TIME\n");
- else ECAT_PRINT_ERROR("UNKNOWN\n");
+ if (status == E_EXIST)
+ ECAT_PRINT_ERROR("E_EXIST\n");
+ else if (status == E_STATE)
+ ECAT_PRINT_ERROR("E_STATE\n");
+ else if (status == E_PARAM)
+ ECAT_PRINT_ERROR("E_PARAM\n");
+ else if (status == E_INVALID_ADDR)
+ ECAT_PRINT_ERROR("E_INVALID_ADDR\n");
+ else if (status == E_IO)
+ ECAT_PRINT_ERROR("E_IO\n");
+ else if (status == E_TIME)
+ ECAT_PRINT_ERROR("E_TIME\n");
+ else
+ ECAT_PRINT_ERROR("UNKNOWN\n");
result = 0;
goto end;
}
time(&now);
do
{
- status = hpeGetMediaStatus(port->handle, &mstat);
- if (status != E_OK)
- {
- ECAT_PRINT_ERROR("hpeGetMediaStatus failed with status %04x\n", status);
- result = 0;
- goto end;
- }
- if (mstat.media_speed == SPEED_NONE)
- {
- RtSleepEx(1000);
- time(&t);
- }
- } while (mstat.media_speed == SPEED_NONE && t < (now+10));
-
- if (((mstat.media_speed & phy_settings) == 0) || ((mstat.media_duplex & phy_settings) == 0)) {
+ status = hpeGetMediaStatus(port->handle, &mstat);
+ if (status != E_OK)
+ {
+ ECAT_PRINT_ERROR("hpeGetMediaStatus failed with status %04x\n", status);
+ result = 0;
+ goto end;
+ }
+ if (mstat.media_speed == SPEED_NONE)
+ {
+ RtSleepEx(1000);
+ time(&t);
+ }
+ } while (mstat.media_speed == SPEED_NONE && t < (now + 10));
+
+ if (((mstat.media_speed & phy_settings) == 0) || ((mstat.media_duplex & phy_settings) == 0))
+ {
ECAT_PRINT_ERROR("Media not connected as requested: speed=%u, duplex=%u\n",
- mstat.media_speed, mstat.media_duplex);
+ mstat.media_speed, mstat.media_duplex);
result = 0;
goto end;
}
- status= hpeGetMacAddress(port->handle, mac);
+ status = hpeGetMacAddress(port->handle, mac);
if (status != E_OK)
{
ECAT_PRINT_ERROR("hpeGetMacAddress failed with status %04x\n", status);
}
/* allocate 2 receive buffers and attach them */
- status = hpeAllocateReceiveBufferSet(port->handle, &(port->rx_buffers), EC_MAXBUF, EC_BUFSIZE);
+ status = hpeAllocateReceiveBufferSet(port->handle, &(port->rx_buffers), EC_MAXBUF, EC_BUFSIZE);
if (status != E_OK)
{
ECAT_PRINT_ERROR("hpeAllocateReceiveBufferSet failed with status %04x\n", status);
{
port->redstate = ECT_RED_NONE;
/* Init regions */
- port->getindex_region = CreateRtRegion (PRIORITY_QUEUING);
- port->rx_region = CreateRtRegion (PRIORITY_QUEUING);
- port->tx_region = CreateRtRegion (PRIORITY_QUEUING);
+ port->getindex_region = CreateRtRegion(PRIORITY_QUEUING);
+ port->rx_region = CreateRtRegion(PRIORITY_QUEUING);
+ port->tx_region = CreateRtRegion(PRIORITY_QUEUING);
port->lastidx = 0;
- port->stack.txbuf = &(port->txbuf);
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
}
/* setup ethernet headers in tx buffers so we don't have to repeat it */
for (i = 0; i < EC_MAXBUF; i++)
{
FreeRtMemory(port->tx_buffers[i]);
- port->tx_buffers[i] = NULL;
+ port->tx_buffers[i] = NULL;
}
}
if (port->rx_buffers)
hpeFreeReceiveBufferSet(port->handle, &(port->rx_buffers));
}
- status= hpeClose(port->handle);
+ status = hpeClose(port->handle);
if (status != E_OK)
{
ECAT_PRINT_ERROR("hpeClose failed with status %04x\n", status);
}
}
port->rxbufstat[idx] = EC_BUF_ALLOC;
- if ( port->redstate != ECT_RED_NONE)
+ if (port->redstate != ECT_RED_NONE)
{
port->redport->rxbufstat[idx] = EC_BUF_ALLOC;
}
// wait for transmit to complete
do
{
- result = hpeGetTransmitterState(port->handle, &txstate) == E_OK && txstate == HPE_TXBUSY;
+ result = hpeGetTransmitterState(port->handle, &txstate) == E_OK && txstate == HPE_TXBUSY;
} while (result && retries-- > 0);
if (result)
{
- result = -1;
- goto end;
+ result = -1;
+ goto end;
}
- log_RT_event('S',(WORD)2);
+ log_RT_event('S', (WORD)2);
status = hpeAttachTransmitBufferSet(port->handle, port->tx_buffers[idx]);
if (status != E_OK)
{
result = -2;
goto end;
}
- log_RT_event('S',(WORD)3);
+ log_RT_event('S', (WORD)3);
(*stack->rxbufstat)[idx] = EC_BUF_TX;
status = hpeStartTransmitter(port->handle);
goto end;
}
- log_RT_event('S',(WORD)4);
+ log_RT_event('S', (WORD)4);
result = lp;
end:
{
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2)[ETH_HEADERSIZE];
+ datagramP = (ec_comt *)&(port->txbuf2)[ETH_HEADERSIZE];
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
ehp->sa1 = oshw_htons(secMAC[1]);
/* transmit over secondary socket */
- //send(sockhandle2, &ec_txbuf2, ec_txbuflength2 , 0);
- // OBS! redundant not ACTIVE for BFIN, just added to compile
- //ASSERT (0);
+ // send(sockhandle2, &ec_txbuf2, ec_txbuflength2 , 0);
+ // OBS! redundant not ACTIVE for BFIN, just added to compile
+ // ASSERT (0);
hpeAttachTransmitBufferSet(port->redport->handle, port->tx_buffers[idx]);
port->redport->rxbufstat[idx] = EC_BUF_TX;
status = hpeStartTransmitter(port->redport->handle);
stack = &(port->redport->stack);
}
- log_RT_event('R',(WORD)2);
+ log_RT_event('R', (WORD)2);
status = hpeGetReceiveBuffer(port->handle, &rxbuffer);
if (status == E_OK)
{
- memcpy(stack->tempbuf,rxbuffer->ptr, rxbuffer->used);
- bytesrx = rxbuffer->used;
- port->tempinbufs = bytesrx;
- // TODO case no interrupt
+ memcpy(stack->tempbuf, rxbuffer->ptr, rxbuffer->used);
+ bytesrx = rxbuffer->used;
+ port->tempinbufs = bytesrx;
+ // TODO case no interrupt
}
- log_RT_event('R',(WORD)3);
+ log_RT_event('R', (WORD)3);
return (bytesrx > 0);
}
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
+ uint16 l;
+ int rval;
+ uint8 idxf;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
rval = EC_NOFRAME;
rxbuf = &(*stack->rxbuf)[idx];
/* check if requested index is already in buffer ? */
- if ((idx < EC_MAXBUF) && ( (*stack->rxbufstat)[idx] == EC_BUF_RCVD))
+ if ((idx < EC_MAXBUF) && ((*stack->rxbufstat)[idx] == EC_BUF_RCVD))
{
l = (*rxbuf)[0] + ((uint16)((*rxbuf)[1] & 0x0f) << 8);
/* return WKC */
if (ecx_recvpkt(port, stacknumber))
{
rval = EC_OTHERFRAME;
- ehp = (ec_etherheadert*)(stack->tempbuf);
+ ehp = (ec_etherheadert *)(stack->tempbuf);
/* check if it is an EtherCAT frame */
if (ehp->etype == oshw_htons(ETH_P_ECAT))
{
- ecp =(ec_comt*)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
+ ecp = (ec_comt *)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
l = etohs(ecp->elength) & 0x0fff;
idxf = ecp->index;
/* found index equals requested index ? */
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer)
{
osal_timert timer2;
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
{
wkc2 = ecx_inframe(port, idx, 1);
}
}
- /* wait for both frames to arrive or timeout */
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
- ecx_outframe(port,idx,1);
+ ecx_outframe(port, idx, 1);
do
{
/* retrieve frame */
/* Allow us to consume MAX buffer number of frames */
do
{
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
loop_cnt++;
} while (wkc <= EC_NOFRAME && (loop_cnt <= EC_MAXBUF));
}
else
{
- osal_timer_start (&timer, timeout);
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, &timer);
}
int wkc = EC_NOFRAME;
osal_timert timer1;
- osal_timer_start (&timer1, timeout);
+ osal_timer_start(&timer1, timeout);
/* tx frame on primary and if in redundant mode a dummy on secondary */
ecx_outframe_red(port, idx);
wkc = ecx_waitinframe_red(port, idx, &timer1);
typedef struct
{
/** socket connection used */
- int *sock;
+ int *sock;
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** temporary receive buffer */
- ec_bufT *tempbuf;
+ ec_bufT *tempbuf;
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
+ int (*rxsa)[EC_MAXBUF];
} ec_stackT;
typedef struct
{
- ec_stackT stack;
+ ec_stackT stack;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
/** temporary rx buffer */
ec_bufT tempinbuf;
/* Intime */
- HPEHANDLE handle;
+ HPEHANDLE handle;
HPERXBUFFERSET *rx_buffers;
HPETXBUFFERSET *tx_buffers[EC_MAXBUF];
} ecx_redportt;
typedef struct
{
- ec_stackT stack;
+ ec_stackT stack;
/** rx buffers */
- ec_bufT rxbuf[EC_MAXBUF];
+ ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
- int rxbufstat[EC_MAXBUF];
+ int rxbufstat[EC_MAXBUF];
/** rx MAC source address */
- int rxsa[EC_MAXBUF];
+ int rxsa[EC_MAXBUF];
/** temporary rx buffer */
- ec_bufT tempinbuf;
+ ec_bufT tempinbuf;
/** temporary rx buffer status */
- int tempinbufs;
+ int tempinbufs;
/** transmit buffers */
- ec_bufT txbuf[EC_MAXBUF];
+ ec_bufT txbuf[EC_MAXBUF];
/** transmit buffer lengths */
- int txbuflength[EC_MAXBUF];
+ int txbuflength[EC_MAXBUF];
/** temporary tx buffer */
- ec_bufT txbuf2;
+ ec_bufT txbuf2;
/** temporary tx buffer length */
- int txbuflength2;
+ int txbuflength2;
/** last used frame index */
- uint8 lastidx;
+ uint8 lastidx;
/** current redundancy state */
- int redstate;
+ int redstate;
/** pointer to redundancy port and buffers */
- ecx_redportt *redport;
- RTHANDLE getindex_region;
- RTHANDLE tx_region;
- RTHANDLE rx_region;
+ ecx_redportt *redport;
+ RTHANDLE getindex_region;
+ RTHANDLE tx_region;
+ RTHANDLE rx_region;
/* Intime */
- HPEHANDLE handle;
+ HPEHANDLE handle;
HPERXBUFFERSET *rx_buffers;
HPETXBUFFERSET *tx_buffers[EC_MAXBUF];
} ecx_portt;
extern const uint16 priMAC[3];
extern const uint16 secMAC[3];
-//extern ecx_portt ecx_port;
-//extern ecx_redportt ecx_redport;
+// extern ecx_portt ecx_port;
+// extern ecx_redportt ecx_redport;
-int ec_setupnic(const char * ifname, int secondary);
+int ec_setupnic(const char *ifname, int secondary);
int ec_closenic(void);
void ec_setupheader(void *p);
void ec_setbufstat(uint8 idx, int bufstat);
int ec_outframe(uint8 idx, int sock);
int ec_outframe_red(uint8 idx);
int ec_waitinframe(uint8 idx, int timeout);
-int ec_srconfirm(uint8 idx,int timeout);
+int ec_srconfirm(uint8 idx, int timeout);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#endif
* Note that Ethercat uses little endian byte order, except for the Ethernet
* header which is big endian as usual.
*/
-uint16 oshw_htons (uint16 host)
+uint16 oshw_htons(uint16 host)
{
- uint16 network = htons (host);
+ uint16 network = htons(host);
return network;
}
* Note that Ethercat uses little endian byte order, except for the Ethernet
* header which is big endian as usual.
*/
-uint16 oshw_ntohs (uint16 network)
+uint16 oshw_ntohs(uint16 network)
{
- uint16 host = ntohs (network);
+ uint16 host = ntohs(network);
return host;
}
/* Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters (void)
+ec_adaptert *oshw_find_adapters(void)
{
return NULL;
}
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters (ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
-
}
extern "C" {
#endif
-uint16 oshw_htons (uint16 hostshort);
-uint16 oshw_ntohs (uint16 networkshort);
-ec_adaptert * oshw_find_adapters (void);
-void oshw_free_adapters (ec_adaptert * adapter);
+uint16 oshw_htons(uint16 hostshort);
+uint16 oshw_ntohs(uint16 networkshort);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
ECT_RED_DOUBLE
};
-
/** Primary source MAC address used for EtherCAT.
* This address is not the MAC address used from the NIC.
* EtherCAT does not care about MAC addressing, but it is used here to
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to find out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0101, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0101, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0404, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0404, 0x0404, 0x0404};
/** second MAC word is used for identification */
#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
static void ecx_clear_rxbufstat(int *rxbufstat)
{
int i;
- for(i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
rxbufstat[i] = EC_BUF_EMPTY;
}
{
int i;
int r, rval, ifindex;
- // struct timeval timeout;
+ // struct timeval timeout;
struct ifreq ifr;
struct sockaddr_ll sll;
int *psock;
/* when using secondary socket it is automatically a redundant setup */
psock = &(port->redport->sockhandle);
*psock = -1;
- port->redstate = ECT_RED_DOUBLE;
- port->redport->stack.sock = &(port->redport->sockhandle);
- port->redport->stack.txbuf = &(port->txbuf);
+ port->redstate = ECT_RED_DOUBLE;
+ port->redport->stack.sock = &(port->redport->sockhandle);
+ port->redport->stack.txbuf = &(port->txbuf);
port->redport->stack.txbuflength = &(port->txbuflength);
- port->redport->stack.tempbuf = &(port->redport->tempinbuf);
- port->redport->stack.rxbuf = &(port->redport->rxbuf);
- port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
- port->redport->stack.rxsa = &(port->redport->rxsa);
+ port->redport->stack.tempbuf = &(port->redport->tempinbuf);
+ port->redport->stack.rxbuf = &(port->redport->rxbuf);
+ port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
+ port->redport->stack.rxsa = &(port->redport->rxsa);
ecx_clear_rxbufstat(&(port->redport->rxbufstat[0]));
}
else
else
{
pthread_mutexattr_init(&mutexattr);
- pthread_mutexattr_setprotocol(&mutexattr , PTHREAD_PRIO_INHERIT);
+ pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&(port->getindex_mutex), &mutexattr);
- pthread_mutex_init(&(port->tx_mutex) , &mutexattr);
- pthread_mutex_init(&(port->rx_mutex) , &mutexattr);
- port->sockhandle = -1;
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.sock = &(port->sockhandle);
- port->stack.txbuf = &(port->txbuf);
+ pthread_mutex_init(&(port->tx_mutex), &mutexattr);
+ pthread_mutex_init(&(port->rx_mutex), &mutexattr);
+ port->sockhandle = -1;
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.sock = &(port->sockhandle);
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
ecx_clear_rxbufstat(&(port->rxbufstat[0]));
psock = &(port->sockhandle);
}
/* we use RAW packet socket, with packet type ETH_P_ECAT */
*psock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ECAT));
- if(*psock < 0)
+ if (*psock < 0)
return 0;
r = 0;
-/*
- timeout.tv_sec = 0;
- timeout.tv_usec = 1;
- r |= setsockopt(*psock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
- r |= setsockopt(*psock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
-*/
+ /*
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 1;
+ r |= setsockopt(*psock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
+ r |= setsockopt(*psock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
+ */
i = 1;
r |= setsockopt(*psock, SOL_SOCKET, SO_DONTROUTE, &i, sizeof(i));
/* connect socket to NIC by name */
uint8 idx;
uint8 cnt;
- pthread_mutex_lock( &(port->getindex_mutex) );
+ pthread_mutex_lock(&(port->getindex_mutex));
idx = port->lastidx + 1;
/* index can't be larger than buffer array */
port->redport->rxbufstat[idx] = EC_BUF_ALLOC;
port->lastidx = idx;
- pthread_mutex_unlock( &(port->getindex_mutex) );
+ pthread_mutex_unlock(&(port->getindex_mutex));
return idx;
}
rval = ecx_outframe(port, idx, 0);
if (port->redstate != ECT_RED_NONE)
{
- pthread_mutex_lock( &(port->tx_mutex) );
+ pthread_mutex_lock(&(port->tx_mutex));
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
ehp->sa1 = htons(secMAC[1]);
/* transmit over secondary socket */
port->redport->rxbufstat[idx] = EC_BUF_TX;
- if (send(port->redport->sockhandle, &(port->txbuf2), port->txbuflength2 , 0) == -1)
+ if (send(port->redport->sockhandle, &(port->txbuf2), port->txbuflength2, 0) == -1)
{
port->redport->rxbufstat[idx] = EC_BUF_EMPTY;
}
- pthread_mutex_unlock( &(port->tx_mutex) );
+ pthread_mutex_unlock(&(port->tx_mutex));
}
return rval;
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
+ uint16 l;
+ int rval;
+ uint8 idxf;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
else if (ecx_recvpkt(port, stacknumber))
{
rval = EC_OTHERFRAME;
- ehp =(ec_etherheadert*)(stack->tempbuf);
+ ehp = (ec_etherheadert *)(stack->tempbuf);
/* check if it is an EtherCAT frame */
if (ehp->etype == htons(ETH_P_ECAT))
{
stack->rxcnt++;
- ecp =(ec_comt*)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
+ ecp = (ec_comt *)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
l = etohs(ecp->elength) & 0x0fff;
idxf = ecp->index;
/* found index equals requested index ? */
}
}
}
- pthread_mutex_unlock( &(port->rx_mutex) );
-
+ pthread_mutex_unlock(&(port->rx_mutex));
}
/* WKC if matching frame found */
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer)
{
osal_timert timer2;
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
struct pollfd fds[2];
struct pollfd *fdsp;
int poll_err = 0;
- struct timespec timeout_spec = { 0, 0 };
+ struct timespec timeout_spec = {0, 0};
timeout_spec.tv_nsec = 50 * 1000;
ec_stackT *stack;
stack = &(port->stack);
fds[0].fd = *stack->sock;
fds[0].events = POLLIN;
int pollcnt = 1;
- if(port->redstate != ECT_RED_NONE)
+ if (port->redstate != ECT_RED_NONE)
{
pollcnt = 2;
stack = &(port->redport->stack);
do
{
poll_err = ppoll(fdsp, pollcnt, &timeout_spec, NULL);
- if(poll_err >= 0)
+ if (poll_err >= 0)
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
{
wkc2 = ecx_inframe(port, idx, 1);
}
}
- /* wait for both frames to arrive or timeout */
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
ecx_outframe(port, idx, 1);
do
int wkc;
osal_timert timer;
- osal_timer_start (&timer, timeout);
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, &timer);
return wkc;
int wkc = EC_NOFRAME;
osal_timert timer1, timer2;
- osal_timer_start (&timer1, timeout);
+ osal_timer_start(&timer1, timeout);
do
{
/* tx frame on primary and if in redundant mode a dummy on secondary */
ecx_outframe_red(port, idx);
if (timeout < EC_TIMEOUTRET)
{
- osal_timer_start (&timer2, timeout);
+ osal_timer_start(&timer2, timeout);
}
else
{
/* normally use partial timeout for rx */
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
}
/* get frame from primary or if in redundant mode possibly from secondary */
wkc = ecx_waitinframe_red(port, idx, &timer2);
- /* wait for answer with WKC>=0 or otherwise retry until timeout */
- } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired (&timer1));
+ /* wait for answer with WKC>=0 or otherwise retry until timeout */
+ } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired(&timer1));
return wkc;
}
#define _nicdrvh_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include <pthread.h>
typedef struct
{
/** socket connection used */
- int *sock;
+ int *sock;
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** temporary receive buffer */
- ec_bufT *tempbuf;
+ ec_bufT *tempbuf;
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
- uint64 rxcnt;
+ int (*rxsa)[EC_MAXBUF];
+ uint64 rxcnt;
} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
+ ec_stackT stack;
+ int sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
+ ec_stackT stack;
+ int sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
extern const uint16 secMAC[3];
void ec_setupheader(void *p);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#ifdef __cplusplus
}
*/
uint16 oshw_htons(uint16 host)
{
- uint16 network = htons (host);
+ uint16 network = htons(host);
return network;
}
*/
uint16 oshw_ntohs(uint16 network)
{
- uint16 host = ntohs (network);
+ uint16 host = ntohs(network);
return host;
}
/** Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters(void)
+ec_adaptert *oshw_find_adapters(void)
{
int i;
struct if_nameindex *ids;
- ec_adaptert * adapter;
- ec_adaptert * prev_adapter = NULL;
- ec_adaptert * ret_adapter = NULL;
-
+ ec_adaptert *adapter;
+ ec_adaptert *prev_adapter = NULL;
+ ec_adaptert *ret_adapter = NULL;
/* Iterate all devices and create a local copy holding the name and
* description.
*/
- ids = if_nameindex ();
- for(i = 0; ids[i].if_index != 0; i++)
+ ids = if_nameindex();
+ for (i = 0; ids[i].if_index != 0; i++)
{
adapter = (ec_adaptert *)malloc(sizeof(ec_adaptert));
/* If we got more than one adapter save link list pointer to previous
if (ids[i].if_name)
{
- strncpy(adapter->name, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
- adapter->name[EC_MAXLEN_ADAPTERNAME-1] = '\0';
- strncpy(adapter->desc, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
- adapter->desc[EC_MAXLEN_ADAPTERNAME-1] = '\0';
+ strncpy(adapter->name, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
+ adapter->name[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
+ strncpy(adapter->desc, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
+ adapter->desc[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
}
else
{
prev_adapter = adapter;
}
- if_freenameindex (ids);
+ if_freenameindex(ids);
return ret_adapter;
}
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters(ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
- ec_adaptert * next_adapter;
+ ec_adaptert *next_adapter;
/* Iterate the linked list and free all elements holding
* adapter information
*/
- if(adapter)
+ if (adapter)
{
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
while (next_adapter)
{
adapter = next_adapter;
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
}
}
}
uint16 oshw_htons(uint16 hostshort);
uint16 oshw_ntohs(uint16 networkshort);
-ec_adaptert * oshw_find_adapters(void);
-void oshw_free_adapters(ec_adaptert * adapter);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
* This layer is fully transparent for the higher layers.
*/
-
#include <assert.h>
#include <sys/types.h>
#include <stdio.h>
/** Redundancy modes */
enum
{
- /** No redundancy, single NIC mode */
- ECT_RED_NONE,
- /** Double redundant NIC connection */
- ECT_RED_DOUBLE
+ /** No redundancy, single NIC mode */
+ ECT_RED_NONE,
+ /** Double redundant NIC connection */
+ ECT_RED_DOUBLE
};
/** Primary source MAC address used for EtherCAT.
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to fund out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0101, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0101, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0404, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0404, 0x0404, 0x0404};
/** second MAC word is used for identification */
#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
static char errbuf[PCAP_ERRBUF_SIZE];
static void ecx_clear_rxbufstat(int *rxbufstat)
{
int i;
- for(i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
rxbufstat[i] = EC_BUF_EMPTY;
}
/* when using secondary socket it is automatically a redundant setup */
psock = &(port->redport->sockhandle);
*psock = NULL;
- port->redstate = ECT_RED_DOUBLE;
- port->redport->stack.sock = &(port->redport->sockhandle);
- port->redport->stack.txbuf = &(port->txbuf);
+ port->redstate = ECT_RED_DOUBLE;
+ port->redport->stack.sock = &(port->redport->sockhandle);
+ port->redport->stack.txbuf = &(port->txbuf);
port->redport->stack.txbuflength = &(port->txbuflength);
- port->redport->stack.tempbuf = &(port->redport->tempinbuf);
- port->redport->stack.rxbuf = &(port->redport->rxbuf);
- port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
- port->redport->stack.rxsa = &(port->redport->rxsa);
+ port->redport->stack.tempbuf = &(port->redport->tempinbuf);
+ port->redport->stack.rxbuf = &(port->redport->rxbuf);
+ port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
+ port->redport->stack.rxsa = &(port->redport->rxsa);
ecx_clear_rxbufstat(&(port->redport->rxbufstat[0]));
}
else
pthread_mutex_init(&(port->getindex_mutex), NULL);
pthread_mutex_init(&(port->tx_mutex), NULL);
pthread_mutex_init(&(port->rx_mutex), NULL);
- port->sockhandle = NULL;
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.sock = &(port->sockhandle);
- port->stack.txbuf = &(port->txbuf);
+ port->sockhandle = NULL;
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.sock = &(port->sockhandle);
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
ecx_clear_rxbufstat(&(port->rxbufstat[0]));
psock = &(port->sockhandle);
}
rval = pcap_setnonblock(*psock, 1, errbuf);
if (rval != 0)
{
- return 0;
+ return 0;
}
for (i = 0; i < EC_MAXBUF; i++)
rval = ecx_outframe(port, idx, 0);
if (port->redstate != ECT_RED_NONE)
{
- pthread_mutex_lock( &(port->tx_mutex) );
+ pthread_mutex_lock(&(port->tx_mutex));
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
{
port->redport->rxbufstat[idx] = EC_BUF_EMPTY;
}
- pthread_mutex_unlock( &(port->tx_mutex) );
+ pthread_mutex_unlock(&(port->tx_mutex));
}
return rval;
{
int lp, bytesrx;
ec_stackT *stack;
- struct pcap_pkthdr * header;
- unsigned char const * pkt_data;
+ struct pcap_pkthdr *header;
+ unsigned char const *pkt_data;
int res;
if (!stacknumber)
lp = sizeof(port->tempinbuf);
res = pcap_next_ex(*stack->sock, &header, &pkt_data);
- if (res <=0 )
+ if (res <= 0)
{
port->tempinbufs = 0;
return 0;
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
+ uint16 l;
+ int rval;
+ uint8 idxf;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
if (ecx_recvpkt(port, stacknumber))
{
rval = EC_OTHERFRAME;
- ehp =(ec_etherheadert*)(stack->tempbuf);
+ ehp = (ec_etherheadert *)(stack->tempbuf);
/* check if it is an EtherCAT frame */
if (ehp->etype == htons(ETH_P_ECAT))
{
- ecp =(ec_comt*)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
+ ecp = (ec_comt *)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
l = etohs(ecp->elength) & 0x0fff;
idxf = ecp->index;
/* found index equals requested index ? */
}
}
}
- pthread_mutex_unlock( &(port->rx_mutex) );
-
+ pthread_mutex_unlock(&(port->rx_mutex));
}
/* WKC if matching frame found */
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer)
{
osal_timert timer2;
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
{
if (wkc2 <= EC_NOFRAME)
wkc2 = ecx_inframe(port, idx, 1);
}
- /* wait for both frames to arrive or timeout */
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
ecx_outframe(port, idx, 1);
do
int wkc;
osal_timert timer;
- osal_timer_start (&timer, timeout);
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, &timer);
return wkc;
int wkc = EC_NOFRAME;
osal_timert timer1, timer2;
- osal_timer_start (&timer1, timeout);
+ osal_timer_start(&timer1, timeout);
do
{
/* tx frame on primary and if in redundant mode a dummy on secondary */
ecx_outframe_red(port, idx);
if (timeout < EC_TIMEOUTRET)
{
- osal_timer_start (&timer2, timeout);
+ osal_timer_start(&timer2, timeout);
}
else
{
/* normally use partial timeout for rx */
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
}
/* get frame from primary or if in redundant mode possibly from secondary */
wkc = ecx_waitinframe_red(port, idx, &timer2);
- /* wait for answer with WKC>=0 or otherwise retry until timeout */
- } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired (&timer1));
+ /* wait for answer with WKC>=0 or otherwise retry until timeout */
+ } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired(&timer1));
return wkc;
}
#define _nicdrvh_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include <pcap/pcap.h>
typedef struct
{
/** socket connection used */
- pcap_t **sock;
+ pcap_t **sock;
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** temporary receive buffer */
- ec_bufT *tempbuf;
+ ec_bufT *tempbuf;
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
+ int (*rxsa)[EC_MAXBUF];
} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct
{
- ec_stackT stack;
- pcap_t *sockhandle;
+ ec_stackT stack;
+ pcap_t *sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct
{
- ec_stackT stack;
- pcap_t *sockhandle;
+ ec_stackT stack;
+ pcap_t *sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
extern const uint16 secMAC[3];
void ec_setupheader(void *p);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#ifdef __cplusplus
}
*/
uint16 oshw_htons(uint16 host)
{
- uint16 network = htons (host);
+ uint16 network = htons(host);
return network;
}
*/
uint16 oshw_ntohs(uint16 network)
{
- uint16 host = ntohs (network);
+ uint16 host = ntohs(network);
return host;
}
/** Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters(void)
+ec_adaptert *oshw_find_adapters(void)
{
int i;
struct if_nameindex *ids;
- ec_adaptert * adapter;
- ec_adaptert * prev_adapter;
- ec_adaptert * ret_adapter = NULL;
-
+ ec_adaptert *adapter;
+ ec_adaptert *prev_adapter;
+ ec_adaptert *ret_adapter = NULL;
/* Iterate all devices and create a local copy holding the name and
* description.
*/
- ids = if_nameindex ();
- for(i = 0; ids[i].if_index != 0; i++)
+ ids = if_nameindex();
+ for (i = 0; ids[i].if_index != 0; i++)
{
adapter = (ec_adaptert *)malloc(sizeof(ec_adaptert));
/* If we got more than one adapter save link list pointer to previous
if (ids[i].if_name)
{
- strncpy(adapter->name, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
- adapter->name[EC_MAXLEN_ADAPTERNAME-1] = '\0';
- strncpy(adapter->desc, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
- adapter->desc[EC_MAXLEN_ADAPTERNAME-1] = '\0';
+ strncpy(adapter->name, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
+ adapter->name[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
+ strncpy(adapter->desc, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
+ adapter->desc[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
}
else
{
prev_adapter = adapter;
}
- if_freenameindex (ids);
+ if_freenameindex(ids);
return ret_adapter;
}
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters(ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
- ec_adaptert * next_adapter;
+ ec_adaptert *next_adapter;
/* Iterate the linked list and free all elements holding
* adapter information
*/
- if(adapter)
+ if (adapter)
{
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
while (next_adapter)
{
adapter = next_adapter;
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
}
}
}
uint16 oshw_htons(uint16 hostshort);
uint16 oshw_ntohs(uint16 networkshort);
-ec_adaptert * oshw_find_adapters(void);
-void oshw_free_adapters(ec_adaptert * adapter);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
ECT_RED_DOUBLE
};
-
/** Primary source MAC address used for EtherCAT.
* This address is not the MAC address used from the NIC.
* EtherCAT does not care about MAC addressing, but it is used here to
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to find out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0201, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0201, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0604, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0604, 0x0404, 0x0404};
/** second MAC word is used for identification */
#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
static void ecx_clear_rxbufstat(int *rxbufstat)
{
int i;
- for(i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
rxbufstat[i] = EC_BUF_EMPTY;
}
/* when using secondary socket it is automatically a redundant setup */
bpf = &(port->redport->sockhandle);
*bpf = -1;
- port->redstate = ECT_RED_DOUBLE;
- port->redport->stack.sock = &(port->redport->sockhandle);
- port->redport->stack.txbuf = &(port->txbuf);
+ port->redstate = ECT_RED_DOUBLE;
+ port->redport->stack.sock = &(port->redport->sockhandle);
+ port->redport->stack.txbuf = &(port->txbuf);
port->redport->stack.txbuflength = &(port->txbuflength);
- port->redport->stack.tempbuf = &(port->redport->tempinbuf);
- port->redport->stack.rxbuf = &(port->redport->rxbuf);
- port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
- port->redport->stack.rxsa = &(port->redport->rxsa);
+ port->redport->stack.tempbuf = &(port->redport->tempinbuf);
+ port->redport->stack.rxbuf = &(port->redport->rxbuf);
+ port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
+ port->redport->stack.rxsa = &(port->redport->rxsa);
ecx_clear_rxbufstat(&(port->redport->rxbufstat[0]));
}
else
else
{
pthread_mutex_init(&(port->getindex_mutex), NULL);
- pthread_mutex_init(&(port->tx_mutex) , NULL);
- pthread_mutex_init(&(port->rx_mutex) , NULL);
- port->sockhandle = -1;
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.sock = &(port->sockhandle);
- port->stack.txbuf = &(port->txbuf);
+ pthread_mutex_init(&(port->tx_mutex), NULL);
+ pthread_mutex_init(&(port->rx_mutex), NULL);
+ port->sockhandle = -1;
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.sock = &(port->sockhandle);
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
ecx_clear_rxbufstat(&(port->rxbufstat[0]));
bpf = &(port->sockhandle);
}
/* Open a bpf file descriptor */
*bpf = -1;
- for(i = 0; *bpf == -1 && i < maxbpffile; ++i)
+ for (i = 0; *bpf == -1 && i < maxbpffile; ++i)
{
- sprintf(fname, "/dev/bpf%i", i);
- *bpf = open(fname, O_RDWR);
+ sprintf(fname, "/dev/bpf%i", i);
+ *bpf = open(fname, O_RDWR);
}
- if(*bpf == -1)
+ if (*bpf == -1)
{
- /* Failed to open bpf */
- perror("Could not open bpf\n");
- return 0;
+ /* Failed to open bpf */
+ perror("Could not open bpf\n");
+ return 0;
}
/* Need to hand the same buffer size as bpf expects,
force bpf to use our buffer size! */
uint buffer_len = sizeof(ec_bufT);
- if (ioctl(*bpf, BIOCSBLEN, &buffer_len) == -1) {
- perror("BIOCGBLEN");
+ if (ioctl(*bpf, BIOCSBLEN, &buffer_len) == -1)
+ {
+ perror("BIOCGBLEN");
}
-
- if (buffer_len < 1518) {
- printf("buffer_len %d < 1518\n", buffer_len);
- return 0;
+
+ if (buffer_len < 1518)
+ {
+ printf("buffer_len %d < 1518\n", buffer_len);
+ return 0;
}
/* connect bpf to NIC by name */
strcpy(ifr.ifr_name, ifname);
- if(ioctl(*bpf, BIOCSETIF, &ifr) == -1) {
- perror("BIOCSETIF");
- return 0;
+ if (ioctl(*bpf, BIOCSETIF, &ifr) == -1)
+ {
+ perror("BIOCSETIF");
+ return 0;
}
/* Set required bpf options */
/* Activate immediate mode */
- if (ioctl(*bpf, BIOCIMMEDIATE, &true_val) == -1) {
- perror("BIOCIMMEDIATE");
- return 0;
+ if (ioctl(*bpf, BIOCIMMEDIATE, &true_val) == -1)
+ {
+ perror("BIOCIMMEDIATE");
+ return 0;
}
/* Set interface in promiscuous mode */
- if (ioctl(*bpf, BIOCPROMISC, &true_val) == -1) {
- perror("BIOCPROMISC");
- return 0;
+ if (ioctl(*bpf, BIOCPROMISC, &true_val) == -1)
+ {
+ perror("BIOCPROMISC");
+ return 0;
}
-
+
/* Allow to have custom source address */
- if (ioctl(*bpf, BIOCSHDRCMPLT, &true_val) == -1) {
- perror("BIOCSHDRCMPLT");
- return 0;
+ if (ioctl(*bpf, BIOCSHDRCMPLT, &true_val) == -1)
+ {
+ perror("BIOCSHDRCMPLT");
+ return 0;
}
/* Listen only to incomming messages */
uint direction = BPF_D_IN;
- if (ioctl(*bpf, BIOCSDIRECTION, &direction) == -1) {
- perror("BIOCSDIRECTION");
- return 0;
+ if (ioctl(*bpf, BIOCSDIRECTION, &direction) == -1)
+ {
+ perror("BIOCSDIRECTION");
+ return 0;
}
/* Set read timeout */
- timeout.tv_sec = 0;
+ timeout.tv_sec = 0;
timeout.tv_usec = 11000;
- if (ioctl(*bpf, BIOCSRTIMEOUT, &timeout) == -1) {
- perror("BIOCSRTIMEOUT");
- return 0;
+ if (ioctl(*bpf, BIOCSRTIMEOUT, &timeout) == -1)
+ {
+ perror("BIOCSRTIMEOUT");
+ return 0;
}
/* setup ethernet headers in tx buffers so we don't have to repeat it */
uint8 idx;
uint8 cnt;
- pthread_mutex_lock( &(port->getindex_mutex) );
+ pthread_mutex_lock(&(port->getindex_mutex));
idx = port->lastidx + 1;
/* index can't be larger than buffer array */
port->redport->rxbufstat[idx] = EC_BUF_ALLOC;
port->lastidx = idx;
- pthread_mutex_unlock( &(port->getindex_mutex) );
+ pthread_mutex_unlock(&(port->getindex_mutex));
return idx;
}
stack = &(port->redport->stack);
}
lp = (*stack->txbuflength)[idx];
- //rval = send(*stack->sock, (*stack->txbuf)[idx], lp, 0);
+ // rval = send(*stack->sock, (*stack->txbuf)[idx], lp, 0);
(*stack->rxbufstat)[idx] = EC_BUF_TX;
- rval = write (*stack->sock,(*stack->txbuf)[idx], lp);
+ rval = write(*stack->sock, (*stack->txbuf)[idx], lp);
if (rval == -1)
{
(*stack->rxbufstat)[idx] = EC_BUF_EMPTY;
rval = ecx_outframe(port, idx, 0);
if (port->redstate != ECT_RED_NONE)
{
- pthread_mutex_lock( &(port->tx_mutex) );
+ pthread_mutex_lock(&(port->tx_mutex));
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
ehp->sa1 = htons(secMAC[1]);
/* transmit over secondary socket */
- //send(port->redport->sockhandle, &(port->txbuf2), port->txbuflength2 , 0);
+ // send(port->redport->sockhandle, &(port->txbuf2), port->txbuflength2 , 0);
port->redport->rxbufstat[idx] = EC_BUF_TX;
if (write(port->redport->sockhandle, &(port->txbuf2), port->txbuflength2) == -1)
{
(*stack->rxbufstat)[idx] = EC_BUF_EMPTY;
}
- pthread_mutex_unlock( &(port->tx_mutex) );
+ pthread_mutex_unlock(&(port->tx_mutex));
}
return rval;
stack = &(port->redport->stack);
}
lp = sizeof(port->tempinbuf);
- //bytesrx = recv(*stack->sock, (*stack->tempbuf), lp, 0);
+ // bytesrx = recv(*stack->sock, (*stack->tempbuf), lp, 0);
bytesrx = read(*stack->sock, (*stack->tempbuf), lp);
port->tempinbufs = bytesrx;
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
+ uint16 l;
+ int rval;
+ uint8 idxf;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
/* The data read from /dev/bpf includes an extra header, skip it. */
struct bpf_hdr *bpfh = (struct bpf_hdr *)(stack->tempbuf);
rval = EC_OTHERFRAME;
- ehp =(ec_etherheadert*)(*stack->tempbuf + bpfh->bh_hdrlen);
+ ehp = (ec_etherheadert *)(*stack->tempbuf + bpfh->bh_hdrlen);
/* check if it is an EtherCAT frame */
if (ehp->etype == htons(ETH_P_ECAT))
{
/* The EtherCAT header follows the ethernet frame header. */
- ecp =(ec_comt*)(&ehp[1]);
+ ecp = (ec_comt *)(&ehp[1]);
l = etohs(ecp->elength) & 0x0fff;
idxf = ecp->index;
/* found index equals requested index ? */
}
}
}
- pthread_mutex_unlock( &(port->rx_mutex) );
-
+ pthread_mutex_unlock(&(port->rx_mutex));
}
/* WKC if matching frame found */
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer)
{
osal_timert timer2;
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
{
if (wkc2 <= EC_NOFRAME)
wkc2 = ecx_inframe(port, idx, 1);
}
- /* wait for both frames to arrive or timeout */
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
ecx_outframe(port, idx, 1);
do
int wkc;
osal_timert timer;
- osal_timer_start (&timer, timeout);
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, &timer);
return wkc;
int wkc = EC_NOFRAME;
osal_timert timer1, timer2;
- osal_timer_start (&timer1, timeout);
+ osal_timer_start(&timer1, timeout);
do
{
/* tx frame on primary and if in redundant mode a dummy on secondary */
ecx_outframe_red(port, idx);
if (timeout < EC_TIMEOUTRET)
{
- osal_timer_start (&timer2, timeout);
+ osal_timer_start(&timer2, timeout);
}
else
{
/* normally use partial timeout for rx */
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
}
/* get frame from primary or if in redundant mode possibly from secondary */
wkc = ecx_waitinframe_red(port, idx, &timer2);
- /* wait for answer with WKC>=0 or otherwise retry until timeout */
- } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired (&timer1));
+ /* wait for answer with WKC>=0 or otherwise retry until timeout */
+ } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired(&timer1));
return wkc;
}
#define _nicdrvh_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include <pthread.h>
typedef struct
{
/** socket connection used */
- int *sock;
+ int *sock;
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** temporary receive buffer */
- ec_bufT *tempbuf;
+ ec_bufT *tempbuf;
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
+ int (*rxsa)[EC_MAXBUF];
} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
+ ec_stackT stack;
+ int sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
+ ec_stackT stack;
+ int sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
extern const uint16 secMAC[3];
void ec_setupheader(void *p);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#ifdef __cplusplus
}
*/
uint16 oshw_htons(uint16 host)
{
- uint16 network = htons (host);
+ uint16 network = htons(host);
return network;
}
*/
uint16 oshw_ntohs(uint16 network)
{
- uint16 host = ntohs (network);
+ uint16 host = ntohs(network);
return host;
}
/** Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters(void)
+ec_adaptert *oshw_find_adapters(void)
{
int i;
struct if_nameindex *ids;
- ec_adaptert * adapter;
- ec_adaptert * prev_adapter;
- ec_adaptert * ret_adapter = NULL;
-
+ ec_adaptert *adapter;
+ ec_adaptert *prev_adapter;
+ ec_adaptert *ret_adapter = NULL;
/* Iterate all devices and create a local copy holding the name and
* description.
*/
- ids = if_nameindex ();
- for(i = 0; ids[i].if_index != 0; i++)
+ ids = if_nameindex();
+ for (i = 0; ids[i].if_index != 0; i++)
{
adapter = (ec_adaptert *)malloc(sizeof(ec_adaptert));
/* If we got more than one adapter save link list pointer to previous
if (ids[i].if_name)
{
- strncpy(adapter->name, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
- adapter->name[EC_MAXLEN_ADAPTERNAME-1] = '\0';
- strncpy(adapter->desc, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
- adapter->desc[EC_MAXLEN_ADAPTERNAME-1] = '\0';
+ strncpy(adapter->name, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
+ adapter->name[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
+ strncpy(adapter->desc, ids[i].if_name, EC_MAXLEN_ADAPTERNAME);
+ adapter->desc[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
}
else
{
prev_adapter = adapter;
}
- if_freenameindex (ids);
+ if_freenameindex(ids);
return ret_adapter;
}
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters(ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
- ec_adaptert * next_adapter;
+ ec_adaptert *next_adapter;
/* Iterate the linked list and free all elements holding
* adapter information
*/
- if(adapter)
+ if (adapter)
{
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
while (next_adapter)
{
adapter = next_adapter;
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
}
}
}
uint16 oshw_htons(uint16 hostshort);
uint16 oshw_ntohs(uint16 networkshort);
-ec_adaptert * oshw_find_adapters(void);
-void oshw_free_adapters(ec_adaptert * adapter);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
* See LICENSE file in the project root for full license information.
********************************************************************/
-#if defined (sabresd) || defined (twrk60f)
+#if defined(sabresd) || defined(twrk60f)
#include "fec_ecat.h"
#include "oshw.h"
#include <bsp.h>
#include <config.h>
-#undef RTK_DEBUG /* Print debugging info? */
-#undef RTK_DEBUG_DATA /* Print packets? */
+#undef RTK_DEBUG /* Print debugging info? */
+#undef RTK_DEBUG_DATA /* Print packets? */
#ifdef RTK_DEBUG
-#define DPRINT(...) rprintp ("FEC: "__VA_ARGS__)
+#define DPRINT(...) rprintp("FEC: "__VA_ARGS__)
#else
#define DPRINT(...)
-#endif /* DEBUG */
+#endif /* DEBUG */
#ifdef RTK_DEBUG_DATA
-#define DUMP_PACKET(p, l) fec_ecat_dump_packet (p, l)
+#define DUMP_PACKET(p, l) fec_ecat_dump_packet(p, l)
#else
#define DUMP_PACKET(p, l)
-#endif /* RTK_DEBUG_DATA */
+#endif /* RTK_DEBUG_DATA */
-#define ETHERNET_FCS_SIZE_IN_BYTES 4 /* Frame Check Sequence (32-bit CRC) */
+#define ETHERNET_FCS_SIZE_IN_BYTES 4 /* Frame Check Sequence (32-bit CRC) */
-#define DELAY(ms) task_delay (tick_from_ms (ms) + 1)
+#define DELAY(ms) task_delay(tick_from_ms(ms) + 1)
-#define ETH_PHY_ADDRESS 0x1 /* Default jumper setting on TWR-K60F */
+#define ETH_PHY_ADDRESS 0x1 /* Default jumper setting on TWR-K60F */
-#define NUM_BUFFERS 2
-#define FEC_ALLIGNED __attribute__((section(".dma"),aligned(16)))
+#define NUM_BUFFERS 2
+#define FEC_ALLIGNED __attribute__((section(".dma"), aligned(16)))
/*
* "The device's system clock is connected to the module clock,
*
* - Kinetis K60 manual ch. 3.9.1.1 "Ethernet Clocking Options"
*/
-#define FEC_MIN_MODULE_CLOCK_Hz (25 * 1000 * 1000)
+#define FEC_MIN_MODULE_CLOCK_Hz (25 * 1000 * 1000)
/* Note that the core clock and the system clock has the same clock frequency */
-#define FEC_MODULE_CLOCK_Hz CFG_IPG_CLOCK
+#define FEC_MODULE_CLOCK_Hz CFG_IPG_CLOCK
-
-#if defined (sabresd)
-extern phy_t * ar8031_init (const phy_cfg_t * cfg);
+#if defined(sabresd)
+extern phy_t *ar8031_init(const phy_cfg_t *cfg);
#define PHY_INIT ar8031_init
#define PHY_INTERFACE FEC_PHY_RGMII
#endif
-#if defined (twrk60f)
+#if defined(twrk60f)
#define PHY_INIT mii_init
#define PHY_INTERFACE FEC_PHY_RMII
#endif
-
//----------------------------------------------------------------------------//
typedef struct fec_mac_t
/* Message Information Block (MIB) Counters */
typedef struct fec_mib
{
- uint32_t rmon_t_drop; /* MBAR_ETH + 0x200 */
- uint32_t rmon_t_packets; /* MBAR_ETH + 0x204 */
- uint32_t rmon_t_bc_pkt; /* MBAR_ETH + 0x208 */
- uint32_t rmon_t_mc_pkt; /* MBAR_ETH + 0x20C */
- uint32_t rmon_t_crc_align; /* MBAR_ETH + 0x210 */
- uint32_t rmon_t_undersize; /* MBAR_ETH + 0x214 */
- uint32_t rmon_t_oversize; /* MBAR_ETH + 0x218 */
- uint32_t rmon_t_frag; /* MBAR_ETH + 0x21C */
- uint32_t rmon_t_jab; /* MBAR_ETH + 0x220 */
- uint32_t rmon_t_col; /* MBAR_ETH + 0x224 */
- uint32_t rmon_t_p64; /* MBAR_ETH + 0x228 */
- uint32_t rmon_t_p65to127; /* MBAR_ETH + 0x22C */
- uint32_t rmon_t_p128to255; /* MBAR_ETH + 0x230 */
- uint32_t rmon_t_p256to511; /* MBAR_ETH + 0x234 */
- uint32_t rmon_t_p512to1023; /* MBAR_ETH + 0x238 */
- uint32_t rmon_t_p1024to2047; /* MBAR_ETH + 0x23C */
- uint32_t rmon_t_p_gte2048; /* MBAR_ETH + 0x240 */
- uint32_t rmon_t_octets; /* MBAR_ETH + 0x244 */
- uint32_t ieee_t_drop; /* MBAR_ETH + 0x248 */
- uint32_t ieee_t_frame_ok; /* MBAR_ETH + 0x24C */
- uint32_t ieee_t_1col; /* MBAR_ETH + 0x250 */
- uint32_t ieee_t_mcol; /* MBAR_ETH + 0x254 */
- uint32_t ieee_t_def; /* MBAR_ETH + 0x258 */
- uint32_t ieee_t_lcol; /* MBAR_ETH + 0x25C */
- uint32_t ieee_t_excol; /* MBAR_ETH + 0x260 */
- uint32_t ieee_t_macerr; /* MBAR_ETH + 0x264 */
- uint32_t ieee_t_cserr; /* MBAR_ETH + 0x268 */
- uint32_t ieee_t_sqe; /* MBAR_ETH + 0x26C */
- uint32_t t_fdxfc; /* MBAR_ETH + 0x270 */
- uint32_t ieee_t_octets_ok; /* MBAR_ETH + 0x274 */
- uint32_t res13[2]; /* MBAR_ETH + 0x278-27C */
- uint32_t rmon_r_drop; /* MBAR_ETH + 0x280 */
- uint32_t rmon_r_packets; /* MBAR_ETH + 0x284 */
- uint32_t rmon_r_bc_pkt; /* MBAR_ETH + 0x288 */
- uint32_t rmon_r_mc_pkt; /* MBAR_ETH + 0x28C */
- uint32_t rmon_r_crc_align; /* MBAR_ETH + 0x290 */
- uint32_t rmon_r_undersize; /* MBAR_ETH + 0x294 */
- uint32_t rmon_r_oversize; /* MBAR_ETH + 0x298 */
- uint32_t rmon_r_frag; /* MBAR_ETH + 0x29C */
- uint32_t rmon_r_jab; /* MBAR_ETH + 0x2A0 */
- uint32_t rmon_r_resvd_0; /* MBAR_ETH + 0x2A4 */
- uint32_t rmon_r_p64; /* MBAR_ETH + 0x2A8 */
- uint32_t rmon_r_p65to127; /* MBAR_ETH + 0x2AC */
- uint32_t rmon_r_p128to255; /* MBAR_ETH + 0x2B0 */
- uint32_t rmon_r_p256to511; /* MBAR_ETH + 0x2B4 */
- uint32_t rmon_r_p512to1023; /* MBAR_ETH + 0x2B8 */
- uint32_t rmon_r_p1024to2047; /* MBAR_ETH + 0x2BC */
- uint32_t rmon_r_p_gte2048; /* MBAR_ETH + 0x2C0 */
- uint32_t rmon_r_octets; /* MBAR_ETH + 0x2C4 */
- uint32_t ieee_r_drop; /* MBAR_ETH + 0x2C8 */
- uint32_t ieee_r_frame_ok; /* MBAR_ETH + 0x2CC */
- uint32_t ieee_r_crc; /* MBAR_ETH + 0x2D0 */
- uint32_t ieee_r_align; /* MBAR_ETH + 0x2D4 */
- uint32_t r_macerr; /* MBAR_ETH + 0x2D8 */
- uint32_t r_fdxfc; /* MBAR_ETH + 0x2DC */
- uint32_t ieee_r_octets_ok; /* MBAR_ETH + 0x2E0 */
- uint32_t res14[7]; /* MBAR_ETH + 0x2E4-2FC */
+ uint32_t rmon_t_drop; /* MBAR_ETH + 0x200 */
+ uint32_t rmon_t_packets; /* MBAR_ETH + 0x204 */
+ uint32_t rmon_t_bc_pkt; /* MBAR_ETH + 0x208 */
+ uint32_t rmon_t_mc_pkt; /* MBAR_ETH + 0x20C */
+ uint32_t rmon_t_crc_align; /* MBAR_ETH + 0x210 */
+ uint32_t rmon_t_undersize; /* MBAR_ETH + 0x214 */
+ uint32_t rmon_t_oversize; /* MBAR_ETH + 0x218 */
+ uint32_t rmon_t_frag; /* MBAR_ETH + 0x21C */
+ uint32_t rmon_t_jab; /* MBAR_ETH + 0x220 */
+ uint32_t rmon_t_col; /* MBAR_ETH + 0x224 */
+ uint32_t rmon_t_p64; /* MBAR_ETH + 0x228 */
+ uint32_t rmon_t_p65to127; /* MBAR_ETH + 0x22C */
+ uint32_t rmon_t_p128to255; /* MBAR_ETH + 0x230 */
+ uint32_t rmon_t_p256to511; /* MBAR_ETH + 0x234 */
+ uint32_t rmon_t_p512to1023; /* MBAR_ETH + 0x238 */
+ uint32_t rmon_t_p1024to2047; /* MBAR_ETH + 0x23C */
+ uint32_t rmon_t_p_gte2048; /* MBAR_ETH + 0x240 */
+ uint32_t rmon_t_octets; /* MBAR_ETH + 0x244 */
+ uint32_t ieee_t_drop; /* MBAR_ETH + 0x248 */
+ uint32_t ieee_t_frame_ok; /* MBAR_ETH + 0x24C */
+ uint32_t ieee_t_1col; /* MBAR_ETH + 0x250 */
+ uint32_t ieee_t_mcol; /* MBAR_ETH + 0x254 */
+ uint32_t ieee_t_def; /* MBAR_ETH + 0x258 */
+ uint32_t ieee_t_lcol; /* MBAR_ETH + 0x25C */
+ uint32_t ieee_t_excol; /* MBAR_ETH + 0x260 */
+ uint32_t ieee_t_macerr; /* MBAR_ETH + 0x264 */
+ uint32_t ieee_t_cserr; /* MBAR_ETH + 0x268 */
+ uint32_t ieee_t_sqe; /* MBAR_ETH + 0x26C */
+ uint32_t t_fdxfc; /* MBAR_ETH + 0x270 */
+ uint32_t ieee_t_octets_ok; /* MBAR_ETH + 0x274 */
+ uint32_t res13[2]; /* MBAR_ETH + 0x278-27C */
+ uint32_t rmon_r_drop; /* MBAR_ETH + 0x280 */
+ uint32_t rmon_r_packets; /* MBAR_ETH + 0x284 */
+ uint32_t rmon_r_bc_pkt; /* MBAR_ETH + 0x288 */
+ uint32_t rmon_r_mc_pkt; /* MBAR_ETH + 0x28C */
+ uint32_t rmon_r_crc_align; /* MBAR_ETH + 0x290 */
+ uint32_t rmon_r_undersize; /* MBAR_ETH + 0x294 */
+ uint32_t rmon_r_oversize; /* MBAR_ETH + 0x298 */
+ uint32_t rmon_r_frag; /* MBAR_ETH + 0x29C */
+ uint32_t rmon_r_jab; /* MBAR_ETH + 0x2A0 */
+ uint32_t rmon_r_resvd_0; /* MBAR_ETH + 0x2A4 */
+ uint32_t rmon_r_p64; /* MBAR_ETH + 0x2A8 */
+ uint32_t rmon_r_p65to127; /* MBAR_ETH + 0x2AC */
+ uint32_t rmon_r_p128to255; /* MBAR_ETH + 0x2B0 */
+ uint32_t rmon_r_p256to511; /* MBAR_ETH + 0x2B4 */
+ uint32_t rmon_r_p512to1023; /* MBAR_ETH + 0x2B8 */
+ uint32_t rmon_r_p1024to2047; /* MBAR_ETH + 0x2BC */
+ uint32_t rmon_r_p_gte2048; /* MBAR_ETH + 0x2C0 */
+ uint32_t rmon_r_octets; /* MBAR_ETH + 0x2C4 */
+ uint32_t ieee_r_drop; /* MBAR_ETH + 0x2C8 */
+ uint32_t ieee_r_frame_ok; /* MBAR_ETH + 0x2CC */
+ uint32_t ieee_r_crc; /* MBAR_ETH + 0x2D0 */
+ uint32_t ieee_r_align; /* MBAR_ETH + 0x2D4 */
+ uint32_t r_macerr; /* MBAR_ETH + 0x2D8 */
+ uint32_t r_fdxfc; /* MBAR_ETH + 0x2DC */
+ uint32_t ieee_r_octets_ok; /* MBAR_ETH + 0x2E0 */
+ uint32_t res14[7]; /* MBAR_ETH + 0x2E4-2FC */
} fec_mib_t;
-COMPILETIME_ASSERT (sizeof (fec_mib_t) == 0x100);
+COMPILETIME_ASSERT(sizeof(fec_mib_t) == 0x100);
/* Register read/write struct */
typedef struct reg_fec
uint32_t resv6[15];
uint32_t tcr;
uint32_t resv7[7];
- fec_mac_t pa; /* Physical address. PALR/PAUR */
+ fec_mac_t pa; /* Physical address. PALR/PAUR */
uint32_t opd;
uint32_t resv8[10];
uint32_t iaur;
uint32_t tx_almost_full; /* Not present on all controllers */
uint32_t resv12[21];
const fec_mib_t mib;
- uint32_t fec_miigsk_cfgr; /* Not present on all controllers */
+ uint32_t fec_miigsk_cfgr; /* Not present on all controllers */
uint32_t resv13;
- uint32_t fec_miigsk_enr; /* Not present on all controllers */
+ uint32_t fec_miigsk_enr; /* Not present on all controllers */
uint32_t resv15[0x7d];
- fec_mac_t smac[4]; /* Not present on all controllers */
+ fec_mac_t smac[4]; /* Not present on all controllers */
} reg_fec_t;
-COMPILETIME_ASSERT (offsetof (reg_fec_t, emrbr) == 0x188);
-COMPILETIME_ASSERT (offsetof (reg_fec_t, tx_almost_full) == 0x1A8);
-COMPILETIME_ASSERT (offsetof (reg_fec_t, fec_miigsk_cfgr) == 0x300);
-COMPILETIME_ASSERT (offsetof (reg_fec_t, smac) == 0x500);
-COMPILETIME_ASSERT (offsetof (reg_fec_t, smac[3]) == 0x518);
+COMPILETIME_ASSERT(offsetof(reg_fec_t, emrbr) == 0x188);
+COMPILETIME_ASSERT(offsetof(reg_fec_t, tx_almost_full) == 0x1A8);
+COMPILETIME_ASSERT(offsetof(reg_fec_t, fec_miigsk_cfgr) == 0x300);
+COMPILETIME_ASSERT(offsetof(reg_fec_t, smac) == 0x500);
+COMPILETIME_ASSERT(offsetof(reg_fec_t, smac[3]) == 0x518);
//----------------------------------------------------------------------------//
/* Bit definitions and macros for FEC_EIR */
-#define FEC_EIR_CLEAR_ALL (0xFFF80000)
-#define FEC_EIR_HBERR (0x80000000)
-#define FEC_EIR_BABR (0x40000000)
-#define FEC_EIR_BABT (0x20000000)
-#define FEC_EIR_GRA (0x10000000)
-#define FEC_EIR_TXF (0x08000000)
-#define FEC_EIR_TXB (0x04000000)
-#define FEC_EIR_RXF (0x02000000)
-#define FEC_EIR_RXB (0x01000000)
-#define FEC_EIR_MII (0x00800000)
-#define FEC_EIR_EBERR (0x00400000)
-#define FEC_EIR_LC (0x00200000)
-#define FEC_EIR_RL (0x00100000)
-#define FEC_EIR_UN (0x00080000)
+#define FEC_EIR_CLEAR_ALL (0xFFF80000)
+#define FEC_EIR_HBERR (0x80000000)
+#define FEC_EIR_BABR (0x40000000)
+#define FEC_EIR_BABT (0x20000000)
+#define FEC_EIR_GRA (0x10000000)
+#define FEC_EIR_TXF (0x08000000)
+#define FEC_EIR_TXB (0x04000000)
+#define FEC_EIR_RXF (0x02000000)
+#define FEC_EIR_RXB (0x01000000)
+#define FEC_EIR_MII (0x00800000)
+#define FEC_EIR_EBERR (0x00400000)
+#define FEC_EIR_LC (0x00200000)
+#define FEC_EIR_RL (0x00100000)
+#define FEC_EIR_UN (0x00080000)
/* Bit definitions and macros for FEC_RDAR */
-#define FEC_RDAR_R_DES_ACTIVE (0x01000000)
+#define FEC_RDAR_R_DES_ACTIVE (0x01000000)
/* Bit definitions and macros for FEC_TDAR */
-#define FEC_TDAR_X_DES_ACTIVE (0x01000000)
+#define FEC_TDAR_X_DES_ACTIVE (0x01000000)
/* Bit definitions and macros for FEC_ECR */
-#define FEC_ECR_DBSWP (0x00000100)
-#define FEC_ECR_SPEED (0x00000020)
-#define FEC_ECR_ETHER_EN (0x00000002)
-#define FEC_ECR_RESET (0x00000001)
+#define FEC_ECR_DBSWP (0x00000100)
+#define FEC_ECR_SPEED (0x00000020)
+#define FEC_ECR_ETHER_EN (0x00000002)
+#define FEC_ECR_RESET (0x00000001)
/* Bit definitions and macros for FEC_MMFR */
-#define FEC_MMFR_DATA(x) (((x)&0xFFFF))
-#define FEC_MMFR_ST(x) (((x)&0x03)<<30)
-#define FEC_MMFR_ST_01 (0x40000000)
-#define FEC_MMFR_OP_RD (0x20000000)
-#define FEC_MMFR_OP_WR (0x10000000)
-#define FEC_MMFR_PA(x) (((x)&0x1F)<<23)
-#define FEC_MMFR_RA(x) (((x)&0x1F)<<18)
-#define FEC_MMFR_TA(x) (((x)&0x03)<<16)
-#define FEC_MMFR_TA_10 (0x00020000)
+#define FEC_MMFR_DATA(x) (((x) & 0xFFFF))
+#define FEC_MMFR_ST(x) (((x) & 0x03) << 30)
+#define FEC_MMFR_ST_01 (0x40000000)
+#define FEC_MMFR_OP_RD (0x20000000)
+#define FEC_MMFR_OP_WR (0x10000000)
+#define FEC_MMFR_PA(x) (((x) & 0x1F) << 23)
+#define FEC_MMFR_RA(x) (((x) & 0x1F) << 18)
+#define FEC_MMFR_TA(x) (((x) & 0x03) << 16)
+#define FEC_MMFR_TA_10 (0x00020000)
/* Bit definitions and macros for FEC_MSCR */
-#define FEC_MSCR_DIS_PREAMBLE (0x00000080)
-#define FEC_MSCR_MII_SPEED(x) (((x)&0x3F)<<1)
+#define FEC_MSCR_DIS_PREAMBLE (0x00000080)
+#define FEC_MSCR_MII_SPEED(x) (((x) & 0x3F) << 1)
/* Bit definitions and macros for FEC_MIBC */
-#define FEC_MIBC_MIB_DISABLE (0x80000000)
-#define FEC_MIBC_MIB_IDLE (0x40000000)
+#define FEC_MIBC_MIB_DISABLE (0x80000000)
+#define FEC_MIBC_MIB_IDLE (0x40000000)
/* Bit definitions and macros for FEC_RCR */
-#define FEC_RCR_GRS (0x80000000)
-#define FEC_RCR_NO_LGTH_CHECK (0x40000000)
-#define FEC_RCR_MAX_FL(x) (((x)&0x7FF)<<16)
-#define FEC_RCR_CNTL_FRM_ENA (0x00008000)
-#define FEC_RCR_CRC_FWD (0x00004000)
-#define FEC_RCR_PAUSE_FWD (0x00002000)
-#define FEC_RCR_PAD_EN (0x00001000)
-#define FEC_RCR_RMII_ECHO (0x00000800)
-#define FEC_RCR_RMII_LOOP (0x00000400)
-#define FEC_RCR_RMII_10T (0x00000200)
-#define FEC_RCR_RMII_MODE (0x00000100)
-#define FEC_RCR_SGMII_ENA (0x00000080)
-#define FEC_RCR_RGMII_EN (0x00000040)
-#define FEC_RCR_FCE (0x00000020)
-#define FEC_RCR_BC_REJ (0x00000010)
-#define FEC_RCR_PROM (0x00000008)
-#define FEC_RCR_MII_MODE (0x00000004)
-#define FEC_RCR_DRT (0x00000002)
-#define FEC_RCR_LOOP (0x00000001)
+#define FEC_RCR_GRS (0x80000000)
+#define FEC_RCR_NO_LGTH_CHECK (0x40000000)
+#define FEC_RCR_MAX_FL(x) (((x) & 0x7FF) << 16)
+#define FEC_RCR_CNTL_FRM_ENA (0x00008000)
+#define FEC_RCR_CRC_FWD (0x00004000)
+#define FEC_RCR_PAUSE_FWD (0x00002000)
+#define FEC_RCR_PAD_EN (0x00001000)
+#define FEC_RCR_RMII_ECHO (0x00000800)
+#define FEC_RCR_RMII_LOOP (0x00000400)
+#define FEC_RCR_RMII_10T (0x00000200)
+#define FEC_RCR_RMII_MODE (0x00000100)
+#define FEC_RCR_SGMII_ENA (0x00000080)
+#define FEC_RCR_RGMII_EN (0x00000040)
+#define FEC_RCR_FCE (0x00000020)
+#define FEC_RCR_BC_REJ (0x00000010)
+#define FEC_RCR_PROM (0x00000008)
+#define FEC_RCR_MII_MODE (0x00000004)
+#define FEC_RCR_DRT (0x00000002)
+#define FEC_RCR_LOOP (0x00000001)
/* Bit definitions and macros for FEC_TCR */
-#define FEC_TCR_RFC_PAUSE (0x00000010)
-#define FEC_TCR_TFC_PAUSE (0x00000008)
-#define FEC_TCR_FDEN (0x00000004)
-#define FEC_TCR_HBC (0x00000002)
-#define FEC_TCR_GTS (0x00000001)
+#define FEC_TCR_RFC_PAUSE (0x00000010)
+#define FEC_TCR_TFC_PAUSE (0x00000008)
+#define FEC_TCR_FDEN (0x00000004)
+#define FEC_TCR_HBC (0x00000002)
+#define FEC_TCR_GTS (0x00000001)
/* Bit definitions and macros for FEC_PAUR */
-#define FEC_PAUR_PADDR2(x) (((x)&0xFFFF)<<16)
-#define FEC_PAUR_TYPE(x) ((x)&0xFFFF)
+#define FEC_PAUR_PADDR2(x) (((x) & 0xFFFF) << 16)
+#define FEC_PAUR_TYPE(x) ((x) & 0xFFFF)
/* Bit definitions and macros for FEC_OPD */
-#define FEC_OPD_PAUSE_DUR(x) (((x)&0x0000FFFF)<<0)
-#define FEC_OPD_OPCODE(x) (((x)&0x0000FFFF)<<16)
+#define FEC_OPD_PAUSE_DUR(x) (((x) & 0x0000FFFF) << 0)
+#define FEC_OPD_OPCODE(x) (((x) & 0x0000FFFF) << 16)
/* Bit definitions and macros for FEC_TFWR */
-#define FEC_TFWR_STR_FWD BIT (8) /* Present on ENET but not on FEC */
-#define FEC_TFWR_X_WMRK(x) ((x)&0x03)
-#define FEC_TFWR_X_WMRK_64 (0x01)
-#define FEC_TFWR_X_WMRK_128 (0x02)
-#define FEC_TFWR_X_WMRK_192 (0x03)
+#define FEC_TFWR_STR_FWD BIT(8) /* Present on ENET but not on FEC */
+#define FEC_TFWR_X_WMRK(x) ((x) & 0x03)
+#define FEC_TFWR_X_WMRK_64 (0x01)
+#define FEC_TFWR_X_WMRK_128 (0x02)
+#define FEC_TFWR_X_WMRK_192 (0x03)
/* Bit definitions and macros for FEC_FRBR */
-#define FEC_FRBR_R_BOUND(x) (((x)&0xFF)<<2)
+#define FEC_FRBR_R_BOUND(x) (((x) & 0xFF) << 2)
/* Bit definitions and macros for FEC_FRSR */
-#define FEC_FRSR_R_FSTART(x) (((x)&0xFF)<<2)
+#define FEC_FRSR_R_FSTART(x) (((x) & 0xFF) << 2)
/* Bit definitions and macros for FEC_ERDSR */
-#define FEC_ERDSR_R_DES_START(x) (((x)&0x3FFFFFFF)<<2)
+#define FEC_ERDSR_R_DES_START(x) (((x) & 0x3FFFFFFF) << 2)
/* Bit definitions and macros for FEC_ETDSR */
-#define FEC_ETDSR_X_DES_START(x) (((x)&0x3FFFFFFF)<<2)
+#define FEC_ETDSR_X_DES_START(x) (((x) & 0x3FFFFFFF) << 2)
/* Bit definitions and macros for FEC_EMRBR */
-#define FEC_EMRBR_R_BUF_SIZE(x) (((x)&0x7F)<<4)
+#define FEC_EMRBR_R_BUF_SIZE(x) (((x) & 0x7F) << 4)
//----------------------------------------------------------------------------//
/* the defines of MII operation */
-#define FEC_MII_ST 0x40000000
-#define FEC_MII_OP_OFF 28
-#define FEC_MII_OP_MASK 0x03
-#define FEC_MII_OP_RD 0x02
-#define FEC_MII_OP_WR 0x01
-#define FEC_MII_PA_OFF 23
-#define FEC_MII_PA_MASK 0xFF
-#define FEC_MII_RA_OFF 18
-#define FEC_MII_RA_MASK 0xFF
-#define FEC_MII_TA 0x00020000
-#define FEC_MII_DATA_OFF 0
-#define FEC_MII_DATA_MASK 0x0000FFFF
-
-#define FEC_MII_FRAME (FEC_MII_ST | FEC_MII_TA)
-#define FEC_MII_OP(x) (((x) & FEC_MII_OP_MASK) << FEC_MII_OP_OFF)
-#define FEC_MII_PA(pa) (((pa) & FEC_MII_PA_MASK) << FEC_MII_PA_OFF)
-#define FEC_MII_RA(ra) (((ra) & FEC_MII_RA_MASK) << FEC_MII_RA_OFF)
-#define FEC_MII_SET_DATA(v) (((v) & FEC_MII_DATA_MASK) << FEC_MII_DATA_OFF)
-#define FEC_MII_GET_DATA(v) (((v) >> FEC_MII_DATA_OFF) & FEC_MII_DATA_MASK)
-#define FEC_MII_READ(pa, ra) ((FEC_MII_FRAME | FEC_MII_OP(FEC_MII_OP_RD)) |\
- FEC_MII_PA(pa) | FEC_MII_RA(ra))
-#define FEC_MII_WRITE(pa, ra, v) (FEC_MII_FRAME | FEC_MII_OP(FEC_MII_OP_WR)|\
- FEC_MII_PA(pa) | FEC_MII_RA(ra) | FEC_MII_SET_DATA(v))
-
-#define FEC_MII_TIMEOUT 10 // 1 * 10 ms
-#define FEC_MII_TICK 1 // 1 ms
+#define FEC_MII_ST 0x40000000
+#define FEC_MII_OP_OFF 28
+#define FEC_MII_OP_MASK 0x03
+#define FEC_MII_OP_RD 0x02
+#define FEC_MII_OP_WR 0x01
+#define FEC_MII_PA_OFF 23
+#define FEC_MII_PA_MASK 0xFF
+#define FEC_MII_RA_OFF 18
+#define FEC_MII_RA_MASK 0xFF
+#define FEC_MII_TA 0x00020000
+#define FEC_MII_DATA_OFF 0
+#define FEC_MII_DATA_MASK 0x0000FFFF
+
+#define FEC_MII_FRAME (FEC_MII_ST | FEC_MII_TA)
+#define FEC_MII_OP(x) (((x) & FEC_MII_OP_MASK) << FEC_MII_OP_OFF)
+#define FEC_MII_PA(pa) (((pa) & FEC_MII_PA_MASK) << FEC_MII_PA_OFF)
+#define FEC_MII_RA(ra) (((ra) & FEC_MII_RA_MASK) << FEC_MII_RA_OFF)
+#define FEC_MII_SET_DATA(v) (((v) & FEC_MII_DATA_MASK) << FEC_MII_DATA_OFF)
+#define FEC_MII_GET_DATA(v) (((v) >> FEC_MII_DATA_OFF) & FEC_MII_DATA_MASK)
+#define FEC_MII_READ(pa, ra) ((FEC_MII_FRAME | FEC_MII_OP(FEC_MII_OP_RD)) | \
+ FEC_MII_PA(pa) | FEC_MII_RA(ra))
+#define FEC_MII_WRITE(pa, ra, v) (FEC_MII_FRAME | FEC_MII_OP(FEC_MII_OP_WR) | \
+ FEC_MII_PA(pa) | FEC_MII_RA(ra) | FEC_MII_SET_DATA(v))
+
+#define FEC_MII_TIMEOUT 10 // 1 * 10 ms
+#define FEC_MII_TICK 1 // 1 ms
//----------------------------------------------------------------------------//
/* Ethernet Transmit and Receive Buffers */
-#define PKT_MAXBUF_SIZE 1518
+#define PKT_MAXBUF_SIZE 1518
//----------------------------------------------------------------------------//
{
uint32_t base;
uint32_t clock;
- fec_buffer_bd_t * tx_bd_base;
- fec_buffer_bd_t * rx_bd_base;
+ fec_buffer_bd_t *tx_bd_base;
+ fec_buffer_bd_t *rx_bd_base;
fec_phy_inteface_t phy_interface;
} fec_cfg_t;
typedef struct fec
{
uint32_t clock;
- fec_buffer_bd_t * tx_bd_base;
- fec_buffer_bd_t * rx_bd_base;
+ fec_buffer_bd_t *tx_bd_base;
+ fec_buffer_bd_t *rx_bd_base;
volatile reg_fec_t *base;
- phy_t * phy;
+ phy_t *phy;
fec_phy_inteface_t phy_interface;
} fec_t;
//----------------------------------------------------------------------------//
#ifdef RTK_DEBUG
-const char * fec_ecat_link_duplex_name (uint8_t link_state)
+const char *fec_ecat_link_duplex_name(uint8_t link_state)
{
if (link_state & PHY_LINK_OK)
{
}
}
-const char * fec_ecat_link_speed_name (uint8_t link_state)
+const char *fec_ecat_link_speed_name(uint8_t link_state)
{
if (link_state & PHY_LINK_OK)
{
#ifdef RTK_DEBUG_DATA
#include <ctype.h>
-static void fec_ecat_dump_packet (const uint8_t * payload, size_t len)
+static void fec_ecat_dump_packet(const uint8_t *payload, size_t len)
{
size_t i, j, n;
char s[80];
- ASSERT (payload != NULL);
+ ASSERT(payload != NULL);
for (i = 0; i < len; i += 16)
{
n = 0;
for (j = 0; j < 16 && (i + j) < len; j++)
{
- ASSERT (n <= sizeof(s));
- n += rsnprintf (s + n, sizeof(s) - n, "%02x ", payload[i + j]);
+ ASSERT(n <= sizeof(s));
+ n += rsnprintf(s + n, sizeof(s) - n, "%02x ", payload[i + j]);
}
for (; j < 16; j++)
{
- ASSERT (n <= sizeof(s));
- n += rsnprintf (s + n, sizeof(s) - n, " ");
+ ASSERT(n <= sizeof(s));
+ n += rsnprintf(s + n, sizeof(s) - n, " ");
}
- ASSERT (n <= sizeof(s));
- n += rsnprintf (s + n, sizeof(s) - n, "|");
+ ASSERT(n <= sizeof(s));
+ n += rsnprintf(s + n, sizeof(s) - n, "|");
for (j = 0; j < 16 && (i + j) < len; j++)
{
uint8_t c = payload[i + j];
- c = (isprint (c)) ? c : '.';
- ASSERT (n <= sizeof(s));
- n += rsnprintf (s + n, sizeof(s) - n, "%c", c);
+ c = (isprint(c)) ? c : '.';
+ ASSERT(n <= sizeof(s));
+ n += rsnprintf(s + n, sizeof(s) - n, "%c", c);
}
- ASSERT (n <= sizeof(s));
- n += rsnprintf (s + n, sizeof(s) - n, "|\n");
- ASSERT (n <= sizeof(s));
- DPRINT ("%s", s);
+ ASSERT(n <= sizeof(s));
+ n += rsnprintf(s + n, sizeof(s) - n, "|\n");
+ ASSERT(n <= sizeof(s));
+ DPRINT("%s", s);
}
}
-#endif /* DEBUG_DATA */
+#endif /* DEBUG_DATA */
-static uint16_t fec_ecat_read_phy (void * arg, uint8_t address, uint8_t reg)
+static uint16_t fec_ecat_read_phy(void *arg, uint8_t address, uint8_t reg)
{
- fec->base->eir = FEC_EIR_MII; // Clear interrupt.
+ fec->base->eir = FEC_EIR_MII; // Clear interrupt.
fec->base->mmfr = FEC_MII_READ(address, reg); // Write read command.
while (!(fec->base->eir & FEC_EIR_MII))
{
return data; // Return read data.
}
-static void fec_ecat_write_phy (void * arg, uint8_t address, uint8_t reg,
- uint16_t value)
+static void fec_ecat_write_phy(void *arg, uint8_t address, uint8_t reg,
+ uint16_t value)
{
- fec->base->eir = FEC_EIR_MII; // Clear interrupt.
+ fec->base->eir = FEC_EIR_MII; // Clear interrupt.
fec->base->mmfr = FEC_MII_WRITE(address, reg, value); // Write data.
while (!(fec->base->eir & FEC_EIR_MII))
{
fec->base->eir = FEC_EIR_MII; // Clear interrupt.
}
-static void fec_ecat_init_hw (const fec_mac_address_t * mac_address)
+static void fec_ecat_init_hw(const fec_mac_address_t *mac_address)
{
uint32_t mii_speed;
// Receive control register
fec->base->rcr = FEC_RCR_MAX_FL(PKT_MAXBUF_SIZE);
- switch(fec->phy_interface)
+ switch (fec->phy_interface)
{
case FEC_PHY_MII:
fec->base->rcr |= FEC_RCR_MII_MODE;
// Reset phy
if (fec->phy->ops->reset)
{
- fec->phy->ops->reset (fec->phy);
+ fec->phy->ops->reset(fec->phy);
}
/* Don't receive any unicast frames except those whose destination address
/* Set our physical address. */
fec->base->pa.lower = (mac_address->octet[0] << 24) +
(mac_address->octet[1] << 16) +
- (mac_address->octet[2] << 8) +
+ (mac_address->octet[2] << 8) +
(mac_address->octet[3] << 0);
fec->base->pa.upper = (mac_address->octet[4] << 24) +
(mac_address->octet[5] << 16) +
0x8808;
/* Start link autonegotiation */
- fec->phy->ops->start (fec->phy);
+ fec->phy->ops->start(fec->phy);
}
-int oshw_mac_send (const void *payload, size_t tot_len)
+int oshw_mac_send(const void *payload, size_t tot_len)
{
- fec_buffer_bd_t * bd;
+ fec_buffer_bd_t *bd;
/* Frames larger than the maximum Ethernet frame size are not allowed. */
- ASSERT (tot_len <= PKT_MAXBUF_SIZE);
- ASSERT (tot_len <= TX_BUFFER_SIZE);
+ ASSERT(tot_len <= PKT_MAXBUF_SIZE);
+ ASSERT(tot_len <= TX_BUFFER_SIZE);
/* Bus errors should never occur, unless the MPU is enabled and forbids
* the Ethernet MAC DMA from accessing the descriptors or buffers.
*/
- ASSERT ((fec->base->eir & FEC_EIR_EBERR) == false);
+ ASSERT((fec->base->eir & FEC_EIR_EBERR) == false);
/* Allocate a transmit buffer. We wait here until the MAC has released at
* least one buffer. This could take a couple of microseconds.
bd = NULL;
while (bd == NULL)
{
- bd = fec_buffer_get_tx ();
+ bd = fec_buffer_get_tx();
}
- DPRINT ("out (%u):\n", tot_len);
- DUMP_PACKET (payload, tot_len);
+ DPRINT("out (%u):\n", tot_len);
+ DUMP_PACKET(payload, tot_len);
/* Copy frame to allocated buffer */
- memcpy (bd->data, payload, tot_len);
+ memcpy(bd->data, payload, tot_len);
bd->length = tot_len;
- fec_buffer_produce_tx (bd);
+ fec_buffer_produce_tx(bd);
-#if defined (twrk60f)
+#if defined(twrk60f)
/* Wait for previous transmissions to complete.
*
* This is a workaround for Freescale Kinetis errata e6358.
return tot_len;
}
-int oshw_mac_recv (void * buffer, size_t buffer_length)
+int oshw_mac_recv(void *buffer, size_t buffer_length)
{
- fec_buffer_bd_t * bd;
+ fec_buffer_bd_t *bd;
int return_value;
size_t frame_length_without_fcs;
/* Bus errors should never occur, unless the MPU is enabled and forbids
* the Ethernet MAC DMA from accessing the descriptors or buffers.
*/
- ASSERT ((fec->base->eir & FEC_EIR_EBERR) == false);
+ ASSERT((fec->base->eir & FEC_EIR_EBERR) == false);
- bd = fec_buffer_get_rx ();
+ bd = fec_buffer_get_rx();
if (bd == NULL)
{
/* No frame received. Not an error. */
frame_length_without_fcs = bd->length - ETHERNET_FCS_SIZE_IN_BYTES;
/* A frame was received. Handle it and then return its buffer to hardware */
- if ((bd->status & BD_RX_L)== 0){
+ if ((bd->status & BD_RX_L) == 0)
+ {
/* Buffer is not last buffer in frame. This really should never
* happen as our buffers are large enough to contain any
* Ethernet frame. Nevertheless, is has been observed to happen.
* Drop the packet and hope for the best.
*/
- DPRINT ("recv(): End of frame not found. Status: 0x%x\n", bd->status);
+ DPRINT("recv(): End of frame not found. Status: 0x%x\n", bd->status);
return_value = -1;
}
else if (bd->status & (BD_RX_LG | BD_RX_NO | BD_RX_CR | BD_RX_OV))
{
- DPRINT ("recv(): Frame is damaged. Status: 0x%x\n", bd->status);
+ DPRINT("recv(): Frame is damaged. Status: 0x%x\n", bd->status);
return_value = -1;
}
else if (buffer_length >= frame_length_without_fcs)
{
/* No errors detected, so frame should be valid. */
- ASSERT (frame_length_without_fcs > 0);
+ ASSERT(frame_length_without_fcs > 0);
- memcpy (buffer, bd->data, frame_length_without_fcs);
- DPRINT ("in (%u):\n", frame_length_without_fcs);
- DUMP_PACKET (buffer, frame_length_without_fcs);
+ memcpy(buffer, bd->data, frame_length_without_fcs);
+ DPRINT("in (%u):\n", frame_length_without_fcs);
+ DUMP_PACKET(buffer, frame_length_without_fcs);
return_value = frame_length_without_fcs;
}
else
{
- DPRINT ("received_frame: User buffer is too small.\n");
+ DPRINT("received_frame: User buffer is too small.\n");
return_value = -1;
}
/* Tell the HW that there are new free RX buffers. */
- fec_buffer_produce_rx (bd);
+ fec_buffer_produce_rx(bd);
fec->base->rdar = 1;
return return_value;
}
-static void fec_ecat_hotplug (void)
+static void fec_ecat_hotplug(void)
{
uint8_t link_state = 0;
/* Set duplex mode according to link state */
- link_state = fec->phy->ops->get_link_state (fec->phy);
+ link_state = fec->phy->ops->get_link_state(fec->phy);
/* Set duplex */
if (link_state & PHY_LINK_FULL_DUPLEX)
fec->base->tfwr = FEC_TFWR_STR_FWD;
// Reset buffers.
- fec_buffer_reset ();
+ fec_buffer_reset();
// FEC_ERDSR - Receive buffer descriptor ring start register
fec->base->erdsr = (uint32_t)fec->rx_bd_base;
// FEC_RDAR - Receive Descriptor ring - Receive descriptor active register
fec->base->rdar = 1;
- DPRINT ("Link up. Speed: %s. Mode: %s.\n", fec_ecat_link_speed_name (link_state),
- fec_ecat_link_duplex_name (link_state));
+ DPRINT("Link up. Speed: %s. Mode: %s.\n", fec_ecat_link_speed_name(link_state),
+ fec_ecat_link_duplex_name(link_state));
}
-static dev_state_t fec_ecat_probe (void)
+static dev_state_t fec_ecat_probe(void)
{
uint8_t link_state;
- link_state = fec->phy->ops->get_link_state (fec->phy);
+ link_state = fec->phy->ops->get_link_state(fec->phy);
return (link_state & PHY_LINK_OK) ? StateAttached : StateDetached;
}
-COMPILETIME_ASSERT (FEC_MODULE_CLOCK_Hz >= FEC_MIN_MODULE_CLOCK_Hz);
+COMPILETIME_ASSERT(FEC_MODULE_CLOCK_Hz >= FEC_MIN_MODULE_CLOCK_Hz);
-int oshw_mac_init (const uint8_t * mac_address)
+int oshw_mac_init(const uint8_t *mac_address)
{
dev_state_t state;
static const fec_cfg_t eth_cfg =
- {
- .base = ENET_BASE,
- .clock = FEC_MODULE_CLOCK_Hz,
- .tx_bd_base = fec_tx_bd,
- .rx_bd_base = fec_rx_bd,
- .phy_interface = PHY_INTERFACE,
- };
+ {
+ .base = ENET_BASE,
+ .clock = FEC_MODULE_CLOCK_Hz,
+ .tx_bd_base = fec_tx_bd,
+ .rx_bd_base = fec_rx_bd,
+ .phy_interface = PHY_INTERFACE,
+ };
static phy_cfg_t phy_cfg =
- {
- .address = ETH_PHY_ADDRESS,
- .read = NULL, /* Set by MAC driver */
- .write = NULL, /* Set by MAC driver */
- .loopback_mode = false,
- };
+ {
+ .address = ETH_PHY_ADDRESS,
+ .read = NULL, /* Set by MAC driver */
+ .write = NULL, /* Set by MAC driver */
+ .loopback_mode = false,
+ };
/* Initialise buffers and buffer descriptors.*/
- fec_buffer_init_tx (fec_tx_bd, fec_tx_data, NUM_BUFFERS);
- fec_buffer_init_rx (fec_rx_bd, fec_rx_data, NUM_BUFFERS);
+ fec_buffer_init_tx(fec_tx_bd, fec_tx_data, NUM_BUFFERS);
+ fec_buffer_init_rx(fec_rx_bd, fec_rx_data, NUM_BUFFERS);
- fec = malloc (sizeof (fec_t));
- UASSERT (fec != NULL, EMEM);
+ fec = malloc(sizeof(fec_t));
+ UASSERT(fec != NULL, EMEM);
-#if defined (sabresd)
- gpio_set (GPIO_RGMII_nRST, 0);
- task_delay (500);
- gpio_set (GPIO_RGMII_nRST, 1);
+#if defined(sabresd)
+ gpio_set(GPIO_RGMII_nRST, 0);
+ task_delay(500);
+ gpio_set(GPIO_RGMII_nRST, 1);
#endif
/* Initialise driver state */
- fec->rx_bd_base = eth_cfg.rx_bd_base;
- fec->tx_bd_base = eth_cfg.tx_bd_base;
- fec->clock = eth_cfg.clock;
- fec->base = (reg_fec_t *)eth_cfg.base;
- fec->phy_interface = eth_cfg.phy_interface;
- fec->phy = PHY_INIT (&phy_cfg);
- fec->phy->arg = fec;
- fec->phy->read = fec_ecat_read_phy;
- fec->phy->write = fec_ecat_write_phy;
+ fec->rx_bd_base = eth_cfg.rx_bd_base;
+ fec->tx_bd_base = eth_cfg.tx_bd_base;
+ fec->clock = eth_cfg.clock;
+ fec->base = (reg_fec_t *)eth_cfg.base;
+ fec->phy_interface = eth_cfg.phy_interface;
+ fec->phy = PHY_INIT(&phy_cfg);
+ fec->phy->arg = fec;
+ fec->phy->read = fec_ecat_read_phy;
+ fec->phy->write = fec_ecat_write_phy;
/* Initialize hardware */
- fec_ecat_init_hw ((fec_mac_address_t *)mac_address);
+ fec_ecat_init_hw((fec_mac_address_t *)mac_address);
state = StateDetached;
while (state == StateDetached)
{
- state = fec_ecat_probe ();
+ state = fec_ecat_probe();
}
- fec_ecat_hotplug ();
+ fec_ecat_hotplug();
return 0;
}
#include <types.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
typedef struct fec_mac_address
* See LICENSE file in the project root for full license information.
********************************************************************/
-#if defined (stamp537)
+#if defined(stamp537)
#include <bsp.h>
#include <kern/kern.h>
"Reconciliation Sublayer (RS) and Media Independent Interface (MII)",
section 2.4.1 to 3.
http://standards.ieee.org/getieee802/download/802.3-2005_section2.pdf */
-#define MII_BMCR 0x00 /* Basic Mode Control Register */
-#define MII_BMSR 0x01 /* Basic Mode Status Register */
-#define MII_PHYIDR1 0x02 /* PHY Identifier Register 1 */
-#define MII_PHYIDR2 0x03 /* PHY Identifier Register 2 */
-#define MII_LPAR 0x05 /* Auto-Negotiation Link Partner Ability Register */
+#define MII_BMCR 0x00 /* Basic Mode Control Register */
+#define MII_BMSR 0x01 /* Basic Mode Status Register */
+#define MII_PHYIDR1 0x02 /* PHY Identifier Register 1 */
+#define MII_PHYIDR2 0x03 /* PHY Identifier Register 2 */
+#define MII_LPAR 0x05 /* Auto-Negotiation Link Partner Ability Register */
/* MII basic mode control register */
-#define MII_BMCR_RST BIT (15)
-#define MII_BMCR_ANEG_EN BIT (12)
-#define MII_BMCR_ANEG_RST BIT (9)
+#define MII_BMCR_RST BIT(15)
+#define MII_BMCR_ANEG_EN BIT(12)
+#define MII_BMCR_ANEG_RST BIT(9)
/* MII basic mode status register */
-#define MII_BMSR_ANEGACK BIT (5)
-#define MII_BMSR_LINK BIT (2)
+#define MII_BMSR_ANEGACK BIT(5)
+#define MII_BMSR_LINK BIT(2)
/* MII auto-negotiation advertisement register */
-#define MII_ANAR_100_FD BIT (8) /* Can do 100BASE-TX full duplex */
-#define MII_ANAR_10_FD BIT (6) /* Can do 10BASE-T full duplex */
+#define MII_ANAR_100_FD BIT(8) /* Can do 100BASE-TX full duplex */
+#define MII_ANAR_10_FD BIT(6) /* Can do 10BASE-T full duplex */
/* Management Data Clock (MDC) frequency.
* 2.5Mz corresponds to the minimum period for MDC as defined by the standard.
* This is independent of whether the PHY is in 10Mbit/s or 100Mbit/s mode.
* See Std. IEEE 802.3 (Ethernet) Clause 22.2.2.11 ("management data clock"). */
-#define PHY_MDC_Hz 2500000
-#define PHY_RETRIES 3000
+#define PHY_MDC_Hz 2500000
+#define PHY_RETRIES 3000
/* TODO: This might need changing for different boards. Fix? */
-#define PHY_ADDR 0
+#define PHY_ADDR 0
-#define ETH_RX_BUF_SIZE 2
-#define ETH_TX_BUF_SIZE 1
-#define ETH_FRAME_SIZE 0x614
+#define ETH_RX_BUF_SIZE 2
+#define ETH_TX_BUF_SIZE 1
+#define ETH_FRAME_SIZE 0x614
/* Ethernet MAC register structure */
typedef struct bfin_emac_regs
{
/* Control-Status Register Group */
- uint32_t opmode; /* operating mode */
- uint32_t addrlo; /* address low */
- uint32_t addrhi; /* address high */
- uint32_t hashlo; /* multicast hash table low */
- uint32_t hashhi; /* multicast hash table high */
- uint32_t staadd; /* station management address */
- uint32_t stadat; /* station management data */
- uint32_t flc; /* flow control */
- uint32_t vlan1; /* VLAN1 tag */
- uint32_t vlan2; /* VLAN2 tag */
+ uint32_t opmode; /* operating mode */
+ uint32_t addrlo; /* address low */
+ uint32_t addrhi; /* address high */
+ uint32_t hashlo; /* multicast hash table low */
+ uint32_t hashhi; /* multicast hash table high */
+ uint32_t staadd; /* station management address */
+ uint32_t stadat; /* station management data */
+ uint32_t flc; /* flow control */
+ uint32_t vlan1; /* VLAN1 tag */
+ uint32_t vlan2; /* VLAN2 tag */
uint32_t _reserved1;
- uint32_t wkup_ctl; /* wakeup frame control and status */
- uint32_t wkup_ffmsk[4]; /* wakeup frame n byte mask (n == 0,..,3) */
- uint32_t wkup_ffcmd; /* wakeup frame filter commands */
- uint32_t wkup_ffoff; /* wakeup frame filter offsets */
- uint32_t wkup_ffcrc0; /* wakeup frame filter CRC0/1 */
- uint32_t wkup_ffcrc1; /* wakeup frame filter CRC2/3 */
+ uint32_t wkup_ctl; /* wakeup frame control and status */
+ uint32_t wkup_ffmsk[4]; /* wakeup frame n byte mask (n == 0,..,3) */
+ uint32_t wkup_ffcmd; /* wakeup frame filter commands */
+ uint32_t wkup_ffoff; /* wakeup frame filter offsets */
+ uint32_t wkup_ffcrc0; /* wakeup frame filter CRC0/1 */
+ uint32_t wkup_ffcrc1; /* wakeup frame filter CRC2/3 */
uint32_t _reserved2[4];
/* System Interface Register Group */
- uint32_t sysctl; /* system control */
- uint32_t systat; /* system status */
+ uint32_t sysctl; /* system control */
+ uint32_t systat; /* system status */
/* Ethernet Frame Status Register Group */
- uint32_t rx_stat; /* RX Current Frame Status */
- uint32_t rx_stky; /* RX Sticky Frame Status */
- uint32_t rx_irqe; /* RX Frame Status Interrupt Enable */
- uint32_t tx_stat; /* TX Current Frame Status Register */
- uint32_t tx_stky; /* TT Sticky Frame Status */
- uint32_t tx_irqe; /* TX Frame Status Interrupt Enable */
+ uint32_t rx_stat; /* RX Current Frame Status */
+ uint32_t rx_stky; /* RX Sticky Frame Status */
+ uint32_t rx_irqe; /* RX Frame Status Interrupt Enable */
+ uint32_t tx_stat; /* TX Current Frame Status Register */
+ uint32_t tx_stky; /* TT Sticky Frame Status */
+ uint32_t tx_irqe; /* TX Frame Status Interrupt Enable */
/* MAC Management Counter Register Group */
- uint32_t mmc_ctl; /* Management Counters Control */
- uint32_t mmc_rirqs; /* MMC RX Interrupt Status */
- uint32_t mmc_rirqe; /* MMC RX Interrupt Enable */
- uint32_t mmc_tirqs; /* MMC TX Interrupt Status */
- uint32_t mmc_tirqe; /* MMC TX Interrupt Enable */
+ uint32_t mmc_ctl; /* Management Counters Control */
+ uint32_t mmc_rirqs; /* MMC RX Interrupt Status */
+ uint32_t mmc_rirqe; /* MMC RX Interrupt Enable */
+ uint32_t mmc_tirqs; /* MMC TX Interrupt Status */
+ uint32_t mmc_tirqe; /* MMC TX Interrupt Enable */
uint32_t _reserved3[27];
- uint32_t mmc_rxc_ok; /* FramesReceivedOK */
- uint32_t mmc_rxc_fcs; /* FrameCheckSequenceErrors */
- uint32_t mmc_rxc_align; /* AlignmentErrors */
- uint32_t mmc_rxc_octet; /* OctetsReceivedOK */
- uint32_t mmc_rxc_dmaovf; /* FramesLostDueToIntMACRcvError */
- uint32_t mmc_rxc_unicst; /* UnicastFramesReceivedOK */
- uint32_t mmc_rxc_multi; /* MulticastFramesReceivedOK */
- uint32_t mmc_rxc_broad; /* BroadcastFramesReceivedOK */
- uint32_t mmc_rxc_lnerri; /* InRangeLengthErrors */
- uint32_t mmc_rxc_lnerro; /* OutOfRangeLengthField */
- uint32_t mmc_rxc_long; /* FrameTooLongErrors */
- uint32_t mmc_rxc_macctl; /* MACControlFramesReceived */
- uint32_t mmc_rxc_opcode; /* UnsupportedOpcodesReceived */
- uint32_t mmc_rxc_pause; /* PAUSEMACCtrlFramesReceived */
- uint32_t mmc_rxc_allfrm; /* FramesReceivedAll */
- uint32_t mmc_rxc_alloct; /* OctetsReceivedAll */
- uint32_t mmc_rxc_typed; /* TypedFramesReceived */
- uint32_t mmc_rxc_short; /* FramesLenLt64Received */
- uint32_t mmc_rxc_eq64; /* FramesLenEq64Received */
- uint32_t mmc_rxc_lt128; /* FramesLen65_127Received */
- uint32_t mmc_rxc_lt256; /* FramesLen128_255Received */
- uint32_t mmc_rxc_lt512; /* FramesLen256_511Received */
- uint32_t mmc_rxc_lt1024; /* FramesLen512_1023Received */
- uint32_t mmc_rxc_ge1024; /* FramesLen1024_MaxReceived */
+ uint32_t mmc_rxc_ok; /* FramesReceivedOK */
+ uint32_t mmc_rxc_fcs; /* FrameCheckSequenceErrors */
+ uint32_t mmc_rxc_align; /* AlignmentErrors */
+ uint32_t mmc_rxc_octet; /* OctetsReceivedOK */
+ uint32_t mmc_rxc_dmaovf; /* FramesLostDueToIntMACRcvError */
+ uint32_t mmc_rxc_unicst; /* UnicastFramesReceivedOK */
+ uint32_t mmc_rxc_multi; /* MulticastFramesReceivedOK */
+ uint32_t mmc_rxc_broad; /* BroadcastFramesReceivedOK */
+ uint32_t mmc_rxc_lnerri; /* InRangeLengthErrors */
+ uint32_t mmc_rxc_lnerro; /* OutOfRangeLengthField */
+ uint32_t mmc_rxc_long; /* FrameTooLongErrors */
+ uint32_t mmc_rxc_macctl; /* MACControlFramesReceived */
+ uint32_t mmc_rxc_opcode; /* UnsupportedOpcodesReceived */
+ uint32_t mmc_rxc_pause; /* PAUSEMACCtrlFramesReceived */
+ uint32_t mmc_rxc_allfrm; /* FramesReceivedAll */
+ uint32_t mmc_rxc_alloct; /* OctetsReceivedAll */
+ uint32_t mmc_rxc_typed; /* TypedFramesReceived */
+ uint32_t mmc_rxc_short; /* FramesLenLt64Received */
+ uint32_t mmc_rxc_eq64; /* FramesLenEq64Received */
+ uint32_t mmc_rxc_lt128; /* FramesLen65_127Received */
+ uint32_t mmc_rxc_lt256; /* FramesLen128_255Received */
+ uint32_t mmc_rxc_lt512; /* FramesLen256_511Received */
+ uint32_t mmc_rxc_lt1024; /* FramesLen512_1023Received */
+ uint32_t mmc_rxc_ge1024; /* FramesLen1024_MaxReceived */
/* TODO: add all registers */
} bfin_emac_regs_t;
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, opmode) == 0x0);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, staadd) == 0x14);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, wkup_ctl) == 0x2c);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, wkup_ffcrc1) == 0x4c);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, sysctl) == 0x60);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, rx_stat) == 0x68);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, mmc_ctl) == 0x80);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, mmc_tirqe) == 0x90);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, mmc_rxc_ok) == 0x100);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, mmc_rxc_dmaovf) == 0x110);
-COMPILETIME_ASSERT (offsetof (bfin_emac_regs_t, mmc_rxc_ge1024) == 0x15c);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, opmode) == 0x0);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, staadd) == 0x14);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, wkup_ctl) == 0x2c);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, wkup_ffcrc1) == 0x4c);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, sysctl) == 0x60);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, rx_stat) == 0x68);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, mmc_ctl) == 0x80);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, mmc_tirqe) == 0x90);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, mmc_rxc_ok) == 0x100);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, mmc_rxc_dmaovf) == 0x110);
+COMPILETIME_ASSERT(offsetof(bfin_emac_regs_t, mmc_rxc_ge1024) == 0x15c);
/* 32-bit aligned struct for ethernet data */
-typedef struct ethernet_data {
- uint16_t length; /* When TX = frame data length in bytes, not including 'length'
- * When RX = 0x0000 padding when using RXDWA
- */
+typedef struct ethernet_data
+{
+ uint16_t length; /* When TX = frame data length in bytes, not including 'length'
+ * When RX = 0x0000 padding when using RXDWA
+ */
uint8_t data[ETH_FRAME_SIZE]; /* Hold the ethernet frame */
- uint16_t padding; /* To make the struct 32-bit aligned */
+ uint16_t padding; /* To make the struct 32-bit aligned */
} ethernet_data_t;
-COMPILETIME_ASSERT (sizeof (ethernet_data_t) == 0x618) ;
+COMPILETIME_ASSERT(sizeof(ethernet_data_t) == 0x618);
-static volatile bfin_emac_regs_t * pEth = (bfin_emac_regs_t *) EMAC_OPMODE;
+static volatile bfin_emac_regs_t *pEth = (bfin_emac_regs_t *)EMAC_OPMODE;
/* Buffers for rx and tx DMA operations */
static ethernet_data_t rxBuffer[ETH_RX_BUF_SIZE] __attribute__((section(".dma")));
/* Hold the current index of rx and tx buffers */
static uint8_t rxIdx, txIdx;
-
/* Internal function that writes to a PHY register */
-static void lw_emac_write_phy_reg(uint8_t phy_addr, uint8_t reg_addr, uint32_t data) {
+static void lw_emac_write_phy_reg(uint8_t phy_addr, uint8_t reg_addr, uint32_t data)
+{
/* Set the flags that should be set reg_addr on PHY */
pEth->stadat = data;
/* Wait for our turn then initiate writing of stadat to PHY register */
pEth->staadd = SET_PHYAD(phy_addr) | SET_REGAD(reg_addr) | STAOP | STABUSY;
- while (pEth->staadd & STABUSY) ;
+ while (pEth->staadd & STABUSY)
+ ;
}
/* Internal function that reads from; and returns a PHY register */
-static uint32_t lw_emac_read_phy_reg(uint8_t phy_addr, uint8_t reg_addr) {
+static uint32_t lw_emac_read_phy_reg(uint8_t phy_addr, uint8_t reg_addr)
+{
pEth->staadd = SET_PHYAD(phy_addr) | SET_REGAD(reg_addr) | STABUSY;
- while (pEth->staadd & STABUSY) ;
+ while (pEth->staadd & STABUSY)
+ ;
return pEth->stadat;
}
/* Internal function that sets the MAC address */
-static void lw_emac_set_mac_addr(const uint8_t * ethAddr)
+static void lw_emac_set_mac_addr(const uint8_t *ethAddr)
{
pEth->addrlo =
- ethAddr[0] |
- ethAddr[1] << 8 |
- ethAddr[2] << 16 |
- ethAddr[3] << 24;
+ ethAddr[0] |
+ ethAddr[1] << 8 |
+ ethAddr[2] << 16 |
+ ethAddr[3] << 24;
pEth->addrhi =
- ethAddr[4] |
- ethAddr[5] << 8;
+ ethAddr[4] |
+ ethAddr[5] << 8;
}
-static uint8_t lw_emac_init_registers(const uint8_t * ethAddr) {
+static uint8_t lw_emac_init_registers(const uint8_t *ethAddr)
+{
uint32_t clock_divisor, sysctl_mdcdiv, phy_stadat, counter;
/* CONFIGURE MAC MII PINS */
/* Enable PHY Clock Output */
- *(volatile uint16_t *) VR_CTL |= PHYCLKOE;
+ *(volatile uint16_t *)VR_CTL |= PHYCLKOE;
/* Set all bits to 1 to use MII mode */
- *(uint16_t *) PORTH_FER = 0xFFFF;
+ *(uint16_t *)PORTH_FER = 0xFFFF;
/* CONFIGURE MAC REGISTERS */
pEth->mmc_ctl = RSTC;
/* Set MAC address */
- lw_emac_set_mac_addr (ethAddr);
+ lw_emac_set_mac_addr(ethAddr);
clock_divisor = SCLK / PHY_MDC_Hz;
sysctl_mdcdiv = clock_divisor / 2 - 1;
- ASSERT (sysctl_mdcdiv <= 0x3f);
+ ASSERT(sysctl_mdcdiv <= 0x3f);
- rprintp ("PHY ID: %04x %04x\n",
- lw_emac_read_phy_reg (PHY_ADDR, MII_PHYIDR1),
- lw_emac_read_phy_reg (PHY_ADDR, MII_PHYIDR2)
- );
+ rprintp("PHY ID: %04x %04x\n",
+ lw_emac_read_phy_reg(PHY_ADDR, MII_PHYIDR1),
+ lw_emac_read_phy_reg(PHY_ADDR, MII_PHYIDR2));
/*
* Set the system control register
* RXDWA = Pad incoming frame with 0x0000 as to make the data-part 32-bit aligned
* RXCKS = Enable Receive Frame TCP/UDP Checksum Computation
*/
- pEth->sysctl = SET_MDCDIV(sysctl_mdcdiv) | RXDWA ;
+ pEth->sysctl = SET_MDCDIV(sysctl_mdcdiv) | RXDWA;
/* CONFIGURE PHY */
/* Loop until link is up or time out after PHY_RETRIES */
counter = 0;
- do {
- if (counter > PHY_RETRIES) {
+ do
+ {
+ if (counter > PHY_RETRIES)
+ {
rprintp("Ethernet link is down\n");
return -1;
}
- task_delay (tick_from_ms (10));
+ task_delay(tick_from_ms(10));
phy_stadat = lw_emac_read_phy_reg(PHY_ADDR, MII_BMSR);
++counter;
- } while (!(phy_stadat & MII_BMSR_LINK)) ;
+ } while (!(phy_stadat & MII_BMSR_LINK));
/* Check whether link partner can do full duplex or not */
phy_stadat = lw_emac_read_phy_reg(PHY_ADDR, MII_LPAR);
- if (phy_stadat & (MII_ANAR_100_FD | MII_ANAR_10_FD) ) {
+ if (phy_stadat & (MII_ANAR_100_FD | MII_ANAR_10_FD))
+ {
pEth->opmode = FDMODE;
}
- else {
+ else
+ {
pEth->opmode = 0;
}
return 0;
}
-int oshw_mac_init (const uint8_t * ethAddr)
+int oshw_mac_init(const uint8_t *ethAddr)
{
rxIdx = txIdx = 0;
- if (lw_emac_init_registers(ethAddr) != 0) {
+ if (lw_emac_init_registers(ethAddr) != 0)
+ {
return -1;
}
// Reset status words
- memset ((uint8_t *)rxStatusWord, 0, sizeof(rxStatusWord));
- memset ((uint8_t *)txStatusWord, 0, sizeof(txStatusWord));
+ memset((uint8_t *)rxStatusWord, 0, sizeof(rxStatusWord));
+ memset((uint8_t *)txStatusWord, 0, sizeof(txStatusWord));
txDMADesc[0].next = &txDMADesc[1];
txDMADesc[0].start_addr = &txBuffer[0];
return 0;
}
-int oshw_mac_send (const void *packet, size_t length)
+int oshw_mac_send(const void *packet, size_t length)
{
UASSERT(length > 0, EARG);
UASSERT(length < ETH_FRAME_SIZE, EARG);
/* TODO: Check DMA Error in IRQ status */
- while (bfin_dma_channel_interrupt_is_active (DMA_CHANNEL_EMAC_TX));
+ while (bfin_dma_channel_interrupt_is_active(DMA_CHANNEL_EMAC_TX))
+ ;
txBuffer[txIdx].length = length;
memcpy(txBuffer[txIdx].data, packet, length);
bfin_dma_channel_enable(DMA_CHANNEL_EMAC_TX, txDMADesc);
pEth->opmode |= TE;
- while ((txStatusWord[txIdx] & TX_COMP) == 0);
+ while ((txStatusWord[txIdx] & TX_COMP) == 0)
+ ;
ASSERT(txStatusWord[txIdx] & TX_OK);
++txIdx;
- if (txIdx == ETH_TX_BUF_SIZE) {
- txIdx = 0;
- }
+ if (txIdx == ETH_TX_BUF_SIZE)
+ {
+ txIdx = 0;
+ }
return 0;
}
-int oshw_mac_recv (void * packet, size_t size)
+int oshw_mac_recv(void *packet, size_t size)
{
uint32_t length;
uint32_t status = rxStatusWord[rxIdx];
/* Check if rx frame is completed */
- if ((status & RX_COMP) == 0) {
+ if ((status & RX_COMP) == 0)
+ {
return -1;
}
- else if ((status & RX_OK) == 0) {
+ else if ((status & RX_OK) == 0)
+ {
ASSERT(0);
/* TODO: Handle error */
return -1;
}
- else if (status & RX_DMAO) {
+ else if (status & RX_DMAO)
+ {
ASSERT(0);
/* TODO: Handle overrun */
return -1;
length = status & RX_FRLEN;
- if (size < length) {
+ if (size < length)
+ {
length = size;
}
memcpy(packet, rxBuffer[rxIdx].data, length);
- bfin_dma_channel_interrupt_clear (DMA_CHANNEL_EMAC_RX);
+ bfin_dma_channel_interrupt_clear(DMA_CHANNEL_EMAC_RX);
rxStatusWord[rxIdx] = 0;
++rxIdx;
- if (rxIdx == ETH_RX_BUF_SIZE) {
+ if (rxIdx == ETH_RX_BUF_SIZE)
+ {
rxIdx = 0;
}
#include "oshw.h"
#ifndef MAX
-#define MAX(a,b) (((a) > (b)) ? (a) : (b))
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
/** Redundancy modes */
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to find out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0101, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0101, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0404, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0404, 0x0404, 0x0404};
/** second MAC word is used for identification */
#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
static void ecx_clear_rxbufstat(int *rxbufstat)
{
int i;
- for(i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
rxbufstat[i] = EC_BUF_EMPTY;
}
/* when using secondary socket it is automatically a redundant setup */
psock = &(port->redport->sockhandle);
*psock = -1;
- port->redstate = ECT_RED_DOUBLE;
- port->redport->stack.sock = &(port->redport->sockhandle);
- port->redport->stack.txbuf = &(port->txbuf);
+ port->redstate = ECT_RED_DOUBLE;
+ port->redport->stack.sock = &(port->redport->sockhandle);
+ port->redport->stack.txbuf = &(port->txbuf);
port->redport->stack.txbuflength = &(port->txbuflength);
- port->redport->stack.tempbuf = &(port->redport->tempinbuf);
- port->redport->stack.rxbuf = &(port->redport->rxbuf);
- port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
- port->redport->stack.rxsa = &(port->redport->rxsa);
+ port->redport->stack.tempbuf = &(port->redport->tempinbuf);
+ port->redport->stack.rxbuf = &(port->redport->rxbuf);
+ port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
+ port->redport->stack.rxsa = &(port->redport->rxsa);
ecx_clear_rxbufstat(&(port->redport->rxbufstat[0]));
}
else
port->getindex_mutex = mtx_create();
port->tx_mutex = mtx_create();
port->rx_mutex = mtx_create();
- port->sockhandle = -1;
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.sock = &(port->sockhandle);
- port->stack.txbuf = &(port->txbuf);
+ port->sockhandle = -1;
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.sock = &(port->sockhandle);
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
ecx_clear_rxbufstat(&(port->rxbufstat[0]));
psock = &(port->sockhandle);
}
uint8 idx;
uint8 cnt;
- mtx_lock (port->getindex_mutex);
+ mtx_lock(port->getindex_mutex);
idx = port->lastidx + 1;
/* index can't be larger than buffer array */
}
port->lastidx = idx;
- mtx_unlock (port->getindex_mutex);
+ mtx_unlock(port->getindex_mutex);
return idx;
}
rval = ecx_outframe(port, idx, 0);
if (port->redstate != ECT_RED_NONE)
{
- mtx_lock (port->tx_mutex);
+ mtx_lock(port->tx_mutex);
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
ehp->sa1 = oshw_htons(secMAC[1]);
/* transmit over secondary socket */
- //send(sockhandle2, &ec_txbuf2, ec_txbuflength2 , 0);
- // OBS! redundant not ACTIVE for BFIN, just added to compile
- ASSERT (0);
+ // send(sockhandle2, &ec_txbuf2, ec_txbuflength2 , 0);
+ // OBS! redundant not ACTIVE for BFIN, just added to compile
+ ASSERT(0);
port->redport->rxbufstat[idx] = EC_BUF_TX;
oshw_mac_send(&(port->txbuf2), port->txbuflength2);
- mtx_unlock (port->tx_mutex);
+ mtx_unlock(port->tx_mutex);
}
return rval;
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
+ uint16 l;
+ int rval;
+ uint8 idxf;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
rval = EC_NOFRAME;
rxbuf = &(*stack->rxbuf)[idx];
/* check if requested index is already in buffer ? */
- if ((idx < EC_MAXBUF) && ( (*stack->rxbufstat)[idx] == EC_BUF_RCVD))
+ if ((idx < EC_MAXBUF) && ((*stack->rxbufstat)[idx] == EC_BUF_RCVD))
{
l = (*rxbuf)[0] + ((uint16)((*rxbuf)[1] & 0x0f) << 8);
/* return WKC */
}
else
{
- mtx_lock (port->rx_mutex);
+ mtx_lock(port->rx_mutex);
/* non blocking call to retrieve frame from socket */
if (ecx_recvpkt(port, stacknumber))
{
rval = EC_OTHERFRAME;
- ehp =(ec_etherheadert*)(stack->tempbuf);
+ ehp = (ec_etherheadert *)(stack->tempbuf);
/* check if it is an EtherCAT frame */
if (ehp->etype == oshw_htons(ETH_P_ECAT))
{
- ecp =(ec_comt*)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
+ ecp = (ec_comt *)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
l = etohs(ecp->elength) & 0x0fff;
idxf = ecp->index;
/* found index equals requested index ? */
}
}
}
- mtx_unlock (port->rx_mutex);
-
+ mtx_unlock(port->rx_mutex);
}
/* WKC if matching frame found */
*/
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert timer)
{
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
{
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
}
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
if (wkc2 <= EC_NOFRAME)
wkc2 = ecx_inframe(port, idx, 1);
}
- /* wait for both frames to arrive or timeout */
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && (osal_timer_is_expired(&timer) == FALSE));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
}
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
osal_timert read_timer;
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
int wkc;
osal_timert timer;
- osal_timer_start (&timer, timeout);
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, timer);
return wkc;
osal_timer_start(&read_timer, MIN(timeout, EC_TIMEOUTRET));
/* get frame from primary or if in redundant mode possibly from secondary */
wkc = ecx_waitinframe_red(port, idx, read_timer);
- /* wait for answer with WKC>0 or otherwise retry until timeout */
+ /* wait for answer with WKC>0 or otherwise retry until timeout */
} while ((wkc <= EC_NOFRAME) && (osal_timer_is_expired(&timer) == FALSE));
return wkc;
typedef struct
{
/** socket connection used */
- int *sock;
+ int *sock;
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** temporary receive buffer */
- ec_bufT *tempbuf;
+ ec_bufT *tempbuf;
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
+ int (*rxsa)[EC_MAXBUF];
} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
+ ec_stackT stack;
+ int sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct
{
- ec_stackT stack;
- int sockhandle;
+ ec_stackT stack;
+ int sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
int redstate;
/** pointer to redundancy port and buffers */
ecx_redportt *redport;
- mtx_t * getindex_mutex;
- mtx_t * tx_mutex;
- mtx_t * rx_mutex;
+ mtx_t *getindex_mutex;
+ mtx_t *tx_mutex;
+ mtx_t *rx_mutex;
} ecx_portt;
extern const uint16 priMAC[3];
extern const uint16 secMAC[3];
void ec_setupheader(void *p);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int stacknumber);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#endif
*/
uint16 oshw_htons(const uint16 host)
{
- uint16 network = htons (host);
- return network;
+ uint16 network = htons(host);
+ return network;
}
/**
*/
uint16 oshw_ntohs(const uint16 network)
{
- uint16 host = ntohs (network);
- return host;
+ uint16 host = ntohs(network);
+ return host;
}
/* Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters(void)
+ec_adaptert *oshw_find_adapters(void)
{
- ec_adaptert * ret_adapter = NULL;
+ ec_adaptert *ret_adapter = NULL;
/* TODO if needed */
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters(ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
- /* TODO if needed */
+ /* TODO if needed */
}
#define _oshw_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include <kern/kern.h>
#include "soem/soem.h"
#include "nicdrv.h"
-int oshw_mac_init (const uint8_t * mac_address);
-int oshw_mac_send (const void *payload, size_t tot_len);
-int oshw_mac_recv (void * buffer, size_t buffer_length);
+int oshw_mac_init(const uint8_t *mac_address);
+int oshw_mac_send(const void *payload, size_t tot_len);
+int oshw_mac_recv(void *buffer, size_t buffer_length);
uint16 oshw_htons(uint16 host);
uint16 oshw_ntohs(uint16 network);
-ec_adaptert * oshw_find_adapters(void);
-void oshw_free_adapters(ec_adaptert * adapter);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
* If there is a match the packet can be combined with the transmit packet
* and returned to the higher level function.
*
- * If EtherCAT is run in parallel with normal IP traffic and EtherCAT have a
+ * If EtherCAT is run in parallel with normal IP traffic and EtherCAT have a
* dedicated NIC, instantiate an extra tNetX task and redirect the NIC workQ
- * to be handle by the extra tNetX task, if needed raise the tNetX task prio.
+ * to be handle by the extra tNetX task, if needed raise the tNetX task prio.
* This prevents from having tNet0 becoming a bottleneck.
*
* The "redundant" option will configure two Mux drivers and two NIC interfaces.
#include "osal.h"
#include "nicdrv.h"
-#define NIC_DEBUG /* Print debugging info? */
+#define NIC_DEBUG /* Print debugging info? */
// wvEvent flags
-#define ECAT_RECV_FAILED 0x664
-#define ECAT_RECV_OK 0x665
-#define ECAT_RECV_RETRY_OK 0x666
-#define ECAT_STACK_RECV 0x667
-#define ECAT_SEND_START 0x675
-#define ECAT_SEND_COMPLETE 0x676
-#define ECAT_SEND_FAILED 0x677
+#define ECAT_RECV_FAILED 0x664
+#define ECAT_RECV_OK 0x665
+#define ECAT_RECV_RETRY_OK 0x666
+#define ECAT_STACK_RECV 0x667
+#define ECAT_SEND_START 0x675
+#define ECAT_SEND_COMPLETE 0x676
+#define ECAT_SEND_FAILED 0x677
#ifdef NIC_DEBUG
-#define NIC_LOGMSG(x,a,b,c,d,e,f) \
- do { \
- logMsg (x,a,b,c,d,e,f); \
- } while (0)
-#define NIC_WVEVENT(a,b,c) \
- do { \
- wvEvent(a, b, c); \
- } while (0)
-
+#define NIC_LOGMSG(x, a, b, c, d, e, f) \
+ do \
+ { \
+ logMsg(x, a, b, c, d, e, f); \
+ } while (0)
+#define NIC_WVEVENT(a, b, c) \
+ do \
+ { \
+ wvEvent(a, b, c); \
+ } while (0)
#else
-#define NIC_LOGMSG(x,a,b,c,d,e,f)
-#define NIC_WVEVENT(a,b,c)
+#define NIC_LOGMSG(x, a, b, c, d, e, f)
+#define NIC_WVEVENT(a, b, c)
#endif /* NIC_DEBUG */
#define IF_NAME_SIZE 8
ECT_RED_DOUBLE
};
-
/** Primary source MAC address used for EtherCAT.
* This address is not the MAC address used from the NIC.
* EtherCAT does not care about MAC addressing, but it is used here to
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to find out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0101, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0101, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0404, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0404, 0x0404, 0x0404};
/** second MAC word is used for identification */
-#define RX_PRIM priMAC[1]
+#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
/* usec per tick for timeconversion, default to 1kHz */
#define USECS_PER_SEC 1000000
static unsigned int usec_per_tick = 1000;
/** Receive hook called by Mux driver. */
-static int mux_rx_callback(void* pCookie, long type, M_BLK_ID pMblk, LL_HDR_INFO *llHdrInfo, void *muxUserArg);
+static int mux_rx_callback(void *pCookie, long type, M_BLK_ID pMblk, LL_HDR_INFO *llHdrInfo, void *muxUserArg);
static void ecx_clear_rxbufstat(int *rxbufstat)
{
int i;
- for(i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
rxbufstat[i] = EC_BUF_EMPTY;
}
void print_nicversion(void)
{
- printf("Generic is used\n");
+ printf("Generic is used\n");
}
/** Basic setup to connect NIC to socket.
-* @param[in] port = port context struct
-* @param[in] ifname = Name of NIC device, f.e. "gei0"
-* @param[in] secondary = if >0 then use secondary stack instead of primary
-* @return >0 if succeeded
-*/
-int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary)
+ * @param[in] port = port context struct
+ * @param[in] ifname = Name of NIC device, f.e. "gei0"
+ * @param[in] secondary = if >0 then use secondary stack instead of primary
+ * @return >0 if succeeded
+ */
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary)
{
int i;
char ifn[IF_NAME_SIZE];
- int unit_no = -1;
- ETHERCAT_PKT_DEV * pPktDev;
+ int unit_no = -1;
+ ETHERCAT_PKT_DEV *pPktDev;
/* Get systick info, sysClkRateGet return ticks per second */
- usec_per_tick = USECS_PER_SEC / sysClkRateGet();
+ usec_per_tick = USECS_PER_SEC / sysClkRateGet();
/* Don't allow 0 since it is used in DIV */
- if(usec_per_tick == 0)
+ if (usec_per_tick == 0)
usec_per_tick = 1;
/* Make reference to packet device struct, keep track if the packet
* device is the redundant or not.
*/
if (secondary)
{
- pPktDev = &(port->redport->pktDev);
- pPktDev->redundant = 1;
+ pPktDev = &(port->redport->pktDev);
+ pPktDev->redundant = 1;
}
else
{
- pPktDev = &(port->pktDev);
- pPktDev->redundant = 0;
+ pPktDev = &(port->pktDev);
+ pPktDev->redundant = 0;
}
/* Clear frame counters*/
/* Create multi-thread support semaphores */
port->sem_get_index = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE);
-
- /* Get the dev name and unit from ifname
- * We assume form gei1, fei0...
+
+ /* Get the dev name and unit from ifname
+ * We assume form gei1, fei0...
*/
- memset(ifn,0x0,sizeof(ifn));
-
- for(i=0; i < strlen(ifname);i++)
+ memset(ifn, 0x0, sizeof(ifn));
+
+ for (i = 0; i < strlen(ifname); i++)
{
- if(isdigit(ifname[i]))
- {
- strncpy(ifn, ifname, i);
- unit_no = atoi(&ifname[i]);
- break;
- }
+ if (isdigit(ifname[i]))
+ {
+ strncpy(ifn, ifname, i);
+ unit_no = atoi(&ifname[i]);
+ break;
+ }
}
/* Detach IP stack */
- //ipDetach(pktDev.unit,pktDev.name);
+ // ipDetach(pktDev.unit,pktDev.name);
pPktDev->port = port;
- /* Bind to mux driver for given interface, include ethercat driver pointer
- * as user reference
- */
+ /* Bind to mux driver for given interface, include ethercat driver pointer
+ * as user reference
+ */
/* Bind to mux */
pPktDev->pCookie = muxBind(ifn,
- unit_no,
- mux_rx_callback,
- NULL,
- NULL,
- NULL,
- MUX_PROTO_SNARF,
- "ECAT SNARF",
+ unit_no,
+ mux_rx_callback,
+ NULL,
+ NULL,
+ NULL,
+ MUX_PROTO_SNARF,
+ "ECAT SNARF",
pPktDev);
if (pPktDev->pCookie == NULL)
{
/* fail */
- NIC_LOGMSG("ecx_setupnic: muxBind init for gei: %d failed\n",
+ NIC_LOGMSG("ecx_setupnic: muxBind init for gei: %d failed\n",
unit_no, 2, 3, 4, 5, 6);
goto exit;
}
/* secondary port struct available? */
if (port->redport)
{
- port->redstate = ECT_RED_DOUBLE;
- port->redport->stack.txbuf = &(port->txbuf);
+ port->redstate = ECT_RED_DOUBLE;
+ port->redport->stack.txbuf = &(port->txbuf);
port->redport->stack.txbuflength = &(port->txbuflength);
- port->redport->stack.rxbuf = &(port->redport->rxbuf);
- port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
- port->redport->stack.rxsa = &(port->redport->rxsa);
+ port->redport->stack.rxbuf = &(port->redport->rxbuf);
+ port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
+ port->redport->stack.rxsa = &(port->redport->rxsa);
/* Create mailboxes for each potential EtherCAT frame index */
for (i = 0; i < EC_MAXBUF; i++)
{
- port->redport->msgQId[i] = msgQCreate(1, sizeof(M_BLK_ID), MSG_Q_FIFO);
- if (port->redport->msgQId[i] == MSG_Q_ID_NULL)
- {
- NIC_LOGMSG("ecx_setupnic: Failed to create redundant MsgQ[%d]",
- i, 2, 3, 4, 5, 6);
- goto exit;
- }
+ port->redport->msgQId[i] = msgQCreate(1, sizeof(M_BLK_ID), MSG_Q_FIFO);
+ if (port->redport->msgQId[i] == MSG_Q_ID_NULL)
+ {
+ NIC_LOGMSG("ecx_setupnic: Failed to create redundant MsgQ[%d]",
+ i, 2, 3, 4, 5, 6);
+ goto exit;
+ }
}
ecx_clear_rxbufstat(&(port->redport->rxbufstat[0]));
}
}
else
{
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.txbuf = &(port->txbuf);
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
/* Create mailboxes for each potential EtherCAT frame index */
for (i = 0; i < EC_MAXBUF; i++)
{
}
/* setup ethernet headers in tx buffers so we don't have to repeat it */
- for (i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
ec_setupheader(&(port->txbuf[i]));
port->rxbufstat[i] = EC_BUF_EMPTY;
exit:
return 0;
-
}
/** Close sockets used
* @param[in] port = port context struct
* @return 0
*/
-int ecx_closenic(ecx_portt *port)
+int ecx_closenic(ecx_portt *port)
{
int i;
- ETHERCAT_PKT_DEV * pPktDev;
+ ETHERCAT_PKT_DEV *pPktDev;
M_BLK_ID trash_can;
pPktDev = &(port->pktDev);
{
if (port->msgQId[i] != MSG_Q_ID_NULL)
{
- if (msgQReceive(port->msgQId[i],
- (char *)&trash_can,
- sizeof(M_BLK_ID),
+ if (msgQReceive(port->msgQId[i],
+ (char *)&trash_can,
+ sizeof(M_BLK_ID),
NO_WAIT) != ERROR)
{
NIC_LOGMSG("ecx_closenic: idx %d MsgQ close\n", i,
- 2, 3, 4, 5, 6);
- /* Free resources */
+ 2, 3, 4, 5, 6);
+ /* Free resources */
netMblkClChainFree(trash_can);
}
msgQDelete(port->msgQId[i]);
- }
+ }
}
if (pPktDev->pCookie != NULL)
{
if (port->redport->msgQId[i] != MSG_Q_ID_NULL)
{
- if (msgQReceive(port->redport->msgQId[i],
- (char *)&trash_can,
- sizeof(M_BLK_ID),
+ if (msgQReceive(port->redport->msgQId[i],
+ (char *)&trash_can,
+ sizeof(M_BLK_ID),
NO_WAIT) != ERROR)
{
NIC_LOGMSG("ecx_closenic: idx %d MsgQ close\n", i,
muxUnbind(pPktDev->pCookie, MUX_PROTO_SNARF, mux_rx_callback);
}
}
-
+
return 0;
}
* Ethertype is always ETH_P_ECAT.
* @param[out] p = buffer
*/
-void ec_setupheader(void *p)
+void ec_setupheader(void *p)
{
ec_etherheadert *bp;
bp = p;
uint8 cnt;
semTake(port->sem_get_index, WAIT_FOREVER);
-
+
idx = port->lastidx + 1;
/* index can't be larger than buffer array */
- if (idx >= EC_MAXBUF)
+ if (idx >= EC_MAXBUF)
{
idx = 0;
}
{
idx++;
cnt++;
- if (idx >= EC_MAXBUF)
+ if (idx >= EC_MAXBUF)
{
idx = 0;
}
}
port->rxbufstat[idx] = EC_BUF_ALLOC;
port->lastidx = idx;
-
+
semGive(port->sem_get_index);
-
+
return idx;
}
}
/** Low level transmit buffer over mux layer 2 driver
-*
-* @param[in] pPktDev = packet device to send buffer over
-* @param[in] idx = index in tx buffer array
-* @param[in] buf = buff to send
-* @param[in] len = bytes to send
-* @return driver send result
-*/
-static int ec_outfram_send(ETHERCAT_PKT_DEV * pPktDev, uint8 idx, void * buf, int len)
+ *
+ * @param[in] pPktDev = packet device to send buffer over
+ * @param[in] idx = index in tx buffer array
+ * @param[in] buf = buff to send
+ * @param[in] len = bytes to send
+ * @return driver send result
+ */
+static int ec_outfram_send(ETHERCAT_PKT_DEV *pPktDev, uint8 idx, void *buf, int len)
{
STATUS status = OK;
M_BLK_ID pPacket = NULL;
int rval = 0;
END_OBJ *endObj = (END_OBJ *)pPktDev->endObj;
- MSG_Q_ID msgQId;
+ MSG_Q_ID msgQId;
/* Clean up any abandoned frames and re-use the allocated buffer*/
msgQId = pPktDev->port->msgQId[idx];
- if(msgQNumMsgs(msgQId) > 0)
+ if (msgQNumMsgs(msgQId) > 0)
{
pPktDev->abandoned_count++;
NIC_LOGMSG("ec_outfram_send: idx %d MsgQ abandoned\n", idx,
2, 3, 4, 5, 6);
- if (msgQReceive(msgQId,
- (char *)&pPacket,
- sizeof(M_BLK_ID),
- NO_WAIT) == ERROR)
+ if (msgQReceive(msgQId,
+ (char *)&pPacket,
+ sizeof(M_BLK_ID),
+ NO_WAIT) == ERROR)
{
pPacket = NULL;
NIC_LOGMSG("ec_outfram_send: idx %d MsgQ mBlk handled by receiver\n", idx,
if (print_once == 0)
{
NIC_LOGMSG("ec_outfram_send: failed\n",
- 1, 2, 3, 4, 5, 6);
+ 1, 2, 3, 4, 5, 6);
print_once = 1;
}
NIC_WVEVENT(ECAT_SEND_FAILED, (char *)&rval, sizeof(rval));
return rval;
}
-/** High level transmit buffer over mux layer 2 driver, passing buffer
-* and packet device to send on as arguments
-* @param[in] port = port context holding reference to packet device
-* @param[in] idx = index in tx buffer array
-* @param[in] stacknumber = 0=Primary 1=Secondary stack
-* @return socket send result
-*/
+/** High level transmit buffer over mux layer 2 driver, passing buffer
+ * and packet device to send on as arguments
+ * @param[in] port = port context holding reference to packet device
+ * @param[in] idx = index in tx buffer array
+ * @param[in] stacknumber = 0=Primary 1=Secondary stack
+ * @return socket send result
+ */
int ecx_outframe(ecx_portt *port, uint8 idx, int stacknumber)
{
int rval = 0;
ec_stackT *stack;
- ETHERCAT_PKT_DEV * pPktDev;
+ ETHERCAT_PKT_DEV *pPktDev;
if (!stacknumber)
{
}
(*stack->rxbufstat)[idx] = EC_BUF_TX;
- rval = ec_outfram_send(pPktDev, idx, (char*)(*stack->txbuf)[idx],
+ rval = ec_outfram_send(pPktDev, idx, (char *)(*stack->txbuf)[idx],
(*stack->txbuflength)[idx]);
if (rval > 0)
{
{
(*stack->rxbufstat)[idx] = EC_BUF_EMPTY;
}
-
+
return rval;
}
/* transmit over primary socket*/
rval = ecx_outframe(port, idx, 0);
if (port->redstate != ECT_RED_NONE)
- {
+ {
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
port->redport->rxbufstat[idx] = EC_BUF_EMPTY;
}
}
-
+
return rval;
}
-
-/** Call back routine registered as hook with mux layer 2 driver
-* @param[in] pCookie = Mux cookie
-* @param[in] type = received type
-* @param[in] pMblk = the received packet reference
-* @param[in] llHdrInfo = header info
-* @param[in] muxUserArg = assigned reference to packet device when init called
-* @return TRUE if frame was successfully read and passed to MsgQ
-*/
-static int mux_rx_callback(void* pCookie, long type, M_BLK_ID pMblk, LL_HDR_INFO *llHdrInfo, void *muxUserArg)
+/** Call back routine registered as hook with mux layer 2 driver
+ * @param[in] pCookie = Mux cookie
+ * @param[in] type = received type
+ * @param[in] pMblk = the received packet reference
+ * @param[in] llHdrInfo = header info
+ * @param[in] muxUserArg = assigned reference to packet device when init called
+ * @return TRUE if frame was successfully read and passed to MsgQ
+ */
+static int mux_rx_callback(void *pCookie, long type, M_BLK_ID pMblk, LL_HDR_INFO *llHdrInfo, void *muxUserArg)
{
BOOL ret = FALSE;
uint8 idxf;
ec_comt *ecp;
- ec_bufT * tempbuf;
- ecx_portt * port;
- MSG_Q_ID msgQId;
- ETHERCAT_PKT_DEV * pPktDev;
- int length;
+ ec_bufT *tempbuf;
+ ecx_portt *port;
+ MSG_Q_ID msgQId;
+ ETHERCAT_PKT_DEV *pPktDev;
+ int length;
int bufstat;
/* check if it is an EtherCAT frame */
port = pPktDev->port;
/* Get ethercat frame header */
- ecp = (ec_comt*)&(*tempbuf)[ETH_HEADERSIZE];
+ ecp = (ec_comt *)&(*tempbuf)[ETH_HEADERSIZE];
idxf = ecp->index;
if (idxf >= EC_MAXBUF)
{
NIC_LOGMSG("mux_rx_callback: idx %d MsgQ overrun\n", idxf,
2, 3, 4, 5, 6);
M_BLK_ID trash_can;
- if (msgQReceive(msgQId,
+ if (msgQReceive(msgQId,
(char *)&trash_can,
- sizeof(M_BLK_ID),
+ sizeof(M_BLK_ID),
NO_WAIT) != ERROR)
{
- /* Free resources */
- netMblkClChainFree(trash_can);
+ /* Free resources */
+ netMblkClChainFree(trash_can);
}
- status = msgQSend(msgQId,
- (char *)&pMblk,
+ status = msgQSend(msgQId,
+ (char *)&pMblk,
sizeof(M_BLK_ID),
- NO_WAIT,
+ NO_WAIT,
MSG_PRI_NORMAL);
if (status == OK)
{
* @param[in] timeout = timeout in us
* @return >0 if frame is available and read
*/
-static int ecx_recvpkt(ecx_portt *port, uint8 idx, int stacknumber, M_BLK_ID * pMblk, int timeout)
+static int ecx_recvpkt(ecx_portt *port, uint8 idx, int stacknumber, M_BLK_ID *pMblk, int timeout)
{
int bytesrx = 0;
- MSG_Q_ID msgQId;
+ MSG_Q_ID msgQId;
int tick_timeout = max((timeout / usec_per_tick), 1);
-
+
if (stacknumber == 1)
{
msgQId = port->redport->msgQId[idx];
{
msgQId = port->msgQId[idx];
}
-
+
if (timeout == 0)
{
- bytesrx = msgQReceive(msgQId, (void *)pMblk,
- sizeof(M_BLK_ID), NO_WAIT);
+ bytesrx = msgQReceive(msgQId, (void *)pMblk,
+ sizeof(M_BLK_ID), NO_WAIT);
}
else
{
- bytesrx = msgQReceive(msgQId, (void *)pMblk,
- sizeof(M_BLK_ID), tick_timeout);
+ bytesrx = msgQReceive(msgQId, (void *)pMblk,
+ sizeof(M_BLK_ID), tick_timeout);
}
if (bytesrx > 0)
{
- bytesrx = (*pMblk)->mBlkHdr.mLen;
- NIC_WVEVENT(ECAT_STACK_RECV, (char *)&bytesrx, sizeof(bytesrx));
+ bytesrx = (*pMblk)->mBlkHdr.mLen;
+ NIC_WVEVENT(ECAT_STACK_RECV, (char *)&bytesrx, sizeof(bytesrx));
}
-
return (bytesrx > 0);
}
/** Non blocking receive frame function. Uses RX buffer and index to combine
* read frame with transmitted frame. Frames are received by separate receiver
- * task tNet0 (default), tNet0 fetch what frame index and store a reference to the
- * received frame in matching MsgQ. The stack user tasks fetch the frame
+ * task tNet0 (default), tNet0 fetch what frame index and store a reference to the
+ * received frame in matching MsgQ. The stack user tasks fetch the frame
* reference and copies the frame the the RX buffer, when done it free
* the frame buffer allocated by the Mux.
- *
+ *
* @param[in] port = port context struct
* @param[in] idx = requested index of frame
* @param[in] stacknumber = 0=primary 1=secondary stack
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber, int timeout)
{
- uint16 l;
- int rval;
+ uint16 l;
+ int rval;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
/* (non-) blocking call to retrieve frame from Muxlayer */
if (ecx_recvpkt(port, idx, stacknumber, &pMblk, timeout))
{
- rval = EC_OTHERFRAME;
-
- /* Get pointer to the frame */
- tempinbuf = (ec_bufT *)pMblk->mBlkHdr.mData;
- /* Get pointer to the Ethernet header */
- ehp = (ec_etherheadert*)tempinbuf;
- /* Get pointer to the EtherCAT frame as ethernet payload */
- ecp = (ec_comt*)&(*tempinbuf)[ETH_HEADERSIZE];
- l = etohs(ecp->elength) & 0x0fff;
- /* yes, put it in the buffer array (strip ethernet header) */
- netMblkOffsetToBufCopy(pMblk, ETH_HEADERSIZE,(void *) rxbuf,
+ rval = EC_OTHERFRAME;
+
+ /* Get pointer to the frame */
+ tempinbuf = (ec_bufT *)pMblk->mBlkHdr.mData;
+ /* Get pointer to the Ethernet header */
+ ehp = (ec_etherheadert *)tempinbuf;
+ /* Get pointer to the EtherCAT frame as ethernet payload */
+ ecp = (ec_comt *)&(*tempinbuf)[ETH_HEADERSIZE];
+ l = etohs(ecp->elength) & 0x0fff;
+ /* yes, put it in the buffer array (strip ethernet header) */
+ netMblkOffsetToBufCopy(pMblk, ETH_HEADERSIZE, (void *)rxbuf,
(*stack->txbuflength)[idx] - ETH_HEADERSIZE, NULL);
- /* return WKC */
- rval = ((*rxbuf)[l] + ((uint16)((*rxbuf)[l + 1]) << 8));
- /* mark as completed */
- (*stack->rxbufstat)[idx] = EC_BUF_COMPLETE;
- /* store MAC source word 1 for redundant routing info */
- (*stack->rxsa)[idx] = ntohs(ehp->sa1);
- netMblkClChainFree(pMblk);
- port->pktDev.rx_count++;
+ /* return WKC */
+ rval = ((*rxbuf)[l] + ((uint16)((*rxbuf)[l + 1]) << 8));
+ /* mark as completed */
+ (*stack->rxbufstat)[idx] = EC_BUF_COMPLETE;
+ /* store MAC source word 1 for redundant routing info */
+ (*stack->rxsa)[idx] = ntohs(ehp->sa1);
+ netMblkClChainFree(pMblk);
+ port->pktDev.rx_count++;
}
-
+
/* WKC if matching frame found */
return rval;
}
* it skips the secondary stack and redundancy functions. In redundant mode it waits
* for both (primary and secondary) frames to come in. The result goes in an decision
* tree that decides, depending on the route of the packet and its possible missing arrival,
- * how to reroute the original packet to get the data in an other try.
+ * how to reroute the original packet to get the data in an other try.
*
* @param[in] port = port context struct
* @param[in] idx = requested index of frame
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer, int timeout)
{
osal_timert timer2;
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
-
+
/* if not in redundant mode then always assume secondary is OK */
if (port->redstate == ECT_RED_NONE)
{
wkc2 = 0;
}
- do
+ do
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
}
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
- {
+ {
/* only read frame if not already in */
if (wkc2 <= EC_NOFRAME)
{
wkc2 = ecx_inframe(port, idx, 1, timeout);
}
- }
- /* wait for both frames to arrive or timeout */
+ }
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
/* secrx if the received MAC source on psecondary socket */
secrx = 0;
if (wkc2 > EC_NOFRAME) secrx = port->redport->rxsa[idx];
-
+
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
wkc = wkc2;
- }
+ }
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
- /* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ /* we need to resend TX packet */
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
- {
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
+ {
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
ecx_outframe(port, idx, 1);
- do
+ do
{
/* retrieve frame */
wkc2 = ecx_inframe(port, idx, 1, timeout);
} while ((wkc2 <= EC_NOFRAME) && !osal_timer_is_expired(&timer2));
if (wkc2 > EC_NOFRAME)
- {
+ {
/* copy secondary result to primary rx buffer */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
wkc = wkc2;
- }
- }
+ }
+ }
}
-
+
/* return WKC or EC_NOFRAME */
return wkc;
-}
+}
/** Blocking receive frame function. Calls ec_waitinframe_red().
* @param[in] port = port context struct
{
int wkc;
osal_timert timer;
-
- osal_timer_start (&timer, timeout);
+
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, &timer, timeout);
-
+
return wkc;
}
int wkc = EC_NOFRAME;
osal_timert timer1, timer2;
- osal_timer_start (&timer1, timeout);
- do
+ osal_timer_start(&timer1, timeout);
+ do
{
/* tx frame on primary and if in redundant mode a dummy on secondary */
ecx_outframe_red(port, idx);
- if (timeout < EC_TIMEOUTRET)
+ if (timeout < EC_TIMEOUTRET)
{
- osal_timer_start (&timer2, timeout);
+ osal_timer_start(&timer2, timeout);
}
- else
+ else
{
/* normally use partial timeout for rx */
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
}
/* get frame from primary or if in redundant mode possibly from secondary */
wkc = ecx_waitinframe_red(port, idx, &timer2, timeout);
- /* wait for answer with WKC>=0 or otherwise retry until timeout */
- } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired (&timer1));
+ /* wait for answer with WKC>=0 or otherwise retry until timeout */
+ } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired(&timer1));
-
return wkc;
}
* full license information.
*/
-/** \file
+/** \file
* \brief
- * Headerfile for nicdrv.c
+ * Headerfile for nicdrv.c
*/
#ifndef _nicdrvh_
#define _nicdrvh_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include <vxWorks.h>
/** structure to connect EtherCAT stack and VxWorks device */
typedef struct ETHERCAT_PKT_DEV
{
- struct ecx_port *port;
- void *pCookie;
- void *endObj;
- UINT32 redundant;
- UINT32 tx_count;
- UINT32 rx_count;
- UINT32 overrun_count;
- UINT32 abandoned_count;
-}ETHERCAT_PKT_DEV;
+ struct ecx_port *port;
+ void *pCookie;
+ void *endObj;
+ UINT32 redundant;
+ UINT32 tx_count;
+ UINT32 rx_count;
+ UINT32 overrun_count;
+ UINT32 abandoned_count;
+} ETHERCAT_PKT_DEV;
/** pointer structure to Tx and Rx stacks */
typedef struct
{
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
-} ec_stackT;
+ int (*rxsa)[EC_MAXBUF];
+} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct ecx_redport
{
- /** Stack reference */
+ /** Stack reference */
ec_stackT stack;
/** Packet device instance */
ETHERCAT_PKT_DEV pktDev;
/** rx MAC source address */
int rxsa[EC_MAXBUF];
/** MSG Q for receive callbacks to post into */
- MSG_Q_ID msgQId[EC_MAXBUF];
+ MSG_Q_ID msgQId[EC_MAXBUF];
} ecx_redportt;
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct ecx_port
{
- /** Stack reference */
+ /** Stack reference */
ec_stackT stack;
/** Packet device instance */
ETHERCAT_PKT_DEV pktDev;
/** current redundancy state */
int redstate;
/** pointer to redundancy port and buffers */
- ecx_redportt *redport;
+ ecx_redportt *redport;
/** Semaphore to protect single resources */
- SEM_ID sem_get_index;
+ SEM_ID sem_get_index;
/** MSG Q for receive callbacks to post into */
- MSG_Q_ID msgQId[EC_MAXBUF];
+ MSG_Q_ID msgQId[EC_MAXBUF];
} ecx_portt;
extern const uint16 priMAC[3];
extern const uint16 secMAC[3];
void ec_setupheader(void *p);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#ifdef __cplusplus
}
*/
uint16 oshw_htons(uint16 host)
{
- uint16 network = htons (host);
+ uint16 network = htons(host);
return network;
}
*/
uint16 oshw_ntohs(uint16 network)
{
- uint16 host = ntohs (network);
+ uint16 host = ntohs(network);
return host;
}
/** Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters(void)
+ec_adaptert *oshw_find_adapters(void)
{
- ec_adaptert * ret_adapter = NULL;
- /* Not implemented */
+ ec_adaptert *ret_adapter = NULL;
+ /* Not implemented */
assert(0);
return ret_adapter;
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters(ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
- /* Not implemented */
- assert(0);
+ /* Not implemented */
+ assert(0);
}
* full license information.
*/
-/** \file
+/** \file
* \brief
- * Headerfile for oshw.c
+ * Headerfile for oshw.c
*/
#ifndef _oshw_
uint16 oshw_htons(uint16 hostshort);
uint16 oshw_ntohs(uint16 networkshort);
-ec_adaptert * oshw_find_adapters(void);
-void oshw_free_adapters(ec_adaptert * adapter);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#endif
#ifdef WIN32
-
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
/** Redundancy modes */
enum
{
- /** No redundancy, single NIC mode */
- ECT_RED_NONE,
- /** Double redundant NIC connection */
- ECT_RED_DOUBLE
+ /** No redundancy, single NIC mode */
+ ECT_RED_NONE,
+ /** Double redundant NIC connection */
+ ECT_RED_DOUBLE
};
/** Primary source MAC address used for EtherCAT.
* differentiate the route the packet traverses through the EtherCAT
* segment. This is needed to fund out the packet flow in redundant
* configurations. */
-const uint16 priMAC[3] = { 0x0101, 0x0101, 0x0101 };
+const uint16 priMAC[3] = {0x0101, 0x0101, 0x0101};
/** Secondary source MAC address used for EtherCAT. */
-const uint16 secMAC[3] = { 0x0404, 0x0404, 0x0404 };
+const uint16 secMAC[3] = {0x0404, 0x0404, 0x0404};
/** second MAC word is used for identification */
#define RX_PRIM priMAC[1]
/** second MAC word is used for identification */
-#define RX_SEC secMAC[1]
+#define RX_SEC secMAC[1]
static char errbuf[PCAP_ERRBUF_SIZE];
static void ecx_clear_rxbufstat(int *rxbufstat)
{
int i;
- for(i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
rxbufstat[i] = EC_BUF_EMPTY;
}
/* when using secondary socket it is automatically a redundant setup */
psock = &(port->redport->sockhandle);
*psock = NULL;
- port->redstate = ECT_RED_DOUBLE;
- port->redport->stack.sock = &(port->redport->sockhandle);
- port->redport->stack.txbuf = &(port->txbuf);
+ port->redstate = ECT_RED_DOUBLE;
+ port->redport->stack.sock = &(port->redport->sockhandle);
+ port->redport->stack.txbuf = &(port->txbuf);
port->redport->stack.txbuflength = &(port->txbuflength);
- port->redport->stack.tempbuf = &(port->redport->tempinbuf);
- port->redport->stack.rxbuf = &(port->redport->rxbuf);
- port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
- port->redport->stack.rxsa = &(port->redport->rxsa);
+ port->redport->stack.tempbuf = &(port->redport->tempinbuf);
+ port->redport->stack.rxbuf = &(port->redport->rxbuf);
+ port->redport->stack.rxbufstat = &(port->redport->rxbufstat);
+ port->redport->stack.rxsa = &(port->redport->rxsa);
ecx_clear_rxbufstat(&(port->redport->rxbufstat[0]));
}
else
InitializeCriticalSection(&(port->getindex_mutex));
InitializeCriticalSection(&(port->tx_mutex));
InitializeCriticalSection(&(port->rx_mutex));
- port->sockhandle = NULL;
- port->lastidx = 0;
- port->redstate = ECT_RED_NONE;
- port->stack.sock = &(port->sockhandle);
- port->stack.txbuf = &(port->txbuf);
+ port->sockhandle = NULL;
+ port->lastidx = 0;
+ port->redstate = ECT_RED_NONE;
+ port->stack.sock = &(port->sockhandle);
+ port->stack.txbuf = &(port->txbuf);
port->stack.txbuflength = &(port->txbuflength);
- port->stack.tempbuf = &(port->tempinbuf);
- port->stack.rxbuf = &(port->rxbuf);
- port->stack.rxbufstat = &(port->rxbufstat);
- port->stack.rxsa = &(port->rxsa);
+ port->stack.tempbuf = &(port->tempinbuf);
+ port->stack.rxbuf = &(port->rxbuf);
+ port->stack.rxbufstat = &(port->rxbufstat);
+ port->stack.rxsa = &(port->rxsa);
ecx_clear_rxbufstat(&(port->rxbufstat[0]));
psock = &(port->sockhandle);
}
/* we use pcap socket to send RAW packets in windows user mode*/
- *psock = pcap_open(ifname, 65536, PCAP_OPENFLAG_PROMISCUOUS |
- PCAP_OPENFLAG_MAX_RESPONSIVENESS |
- PCAP_OPENFLAG_NOCAPTURE_LOCAL, -1, NULL , errbuf);
+ *psock = pcap_open(ifname, 65536, PCAP_OPENFLAG_PROMISCUOUS | PCAP_OPENFLAG_MAX_RESPONSIVENESS | PCAP_OPENFLAG_NOCAPTURE_LOCAL, -1, NULL, errbuf);
if (NULL == *psock)
{
printf("interface %s could not open with pcap\n", ifname);
return 0;
}
- for (i = 0; i < EC_MAXBUF; i++)
+ for (i = 0; i < EC_MAXBUF; i++)
{
ec_setupheader(&(port->txbuf[i]));
port->rxbufstat[i] = EC_BUF_EMPTY;
rval = ecx_outframe(port, idx, 0);
if (port->redstate != ECT_RED_NONE)
{
- EnterCriticalSection( &(port->tx_mutex) );
+ EnterCriticalSection(&(port->tx_mutex));
ehp = (ec_etherheadert *)&(port->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
- datagramP = (ec_comt*)&(port->txbuf2[ETH_HEADERSIZE]);
+ datagramP = (ec_comt *)&(port->txbuf2[ETH_HEADERSIZE]);
/* write index to frame */
datagramP->index = idx;
/* rewrite MAC source address 1 to secondary */
{
port->redport->rxbufstat[idx] = EC_BUF_EMPTY;
}
- LeaveCriticalSection( &(port->tx_mutex) );
+ LeaveCriticalSection(&(port->tx_mutex));
}
return rval;
{
int lp, bytesrx;
ec_stackT *stack;
- struct pcap_pkthdr * header;
- unsigned char const * pkt_data;
+ struct pcap_pkthdr *header;
+ unsigned char const *pkt_data;
int res;
if (!stacknumber)
lp = sizeof(port->tempinbuf);
res = pcap_next_ex(*stack->sock, &header, &pkt_data);
- if (res <=0 )
+ if (res <= 0)
{
- port->tempinbufs = 0;
+ port->tempinbufs = 0;
return 0;
}
bytesrx = header->len;
*/
int ecx_inframe(ecx_portt *port, uint8 idx, int stacknumber)
{
- uint16 l;
- int rval;
- uint8 idxf;
+ uint16 l;
+ int rval;
+ uint8 idxf;
ec_etherheadert *ehp;
ec_comt *ecp;
ec_stackT *stack;
if (ecx_recvpkt(port, stacknumber))
{
rval = EC_OTHERFRAME;
- ehp =(ec_etherheadert*)(stack->tempbuf);
+ ehp = (ec_etherheadert *)(stack->tempbuf);
/* check if it is an EtherCAT frame */
if (ehp->etype == htons(ETH_P_ECAT))
{
- ecp =(ec_comt*)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
+ ecp = (ec_comt *)(&(*stack->tempbuf)[ETH_HEADERSIZE]);
l = etohs(ecp->elength) & 0x0fff;
idxf = ecp->index;
/* found index equals requested index ? */
}
}
}
- LeaveCriticalSection( &(port->rx_mutex) );
-
+ LeaveCriticalSection(&(port->rx_mutex));
}
/* WKC if matching frame found */
static int ecx_waitinframe_red(ecx_portt *port, uint8 idx, osal_timert *timer)
{
osal_timert timer2;
- int wkc = EC_NOFRAME;
+ int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
- wkc = ecx_inframe(port, idx, 0);
+ wkc = ecx_inframe(port, idx, 0);
/* only try secondary if in redundant mode */
if (port->redstate != ECT_RED_NONE)
{
if (wkc2 <= EC_NOFRAME)
wkc2 = ecx_inframe(port, idx, 1);
}
- /* wait for both frames to arrive or timeout */
+ /* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (port->redstate != ECT_RED_NONE)
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
- if ( ((primrx == RX_SEC) && (secrx == RX_PRIM)) )
+ if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(port->rxbuf[idx]), &(port->redport->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
- if ( ((primrx == 0) && (secrx == RX_SEC)) ||
- ((primrx == RX_PRIM) && (secrx == RX_SEC)) )
+ if (((primrx == 0) && (secrx == RX_SEC)) ||
+ ((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
- if ( (primrx == RX_PRIM) && (secrx == RX_SEC) )
+ if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(&(port->txbuf[idx][ETH_HEADERSIZE]), &(port->rxbuf[idx]), port->txbuflength[idx] - ETH_HEADERSIZE);
}
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
ecx_outframe(port, idx, 1);
do
int wkc;
osal_timert timer;
- osal_timer_start (&timer, timeout);
+ osal_timer_start(&timer, timeout);
wkc = ecx_waitinframe_red(port, idx, &timer);
return wkc;
int wkc = EC_NOFRAME;
osal_timert timer1, timer2;
- osal_timer_start (&timer1, timeout);
+ osal_timer_start(&timer1, timeout);
do
{
/* tx frame on primary and if in redundant mode a dummy on secondary */
ecx_outframe_red(port, idx);
if (timeout < EC_TIMEOUTRET)
{
- osal_timer_start (&timer2, timeout);
+ osal_timer_start(&timer2, timeout);
}
else
{
/* normally use partial timeout for rx */
- osal_timer_start (&timer2, EC_TIMEOUTRET);
+ osal_timer_start(&timer2, EC_TIMEOUTRET);
}
/* get frame from primary or if in redundant mode possibly from secondary */
wkc = ecx_waitinframe_red(port, idx, &timer2);
- /* wait for answer with WKC>=0 or otherwise retry until timeout */
- } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired (&timer1));
+ /* wait for answer with WKC>=0 or otherwise retry until timeout */
+ } while ((wkc <= EC_NOFRAME) && !osal_timer_is_expired(&timer1));
return wkc;
}
#define _nicdrvh_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#define HAVE_REMOTE
typedef struct
{
/** socket connection used */
- pcap_t **sock;
+ pcap_t **sock;
/** tx buffer */
- ec_bufT (*txbuf)[EC_MAXBUF];
+ ec_bufT (*txbuf)[EC_MAXBUF];
/** tx buffer lengths */
- int (*txbuflength)[EC_MAXBUF];
+ int (*txbuflength)[EC_MAXBUF];
/** temporary receive buffer */
- ec_bufT *tempbuf;
+ ec_bufT *tempbuf;
/** rx buffers */
- ec_bufT (*rxbuf)[EC_MAXBUF];
+ ec_bufT (*rxbuf)[EC_MAXBUF];
/** rx buffer status fields */
- int (*rxbufstat)[EC_MAXBUF];
+ int (*rxbufstat)[EC_MAXBUF];
/** received MAC source address (middle word) */
- int (*rxsa)[EC_MAXBUF];
+ int (*rxsa)[EC_MAXBUF];
} ec_stackT;
/** pointer structure to buffers for redundant port */
typedef struct
{
- ec_stackT stack;
- pcap_t *sockhandle;
+ ec_stackT stack;
+ pcap_t *sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
/** pointer structure to buffers, vars and mutexes for port instantiation */
typedef struct
{
- ec_stackT stack;
- pcap_t *sockhandle;
+ ec_stackT stack;
+ pcap_t *sockhandle;
/** rx buffers */
ec_bufT rxbuf[EC_MAXBUF];
/** rx buffer status */
extern const uint16 secMAC[3];
void ec_setupheader(void *p);
-int ecx_setupnic(ecx_portt *port, const char * ifname, int secondary);
+int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary);
int ecx_closenic(ecx_portt *port);
void ecx_setbufstat(ecx_portt *port, uint8 idx, int bufstat);
uint8 ecx_getindex(ecx_portt *port);
int ecx_outframe(ecx_portt *port, uint8 idx, int sock);
int ecx_outframe_red(ecx_portt *port, uint8 idx);
int ecx_waitinframe(ecx_portt *port, uint8 idx, int timeout);
-int ecx_srconfirm(ecx_portt *port, uint8 idx,int timeout);
+int ecx_srconfirm(ecx_portt *port, uint8 idx, int timeout);
#ifdef __cplusplus
}
* Note that Ethercat uses little endian byte order, except for the Ethernet
* header which is big endian as usual.
*/
-uint16 oshw_htons (uint16 host)
+uint16 oshw_htons(uint16 host)
{
- uint16 network = htons (host);
+ uint16 network = htons(host);
return network;
}
* Note that Ethercat uses little endian byte order, except for the Ethernet
* header which is big endian as usual.
*/
-uint16 oshw_ntohs (uint16 network)
+uint16 oshw_ntohs(uint16 network)
{
- uint16 host = ntohs (network);
+ uint16 host = ntohs(network);
return host;
}
/* Create list over available network adapters.
* @return First element in linked list of adapters
*/
-ec_adaptert * oshw_find_adapters (void)
+ec_adaptert *oshw_find_adapters(void)
{
pcap_if_t *alldevs;
pcap_if_t *d;
- ec_adaptert * adapter;
- ec_adaptert * prev_adapter;
- ec_adaptert * ret_adapter = NULL;
+ ec_adaptert *adapter;
+ ec_adaptert *prev_adapter;
+ ec_adaptert *ret_adapter = NULL;
char errbuf[PCAP_ERRBUF_SIZE];
/* find all devices */
if (pcap_findalldevs(&alldevs, errbuf) == -1)
{
- fprintf(stderr,"Error in pcap_findalldevs_ex: %s\n", errbuf);
+ fprintf(stderr, "Error in pcap_findalldevs_ex: %s\n", errbuf);
return (NULL);
}
/* Iterate all devices and create a local copy holding the name and
* description.
*/
- for(d= alldevs; d != NULL; d= d->next)
+ for (d = alldevs; d != NULL; d = d->next)
{
adapter = (ec_adaptert *)malloc(sizeof(ec_adaptert));
/* If we got more than one adapter save link list pointer to previous
if (d->name)
{
strncpy(adapter->name, d->name, EC_MAXLEN_ADAPTERNAME);
- adapter->name[EC_MAXLEN_ADAPTERNAME-1] = '\0';
+ adapter->name[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
}
else
{
if (d->description)
{
strncpy(adapter->desc, d->description, EC_MAXLEN_ADAPTERNAME);
- adapter->desc[EC_MAXLEN_ADAPTERNAME-1] = '\0';
+ adapter->desc[EC_MAXLEN_ADAPTERNAME - 1] = '\0';
}
else
{
- adapter->desc[0] = '\0';
+ adapter->desc[0] = '\0';
}
prev_adapter = adapter;
}
* @param[in] adapter = First element in linked list of adapters
* EC_NOFRAME.
*/
-void oshw_free_adapters (ec_adaptert * adapter)
+void oshw_free_adapters(ec_adaptert *adapter)
{
- ec_adaptert * next_adapter;
+ ec_adaptert *next_adapter;
/* Iterate the linked list and free all elements holding
* adapter information
*/
- if(adapter)
+ if (adapter)
{
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
while (next_adapter)
{
adapter = next_adapter;
next_adapter = adapter->next;
- free (adapter);
+ free(adapter);
}
}
}
#define _oshw_
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#include "soem/soem.h"
#include "nicdrv.h"
-uint16 oshw_htons (uint16 hostshort);
-uint16 oshw_ntohs (uint16 networkshort);
-ec_adaptert * oshw_find_adapters (void);
-void oshw_free_adapters (ec_adaptert * adapter);
+uint16 oshw_htons(uint16 hostshort);
+uint16 oshw_ntohs(uint16 networkshort);
+ec_adaptert *oshw_find_adapters(void);
+void oshw_free_adapters(ec_adaptert *adapter);
#ifdef __cplusplus
}
#include "soem/soem.h"
-#define MAXBUF 524288
-#define STDBUF 2048
-#define MINBUF 128
-#define CRCBUF 14
+#define MAXBUF 524288
+#define STDBUF 2048
+#define MINBUF 128
+#define CRCBUF 14
-#define MODE_NONE 0
-#define MODE_READBIN 1
-#define MODE_READINTEL 2
-#define MODE_WRITEBIN 3
-#define MODE_WRITEINTEL 4
-#define MODE_WRITEALIAS 5
-#define MODE_INFO 6
+#define MODE_NONE 0
+#define MODE_READBIN 1
+#define MODE_READINTEL 2
+#define MODE_WRITEBIN 3
+#define MODE_WRITEINTEL 4
+#define MODE_WRITEALIAS 5
+#define MODE_INFO 6
-#define MAXSLENGTH 256
+#define MAXSLENGTH 256
uint8 ebuf[MAXBUF];
uint8 ob;
int os;
int slave;
int alias;
-ec_timet tstart,tend, tdif;
+ec_timet tstart, tend, tdif;
int wkc;
int mode;
char sline[MAXSLENGTH];
static ecx_portt ecx_port;
static ec_mbxpoolt ec_mbxpool;
-static ecx_contextt ctx = {
- .port = &ecx_port,
- .slavelist = &ec_slave[0],
- .slavecount = &ec_slavecount,
- .maxslave = EC_MAXSLAVE,
- .grouplist = &ec_group[0],
- .maxgroup = EC_MAXGROUP,
- .esibuf = &ec_esibuf[0],
- .esimap = &ec_esimap[0],
- .esislave = 0,
- .elist = &ec_elist,
- .idxstack = &ec_idxstack,
- .ecaterror = &EcatError,
- .DCtime = &ec_DCtime,
- .SMcommtype = &ec_SMcommtype[0],
- .PDOassign = &ec_PDOassign[0],
- .PDOdesc = &ec_PDOdesc[0],
- .eepSM = &ec_SM,
- .eepFMMU = &ec_FMMU,
- .mbxpool = &ec_mbxpool,
- .FOEhook = NULL,
- .EOEhook = NULL,
- .manualstatechange = 0,
- .userdata = NULL,
+static ecx_contextt ctx = {
+ .port = &ecx_port,
+ .slavelist = &ec_slave[0],
+ .slavecount = &ec_slavecount,
+ .maxslave = EC_MAXSLAVE,
+ .grouplist = &ec_group[0],
+ .maxgroup = EC_MAXGROUP,
+ .esibuf = &ec_esibuf[0],
+ .esimap = &ec_esimap[0],
+ .esislave = 0,
+ .elist = &ec_elist,
+ .idxstack = &ec_idxstack,
+ .ecaterror = &EcatError,
+ .DCtime = &ec_DCtime,
+ .SMcommtype = &ec_SMcommtype[0],
+ .PDOassign = &ec_PDOassign[0],
+ .PDOdesc = &ec_PDOdesc[0],
+ .eepSM = &ec_SM,
+ .eepFMMU = &ec_FMMU,
+ .mbxpool = &ec_mbxpool,
+ .FOEhook = NULL,
+ .EOEhook = NULL,
+ .manualstatechange = 0,
+ .userdata = NULL,
};
#define IHEXLENGTH 0x20
{
int j;
*crc ^= b;
- for(j = 0; j <= 7 ; j++ )
+ for (j = 0; j <= 7; j++)
{
- if(*crc & 0x80)
- *crc = (*crc << 1) ^ 0x07;
- else
- *crc = (*crc << 1);
+ if (*crc & 0x80)
+ *crc = (*crc << 1) ^ 0x07;
+ else
+ *crc = (*crc << 1);
}
}
uint8 crc;
crc = 0xff;
- for( i = 0 ; i <= 13 ; i++ )
+ for (i = 0; i <= 13; i++)
{
- calc_crc(&crc , *(buf++));
+ calc_crc(&crc, *(buf++));
}
return (uint16)crc;
}
int cc = 0, c;
fp = fopen(fname, "rb");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
while (((c = fgetc(fp)) != EOF) && (cc < MAXBUF))
ebuf[cc++] = (uint8)c;
int hstart, hlength, sum;
fp = fopen(fname, "r");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
hstart = MAXBUF;
hlength = 0;
{
memset(sline, 0x00, MAXSLENGTH);
sc = 0;
- while (((c = fgetc(fp)) != EOF) && (c != 0x0A) && (sc < (MAXSLENGTH -1)))
+ while (((c = fgetc(fp)) != EOF) && (c != 0x0A) && (sc < (MAXSLENGTH - 1)))
sline[sc++] = (uint8)c;
if ((c != EOF) && ((sc < 11) || (sline[0] != ':')))
{
}
if (c != EOF)
{
- sn = sscanf(sline , ":%2x%4x%2x", &ll, &ladr, <);
+ sn = sscanf(sline, ":%2x%4x%2x", &ll, &ladr, <);
if ((sn == 3) && ((ladr + ll) <= MAXBUF) && (lt == 0))
{
sum = ll + (ladr >> 8) + (ladr & 0xff) + lt;
- if(ladr < hstart) hstart = ladr;
- for(i = 0; i < ll ; i++)
+ if (ladr < hstart) hstart = ladr;
+ for (i = 0; i < ll; i++)
{
sn = sscanf(&sline[9 + (i << 1)], "%2x", &lval);
ebuf[ladr + i] = (uint8)lval;
sum += (uint8)lval;
}
- if(((ladr + ll) - hstart) > hlength)
+ if (((ladr + ll) - hstart) > hlength)
hlength = (ladr + ll) - hstart;
sum = (0x100 - sum) & 0xff;
sn = sscanf(&sline[9 + (i << 1)], "%2x", &lval);
}
}
}
- }
- while (c != EOF);
+ } while (c != EOF);
if (retval)
{
*length = hlength;
int cc;
fp = fopen(fname, "wb");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
- for (cc = 0 ; cc < length ; cc++)
- fputc( ebuf[cc], fp);
+ for (cc = 0; cc < length; cc++)
+ fputc(ebuf[cc], fp);
fclose(fp);
return 1;
int cc = 0, ll, sum, i;
fp = fopen(fname, "w");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
while (cc < length)
{
uint64 b8;
uint8 eepctl;
- if((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
{
aiadr = 1 - slave;
eepctl = 2;
- ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
+ ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
eepctl = 0;
- ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
+ ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
estat = 0x0000;
aiadr = 1 - slave;
if (estat & EC_ESTAT_R64)
{
ainc = 8;
- for (i = start ; i < (start + length) ; i+=ainc)
+ for (i = start; i < (start + length); i += ainc)
{
- b8 = ecx_readeepromAP(&ctx, aiadr, i >> 1 , EC_TIMEOUTEEP);
+ b8 = ecx_readeepromAP(&ctx, aiadr, i >> 1, EC_TIMEOUTEEP);
ebuf[i] = b8 & 0xFF;
- ebuf[i+1] = (b8 >> 8) & 0xFF;
- ebuf[i+2] = (b8 >> 16) & 0xFF;
- ebuf[i+3] = (b8 >> 24) & 0xFF;
- ebuf[i+4] = (b8 >> 32) & 0xFF;
- ebuf[i+5] = (b8 >> 40) & 0xFF;
- ebuf[i+6] = (b8 >> 48) & 0xFF;
- ebuf[i+7] = (b8 >> 56) & 0xFF;
+ ebuf[i + 1] = (b8 >> 8) & 0xFF;
+ ebuf[i + 2] = (b8 >> 16) & 0xFF;
+ ebuf[i + 3] = (b8 >> 24) & 0xFF;
+ ebuf[i + 4] = (b8 >> 32) & 0xFF;
+ ebuf[i + 5] = (b8 >> 40) & 0xFF;
+ ebuf[i + 6] = (b8 >> 48) & 0xFF;
+ ebuf[i + 7] = (b8 >> 56) & 0xFF;
}
}
else
{
- for (i = start ; i < (start + length) ; i+=ainc)
+ for (i = start; i < (start + length); i += ainc)
{
- b4 = ecx_readeepromAP(&ctx, aiadr, i >> 1 , EC_TIMEOUTEEP) & 0xFFFFFFFF;
+ b4 = ecx_readeepromAP(&ctx, aiadr, i >> 1, EC_TIMEOUTEEP) & 0xFFFFFFFF;
ebuf[i] = b4 & 0xFF;
- ebuf[i+1] = (b4 >> 8) & 0xFF;
- ebuf[i+2] = (b4 >> 16) & 0xFF;
- ebuf[i+3] = (b4 >> 24) & 0xFF;
+ ebuf[i + 1] = (b4 >> 8) & 0xFF;
+ ebuf[i + 2] = (b4 >> 16) & 0xFF;
+ ebuf[i + 3] = (b4 >> 24) & 0xFF;
}
}
uint16 aiadr, *wbuf;
uint8 eepctl;
- if((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
{
aiadr = 1 - slave;
eepctl = 2;
- ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
+ ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
eepctl = 0;
- ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
+ ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
aiadr = 1 - slave;
wbuf = (uint16 *)&ebuf[0];
- for (i = start ; i < (start + length) ; i+=2)
+ for (i = start; i < (start + length); i += 2)
{
- ecx_writeeepromAP(&ctx, aiadr, i >> 1 , *(wbuf + (i >> 1)), EC_TIMEOUTEEP);
+ ecx_writeeepromAP(&ctx, aiadr, i >> 1, *(wbuf + (i >> 1)), EC_TIMEOUTEEP);
if (++dc >= 100)
{
dc = 0;
uint8 eepctl;
int ret;
- if((ec_slavecount >= slave) && (slave > 0) && (alias <= 0xffff))
+ if ((ec_slavecount >= slave) && (slave > 0) && (alias <= 0xffff))
{
aiadr = 1 - slave;
eepctl = 2;
- ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
+ ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
eepctl = 0;
- ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
+ ecx_APWR(&ctx.port[0], aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
- ret = ecx_writeeepromAP(&ctx, aiadr, 0x04 , alias, EC_TIMEOUTEEP);
+ ret = ecx_writeeepromAP(&ctx, aiadr, 0x04, alias, EC_TIMEOUTEEP);
if (ret)
- ret = ecx_writeeepromAP(&ctx, aiadr, 0x07 , crc, EC_TIMEOUTEEP);
+ ret = ecx_writeeepromAP(&ctx, aiadr, 0x07, crc, EC_TIMEOUTEEP);
return ret;
}
/* initialise SOEM, bind socket to ifname */
if (ecx_init(&ctx, ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
w = 0x0000;
- wkc = ecx_BRD(&ctx.port[0], 0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
- if (wkc > 0)
- {
+ wkc = ecx_BRD(&ctx.port[0], 0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
+ if (wkc > 0)
+ {
ec_slavecount = wkc;
- printf("%d slaves found.\n",ec_slavecount);
- if((ec_slavecount >= slave) && (slave > 0))
+ printf("%d slaves found.\n", ec_slavecount);
+ if ((ec_slavecount >= slave) && (slave > 0))
{
if ((mode == MODE_INFO) || (mode == MODE_READBIN) || (mode == MODE_READINTEL))
{
wbuf = (uint16 *)&ebuf[0];
printf("Slave %d data\n", slave);
- printf(" PDI Control : %4.4X\n",*(wbuf + 0x00));
- printf(" PDI Config : %4.4X\n",*(wbuf + 0x01));
- printf(" Config Alias : %4.4X\n",*(wbuf + 0x04));
- printf(" Checksum : %4.4X\n",*(wbuf + 0x07));
- printf(" calculated : %4.4X\n",SIIcrc(&ebuf[0]));
- printf(" Vendor ID : %8.8X\n",*(uint32 *)(wbuf + 0x08));
- printf(" Product Code : %8.8X\n",*(uint32 *)(wbuf + 0x0A));
- printf(" Revision Number : %8.8X\n",*(uint32 *)(wbuf + 0x0C));
- printf(" Serial Number : %8.8X\n",*(uint32 *)(wbuf + 0x0E));
- printf(" Mailbox Protocol : %4.4X\n",*(wbuf + 0x1C));
+ printf(" PDI Control : %4.4X\n", *(wbuf + 0x00));
+ printf(" PDI Config : %4.4X\n", *(wbuf + 0x01));
+ printf(" Config Alias : %4.4X\n", *(wbuf + 0x04));
+ printf(" Checksum : %4.4X\n", *(wbuf + 0x07));
+ printf(" calculated : %4.4X\n", SIIcrc(&ebuf[0]));
+ printf(" Vendor ID : %8.8X\n", *(uint32 *)(wbuf + 0x08));
+ printf(" Product Code : %8.8X\n", *(uint32 *)(wbuf + 0x0A));
+ printf(" Revision Number : %8.8X\n", *(uint32 *)(wbuf + 0x0C));
+ printf(" Serial Number : %8.8X\n", *(uint32 *)(wbuf + 0x0E));
+ printf(" Mailbox Protocol : %4.4X\n", *(wbuf + 0x1C));
esize = (*(wbuf + 0x3E) + 1) * 128;
if (esize > MAXBUF) esize = MAXBUF;
- printf(" Size : %4.4X = %d bytes\n",*(wbuf + 0x3E), esize);
- printf(" Version : %4.4X\n",*(wbuf + 0x3F));
+ printf(" Size : %4.4X = %d bytes\n", *(wbuf + 0x3E), esize);
+ printf(" Version : %4.4X\n", *(wbuf + 0x3F));
}
if ((mode == MODE_READBIN) || (mode == MODE_READINTEL))
{
tend = osal_current_time();
osal_time_diff(&tstart, &tend, &tdif);
if (mode == MODE_READINTEL) output_intelhex(fname, esize);
- if (mode == MODE_READBIN) output_bin(fname, esize);
+ if (mode == MODE_READBIN) output_bin(fname, esize);
- printf("\nTotal EEPROM read time :%ldms\n", (tdif.usec+(tdif.sec*1000000L)) / 1000);
+ printf("\nTotal EEPROM read time :%ldms\n", (tdif.usec + (tdif.sec * 1000000L)) / 1000);
}
if ((mode == MODE_WRITEBIN) || (mode == MODE_WRITEINTEL))
{
estart = 0;
if (mode == MODE_WRITEINTEL) rc = input_intelhex(fname, &estart, &esize);
- if (mode == MODE_WRITEBIN) rc = input_bin(fname, &esize);
+ if (mode == MODE_WRITEBIN) rc = input_bin(fname, &esize);
if (rc > 0)
{
wbuf = (uint16 *)&ebuf[0];
printf("Slave %d\n", slave);
- printf(" Vendor ID : %8.8X\n",*(uint32 *)(wbuf + 0x08));
- printf(" Product Code : %8.8X\n",*(uint32 *)(wbuf + 0x0A));
- printf(" Revision Number : %8.8X\n",*(uint32 *)(wbuf + 0x0C));
- printf(" Serial Number : %8.8X\n",*(uint32 *)(wbuf + 0x0E));
+ printf(" Vendor ID : %8.8X\n", *(uint32 *)(wbuf + 0x08));
+ printf(" Product Code : %8.8X\n", *(uint32 *)(wbuf + 0x0A));
+ printf(" Revision Number : %8.8X\n", *(uint32 *)(wbuf + 0x0C));
+ printf(" Serial Number : %8.8X\n", *(uint32 *)(wbuf + 0x0E));
printf("Busy");
fflush(stdout);
tend = osal_current_time();
osal_time_diff(&tstart, &tend, &tdif);
- printf("\nTotal EEPROM write time :%ldms\n", (tdif.usec+(tdif.sec*1000000L)) / 1000);
+ printf("\nTotal EEPROM write time :%ldms\n", (tdif.usec + (tdif.sec * 1000000L)) / 1000);
}
else
printf("Error reading file, abort.\n");
}
if (mode == MODE_WRITEALIAS)
{
- if( eeprom_read(slave, 0x0000, CRCBUF) ) // read first 14 bytes
+ if (eeprom_read(slave, 0x0000, CRCBUF)) // read first 14 bytes
{
wbuf = (uint16 *)&ebuf[0];
*(wbuf + 0x04) = alias;
- if(eeprom_writealias(slave, alias, SIIcrc(&ebuf[0])))
+ if (eeprom_writealias(slave, alias, SIIcrc(&ebuf[0])))
{
printf("Alias %4.4X written successfully to slave %d\n", alias, slave);
}
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
if (argc > 3)
{
slave = atoi(argv[2]);
- if ((strncmp(argv[3], "-i", sizeof("-i")) == 0)) mode = MODE_INFO;
+ if ((strncmp(argv[3], "-i", sizeof("-i")) == 0)) mode = MODE_INFO;
if (argc > 4)
{
- if ((strncmp(argv[3], "-r", sizeof("-r")) == 0)) mode = MODE_READBIN;
+ if ((strncmp(argv[3], "-r", sizeof("-r")) == 0)) mode = MODE_READBIN;
if ((strncmp(argv[3], "-ri", sizeof("-ri")) == 0)) mode = MODE_READINTEL;
- if ((strncmp(argv[3], "-w", sizeof("-w")) == 0)) mode = MODE_WRITEBIN;
+ if ((strncmp(argv[3], "-w", sizeof("-w")) == 0)) mode = MODE_WRITEBIN;
if ((strncmp(argv[3], "-wi", sizeof("-wi")) == 0)) mode = MODE_WRITEINTEL;
if ((strncmp(argv[3], "-walias", sizeof("-walias")) == 0))
{
}
}
/* start tool */
- eepromtool(argv[1],slave,mode,argv[4]);
+ eepromtool(argv[1], slave, mode, argv[4]);
}
else
{
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
printf("Usage: eepromtool ifname slave OPTION fname|alias\n");
printf("ifname = eth0 for example\n");
printf(" -w write EEPROM, input binary format\n");
printf(" -wi write EEPROM, input Intel Hex format\n");
- printf ("\nAvailable adapters:\n");
- head = adapter = ec_find_adapters ();
+ printf("\nAvailable adapters:\n");
+ head = adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf (" - %s (%s)\n", adapter->name, adapter->desc);
+ printf(" - %s (%s)\n", adapter->name, adapter->desc);
adapter = adapter->next;
}
ec_free_adapters(head);
#include <stdlib.h>
#include <string.h>
-
-typedef struct {
- ecx_contextt context;
- char * iface;
- uint8 group;
- int roundtrip_time;
-
- /* Used by the context */
- uint8 map[4096];
- ecx_portt port;
- ec_slavet slavelist[EC_MAXSLAVE];
- int slavecount;
- ec_groupt grouplist[EC_MAXGROUP];
- uint8 esibuf[EC_MAXEEPBUF];
- uint32 esimap[EC_MAXEEPBITMAP];
- ec_eringt elist;
- ec_idxstackT idxstack;
- boolean ecaterror;
- int64 DCtime;
- ec_SMcommtypet SMcommtype[EC_MAX_MAPT];
- ec_PDOassignt PDOassign[EC_MAX_MAPT];
- ec_PDOdesct PDOdesc[EC_MAX_MAPT];
- ec_eepromSMt eepSM;
- ec_eepromFMMUt eepFMMU;
+typedef struct
+{
+ ecx_contextt context;
+ char *iface;
+ uint8 group;
+ int roundtrip_time;
+
+ /* Used by the context */
+ uint8 map[4096];
+ ecx_portt port;
+ ec_slavet slavelist[EC_MAXSLAVE];
+ int slavecount;
+ ec_groupt grouplist[EC_MAXGROUP];
+ uint8 esibuf[EC_MAXEEPBUF];
+ uint32 esimap[EC_MAXEEPBITMAP];
+ ec_eringt elist;
+ ec_idxstackT idxstack;
+ boolean ecaterror;
+ int64 DCtime;
+ ec_SMcommtypet SMcommtype[EC_MAX_MAPT];
+ ec_PDOassignt PDOassign[EC_MAX_MAPT];
+ ec_PDOdesct PDOdesc[EC_MAX_MAPT];
+ ec_eepromSMt eepSM;
+ ec_eepromFMMUt eepFMMU;
} Fieldbus;
-
static void
fieldbus_initialize(Fieldbus *fieldbus, char *iface)
{
- ecx_contextt *context;
-
- /* Let's start by 0-filling `fieldbus` to avoid surprises */
- memset(fieldbus, 0, sizeof(*fieldbus));
-
- fieldbus->iface = iface;
- fieldbus->group = 0;
- fieldbus->roundtrip_time = 0;
- fieldbus->ecaterror = FALSE;
-
- /* Initialize the ecx_contextt data structure */
- context = &fieldbus->context;
- context->port = &fieldbus->port;
- context->slavelist = fieldbus->slavelist;
- context->slavecount = &fieldbus->slavecount;
- context->maxslave = EC_MAXSLAVE;
- context->grouplist = fieldbus->grouplist;
- context->maxgroup = EC_MAXGROUP;
- context->esibuf = fieldbus->esibuf;
- context->esimap = fieldbus->esimap;
- context->esislave = 0;
- context->elist = &fieldbus->elist;
- context->idxstack = &fieldbus->idxstack;
- context->ecaterror = &fieldbus->ecaterror;
- context->DCtime = &fieldbus->DCtime;
- context->SMcommtype = fieldbus->SMcommtype;
- context->PDOassign = fieldbus->PDOassign;
- context->PDOdesc = fieldbus->PDOdesc;
- context->eepSM = &fieldbus->eepSM;
- context->eepFMMU = &fieldbus->eepFMMU;
- context->FOEhook = NULL;
- context->EOEhook = NULL;
- context->manualstatechange = 0;
+ ecx_contextt *context;
+
+ /* Let's start by 0-filling `fieldbus` to avoid surprises */
+ memset(fieldbus, 0, sizeof(*fieldbus));
+
+ fieldbus->iface = iface;
+ fieldbus->group = 0;
+ fieldbus->roundtrip_time = 0;
+ fieldbus->ecaterror = FALSE;
+
+ /* Initialize the ecx_contextt data structure */
+ context = &fieldbus->context;
+ context->port = &fieldbus->port;
+ context->slavelist = fieldbus->slavelist;
+ context->slavecount = &fieldbus->slavecount;
+ context->maxslave = EC_MAXSLAVE;
+ context->grouplist = fieldbus->grouplist;
+ context->maxgroup = EC_MAXGROUP;
+ context->esibuf = fieldbus->esibuf;
+ context->esimap = fieldbus->esimap;
+ context->esislave = 0;
+ context->elist = &fieldbus->elist;
+ context->idxstack = &fieldbus->idxstack;
+ context->ecaterror = &fieldbus->ecaterror;
+ context->DCtime = &fieldbus->DCtime;
+ context->SMcommtype = fieldbus->SMcommtype;
+ context->PDOassign = fieldbus->PDOassign;
+ context->PDOdesc = fieldbus->PDOdesc;
+ context->eepSM = &fieldbus->eepSM;
+ context->eepFMMU = &fieldbus->eepFMMU;
+ context->FOEhook = NULL;
+ context->EOEhook = NULL;
+ context->manualstatechange = 0;
}
static int
fieldbus_roundtrip(Fieldbus *fieldbus)
{
- ecx_contextt *context;
- ec_timet start, end, diff;
- int wkc;
+ ecx_contextt *context;
+ ec_timet start, end, diff;
+ int wkc;
- context = &fieldbus->context;
+ context = &fieldbus->context;
- start = osal_current_time();
- ecx_send_processdata(context);
- wkc = ecx_receive_processdata(context, EC_TIMEOUTRET);
- end = osal_current_time();
- osal_time_diff(&start, &end, &diff);
- fieldbus->roundtrip_time = diff.sec * 1000000 + diff.usec;
+ start = osal_current_time();
+ ecx_send_processdata(context);
+ wkc = ecx_receive_processdata(context, EC_TIMEOUTRET);
+ end = osal_current_time();
+ osal_time_diff(&start, &end, &diff);
+ fieldbus->roundtrip_time = diff.sec * 1000000 + diff.usec;
- return wkc;
+ return wkc;
}
static boolean
fieldbus_start(Fieldbus *fieldbus)
{
- ecx_contextt *context;
- ec_groupt *grp;
- ec_slavet *slave;
- int i;
-
- context = &fieldbus->context;
- grp = fieldbus->grouplist + fieldbus->group;
-
- printf("Initializing SOEM on '%s'... ", fieldbus->iface);
- if (! ecx_init(context, fieldbus->iface)) {
- printf("no socket connection\n");
- return FALSE;
- }
- printf("done\n");
-
- printf("Finding autoconfig slaves... ");
- if (ecx_config_init(context, FALSE) <= 0) {
- printf("no slaves found\n");
- return FALSE;
- }
- printf("%d slaves found\n", fieldbus->slavecount);
-
- printf("Sequential mapping of I/O... ");
- ecx_config_map_group(context, fieldbus->map, fieldbus->group);
- printf("mapped %dO+%dI bytes from %d segments",
- grp->Obytes, grp->Ibytes, grp->nsegments);
- if (grp->nsegments > 1) {
- /* Show how slaves are distrubuted */
- for (i = 0; i < grp->nsegments; ++i) {
- printf("%s%d", i == 0 ? " (" : "+", grp->IOsegment[i]);
- }
- printf(" slaves)");
- }
- printf("\n");
-
- printf("Configuring distributed clock... ");
- ecx_configdc(context);
- printf("done\n");
-
- printf("Waiting for all slaves in safe operational... ");
- ecx_statecheck(context, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
- printf("done\n");
-
- printf("Send a roundtrip to make outputs in slaves happy... ");
- fieldbus_roundtrip(fieldbus);
- printf("done\n");
-
- printf("Setting operational state..");
- /* Act on slave 0 (a virtual slave used for broadcasting) */
- slave = fieldbus->slavelist;
- slave->state = EC_STATE_OPERATIONAL;
- ecx_writestate(context, 0);
- /* Poll the result ten times before giving up */
- for (i = 0; i < 10; ++i) {
- printf(".");
- fieldbus_roundtrip(fieldbus);
- ecx_statecheck(context, 0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE / 10);
- if (slave->state == EC_STATE_OPERATIONAL) {
- printf(" all slaves are now operational\n");
- return TRUE;
- }
- }
-
- printf(" failed,");
- ecx_readstate(context);
- for (i = 1; i <= fieldbus->slavecount; ++i) {
- slave = fieldbus->slavelist + i;
- if (slave->state != EC_STATE_OPERATIONAL) {
- printf(" slave %d is 0x%04X (AL-status=0x%04X %s)",
- i, slave->state, slave->ALstatuscode,
- ec_ALstatuscode2string(slave->ALstatuscode));
- }
- }
- printf("\n");
-
- return FALSE;
+ ecx_contextt *context;
+ ec_groupt *grp;
+ ec_slavet *slave;
+ int i;
+
+ context = &fieldbus->context;
+ grp = fieldbus->grouplist + fieldbus->group;
+
+ printf("Initializing SOEM on '%s'... ", fieldbus->iface);
+ if (!ecx_init(context, fieldbus->iface))
+ {
+ printf("no socket connection\n");
+ return FALSE;
+ }
+ printf("done\n");
+
+ printf("Finding autoconfig slaves... ");
+ if (ecx_config_init(context, FALSE) <= 0)
+ {
+ printf("no slaves found\n");
+ return FALSE;
+ }
+ printf("%d slaves found\n", fieldbus->slavecount);
+
+ printf("Sequential mapping of I/O... ");
+ ecx_config_map_group(context, fieldbus->map, fieldbus->group);
+ printf("mapped %dO+%dI bytes from %d segments",
+ grp->Obytes, grp->Ibytes, grp->nsegments);
+ if (grp->nsegments > 1)
+ {
+ /* Show how slaves are distrubuted */
+ for (i = 0; i < grp->nsegments; ++i)
+ {
+ printf("%s%d", i == 0 ? " (" : "+", grp->IOsegment[i]);
+ }
+ printf(" slaves)");
+ }
+ printf("\n");
+
+ printf("Configuring distributed clock... ");
+ ecx_configdc(context);
+ printf("done\n");
+
+ printf("Waiting for all slaves in safe operational... ");
+ ecx_statecheck(context, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
+ printf("done\n");
+
+ printf("Send a roundtrip to make outputs in slaves happy... ");
+ fieldbus_roundtrip(fieldbus);
+ printf("done\n");
+
+ printf("Setting operational state..");
+ /* Act on slave 0 (a virtual slave used for broadcasting) */
+ slave = fieldbus->slavelist;
+ slave->state = EC_STATE_OPERATIONAL;
+ ecx_writestate(context, 0);
+ /* Poll the result ten times before giving up */
+ for (i = 0; i < 10; ++i)
+ {
+ printf(".");
+ fieldbus_roundtrip(fieldbus);
+ ecx_statecheck(context, 0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE / 10);
+ if (slave->state == EC_STATE_OPERATIONAL)
+ {
+ printf(" all slaves are now operational\n");
+ return TRUE;
+ }
+ }
+
+ printf(" failed,");
+ ecx_readstate(context);
+ for (i = 1; i <= fieldbus->slavecount; ++i)
+ {
+ slave = fieldbus->slavelist + i;
+ if (slave->state != EC_STATE_OPERATIONAL)
+ {
+ printf(" slave %d is 0x%04X (AL-status=0x%04X %s)",
+ i, slave->state, slave->ALstatuscode,
+ ec_ALstatuscode2string(slave->ALstatuscode));
+ }
+ }
+ printf("\n");
+
+ return FALSE;
}
static void
fieldbus_stop(Fieldbus *fieldbus)
{
- ecx_contextt *context;
- ec_slavet *slave;
+ ecx_contextt *context;
+ ec_slavet *slave;
- context = &fieldbus->context;
- /* Act on slave 0 (a virtual slave used for broadcasting) */
- slave = fieldbus->slavelist;
+ context = &fieldbus->context;
+ /* Act on slave 0 (a virtual slave used for broadcasting) */
+ slave = fieldbus->slavelist;
- printf("Requesting init state on all slaves... ");
- slave->state = EC_STATE_INIT;
- ecx_writestate(context, 0);
- printf("done\n");
+ printf("Requesting init state on all slaves... ");
+ slave->state = EC_STATE_INIT;
+ ecx_writestate(context, 0);
+ printf("done\n");
- printf("Close socket... ");
- ecx_close(context);
- printf("done\n");
+ printf("Close socket... ");
+ ecx_close(context);
+ printf("done\n");
}
static boolean
fieldbus_dump(Fieldbus *fieldbus)
{
- ec_groupt *grp;
- uint32 n;
- int wkc, expected_wkc;
-
- grp = fieldbus->grouplist + fieldbus->group;
-
- wkc = fieldbus_roundtrip(fieldbus);
- expected_wkc = grp->outputsWKC * 2 + grp->inputsWKC;
- printf("%6d usec WKC %d", fieldbus->roundtrip_time, wkc);
- if (wkc < expected_wkc) {
- printf(" wrong (expected %d)\n", expected_wkc);
- return FALSE;
- }
-
- printf(" O:");
- for (n = 0; n < grp->Obytes; ++n) {
- printf(" %02X", grp->outputs[n]);
- }
- printf(" I:");
- for (n = 0; n < grp->Ibytes; ++n) {
- printf(" %02X", grp->inputs[n]);
- }
- printf(" T: %lld\r", (long long) fieldbus->DCtime);
- return TRUE;
+ ec_groupt *grp;
+ uint32 n;
+ int wkc, expected_wkc;
+
+ grp = fieldbus->grouplist + fieldbus->group;
+
+ wkc = fieldbus_roundtrip(fieldbus);
+ expected_wkc = grp->outputsWKC * 2 + grp->inputsWKC;
+ printf("%6d usec WKC %d", fieldbus->roundtrip_time, wkc);
+ if (wkc < expected_wkc)
+ {
+ printf(" wrong (expected %d)\n", expected_wkc);
+ return FALSE;
+ }
+
+ printf(" O:");
+ for (n = 0; n < grp->Obytes; ++n)
+ {
+ printf(" %02X", grp->outputs[n]);
+ }
+ printf(" I:");
+ for (n = 0; n < grp->Ibytes; ++n)
+ {
+ printf(" %02X", grp->inputs[n]);
+ }
+ printf(" T: %lld\r", (long long)fieldbus->DCtime);
+ return TRUE;
}
static void
fieldbus_check_state(Fieldbus *fieldbus)
{
- ecx_contextt *context;
- ec_groupt *grp;
- ec_slavet *slave;
- int i;
-
- context = &fieldbus->context;
- grp = context->grouplist + fieldbus->group;
- grp->docheckstate = FALSE;
- ecx_readstate(context);
- for (i = 1; i <= fieldbus->slavecount; ++i) {
- slave = context->slavelist + i;
- if (slave->group != fieldbus->group) {
- /* This slave is part of another group: do nothing */
- } else if (slave->state != EC_STATE_OPERATIONAL) {
- grp->docheckstate = TRUE;
- if (slave->state == EC_STATE_SAFE_OP + EC_STATE_ERROR) {
- printf("* Slave %d is in SAFE_OP+ERROR, attempting ACK\n", i);
- slave->state = EC_STATE_SAFE_OP + EC_STATE_ACK;
- ecx_writestate(context, i);
- } else if(slave->state == EC_STATE_SAFE_OP) {
- printf("* Slave %d is in SAFE_OP, change to OPERATIONAL\n", i);
- slave->state = EC_STATE_OPERATIONAL;
- ecx_writestate(context, i);
- } else if(slave->state > EC_STATE_NONE) {
- if (ecx_reconfig_slave(context, i, EC_TIMEOUTRET)) {
- slave->islost = FALSE;
- printf("* Slave %d reconfigured\n", i);
- }
- } else if(! slave->islost) {
- ecx_statecheck(context, i, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (slave->state == EC_STATE_NONE) {
- slave->islost = TRUE;
- printf("* Slave %d lost\n", i);
- }
+ ecx_contextt *context;
+ ec_groupt *grp;
+ ec_slavet *slave;
+ int i;
+
+ context = &fieldbus->context;
+ grp = context->grouplist + fieldbus->group;
+ grp->docheckstate = FALSE;
+ ecx_readstate(context);
+ for (i = 1; i <= fieldbus->slavecount; ++i)
+ {
+ slave = context->slavelist + i;
+ if (slave->group != fieldbus->group)
+ {
+ /* This slave is part of another group: do nothing */
+ }
+ else if (slave->state != EC_STATE_OPERATIONAL)
+ {
+ grp->docheckstate = TRUE;
+ if (slave->state == EC_STATE_SAFE_OP + EC_STATE_ERROR)
+ {
+ printf("* Slave %d is in SAFE_OP+ERROR, attempting ACK\n", i);
+ slave->state = EC_STATE_SAFE_OP + EC_STATE_ACK;
+ ecx_writestate(context, i);
+ }
+ else if (slave->state == EC_STATE_SAFE_OP)
+ {
+ printf("* Slave %d is in SAFE_OP, change to OPERATIONAL\n", i);
+ slave->state = EC_STATE_OPERATIONAL;
+ ecx_writestate(context, i);
+ }
+ else if (slave->state > EC_STATE_NONE)
+ {
+ if (ecx_reconfig_slave(context, i, EC_TIMEOUTRET))
+ {
+ slave->islost = FALSE;
+ printf("* Slave %d reconfigured\n", i);
}
- } else if (slave->islost) {
- if(slave->state != EC_STATE_NONE) {
- slave->islost = FALSE;
- printf("* Slave %d found\n", i);
- } else if (ecx_recover_slave(context, i, EC_TIMEOUTRET)) {
- slave->islost = FALSE;
- printf("* Slave %d recovered\n", i);
+ }
+ else if (!slave->islost)
+ {
+ ecx_statecheck(context, i, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (slave->state == EC_STATE_NONE)
+ {
+ slave->islost = TRUE;
+ printf("* Slave %d lost\n", i);
}
- }
- }
-
- if (! grp->docheckstate) {
- printf("All slaves resumed OPERATIONAL\n");
- }
+ }
+ }
+ else if (slave->islost)
+ {
+ if (slave->state != EC_STATE_NONE)
+ {
+ slave->islost = FALSE;
+ printf("* Slave %d found\n", i);
+ }
+ else if (ecx_recover_slave(context, i, EC_TIMEOUTRET))
+ {
+ slave->islost = FALSE;
+ printf("* Slave %d recovered\n", i);
+ }
+ }
+ }
+
+ if (!grp->docheckstate)
+ {
+ printf("All slaves resumed OPERATIONAL\n");
+ }
}
-int
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
{
- Fieldbus fieldbus;
-
- if (argc != 2) {
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
- printf("Usage: simple_ng IFNAME1\n"
- "IFNAME1 is the NIC interface name, e.g. 'eth0'\n");
-
- printf("\nAvailable adapters:\n");
- head = adapter = ec_find_adapters();
- while (adapter != NULL)
- {
- printf(" - %s (%s)\n", adapter->name, adapter->desc);
- adapter = adapter->next;
- }
- ec_free_adapters(head);
- return 1;
- }
-
- fieldbus_initialize(&fieldbus, argv[1]);
- if (fieldbus_start(&fieldbus)) {
- int i, min_time, max_time;
- min_time = max_time = 0;
- for (i = 1; i <= 10000; ++i) {
- printf("Iteration %4d:", i);
- if (! fieldbus_dump(&fieldbus)) {
- fieldbus_check_state(&fieldbus);
- } else if (i == 1) {
- min_time = max_time = fieldbus.roundtrip_time;
- } else if (fieldbus.roundtrip_time < min_time) {
- min_time = fieldbus.roundtrip_time;
- } else if (fieldbus.roundtrip_time > max_time) {
- max_time = fieldbus.roundtrip_time;
- }
- osal_usleep(5000);
- }
- printf("\nRoundtrip time (usec): min %d max %d\n", min_time, max_time);
- fieldbus_stop(&fieldbus);
- }
-
- return 0;
+ Fieldbus fieldbus;
+
+ if (argc != 2)
+ {
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
+ printf("Usage: simple_ng IFNAME1\n"
+ "IFNAME1 is the NIC interface name, e.g. 'eth0'\n");
+
+ printf("\nAvailable adapters:\n");
+ head = adapter = ec_find_adapters();
+ while (adapter != NULL)
+ {
+ printf(" - %s (%s)\n", adapter->name, adapter->desc);
+ adapter = adapter->next;
+ }
+ ec_free_adapters(head);
+ return 1;
+ }
+
+ fieldbus_initialize(&fieldbus, argv[1]);
+ if (fieldbus_start(&fieldbus))
+ {
+ int i, min_time, max_time;
+ min_time = max_time = 0;
+ for (i = 1; i <= 10000; ++i)
+ {
+ printf("Iteration %4d:", i);
+ if (!fieldbus_dump(&fieldbus))
+ {
+ fieldbus_check_state(&fieldbus);
+ }
+ else if (i == 1)
+ {
+ min_time = max_time = fieldbus.roundtrip_time;
+ }
+ else if (fieldbus.roundtrip_time < min_time)
+ {
+ min_time = fieldbus.roundtrip_time;
+ }
+ else if (fieldbus.roundtrip_time > max_time)
+ {
+ max_time = fieldbus.roundtrip_time;
+ }
+ osal_usleep(5000);
+ }
+ printf("\nRoundtrip time (usec): min %d max %d\n", min_time, max_time);
+ fieldbus_stop(&fieldbus);
+ }
+
+ return 0;
}
static ecx_portt ecx_port;
static ec_mbxpoolt ec_mbxpool;
-static ecx_contextt ctx = {
- .port = &ecx_port,
- .slavelist = &ec_slave[0],
- .slavecount = &ec_slavecount,
- .maxslave = EC_MAXSLAVE,
- .grouplist = &ec_group[0],
- .maxgroup = EC_MAXGROUP,
- .esibuf = &ec_esibuf[0],
- .esimap = &ec_esimap[0],
- .esislave = 0,
- .elist = &ec_elist,
- .idxstack = &ec_idxstack,
- .ecaterror = &EcatError,
- .DCtime = &ec_DCtime,
- .SMcommtype = &ec_SMcommtype[0],
- .PDOassign = &ec_PDOassign[0],
- .PDOdesc = &ec_PDOdesc[0],
- .eepSM = &ec_SM,
- .eepFMMU = &ec_FMMU,
- .mbxpool = &ec_mbxpool,
- .FOEhook = NULL,
- .EOEhook = NULL,
- .manualstatechange = 0,
- .userdata = NULL,
+static ecx_contextt ctx = {
+ .port = &ecx_port,
+ .slavelist = &ec_slave[0],
+ .slavecount = &ec_slavecount,
+ .maxslave = EC_MAXSLAVE,
+ .grouplist = &ec_group[0],
+ .maxgroup = EC_MAXGROUP,
+ .esibuf = &ec_esibuf[0],
+ .esimap = &ec_esimap[0],
+ .esislave = 0,
+ .elist = &ec_elist,
+ .idxstack = &ec_idxstack,
+ .ecaterror = &EcatError,
+ .DCtime = &ec_DCtime,
+ .SMcommtype = &ec_SMcommtype[0],
+ .PDOassign = &ec_PDOassign[0],
+ .PDOdesc = &ec_PDOdesc[0],
+ .eepSM = &ec_SM,
+ .eepFMMU = &ec_FMMU,
+ .mbxpool = &ec_mbxpool,
+ .FOEhook = NULL,
+ .EOEhook = NULL,
+ .manualstatechange = 0,
+ .userdata = NULL,
};
void simpletest(char *ifname)
{
- int i, j, oloop, iloop, chk;
- needlf = FALSE;
- inOP = FALSE;
+ int i, j, oloop, iloop, chk;
+ needlf = FALSE;
+ inOP = FALSE;
printf("Starting simple test\n");
/* initialise SOEM, bind socket to ifname */
if (ecx_init(&ctx, ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
if (ecx_config_init(&ctx, FALSE) > 0)
{
- printf("%d slaves found and configured.\n",ec_slavecount);
+ printf("%d slaves found and configured.\n", ec_slavecount);
if (forceByteAlignment)
{
printf("Slaves mapped, state to SAFE_OP.\n");
/* wait for all slaves to reach SAFE_OP state */
- ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
+ ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
oloop = ec_slave[0].Obytes;
if ((oloop == 0) && (ec_slave[0].Obits > 0)) oloop = 1;
if ((iloop == 0) && (ec_slave[0].Ibits > 0)) iloop = 1;
if (iloop > 8) iloop = 8;
- printf("segments : %d : %d %d %d %d\n",ec_group[0].nsegments ,ec_group[0].IOsegment[0],ec_group[0].IOsegment[1],ec_group[0].IOsegment[2],ec_group[0].IOsegment[3]);
+ printf("segments : %d : %d %d %d %d\n", ec_group[0].nsegments, ec_group[0].IOsegment[0], ec_group[0].IOsegment[1], ec_group[0].IOsegment[2], ec_group[0].IOsegment[3]);
printf("Request operational state for all slaves\n");
expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
ecx_send_processdata(&ctx);
ecx_receive_processdata(&ctx, EC_TIMEOUTRET);
ecx_statecheck(&ctx, 0, EC_STATE_OPERATIONAL, 50000);
- }
- while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ } while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
inOP = TRUE;
- /* cyclic loop */
- for(i = 1; i <= 10000; i++)
+ /* cyclic loop */
+ for (i = 1; i <= 10000; i++)
{
ecx_send_processdata(&ctx);
wkc = ecx_receive_processdata(&ctx, EC_TIMEOUTRET);
- if(wkc >= expectedWKC)
- {
- printf("Processdata cycle %4d, WKC %d , O:", i, wkc);
-
- for(j = 0 ; j < oloop; j++)
- {
- printf(" %2.2x", *(ec_slave[0].outputs + j));
- }
+ if (wkc >= expectedWKC)
+ {
+ printf("Processdata cycle %4d, WKC %d , O:", i, wkc);
- printf(" I:");
- for(j = 0 ; j < iloop; j++)
- {
- printf(" %2.2x", *(ec_slave[0].inputs + j));
- }
- printf(" T:%"PRId64"\r",ec_DCtime);
- needlf = TRUE;
- }
- osal_usleep(5000);
+ for (j = 0; j < oloop; j++)
+ {
+ printf(" %2.2x", *(ec_slave[0].outputs + j));
+ }
- }
- inOP = FALSE;
+ printf(" I:");
+ for (j = 0; j < iloop; j++)
+ {
+ printf(" %2.2x", *(ec_slave[0].inputs + j));
+ }
+ printf(" T:%" PRId64 "\r", ec_DCtime);
+ needlf = TRUE;
+ }
+ osal_usleep(5000);
}
- else
+ inOP = FALSE;
+ }
+ else
+ {
+ printf("Not all slaves reached operational state.\n");
+ ecx_readstate(&ctx);
+ for (i = 1; i <= ec_slavecount; i++)
{
- printf("Not all slaves reached operational state.\n");
- ecx_readstate(&ctx);
- for(i = 1; i<=ec_slavecount ; i++)
- {
- if(ec_slave[i].state != EC_STATE_OPERATIONAL)
- {
- printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
- i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
- }
- }
+ if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ {
+ printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
+ i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
+ }
}
- printf("\nRequest init state for all slaves\n");
- ec_slave[0].state = EC_STATE_INIT;
- /* request INIT state for all slaves */
- ecx_writestate(&ctx, 0);
- }
- else
- {
- printf("No slaves found!\n");
- }
- printf("End simple test, close socket\n");
- /* stop SOEM, close socket */
- ecx_close(&ctx);
- }
- else
- {
- printf("No socket connection on %s\nExecute as root\n",ifname);
- }
+ }
+ printf("\nRequest init state for all slaves\n");
+ ec_slave[0].state = EC_STATE_INIT;
+ /* request INIT state for all slaves */
+ ecx_writestate(&ctx, 0);
+ }
+ else
+ {
+ printf("No slaves found!\n");
+ }
+ printf("End simple test, close socket\n");
+ /* stop SOEM, close socket */
+ ecx_close(&ctx);
+ }
+ else
+ {
+ printf("No socket connection on %s\nExecute as root\n", ifname);
+ }
}
-OSAL_THREAD_FUNC ecatcheck( void *ptr )
+OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
- int slave;
- (void)ptr; /* Not used */
+ int slave;
+ (void)ptr; /* Not used */
- while(1)
- {
- if( inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
- {
- printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ec_group[currentgroup].docheckstate);
- if (needlf)
- {
- needlf = FALSE;
- printf("\n");
- }
- /* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
- ecx_readstate(&ctx);
- for (slave = 1; slave <= ec_slavecount; slave++)
+ while (1)
+ {
+ if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ {
+ printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ec_group[currentgroup].docheckstate);
+ if (needlf)
+ {
+ needlf = FALSE;
+ printf("\n");
+ }
+ /* one ore more slaves are not responding */
+ ec_group[currentgroup].docheckstate = FALSE;
+ ecx_readstate(&ctx);
+ for (slave = 1; slave <= ec_slavecount; slave++)
+ {
+ if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_group[currentgroup].docheckstate = TRUE;
+ if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
- {
- printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
- ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
- ecx_writestate(&ctx, slave);
- }
- else if(ec_slave[slave].state == EC_STATE_SAFE_OP)
- {
- printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
- ec_slave[slave].state = EC_STATE_OPERATIONAL;
- if(ec_slave[slave].mbxhandlerstate == ECT_MBXH_LOST) ec_slave[slave].mbxhandlerstate = ECT_MBXH_CYCLIC;
- ecx_writestate(&ctx, slave);
- }
- else if(ec_slave[slave].state > EC_STATE_NONE)
- {
- if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n",slave);
- }
- }
- else if(!ec_slave[slave].islost)
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
+ ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ecx_writestate(&ctx, slave);
+ }
+ else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ {
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
+ ec_slave[slave].state = EC_STATE_OPERATIONAL;
+ if (ec_slave[slave].mbxhandlerstate == ECT_MBXH_LOST) ec_slave[slave].mbxhandlerstate = ECT_MBXH_CYCLIC;
+ ecx_writestate(&ctx, slave);
+ }
+ else if (ec_slave[slave].state > EC_STATE_NONE)
+ {
+ if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
{
- /* re-check state */
- ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
- {
- ec_slave[slave].islost = TRUE;
- ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
- /* zero input data for this slave */
- if(ec_slave[slave].Ibytes)
- {
- memset(ec_slave[slave].inputs, 0x00, ec_slave[slave].Ibytes);
- printf("zero inputs %p %d\n\r", ec_slave[slave].inputs, ec_slave[slave].Ibytes);
- }
- printf("ERROR : slave %d lost\n",slave);
- }
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slave);
}
}
- if (ec_slave[slave].islost)
+ else if (!ec_slave[slave].islost)
{
- if(ec_slave[slave].state <= EC_STATE_INIT)
+ /* re-check state */
+ ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (ec_slave[slave].state == EC_STATE_NONE)
{
- if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
+ ec_slave[slave].islost = TRUE;
+ ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
+ /* zero input data for this slave */
+ if (ec_slave[slave].Ibytes)
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n",slave);
+ memset(ec_slave[slave].inputs, 0x00, ec_slave[slave].Ibytes);
+ printf("zero inputs %p %d\n\r", ec_slave[slave].inputs, ec_slave[slave].Ibytes);
}
+ printf("ERROR : slave %d lost\n", slave);
}
- else
+ }
+ }
+ if (ec_slave[slave].islost)
+ {
+ if (ec_slave[slave].state <= EC_STATE_INIT)
+ {
+ if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n",slave);
+ printf("MESSAGE : slave %d recovered\n", slave);
}
}
+ else
+ {
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slave);
+ }
}
- if(!ec_group[currentgroup].docheckstate)
- printf("OK : all slaves resumed OPERATIONAL.\n");
- }
- osal_usleep(10000);
- }
+ }
+ if (!ec_group[currentgroup].docheckstate)
+ printf("OK : all slaves resumed OPERATIONAL.\n");
+ }
+ osal_usleep(10000);
+ }
}
int main(int argc, char *argv[])
}
else
{
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
printf("Usage: simple_test ifname1\nifname = eth0 for example\n");
- printf ("\nAvailable adapters:\n");
- head = adapter = ec_find_adapters ();
+ printf("\nAvailable adapters:\n");
+ head = adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf (" - %s (%s)\n", adapter->name, adapter->desc);
+ printf(" - %s (%s)\n", adapter->name, adapter->desc);
adapter = adapter->next;
}
ec_free_adapters(head);
static ecx_portt ecx_port;
static ec_mbxpoolt ec_mbxpool;
-static ecx_contextt ctx = {
- .port = &ecx_port,
- .slavelist = &ec_slave[0],
- .slavecount = &ec_slavecount,
- .maxslave = EC_MAXSLAVE,
- .grouplist = &ec_group[0],
- .maxgroup = EC_MAXGROUP,
- .esibuf = &ec_esibuf[0],
- .esimap = &ec_esimap[0],
- .esislave = 0,
- .elist = &ec_elist,
- .idxstack = &ec_idxstack,
- .ecaterror = &EcatError,
- .DCtime = &ec_DCtime,
- .SMcommtype = &ec_SMcommtype[0],
- .PDOassign = &ec_PDOassign[0],
- .PDOdesc = &ec_PDOdesc[0],
- .eepSM = &ec_SM,
- .eepFMMU = &ec_FMMU,
- .mbxpool = &ec_mbxpool,
- .FOEhook = NULL,
- .EOEhook = NULL,
- .manualstatechange = 0,
- .userdata = NULL,
+static ecx_contextt ctx = {
+ .port = &ecx_port,
+ .slavelist = &ec_slave[0],
+ .slavecount = &ec_slavecount,
+ .maxslave = EC_MAXSLAVE,
+ .grouplist = &ec_group[0],
+ .maxgroup = EC_MAXGROUP,
+ .esibuf = &ec_esibuf[0],
+ .esimap = &ec_esimap[0],
+ .esislave = 0,
+ .elist = &ec_elist,
+ .idxstack = &ec_idxstack,
+ .ecaterror = &EcatError,
+ .DCtime = &ec_DCtime,
+ .SMcommtype = &ec_SMcommtype[0],
+ .PDOassign = &ec_PDOassign[0],
+ .PDOdesc = &ec_PDOdesc[0],
+ .eepSM = &ec_SM,
+ .eepFMMU = &ec_FMMU,
+ .mbxpool = &ec_mbxpool,
+ .FOEhook = NULL,
+ .EOEhook = NULL,
+ .manualstatechange = 0,
+ .userdata = NULL,
};
-#define OTYPE_VAR 0x0007
-#define OTYPE_ARRAY 0x0008
-#define OTYPE_RECORD 0x0009
+#define OTYPE_VAR 0x0007
+#define OTYPE_ARRAY 0x0008
+#define OTYPE_RECORD 0x0009
-#define ATYPE_Rpre 0x01
-#define ATYPE_Rsafe 0x02
-#define ATYPE_Rop 0x04
-#define ATYPE_Wpre 0x08
-#define ATYPE_Wsafe 0x10
-#define ATYPE_Wop 0x20
+#define ATYPE_Rpre 0x01
+#define ATYPE_Rsafe 0x02
+#define ATYPE_Rop 0x04
+#define ATYPE_Wpre 0x08
+#define ATYPE_Wsafe 0x10
+#define ATYPE_Wop 0x20
-
-char* dtype2string(uint16 dtype, uint16 bitlen)
+char *dtype2string(uint16 dtype, uint16 bitlen)
{
- static char str[32] = { 0 };
-
- switch(dtype)
- {
- case ECT_BOOLEAN:
- sprintf(str, "BOOLEAN");
- break;
- case ECT_INTEGER8:
- sprintf(str, "INTEGER8");
- break;
- case ECT_INTEGER16:
- sprintf(str, "INTEGER16");
- break;
- case ECT_INTEGER32:
- sprintf(str, "INTEGER32");
- break;
- case ECT_INTEGER24:
- sprintf(str, "INTEGER24");
- break;
- case ECT_INTEGER64:
- sprintf(str, "INTEGER64");
- break;
- case ECT_UNSIGNED8:
- sprintf(str, "UNSIGNED8");
- break;
- case ECT_UNSIGNED16:
- sprintf(str, "UNSIGNED16");
- break;
- case ECT_UNSIGNED32:
- sprintf(str, "UNSIGNED32");
- break;
- case ECT_UNSIGNED24:
- sprintf(str, "UNSIGNED24");
- break;
- case ECT_UNSIGNED64:
- sprintf(str, "UNSIGNED64");
- break;
- case ECT_REAL32:
- sprintf(str, "REAL32");
- break;
- case ECT_REAL64:
- sprintf(str, "REAL64");
- break;
- case ECT_BIT1:
- sprintf(str, "BIT1");
- break;
- case ECT_BIT2:
- sprintf(str, "BIT2");
- break;
- case ECT_BIT3:
- sprintf(str, "BIT3");
- break;
- case ECT_BIT4:
- sprintf(str, "BIT4");
- break;
- case ECT_BIT5:
- sprintf(str, "BIT5");
- break;
- case ECT_BIT6:
- sprintf(str, "BIT6");
- break;
- case ECT_BIT7:
- sprintf(str, "BIT7");
- break;
- case ECT_BIT8:
- sprintf(str, "BIT8");
- break;
- case ECT_VISIBLE_STRING:
- sprintf(str, "VISIBLE_STR(%d)", bitlen);
- break;
- case ECT_OCTET_STRING:
- sprintf(str, "OCTET_STR(%d)", bitlen);
- break;
- default:
- sprintf(str, "dt:0x%4.4X (%d)", dtype, bitlen);
- }
- return str;
+ static char str[32] = {0};
+
+ switch (dtype)
+ {
+ case ECT_BOOLEAN:
+ sprintf(str, "BOOLEAN");
+ break;
+ case ECT_INTEGER8:
+ sprintf(str, "INTEGER8");
+ break;
+ case ECT_INTEGER16:
+ sprintf(str, "INTEGER16");
+ break;
+ case ECT_INTEGER32:
+ sprintf(str, "INTEGER32");
+ break;
+ case ECT_INTEGER24:
+ sprintf(str, "INTEGER24");
+ break;
+ case ECT_INTEGER64:
+ sprintf(str, "INTEGER64");
+ break;
+ case ECT_UNSIGNED8:
+ sprintf(str, "UNSIGNED8");
+ break;
+ case ECT_UNSIGNED16:
+ sprintf(str, "UNSIGNED16");
+ break;
+ case ECT_UNSIGNED32:
+ sprintf(str, "UNSIGNED32");
+ break;
+ case ECT_UNSIGNED24:
+ sprintf(str, "UNSIGNED24");
+ break;
+ case ECT_UNSIGNED64:
+ sprintf(str, "UNSIGNED64");
+ break;
+ case ECT_REAL32:
+ sprintf(str, "REAL32");
+ break;
+ case ECT_REAL64:
+ sprintf(str, "REAL64");
+ break;
+ case ECT_BIT1:
+ sprintf(str, "BIT1");
+ break;
+ case ECT_BIT2:
+ sprintf(str, "BIT2");
+ break;
+ case ECT_BIT3:
+ sprintf(str, "BIT3");
+ break;
+ case ECT_BIT4:
+ sprintf(str, "BIT4");
+ break;
+ case ECT_BIT5:
+ sprintf(str, "BIT5");
+ break;
+ case ECT_BIT6:
+ sprintf(str, "BIT6");
+ break;
+ case ECT_BIT7:
+ sprintf(str, "BIT7");
+ break;
+ case ECT_BIT8:
+ sprintf(str, "BIT8");
+ break;
+ case ECT_VISIBLE_STRING:
+ sprintf(str, "VISIBLE_STR(%d)", bitlen);
+ break;
+ case ECT_OCTET_STRING:
+ sprintf(str, "OCTET_STR(%d)", bitlen);
+ break;
+ default:
+ sprintf(str, "dt:0x%4.4X (%d)", dtype, bitlen);
+ }
+ return str;
}
-char* otype2string(uint16 otype)
+char *otype2string(uint16 otype)
{
- static char str[32] = { 0 };
-
- switch(otype)
- {
- case OTYPE_VAR:
- sprintf(str, "VAR");
- break;
- case OTYPE_ARRAY:
- sprintf(str, "ARRAY");
- break;
- case OTYPE_RECORD:
- sprintf(str, "RECORD");
- break;
- default:
- sprintf(str, "ot:0x%4.4X", otype);
- }
- return str;
+ static char str[32] = {0};
+
+ switch (otype)
+ {
+ case OTYPE_VAR:
+ sprintf(str, "VAR");
+ break;
+ case OTYPE_ARRAY:
+ sprintf(str, "ARRAY");
+ break;
+ case OTYPE_RECORD:
+ sprintf(str, "RECORD");
+ break;
+ default:
+ sprintf(str, "ot:0x%4.4X", otype);
+ }
+ return str;
}
-char* access2string(uint16 access)
+char *access2string(uint16 access)
{
- static char str[32] = { 0 };
-
- sprintf(str, "%s%s%s%s%s%s",
- ((access & ATYPE_Rpre) != 0 ? "R" : "_"),
- ((access & ATYPE_Wpre) != 0 ? "W" : "_"),
- ((access & ATYPE_Rsafe) != 0 ? "R" : "_"),
- ((access & ATYPE_Wsafe) != 0 ? "W" : "_"),
- ((access & ATYPE_Rop) != 0 ? "R" : "_"),
- ((access & ATYPE_Wop) != 0 ? "W" : "_"));
- return str;
+ static char str[32] = {0};
+
+ sprintf(str, "%s%s%s%s%s%s",
+ ((access & ATYPE_Rpre) != 0 ? "R" : "_"),
+ ((access & ATYPE_Wpre) != 0 ? "W" : "_"),
+ ((access & ATYPE_Rsafe) != 0 ? "R" : "_"),
+ ((access & ATYPE_Wsafe) != 0 ? "W" : "_"),
+ ((access & ATYPE_Rop) != 0 ? "R" : "_"),
+ ((access & ATYPE_Wop) != 0 ? "W" : "_"));
+ return str;
}
-char* SDO2string(uint16 slave, uint16 index, uint8 subidx, uint16 dtype)
+char *SDO2string(uint16 slave, uint16 index, uint8 subidx, uint16 dtype)
{
int l = sizeof(usdo) - 1, i;
uint8 *u8;
}
else
{
- static char str[64] = { 0 };
- switch(dtype)
+ static char str[64] = {0};
+ switch (dtype)
{
- case ECT_BOOLEAN:
- u8 = (uint8*) &usdo[0];
- if (*u8) sprintf(str, "TRUE");
- else sprintf(str, "FALSE");
- break;
- case ECT_INTEGER8:
- i8 = (int8*) &usdo[0];
- sprintf(str, "0x%2.2x / %d", *i8, *i8);
- break;
- case ECT_INTEGER16:
- i16 = (int16*) &usdo[0];
- sprintf(str, "0x%4.4x / %d", *i16, *i16);
- break;
- case ECT_INTEGER32:
- case ECT_INTEGER24:
- i32 = (int32*) &usdo[0];
- sprintf(str, "0x%8.8x / %d", *i32, *i32);
- break;
- case ECT_INTEGER64:
- i64 = (int64*) &usdo[0];
- sprintf(str, "0x%16.16"PRIx64" / %"PRId64, *i64, *i64);
- break;
- case ECT_UNSIGNED8:
- u8 = (uint8*) &usdo[0];
- sprintf(str, "0x%2.2x / %u", *u8, *u8);
- break;
- case ECT_UNSIGNED16:
- u16 = (uint16*) &usdo[0];
- sprintf(str, "0x%4.4x / %u", *u16, *u16);
- break;
- case ECT_UNSIGNED32:
- case ECT_UNSIGNED24:
- u32 = (uint32*) &usdo[0];
- sprintf(str, "0x%8.8x / %u", *u32, *u32);
- break;
- case ECT_UNSIGNED64:
- u64 = (uint64*) &usdo[0];
- sprintf(str, "0x%16.16"PRIx64" / %"PRIu64, *u64, *u64);
- break;
- case ECT_REAL32:
- sr = (float*) &usdo[0];
- sprintf(str, "%f", *sr);
- break;
- case ECT_REAL64:
- dr = (double*) &usdo[0];
- sprintf(str, "%f", *dr);
- break;
- case ECT_BIT1:
- case ECT_BIT2:
- case ECT_BIT3:
- case ECT_BIT4:
- case ECT_BIT5:
- case ECT_BIT6:
- case ECT_BIT7:
- case ECT_BIT8:
- u8 = (uint8*) &usdo[0];
- sprintf(str, "0x%x / %u", *u8, *u8);
- break;
- case ECT_VISIBLE_STRING:
- strcpy(str, "\"");
- strcat(str, usdo);
- strcat(str, "\"");
- break;
- case ECT_OCTET_STRING:
- str[0] = 0x00;
- for (i = 0 ; i < l ; i++)
- {
- sprintf(es, "0x%2.2x ", usdo[i]);
- strcat( str, es);
- }
- break;
- default:
- sprintf(str, "Unknown type");
+ case ECT_BOOLEAN:
+ u8 = (uint8 *)&usdo[0];
+ if (*u8)
+ sprintf(str, "TRUE");
+ else
+ sprintf(str, "FALSE");
+ break;
+ case ECT_INTEGER8:
+ i8 = (int8 *)&usdo[0];
+ sprintf(str, "0x%2.2x / %d", *i8, *i8);
+ break;
+ case ECT_INTEGER16:
+ i16 = (int16 *)&usdo[0];
+ sprintf(str, "0x%4.4x / %d", *i16, *i16);
+ break;
+ case ECT_INTEGER32:
+ case ECT_INTEGER24:
+ i32 = (int32 *)&usdo[0];
+ sprintf(str, "0x%8.8x / %d", *i32, *i32);
+ break;
+ case ECT_INTEGER64:
+ i64 = (int64 *)&usdo[0];
+ sprintf(str, "0x%16.16" PRIx64 " / %" PRId64, *i64, *i64);
+ break;
+ case ECT_UNSIGNED8:
+ u8 = (uint8 *)&usdo[0];
+ sprintf(str, "0x%2.2x / %u", *u8, *u8);
+ break;
+ case ECT_UNSIGNED16:
+ u16 = (uint16 *)&usdo[0];
+ sprintf(str, "0x%4.4x / %u", *u16, *u16);
+ break;
+ case ECT_UNSIGNED32:
+ case ECT_UNSIGNED24:
+ u32 = (uint32 *)&usdo[0];
+ sprintf(str, "0x%8.8x / %u", *u32, *u32);
+ break;
+ case ECT_UNSIGNED64:
+ u64 = (uint64 *)&usdo[0];
+ sprintf(str, "0x%16.16" PRIx64 " / %" PRIu64, *u64, *u64);
+ break;
+ case ECT_REAL32:
+ sr = (float *)&usdo[0];
+ sprintf(str, "%f", *sr);
+ break;
+ case ECT_REAL64:
+ dr = (double *)&usdo[0];
+ sprintf(str, "%f", *dr);
+ break;
+ case ECT_BIT1:
+ case ECT_BIT2:
+ case ECT_BIT3:
+ case ECT_BIT4:
+ case ECT_BIT5:
+ case ECT_BIT6:
+ case ECT_BIT7:
+ case ECT_BIT8:
+ u8 = (uint8 *)&usdo[0];
+ sprintf(str, "0x%x / %u", *u8, *u8);
+ break;
+ case ECT_VISIBLE_STRING:
+ strcpy(str, "\"");
+ strcat(str, usdo);
+ strcat(str, "\"");
+ break;
+ case ECT_OCTET_STRING:
+ str[0] = 0x00;
+ for (i = 0; i < l; i++)
+ {
+ sprintf(es, "0x%2.2x ", usdo[i]);
+ strcat(str, es);
+ }
+ break;
+ default:
+ sprintf(str, "Unknown type");
}
return str;
}
/** Read PDO assign structure */
int si_PDOassign(uint16 slave, uint16 PDOassign, int mapoffset, int bitoffset)
{
- uint16 idxloop, nidx, subidxloop, rdat, idx, subidx;
- uint8 subcnt;
- int wkc, bsize = 0, rdl;
- int32 rdat2;
- uint8 bitlen, obj_subidx;
- uint16 obj_idx;
- int abs_offset, abs_bit;
-
- rdl = sizeof(rdat); rdat = 0;
- /* read PDO assign subindex 0 ( = number of PDO's) */
- wkc = ecx_SDOread(&ctx, slave, PDOassign, 0x00, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
- rdat = etohs(rdat);
- /* positive result from slave ? */
- if ((wkc > 0) && (rdat > 0))
- {
- /* number of available sub indexes */
- nidx = rdat;
- bsize = 0;
- /* read all PDO's */
- for (idxloop = 1; idxloop <= nidx; idxloop++)
- {
- rdl = sizeof(rdat); rdat = 0;
- /* read PDO assign */
- wkc = ecx_SDOread(&ctx, slave, PDOassign, (uint8)idxloop, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
- /* result is index of PDO */
- idx = etohs(rdat);
- if (idx > 0)
+ uint16 idxloop, nidx, subidxloop, rdat, idx, subidx;
+ uint8 subcnt;
+ int wkc, bsize = 0, rdl;
+ int32 rdat2;
+ uint8 bitlen, obj_subidx;
+ uint16 obj_idx;
+ int abs_offset, abs_bit;
+
+ rdl = sizeof(rdat);
+ rdat = 0;
+ /* read PDO assign subindex 0 ( = number of PDO's) */
+ wkc = ecx_SDOread(&ctx, slave, PDOassign, 0x00, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
+ rdat = etohs(rdat);
+ /* positive result from slave ? */
+ if ((wkc > 0) && (rdat > 0))
+ {
+ /* number of available sub indexes */
+ nidx = rdat;
+ bsize = 0;
+ /* read all PDO's */
+ for (idxloop = 1; idxloop <= nidx; idxloop++)
+ {
+ rdl = sizeof(rdat);
+ rdat = 0;
+ /* read PDO assign */
+ wkc = ecx_SDOread(&ctx, slave, PDOassign, (uint8)idxloop, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
+ /* result is index of PDO */
+ idx = etohs(rdat);
+ if (idx > 0)
+ {
+ rdl = sizeof(subcnt);
+ subcnt = 0;
+ /* read number of subindexes of PDO */
+ wkc = ecx_SDOread(&ctx, slave, idx, 0x00, FALSE, &rdl, &subcnt, EC_TIMEOUTRXM);
+ subidx = subcnt;
+ /* for each subindex */
+ for (subidxloop = 1; subidxloop <= subidx; subidxloop++)
{
- rdl = sizeof(subcnt); subcnt = 0;
- /* read number of subindexes of PDO */
- wkc = ecx_SDOread(&ctx, slave,idx, 0x00, FALSE, &rdl, &subcnt, EC_TIMEOUTRXM);
- subidx = subcnt;
- /* for each subindex */
- for (subidxloop = 1; subidxloop <= subidx; subidxloop++)
- {
- rdl = sizeof(rdat2); rdat2 = 0;
- /* read SDO that is mapped in PDO */
- wkc = ecx_SDOread(&ctx, slave, idx, (uint8)subidxloop, FALSE, &rdl, &rdat2, EC_TIMEOUTRXM);
- rdat2 = etohl(rdat2);
- /* extract bitlength of SDO */
- bitlen = LO_BYTE(rdat2);
- bsize += bitlen;
- obj_idx = (uint16)(rdat2 >> 16);
- obj_subidx = (uint8)((rdat2 >> 8) & 0x000000ff);
- abs_offset = mapoffset + (bitoffset / 8);
- abs_bit = bitoffset % 8;
- ODlist.Slave = slave;
- ODlist.Index[0] = obj_idx;
- OElist.Entries = 0;
- wkc = 0;
- /* read object entry from dictionary if not a filler (0x0000:0x00) */
- if(obj_idx || obj_subidx)
- wkc = ecx_readOEsingle(&ctx, 0, obj_subidx, &ODlist, &OElist);
- printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
- if((wkc > 0) && OElist.Entries)
- {
- printf(" %-12s %s\n", dtype2string(OElist.DataType[obj_subidx], bitlen), OElist.Name[obj_subidx]);
- }
- else
- printf("\n");
- bitoffset += bitlen;
- };
+ rdl = sizeof(rdat2);
+ rdat2 = 0;
+ /* read SDO that is mapped in PDO */
+ wkc = ecx_SDOread(&ctx, slave, idx, (uint8)subidxloop, FALSE, &rdl, &rdat2, EC_TIMEOUTRXM);
+ rdat2 = etohl(rdat2);
+ /* extract bitlength of SDO */
+ bitlen = LO_BYTE(rdat2);
+ bsize += bitlen;
+ obj_idx = (uint16)(rdat2 >> 16);
+ obj_subidx = (uint8)((rdat2 >> 8) & 0x000000ff);
+ abs_offset = mapoffset + (bitoffset / 8);
+ abs_bit = bitoffset % 8;
+ ODlist.Slave = slave;
+ ODlist.Index[0] = obj_idx;
+ OElist.Entries = 0;
+ wkc = 0;
+ /* read object entry from dictionary if not a filler (0x0000:0x00) */
+ if (obj_idx || obj_subidx)
+ wkc = ecx_readOEsingle(&ctx, 0, obj_subidx, &ODlist, &OElist);
+ printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
+ if ((wkc > 0) && OElist.Entries)
+ {
+ printf(" %-12s %s\n", dtype2string(OElist.DataType[obj_subidx], bitlen), OElist.Name[obj_subidx]);
+ }
+ else
+ printf("\n");
+ bitoffset += bitlen;
};
- };
- };
- /* return total found bitlength (PDO) */
- return bsize;
+ };
+ };
+ };
+ /* return total found bitlength (PDO) */
+ return bsize;
}
int si_map_sdo(int slave)
{
- int wkc, rdl;
- int retVal = 0;
- uint8 nSM, iSM, tSM;
- int Tsize, outputs_bo, inputs_bo;
- uint8 SMt_bug_add;
-
- printf("PDO mapping according to CoE :\n");
- SMt_bug_add = 0;
- outputs_bo = 0;
- inputs_bo = 0;
- rdl = sizeof(nSM); nSM = 0;
- /* read SyncManager Communication Type object count */
- wkc = ecx_SDOread(&ctx, slave, ECT_SDO_SMCOMMTYPE, 0x00, FALSE, &rdl, &nSM, EC_TIMEOUTRXM);
- /* positive result from slave ? */
- if ((wkc > 0) && (nSM > 2))
- {
- /* make nSM equal to number of defined SM */
- nSM--;
- /* limit to maximum number of SM defined, if true the slave can't be configured */
- if (nSM > EC_MAXSM)
- nSM = EC_MAXSM;
- /* iterate for every SM type defined */
- for (iSM = 2 ; iSM <= nSM ; iSM++)
- {
- rdl = sizeof(tSM); tSM = 0;
- /* read SyncManager Communication Type */
- wkc = ecx_SDOread(&ctx, slave, ECT_SDO_SMCOMMTYPE, iSM + 1, FALSE, &rdl, &tSM, EC_TIMEOUTRXM);
- if (wkc > 0)
+ int wkc, rdl;
+ int retVal = 0;
+ uint8 nSM, iSM, tSM;
+ int Tsize, outputs_bo, inputs_bo;
+ uint8 SMt_bug_add;
+
+ printf("PDO mapping according to CoE :\n");
+ SMt_bug_add = 0;
+ outputs_bo = 0;
+ inputs_bo = 0;
+ rdl = sizeof(nSM);
+ nSM = 0;
+ /* read SyncManager Communication Type object count */
+ wkc = ecx_SDOread(&ctx, slave, ECT_SDO_SMCOMMTYPE, 0x00, FALSE, &rdl, &nSM, EC_TIMEOUTRXM);
+ /* positive result from slave ? */
+ if ((wkc > 0) && (nSM > 2))
+ {
+ /* make nSM equal to number of defined SM */
+ nSM--;
+ /* limit to maximum number of SM defined, if true the slave can't be configured */
+ if (nSM > EC_MAXSM)
+ nSM = EC_MAXSM;
+ /* iterate for every SM type defined */
+ for (iSM = 2; iSM <= nSM; iSM++)
+ {
+ rdl = sizeof(tSM);
+ tSM = 0;
+ /* read SyncManager Communication Type */
+ wkc = ecx_SDOread(&ctx, slave, ECT_SDO_SMCOMMTYPE, iSM + 1, FALSE, &rdl, &tSM, EC_TIMEOUTRXM);
+ if (wkc > 0)
+ {
+ if ((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
{
- if((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
- {
- SMt_bug_add = 1; // try to correct, this works if the types are 0 1 2 3 and should be 1 2 3 4
- printf("Activated SM type workaround, possible incorrect mapping.\n");
- }
- if(tSM)
- tSM += SMt_bug_add; // only add if SMt > 0
-
- if (tSM == 3) // outputs
- {
- /* read the assign RXPDO */
- printf(" SM%1d outputs\n addr b index: sub bitl data_type name\n", iSM);
- Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap[0]), outputs_bo );
- outputs_bo += Tsize;
- }
- if (tSM == 4) // inputs
- {
- /* read the assign TXPDO */
- printf(" SM%1d inputs\n addr b index: sub bitl data_type name\n", iSM);
- Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap[0]), inputs_bo );
- inputs_bo += Tsize;
- }
+ SMt_bug_add = 1; // try to correct, this works if the types are 0 1 2 3 and should be 1 2 3 4
+ printf("Activated SM type workaround, possible incorrect mapping.\n");
}
- }
- }
+ if (tSM)
+ tSM += SMt_bug_add; // only add if SMt > 0
- /* found some I/O bits ? */
- if ((outputs_bo > 0) || (inputs_bo > 0))
- retVal = 1;
- return retVal;
+ if (tSM == 3) // outputs
+ {
+ /* read the assign RXPDO */
+ printf(" SM%1d outputs\n addr b index: sub bitl data_type name\n", iSM);
+ Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap[0]), outputs_bo);
+ outputs_bo += Tsize;
+ }
+ if (tSM == 4) // inputs
+ {
+ /* read the assign TXPDO */
+ printf(" SM%1d inputs\n addr b index: sub bitl data_type name\n", iSM);
+ Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap[0]), inputs_bo);
+ inputs_bo += Tsize;
+ }
+ }
+ }
+ }
+
+ /* found some I/O bits ? */
+ if ((outputs_bo > 0) || (inputs_bo > 0))
+ retVal = 1;
+ return retVal;
}
int si_siiPDO(uint16 slave, uint8 t, int mapoffset, int bitoffset)
{
- uint16 a , w, c, e, er;
- uint8 eectl;
- uint16 obj_idx;
- uint8 obj_subidx;
- uint8 obj_name;
- uint8 obj_datatype;
- uint8 bitlen;
- int totalsize;
- ec_eepromPDOt eepPDO;
- ec_eepromPDOt *PDO;
- int abs_offset, abs_bit;
- char str_name[EC_MAXNAME + 1];
-
- eectl = ec_slave[slave].eep_pdi;
-
- totalsize = 0;
- PDO = &eepPDO;
- PDO->nPDO = 0;
- PDO->Length = 0;
- PDO->Index[1] = 0;
- for (c = 0 ; c < EC_MAXSM ; c++) PDO->SMbitsize[c] = 0;
- if (t > 1)
- t = 1;
- PDO->Startpos = ecx_siifind(&ctx, slave, ECT_SII_PDO + t);
- if (PDO->Startpos > 0)
- {
- a = PDO->Startpos;
- w = ecx_siigetbyte(&ctx, slave, a++);
- w += (ecx_siigetbyte(&ctx, slave, a++) << 8);
- PDO->Length = w;
- c = 1;
- /* traverse through all PDOs */
- do
- {
- PDO->nPDO++;
- PDO->Index[PDO->nPDO] = ecx_siigetbyte(&ctx, slave, a++);
- PDO->Index[PDO->nPDO] += (ecx_siigetbyte(&ctx, slave, a++) << 8);
- PDO->BitSize[PDO->nPDO] = 0;
- c++;
- /* number of entries in PDO */
- e = ecx_siigetbyte(&ctx, slave, a++);
- PDO->SyncM[PDO->nPDO] = ecx_siigetbyte(&ctx, slave, a++);
- a++;
- obj_name = ecx_siigetbyte(&ctx, slave, a++);
- a += 2;
- c += 2;
- if (PDO->SyncM[PDO->nPDO] < EC_MAXSM) /* active and in range SM? */
- {
- str_name[0] = 0;
- if(obj_name)
- ecx_siistring(&ctx, str_name, slave, obj_name);
- if (t)
- printf(" SM%1d RXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
- else
- printf(" SM%1d TXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
- printf(" addr b index: sub bitl data_type name\n");
- /* read all entries defined in PDO */
- for (er = 1; er <= e; er++)
- {
- c += 4;
- obj_idx = ecx_siigetbyte(&ctx, slave, a++);
- obj_idx += (ecx_siigetbyte(&ctx, slave, a++) << 8);
- obj_subidx = ecx_siigetbyte(&ctx, slave, a++);
- obj_name = ecx_siigetbyte(&ctx, slave, a++);
- obj_datatype = ecx_siigetbyte(&ctx, slave, a++);
- bitlen = ecx_siigetbyte(&ctx, slave, a++);
- abs_offset = mapoffset + (bitoffset / 8);
- abs_bit = bitoffset % 8;
-
- PDO->BitSize[PDO->nPDO] += bitlen;
- a += 2;
-
- /* skip entry if filler (0x0000:0x00) */
- if(obj_idx || obj_subidx)
- {
- str_name[0] = 0;
- if(obj_name)
- ecx_siistring(&ctx, str_name, slave, obj_name);
-
- printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
- printf(" %-12s %s\n", dtype2string(obj_datatype, bitlen), str_name);
- }
- bitoffset += bitlen;
- totalsize += bitlen;
- }
- PDO->SMbitsize[ PDO->SyncM[PDO->nPDO] ] += PDO->BitSize[PDO->nPDO];
- c++;
- }
- else /* PDO deactivated because SM is 0xff or > EC_MAXSM */
+ uint16 a, w, c, e, er;
+ uint8 eectl;
+ uint16 obj_idx;
+ uint8 obj_subidx;
+ uint8 obj_name;
+ uint8 obj_datatype;
+ uint8 bitlen;
+ int totalsize;
+ ec_eepromPDOt eepPDO;
+ ec_eepromPDOt *PDO;
+ int abs_offset, abs_bit;
+ char str_name[EC_MAXNAME + 1];
+
+ eectl = ec_slave[slave].eep_pdi;
+
+ totalsize = 0;
+ PDO = &eepPDO;
+ PDO->nPDO = 0;
+ PDO->Length = 0;
+ PDO->Index[1] = 0;
+ for (c = 0; c < EC_MAXSM; c++)
+ PDO->SMbitsize[c] = 0;
+ if (t > 1)
+ t = 1;
+ PDO->Startpos = ecx_siifind(&ctx, slave, ECT_SII_PDO + t);
+ if (PDO->Startpos > 0)
+ {
+ a = PDO->Startpos;
+ w = ecx_siigetbyte(&ctx, slave, a++);
+ w += (ecx_siigetbyte(&ctx, slave, a++) << 8);
+ PDO->Length = w;
+ c = 1;
+ /* traverse through all PDOs */
+ do
+ {
+ PDO->nPDO++;
+ PDO->Index[PDO->nPDO] = ecx_siigetbyte(&ctx, slave, a++);
+ PDO->Index[PDO->nPDO] += (ecx_siigetbyte(&ctx, slave, a++) << 8);
+ PDO->BitSize[PDO->nPDO] = 0;
+ c++;
+ /* number of entries in PDO */
+ e = ecx_siigetbyte(&ctx, slave, a++);
+ PDO->SyncM[PDO->nPDO] = ecx_siigetbyte(&ctx, slave, a++);
+ a++;
+ obj_name = ecx_siigetbyte(&ctx, slave, a++);
+ a += 2;
+ c += 2;
+ if (PDO->SyncM[PDO->nPDO] < EC_MAXSM) /* active and in range SM? */
+ {
+ str_name[0] = 0;
+ if (obj_name)
+ ecx_siistring(&ctx, str_name, slave, obj_name);
+ if (t)
+ printf(" SM%1d RXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
+ else
+ printf(" SM%1d TXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
+ printf(" addr b index: sub bitl data_type name\n");
+ /* read all entries defined in PDO */
+ for (er = 1; er <= e; er++)
{
- c += 4 * e;
- a += 8 * e;
- c++;
+ c += 4;
+ obj_idx = ecx_siigetbyte(&ctx, slave, a++);
+ obj_idx += (ecx_siigetbyte(&ctx, slave, a++) << 8);
+ obj_subidx = ecx_siigetbyte(&ctx, slave, a++);
+ obj_name = ecx_siigetbyte(&ctx, slave, a++);
+ obj_datatype = ecx_siigetbyte(&ctx, slave, a++);
+ bitlen = ecx_siigetbyte(&ctx, slave, a++);
+ abs_offset = mapoffset + (bitoffset / 8);
+ abs_bit = bitoffset % 8;
+
+ PDO->BitSize[PDO->nPDO] += bitlen;
+ a += 2;
+
+ /* skip entry if filler (0x0000:0x00) */
+ if (obj_idx || obj_subidx)
+ {
+ str_name[0] = 0;
+ if (obj_name)
+ ecx_siistring(&ctx, str_name, slave, obj_name);
+
+ printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
+ printf(" %-12s %s\n", dtype2string(obj_datatype, bitlen), str_name);
+ }
+ bitoffset += bitlen;
+ totalsize += bitlen;
}
- if (PDO->nPDO >= (EC_MAXEEPDO - 1)) c = PDO->Length; /* limit number of PDO entries in buffer */
- }
- while (c < PDO->Length);
- }
- if (eectl) ecx_eeprom2pdi(&ctx, slave); /* if eeprom control was previously pdi then restore */
- return totalsize;
+ PDO->SMbitsize[PDO->SyncM[PDO->nPDO]] += PDO->BitSize[PDO->nPDO];
+ c++;
+ }
+ else /* PDO deactivated because SM is 0xff or > EC_MAXSM */
+ {
+ c += 4 * e;
+ a += 8 * e;
+ c++;
+ }
+ if (PDO->nPDO >= (EC_MAXEEPDO - 1)) c = PDO->Length; /* limit number of PDO entries in buffer */
+ } while (c < PDO->Length);
+ }
+ if (eectl) ecx_eeprom2pdi(&ctx, slave); /* if eeprom control was previously pdi then restore */
+ return totalsize;
}
-
int si_map_sii(int slave)
{
- int retVal = 0;
- int Tsize, outputs_bo, inputs_bo;
-
- printf("PDO mapping according to SII :\n");
-
- outputs_bo = 0;
- inputs_bo = 0;
- /* read the assign RXPDOs */
- Tsize = si_siiPDO(slave, 1, (int)(ec_slave[slave].outputs - (uint8*)&IOmap), outputs_bo );
- outputs_bo += Tsize;
- /* read the assign TXPDOs */
- Tsize = si_siiPDO(slave, 0, (int)(ec_slave[slave].inputs - (uint8*)&IOmap), inputs_bo );
- inputs_bo += Tsize;
- /* found some I/O bits ? */
- if ((outputs_bo > 0) || (inputs_bo > 0))
- retVal = 1;
- return retVal;
+ int retVal = 0;
+ int Tsize, outputs_bo, inputs_bo;
+
+ printf("PDO mapping according to SII :\n");
+
+ outputs_bo = 0;
+ inputs_bo = 0;
+ /* read the assign RXPDOs */
+ Tsize = si_siiPDO(slave, 1, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap), outputs_bo);
+ outputs_bo += Tsize;
+ /* read the assign TXPDOs */
+ Tsize = si_siiPDO(slave, 0, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap), inputs_bo);
+ inputs_bo += Tsize;
+ /* found some I/O bits ? */
+ if ((outputs_bo > 0) || (inputs_bo > 0))
+ retVal = 1;
+ return retVal;
}
void si_sdo(int cnt)
{
- int i, j;
-
- ODlist.Entries = 0;
- memset(&ODlist, 0, sizeof(ODlist));
- if( ecx_readODlist(&ctx, cnt, &ODlist))
- {
- printf(" CoE Object Description found, %d entries.\n",ODlist.Entries);
- for( i = 0 ; i < ODlist.Entries ; i++)
- {
- uint16_t max_sub;
- char name[128] = { 0 };
-
- ecx_readODdescription(&ctx, i, &ODlist);
- while(EcatError) printf(" - %s\n", ecx_elist2string(&ctx));
- snprintf(name, sizeof(name) - 1, "\"%s\"", ODlist.Name[i]);
- if (ODlist.ObjectCode[i] == OTYPE_VAR)
- {
- printf("0x%04x %-40s [%s]\n", ODlist.Index[i], name,
- otype2string(ODlist.ObjectCode[i]));
- }
- else
- {
- printf("0x%04x %-40s [%s maxsub(0x%02x / %d)]\n",
- ODlist.Index[i], name, otype2string(ODlist.ObjectCode[i]),
- ODlist.MaxSub[i], ODlist.MaxSub[i]);
- }
- memset(&OElist, 0, sizeof(OElist));
- ecx_readOE(&ctx, i, &ODlist, &OElist);
- while(EcatError) printf("- %s\n", ecx_elist2string(&ctx));
+ int i, j;
- if(ODlist.ObjectCode[i] != OTYPE_VAR)
- {
- int l = sizeof(max_sub);
- ecx_SDOread(&ctx, cnt, ODlist.Index[i], 0, FALSE, &l, &max_sub, EC_TIMEOUTRXM);
- }
- else {
- max_sub = ODlist.MaxSub[i];
- }
+ ODlist.Entries = 0;
+ memset(&ODlist, 0, sizeof(ODlist));
+ if (ecx_readODlist(&ctx, cnt, &ODlist))
+ {
+ printf(" CoE Object Description found, %d entries.\n", ODlist.Entries);
+ for (i = 0; i < ODlist.Entries; i++)
+ {
+ uint16_t max_sub;
+ char name[128] = {0};
+
+ ecx_readODdescription(&ctx, i, &ODlist);
+ while (EcatError)
+ printf(" - %s\n", ecx_elist2string(&ctx));
+ snprintf(name, sizeof(name) - 1, "\"%s\"", ODlist.Name[i]);
+ if (ODlist.ObjectCode[i] == OTYPE_VAR)
+ {
+ printf("0x%04x %-40s [%s]\n", ODlist.Index[i], name,
+ otype2string(ODlist.ObjectCode[i]));
+ }
+ else
+ {
+ printf("0x%04x %-40s [%s maxsub(0x%02x / %d)]\n",
+ ODlist.Index[i], name, otype2string(ODlist.ObjectCode[i]),
+ ODlist.MaxSub[i], ODlist.MaxSub[i]);
+ }
+ memset(&OElist, 0, sizeof(OElist));
+ ecx_readOE(&ctx, i, &ODlist, &OElist);
+ while (EcatError)
+ printf("- %s\n", ecx_elist2string(&ctx));
+
+ if (ODlist.ObjectCode[i] != OTYPE_VAR)
+ {
+ int l = sizeof(max_sub);
+ ecx_SDOread(&ctx, cnt, ODlist.Index[i], 0, FALSE, &l, &max_sub, EC_TIMEOUTRXM);
+ }
+ else
+ {
+ max_sub = ODlist.MaxSub[i];
+ }
- for( j = 0 ; j < max_sub+1 ; j++)
+ for (j = 0; j < max_sub + 1; j++)
+ {
+ if ((OElist.DataType[j] > 0) && (OElist.BitLength[j] > 0))
{
- if ((OElist.DataType[j] > 0) && (OElist.BitLength[j] > 0))
- {
- snprintf(name, sizeof(name) - 1, "\"%s\"", OElist.Name[j]);
- printf(" 0x%02x %-40s [%-16s %6s] ", j, name,
- dtype2string(OElist.DataType[j], OElist.BitLength[j]),
- access2string(OElist.ObjAccess[j]));
- if ((OElist.ObjAccess[j] & 0x0007))
- {
- printf("%s", SDO2string(cnt, ODlist.Index[i], j, OElist.DataType[j]));
- }
- printf("\n");
- }
+ snprintf(name, sizeof(name) - 1, "\"%s\"", OElist.Name[j]);
+ printf(" 0x%02x %-40s [%-16s %6s] ", j, name,
+ dtype2string(OElist.DataType[j], OElist.BitLength[j]),
+ access2string(OElist.ObjAccess[j]));
+ if ((OElist.ObjAccess[j] & 0x0007))
+ {
+ printf("%s", SDO2string(cnt, ODlist.Index[i], j, OElist.DataType[j]));
+ }
+ printf("\n");
}
- }
- }
- else
- {
- while(EcatError) printf("%s", ecx_elist2string(&ctx));
- }
+ }
+ }
+ }
+ else
+ {
+ while (EcatError)
+ printf("%s", ecx_elist2string(&ctx));
+ }
}
void slaveinfo(char *ifname)
{
int cnt, i, j, nSM;
- uint16 ssigen;
- int expectedWKC;
+ uint16 ssigen;
+ int expectedWKC;
printf("Starting slaveinfo\n");
/* initialise SOEM, bind socket to ifname */
if (ecx_init(&ctx, ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
if (ecx_config_init(&ctx, FALSE) > 0)
}
ecx_configdc(&ctx);
- while(EcatError) printf("%s", ecx_elist2string(&ctx));
- printf("%d slaves found and configured.\n",ec_slavecount);
+ while (EcatError)
+ printf("%s", ecx_elist2string(&ctx));
+ printf("%d slaves found and configured.\n", ec_slavecount);
expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC);
/* wait for all slaves to reach SAFE_OP state */
- ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 3);
- if (ec_slave[0].state != EC_STATE_SAFE_OP )
+ ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 3);
+ if (ec_slave[0].state != EC_STATE_SAFE_OP)
{
printf("Not all slaves reached safe operational state.\n");
ecx_readstate(&ctx);
- for(i = 1; i<=ec_slavecount ; i++)
+ for (i = 1; i <= ec_slavecount; i++)
{
- if(ec_slave[i].state != EC_STATE_SAFE_OP)
+ if (ec_slave[i].state != EC_STATE_SAFE_OP)
{
printf("Slave %d State=%2x StatusCode=%4x : %s\n",
- i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
+ i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
}
}
}
-
ecx_readstate(&ctx);
- for( cnt = 1 ; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
printf("\nSlave:%d\n Name:%s\n Output size: %dbits\n Input size: %dbits\n State: %d\n Delay: %d[ns]\n Has DC: %d\n",
- cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
- ec_slave[cnt].state, ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
+ cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
+ ec_slave[cnt].state, ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
if (ec_slave[cnt].hasdc) printf(" DCParentport:%d\n", ec_slave[cnt].parentport);
- printf(" Activeports:%d.%d.%d.%d\n", (ec_slave[cnt].activeports & 0x01) > 0 ,
- (ec_slave[cnt].activeports & 0x02) > 0 ,
- (ec_slave[cnt].activeports & 0x04) > 0 ,
- (ec_slave[cnt].activeports & 0x08) > 0 );
+ printf(" Activeports:%d.%d.%d.%d\n", (ec_slave[cnt].activeports & 0x01) > 0,
+ (ec_slave[cnt].activeports & 0x02) > 0,
+ (ec_slave[cnt].activeports & 0x04) > 0,
+ (ec_slave[cnt].activeports & 0x08) > 0);
printf(" Configured address: %4.4x\n", ec_slave[cnt].configadr);
printf(" Man: %8.8x ID: %8.8x Rev: %8.8x\n", (int)ec_slave[cnt].eep_man, (int)ec_slave[cnt].eep_id, (int)ec_slave[cnt].eep_rev);
- for(nSM = 0 ; nSM < EC_MAXSM ; nSM++)
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
- if(ec_slave[cnt].SM[nSM].StartAddr > 0)
- printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n",nSM, etohs(ec_slave[cnt].SM[nSM].StartAddr), etohs(ec_slave[cnt].SM[nSM].SMlength),
+ if (ec_slave[cnt].SM[nSM].StartAddr > 0)
+ printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n", nSM, etohs(ec_slave[cnt].SM[nSM].StartAddr), etohs(ec_slave[cnt].SM[nSM].SMlength),
etohl(ec_slave[cnt].SM[nSM].SMflags), ec_slave[cnt].SMtype[nSM]);
}
- for(j = 0 ; j < ec_slave[cnt].FMMUunused ; j++)
+ for (j = 0; j < ec_slave[cnt].FMMUunused; j++)
{
printf(" FMMU%1d Ls:%8.8x Ll:%4d Lsb:%d Leb:%d Ps:%4.4x Psb:%d Ty:%2.2x Act:%2.2x\n", j,
- etohl(ec_slave[cnt].FMMU[j].LogStart), etohs(ec_slave[cnt].FMMU[j].LogLength), ec_slave[cnt].FMMU[j].LogStartbit,
- ec_slave[cnt].FMMU[j].LogEndbit, etohs(ec_slave[cnt].FMMU[j].PhysStart), ec_slave[cnt].FMMU[j].PhysStartBit,
- ec_slave[cnt].FMMU[j].FMMUtype, ec_slave[cnt].FMMU[j].FMMUactive);
+ etohl(ec_slave[cnt].FMMU[j].LogStart), etohs(ec_slave[cnt].FMMU[j].LogLength), ec_slave[cnt].FMMU[j].LogStartbit,
+ ec_slave[cnt].FMMU[j].LogEndbit, etohs(ec_slave[cnt].FMMU[j].PhysStart), ec_slave[cnt].FMMU[j].PhysStartBit,
+ ec_slave[cnt].FMMU[j].FMMUtype, ec_slave[cnt].FMMU[j].FMMUactive);
}
printf(" FMMUfunc 0:%d 1:%d 2:%d 3:%d\n",
- ec_slave[cnt].FMMU0func, ec_slave[cnt].FMMU1func, ec_slave[cnt].FMMU2func, ec_slave[cnt].FMMU3func);
+ ec_slave[cnt].FMMU0func, ec_slave[cnt].FMMU1func, ec_slave[cnt].FMMU2func, ec_slave[cnt].FMMU3func);
printf(" MBX length wr: %d rd: %d MBX protocols : %2.2x\n", ec_slave[cnt].mbx_l, ec_slave[cnt].mbx_rl, ec_slave[cnt].mbx_proto);
ssigen = ecx_siifind(&ctx, cnt, ECT_SII_GENERAL);
/* SII general section */
ec_slave[cnt].FoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x08);
ec_slave[cnt].EoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x09);
ec_slave[cnt].SoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x0a);
- if((ecx_siigetbyte(&ctx, cnt, ssigen + 0x0d) & 0x02) > 0)
+ if ((ecx_siigetbyte(&ctx, cnt, ssigen + 0x0d) & 0x02) > 0)
{
ec_slave[cnt].blockLRW = 1;
ec_slave[0].blockLRW++;
ec_slave[0].Ebuscurrent += ec_slave[cnt].Ebuscurrent;
}
printf(" CoE details: %2.2x FoE details: %2.2x EoE details: %2.2x SoE details: %2.2x\n",
- ec_slave[cnt].CoEdetails, ec_slave[cnt].FoEdetails, ec_slave[cnt].EoEdetails, ec_slave[cnt].SoEdetails);
+ ec_slave[cnt].CoEdetails, ec_slave[cnt].FoEdetails, ec_slave[cnt].EoEdetails, ec_slave[cnt].SoEdetails);
printf(" Ebus current: %d[mA]\n only LRD/LWR:%d\n",
- ec_slave[cnt].Ebuscurrent, ec_slave[cnt].blockLRW);
+ ec_slave[cnt].Ebuscurrent, ec_slave[cnt].blockLRW);
if ((ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE) && printSDO)
- si_sdo(cnt);
- if(printMAP)
+ si_sdo(cnt);
+ if (printMAP)
{
- if (ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE)
- si_map_sdo(cnt);
- else
- si_map_sii(cnt);
+ if (ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE)
+ si_map_sdo(cnt);
+ else
+ si_map_sii(cnt);
}
}
}
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
int main(int argc, char *argv[])
{
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
printf("SOEM (Simple Open EtherCAT Master)\nSlaveinfo\n");
if (argc > 1)
{
printf("Usage: slaveinfo ifname [options]\nifname = eth0 for example\nOptions :\n -sdo : print SDO info\n -map : print mapping\n");
- printf ("Available adapters\n");
- head = adapter = ec_find_adapters ();
+ printf("Available adapters\n");
+ head = adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf ("Description : %s, Device to use for wpcap: %s\n", adapter->desc,adapter->name);
+ printf("Description : %s, Device to use for wpcap: %s\n", adapter->desc, adapter->name);
adapter = adapter->next;
}
ec_free_adapters(head);
* @param[in] length = length of databuffer
* @param[in] data = databuffer to be copied into datagram
*/
-static void ecx_writedatagramdata(void *datagramdata, ec_cmdtype com, uint16 length, const void * data)
+static void ecx_writedatagramdata(void *datagramdata, ec_cmdtype com, uint16 length, const void *data)
{
if (length > 0)
{
switch (com)
{
- case EC_CMD_NOP:
- /* Fall-through */
- case EC_CMD_APRD:
- /* Fall-through */
- case EC_CMD_FPRD:
- /* Fall-through */
- case EC_CMD_BRD:
- /* Fall-through */
- case EC_CMD_LRD:
- /* no data to write. initialise data so frame is in a known state */
- memset(datagramdata, 0, length);
- break;
- default:
- memcpy(datagramdata, data, length);
- break;
+ case EC_CMD_NOP:
+ /* Fall-through */
+ case EC_CMD_APRD:
+ /* Fall-through */
+ case EC_CMD_FPRD:
+ /* Fall-through */
+ case EC_CMD_BRD:
+ /* Fall-through */
+ case EC_CMD_LRD:
+ /* no data to write. initialise data so frame is in a known state */
+ memset(datagramdata, 0, length);
+ break;
+ default:
+ memcpy(datagramdata, data, length);
+ break;
}
}
}
frameP = frame;
/* Ethernet header is preset and fixed in frame buffers
EtherCAT header needs to be added after that */
- datagramP = (ec_comt*)&frameP[ETH_HEADERSIZE];
+ datagramP = (ec_comt *)&frameP[ETH_HEADERSIZE];
datagramP->elength = htoes(EC_ECATTYPE + EC_HEADERSIZE + length);
datagramP->command = com;
datagramP->index = idx;
frameP = frame;
/* copy previous frame size */
prevlength = (uint16)port->txbuflength[idx];
- datagramP = (ec_comt*)&frameP[ETH_HEADERSIZE];
+ datagramP = (ec_comt *)&frameP[ETH_HEADERSIZE];
/* add new datagram to ethernet frame size */
- datagramP->elength = htoes( etohs(datagramP->elength) + EC_HEADERSIZE + length );
+ datagramP->elength = htoes(etohs(datagramP->elength) + EC_HEADERSIZE + length);
/* add "datagram follows" flag to previous subframe dlength */
- datagramP->dlength = htoes( etohs(datagramP->dlength) | EC_DATAGRAMFOLLOWS );
+ datagramP->dlength = htoes(etohs(datagramP->dlength) | EC_DATAGRAMFOLLOWS);
/* set new EtherCAT header position */
- datagramP = (ec_comt*)&frameP[prevlength - EC_ELENGTHSIZE];
+ datagramP = (ec_comt *)&frameP[prevlength - EC_ELENGTHSIZE];
datagramP->command = com;
datagramP->index = idx;
datagramP->ADP = htoes(ADP);
* @param[in] timeout = timeout in us, standard is EC_TIMEOUTRET
* @return Workcounter or EC_NOFRAME
*/
-int ecx_BWR (ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout)
+int ecx_BWR(ecx_portt *port, uint16 ADP, uint16 ADO, uint16 length, void *data, int timeout)
{
uint8 idx;
int wkc;
/* get fresh index */
- idx = ecx_getindex (port);
+ idx = ecx_getindex(port);
/* setup datagram */
- ecx_setupdatagram (port, &(port->txbuf[idx]), EC_CMD_BWR, idx, ADP, ADO, length, data);
+ ecx_setupdatagram(port, &(port->txbuf[idx]), EC_CMD_BWR, idx, ADP, ADO, length, data);
/* send data and wait for answer */
- wkc = ecx_srconfirm (port, idx, timeout);
+ wkc = ecx_srconfirm(port, idx, timeout);
/* clear buffer status */
- ecx_setbufstat (port, idx, EC_BUF_EMPTY);
+ ecx_setbufstat(port, idx, EC_BUF_EMPTY);
return wkc;
}
/* setup datagram */
ecx_setupdatagram(port, &(port->txbuf[idx]), EC_CMD_BRD, idx, ADP, ADO, length, data);
/* send data and wait for answer */
- wkc = ecx_srconfirm (port, idx, timeout);
+ wkc = ecx_srconfirm(port, idx, timeout);
if (wkc > 0)
{
/* copy datagram to data buffer */
idx = ecx_getindex(port);
ecx_setupdatagram(port, &(port->txbuf[idx]), EC_CMD_LRD, idx, LO_WORD(LogAdr), HI_WORD(LogAdr), length, data);
wkc = ecx_srconfirm(port, idx, timeout);
- if ((wkc > 0) && (port->rxbuf[idx][EC_CMDOFFSET]==EC_CMD_LRD))
+ if ((wkc > 0) && (port->rxbuf[idx][EC_CMDOFFSET] == EC_CMD_LRD))
{
memcpy(data, &(port->rxbuf[idx][EC_HEADERSIZE]), length);
}
PACKED_BEGIN
typedef struct PACKED
{
- ec_mbxheadert MbxHeader;
- uint16 CANOpen;
- uint8 Command;
- uint16 Index;
- uint8 SubIndex;
+ ec_mbxheadert MbxHeader;
+ uint16 CANOpen;
+ uint8 Command;
+ uint16 Index;
+ uint8 SubIndex;
union
{
- uint8 bdata[0x200]; /* variants for easy data access */
- uint16 wdata[0x100];
- uint32 ldata[0x80];
+ uint8 bdata[0x200]; /* variants for easy data access */
+ uint16 wdata[0x100];
+ uint32 ldata[0x80];
};
} ec_SDOt;
PACKED_END
PACKED_BEGIN
typedef struct PACKED
{
- ec_mbxheadert MbxHeader;
- uint16 CANOpen;
- uint8 Opcode;
- uint8 Reserved;
- uint16 Fragments;
+ ec_mbxheadert MbxHeader;
+ uint16 CANOpen;
+ uint8 Opcode;
+ uint8 Reserved;
+ uint16 Fragments;
union
{
- uint8 bdata[0x200]; /* variants for easy data access */
- uint16 wdata[0x100];
- uint32 ldata[0x80];
+ uint8 bdata[0x200]; /* variants for easy data access */
+ uint16 wdata[0x100];
+ uint32 ldata[0x80];
};
} ec_SDOservicet;
PACKED_END
* @return Workcounter from last slave response
*/
int ecx_SDOread(ecx_contextt *context, uint16 slave, uint16 index, uint8 subindex,
- boolean CA, int *psize, void *p, int timeout)
+ boolean CA, int *psize, void *p, int timeout)
{
ec_SDOt *SDOp, *aSDOp;
uint16 bytesize, Framedatasize;
MbxOut = NULL;
wkc = ecx_mbxreceive(context, slave, &MbxIn, 0);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOt *)MbxOut;
SDOp->MbxHeader.length = htoes(0x000a);
SDOp->MbxHeader.address = htoes(0x0000);
SDOp->MbxHeader.priority = 0x00;
/* get new mailbox count value, used as session handle */
- cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
+ cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
context->slavelist[slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits (SDO request) */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits (SDO request) */
if (CA)
{
SDOp->Command = ECT_SDO_UP_REQ_CA; /* upload request complete access */
if (wkc > 0) /* succeeded to place mailbox in slave ? */
{
/* read slave response */
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
do
{
/* slave response should be CoE, SDO response and the correct index */
if (((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
((etohs(aSDOp->CANOpen) >> 12) == ECT_COES_SDORES) &&
- (aSDOp->Index == SDOp->Index))
+ (aSDOp->Index == SDOp->Index))
{
if ((aSDOp->Command & 0x02) > 0)
{
hp += Framedatasize;
*psize = Framedatasize;
NotLast = TRUE;
- toggle= 0x00;
+ toggle = 0x00;
while (NotLast) /* segmented transfer */
{
MbxOut = ecx_getmbx(context);
- if(!MbxOut)
+ if (!MbxOut)
{
NotLast = FALSE;
break;
cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
context->slavelist[slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits (SDO request) */
- SDOp->Command = ECT_SDO_SEG_UP_REQ + toggle; /* segment upload request */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits (SDO request) */
+ SDOp->Command = ECT_SDO_SEG_UP_REQ + toggle; /* segment upload request */
SDOp->Index = htoes(index);
SDOp->SubIndex = subindex;
SDOp->ldata[0] = 0;
MbxOut = NULL;
if (wkc > 0)
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
if ((((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
((etohs(aSDOp->CANOpen) >> 12) == ECT_COES_SDORES) &&
((aSDOp->Command & 0xe0) == 0x00)))
- {
+ {
/* calculate mailbox transfer size */
Framedatasize = etohs(aSDOp->MbxHeader.length) - 3;
if ((aSDOp->Command & 0x01) > 0)
}
}
}
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- if (MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
ec_mbxbuft *MbxIn, *MbxOut;
uint8 cnt, toggle;
int framedatasize;
- boolean NotLast;
+ boolean NotLast;
const uint8 *hp;
MbxIn = NULL;
MbxOut = NULL;
wkc = ecx_mbxreceive(context, Slave, &MbxIn, 0);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOt *)MbxOut;
maxdata = context->slavelist[Slave].mbx_l - 0x10; /* data section=mailbox size - 6 mbx - 2 CoE - 8 sdo req */
/* get new mailbox counter, used for session handle */
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
- SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits */
+ SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits */
SDOp->Command = ECT_SDO_DOWN_EXP | (((4 - psize) << 2) & 0x0c); /* expedited SDO download transfer */
SDOp->Index = htoes(Index);
SDOp->SubIndex = SubIndex;
MbxOut = NULL;
if (wkc > 0)
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, Slave, &MbxIn, Timeout);
/* response should be CoE, SDO response, correct index and subindex */
if (((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
((etohs(aSDOp->CANOpen) >> 12) == ECT_COES_SDORES) &&
- (aSDOp->Index == SDOp->Index) &&
- (aSDOp->SubIndex == SDOp->SubIndex))
+ (aSDOp->Index == SDOp->Index) &&
+ (aSDOp->SubIndex == SDOp->SubIndex))
{
- /* all OK */
+ /* all OK */
}
/* unexpected response from slave */
else
NotLast = FALSE;
if (framedatasize > maxdata)
{
- framedatasize = maxdata; /* segmented transfer needed */
+ framedatasize = maxdata; /* segmented transfer needed */
NotLast = TRUE;
}
SDOp->MbxHeader.length = htoes((uint16)(0x0a + framedatasize));
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits */
if (CA)
{
SDOp->Command = ECT_SDO_DOWN_INIT_CA; /* Complete Access, normal SDO init download transfer */
MbxOut = NULL;
if (wkc > 0)
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, Slave, &MbxIn, Timeout);
/* response should be CoE, SDO response, correct index and subindex */
if (((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
((etohs(aSDOp->CANOpen) >> 12) == ECT_COES_SDORES) &&
- (aSDOp->Index == SDOp->Index) &&
- (aSDOp->SubIndex == SDOp->SubIndex))
+ (aSDOp->Index == SDOp->Index) &&
+ (aSDOp->SubIndex == SDOp->SubIndex))
{
/* all ok */
maxdata += 7;
while (NotLast)
{
MbxOut = ecx_getmbx(context);
- if(!MbxOut)
+ if (!MbxOut)
{
NotLast = FALSE;
break;
SDOp->Command = 0x01; /* last segment */
if (framedatasize > maxdata)
{
- framedatasize = maxdata; /* more segments needed */
+ framedatasize = maxdata; /* more segments needed */
NotLast = TRUE;
SDOp->Command = 0x00; /* segments follow */
}
if (!NotLast && (framedatasize < 7))
{
- SDOp->MbxHeader.length = htoes(0x0a); /* minimum size */
+ SDOp->MbxHeader.length = htoes(0x0a); /* minimum size */
SDOp->Command = (uint8)(0x01 + ((7 - framedatasize) << 1)); /* last segment reduced octets */
}
else
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits (SDO request) */
- SDOp->Command = SDOp->Command + toggle; /* add toggle bit to command byte */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOREQ << 12)); /* number 9bits service upper 4 bits (SDO request) */
+ SDOp->Command = SDOp->Command + toggle; /* add toggle bit to command byte */
/* copy parameter data to mailbox */
memcpy(&SDOp->Index, hp, framedatasize);
/* update parameter buffer pointer */
MbxOut = NULL;
if (wkc > 0)
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, Slave, &MbxIn, Timeout);
((etohs(aSDOp->CANOpen) >> 12) == ECT_COES_SDORES) &&
((aSDOp->Command & 0xe0) == 0x20))
{
- /* all OK, nothing to do */
+ /* all OK, nothing to do */
}
else
{
}
}
}
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- if (MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
int wkc, maxdata, framedatasize;
ec_mbxbuft *MbxIn, *MbxOut;
uint8 cnt;
-
+
MbxIn = NULL;
MbxOut = NULL;
wkc = ecx_mbxreceive(context, Slave, &MbxIn, 0);
if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOt *)MbxOut;
maxdata = context->slavelist[Slave].mbx_l - 0x08; /* data section=mailbox size - 6 mbx - 2 CoE */
framedatasize = psize;
if (framedatasize > maxdata)
{
- framedatasize = maxdata; /* limit transfer */
+ framedatasize = maxdata; /* limit transfer */
}
SDOp->MbxHeader.length = htoes((uint16)(0x02 + framedatasize));
SDOp->MbxHeader.address = htoes(0x0000);
/* get new mailbox counter, used for session handle */
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
- SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
+ SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
SDOp->CANOpen = htoes((RxPDOnumber & 0x01ff) + (ECT_COES_RXPDO << 12)); /* number 9bits service upper 4 bits */
/* copy PDO data to mailbox */
memcpy(&SDOp->Command, p, framedatasize);
* @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
* @return Workcounter from last slave response
*/
-int ecx_TxPDO(ecx_contextt *context, uint16 slave, uint16 TxPDOnumber , int *psize, void *p, int timeout)
+int ecx_TxPDO(ecx_contextt *context, uint16 slave, uint16 TxPDOnumber, int *psize, void *p, int timeout)
{
ec_SDOt *SDOp, *aSDOp;
int wkc;
wkc = ecx_mbxreceive(context, slave, &MbxIn, 0);
if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOt *)MbxOut;
SDOp->MbxHeader.length = htoes(0x02);
/* get new mailbox counter, used for session handle */
cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
context->slavelist[slave].mbx_cnt = cnt;
- SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
+ SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
SDOp->CANOpen = htoes((TxPDOnumber & 0x01ff) + (ECT_COES_TXPDO_RR << 12)); /* number 9bits service upper 4 bits */
wkc = ecx_mbxsend(context, slave, MbxOut, EC_TIMEOUTTXM);
MbxOut = NULL;
if (wkc > 0)
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
}
}
}
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- if (MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
int32 rdat2;
uint32 bsize = 0;
- rdl = sizeof(rdat); rdat = 0;
+ rdl = sizeof(rdat);
+ rdat = 0;
/* read PDO assign subindex 0 ( = number of PDO's) */
wkc = ecx_SDOread(context, Slave, PDOassign, 0x00, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
rdat = etohs(rdat);
/* read all PDO's */
for (idxloop = 1; idxloop <= nidx; idxloop++)
{
- rdl = sizeof(rdat); rdat = 0;
+ rdl = sizeof(rdat);
+ rdat = 0;
/* read PDO assign */
wkc = ecx_SDOread(context, Slave, PDOassign, (uint8)idxloop, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
/* result is index of PDO */
idx = etohs(rdat);
if (idx > 0)
{
- rdl = sizeof(subcnt); subcnt = 0;
+ rdl = sizeof(subcnt);
+ subcnt = 0;
/* read number of subindexes of PDO */
- wkc = ecx_SDOread(context, Slave,idx, 0x00, FALSE, &rdl, &subcnt, EC_TIMEOUTRXM);
+ wkc = ecx_SDOread(context, Slave, idx, 0x00, FALSE, &rdl, &subcnt, EC_TIMEOUTRXM);
subidx = subcnt;
/* for each subindex */
for (subidxloop = 1; subidxloop <= subidx; subidxloop++)
{
- rdl = sizeof(rdat2); rdat2 = 0;
+ rdl = sizeof(rdat2);
+ rdat2 = 0;
/* read SDO that is mapped in PDO */
wkc = ecx_SDOread(context, Slave, idx, (uint8)subidxloop, FALSE, &rdl, &rdat2, EC_TIMEOUTRXM);
rdat2 = etohl(rdat2);
}
else
{
- rdl = sizeof(rdat); rdat = htoes(0xff);
+ rdl = sizeof(rdat);
+ rdat = htoes(0xff);
/* read Object Entry in Object database */
-// wkc = ec_readOEsingle(idx, (uint8)SubCount, pODlist, pOElist);
+ // wkc = ec_readOEsingle(idx, (uint8)SubCount, pODlist, pOElist);
bsize += etohs(rdat);
}
}
* @return total bitlength of PDO assign
*/
uint32 ecx_readPDOassignCA(ecx_contextt *context, uint16 Slave, int Thread_n,
- uint16 PDOassign)
+ uint16 PDOassign)
{
uint16 idxloop, nidx, subidxloop, idx, subidx;
int wkc, rdl;
/* find maximum size of PDOassign buffer */
rdl = sizeof(ec_PDOassignt);
- context->PDOassign[Thread_n].n=0;
+ context->PDOassign[Thread_n].n = 0;
/* read rxPDOassign in CA mode, all subindexes are read in one struct */
wkc = ecx_SDOread(context, Slave, PDOassign, 0x00, TRUE, &rdl,
- &(context->PDOassign[Thread_n]), EC_TIMEOUTRXM);
+ &(context->PDOassign[Thread_n]), EC_TIMEOUTRXM);
/* positive result from slave ? */
if ((wkc > 0) && (context->PDOassign[Thread_n].n > 0))
{
idx = etohs(context->PDOassign[Thread_n].index[idxloop - 1]);
if (idx > 0)
{
- rdl = sizeof(ec_PDOdesct); context->PDOdesc[Thread_n].n = 0;
+ rdl = sizeof(ec_PDOdesct);
+ context->PDOdesc[Thread_n].n = 0;
/* read SDO's that are mapped in PDO, CA mode */
- wkc = ecx_SDOread(context, Slave,idx, 0x00, TRUE, &rdl,
- &(context->PDOdesc[Thread_n]), EC_TIMEOUTRXM);
+ wkc = ecx_SDOread(context, Slave, idx, 0x00, TRUE, &rdl,
+ &(context->PDOdesc[Thread_n]), EC_TIMEOUTRXM);
subidx = context->PDOdesc[Thread_n].n;
/* extract all bitlengths of SDO's */
for (subidxloop = 1; subidxloop <= subidx; subidxloop++)
{
- bsize += LO_BYTE(etohl(context->PDOdesc[Thread_n].PDO[subidxloop -1]));
+ bsize += LO_BYTE(etohl(context->PDOdesc[Thread_n].PDO[subidxloop - 1]));
}
}
}
*Isize = 0;
*Osize = 0;
SMt_bug_add = 0;
- rdl = sizeof(nSM); nSM = 0;
+ rdl = sizeof(nSM);
+ nSM = 0;
/* read SyncManager Communication Type object count */
wkc = ecx_SDOread(context, Slave, ECT_SDO_SMCOMMTYPE, 0x00, FALSE, &rdl, &nSM, EC_TIMEOUTRXM);
/* positive result from slave ? */
if (nSM > EC_MAXSM)
nSM = EC_MAXSM;
/* iterate for every SM type defined */
- for (iSM = 2 ; iSM < nSM ; iSM++)
+ for (iSM = 2; iSM < nSM; iSM++)
{
- rdl = sizeof(tSM); tSM = 0;
+ rdl = sizeof(tSM);
+ tSM = 0;
/* read SyncManager Communication Type */
wkc = ecx_SDOread(context, Slave, ECT_SDO_SMCOMMTYPE, iSM + 1, FALSE, &rdl, &tSM, EC_TIMEOUTRXM);
if (wkc > 0)
{
-// start slave bug prevention code, remove if possible
- if((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
+ // start slave bug prevention code, remove if possible
+ if ((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
{
SMt_bug_add = 1; // try to correct, this works if the types are 0 1 2 3 and should be 1 2 3 4
}
- if(tSM)
+ if (tSM)
{
tSM += SMt_bug_add; // only add if SMt > 0
}
- if((iSM == 2) && (tSM == 0)) // SM2 has type 0, this is a bug in the slave!
+ if ((iSM == 2) && (tSM == 0)) // SM2 has type 0, this is a bug in the slave!
{
tSM = 3;
}
- if((iSM == 3) && (tSM == 0)) // SM3 has type 0, this is a bug in the slave!
+ if ((iSM == 3) && (tSM == 0)) // SM3 has type 0, this is a bug in the slave!
{
tSM = 4;
}
-// end slave bug prevention code
+ // end slave bug prevention code
context->slavelist[Slave].SMtype[iSM] = tSM;
/* check if SM is unused -> clear enable flag */
if (tSM == 0)
{
context->slavelist[Slave].SM[iSM].SMflags =
- htoel( etohl(context->slavelist[Slave].SM[iSM].SMflags) & EC_SMENABLEMASK);
+ htoel(etohl(context->slavelist[Slave].SM[iSM].SMflags) & EC_SMENABLEMASK);
}
if ((tSM == 3) || (tSM == 4))
{
/* read the assign PDO */
- Tsize = ecx_readPDOassign(context, Slave, ECT_SDO_PDOASSIGN + iSM );
+ Tsize = ecx_readPDOassign(context, Slave, ECT_SDO_PDOASSIGN + iSM);
/* if a mapping is found */
if (Tsize)
{
context->SMcommtype[Thread_n].n = 0;
/* read SyncManager Communication Type object count Complete Access*/
wkc = ecx_SDOread(context, Slave, ECT_SDO_SMCOMMTYPE, 0x00, TRUE, &rdl,
- &(context->SMcommtype[Thread_n]), EC_TIMEOUTRXM);
+ &(context->SMcommtype[Thread_n]), EC_TIMEOUTRXM);
/* positive result from slave ? */
if ((wkc > 0) && (context->SMcommtype[Thread_n].n > 2))
{
ecx_packeterror(context, Slave, 0, 0, 10); /* #SM larger than EC_MAXSM */
}
/* iterate for every SM type defined */
- for (iSM = 2 ; iSM < nSM ; iSM++)
+ for (iSM = 2; iSM < nSM; iSM++)
{
tSM = context->SMcommtype[Thread_n].SMtype[iSM];
-// start slave bug prevention code, remove if possible
- if((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
+ // start slave bug prevention code, remove if possible
+ if ((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
{
SMt_bug_add = 1; // try to correct, this works if the types are 0 1 2 3 and should be 1 2 3 4
}
- if(tSM)
+ if (tSM)
{
tSM += SMt_bug_add; // only add if SMt > 0
}
-// end slave bug prevention code
+ // end slave bug prevention code
context->slavelist[Slave].SMtype[iSM] = tSM;
/* check if SM is unused -> clear enable flag */
if (tSM == 0)
{
context->slavelist[Slave].SM[iSM].SMflags =
- htoel( etohl(context->slavelist[Slave].SM[iSM].SMflags) & EC_SMENABLEMASK);
+ htoel(etohl(context->slavelist[Slave].SM[iSM].SMflags) & EC_SMENABLEMASK);
}
if ((tSM == 3) || (tSM == 4))
{
/* read the assign PDO */
Tsize = ecx_readPDOassignCA(context, Slave, Thread_n,
- ECT_SDO_PDOASSIGN + iSM );
+ ECT_SDO_PDOASSIGN + iSM);
/* if a mapping is found */
if (Tsize)
{
wkc = ecx_mbxreceive(context, Slave, &MbxIn, 0);
if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOservicet *)MbxOut;
SDOp->MbxHeader.length = htoes(0x0008);
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOINFO << 12)); /* number 9bits service upper 4 bits */
- SDOp->Opcode = ECT_GET_ODLIST_REQ; /* get object description list request */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOINFO << 12)); /* number 9bits service upper 4 bits */
+ SDOp->Opcode = ECT_GET_ODLIST_REQ; /* get object description list request */
SDOp->Reserved = 0;
- SDOp->Fragments = 0; /* fragments left */
+ SDOp->Fragments = 0; /* fragments left */
SDOp->wdata[0] = htoes(0x01); /* all objects */
/* send get object description list request to slave */
wkc = ecx_mbxsend(context, Slave, MbxOut, EC_TIMEOUTTXM);
do
{
stop = TRUE; /* assume this is last iteration */
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, Slave, &MbxIn, EC_TIMEOUTRXM);
/* got response ? */
if (wkc > 0)
{
- aSDOp = (ec_SDOservicet*)MbxIn;
+ aSDOp = (ec_SDOservicet *)MbxIn;
/* response should be CoE and "get object description list response" */
if (((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
((aSDOp->Opcode & 0x7f) == ECT_GET_ODLIST_RES))
/* got unexpected response from slave */
else
{
- if ((aSDOp->Opcode & 0x7f) == ECT_SDOINFO_ERROR) /* SDO info error received */
+ if ((aSDOp->Opcode & 0x7f) == ECT_SDOINFO_ERROR) /* SDO info error received */
{
ecx_SDOinfoerror(context, Slave, 0, 0, etohl(aSDOp->ldata[0]));
stop = TRUE;
}
}
x++;
- }
- while ((x <= 128) && !stop);
+ } while ((x <= 128) && !stop);
}
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- if (MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
{
ec_SDOservicet *SDOp, *aSDOp;
int wkc;
- uint16 n, Slave;
+ uint16 n, Slave;
ec_mbxbuft *MbxIn, *MbxOut;
uint8 cnt;
MbxOut = NULL;
/* Empty slave out mailbox if something is in. Timout set to 0 */
wkc = ecx_mbxreceive(context, Slave, &MbxIn, 0);
- if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOservicet *)MbxOut;
SDOp->MbxHeader.length = htoes(0x0008);
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOINFO << 12)); /* number 9bits service upper 4 bits */
- SDOp->Opcode = ECT_GET_OD_REQ; /* get object description request */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOINFO << 12)); /* number 9bits service upper 4 bits */
+ SDOp->Opcode = ECT_GET_OD_REQ; /* get object description request */
SDOp->Reserved = 0;
- SDOp->Fragments = 0; /* fragments left */
+ SDOp->Fragments = 0; /* fragments left */
SDOp->wdata[0] = htoes(pODlist->Index[Item]); /* Data of Index */
/* send get object description request to slave */
wkc = ecx_mbxsend(context, Slave, MbxOut, EC_TIMEOUTTXM);
/* got response ? */
if (wkc > 0)
{
- aSDOp = (ec_SDOservicet*)MbxIn;
+ aSDOp = (ec_SDOservicet *)MbxIn;
if (((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
((aSDOp->Opcode & 0x7f) == ECT_GET_OD_RES))
{
pODlist->ObjectCode[Item] = aSDOp->bdata[5];
pODlist->MaxSub[Item] = aSDOp->bdata[4];
- memcpy(pODlist->Name[Item] , (char *)&aSDOp->bdata[6], n);
+ memcpy(pODlist->Name[Item], (char *)&aSDOp->bdata[6], n);
pODlist->Name[Item][n] = 0x00; /* String terminator */
}
/* got unexpected response from slave */
{
if (((aSDOp->Opcode & 0x7f) == ECT_SDOINFO_ERROR)) /* SDO info error received */
{
- ecx_SDOinfoerror(context, Slave,pODlist->Index[Item], 0, etohl(aSDOp->ldata[0]));
+ ecx_SDOinfoerror(context, Slave, pODlist->Index[Item], 0, etohl(aSDOp->ldata[0]));
}
else
{
- ecx_packeterror(context, Slave,pODlist->Index[Item], 0, 1); /* Unexpected frame returned */
+ ecx_packeterror(context, Slave, pODlist->Index[Item], 0, 1); /* Unexpected frame returned */
}
wkc = 0;
}
}
}
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- if (MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
wkc = ecx_mbxreceive(context, Slave, &MbxIn, 0);
if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxOut = ecx_getmbx(context);
- if(!MbxOut) return wkc;
+ if (!MbxOut) return wkc;
ec_clearmbx(MbxOut);
SDOp = (ec_SDOservicet *)MbxOut;
SDOp->MbxHeader.length = htoes(0x000a);
cnt = ec_nextmbxcnt(context->slavelist[Slave].mbx_cnt);
context->slavelist[Slave].mbx_cnt = cnt;
SDOp->MbxHeader.mbxtype = ECT_MBXT_COE + MBX_HDR_SET_CNT(cnt); /* CoE */
- SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOINFO << 12)); /* number 9bits service upper 4 bits */
- SDOp->Opcode = ECT_GET_OE_REQ; /* get object entry description request */
+ SDOp->CANOpen = htoes(0x000 + (ECT_COES_SDOINFO << 12)); /* number 9bits service upper 4 bits */
+ SDOp->Opcode = ECT_GET_OE_REQ; /* get object entry description request */
SDOp->Reserved = 0;
- SDOp->Fragments = 0; /* fragments left */
- SDOp->wdata[0] = htoes(Index); /* Index */
- SDOp->bdata[2] = SubI; /* SubIndex */
- SDOp->bdata[3] = 1 + 2 + 4; /* get access rights, object category, PDO */
+ SDOp->Fragments = 0; /* fragments left */
+ SDOp->wdata[0] = htoes(Index); /* Index */
+ SDOp->bdata[2] = SubI; /* SubIndex */
+ SDOp->bdata[3] = 1 + 2 + 4; /* get access rights, object category, PDO */
/* send get object entry description request to slave */
wkc = ecx_mbxsend(context, Slave, MbxOut, EC_TIMEOUTTXM);
MbxOut = NULL;
/* got response ? */
if (wkc > 0)
{
- aSDOp = (ec_SDOservicet*)MbxIn;
+ aSDOp = (ec_SDOservicet *)MbxIn;
if (((aSDOp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_COE) &&
- ((aSDOp->Opcode & 0x7f) == ECT_GET_OE_RES))
+ ((aSDOp->Opcode & 0x7f) == ECT_GET_OE_RES))
{
pOElist->Entries++;
n = (etohs(aSDOp->MbxHeader.length) - 16); /* length of string(name of object) */
{
n = EC_MAXNAME; /* max string length */
}
- if (n < 0 )
+ if (n < 0)
{
n = 0;
}
pOElist->BitLength[SubI] = etohs(aSDOp->wdata[3]);
pOElist->ObjAccess[SubI] = etohs(aSDOp->wdata[4]);
- memcpy(pOElist->Name[SubI] , (char *)&aSDOp->wdata[5], n);
+ memcpy(pOElist->Name[SubI], (char *)&aSDOp->wdata[5], n);
pOElist->Name[SubI][n] = 0x00; /* string terminator */
}
/* got unexpected response from slave */
}
}
}
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- if (MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
#include "osal.h"
#include "oshw.h"
-
typedef struct
{
int thread_n;
#endif
/** standard SM0 flags configuration for mailbox slaves */
-#define EC_DEFAULTMBXSM0 0x00010026
+#define EC_DEFAULTMBXSM0 0x00010026
/** standard SM1 flags configuration for mailbox slaves */
-#define EC_DEFAULTMBXSM1 0x00010022
+#define EC_DEFAULTMBXSM1 0x00010022
/** standard SM0 flags configuration for digital output slaves */
-#define EC_DEFAULTDOSM0 0x00010044
+#define EC_DEFAULTDOSM0 0x00010044
void ecx_init_context(ecx_contextt *context)
{
memset(context->grouplist, 0x00, sizeof(ec_groupt) * context->maxgroup);
/* clear slave eeprom cache, does not actually read any eeprom */
ecx_siigetbyte(context, 0, EC_MAXEEPBUF);
- for(lp = 0; lp < context->maxgroup; lp++)
+ for (lp = 0; lp < context->maxgroup; lp++)
{
/* default start address per group entry */
context->grouplist[lp].logstartaddr = lp << EC_LOGGROUPOFFSET;
int ecx_detect_slaves(ecx_contextt *context)
{
- uint8 b;
+ uint8 b;
uint16 w;
- int wkc;
+ int wkc;
/* make special pre-init register writes to enable MAC[1] local administered bit *
* setting for old netX100 slaves */
b = 0x00;
- ecx_BWR(context->port, 0x0000, ECT_REG_DLALIAS, sizeof(b), &b, EC_TIMEOUTRET3); /* Ignore Alias register */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DLALIAS, sizeof(b), &b, EC_TIMEOUTRET3); /* Ignore Alias register */
w = htoes(EC_STATE_INIT | EC_STATE_ACK);
- ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(w), &w, EC_TIMEOUTRET3); /* Reset all slaves to Init */
+ ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(w), &w, EC_TIMEOUTRET3); /* Reset all slaves to Init */
/* netX100 should now be happy */
- ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(w), &w, EC_TIMEOUTRET3); /* Reset all slaves to Init */
- wkc = ecx_BRD(context->port, 0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
+ ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(w), &w, EC_TIMEOUTRET3); /* Reset all slaves to Init */
+ wkc = ecx_BRD(context->port, 0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
if (wkc > 0)
{
/* this is strictly "less than" since the master is "slave 0" */
else
{
EC_PRINT("Error: too many slaves on network: num_slaves=%d, max_slaves=%d\n",
- wkc, context->maxslave);
+ wkc, context->maxslave);
return EC_SLAVECOUNTEXCEEDED;
}
}
uint8 zbuf[64];
memset(&zbuf, 0x00, sizeof(zbuf));
b = 0x00;
- ecx_BWR(context->port, 0x0000, ECT_REG_DLPORT , sizeof(b) , &b, EC_TIMEOUTRET3); /* deact loop manual */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DLPORT, sizeof(b), &b, EC_TIMEOUTRET3); /* deact loop manual */
w = htoes(0x0004);
- ecx_BWR(context->port, 0x0000, ECT_REG_IRQMASK , sizeof(w) , &w, EC_TIMEOUTRET3); /* set IRQ mask */
- ecx_BWR(context->port, 0x0000, ECT_REG_RXERR , 8 , &zbuf, EC_TIMEOUTRET3); /* reset CRC counters */
- ecx_BWR(context->port, 0x0000, ECT_REG_FMMU0 , 16 * 3 , &zbuf, EC_TIMEOUTRET3); /* reset FMMU's */
- ecx_BWR(context->port, 0x0000, ECT_REG_SM0 , 8 * 4 , &zbuf, EC_TIMEOUTRET3); /* reset SyncM */
+ ecx_BWR(context->port, 0x0000, ECT_REG_IRQMASK, sizeof(w), &w, EC_TIMEOUTRET3); /* set IRQ mask */
+ ecx_BWR(context->port, 0x0000, ECT_REG_RXERR, 8, &zbuf, EC_TIMEOUTRET3); /* reset CRC counters */
+ ecx_BWR(context->port, 0x0000, ECT_REG_FMMU0, 16 * 3, &zbuf, EC_TIMEOUTRET3); /* reset FMMU's */
+ ecx_BWR(context->port, 0x0000, ECT_REG_SM0, 8 * 4, &zbuf, EC_TIMEOUTRET3); /* reset SyncM */
b = 0x00;
- ecx_BWR(context->port, 0x0000, ECT_REG_DCSYNCACT , sizeof(b) , &b, EC_TIMEOUTRET3); /* reset activation register */
- ecx_BWR(context->port, 0x0000, ECT_REG_DCSYSTIME , 4 , &zbuf, EC_TIMEOUTRET3); /* reset system time+ofs */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DCSYNCACT, sizeof(b), &b, EC_TIMEOUTRET3); /* reset activation register */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DCSYSTIME, 4, &zbuf, EC_TIMEOUTRET3); /* reset system time+ofs */
w = htoes(0x1000);
- ecx_BWR(context->port, 0x0000, ECT_REG_DCSPEEDCNT , sizeof(w) , &w, EC_TIMEOUTRET3); /* DC speedstart */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DCSPEEDCNT, sizeof(w), &w, EC_TIMEOUTRET3); /* DC speedstart */
w = htoes(0x0c00);
- ecx_BWR(context->port, 0x0000, ECT_REG_DCTIMEFILT , sizeof(w) , &w, EC_TIMEOUTRET3); /* DC filt expr */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DCTIMEFILT, sizeof(w), &w, EC_TIMEOUTRET3); /* DC filt expr */
b = 0x00;
- ecx_BWR(context->port, 0x0000, ECT_REG_DLALIAS , sizeof(b) , &b, EC_TIMEOUTRET3); /* Ignore Alias register */
+ ecx_BWR(context->port, 0x0000, ECT_REG_DLALIAS, sizeof(b), &b, EC_TIMEOUTRET3); /* Ignore Alias register */
w = htoes(EC_STATE_INIT | EC_STATE_ACK);
- ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL , sizeof(w) , &w, EC_TIMEOUTRET3); /* Reset all slaves to Init */
+ ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(w), &w, EC_TIMEOUTRET3); /* Reset all slaves to Init */
b = 2;
- ecx_BWR(context->port, 0x0000, ECT_REG_EEPCFG , sizeof(b) , &b, EC_TIMEOUTRET3); /* force Eeprom from PDI */
+ ecx_BWR(context->port, 0x0000, ECT_REG_EEPCFG, sizeof(b), &b, EC_TIMEOUTRET3); /* force Eeprom from PDI */
b = 0;
- ecx_BWR(context->port, 0x0000, ECT_REG_EEPCFG , sizeof(b) , &b, EC_TIMEOUTRET3); /* set Eeprom to master */
+ ecx_BWR(context->port, 0x0000, ECT_REG_EEPCFG, sizeof(b), &b, EC_TIMEOUTRET3); /* set Eeprom to master */
}
static int ecx_config_from_table(ecx_contextt *context, uint16 slave)
if ((slave > 1) && (*(context->slavecount) > 0))
{
i = 1;
- while(((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
- (context->slavelist[i].eep_id != context->slavelist[slave].eep_id ) ||
- (context->slavelist[i].eep_rev != context->slavelist[slave].eep_rev)) &&
- (i < slave))
+ while (((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
+ (context->slavelist[i].eep_id != context->slavelist[slave].eep_id) ||
+ (context->slavelist[i].eep_rev != context->slavelist[slave].eep_rev)) &&
+ (i < slave))
{
i++;
}
- if(i < slave)
+ if (i < slave)
{
context->slavelist[slave].CoEdetails = context->slavelist[i].CoEdetails;
context->slavelist[slave].FoEdetails = context->slavelist[i].FoEdetails;
context->slavelist[slave].EoEdetails = context->slavelist[i].EoEdetails;
context->slavelist[slave].SoEdetails = context->slavelist[i].SoEdetails;
- if(context->slavelist[i].blockLRW > 0)
+ if (context->slavelist[i].blockLRW > 0)
{
context->slavelist[slave].blockLRW = 1;
context->slavelist[0].blockLRW++;
context->slavelist[slave].Ebuscurrent = context->slavelist[i].Ebuscurrent;
context->slavelist[0].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
memcpy(context->slavelist[slave].name, context->slavelist[i].name, EC_MAXNAME + 1);
- for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
context->slavelist[slave].SM[nSM].StartAddr = context->slavelist[i].SM[nSM].StartAddr;
- context->slavelist[slave].SM[nSM].SMlength = context->slavelist[i].SM[nSM].SMlength;
- context->slavelist[slave].SM[nSM].SMflags = context->slavelist[i].SM[nSM].SMflags;
+ context->slavelist[slave].SM[nSM].SMlength = context->slavelist[i].SM[nSM].SMlength;
+ context->slavelist[slave].SM[nSM].SMflags = context->slavelist[i].SM[nSM].SMflags;
}
context->slavelist[slave].FMMU0func = context->slavelist[i].FMMU0func;
context->slavelist[slave].FMMU1func = context->slavelist[i].FMMU1func;
uint16 slave, ADPh, configadr, ssigen;
uint16 topology, estat;
int16 topoc, slavec, aliasadr;
- uint8 b,h;
+ uint8 b, h;
uint8 SMc;
uint32 eedat;
int wkc, cindex, nSM;
uint16 val16;
- EC_PRINT("ec_config_init %d\n",usetable);
+ EC_PRINT("ec_config_init %d\n", usetable);
ecx_init_context(context);
wkc = ecx_detect_slaves(context);
if (wkc > 0)
context->slavelist[slave].Itype = etohs(val16);
/* a node offset is used to improve readability of network frames */
/* this has no impact on the number of addressable slaves (auto wrap around) */
- ecx_APWRw(context->port, ADPh, ECT_REG_STADR, htoes(slave + EC_NODEOFFSET) , EC_TIMEOUTRET3); /* set node address of slave */
+ ecx_APWRw(context->port, ADPh, ECT_REG_STADR, htoes(slave + EC_NODEOFFSET), EC_TIMEOUTRET3); /* set node address of slave */
if (slave == 1)
{
b = 1; /* kill non ecat frames for first slave */
{
if (context->slavelist[slave].mbx_l > 0)
{
- eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* read mailbox offset */
+ eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* read mailbox offset */
context->slavelist[slave].mbx_ro = (uint16)LO_WORD(etohl(eedat)); /* read mailbox offset */
context->slavelist[slave].mbx_rl = (uint16)HI_WORD(etohl(eedat)); /*read mailbox length */
if (context->slavelist[slave].mbx_rl == 0)
}
configadr = context->slavelist[slave].configadr;
val16 = ecx_FPRDw(context->port, configadr, ECT_REG_ESCSUP, EC_TIMEOUTRET3);
- if ((etohs(val16) & 0x04) > 0) /* Support DC? */
+ if ((etohs(val16) & 0x04) > 0) /* Support DC? */
{
context->slavelist[slave].hasdc = TRUE;
}
slavec = 1;
}
slavec--;
- }
- while (slavec > 0);
+ } while (slavec > 0);
}
- (void)ecx_statecheck(context, slave, EC_STATE_INIT, EC_TIMEOUTSTATE); //* check state change Init */
+ (void)ecx_statecheck(context, slave, EC_STATE_INIT, EC_TIMEOUTSTATE); //* check state change Init */
/* set default mailbox configuration if slave has mailbox */
- if (context->slavelist[slave].mbx_l>0)
+ if (context->slavelist[slave].mbx_l > 0)
{
context->slavelist[slave].SMtype[0] = 1;
context->slavelist[slave].SMtype[1] = 2;
context->slavelist[slave].FoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x08);
context->slavelist[slave].EoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x09);
context->slavelist[slave].SoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x0a);
- if((ecx_siigetbyte(context, slave, ssigen + 0x0d) & 0x02) > 0)
+ if ((ecx_siigetbyte(context, slave, ssigen + 0x0d) & 0x02) > 0)
{
context->slavelist[slave].blockLRW = 1;
context->slavelist[0].blockLRW++;
}
/* SII SM section */
nSM = ecx_siiSM(context, slave, context->eepSM);
- if (nSM>0)
+ if (nSM > 0)
{
context->slavelist[slave].SM[0].StartAddr = htoes(context->eepSM->PhStart);
context->slavelist[slave].SM[0].SMlength = htoes(context->eepSM->Plength);
context->slavelist[slave].SM[0].SMflags =
- htoel((context->eepSM->Creg) + (context->eepSM->Activate << 16));
+ htoel((context->eepSM->Creg) + (context->eepSM->Activate << 16));
SMc = 1;
- while ((SMc < EC_MAXSM) && ecx_siiSMnext(context, slave, context->eepSM, SMc))
+ while ((SMc < EC_MAXSM) && ecx_siiSMnext(context, slave, context->eepSM, SMc))
{
context->slavelist[slave].SM[SMc].StartAddr = htoes(context->eepSM->PhStart);
context->slavelist[slave].SM[SMc].SMlength = htoes(context->eepSM->Plength);
context->slavelist[slave].SM[SMc].SMflags =
- htoel((context->eepSM->Creg) + (context->eepSM->Activate << 16));
+ htoel((context->eepSM->Creg) + (context->eepSM->Activate << 16));
SMc++;
}
}
/* SII FMMU section */
if (ecx_siiFMMU(context, slave, context->eepFMMU))
{
- if (context->eepFMMU->FMMU0 !=0xff)
+ if (context->eepFMMU->FMMU0 != 0xff)
{
context->slavelist[slave].FMMU0func = context->eepFMMU->FMMU0;
}
- if (context->eepFMMU->FMMU1 !=0xff)
+ if (context->eepFMMU->FMMU1 != 0xff)
{
context->slavelist[slave].FMMU1func = context->eepFMMU->FMMU1;
}
- if (context->eepFMMU->FMMU2 !=0xff)
+ if (context->eepFMMU->FMMU2 != 0xff)
{
context->slavelist[slave].FMMU2func = context->eepFMMU->FMMU2;
}
- if (context->eepFMMU->FMMU3 !=0xff)
+ if (context->eepFMMU->FMMU3 != 0xff)
{
context->slavelist[slave].FMMU3func = context->eepFMMU->FMMU3;
}
/* program SM0 mailbox in and SM1 mailbox out for slave */
/* writing both SM in one datagram will solve timing issue in old NETX */
ecx_FPWR(context->port, configadr, ECT_REG_SM0, sizeof(ec_smt) * 2,
- &(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
+ &(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
}
/* some slaves need eeprom available to PDI in init->preop transition */
ecx_eeprom2pdi(context, slave);
{
/* request pre_op for slave */
ecx_FPWRw(context->port,
- configadr,
- ECT_REG_ALCTL,
- htoes(EC_STATE_PRE_OP | EC_STATE_ACK),
- EC_TIMEOUTRET3); /* set preop status */
+ configadr,
+ ECT_REG_ALCTL,
+ htoes(EC_STATE_PRE_OP | EC_STATE_ACK),
+ EC_TIMEOUTRET3); /* set preop status */
}
}
}
if ((slave > 1) && (*(context->slavecount) > 0))
{
i = 1;
- while(((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
- (context->slavelist[i].eep_id != context->slavelist[slave].eep_id ) ||
- (context->slavelist[i].eep_rev != context->slavelist[slave].eep_rev)) &&
- (i < slave))
+ while (((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
+ (context->slavelist[i].eep_id != context->slavelist[slave].eep_id) ||
+ (context->slavelist[i].eep_rev != context->slavelist[slave].eep_rev)) &&
+ (i < slave))
{
i++;
}
- if(i < slave)
+ if (i < slave)
{
- for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
context->slavelist[slave].SM[nSM].SMlength = context->slavelist[i].SM[nSM].SMlength;
context->slavelist[slave].SMtype[nSM] = context->slavelist[i].SMtype[nSM];
memset(&eepPDO, 0, sizeof(eepPDO));
Isize = ecx_siiPDO(context, slave, &eepPDO, 0);
EC_PRINT(" SII Isize:%u\n", Isize);
- for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
if (eepPDO.SMbitsize[nSM] > 0)
{
- context->slavelist[slave].SM[nSM].SMlength = htoes((eepPDO.SMbitsize[nSM] + 7) / 8);
+ context->slavelist[slave].SM[nSM].SMlength = htoes((eepPDO.SMbitsize[nSM] + 7) / 8);
context->slavelist[slave].SMtype[nSM] = 4;
EC_PRINT(" SM%d length %d\n", nSM, eepPDO.SMbitsize[nSM]);
}
}
Osize = ecx_siiPDO(context, slave, &eepPDO, 1);
EC_PRINT(" SII Osize:%u\n", Osize);
- for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
if (eepPDO.SMbitsize[nSM] > 0)
{
- context->slavelist[slave].SM[nSM].SMlength = htoes((eepPDO.SMbitsize[nSM] + 7) / 8);
+ context->slavelist[slave].SM[nSM].SMlength = htoes((eepPDO.SMbitsize[nSM] + 7) / 8);
context->slavelist[slave].SMtype[nSM] = 3;
EC_PRINT(" SM%d length %d\n", nSM, eepPDO.SMbitsize[nSM]);
}
context->slavelist[slave].Obits = (uint16)Osize;
context->slavelist[slave].Ibits = (uint16)Isize;
EC_PRINT(" ISIZE:%d %d OSIZE:%d\n",
- context->slavelist[slave].Ibits, Isize,context->slavelist[slave].Obits);
+ context->slavelist[slave].Ibits, Isize, context->slavelist[slave].Obits);
return 1;
}
if (!context->slavelist[slave].mbx_l && context->slavelist[slave].SM[0].StartAddr)
{
ecx_FPWR(context->port, configadr, ECT_REG_SM0,
- sizeof(ec_smt), &(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
+ sizeof(ec_smt), &(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
EC_PRINT(" SM0 Type:%d StartAddr:%4.4x Flags:%8.8x\n",
- context->slavelist[slave].SMtype[0],
- etohs(context->slavelist[slave].SM[0].StartAddr),
- etohl(context->slavelist[slave].SM[0].SMflags));
+ context->slavelist[slave].SMtype[0],
+ etohs(context->slavelist[slave].SM[0].StartAddr),
+ etohl(context->slavelist[slave].SM[0].SMflags));
}
if (!context->slavelist[slave].mbx_l && context->slavelist[slave].SM[1].StartAddr)
{
ecx_FPWR(context->port, configadr, ECT_REG_SM1,
- sizeof(ec_smt), &context->slavelist[slave].SM[1], EC_TIMEOUTRET3);
+ sizeof(ec_smt), &context->slavelist[slave].SM[1], EC_TIMEOUTRET3);
EC_PRINT(" SM1 Type:%d StartAddr:%4.4x Flags:%8.8x\n",
- context->slavelist[slave].SMtype[1],
- etohs(context->slavelist[slave].SM[1].StartAddr),
- etohl(context->slavelist[slave].SM[1].SMflags));
+ context->slavelist[slave].SMtype[1],
+ etohs(context->slavelist[slave].SM[1].StartAddr),
+ etohl(context->slavelist[slave].SM[1].SMflags));
}
/* program SM2 to SMx */
- for( nSM = 2 ; nSM < EC_MAXSM ; nSM++ )
+ for (nSM = 2; nSM < EC_MAXSM; nSM++)
{
if (context->slavelist[slave].SM[nSM].StartAddr)
{
/* check if SM length is zero -> clear enable flag */
- if( context->slavelist[slave].SM[nSM].SMlength == 0)
+ if (context->slavelist[slave].SM[nSM].SMlength == 0)
{
context->slavelist[slave].SM[nSM].SMflags =
- htoel( etohl(context->slavelist[slave].SM[nSM].SMflags) & EC_SMENABLEMASK);
+ htoel(etohl(context->slavelist[slave].SM[nSM].SMflags) & EC_SMENABLEMASK);
}
/* if SM length is non zero always set enable flag */
else
{
context->slavelist[slave].SM[nSM].SMflags =
- htoel( etohl(context->slavelist[slave].SM[nSM].SMflags) | ~EC_SMENABLEMASK);
+ htoel(etohl(context->slavelist[slave].SM[nSM].SMflags) | ~EC_SMENABLEMASK);
}
ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt))),
- sizeof(ec_smt), &context->slavelist[slave].SM[nSM], EC_TIMEOUTRET3);
+ sizeof(ec_smt), &context->slavelist[slave].SM[nSM], EC_TIMEOUTRET3);
EC_PRINT(" SM%d Type:%d StartAddr:%4.4x Flags:%8.8x\n", nSM,
- context->slavelist[slave].SMtype[nSM],
- etohs(context->slavelist[slave].SM[nSM].StartAddr),
- etohl(context->slavelist[slave].SM[nSM].SMflags));
+ context->slavelist[slave].SMtype[nSM],
+ etohs(context->slavelist[slave].SM[nSM].StartAddr),
+ etohl(context->slavelist[slave].SM[nSM].SMflags));
}
}
if (context->slavelist[slave].Ibits > 7)
{
int p;
p = 0;
- while((p < EC_MAX_MAPT) && ecx_mapt[p].running)
+ while ((p < EC_MAX_MAPT) && ecx_mapt[p].running)
{
p++;
}
- if(p < EC_MAX_MAPT)
+ if (p < EC_MAX_MAPT)
{
return p;
}
{
int thrc, thrn;
thrc = 0;
- for(thrn = 0 ; thrn < EC_MAX_MAPT ; thrn++)
+ for (thrn = 0; thrn < EC_MAX_MAPT; thrn++)
{
thrc += ecx_mapt[thrn].running;
}
if (!group || (group == context->slavelist[slave].group))
{
#if EC_MAX_MAPT > 1
- /* multi-threaded version */
- while ((thrn = ecx_find_mapt()) < 0)
- {
- osal_usleep(1000);
- }
- ecx_mapt[thrn].context = context;
- ecx_mapt[thrn].slave = slave;
- ecx_mapt[thrn].thread_n = thrn;
- ecx_mapt[thrn].running = 1;
- osal_thread_create(&(ecx_threadh[thrn]), 128000,
- &ecx_mapper_thread, &(ecx_mapt[thrn]));
+ /* multi-threaded version */
+ while ((thrn = ecx_find_mapt()) < 0)
+ {
+ osal_usleep(1000);
+ }
+ ecx_mapt[thrn].context = context;
+ ecx_mapt[thrn].slave = slave;
+ ecx_mapt[thrn].thread_n = thrn;
+ ecx_mapt[thrn].running = 1;
+ osal_thread_create(&(ecx_threadh[thrn]), 128000,
+ &ecx_mapper_thread, &(ecx_mapt[thrn]));
#else
- /* serialised version */
- ecx_map_coe_soe(context, slave, 0);
+ /* serialised version */
+ ecx_map_coe_soe(context, slave, 0);
#endif
}
}
}
static void ecx_config_create_input_mappings(ecx_contextt *context, void *pIOmap,
- uint8 group, int16 slave, uint32 * LogAddr, uint8 * BitPos)
+ uint8 group, int16 slave, uint32 *LogAddr, uint8 *BitPos)
{
int BitCount = 0;
int FMMUdone = 0;
}
EC_PRINT(" SM%d\n", SMc);
context->slavelist[slave].FMMU[FMMUc].PhysStart =
- context->slavelist[slave].SM[SMc].StartAddr;
+ context->slavelist[slave].SM[SMc].StartAddr;
SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
ByteCount += SMlength;
BitCount += SMlength * 8;
context->slavelist[slave].FMMU[FMMUc].LogStartbit = *BitPos;
*BitPos = 7;
FMMUsize = ByteCount;
- if ((FMMUsize + FMMUdone)> (int)context->slavelist[slave].Ibytes)
+ if ((FMMUsize + FMMUdone) > (int)context->slavelist[slave].Ibytes)
{
FMMUsize = (uint16)(context->slavelist[slave].Ibytes - FMMUdone);
}
context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
/* program FMMU for input */
ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
- sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
+ sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
}
if (!context->slavelist[slave].inputs)
{
if (group)
{
context->slavelist[slave].inputs =
- (uint8 *)(pIOmap) +
- etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) -
- context->grouplist[group].logstartaddr;
+ (uint8 *)(pIOmap) +
+ etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) -
+ context->grouplist[group].logstartaddr;
}
else
{
context->slavelist[slave].inputs =
- (uint8 *)(pIOmap) +
- etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
+ (uint8 *)(pIOmap) +
+ etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
}
context->slavelist[slave].Istartbit =
- context->slavelist[slave].FMMU[FMMUc].LogStartbit;
+ context->slavelist[slave].FMMU[FMMUc].LogStartbit;
EC_PRINT(" Inputs %p startbit %d\n",
- context->slavelist[slave].inputs,
- context->slavelist[slave].Istartbit);
+ context->slavelist[slave].inputs,
+ context->slavelist[slave].Istartbit);
}
FMMUc++;
}
}
static void ecx_config_create_output_mappings(ecx_contextt *context, void *pIOmap,
- uint8 group, int16 slave, uint32 * LogAddr, uint8 * BitPos)
+ uint8 group, int16 slave, uint32 *LogAddr, uint8 *BitPos)
{
int BitCount = 0;
int FMMUdone = 0;
}
EC_PRINT(" SM%d\n", SMc);
context->slavelist[slave].FMMU[FMMUc].PhysStart =
- context->slavelist[slave].SM[SMc].StartAddr;
+ context->slavelist[slave].SM[SMc].StartAddr;
SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
ByteCount += SMlength;
BitCount += SMlength * 8;
context->slavelist[slave].FMMU[FMMUc].LogStartbit = *BitPos;
*BitPos = 7;
FMMUsize = ByteCount;
- if ((FMMUsize + FMMUdone)> (int)context->slavelist[slave].Obytes)
+ if ((FMMUsize + FMMUdone) > (int)context->slavelist[slave].Obytes)
{
FMMUsize = (uint16)(context->slavelist[slave].Obytes - FMMUdone);
}
context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
/* program FMMU for output */
ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
- sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
+ sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
}
if (!context->slavelist[slave].outputs)
{
if (group)
{
context->slavelist[slave].outputs =
- (uint8 *)(pIOmap) +
- etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) -
- context->grouplist[group].logstartaddr;
+ (uint8 *)(pIOmap) +
+ etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) -
+ context->grouplist[group].logstartaddr;
}
else
{
context->slavelist[slave].outputs =
- (uint8 *)(pIOmap) +
- etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
+ (uint8 *)(pIOmap) +
+ etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
}
context->slavelist[slave].Ostartbit =
- context->slavelist[slave].FMMU[FMMUc].LogStartbit;
+ context->slavelist[slave].FMMU[FMMUc].LogStartbit;
EC_PRINT(" slave %d Outputs %p startbit %d\n",
- slave,
- context->slavelist[slave].outputs,
- context->slavelist[slave].Ostartbit);
+ slave,
+ context->slavelist[slave].outputs,
+ context->slavelist[slave].Ostartbit);
}
FMMUc++;
}
}
static void ecx_config_create_mbxstatus_mappings(ecx_contextt *context, void *pIOmap,
- uint8 group, int16 slave, uint32 * LogAddr)
+ uint8 group, int16 slave, uint32 *LogAddr)
{
uint16 FMMUsize = 1;
uint16 configadr;
*LogAddr += FMMUsize;
context->slavelist[slave].FMMU[FMMUc].LogLength = htoes(FMMUsize);
context->slavelist[slave].FMMU[FMMUc].LogEndbit = 7;
- context->slavelist[slave].FMMU[FMMUc].PhysStart = ECT_REG_SM1STAT;
+ context->slavelist[slave].FMMU[FMMUc].PhysStart = ECT_REG_SM1STAT;
context->slavelist[slave].FMMU[FMMUc].PhysStartBit = 0;
context->slavelist[slave].FMMU[FMMUc].FMMUtype = 1;
context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
/* program FMMU for input */
ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
- sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
+ sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
position = etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
context->slavelist[slave].mbxstatus = (uint8 *)(pIOmap) + position;
context->grouplist[group].mbxstatuslength++;
FMMUc++;
/* account for MBXSTATUS wkc increment */
- if(!context->slavelist[slave].Ibytes)
+ if (!context->slavelist[slave].Ibytes)
context->grouplist[group].inputsWKC++;
}
context->slavelist[slave].FMMUunused = FMMUc;
/* create output mapping */
if (context->slavelist[slave].Obits)
{
- ecx_config_create_output_mappings (context, pIOmap, group, slave, &LogAddr, &BitPos);
+ ecx_config_create_output_mappings(context, pIOmap, group, slave, &LogAddr, &BitPos);
if (forceByteAlignment)
{
{
context->slavelist[0].outputs = pIOmap;
context->slavelist[0].Obytes = LogAddr -
- context->grouplist[group].logstartaddr; /* store output bytes in master record */
+ context->grouplist[group].logstartaddr; /* store output bytes in master record */
}
/* do input mapping of slave and program FMMUs */
context->grouplist[group].nsegments = currentsegment + 1;
context->grouplist[group].inputs = (uint8 *)(pIOmap) + context->grouplist[group].Obytes;
context->grouplist[group].Ibytes = LogAddr -
- context->grouplist[group].logstartaddr -
- context->grouplist[group].Obytes;
+ context->grouplist[group].logstartaddr -
+ context->grouplist[group].Obytes;
/* do mbxstatus mapping of slave and program FMMUs */
for (slave = 1; slave <= *(context->slavecount); slave++)
oLogAddr = LogAddr;
if ((segmentsize + diff) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
{
- context->grouplist[group].IOsegment[currentsegment] = segmentsize;
- if (currentsegment < (EC_MAXIOSEGMENTS - 1))
- {
- currentsegment++;
- segmentsize = diff;
- }
+ context->grouplist[group].IOsegment[currentsegment] = segmentsize;
+ if (currentsegment < (EC_MAXIOSEGMENTS - 1))
+ {
+ currentsegment++;
+ segmentsize = diff;
+ }
}
else
{
- segmentsize += diff;
+ segmentsize += diff;
}
}
}
{
context->slavelist[0].inputs = (uint8 *)(pIOmap) + context->slavelist[0].Obytes;
context->slavelist[0].Ibytes = LogAddr -
- context->grouplist[group].logstartaddr -
- context->slavelist[0].Obytes; /* store input bytes in master record */
+ context->grouplist[group].logstartaddr -
+ context->slavelist[0].Obytes; /* store input bytes in master record */
context->slavelist[0].mbxstatus = (uint8 *)(pIOmap) + context->slavelist[0].Obytes + context->slavelist[0].Ibytes;
}
-
/* Do post mapping actions */
for (slave = 1; slave <= *(context->slavecount); slave++)
{
/* User may override automatic state change */
if (context->manualstatechange == 0)
{
- /* request safe_op for slave */
- ecx_FPWRw(context->port,
- configadr,
- ECT_REG_ALCTL,
- htoes(EC_STATE_SAFE_OP),
- EC_TIMEOUTRET3);
+ /* request safe_op for slave */
+ ecx_FPWRw(context->port,
+ configadr,
+ ECT_REG_ALCTL,
+ htoes(EC_STATE_SAFE_OP),
+ EC_TIMEOUTRET3);
}
/* Store slave properties*/
if (context->slavelist[slave].blockLRW)
{
- context->grouplist[group].blockLRW++;
+ context->grouplist[group].blockLRW++;
}
context->grouplist[group].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
}
}
EC_PRINT("IOmapSize %d\n", context->grouplist[group].Obytes +
- context->grouplist[group].Ibytes +
- context->grouplist[group].mbxstatuslength);
+ context->grouplist[group].Ibytes +
+ context->grouplist[group].mbxstatuslength);
return (context->grouplist[group].Obytes +
- context->grouplist[group].Ibytes) +
- context->grouplist[group].mbxstatuslength;
+ context->grouplist[group].Ibytes) +
+ context->grouplist[group].mbxstatuslength;
}
return 0;
}
/** Map all PDOs in one group of slaves to IOmap with Outputs/Inputs
-* in sequential order (legacy SOEM way).
-*
+ * in sequential order (legacy SOEM way).
+ *
*
* @param[in] context = context struct
* @param[out] pIOmap = pointer to IOmap
}
/** Map all PDOs in one group of slaves to IOmap with Outputs/Inputs
-* in sequential order (legacy SOEM way) and force byte alignement.
-*
+ * in sequential order (legacy SOEM way) and force byte alignement.
+ *
*
* @param[in] context = context struct
* @param[out] pIOmap = pointer to IOmap
{
ecx_config_create_output_mappings(context, pIOmap, group,
- slave, &soLogAddr, &BitPos);
+ slave, &soLogAddr, &BitPos);
if (BitPos)
{
soLogAddr++;
if (context->slavelist[slave].Ibits)
{
ecx_config_create_input_mappings(context, pIOmap, group,
- slave, &siLogAddr, &BitPos);
+ slave, &siLogAddr, &BitPos);
if (BitPos)
{
siLogAddr++;
}
}
- tempLogAddr = (siLogAddr > soLogAddr) ? siLogAddr : soLogAddr;
+ tempLogAddr = (siLogAddr > soLogAddr) ? siLogAddr : soLogAddr;
diff = tempLogAddr - mLogAddr;
int soLength = soLogAddr - mLogAddr;
int siLength = siLogAddr - mLogAddr;
{
if (!group || (group == context->slavelist[slave].group))
{
- if(context->slavelist[slave].Ibits > 0)
+ if (context->slavelist[slave].Ibits > 0)
{
context->slavelist[slave].inputs += context->grouplist[group].Obytes;
}
mLogAddr = tempLogAddr;
if ((segmentsize + diff) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
{
- context->grouplist[group].IOsegment[currentsegment] = segmentsize;
- if (currentsegment < (EC_MAXIOSEGMENTS - 1))
- {
- currentsegment++;
- segmentsize = diff;
- }
+ context->grouplist[group].IOsegment[currentsegment] = segmentsize;
+ if (currentsegment < (EC_MAXIOSEGMENTS - 1))
+ {
+ currentsegment++;
+ segmentsize = diff;
+ }
}
else
{
- segmentsize += diff;
+ segmentsize += diff;
}
/* Move calculated mbxstatus with OBytes + Ibytes offset */
context->slavelist[slave].mbxstatus += context->grouplist[group].Obytes;
context->slavelist[0].inputs = (uint8 *)pIOmap + context->slavelist[0].Obytes;
context->slavelist[0].Ibytes = siLogAddr - context->grouplist[group].logstartaddr;
context->slavelist[0].mbxstatus = (uint8 *)pIOmap +
- context->slavelist[0].Obytes +
- context->slavelist[0].Ibytes;
+ context->slavelist[0].Obytes +
+ context->slavelist[0].Ibytes;
}
/* Do post mapping actions */
/* User may override automatic state change */
if (context->manualstatechange == 0)
{
- /* request safe_op for slave */
- ecx_FPWRw(context->port,
- configadr,
- ECT_REG_ALCTL,
- htoes(EC_STATE_SAFE_OP),
- EC_TIMEOUTRET3);
+ /* request safe_op for slave */
+ ecx_FPWRw(context->port,
+ configadr,
+ ECT_REG_ALCTL,
+ htoes(EC_STATE_SAFE_OP),
+ EC_TIMEOUTRET3);
}
/* Store slave properties*/
if (context->slavelist[slave].blockLRW)
{
- context->grouplist[group].blockLRW++;
+ context->grouplist[group].blockLRW++;
}
context->grouplist[group].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
}
}
EC_PRINT("IOmapSize %d\n", context->grouplist[group].Obytes +
- context->grouplist[group].Ibytes +
- context->grouplist[group].mbxstatuslength);
+ context->grouplist[group].Ibytes +
+ context->grouplist[group].mbxstatuslength);
return (context->grouplist[group].Obytes +
- context->grouplist[group].Ibytes) +
- context->grouplist[group].mbxstatuslength;
+ context->grouplist[group].Ibytes) +
+ context->grouplist[group].mbxstatuslength;
}
return 0;
}
-
/** Recover slave.
*
* @param[in] context = context struct
readadr = 0xfffe;
wkc = ecx_APRD(context->port, ADPh, ECT_REG_STADR, sizeof(readadr), &readadr, timeout);
/* correct slave found, finished */
- if(readadr == configadr)
+ if (readadr == configadr)
{
- return 1;
+ return 1;
}
/* only try if no config address*/
- if( (wkc > 0) && (readadr == 0))
+ if ((wkc > 0) && (readadr == 0))
{
/* clear possible slaves at EC_TEMPNODE */
- ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0) , 0);
+ ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0), 0);
/* set temporary node address of slave */
- if(ecx_APWRw(context->port, ADPh, ECT_REG_STADR, htoes(EC_TEMPNODE) , timeout) <= 0)
+ if (ecx_APWRw(context->port, ADPh, ECT_REG_STADR, htoes(EC_TEMPNODE), timeout) <= 0)
{
- ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0) , 0);
+ ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0), 0);
return 0; /* slave fails to respond */
}
context->slavelist[slave].configadr = EC_TEMPNODE; /* temporary config address */
- ecx_eeprom2master(context, slave); /* set Eeprom control to master */
+ ecx_eeprom2master(context, slave); /* set Eeprom control to master */
/* check if slave is the same as configured before */
if ((ecx_FPRDw(context->port, EC_TEMPNODE, ECT_REG_ALIAS, timeout) ==
- htoes(context->slavelist[slave].aliasadr)) &&
+ htoes(context->slavelist[slave].aliasadr)) &&
(ecx_readeeprom(context, slave, ECT_SII_ID, EC_TIMEOUTEEP) ==
- htoel(context->slavelist[slave].eep_id)) &&
+ htoel(context->slavelist[slave].eep_id)) &&
(ecx_readeeprom(context, slave, ECT_SII_MANUF, EC_TIMEOUTEEP) ==
- htoel(context->slavelist[slave].eep_man)) &&
+ htoel(context->slavelist[slave].eep_man)) &&
(ecx_readeeprom(context, slave, ECT_SII_REV, EC_TIMEOUTEEP) ==
- htoel(context->slavelist[slave].eep_rev)))
+ htoel(context->slavelist[slave].eep_rev)))
{
- rval = ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(configadr) , timeout);
+ rval = ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(configadr), timeout);
context->slavelist[slave].configadr = configadr;
}
else
{
/* slave is not the expected one, remove config address*/
- ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0) , timeout);
+ ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0), timeout);
context->slavelist[slave].configadr = configadr;
}
}
uint16 configadr;
configadr = context->slavelist[slave].configadr;
- if (ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_INIT) , timeout) <= 0)
+ if (ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_INIT), timeout) <= 0)
{
return 0;
}
ecx_eeprom2pdi(context, slave); /* set Eeprom control to PDI */
/* check state change init */
state = ecx_statecheck(context, slave, EC_STATE_INIT, EC_TIMEOUTSTATE);
- if(state == EC_STATE_INIT)
+ if (state == EC_STATE_INIT)
{
/* program all enabled SM */
- for( nSM = 0 ; nSM < EC_MAXSM ; nSM++ )
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
if (context->slavelist[slave].SM[nSM].StartAddr)
{
ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt))),
- sizeof(ec_smt), &context->slavelist[slave].SM[nSM], timeout);
+ sizeof(ec_smt), &context->slavelist[slave].SM[nSM], timeout);
}
}
/* small delay to allow slave to process SM changes */
osal_usleep(5000);
- ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_PRE_OP) , timeout);
+ ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_PRE_OP), timeout);
state = ecx_statecheck(context, slave, EC_STATE_PRE_OP, EC_TIMEOUTSTATE); /* check state change pre-op */
- if( state == EC_STATE_PRE_OP)
+ if (state == EC_STATE_PRE_OP)
{
/* execute slave configuration hook Pre-Op to Safe-OP */
if (context->slavelist[slave].PO2SOconfig) /* only if registered */
{
context->slavelist[slave].PO2SOconfig(context, slave);
}
- ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_SAFE_OP) , timeout); /* set safeop status */
- state = ecx_statecheck(context, slave, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE); /* check state change safe-op */
+ ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_SAFE_OP), timeout); /* set safeop status */
+ state = ecx_statecheck(context, slave, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE); /* check state change safe-op */
/* program configured FMMU */
- for( FMMUc = 0 ; FMMUc < context->slavelist[slave].FMMUunused ; FMMUc++ )
+ for (FMMUc = 0; FMMUc < context->slavelist[slave].FMMUunused; FMMUc++)
{
ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc)),
- sizeof(ec_fmmut), &context->slavelist[slave].FMMU[FMMUc], timeout);
+ sizeof(ec_fmmut), &context->slavelist[slave].FMMU[FMMUc], timeout);
}
}
}
#include "oshw.h"
#include "osal.h"
-#define PORTM0 0x01
-#define PORTM1 0x02
-#define PORTM2 0x04
-#define PORTM3 0x08
+#define PORTM0 0x01
+#define PORTM1 0x02
+#define PORTM2 0x04
+#define PORTM3 0x08
/** 1st sync pulse delay in ns here 100ms */
-#define SyncDelay ((int32)100000000)
+#define SyncDelay ((int32)100000000)
/**
* Set DC of slave to fire sync0 at CyclTime interval with CyclShift offset.
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET);
if (act)
{
- RA = 1 + 2; /* act cyclic operation and sync0, sync1 deactivated */
+ RA = 1 + 2; /* act cyclic operation and sync0, sync1 deactivated */
}
h = 0;
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCUC, sizeof(h), &h, EC_TIMEOUTRET); /* write access to ethercat */
will sync at the same moment (you can use CyclShift to shift the sync) */
if (CyclTime > 0)
{
- t = ((t1 + SyncDelay) / CyclTime) * CyclTime + CyclTime + CyclShift;
+ t = ((t1 + SyncDelay) / CyclTime) * CyclTime + CyclTime + CyclShift;
}
else
{
t = htoell(t);
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSTART0, sizeof(t), &t, EC_TIMEOUTRET); /* SYNC0 start time */
tc = htoel(CyclTime);
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCYCLE0, sizeof(tc), &tc, EC_TIMEOUTRET); /* SYNC0 cycle time */
+ (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCYCLE0, sizeof(tc), &tc, EC_TIMEOUTRET); /* SYNC0 cycle time */
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET); /* activate cyclic operation */
- // update ec_slave state
- context->slavelist[slave].DCactive = (uint8)act;
- context->slavelist[slave].DCshift = CyclShift;
- context->slavelist[slave].DCcycle = CyclTime;
+ // update ec_slave state
+ context->slavelist[slave].DCactive = (uint8)act;
+ context->slavelist[slave].DCshift = CyclShift;
+ context->slavelist[slave].DCcycle = CyclTime;
}
/**
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET);
if (act)
{
- RA = 1 + 2 + 4; /* act cyclic operation and sync0 + sync1 */
+ RA = 1 + 2 + 4; /* act cyclic operation and sync0 + sync1 */
}
h = 0;
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCUC, sizeof(h), &h, EC_TIMEOUTRET); /* write access to ethercat */
tc = htoel(CyclTime0);
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCYCLE0, sizeof(tc), &tc, EC_TIMEOUTRET); /* SYNC0 cycle time */
tc = htoel(CyclTime1);
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCYCLE1, sizeof(tc), &tc, EC_TIMEOUTRET); /* SYNC1 cycle time */
+ (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCYCLE1, sizeof(tc), &tc, EC_TIMEOUTRET); /* SYNC1 cycle time */
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET); /* activate cyclic operation */
- // update ec_slave state
- context->slavelist[slave].DCactive = (uint8)act;
- context->slavelist[slave].DCshift = CyclShift;
- context->slavelist[slave].DCcycle = CyclTime0;
+ // update ec_slave state
+ context->slavelist[slave].DCactive = (uint8)act;
+ context->slavelist[slave].DCshift = CyclShift;
+ context->slavelist[slave].DCcycle = CyclTime0;
}
/* latched port time of slave */
int32 ts;
switch (port)
{
- case 0:
- ts = context->slavelist[slave].DCrtA;
- break;
- case 1:
- ts = context->slavelist[slave].DCrtB;
- break;
- case 2:
- ts = context->slavelist[slave].DCrtC;
- break;
- case 3:
- ts = context->slavelist[slave].DCrtD;
- break;
- default:
- ts = 0;
- break;
+ case 0:
+ ts = context->slavelist[slave].DCrtA;
+ break;
+ case 1:
+ ts = context->slavelist[slave].DCrtB;
+ break;
+ case 2:
+ ts = context->slavelist[slave].DCrtC;
+ break;
+ case 3:
+ ts = context->slavelist[slave].DCrtD;
+ break;
+ default:
+ ts = 0;
+ break;
}
return ts;
}
{
uint8 pport = port;
uint8 aport = context->slavelist[slave].activeports;
- switch(port)
+ switch (port)
{
- case 0:
- if(aport & PORTM2)
- pport = 2;
- else if (aport & PORTM1)
- pport = 1;
- else if (aport & PORTM3)
- pport = 3;
- break;
- case 1:
- if(aport & PORTM3)
- pport = 3;
- else if (aport & PORTM0)
- pport = 0;
- else if (aport & PORTM2)
- pport = 2;
- break;
- case 2:
- if(aport & PORTM1)
- pport = 1;
- else if (aport & PORTM3)
- pport = 3;
- else if (aport & PORTM0)
- pport = 0;
- break;
- case 3:
- if(aport & PORTM0)
- pport = 0;
- else if (aport & PORTM2)
- pport = 2;
- else if (aport & PORTM1)
- pport = 1;
- break;
+ case 0:
+ if (aport & PORTM2)
+ pport = 2;
+ else if (aport & PORTM1)
+ pport = 1;
+ else if (aport & PORTM3)
+ pport = 3;
+ break;
+ case 1:
+ if (aport & PORTM3)
+ pport = 3;
+ else if (aport & PORTM0)
+ pport = 0;
+ else if (aport & PORTM2)
+ pport = 2;
+ break;
+ case 2:
+ if (aport & PORTM1)
+ pport = 1;
+ else if (aport & PORTM3)
+ pport = 3;
+ else if (aport & PORTM0)
+ pport = 0;
+ break;
+ case 3:
+ if (aport & PORTM0)
+ pport = 0;
+ else if (aport & PORTM2)
+ pport = 2;
+ else if (aport & PORTM1)
+ pport = 1;
+ break;
}
return pport;
}
context->grouplist[0].hasdc = FALSE;
ht = 0;
- ecx_BWR(context->port, 0, ECT_REG_DCTIME0, sizeof(ht), &ht, EC_TIMEOUTRET); /* latch DCrecvTimeA of all slaves */
+ ecx_BWR(context->port, 0, ECT_REG_DCTIME0, sizeof(ht), &ht, EC_TIMEOUTRET); /* latch DCrecvTimeA of all slaves */
mastertime = osal_current_time();
- mastertime.sec -= 946684800UL; /* EtherCAT uses 2000-01-01 as epoch start instead of 1970-01-01 */
+ mastertime.sec -= 946684800UL; /* EtherCAT uses 2000-01-01 as epoch start instead of 1970-01-01 */
mastertime64 = (((uint64)mastertime.sec * 1000000) + (uint64)mastertime.usec) * 1000;
for (i = 1; i <= *(context->slavecount); i++)
{
}
/* entryport is port with the lowest timestamp */
entryport = 0;
- if((nlist > 1) && (tlist[1] < tlist[entryport]))
+ if ((nlist > 1) && (tlist[1] < tlist[entryport]))
{
entryport = 1;
}
- if((nlist > 2) && (tlist[2] < tlist[entryport]))
+ if ((nlist > 2) && (tlist[2] < tlist[entryport]))
{
entryport = 2;
}
- if((nlist > 3) && (tlist[3] < tlist[entryport]))
+ if ((nlist > 3) && (tlist[3] < tlist[entryport]))
{
entryport = 3;
}
entryport = plist[entryport];
context->slavelist[i].entryport = entryport;
/* consume entryport from activeports */
- context->slavelist[i].consumedports &= (uint8)~(1 << entryport);
+ context->slavelist[i].consumedports &= (uint8) ~(1 << entryport);
/* finding DC parent of current */
parent = i;
{
child = parent;
parent = context->slavelist[parent].parent;
- }
- while (!((parent == 0) || (context->slavelist[parent].hasdc)));
+ } while (!((parent == 0) || (context->slavelist[parent].hasdc)));
/* only calculate propagation delay if slave is not the first */
if (parent > 0)
{
/* non active ports are skipped */
dt3 = ecx_porttime(context, parent, context->slavelist[i].parentport) -
ecx_porttime(context, parent,
- ecx_prevport(context, parent, context->slavelist[i].parentport));
+ ecx_prevport(context, parent, context->slavelist[i].parentport));
/* current slave has children */
/* those children's delays need to be subtracted */
if (context->slavelist[i].topology > 1)
{
dt1 = ecx_porttime(context, i,
- ecx_prevport(context, i, context->slavelist[i].entryport)) -
+ ecx_prevport(context, i, context->slavelist[i].entryport)) -
ecx_porttime(context, i, context->slavelist[i].entryport);
}
/* we are only interested in positive difference */
if ((child - parent) > 1)
{
dt2 = ecx_porttime(context, parent,
- ecx_prevport(context, parent, context->slavelist[i].parentport)) -
+ ecx_prevport(context, parent, context->slavelist[i].parentport)) -
ecx_porttime(context, parent, context->slavelist[parent].entryport);
}
if (dt2 < 0) dt2 = -dt2;
/* calculate current slave delay from delta times */
/* assumption : forward delay equals return delay */
context->slavelist[i].pdelay = ((dt3 - dt1) / 2) + dt2 +
- context->slavelist[parent].pdelay;
+ context->slavelist[parent].pdelay;
ht = htoel(context->slavelist[i].pdelay);
/* write propagation delay*/
(void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYSDELAY, sizeof(ht), &ht, EC_TIMEOUTRET);
context->slavelist[i].DCrtD = 0;
parent = context->slavelist[i].parent;
/* if non DC slave found on first position on branch hold root parent */
- if ( (parent > 0) && (context->slavelist[parent].topology > 2))
+ if ((parent > 0) && (context->slavelist[parent].topology > 2))
parenthold = parent;
/* if branch has no DC slaves consume port on root parent */
- if ( parenthold && (context->slavelist[i].topology == 1))
+ if (parenthold && (context->slavelist[i].topology == 1))
{
ecx_parentport(context, parenthold);
parenthold = 0;
#include "osal.h"
#include "oshw.h"
- /** EoE utility function to convert uint32 to eoe ip bytes.
+/** EoE utility function to convert uint32 to eoe ip bytes.
* @param[in] ip = ip in uint32
* @param[out] byte_ip = eoe ip 4th octet, 3ed octet, 2nd octet, 1st octet
*/
-static void EOE_ip_uint32_to_byte(eoe_ip4_addr_t * ip, uint8_t * byte_ip)
+static void EOE_ip_uint32_to_byte(eoe_ip4_addr_t *ip, uint8_t *byte_ip)
{
byte_ip[3] = eoe_ip4_addr1(ip); /* 1st octet */
byte_ip[2] = eoe_ip4_addr2(ip); /* 2nd octet */
}
/** EoE utility function to convert eoe ip bytes to uint32.
-* @param[in] byte_ip = eoe ip 4th octet, 3ed octet, 2nd octet, 1st octet
-* @param[out] ip = ip in uint32
-*/
-static void EOE_ip_byte_to_uint32(uint8_t * byte_ip, eoe_ip4_addr_t * ip)
+ * @param[in] byte_ip = eoe ip 4th octet, 3ed octet, 2nd octet, 1st octet
+ * @param[out] ip = ip in uint32
+ */
+static void EOE_ip_byte_to_uint32(uint8_t *byte_ip, eoe_ip4_addr_t *ip)
{
EOE_IP4_ADDR_TO_U32(ip,
- byte_ip[3], /* 1st octet */
- byte_ip[2], /* 2nd octet */
- byte_ip[1], /* 3ed octet */
- byte_ip[0]); /* 4th octet */
+ byte_ip[3], /* 1st octet */
+ byte_ip[2], /* 2nd octet */
+ byte_ip[1], /* 3ed octet */
+ byte_ip[0]); /* 4th octet */
}
/** EoE fragment data handler hook. Should not block.
-*
-* @param[in] context = context struct
-* @param[in] hook = Pointer to hook function.
-* @return 1
-*/
+ *
+ * @param[in] context = context struct
+ * @param[in] hook = Pointer to hook function.
+ * @return 1
+ */
int ecx_EOEdefinehook(ecx_contextt *context, void *hook)
{
context->EOEhook = hook;
}
/** EoE EOE set IP, blocking. Waits for response from the slave.
-*
-* @param[in] context = Context struct
-* @param[in] slave = Slave number
-* @param[in] port = Port number on slave if applicable
-* @param[in] ipparam = IP parameter data to be sent
-* @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
-* @return Workcounter from last slave response or returned result code
-*/
-int ecx_EOEsetIp(ecx_contextt *context, uint16 slave, uint8 port, eoe_param_t * ipparam, int timeout)
+ *
+ * @param[in] context = Context struct
+ * @param[in] slave = Slave number
+ * @param[in] port = Port number on slave if applicable
+ * @param[in] ipparam = IP parameter data to be sent
+ * @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
+ * @return Workcounter from last slave response or returned result code
+ */
+int ecx_EOEsetIp(ecx_contextt *context, uint16 slave, uint8 port, eoe_param_t *ipparam, int timeout)
{
ec_EOEt *EOEp, *aEOEp;
ec_mbxbuft *MbxIn, *MbxOut;
MbxIn = NULL;
MbxOut = NULL;
/* Empty slave out mailbox if something is in. Timout set to 0 */
- wkc = ecx_mbxreceive(context, slave, &MbxIn, 0);
+ wkc = ecx_mbxreceive(context, slave, &MbxIn, 0);
MbxOut = ecx_getmbx(context);
ec_clearmbx(MbxOut);
EOEp = (ec_EOEt *)MbxOut;
EOEp->mbxheader.address = htoes(0x0000);
EOEp->mbxheader.priority = 0x00;
data_offset = EOE_PARAM_OFFSET;
-
+
/* get new mailbox count value, used as session handle */
cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
context->slavelist[slave].mbx_cnt = cnt;
EOEp->mbxheader.mbxtype = ECT_MBXT_EOE + MBX_HDR_SET_CNT(cnt); /* EoE */
EOEp->frameinfo1 = htoes(EOE_HDR_FRAME_TYPE_SET(EOE_INIT_REQ) |
- EOE_HDR_FRAME_PORT_SET(port) |
- EOE_HDR_LAST_FRAGMENT);
+ EOE_HDR_FRAME_PORT_SET(port) |
+ EOE_HDR_LAST_FRAGMENT);
EOEp->frameinfo2 = 0;
-
+
if (ipparam->mac_set)
{
flags |= EOE_PARAM_MAC_INCLUDE;
if (wkc > 0) /* succeeded to place mailbox in slave ? */
{
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- MbxIn = NULL;
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
if (wkc > 0) /* succeeded to read slave response ? */
{
- aEOEp = (ec_EOEt*)MbxIn;
+ aEOEp = (ec_EOEt *)MbxIn;
/* slave response should be EoE */
if ((aEOEp->mbxheader.mbxtype & 0x0f) == ECT_MBXT_EOE)
{
}
/** EoE EOE get IP, blocking. Waits for response from the slave.
-*
-* @param[in] context = Context struct
-* @param[in] slave = Slave number
-* @param[in] port = Port number on slave if applicable
-* @param[out] ipparam = IP parameter data retrived from slave
-* @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
-* @return Workcounter from last slave response or returned result code
-*/
-int ecx_EOEgetIp(ecx_contextt *context, uint16 slave, uint8 port, eoe_param_t * ipparam, int timeout)
+ *
+ * @param[in] context = Context struct
+ * @param[in] slave = Slave number
+ * @param[in] port = Port number on slave if applicable
+ * @param[out] ipparam = IP parameter data retrived from slave
+ * @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
+ * @return Workcounter from last slave response or returned result code
+ */
+int ecx_EOEgetIp(ecx_contextt *context, uint16 slave, uint8 port, eoe_param_t *ipparam, int timeout)
{
ec_EOEt *EOEp, *aEOEp;
ec_mbxbuft *MbxIn, *MbxOut;
EOEp->mbxheader.mbxtype = ECT_MBXT_EOE + MBX_HDR_SET_CNT(cnt); /* EoE */
EOEp->frameinfo1 = htoes(EOE_HDR_FRAME_TYPE_SET(EOE_GET_IP_PARAM_REQ) |
- EOE_HDR_FRAME_PORT_SET(port) |
- EOE_HDR_LAST_FRAGMENT);
+ EOE_HDR_FRAME_PORT_SET(port) |
+ EOE_HDR_LAST_FRAGMENT);
EOEp->frameinfo2 = 0;
- EOEp->mbxheader.length = htoes(0x0004);
+ EOEp->mbxheader.length = htoes(0x0004);
EOEp->data[0] = flags;
/* send EoE request to slave */
MbxOut = NULL;
if (wkc > 0) /* succeeded to place mailbox in slave ? */
{
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- MbxIn = NULL;
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
if (wkc > 0) /* succeeded to read slave response ? */
{
- aEOEp = (ec_EOEt*)MbxIn;
+ aEOEp = (ec_EOEt *)MbxIn;
/* slave response should be FoE */
if ((aEOEp->mbxheader.mbxtype & 0x0f) == ECT_MBXT_EOE)
{
flags = aEOEp->data[0];
if (flags & EOE_PARAM_MAC_INCLUDE)
{
- memcpy(ipparam->mac.addr,
- &aEOEp->data[data_offset],
- EOE_ETHADDR_LENGTH);
+ memcpy(ipparam->mac.addr,
+ &aEOEp->data[data_offset],
+ EOE_ETHADDR_LENGTH);
ipparam->mac_set = 1;
data_offset += EOE_ETHADDR_LENGTH;
}
if (flags & EOE_PARAM_IP_INCLUDE)
{
EOE_ip_byte_to_uint32(&aEOEp->data[data_offset],
- &ipparam->ip);
+ &ipparam->ip);
ipparam->ip_set = 1;
data_offset += EOE_IP4_LENGTH;
}
if (flags & EOE_PARAM_SUBNET_IP_INCLUDE)
{
EOE_ip_byte_to_uint32(&aEOEp->data[data_offset],
- &ipparam->subnet);
+ &ipparam->subnet);
ipparam->subnet_set = 1;
data_offset += EOE_IP4_LENGTH;
}
if (flags & EOE_PARAM_DEFAULT_GATEWAY_INCLUDE)
{
EOE_ip_byte_to_uint32(&aEOEp->data[data_offset],
- &ipparam->default_gateway);
+ &ipparam->default_gateway);
ipparam->default_gateway_set = 1;
data_offset += EOE_IP4_LENGTH;
}
if (flags & EOE_PARAM_DNS_IP_INCLUDE)
{
EOE_ip_byte_to_uint32(&aEOEp->data[data_offset],
- &ipparam->dns_ip);
+ &ipparam->dns_ip);
ipparam->dns_ip_set = 1;
data_offset += EOE_IP4_LENGTH;
}
else
{
dns_len = EOE_DNS_NAME_LENGTH;
- }
+ }
/* Assume ZERO terminated string */
memcpy(ipparam->dns_name, &aEOEp->data[data_offset], dns_len);
ipparam->dns_name_set = 1;
data_offset += EOE_DNS_NAME_LENGTH;
}
/* Something os not correct, flag the error */
- if(data_offset > eoedatasize)
+ if (data_offset > eoedatasize)
{
wkc = -EC_ERR_TYPE_MBX_ERROR;
}
return wkc;
}
-/** EoE ethernet buffer write, blocking.
-*
-* If the buffer is larger than the mailbox size then the buffer is sent in
-* several fragments. The function will split the buf data in fragments and
-* send them to the slave one by one.
-*
-* @param[in] context = context struct
-* @param[in] slave = Slave number
-* @param[in] port = Port number on slave if applicable
-* @param[in] psize = Size in bytes of parameter buffer.
-* @param[in] p = Pointer to parameter buffer
-* @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
-* @return Workcounter from last slave transmission
-*/
+/** EoE ethernet buffer write, blocking.
+ *
+ * If the buffer is larger than the mailbox size then the buffer is sent in
+ * several fragments. The function will split the buf data in fragments and
+ * send them to the slave one by one.
+ *
+ * @param[in] context = context struct
+ * @param[in] slave = Slave number
+ * @param[in] port = Port number on slave if applicable
+ * @param[in] psize = Size in bytes of parameter buffer.
+ * @param[in] p = Pointer to parameter buffer
+ * @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
+ * @return Workcounter from last slave transmission
+ */
int ecx_EOEsend(ecx_contextt *context, uint16 slave, uint8 port, int psize, void *p, int timeout)
{
ec_EOEt *EOEp;
ec_mbxbuft *MbxOut;
uint16 frameinfo1, frameinfo2;
- uint8 cnt, txfragmentno;
- boolean NotLast;
+ uint8 cnt, txfragmentno;
+ boolean NotLast;
int wkc, maxdata, txframesize, txframeoffset;
- const uint8 * buf = p;
+ const uint8 *buf = p;
static uint8_t txframeno = 0;
MbxOut = NULL;
/* data section=mailbox size - 6 mbx - 4 EoEh */
- maxdata = context->slavelist[slave].mbx_l - 0x0A;
+ maxdata = context->slavelist[slave].mbx_l - 0x0A;
txframesize = psize;
txfragmentno = 0;
txframeoffset = 0;
{
MbxOut = ecx_getmbx(context);
ec_clearmbx(MbxOut);
- EOEp = (ec_EOEt*)MbxOut;
+ EOEp = (ec_EOEt *)MbxOut;
EOEp->mbxheader.address = htoes(0x0000);
EOEp->mbxheader.priority = 0x00;
cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
context->slavelist[slave].mbx_cnt = cnt;
- EOEp->mbxheader.length = htoes((uint16)(4 + txframesize)); /* no timestamp */
+ EOEp->mbxheader.length = htoes((uint16)(4 + txframesize)); /* no timestamp */
EOEp->mbxheader.mbxtype = ECT_MBXT_EOE + MBX_HDR_SET_CNT(cnt); /* EoE */
EOEp->frameinfo1 = htoes(frameinfo1);
/* send EoE request to slave */
wkc = ecx_mbxsend(context, slave, MbxOut, timeout);
MbxOut = NULL;
- if ((NotLast == TRUE) && (wkc > 0))
+ if ((NotLast == TRUE) && (wkc > 0))
{
txframeoffset += txframesize;
txfragmentno++;
return wkc;
}
-
/** EoE ethernet buffer read, blocking.
-*
-* If the buffer is larger than the mailbox size then the buffer is received
-* by several fragments. The function will assamble the fragments into
-* a complete Ethernet buffer.
-*
-* @param[in] context = context struct
-* @param[in] slave = Slave number
-* @param[in] port = Port number on slave if applicable
-* @param[in,out] psize = Size in bytes of parameter buffer.
-* @param[in] p = Pointer to parameter buffer
-* @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
-* @return Workcounter from last slave response or error code
-*/
-int ecx_EOErecv(ecx_contextt *context, uint16 slave, uint8 port, int * psize, void *p, int timeout)
+ *
+ * If the buffer is larger than the mailbox size then the buffer is received
+ * by several fragments. The function will assamble the fragments into
+ * a complete Ethernet buffer.
+ *
+ * @param[in] context = context struct
+ * @param[in] slave = Slave number
+ * @param[in] port = Port number on slave if applicable
+ * @param[in,out] psize = Size in bytes of parameter buffer.
+ * @param[in] p = Pointer to parameter buffer
+ * @param[in] timeout = Timeout in us, standard is EC_TIMEOUTRXM
+ * @return Workcounter from last slave response or error code
+ */
+int ecx_EOErecv(ecx_contextt *context, uint16 slave, uint8 port, int *psize, void *p, int timeout)
{
ec_EOEt *aEOEp;
ec_mbxbuft *MbxIn;
uint8 rxfragmentno, rxframeno;
boolean NotLast;
int wkc, buffersize, rxframesize, rxframeoffset, eoedatasize;
- uint8 * buf = p;
+ uint8 *buf = p;
MbxIn = NULL;
NotLast = TRUE;
rxfragmentno = 0;
rxframeno = 0xff;
rxframeoffset = 0;
-
+
/* Hang for a while if nothing is in */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
while ((wkc > 0) && (NotLast == TRUE))
{
- aEOEp = (ec_EOEt*)MbxIn;
+ aEOEp = (ec_EOEt *)MbxIn;
/* slave response should be FoE */
if ((aEOEp->mbxheader.mbxtype & 0x0f) == ECT_MBXT_EOE)
{
}
else
{
- if (MbxIn) ecx_dropmbx(context, MbxIn);
- MbxIn = NULL;
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ MbxIn = NULL;
/* Hang for a while if nothing is in */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
}
}
/** EoE mailbox fragment read
-*
-* Will take the data in incoming mailbox buffer and copy to destination
-* Ethernet frame buffer at given offset and update current fragment variables
-*
-* @param[in] MbxIn = Received mailbox containing fragment data
-* @param[in,out] rxfragmentno = Fragment number
-* @param[in,out] rxframesize = Frame size
-* @param[in,out] rxframeoffset = Frame offset
-* @param[in,out] rxframeno = Frame number
-* @param[in,out] psize = Size in bytes of frame buffer.
-* @param[out] p = Pointer to frame buffer
-* @return 0= if fragment OK, >0 if last fragment, <0 on error
-*/
+ *
+ * Will take the data in incoming mailbox buffer and copy to destination
+ * Ethernet frame buffer at given offset and update current fragment variables
+ *
+ * @param[in] MbxIn = Received mailbox containing fragment data
+ * @param[in,out] rxfragmentno = Fragment number
+ * @param[in,out] rxframesize = Frame size
+ * @param[in,out] rxframeoffset = Frame offset
+ * @param[in,out] rxframeno = Frame number
+ * @param[in,out] psize = Size in bytes of frame buffer.
+ * @param[out] p = Pointer to frame buffer
+ * @return 0= if fragment OK, >0 if last fragment, <0 on error
+ */
int ecx_EOEreadfragment(
- ec_mbxbuft *MbxIn,
- uint8 *rxfragmentno,
- uint16 *rxframesize,
- uint16 *rxframeoffset,
- uint16 *rxframeno,
- int *psize,
- void *p)
-{
- uint16 frameinfo1, frameinfo2, eoedatasize;
+ ec_mbxbuft *MbxIn,
+ uint8 *rxfragmentno,
+ uint16 *rxframesize,
+ uint16 *rxframeoffset,
+ uint16 *rxframeno,
+ int *psize,
+ void *p)
+{
+ uint16 frameinfo1, frameinfo2, eoedatasize;
int wkc;
- ec_EOEt * aEOEp;
- uint8 * buf;
-
+ ec_EOEt *aEOEp;
+ uint8 *buf;
+
aEOEp = (ec_EOEt *)MbxIn;
buf = p;
wkc = 0;
}
/* Make sure we're inside expected frame size */
- if (((*rxframeoffset + eoedatasize) <= *rxframesize) &&
- ((*rxframeoffset + eoedatasize) <= *psize))
+ if (((*rxframeoffset + eoedatasize) <= *rxframesize) &&
+ ((*rxframeoffset + eoedatasize) <= *psize))
{
memcpy(&buf[*rxframeoffset], aEOEp->data, eoedatasize);
*rxframeoffset += eoedatasize;
#include "oshw.h"
/* use maximum size for FOE mailbox data - header and metadata */
-#define EC_MAXFOEDATA \
- (EC_MAXMBX - \
- (sizeof(ec_mbxheadert) + \
- sizeof(uint8_t) + \
- sizeof(uint8_t) + \
+#define EC_MAXFOEDATA \
+ (EC_MAXMBX - \
+ (sizeof(ec_mbxheadert) + \
+ sizeof(uint8_t) + \
+ sizeof(uint8_t) + \
sizeof(uint32_t)))
/** FOE structure.
typedef struct PACKED
{
ec_mbxheadert MbxHeader;
- uint8 OpCode;
- uint8 Reserved;
+ uint8 OpCode;
+ uint8 Reserved;
union
{
- uint32 Password;
- uint32 PacketNumber;
- uint32 ErrorCode;
+ uint32 Password;
+ uint32 PacketNumber;
+ uint32 ErrorCode;
};
union
{
- char FileName[EC_MAXFOEDATA];
- uint8 Data[EC_MAXFOEDATA];
- char ErrorText[EC_MAXFOEDATA];
+ char FileName[EC_MAXFOEDATA];
+ uint8 Data[EC_MAXFOEDATA];
+ char ErrorText[EC_MAXFOEDATA];
};
} ec_FOEt;
PACKED_END
*/
int ecx_FOEdefinehook(ecx_contextt *context, void *hook)
{
- context->FOEhook = hook;
- return 1;
+ context->FOEhook = hook;
+ return 1;
}
/** FoE read, blocking.
do
{
worktodo = FALSE;
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
/* slave response should be FoE */
if ((aFOEp->MbxHeader.mbxtype & 0x0f) == ECT_MBXT_FOE)
{
- if(aFOEp->OpCode == ECT_FOE_DATA)
+ if (aFOEp->OpCode == ECT_FOE_DATA)
{
segmentdata = etohs(aFOEp->MbxHeader.length) - 0x0006;
packetnumber = etohl(aFOEp->PacketNumber);
}
else
{
- if(aFOEp->OpCode == ECT_FOE_ERROR)
+ if (aFOEp->OpCode == ECT_FOE_ERROR)
{
/* FoE error */
wkc = -EC_ERR_TYPE_FOE_ERROR;
}
} while (worktodo);
}
- if(MbxIn) ecx_dropmbx(context, MbxIn);
- if(MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
do
{
worktodo = FALSE;
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
{
switch (aFOEp->OpCode)
{
- case ECT_FOE_ACK:
+ case ECT_FOE_ACK:
+ {
+ packetnumber = etohl(aFOEp->PacketNumber);
+ if (packetnumber == sendpacket)
{
- packetnumber = etohl(aFOEp->PacketNumber);
- if (packetnumber == sendpacket)
+ if (context->FOEhook)
{
- if (context->FOEhook)
- {
- context->FOEhook(slave, packetnumber, psize);
- }
- tsize = psize;
- if (tsize > maxdata)
- {
- tsize = maxdata;
- }
- if(tsize || dofinalzero)
- {
- worktodo = TRUE;
- dofinalzero = FALSE;
- segmentdata = tsize;
- psize -= segmentdata;
- /* if last packet was full size, add a zero size packet as final */
- /* EOF is defined as packetsize < full packetsize */
- if (!psize && (segmentdata == maxdata))
- {
- dofinalzero = TRUE;
- }
- MbxOut = ecx_getmbx(context);
- ec_clearmbx(MbxOut);
- FOEp = (ec_FOEt *)MbxOut;
- FOEp->MbxHeader.length = htoes((uint16)(0x0006 + segmentdata));
- FOEp->MbxHeader.address = htoes(0x0000);
- FOEp->MbxHeader.priority = 0x00;
- /* get new mailbox count value */
- cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
- context->slavelist[slave].mbx_cnt = cnt;
- FOEp->MbxHeader.mbxtype = ECT_MBXT_FOE + MBX_HDR_SET_CNT(cnt); /* FoE */
- FOEp->OpCode = ECT_FOE_DATA;
- sendpacket++;
- FOEp->PacketNumber = htoel(sendpacket);
- memcpy(&FOEp->Data[0], p, segmentdata);
- p = (uint8 *)p + segmentdata;
- /* send FoE data to slave */
- wkc = ecx_mbxsend(context, slave, MbxOut, EC_TIMEOUTTXM);
- MbxOut = NULL;
- if (wkc <= 0)
- {
- worktodo = FALSE;
- }
- }
+ context->FOEhook(slave, packetnumber, psize);
}
- else
+ tsize = psize;
+ if (tsize > maxdata)
{
- /* FoE error */
- wkc = -EC_ERR_TYPE_FOE_PACKETNUMBER;
+ tsize = maxdata;
}
- break;
- }
- case ECT_FOE_BUSY:
- {
- /* resend if data has been send before */
- /* otherwise ignore */
- if (sendpacket)
+ if (tsize || dofinalzero)
{
- psize += segmentdata;
- p = (uint8 *)p - segmentdata;
- --sendpacket;
- tsize = psize;
- if (tsize > maxdata)
+ worktodo = TRUE;
+ dofinalzero = FALSE;
+ segmentdata = tsize;
+ psize -= segmentdata;
+ /* if last packet was full size, add a zero size packet as final */
+ /* EOF is defined as packetsize < full packetsize */
+ if (!psize && (segmentdata == maxdata))
{
- tsize = maxdata;
+ dofinalzero = TRUE;
}
- if(tsize || dofinalzero)
+ MbxOut = ecx_getmbx(context);
+ ec_clearmbx(MbxOut);
+ FOEp = (ec_FOEt *)MbxOut;
+ FOEp->MbxHeader.length = htoes((uint16)(0x0006 + segmentdata));
+ FOEp->MbxHeader.address = htoes(0x0000);
+ FOEp->MbxHeader.priority = 0x00;
+ /* get new mailbox count value */
+ cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
+ context->slavelist[slave].mbx_cnt = cnt;
+ FOEp->MbxHeader.mbxtype = ECT_MBXT_FOE + MBX_HDR_SET_CNT(cnt); /* FoE */
+ FOEp->OpCode = ECT_FOE_DATA;
+ sendpacket++;
+ FOEp->PacketNumber = htoel(sendpacket);
+ memcpy(&FOEp->Data[0], p, segmentdata);
+ p = (uint8 *)p + segmentdata;
+ /* send FoE data to slave */
+ wkc = ecx_mbxsend(context, slave, MbxOut, EC_TIMEOUTTXM);
+ MbxOut = NULL;
+ if (wkc <= 0)
{
- worktodo = TRUE;
- dofinalzero = FALSE;
- segmentdata = tsize;
- psize -= segmentdata;
- /* if last packet was full size, add a zero size packet as final */
- /* EOF is defined as packetsize < full packetsize */
- if (!psize && (segmentdata == maxdata))
- {
- dofinalzero = TRUE;
- }
- FOEp->MbxHeader.length = htoes((uint16)(0x0006 + segmentdata));
- FOEp->MbxHeader.address = htoes(0x0000);
- FOEp->MbxHeader.priority = 0x00;
- /* get new mailbox count value */
- cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
- context->slavelist[slave].mbx_cnt = cnt;
- FOEp->MbxHeader.mbxtype = ECT_MBXT_FOE + MBX_HDR_SET_CNT(cnt); /* FoE */
- FOEp->OpCode = ECT_FOE_DATA;
- sendpacket++;
- FOEp->PacketNumber = htoel(sendpacket);
- memcpy(&FOEp->Data[0], p, segmentdata);
- p = (uint8 *)p + segmentdata;
- /* send FoE data to slave */
- wkc = ecx_mbxsend(context, slave, (ec_mbxbuft *)&MbxOut, EC_TIMEOUTTXM);
- if (wkc <= 0)
- {
- worktodo = FALSE;
- }
+ worktodo = FALSE;
}
}
- break;
}
- case ECT_FOE_ERROR:
+ else
{
/* FoE error */
- if (aFOEp->ErrorCode == 0x8001)
+ wkc = -EC_ERR_TYPE_FOE_PACKETNUMBER;
+ }
+ break;
+ }
+ case ECT_FOE_BUSY:
+ {
+ /* resend if data has been send before */
+ /* otherwise ignore */
+ if (sendpacket)
+ {
+ psize += segmentdata;
+ p = (uint8 *)p - segmentdata;
+ --sendpacket;
+ tsize = psize;
+ if (tsize > maxdata)
{
- wkc = -EC_ERR_TYPE_FOE_FILE_NOTFOUND;
+ tsize = maxdata;
}
- else
+ if (tsize || dofinalzero)
{
- wkc = -EC_ERR_TYPE_FOE_ERROR;
+ worktodo = TRUE;
+ dofinalzero = FALSE;
+ segmentdata = tsize;
+ psize -= segmentdata;
+ /* if last packet was full size, add a zero size packet as final */
+ /* EOF is defined as packetsize < full packetsize */
+ if (!psize && (segmentdata == maxdata))
+ {
+ dofinalzero = TRUE;
+ }
+ FOEp->MbxHeader.length = htoes((uint16)(0x0006 + segmentdata));
+ FOEp->MbxHeader.address = htoes(0x0000);
+ FOEp->MbxHeader.priority = 0x00;
+ /* get new mailbox count value */
+ cnt = ec_nextmbxcnt(context->slavelist[slave].mbx_cnt);
+ context->slavelist[slave].mbx_cnt = cnt;
+ FOEp->MbxHeader.mbxtype = ECT_MBXT_FOE + MBX_HDR_SET_CNT(cnt); /* FoE */
+ FOEp->OpCode = ECT_FOE_DATA;
+ sendpacket++;
+ FOEp->PacketNumber = htoel(sendpacket);
+ memcpy(&FOEp->Data[0], p, segmentdata);
+ p = (uint8 *)p + segmentdata;
+ /* send FoE data to slave */
+ wkc = ecx_mbxsend(context, slave, (ec_mbxbuft *)&MbxOut, EC_TIMEOUTTXM);
+ if (wkc <= 0)
+ {
+ worktodo = FALSE;
+ }
}
- break;
}
- default:
+ break;
+ }
+ case ECT_FOE_ERROR:
+ {
+ /* FoE error */
+ if (aFOEp->ErrorCode == 0x8001)
{
- /* unexpected mailbox received */
- wkc = -EC_ERR_TYPE_PACKET_ERROR;
- break;
+ wkc = -EC_ERR_TYPE_FOE_FILE_NOTFOUND;
+ }
+ else
+ {
+ wkc = -EC_ERR_TYPE_FOE_ERROR;
}
+ break;
+ }
+ default:
+ {
+ /* unexpected mailbox received */
+ wkc = -EC_ERR_TYPE_PACKET_ERROR;
+ break;
+ }
}
}
else
}
} while (worktodo);
}
- if(MbxIn) ecx_dropmbx(context, MbxIn);
- if(MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
#include "osal.h"
#include "oshw.h"
-
/** delay in us for eeprom ready loop */
-#define EC_LOCALDELAY 200
+#define EC_LOCALDELAY 200
/** record for ethercat eeprom communications */
PACKED_BEGIN
typedef struct PACKED
{
- uint16 comm;
- uint16 addr;
- uint16 d2;
+ uint16 comm;
+ uint16 addr;
+ uint16 d2;
} ec_eepromt;
PACKED_END
PACKED_BEGIN
typedef struct PACKED
{
- ec_mbxheadert MbxHeader;
- uint16 Type;
- uint16 Detail;
+ ec_mbxheadert MbxHeader;
+ uint16 Type;
+ uint16 Detail;
} ec_mbxerrort;
PACKED_END
PACKED_BEGIN
typedef struct PACKED
{
- ec_mbxheadert MbxHeader;
- uint16 CANOpen;
- uint16 ErrorCode;
- uint8 ErrorReg;
- uint8 bData;
- uint16 w1,w2;
+ ec_mbxheadert MbxHeader;
+ uint16 CANOpen;
+ uint16 ErrorCode;
+ uint8 ErrorReg;
+ uint8 bData;
+ uint16 w1, w2;
} ec_emcyt;
PACKED_END
*
* @return First element in list over available network adapters.
*/
-ec_adaptert * ec_find_adapters (void)
+ec_adaptert *ec_find_adapters(void)
{
- ec_adaptert * ret_adapter;
+ ec_adaptert *ret_adapter;
- ret_adapter = oshw_find_adapters ();
+ ret_adapter = oshw_find_adapters();
return ret_adapter;
}
*
* @param[in] adapter = Struct holding adapter name, description and pointer to next.
*/
-void ec_free_adapters (ec_adaptert * adapter)
+void ec_free_adapters(ec_adaptert *adapter)
{
- oshw_free_adapters (adapter);
+ oshw_free_adapters(adapter);
}
/** Pushes an error on the error list.
* @param[in] Slave = Slave number
* @param[in] Detail = Following EtherCAT specification
*/
-static void ecx_mbxerror(ecx_contextt *context, uint16 Slave,uint16 Detail)
+static void ecx_mbxerror(ecx_contextt *context, uint16 Slave, uint16 Detail)
{
ec_errort Ec;
* @param[in] w1
* @param[in] w2
*/
-static void ecx_mbxemergencyerror(ecx_contextt *context, uint16 Slave,uint16 ErrorCode,uint16 ErrorReg,
- uint8 b1, uint16 w1, uint16 w2)
+static void ecx_mbxemergencyerror(ecx_contextt *context, uint16 Slave, uint16 ErrorCode, uint16 ErrorReg,
+ uint8 b1, uint16 w1, uint16 w2)
{
ec_errort Ec;
* @param[in] ifname = Dev name, f.e. "eth0"
* @return >0 if OK
*/
-int ecx_init(ecx_contextt *context, const char * ifname)
+int ecx_init(ecx_contextt *context, const char *ifname)
{
ecx_initmbxpool(context);
return ecx_setupnic(context->port, ifname, FALSE);
ec_mbxbuft *mbx = NULL;
ec_mbxpoolt *mbxpool = context->mbxpool;
osal_mutex_lock(mbxpool->mbxmutex);
- if(mbxpool->listcount > 0)
+ if (mbxpool->listcount > 0)
{
mbx = (ec_mbxbuft *)&(mbxpool->mbx[mbxpool->mbxemptylist[mbxpool->listtail]]);
-// printf("getmbx item:%d mbx:%p\n\r",mbxpool->mbxemptylist[mbxpool->listtail], mbx);
+ // printf("getmbx item:%d mbx:%p\n\r",mbxpool->mbxemptylist[mbxpool->listtail], mbx);
mbxpool->listtail++;
- if(mbxpool->listtail >= EC_MBXPOOLSIZE) mbxpool->listtail = 0;
+ if (mbxpool->listtail >= EC_MBXPOOLSIZE) mbxpool->listtail = 0;
mbxpool->listcount--;
}
osal_mutex_unlock(mbxpool->mbxmutex);
{
ec_mbxpoolt *mbxpool = context->mbxpool;
int item = mbx - &(mbxpool->mbx[0]);
-// printf("dropmbx item:%d mbx:%p\n\r",item, mbx);
- if((item >= 0) && (item < EC_MBXPOOLSIZE))
+ // printf("dropmbx item:%d mbx:%p\n\r",item, mbx);
+ if ((item >= 0) && (item < EC_MBXPOOLSIZE))
{
osal_mutex_lock(mbxpool->mbxmutex);
mbxpool->mbxemptylist[mbxpool->listhead++] = item;
- if(mbxpool->listhead >= EC_MBXPOOLSIZE) mbxpool->listhead = 0;
+ if (mbxpool->listhead >= EC_MBXPOOLSIZE) mbxpool->listhead = 0;
mbxpool->listcount++;
osal_mutex_unlock(mbxpool->mbxmutex);
return 1;
int retval = 0;
ec_mbxpoolt *mbxpool = context->mbxpool;
mbxpool->mbxmutex = (osal_mutext *)osal_mutex_create();
- for(int item = 0 ; item < EC_MBXPOOLSIZE ; item++)
+ for (int item = 0; item < EC_MBXPOOLSIZE; item++)
{
mbxpool->mbxemptylist[item] = item;
}
mbxpool->listhead = 0;
mbxpool->listtail = 0;
mbxpool->listcount = EC_MBXPOOLSIZE;
- // printf("intmbxpool mbxp:%p mutex:%p\n\r", mbxpool->mbx[0], mbxpool->mbxmutex);
+ // printf("intmbxpool mbxp:%p mutex:%p\n\r", mbxpool->mbx[0], mbxpool->mbxmutex);
return retval;
}
mbxqueue->listhead = 0;
mbxqueue->listtail = 0;
mbxqueue->listcount = 0;
- for(cnt = 0 ; cnt < EC_MBXPOOLSIZE ; cnt++)
+ for (cnt = 0; cnt < EC_MBXPOOLSIZE; cnt++)
mbxqueue->mbxticket[cnt] = -1;
return retval;
}
uint8 group = context->slavelist[slave].group;
ec_mbxqueuet *mbxqueue = &(context->grouplist[group].mbxtxqueue);
osal_mutex_lock(mbxqueue->mbxmutex);
- if((mbxqueue->listcount < EC_MBXPOOLSIZE))
+ if ((mbxqueue->listcount < EC_MBXPOOLSIZE))
{
ticketloc = mbxqueue->listhead;
- while((++ticket < EC_MBXPOOLSIZE) && (mbxqueue->mbxticket[ticket] >= 0)) {};
+ while ((++ticket < EC_MBXPOOLSIZE) && (mbxqueue->mbxticket[ticket] >= 0))
+ {
+ };
mbxqueue->mbxticket[ticket] = ticketloc;
mbxqueue->mbxslave[ticketloc] = slave;
mbxqueue->mbx[ticketloc] = mbx;
mbxqueue->listhead++;
- if(mbxqueue->listhead >= EC_MBXPOOLSIZE) mbxqueue->listhead = 0;
+ if (mbxqueue->listhead >= EC_MBXPOOLSIZE) mbxqueue->listhead = 0;
mbxqueue->mbxremove[ticketloc] = 0;
mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_REQ;
mbxqueue->listcount++;
int ecx_mbxdonequeue(ecx_contextt *context, uint16 slave, int ticket)
{
int retval = 0;
- if((ticket >= 0) && (ticket < EC_MBXPOOLSIZE))
+ if ((ticket >= 0) && (ticket < EC_MBXPOOLSIZE))
{
uint8 group = context->slavelist[slave].group;
ec_mbxqueuet *mbxqueue = &(context->grouplist[group].mbxtxqueue);
osal_mutex_lock(mbxqueue->mbxmutex);
- if(mbxqueue->mbxstate[mbxqueue->mbxticket[ticket]] == EC_MBXQUEUESTATE_DONE)
+ if (mbxqueue->mbxstate[mbxqueue->mbxticket[ticket]] == EC_MBXQUEUESTATE_DONE)
{
mbxqueue->mbxremove[mbxqueue->mbxticket[ticket]] = 1;
mbxqueue->mbxticket[ticket] = -1;
int ecx_mbxexpirequeue(ecx_contextt *context, uint16 slave, int ticket)
{
int retval = 0;
- if((ticket >= 0) && (ticket < EC_MBXPOOLSIZE))
+ if ((ticket >= 0) && (ticket < EC_MBXPOOLSIZE))
{
uint8 group = context->slavelist[slave].group;
ec_mbxqueuet *mbxqueue = &(context->grouplist[group].mbxtxqueue);
osal_mutex_lock(mbxqueue->mbxmutex);
- if(mbxqueue->mbxstate[mbxqueue->mbxticket[ticket]] > EC_MBXQUEUESTATE_NONE)
+ if (mbxqueue->mbxstate[mbxqueue->mbxticket[ticket]] > EC_MBXQUEUESTATE_NONE)
{
mbxqueue->mbxremove[mbxqueue->mbxticket[ticket]] = 1;
mbxqueue->mbxticket[ticket] = -1;
osal_mutex_lock(mbxqueue->mbxmutex);
int head = mbxqueue->listhead;
int tail = mbxqueue->listtail;
- if(head != tail)
+ if (head != tail)
{
- while((cnt < EC_MBXPOOLSIZE) && (mbxqueue->mbxticket[cnt] != ticketloc)) cnt++;
+ while ((cnt < EC_MBXPOOLSIZE) && (mbxqueue->mbxticket[cnt] != ticketloc))
+ cnt++;
ticket = cnt;
- if((ticket >= 0) && (ticket < EC_MBXPOOLSIZE))
+ if ((ticket >= 0) && (ticket < EC_MBXPOOLSIZE))
{
mbxqueue->mbxticket[ticket] = head;
mbxqueue->mbxremove[head] = mbxqueue->mbxremove[tail];
mbxqueue->mbxslave[head] = mbxqueue->mbxslave[tail];
mbxqueue->mbx[head] = mbxqueue->mbx[tail];
mbxqueue->listhead++;
- if(mbxqueue->listhead >= EC_MBXPOOLSIZE) mbxqueue->listhead = 0;
+ if (mbxqueue->listhead >= EC_MBXPOOLSIZE) mbxqueue->listhead = 0;
mbxqueue->listtail++;
- if(mbxqueue->listtail >= EC_MBXPOOLSIZE) mbxqueue->listtail = 0;
+ if (mbxqueue->listtail >= EC_MBXPOOLSIZE) mbxqueue->listtail = 0;
retval = 1;
}
}
- else
+ else
{
retval = 1;
}
int ecx_slavembxcyclic(ecx_contextt *context, uint16 slave)
{
- if(context->slavelist[slave].mbxstatus)
+ if (context->slavelist[slave].mbxstatus)
{
context->slavelist[slave].coembxin = EC_MBXINENABLE;
context->slavelist[slave].mbxhandlerstate = ECT_MBXH_CYCLIC;
{
ec_mbxbuft *mbx;
ec_mbxqueuet *mbxqueue = &(context->grouplist[group].mbxtxqueue);
-// printf("mbxgetqueue item:%d mbx:%p\n\r",item, mbx);
+ // printf("mbxgetqueue item:%d mbx:%p\n\r",item, mbx);
osal_mutex_lock(mbxqueue->mbxmutex);
mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_NONE;
mbxqueue->mbxremove[ticketloc] = 0;
mbx = mbxqueue->mbx[ticketloc];
mbxqueue->mbx[ticketloc] = NULL;
mbxqueue->listtail++;
- if(mbxqueue->listtail >= EC_MBXPOOLSIZE) mbxqueue->listtail = 0;
+ if (mbxqueue->listtail >= EC_MBXPOOLSIZE) mbxqueue->listtail = 0;
mbxqueue->listcount--;
osal_mutex_unlock(mbxqueue->mbxmutex);
return mbx;
}
-
+
/** Read one byte from slave EEPROM via cache.
* If the cache location is empty then a read request is made to the slave.
* Depending on the slave capabilities the request is 4 or 8 bytes.
uint64 edat64;
uint32 edat32;
uint16 mapw, mapb;
- int lp,cnt;
+ int lp, cnt;
uint8 retval;
retval = 0xff;
configadr = context->slavelist[slave].configadr;
ecx_eeprom2master(context, slave); /* set eeprom control to master */
eadr = address >> 1;
- edat64 = ecx_readeepromFP (context, configadr, eadr, EC_TIMEOUTEEP);
+ edat64 = ecx_readeepromFP(context, configadr, eadr, EC_TIMEOUTEEP);
/* 8 byte response */
if (context->slavelist[slave].eep_8byte)
{
/* find bitmap location */
mapw = eadr >> 4;
mapb = (uint16)((eadr << 1) - (mapw << 5));
- for(lp = 0 ; lp < cnt ; lp++)
+ for (lp = 0; lp < cnt; lp++)
{
/* set bitmap for each byte that is read */
context->esimap[mapw] |= (1U << mapb);
*/
void ecx_siistring(ecx_contextt *context, char *str, uint16 slave, uint16 Sn)
{
- uint16 a,i,j,l,n,ba;
+ uint16 a, i, j, l, n, ba;
char *ptr;
uint8 eectl = context->slavelist[slave].eep_pdi;
ptr = str;
- a = ecx_siifind (context, slave, ECT_SII_STRING); /* find string section */
+ a = ecx_siifind(context, slave, ECT_SII_STRING); /* find string section */
if (a > 0)
{
- ba = a + 2; /* skip SII section header */
+ ba = a + 2; /* skip SII section header */
n = ecx_siigetbyte(context, slave, ba++); /* read number of strings in section */
- if (Sn <= n) /* is req string available? */
+ if (Sn <= n) /* is req string available? */
{
for (i = 1; i <= Sn; i++) /* walk through strings */
{
ptr = str;
for (j = 1; j <= l; j++) /* copy one string */
{
- if(j <= EC_MAXNAME)
+ if (j <= EC_MAXNAME)
{
*ptr = (char)ecx_siigetbyte(context, slave, ba++);
ptr++;
* @param[out] FMMU = FMMU struct from SII, max. 4 FMMU's
* @return number of FMMU's defined in section
*/
-uint16 ecx_siiFMMU(ecx_contextt *context, uint16 slave, ec_eepromFMMUt* FMMU)
+uint16 ecx_siiFMMU(ecx_contextt *context, uint16 slave, ec_eepromFMMUt *FMMU)
{
- uint16 a;
+ uint16 a;
uint8 eectl = context->slavelist[slave].eep_pdi;
FMMU->nFMMU = 0;
* @param[out] SM = first SM struct from SII
* @return number of SM's defined in section
*/
-uint16 ecx_siiSM(ecx_contextt *context, uint16 slave, ec_eepromSMt* SM)
+uint16 ecx_siiSM(ecx_contextt *context, uint16 slave, ec_eepromSMt *SM)
{
- uint16 a,w;
+ uint16 a, w;
uint8 eectl = context->slavelist[slave].eep_pdi;
SM->nSM = 0;
* @param[in] n = SM number
* @return >0 if OK
*/
-uint16 ecx_siiSMnext(ecx_contextt *context, uint16 slave, ec_eepromSMt* SM, uint16 n)
+uint16 ecx_siiSMnext(ecx_contextt *context, uint16 slave, ec_eepromSMt *SM, uint16 n)
{
uint16 a;
uint16 retVal = 0;
* @param[in] t = 0=RXPDO 1=TXPDO
* @return mapping size in bits of PDO
*/
-uint32 ecx_siiPDO(ecx_contextt *context, uint16 slave, ec_eepromPDOt* PDO, uint8 t)
+uint32 ecx_siiPDO(ecx_contextt *context, uint16 slave, ec_eepromPDOt *PDO, uint8 t)
{
- uint16 a , w, c, e, er, Size;
+ uint16 a, w, c, e, er, Size;
uint8 eectl = context->slavelist[slave].eep_pdi;
Size = 0;
PDO->nPDO = 0;
PDO->Length = 0;
PDO->Index[1] = 0;
- for (c = 0 ; c < EC_MAXSM ; c++) PDO->SMbitsize[c] = 0;
+ for (c = 0; c < EC_MAXSM; c++)
+ PDO->SMbitsize[c] = 0;
if (t > 1)
t = 1;
PDO->Startpos = ecx_siifind(context, slave, ECT_SII_PDO + t);
PDO->BitSize[PDO->nPDO] += ecx_siigetbyte(context, slave, a++);
a += 2;
}
- PDO->SMbitsize[ PDO->SyncM[PDO->nPDO] ] += PDO->BitSize[PDO->nPDO];
+ PDO->SMbitsize[PDO->SyncM[PDO->nPDO]] += PDO->BitSize[PDO->nPDO];
Size += PDO->BitSize[PDO->nPDO];
c++;
}
{
c = PDO->Length; /* limit number of PDO entries in buffer */
}
- }
- while (c < PDO->Length);
+ } while (c < PDO->Length);
}
if (eectl)
{
idx = ecx_getindex(port);
slcnt = 0;
ecx_setupdatagram(port, &(port->txbuf[idx]), EC_CMD_FPRD, idx,
- *(configlst + slcnt), ECT_REG_ALSTAT, sizeof(ec_alstatust), slstatlst + slcnt);
+ *(configlst + slcnt), ECT_REG_ALSTAT, sizeof(ec_alstatust), slstatlst + slcnt);
sldatapos[slcnt] = EC_HEADERSIZE;
- while(++slcnt < (n - 1))
+ while (++slcnt < (n - 1))
{
sldatapos[slcnt] = ecx_adddatagram(port, &(port->txbuf[idx]), EC_CMD_FPRD, idx, TRUE,
- *(configlst + slcnt), ECT_REG_ALSTAT, sizeof(ec_alstatust), slstatlst + slcnt);
+ *(configlst + slcnt), ECT_REG_ALSTAT, sizeof(ec_alstatust), slstatlst + slcnt);
}
- if(slcnt < n)
+ if (slcnt < n)
{
sldatapos[slcnt] = ecx_adddatagram(port, &(port->txbuf[idx]), EC_CMD_FPRD, idx, FALSE,
- *(configlst + slcnt), ECT_REG_ALSTAT, sizeof(ec_alstatust), slstatlst + slcnt);
+ *(configlst + slcnt), ECT_REG_ALSTAT, sizeof(ec_alstatust), slstatlst + slcnt);
}
wkc = ecx_srconfirm(port, idx, timeout);
if (wkc >= 0)
{
- for(slcnt = 0 ; slcnt < n ; slcnt++)
+ for (slcnt = 0; slcnt < n; slcnt++)
{
memcpy(slstatlst + slcnt, &(port->rxbuf[idx][sldatapos[slcnt]]), sizeof(ec_alstatust));
}
rval = 0;
wkc = ecx_BRD(context->port, 0, ECT_REG_ALSTAT, sizeof(rval), &rval, EC_TIMEOUTRET);
- if(wkc >= *(context->slavecount))
+ if (wkc >= *(context->slavecount))
{
allslavespresent = TRUE;
}
{
noerrorflag = TRUE;
context->slavelist[0].ALstatuscode = 0;
- }
+ }
else
{
noerrorflag = FALSE;
switch (bitwisestate)
{
- /* Note: BOOT State collides with PRE_OP | INIT and cannot be used here */
- case EC_STATE_INIT:
- case EC_STATE_PRE_OP:
- case EC_STATE_SAFE_OP:
- case EC_STATE_OPERATIONAL:
- allslavessamestate = TRUE;
- context->slavelist[0].state = bitwisestate;
- break;
- default:
- allslavessamestate = FALSE;
- break;
+ /* Note: BOOT State collides with PRE_OP | INIT and cannot be used here */
+ case EC_STATE_INIT:
+ case EC_STATE_PRE_OP:
+ case EC_STATE_SAFE_OP:
+ case EC_STATE_OPERATIONAL:
+ allslavessamestate = TRUE;
+ context->slavelist[0].state = bitwisestate;
+ break;
+ default:
+ allslavessamestate = FALSE;
+ break;
}
-
+
if (noerrorflag && allslavessamestate && allslavespresent)
{
/* No slave has toggled the error flag so the alstatuscode
fslave = 1;
do
{
- lslave = (uint16)*(context->slavecount);
+ lslave = (uint16) * (context->slavecount);
if ((lslave - fslave) >= MAX_FPRD_MULTI)
{
lslave = fslave + MAX_FPRD_MULTI - 1;
}
for (slave = fslave; slave <= lslave; slave++)
{
- const ec_alstatust zero = { 0, 0, 0 };
+ const ec_alstatust zero = {0, 0, 0};
configadr = context->slavelist[slave].configadr;
slca[slave - fslave] = configadr;
} while (lslave < *(context->slavecount));
context->slavelist[0].state = lowest;
}
-
+
return lowest;
}
{
slstate = htoes(context->slavelist[slave].state);
ret = ecx_BWR(context->port, 0, ECT_REG_ALCTL, sizeof(slstate),
- &slstate, EC_TIMEOUTRET3);
+ &slstate, EC_TIMEOUTRET3);
}
else
{
configadr = context->slavelist[slave].configadr;
ret = ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL,
- htoes(context->slavelist[slave].state), EC_TIMEOUTRET3);
+ htoes(context->slavelist[slave].state), EC_TIMEOUTRET3);
}
return ret;
}
ec_alstatust slstat;
osal_timert timer;
- if ( slave > *(context->slavecount) )
+ if (slave > *(context->slavecount))
{
return 0;
}
if (slave < 1)
{
rval = 0;
- ecx_BRD(context->port, 0, ECT_REG_ALSTAT, sizeof(rval), &rval , EC_TIMEOUTRET);
+ ecx_BRD(context->port, 0, ECT_REG_ALSTAT, sizeof(rval), &rval, EC_TIMEOUTRET);
rval = etohs(rval);
}
else
{
osal_usleep(1000);
}
- }
- while ((state != reqstate) && (osal_timer_is_expired(&timer) == FALSE));
+ } while ((state != reqstate) && (osal_timer_is_expired(&timer) == FALSE));
context->slavelist[slave].state = rval;
return state;
*/
void ec_clearmbx(ec_mbxbuft *Mbx)
{
- if(Mbx)
- memset(Mbx, 0x00, EC_MAXMBX);
+ if (Mbx)
+ memset(Mbx, 0x00, EC_MAXMBX);
}
int ecx_clearmbxstatus(ecx_contextt *context, uint8 group)
{
- if(context->grouplist[group].mbxstatus && context->grouplist[group].mbxstatuslength)
+ if (context->grouplist[group].mbxstatus && context->grouplist[group].mbxstatuslength)
{
memset(context->grouplist[group].mbxstatus, 0x00, context->grouplist[group].mbxstatuslength);
return 1;
int ecx_readmbxstatus(ecx_contextt *context, uint16 slave, uint8 *SMstat)
{
int wkc = 0;
- if(context->slavelist[slave].mbxhandlerstate == ECT_MBXH_CYCLIC)
+ if (context->slavelist[slave].mbxhandlerstate == ECT_MBXH_CYCLIC)
{
*SMstat = *(context->slavelist[slave].mbxstatus);
wkc = 1;
}
else
- {
+ {
uint16 configadr = context->slavelist[slave].configadr;
wkc = ecx_FPRD(context->port, configadr, ECT_REG_SM1STAT, sizeof(uint8), SMstat, EC_TIMEOUTRET);
}
{
osal_usleep(EC_LOCALDELAY);
}
- }
- while (((wkc <= 0) || ((SMstat & 0x08) != 0)) && (osal_timer_is_expired(&timer) == FALSE));
+ } while (((wkc <= 0) || ((SMstat & 0x08) != 0)) && (osal_timer_is_expired(&timer) == FALSE));
if ((wkc > 0) && ((SMstat & 0x08) == 0))
{
ec_mbxerrort *MBXEp;
uint8 SMcontr;
uint16 SMstatex;
-
+
limitcnt = 0;
int firstmbxpos = context->grouplist[group].lastmbxpos + 1;
int maxcntstored = maxcnt;
/* iterate over all possible mailbox slaves */
- for(cnt = 0 ; cnt < maxcnt ; cnt++)
+ for (cnt = 0; cnt < maxcnt; cnt++)
{
/* start from last stored slave position to allow fair handling under load */
- cntoffset = firstmbxpos + cnt;
- if(cntoffset >= maxcntstored) cntoffset -= maxcntstored;
+ cntoffset = firstmbxpos + cnt;
+ if (cntoffset >= maxcntstored) cntoffset -= maxcntstored;
context->grouplist[group].lastmbxpos = cntoffset;
uint16 slave = context->grouplist[group].mbxstatuslookup[cntoffset];
ec_slavet *slaveitem = &context->slavelist[slave];
uint16 configadr = slaveitem->configadr;
/* cyclic handler enabled for this slave */
- if(slaveitem->mbxhandlerstate == ECT_MBXH_CYCLIC)
+ if (slaveitem->mbxhandlerstate == ECT_MBXH_CYCLIC)
{
/* handle robust mailbox protocol state machine */
- if(slaveitem->mbxrmpstate)
+ if (slaveitem->mbxrmpstate)
{
- if(slaveitem->islost)
+ if (slaveitem->islost)
{
- slaveitem->mbxrmpstate = 0;
+ slaveitem->mbxrmpstate = 0;
}
else
{
- switch(slaveitem->mbxrmpstate)
+ switch (slaveitem->mbxrmpstate)
{
- case 1 :
- if(ecx_readmbxstatusex(context, slave, &(slaveitem->mbxinstateex)) > 0)
- {
- slaveitem->mbxinstateex ^= 0x0200; /* toggle repeat request */
- slaveitem->mbxrmpstate++;
- }
- break;
- case 2 :
- SMstatex = htoes(slaveitem->mbxinstateex);
- if(ecx_FPWR(context->port, configadr, ECT_REG_SM1STAT, sizeof(SMstatex), &(slaveitem->mbxinstateex), EC_TIMEOUTRET) > 0)
- {
- slaveitem->mbxrmpstate++;
- }
- break;
- case 3 :
- /* wait for repeat ack */
- SMstatex = htoes(slaveitem->mbxinstateex);
- wkc2 = ecx_FPRD(context->port, configadr, ECT_REG_SM1CONTR, sizeof(SMcontr), &SMcontr, EC_TIMEOUTRET);
- if((wkc2 > 0) && ((SMcontr & 0x02) == (HI_BYTE(SMstatex) & 0x02)))
- {
- slaveitem->mbxrmpstate = 0;
- }
- break;
+ case 1:
+ if (ecx_readmbxstatusex(context, slave, &(slaveitem->mbxinstateex)) > 0)
+ {
+ slaveitem->mbxinstateex ^= 0x0200; /* toggle repeat request */
+ slaveitem->mbxrmpstate++;
+ }
+ break;
+ case 2:
+ SMstatex = htoes(slaveitem->mbxinstateex);
+ if (ecx_FPWR(context->port, configadr, ECT_REG_SM1STAT, sizeof(SMstatex), &(slaveitem->mbxinstateex), EC_TIMEOUTRET) > 0)
+ {
+ slaveitem->mbxrmpstate++;
+ }
+ break;
+ case 3:
+ /* wait for repeat ack */
+ SMstatex = htoes(slaveitem->mbxinstateex);
+ wkc2 = ecx_FPRD(context->port, configadr, ECT_REG_SM1CONTR, sizeof(SMcontr), &SMcontr, EC_TIMEOUTRET);
+ if ((wkc2 > 0) && ((SMcontr & 0x02) == (HI_BYTE(SMstatex) & 0x02)))
+ {
+ slaveitem->mbxrmpstate = 0;
+ }
+ break;
}
/* keep track of work limit */
- if(++limitcnt >= limit) maxcnt = 0;
+ if (++limitcnt >= limit) maxcnt = 0;
}
}
/* mbxin full detected */
- else if((*(context->grouplist[group].mbxstatus + cntoffset) & 0x08) > 0)
+ else if ((*(context->grouplist[group].mbxstatus + cntoffset) & 0x08) > 0)
{
uint16 mbxl = slaveitem->mbx_rl;
uint16 mbxro = slaveitem->mbx_ro;
- if((mbxl > 0) && (mbx = ecx_getmbx(context)))
+ if ((mbxl > 0) && (mbx = ecx_getmbx(context)))
{
/* keep track of work limit */
- if(++limitcnt >= limit) maxcnt = 0;
+ if (++limitcnt >= limit) maxcnt = 0;
wkc = ecx_FPRD(context->port, configadr, mbxro, mbxl, mbx, EC_TIMEOUTRET); /* get mailbox */
- if(wkc > 0)
+ if (wkc > 0)
{
mbxh = (ec_mbxheadert *)mbx;
if ((mbxh->mbxtype & 0x0f) == ECT_MBXT_ERR) /* Mailbox error response? */
if ((etohs(EMp->CANOpen) >> 12) == 0x01) /* Emergency request? */
{
ecx_mbxemergencyerror(context, slave, etohs(EMp->ErrorCode), EMp->ErrorReg,
- EMp->bData, etohs(EMp->w1), etohs(EMp->w2));
+ EMp->bData, etohs(EMp->w1), etohs(EMp->w2));
}
else
{
- if(slaveitem->coembxin && (slaveitem->coembxinfull == FALSE))
+ if (slaveitem->coembxin && (slaveitem->coembxinfull == FALSE))
{
slaveitem->coembxin = (uint8 *)mbx;
mbx = NULL;
}
else if ((mbxh->mbxtype & 0x0f) == ECT_MBXT_SOE) /* SoE response? */
{
- if(slaveitem->soembxin && (slaveitem->soembxinfull == FALSE))
+ if (slaveitem->soembxin && (slaveitem->soembxinfull == FALSE))
{
slaveitem->soembxin = (uint8 *)mbx;
mbx = NULL;
}
else if ((mbxh->mbxtype & 0x0f) == ECT_MBXT_EOE) /* EoE response? */
{
- ec_EOEt *eoembx = (ec_EOEt*)mbx;
+ ec_EOEt *eoembx = (ec_EOEt *)mbx;
uint16 frameinfo1 = etohs(eoembx->frameinfo1);
/* All non fragment data frame types are expected to be handled by
* slave send/receive API if the EoE hook is set
{
/* Fragment handled by EoE hook */
wkc = 0;
- }
+ }
}
}
/* Not handled by hook */
- if((wkc > 0) && slaveitem->eoembxin && (slaveitem->eoembxinfull == FALSE))
+ if ((wkc > 0) && slaveitem->eoembxin && (slaveitem->eoembxinfull == FALSE))
{
slaveitem->eoembxin = (uint8 *)mbx;
mbx = NULL;
}
else if ((mbxh->mbxtype & 0x0f) == ECT_MBXT_FOE) /* FoE response? */
{
- if(slaveitem->foembxin && (slaveitem->foembxinfull == FALSE))
+ if (slaveitem->foembxin && (slaveitem->foembxinfull == FALSE))
{
slaveitem->foembxin = (uint8 *)mbx;
mbx = NULL;
}
else if ((mbxh->mbxtype & 0x0f) == ECT_MBXT_VOE) /* VoE response? */
{
- if(slaveitem->voembxin && (slaveitem->voembxinfull == FALSE))
- {
+ if (slaveitem->voembxin && (slaveitem->voembxinfull == FALSE))
+ {
slaveitem->voembxin = (uint8 *)mbx;
mbx = NULL;
slaveitem->voembxinfull = TRUE;
}
else if ((mbxh->mbxtype & 0x0f) == ECT_MBXT_AOE) /* AoE response? */
{
- if(slaveitem->aoembxin && (slaveitem->aoembxinfull == FALSE))
+ if (slaveitem->aoembxin && (slaveitem->aoembxinfull == FALSE))
{
slaveitem->aoembxin = (uint8 *)mbx;
mbx = NULL;
}
}
}
- }
- }
+ }
+ }
return limitcnt;
}
ec_mbxbuft *mbx;
ec_mbxqueuet *mbxqueue = &(context->grouplist[group].mbxtxqueue);
int listcount = mbxqueue->listcount;
- while((limitcnt <= limit) && listcount)
+ while ((limitcnt <= limit) && listcount)
{
listcount--;
ticketloc = mbxqueue->listtail;
state = mbxqueue->mbxstate[ticketloc];
- switch(state)
+ switch (state)
{
- case EC_MBXQUEUESTATE_REQ :
- case EC_MBXQUEUESTATE_FAIL:
- slave = mbxqueue->mbxslave[ticketloc];
- mbx = mbxqueue->mbx[ticketloc];
- mbxl = context->slavelist[slave].mbx_l;
- configadr = context->slavelist[slave].configadr;
- mbxwo = context->slavelist[slave].mbx_wo;
- limitcnt++;
- if(context->slavelist[slave].state >= EC_STATE_PRE_OP)
+ case EC_MBXQUEUESTATE_REQ:
+ case EC_MBXQUEUESTATE_FAIL:
+ slave = mbxqueue->mbxslave[ticketloc];
+ mbx = mbxqueue->mbx[ticketloc];
+ mbxl = context->slavelist[slave].mbx_l;
+ configadr = context->slavelist[slave].configadr;
+ mbxwo = context->slavelist[slave].mbx_wo;
+ limitcnt++;
+ if (context->slavelist[slave].state >= EC_STATE_PRE_OP)
+ {
+ /* write slave in mailbox 1st try*/
+ wkc = ecx_FPWR(context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET);
+ if (wkc > 0)
{
- /* write slave in mailbox 1st try*/
- wkc = ecx_FPWR(context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET);
- if(wkc > 0)
- {
- mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_DONE; // mbx tx ok
- ecx_dropmbx(context, mbx);
- mbxqueue->mbx[ticketloc] = NULL;
- }
- else
- {
- if(state != EC_MBXQUEUESTATE_FAIL)
- mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_FAIL; // mbx tx fail, retry
- }
+ mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_DONE; // mbx tx ok
+ ecx_dropmbx(context, mbx);
+ mbxqueue->mbx[ticketloc] = NULL;
}
- /* fall through */
- case EC_MBXQUEUESTATE_DONE: // mbx tx ok
- ecx_mbxrotatequeue(context, group, ticketloc);
- break;
+ else
+ {
+ if (state != EC_MBXQUEUESTATE_FAIL)
+ mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_FAIL; // mbx tx fail, retry
+ }
+ }
+ /* fall through */
+ case EC_MBXQUEUESTATE_DONE: // mbx tx ok
+ ecx_mbxrotatequeue(context, group, ticketloc);
+ break;
}
- if(mbxqueue->mbxremove[ticketloc])
+ if (mbxqueue->mbxremove[ticketloc])
{
mbx = ecx_mbxdropqueue(context, group, ticketloc);
- if(mbx) ecx_dropmbx(context, mbx);
+ if (mbx) ecx_dropmbx(context, mbx);
}
- }
+ }
return limitcnt;
}
int limitcnt;
limitcnt = ecx_mbxinhandler(context, group, limit);
return ecx_mbxouthandler(context, group, (limit - limitcnt));
- //return limitcnt;
+ // return limitcnt;
}
/** Write IN mailbox to slave.
* @param[in] timeout = Timeout in us
* @return Work counter (>0 is success)
*/
-int ecx_mbxsend(ecx_contextt *context, uint16 slave,ec_mbxbuft *mbx, int timeout)
+int ecx_mbxsend(ecx_contextt *context, uint16 slave, ec_mbxbuft *mbx, int timeout)
{
uint16 mbxwo, mbxl, configadr;
int wkc, ticket;
{
osal_timer_start(&timer, timeout);
wkc = 0;
- if(mbxl > 0)
+ if (mbxl > 0)
{
do
{
- if((ticket = ecx_mbxaddqueue(context, slave, mbx)) >= 0)
+ if ((ticket = ecx_mbxaddqueue(context, slave, mbx)) >= 0)
{
mbx = NULL;
do
{
osal_usleep(EC_LOCALDELAY);
}
- }
- while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE));
- if(wkc <= 0)
+ } while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE));
+ if (wkc <= 0)
{
- if(!ecx_mbxexpirequeue(context, slave, ticket))
+ if (!ecx_mbxexpirequeue(context, slave, ticket))
{
-// printf("expirequeue failed\n\r");
+ // printf("expirequeue failed\n\r");
}
}
}
{
osal_usleep(EC_LOCALDELAY);
}
- }
- while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE));
+ } while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE));
}
}
else if ((mbxl > 0) && (mbxl <= EC_MAXMBX) && (slavelist->state >= EC_STATE_PRE_OP))
/* retry */
wkc = ecx_FPWR(context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET3);
}
- if(wkc < 0 ) wkc = 0;
+ if (wkc < 0) wkc = 0;
}
if (mbx) ecx_dropmbx(context, mbx);
return wkc;
/** Read OUT mailbox from slave.
* Supports Mailbox Link Layer with repeat requests.
- * Mailbox is fetched from pool, caller is owner after return
+ * Mailbox is fetched from pool, caller is owner after return
* and therefore should drop it back to the pool whe finished.
* @param[in] context = context struct
* @param[in] slave = Slave number
*/
int ecx_mbxreceive(ecx_contextt *context, uint16 slave, ec_mbxbuft **mbx, int timeout)
{
- uint16 mbxro,mbxl,configadr;
- int wkc=0;
+ uint16 mbxro, mbxl, configadr;
+ int wkc = 0;
int wkc2;
uint8 SMstat;
uint16 SMstatex;
}
else if (slavelist->eoembxinfull == TRUE)
{
- *mbx = (ec_mbxbuft*)slavelist->eoembxin;
- slavelist->eoembxin = EC_MBXINENABLE;
- slavelist->eoembxinfull = FALSE;
- wkc = 1;
+ *mbx = (ec_mbxbuft *)slavelist->eoembxin;
+ slavelist->eoembxin = EC_MBXINENABLE;
+ slavelist->eoembxinfull = FALSE;
+ wkc = 1;
}
if (!wkc && (timeout > EC_LOCALDELAY))
{
osal_usleep(EC_LOCALDELAY);
}
- }
- while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE));
+ } while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE));
}
else if ((mbxl > 0) && (mbxl <= EC_MAXMBX))
{
{
osal_usleep(EC_LOCALDELAY);
}
- }
- while (((wkc <= 0) || ((SMstat & 0x08) == 0)) && (osal_timer_is_expired(&timer) == FALSE));
+ } while (((wkc <= 0) || ((SMstat & 0x08) == 0)) && (osal_timer_is_expired(&timer) == FALSE));
if ((wkc > 0) && ((SMstat & 0x08) > 0)) /* read mailbox available ? */
{
do
{
wkc = ecx_FPRD(context->port, configadr, mbxro, mbxl, mbxin, EC_TIMEOUTRET); /* get mailbox */
- if ((wkc > 0) && ((mbxh->mbxtype & 0x0f) == 0x00)) /* Mailbox error response? */
+ if ((wkc > 0) && ((mbxh->mbxtype & 0x0f) == 0x00)) /* Mailbox error response? */
{
MBXEp = (ec_mbxerrort *)mbxin;
ecx_mbxerror(context, slave, etohs(MBXEp->Detail));
if ((etohs(EMp->CANOpen) >> 12) == 0x01) /* Emergency request? */
{
ecx_mbxemergencyerror(context, slave, etohs(EMp->ErrorCode), EMp->ErrorReg,
- EMp->bData, etohs(EMp->w1), etohs(EMp->w2));
+ EMp->bData, etohs(EMp->w1), etohs(EMp->w2));
ecx_dropmbx(context, mbxin);
mbxin = NULL;
wkc = 0; /* prevent emergency to cascade up, it is already handled. */
}
- else
+ else
{
*mbx = mbxin;
mbxin = NULL;
}
else if ((wkc > 0) && ((mbxh->mbxtype & 0x0f) == ECT_MBXT_EOE)) /* EoE response? */
{
- ec_EOEt* eoembx = (ec_EOEt*)mbx;
- uint16 frameinfo1 = etohs(eoembx->frameinfo1);
- /* All non fragment data frame types are expected to be handled by
+ ec_EOEt *eoembx = (ec_EOEt *)mbx;
+ uint16 frameinfo1 = etohs(eoembx->frameinfo1);
+ /* All non fragment data frame types are expected to be handled by
* slave send/receive API if the EoE hook is set
*/
- if (EOE_HDR_FRAME_TYPE_GET(frameinfo1) == EOE_FRAG_DATA)
- {
- if (context->EOEhook)
- {
- if (context->EOEhook(context, slave, eoembx) > 0)
- {
- /* Fragment handled by EoE hook */
- ecx_dropmbx(context, mbxin);
- mbxin = NULL;
- wkc = 0;
- }
- }
- }
- /* Not handled by EoE hook*/
- if(wkc > 0)
- {
- *mbx = mbxin;
- mbxin = NULL;
- }
+ if (EOE_HDR_FRAME_TYPE_GET(frameinfo1) == EOE_FRAG_DATA)
+ {
+ if (context->EOEhook)
+ {
+ if (context->EOEhook(context, slave, eoembx) > 0)
+ {
+ /* Fragment handled by EoE hook */
+ ecx_dropmbx(context, mbxin);
+ mbxin = NULL;
+ wkc = 0;
+ }
+ }
+ }
+ /* Not handled by EoE hook*/
+ if (wkc > 0)
+ {
+ *mbx = mbxin;
+ mbxin = NULL;
+ }
}
else
{
do /* wait for toggle ack */
{
wkc2 = ecx_FPRD(context->port, configadr, ECT_REG_SM1CONTR, sizeof(SMcontr), &SMcontr, EC_TIMEOUTRET);
- } while (((wkc2 <= 0) || ((SMcontr & 0x02) != (HI_BYTE(SMstatex) & 0x02))) && (osal_timer_is_expired(&timer) == FALSE));
+ } while (((wkc2 <= 0) || ((SMcontr & 0x02) != (HI_BYTE(SMstatex) & 0x02))) && (osal_timer_is_expired(&timer) == FALSE));
do /* wait for read mailbox available */
{
wkc2 = ecx_readmbxstatusex(context, slave, &SMstatex);
}
}
} while ((wkc <= 0) && (osal_timer_is_expired(&timer) == FALSE)); /* if WKC<=0 repeat */
- if(mbxin) ecx_dropmbx(context, mbxin);
+ if (mbxin) ecx_dropmbx(context, mbxin);
}
else /* no read mailbox available */
{
ecx_eeprom2master(context, slave); /* set eeprom control to master */
configadr = context->slavelist[slave].configadr;
address = ECT_SII_START;
- p16=(uint16*)esibuf;
+ p16 = (uint16 *)esibuf;
if (context->slavelist[slave].eep_8byte)
{
incr = 4;
do
{
edat = ecx_readeepromFP(context, configadr, address, EC_TIMEOUTEEP);
- p64 = (uint64*)p16;
+ p64 = (uint64 *)p16;
*p64 = edat;
p16 += incr;
address += incr;
uint16 configadr;
uint8 eepctl;
- if ( context->slavelist[slave].eep_pdi )
+ if (context->slavelist[slave].eep_pdi)
{
configadr = context->slavelist[slave].configadr;
eepctl = 2;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
eepctl = 0;
cnt = 0;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
context->slavelist[slave].eep_pdi = 0;
}
uint16 configadr;
uint8 eepctl;
- if ( !context->slavelist[slave].eep_pdi )
+ if (!context->slavelist[slave].eep_pdi)
{
configadr = context->slavelist[slave].configadr;
eepctl = 1;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to PDI */
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to PDI */
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
context->slavelist[slave].eep_pdi = 1;
}
return wkc;
}
-uint16 ecx_eeprom_waitnotbusyAP(ecx_contextt *context, uint16 aiadr,uint16 *estat, int timeout)
+uint16 ecx_eeprom_waitnotbusyAP(ecx_contextt *context, uint16 aiadr, uint16 *estat, int timeout)
{
int wkc, cnt = 0;
uint16 retval = 0;
osal_usleep(EC_LOCALDELAY);
}
*estat = 0;
- wkc=ecx_APRD(context->port, aiadr, ECT_REG_EEPSTAT, sizeof(*estat), estat, EC_TIMEOUTRET);
+ wkc = ecx_APRD(context->port, aiadr, ECT_REG_EEPSTAT, sizeof(*estat), estat, EC_TIMEOUTRET);
*estat = etohs(*estat);
- }
- while (((wkc <= 0) || ((*estat & EC_ESTAT_BUSY) > 0)) && (osal_timer_is_expired(&timer) == FALSE)); /* wait for eeprom ready */
+ } while (((wkc <= 0) || ((*estat & EC_ESTAT_BUSY) > 0)) && (osal_timer_is_expired(&timer) == FALSE)); /* wait for eeprom ready */
if ((*estat & EC_ESTAT_BUSY) == 0)
{
retval = 1;
{
ed.comm = htoes(EC_ECMD_READ);
ed.addr = htoes(eeproma);
- ed.d2 = 0x0000;
+ ed.d2 = 0x0000;
cnt = 0;
do
{
wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
osal_usleep(EC_LOCALDELAY);
do
{
wkc = ecx_APRD(context->port, aiadr, ECT_REG_EEPDAT, sizeof(edat64), &edat64, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
else
{
do
{
wkc = ecx_APRD(context->port, aiadr, ECT_REG_EEPDAT, sizeof(edat32), &edat32, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
- edat64=(uint64)edat32;
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ edat64 = (uint64)edat32;
}
}
}
}
- }
- while ((nackcnt > 0) && (nackcnt < 3));
+ } while ((nackcnt > 0) && (nackcnt < 3));
}
return edat64;
do
{
wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPDAT, sizeof(data), &data, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
ed.comm = EC_ECMD_WRITE;
ed.addr = eeproma;
- ed.d2 = 0x0000;
+ ed.d2 = 0x0000;
cnt = 0;
do
{
wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
osal_usleep(EC_LOCALDELAY * 2);
}
}
- }
- while ((nackcnt > 0) && (nackcnt < 3));
+ } while ((nackcnt > 0) && (nackcnt < 3));
}
return rval;
}
-uint16 ecx_eeprom_waitnotbusyFP(ecx_contextt *context, uint16 configadr,uint16 *estat, int timeout)
+uint16 ecx_eeprom_waitnotbusyFP(ecx_contextt *context, uint16 configadr, uint16 *estat, int timeout)
{
int wkc, cnt = 0;
uint16 retval = 0;
osal_usleep(EC_LOCALDELAY);
}
*estat = 0;
- wkc=ecx_FPRD(context->port, configadr, ECT_REG_EEPSTAT, sizeof(*estat), estat, EC_TIMEOUTRET);
+ wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPSTAT, sizeof(*estat), estat, EC_TIMEOUTRET);
*estat = etohs(*estat);
- }
- while (((wkc <= 0) || ((*estat & EC_ESTAT_BUSY) > 0)) && (osal_timer_is_expired(&timer) == FALSE)); /* wait for eeprom ready */
+ } while (((wkc <= 0) || ((*estat & EC_ESTAT_BUSY) > 0)) && (osal_timer_is_expired(&timer) == FALSE)); /* wait for eeprom ready */
if ((*estat & EC_ESTAT_BUSY) == 0)
{
retval = 1;
if (estat & EC_ESTAT_EMASK) /* error bits are set */
{
estat = htoes(EC_ECMD_NOP); /* clear error bits */
- wkc=ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(estat), &estat, EC_TIMEOUTRET3);
+ wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(estat), &estat, EC_TIMEOUTRET3);
}
do
{
ed.comm = htoes(EC_ECMD_READ);
ed.addr = htoes(eeproma);
- ed.d2 = 0x0000;
+ ed.d2 = 0x0000;
cnt = 0;
do
{
- wkc=ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
osal_usleep(EC_LOCALDELAY);
cnt = 0;
do
{
- wkc=ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat64), &edat64, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat64), &edat64, EC_TIMEOUTRET);
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
else
{
cnt = 0;
do
{
- wkc=ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat32), &edat32, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
- edat64=(uint64)edat32;
+ wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat32), &edat32, EC_TIMEOUTRET);
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ edat64 = (uint64)edat32;
}
}
}
}
- }
- while ((nackcnt > 0) && (nackcnt < 3));
+ } while ((nackcnt > 0) && (nackcnt < 3));
}
return edat64;
do
{
wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPDAT, sizeof(data), &data, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
ed.comm = EC_ECMD_WRITE;
ed.addr = eeproma;
- ed.d2 = 0x0000;
+ ed.d2 = 0x0000;
cnt = 0;
do
{
wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
osal_usleep(EC_LOCALDELAY * 2);
}
}
}
- }
- while ((nackcnt > 0) && (nackcnt < 3));
+ } while ((nackcnt > 0) && (nackcnt < 3));
}
return rval;
}
ed.comm = htoes(EC_ECMD_READ);
ed.addr = htoes(eeproma);
- ed.d2 = 0x0000;
+ ed.d2 = 0x0000;
do
{
wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
}
{
do
{
- wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat), &edat, EC_TIMEOUTRET);
- }
- while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
+ wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat), &edat, EC_TIMEOUTRET);
+ } while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
return edat;
*/
static void ecx_pushindex(ecx_contextt *context, uint8 idx, void *data, uint16 length, uint16 DCO)
{
- if(context->idxstack->pushed < EC_MAXBUF)
+ if (context->idxstack->pushed < EC_MAXBUF)
{
context->idxstack->idx[context->idxstack->pushed] = idx;
context->idxstack->data[context->idxstack->pushed] = data;
static int ecx_pullindex(ecx_contextt *context)
{
int rval = -1;
- if(context->idxstack->pulled < context->idxstack->pushed)
+ if (context->idxstack->pulled < context->idxstack->pushed)
{
rval = context->idxstack->pulled;
context->idxstack->pulled++;
return rval;
}
-/**
+/**
* Clear the idx stack.
- *
+ *
* @param context = context struct
*/
-static void ecx_clearindex(ecx_contextt *context) {
+static void ecx_clearindex(ecx_contextt *context)
+{
context->idxstack->pushed = 0;
context->idxstack->pulled = 0;
-
}
/** Transmit processdata to slaves.
uint16 sublength;
uint8 idx;
int wkc;
- uint8* data;
- boolean first=FALSE;
+ uint8 *data;
+ boolean first = FALSE;
uint16 currentsegment = 0;
uint32 iomapinputoffset;
uint16 DCO;
wkc = 0;
- if(context->grouplist[group].hasdc)
+ if (context->grouplist[group].hasdc)
{
first = TRUE;
}
ecx_clearmbxstatus(context, group);
-
+
/* For overlapping IO map use the biggest */
- if(use_overlap_io == TRUE)
+ if (use_overlap_io == TRUE)
{
/* For overlap IOmap make the frame EQ big to biggest part */
- length = (context->grouplist[group].Obytes > context->grouplist[group].Ibytes) ?
- context->grouplist[group].Obytes : context->grouplist[group].Ibytes;
+ length = (context->grouplist[group].Obytes > context->grouplist[group].Ibytes) ? context->grouplist[group].Obytes : context->grouplist[group].Ibytes;
length += context->grouplist[group].mbxstatuslength;
/* Save the offset used to compensate where to save inputs when frame returns */
iomapinputoffset = context->grouplist[group].Obytes;
}
else
{
- length = context->grouplist[group].Obytes +
- context->grouplist[group].Ibytes +
- context->grouplist[group].mbxstatuslength;
+ length = context->grouplist[group].Obytes +
+ context->grouplist[group].Ibytes +
+ context->grouplist[group].mbxstatuslength;
iomapinputoffset = 0;
}
-
+
LogAdr = context->grouplist[group].logstartaddr;
- if(length)
+ if (length)
{
wkc = 1;
/* LRW blocked by one or more slaves ? */
- if(context->grouplist[group].blockLRW)
+ if (context->grouplist[group].blockLRW)
{
/* if inputs available generate LRD */
- if(context->grouplist[group].Ibytes)
+ if (context->grouplist[group].Ibytes)
{
currentsegment = context->grouplist[group].Isegment;
data = context->grouplist[group].inputs;
/* segment transfer if needed */
do
{
- if(currentsegment == context->grouplist[group].Isegment)
+ if (currentsegment == context->grouplist[group].Isegment)
{
sublength = (uint16)(context->grouplist[group].IOsegment[currentsegment++] - context->grouplist[group].Ioffset);
}
w2 = HI_WORD(LogAdr);
DCO = 0;
ecx_setupdatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_LRD, idx, w1, w2, sublength, data);
- if(first)
+ if (first)
{
/* FPRMW in second datagram */
DCO = ecx_adddatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_FRMW, idx, FALSE,
- context->slavelist[context->grouplist[group].DCnext].configadr,
- ECT_REG_DCSYSTIME, sizeof(int64), context->DCtime);
+ context->slavelist[context->grouplist[group].DCnext].configadr,
+ ECT_REG_DCSYSTIME, sizeof(int64), context->DCtime);
first = FALSE;
}
/* send frame */
} while (length && (currentsegment < context->grouplist[group].nsegments));
}
/* if outputs available generate LWR */
- if(context->grouplist[group].Obytes)
+ if (context->grouplist[group].Obytes)
{
data = context->grouplist[group].outputs;
length = context->grouplist[group].Obytes;
do
{
sublength = (uint16)context->grouplist[group].IOsegment[currentsegment++];
- if((length - sublength) < 0)
+ if ((length - sublength) < 0)
{
sublength = (uint16)length;
}
w2 = HI_WORD(LogAdr);
DCO = 0;
ecx_setupdatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_LWR, idx, w1, w2, sublength, data);
- if(first)
+ if (first)
{
/* FPRMW in second datagram */
DCO = ecx_adddatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_FRMW, idx, FALSE,
- context->slavelist[context->grouplist[group].DCnext].configadr,
- ECT_REG_DCSYSTIME, sizeof(int64), context->DCtime);
+ context->slavelist[context->grouplist[group].DCnext].configadr,
+ ECT_REG_DCSYSTIME, sizeof(int64), context->DCtime);
first = FALSE;
}
/* send frame */
w2 = HI_WORD(LogAdr);
DCO = 0;
ecx_setupdatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_LRW, idx, w1, w2, sublength, data);
- if(first)
+ if (first)
{
/* FPRMW in second datagram */
DCO = ecx_adddatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_FRMW, idx, FALSE,
- context->slavelist[context->grouplist[group].DCnext].configadr,
- ECT_REG_DCSYSTIME, sizeof(int64), context->DCtime);
+ context->slavelist[context->grouplist[group].DCnext].configadr,
+ ECT_REG_DCSYSTIME, sizeof(int64), context->DCtime);
first = FALSE;
}
/* send frame */
ecx_outframe_red(context->port, idx);
/* push index and data pointer on stack.
- * the iomapinputoffset compensate for where the inputs are stored
+ * the iomapinputoffset compensate for where the inputs are stored
* in the IOmap if we use an overlapping IOmap. If a regular IOmap
* is used it should always be 0.
*/
- ecx_pushindex(context, idx, (data + iomapinputoffset), sublength, DCO);
+ ecx_pushindex(context, idx, (data + iomapinputoffset), sublength, DCO);
length -= sublength;
LogAdr += sublength;
data += sublength;
}
/** Transmit processdata to slaves.
-* Uses LRW, or LRD/LWR if LRW is not allowed (blockLRW).
-* Both the input and output processdata are transmitted in the overlapped IOmap.
-* The outputs with the actual data, the inputs replace the output data in the
-* returning frame. The inputs are gathered with the receive processdata function.
-* In contrast to the base LRW function this function is non-blocking.
-* If the processdata does not fit in one datagram, multiple are used.
-* In order to recombine the slave response, a stack is used.
-* @param[in] context = context struct
-* @param[in] group = group number
-* @return >0 if processdata is transmitted.
-*/
+ * Uses LRW, or LRD/LWR if LRW is not allowed (blockLRW).
+ * Both the input and output processdata are transmitted in the overlapped IOmap.
+ * The outputs with the actual data, the inputs replace the output data in the
+ * returning frame. The inputs are gathered with the receive processdata function.
+ * In contrast to the base LRW function this function is non-blocking.
+ * If the processdata does not fit in one datagram, multiple are used.
+ * In order to recombine the slave response, a stack is used.
+ * @param[in] context = context struct
+ * @param[in] group = group number
+ * @return >0 if processdata is transmitted.
+ */
int ecx_send_overlap_processdata_group(ecx_contextt *context, uint8 group)
{
return ecx_main_send_processdata(context, group, TRUE);
}
/** Transmit processdata to slaves.
-* Uses LRW, or LRD/LWR if LRW is not allowed (blockLRW).
-* Both the input and output processdata are transmitted.
-* The outputs with the actual data, the inputs have a placeholder.
-* The inputs are gathered with the receive processdata function.
-* In contrast to the base LRW function this function is non-blocking.
-* If the processdata does not fit in one datagram, multiple are used.
-* In order to recombine the slave response, a stack is used.
-* @param[in] context = context struct
-* @param[in] group = group number
-* @return >0 if processdata is transmitted.
-*/
+ * Uses LRW, or LRD/LWR if LRW is not allowed (blockLRW).
+ * Both the input and output processdata are transmitted.
+ * The outputs with the actual data, the inputs have a placeholder.
+ * The inputs are gathered with the receive processdata function.
+ * In contrast to the base LRW function this function is non-blocking.
+ * If the processdata does not fit in one datagram, multiple are used.
+ * In order to recombine the slave response, a stack is used.
+ * @param[in] context = context struct
+ * @param[in] group = group number
+ * @return >0 if processdata is transmitted.
+ */
int ecx_send_processdata_group(ecx_contextt *context, uint8 group)
{
return ecx_main_send_processdata(context, group, FALSE);
/* check if there is input data in frame */
if (wkc2 > EC_NOFRAME)
{
- if((rxbuf[idx][EC_CMDOFFSET]==EC_CMD_LRD) || (rxbuf[idx][EC_CMDOFFSET]==EC_CMD_LRW))
+ if ((rxbuf[idx][EC_CMDOFFSET] == EC_CMD_LRD) || (rxbuf[idx][EC_CMDOFFSET] == EC_CMD_LRW))
{
- if(idxstack->dcoffset[pos] > 0)
+ if (idxstack->dcoffset[pos] > 0)
{
memcpy(idxstack->data[pos], &(rxbuf[idx][EC_HEADERSIZE]), idxstack->length[pos]);
memcpy(&le_wkc, &(rxbuf[idx][EC_HEADERSIZE + idxstack->length[pos]]), EC_WKCSIZE);
}
valid_wkc = 1;
}
- else if(rxbuf[idx][EC_CMDOFFSET]==EC_CMD_LWR)
+ else if (rxbuf[idx][EC_CMDOFFSET] == EC_CMD_LWR)
{
- if(idxstack->dcoffset[pos] > 0)
+ if (idxstack->dcoffset[pos] > 0)
{
memcpy(&le_wkc, &(rxbuf[idx][EC_HEADERSIZE + idxstack->length[pos]]), EC_WKCSIZE);
/* output WKC counts 2 times when using LRW, emulate the same for LWR */
typedef struct
{
/** Error code returned from SDO */
- uint32 errorcode;
+ uint32 errorcode;
/** Readable error description */
- char errordescription[EC_MAXERRORNAME + 1];
+ char errordescription[EC_MAXERRORNAME + 1];
} ec_sdoerrorlist_t;
/** AL status code list type definition */
typedef struct
{
/** AL status code */
- uint16 ALstatuscode;
+ uint16 ALstatuscode;
/** Readable description */
- char ALstatuscodedescription[EC_MAXERRORNAME + 1];
+ char ALstatuscodedescription[EC_MAXERRORNAME + 1];
} ec_ALstatuscodelist_t;
/** SoE error list type definition */
typedef struct
{
/** SoE error code */
- uint16 errorcode;
+ uint16 errorcode;
/** Readable description */
- char errordescription[EC_MAXERRORNAME + 1];
+ char errordescription[EC_MAXERRORNAME + 1];
} ec_soeerrorlist_t;
/** MBX error list type definition */
typedef struct
{
/** MBX error code */
- uint16 errorcode;
+ uint16 errorcode;
/** Readable description */
- char errordescription[EC_MAXERRORNAME + 1];
+ char errordescription[EC_MAXERRORNAME + 1];
} ec_mbxerrorlist_t;
char estring[EC_MAXERRORNAME];
/** SDO error list definition */
const ec_sdoerrorlist_t ec_sdoerrorlist[] = {
- {0x00000000, "No error" },
- {0x05030000, "Toggle bit not changed" },
- {0x05040000, "SDO protocol timeout" },
- {0x05040001, "Client/Server command specifier not valid or unknown" },
- {0x05040005, "Out of memory" },
- {0x06010000, "Unsupported access to an object" },
- {0x06010001, "Attempt to read to a write only object" },
- {0x06010002, "Attempt to write to a read only object" },
- {0x06010003, "Subindex can not be written, SI0 must be 0 for write access" },
- {0x06010004, "SDO Complete access not supported for variable length objects" },
- {0x06010005, "Object length exceeds mailbox size" },
- {0x06010006, "Object mapped to RxPDO, SDO download blocked" },
- {0x06020000, "The object does not exist in the object directory" },
- {0x06040041, "The object can not be mapped into the PDO" },
- {0x06040042, "The number and length of the objects to be mapped would exceed the PDO length" },
- {0x06040043, "General parameter incompatibility reason" },
- {0x06040047, "General internal incompatibility in the device" },
- {0x06060000, "Access failed due to a hardware error" },
- {0x06070010, "Data type does not match, length of service parameter does not match" },
- {0x06070012, "Data type does not match, length of service parameter too high" },
- {0x06070013, "Data type does not match, length of service parameter too low" },
- {0x06090011, "Subindex does not exist" },
- {0x06090030, "Value range of parameter exceeded (only for write access)" },
- {0x06090031, "Value of parameter written too high" },
- {0x06090032, "Value of parameter written too low" },
- {0x06090036, "Maximum value is less than minimum value" },
- {0x08000000, "General error" },
- {0x08000020, "Data cannot be transferred or stored to the application" },
- {0x08000021, "Data cannot be transferred or stored to the application because of local control" },
- {0x08000022, "Data cannot be transferred or stored to the application because of the present device state" },
- {0x08000023, "Object dictionary dynamic generation fails or no object dictionary is present" },
- {0xffffffff, "Unknown" }
+ {0x00000000, "No error"},
+ {0x05030000, "Toggle bit not changed"},
+ {0x05040000, "SDO protocol timeout"},
+ {0x05040001, "Client/Server command specifier not valid or unknown"},
+ {0x05040005, "Out of memory"},
+ {0x06010000, "Unsupported access to an object"},
+ {0x06010001, "Attempt to read to a write only object"},
+ {0x06010002, "Attempt to write to a read only object"},
+ {0x06010003, "Subindex can not be written, SI0 must be 0 for write access"},
+ {0x06010004, "SDO Complete access not supported for variable length objects"},
+ {0x06010005, "Object length exceeds mailbox size"},
+ {0x06010006, "Object mapped to RxPDO, SDO download blocked"},
+ {0x06020000, "The object does not exist in the object directory"},
+ {0x06040041, "The object can not be mapped into the PDO"},
+ {0x06040042, "The number and length of the objects to be mapped would exceed the PDO length"},
+ {0x06040043, "General parameter incompatibility reason"},
+ {0x06040047, "General internal incompatibility in the device"},
+ {0x06060000, "Access failed due to a hardware error"},
+ {0x06070010, "Data type does not match, length of service parameter does not match"},
+ {0x06070012, "Data type does not match, length of service parameter too high"},
+ {0x06070013, "Data type does not match, length of service parameter too low"},
+ {0x06090011, "Subindex does not exist"},
+ {0x06090030, "Value range of parameter exceeded (only for write access)"},
+ {0x06090031, "Value of parameter written too high"},
+ {0x06090032, "Value of parameter written too low"},
+ {0x06090036, "Maximum value is less than minimum value"},
+ {0x08000000, "General error"},
+ {0x08000020, "Data cannot be transferred or stored to the application"},
+ {0x08000021, "Data cannot be transferred or stored to the application because of local control"},
+ {0x08000022, "Data cannot be transferred or stored to the application because of the present device state"},
+ {0x08000023, "Object dictionary dynamic generation fails or no object dictionary is present"},
+ {0xffffffff, "Unknown"},
};
/** AL status code list definition */
const ec_ALstatuscodelist_t ec_ALstatuscodelist[] = {
- {0x0000 , "No error" },
- {0x0001 , "Unspecified error" },
- {0x0002 , "No memory" },
- {0x0003 , "Invalid device setup" },
- {0x0004 , "Invalid revision" },
- {0x0006 , "SII/EEPROM information does not match firmware" },
- {0x0007 , "Firmware update not successful. Old firmware still running" },
- {0x000E , "License error" },
- {0x0011 , "Invalid requested state change" },
- {0x0012 , "Unknown requested state" },
- {0x0013 , "Bootstrap not supported" },
- {0x0014 , "No valid firmware" },
- {0x0015 , "Invalid mailbox configuration" },
- {0x0016 , "Invalid mailbox configuration" },
- {0x0017 , "Invalid sync manager configuration" },
- {0x0018 , "No valid inputs available" },
- {0x0019 , "No valid outputs" },
- {0x001A , "Synchronization error" },
- {0x001B , "Sync manager watchdog" },
- {0x001C , "Invalid sync Manager types" },
- {0x001D , "Invalid output configuration" },
- {0x001E , "Invalid input configuration" },
- {0x001F , "Invalid watchdog configuration" },
- {0x0020 , "Slave needs cold start" },
- {0x0021 , "Slave needs INIT" },
- {0x0022 , "Slave needs PREOP" },
- {0x0023 , "Slave needs SAFEOP" },
- {0x0024 , "Invalid input mapping" },
- {0x0025 , "Invalid output mapping" },
- {0x0026 , "Inconsistent settings" },
- {0x0027 , "Freerun not supported" },
- {0x0028 , "Synchronisation not supported" },
- {0x0029 , "Freerun needs 3buffer mode" },
- {0x002A , "Background watchdog" },
- {0x002B , "No valid Inputs and Outputs" },
- {0x002C , "Fatal sync error" },
- {0x002D , "No sync error" }, // was "Invalid Output FMMU Configuration"
- {0x002E , "Invalid input FMMU configuration" },
- {0x0030 , "Invalid DC SYNC configuration" },
- {0x0031 , "Invalid DC latch configuration" },
- {0x0032 , "PLL error" },
- {0x0033 , "DC sync IO error" },
- {0x0034 , "DC sync timeout error" },
- {0x0035 , "DC invalid sync cycle time" },
- {0x0036 , "DC invalid sync0 cycle time" },
- {0x0037 , "DC invalid sync1 cycle time" },
- {0x0041 , "MBX_AOE" },
- {0x0042 , "MBX_EOE" },
- {0x0043 , "MBX_COE" },
- {0x0044 , "MBX_FOE" },
- {0x0045 , "MBX_SOE" },
- {0x004F , "MBX_VOE" },
- {0x0050 , "EEPROM no access" },
- {0x0051 , "EEPROM error" },
- {0x0052 , "External hardware not ready" },
- {0x0060 , "Slave restarted locally" },
- {0x0061 , "Device identification value updated" },
- {0x0070 , "Detected Module Ident List does not match" },
- {0x0080 , "Supply voltage too low" },
- {0x0081 , "Supply voltage too high" },
- {0x0082 , "Temperature too low" },
- {0x0083 , "Temperature too high" },
- {0x00f0 , "Application controller available" },
- {0xffff , "Unknown" }
-};
+ {0x0000, "No error"},
+ {0x0001, "Unspecified error"},
+ {0x0002, "No memory"},
+ {0x0003, "Invalid device setup"},
+ {0x0004, "Invalid revision"},
+ {0x0006, "SII/EEPROM information does not match firmware"},
+ {0x0007, "Firmware update not successful. Old firmware still running"},
+ {0x000E, "License error"},
+ {0x0011, "Invalid requested state change"},
+ {0x0012, "Unknown requested state"},
+ {0x0013, "Bootstrap not supported"},
+ {0x0014, "No valid firmware"},
+ {0x0015, "Invalid mailbox configuration"},
+ {0x0016, "Invalid mailbox configuration"},
+ {0x0017, "Invalid sync manager configuration"},
+ {0x0018, "No valid inputs available"},
+ {0x0019, "No valid outputs"},
+ {0x001A, "Synchronization error"},
+ {0x001B, "Sync manager watchdog"},
+ {0x001C, "Invalid sync Manager types"},
+ {0x001D, "Invalid output configuration"},
+ {0x001E, "Invalid input configuration"},
+ {0x001F, "Invalid watchdog configuration"},
+ {0x0020, "Slave needs cold start"},
+ {0x0021, "Slave needs INIT"},
+ {0x0022, "Slave needs PREOP"},
+ {0x0023, "Slave needs SAFEOP"},
+ {0x0024, "Invalid input mapping"},
+ {0x0025, "Invalid output mapping"},
+ {0x0026, "Inconsistent settings"},
+ {0x0027, "Freerun not supported"},
+ {0x0028, "Synchronisation not supported"},
+ {0x0029, "Freerun needs 3buffer mode"},
+ {0x002A, "Background watchdog"},
+ {0x002B, "No valid Inputs and Outputs"},
+ {0x002C, "Fatal sync error"},
+ {0x002D, "No sync error"}, // was "Invalid Output FMMU Configuration"
+ {0x002E, "Invalid input FMMU configuration"},
+ {0x0030, "Invalid DC SYNC configuration"},
+ {0x0031, "Invalid DC latch configuration"},
+ {0x0032, "PLL error"},
+ {0x0033, "DC sync IO error"},
+ {0x0034, "DC sync timeout error"},
+ {0x0035, "DC invalid sync cycle time"},
+ {0x0036, "DC invalid sync0 cycle time"},
+ {0x0037, "DC invalid sync1 cycle time"},
+ {0x0041, "MBX_AOE"},
+ {0x0042, "MBX_EOE"},
+ {0x0043, "MBX_COE"},
+ {0x0044, "MBX_FOE"},
+ {0x0045, "MBX_SOE"},
+ {0x004F, "MBX_VOE"},
+ {0x0050, "EEPROM no access"},
+ {0x0051, "EEPROM error"},
+ {0x0052, "External hardware not ready"},
+ {0x0060, "Slave restarted locally"},
+ {0x0061, "Device identification value updated"},
+ {0x0070, "Detected Module Ident List does not match"},
+ {0x0080, "Supply voltage too low"},
+ {0x0081, "Supply voltage too high"},
+ {0x0082, "Temperature too low"},
+ {0x0083, "Temperature too high"},
+ {0x00f0, "Application controller available"},
+ {0xffff, "Unknown"}};
/** SoE error list definition */
const ec_soeerrorlist_t ec_soeerrorlist[] = {
- {0x0000, "No error" },
- {0x1001, "No IDN" },
- {0x1009, "Invalid access to element 1" },
- {0x2001, "No Name" },
- {0x2002, "Name transmission too short" },
- {0x2003, "Name transmission too long" },
- {0x2004, "Name cannot be changed (read only)" },
- {0x2005, "Name is write-protected at this time" },
- {0x3002, "Attribute transmission too short" },
- {0x3003, "Attribute transmission too long" },
- {0x3004, "Attribute cannot be changed (read only)" },
- {0x3005, "Attribute is write-protected at this time" },
- {0x4001, "No units" },
- {0x4002, "Unit transmission too short" },
- {0x4003, "Unit transmission too long" },
- {0x4004, "Unit cannot be changed (read only)" },
- {0x4005, "Unit is write-protected at this time" },
- {0x5001, "No minimum input value" },
- {0x5002, "Minimum input value transmission too short" },
- {0x5003, "Minimum input value transmission too long" },
- {0x5004, "Minimum input value cannot be changed (read only)" },
- {0x5005, "Minimum input value is write-protected at this time" },
- {0x6001, "No maximum input value" },
- {0x6002, "Maximum input value transmission too short" },
- {0x6003, "Maximum input value transmission too long" },
- {0x6004, "Maximum input value cannot be changed (read only)" },
- {0x6005, "Maximum input value is write-protected at this time" },
- {0x7002, "Operation data transmission too short" },
- {0x7003, "Operation data transmission too long" },
- {0x7004, "Operation data cannot be changed (read only)" },
- {0x7005, "Operation data is write-protected at this time (state)" },
- {0x7006, "Operation data is smaller than the minimum input value" },
- {0x7007, "Operation data is smaller than the maximum input value" },
- {0x7008, "Invalid operation data:Configured IDN will not be supported" },
- {0x7009, "Operation data write protected by a password" },
- {0x700A, "Operation data is write protected, it is configured cyclically" },
- {0x700B, "Invalid indirect addressing: (e.g., data container, list handling)" },
- {0x700C, "Operation data is write protected, due to other settings" },
- {0x700D, "Reserved" },
- {0x7010, "Procedure command already active" },
- {0x7011, "Procedure command not interruptible" },
- {0x7012, "Procedure command at this time not executable (state)" },
- {0x7013, "Procedure command not executable (invalid or false parameters)" },
- {0x7014, "No data state" },
- {0x8001, "No default value" },
- {0x8002, "Default value transmission too long" },
- {0x8004, "Default value cannot be changed, read only" },
- {0x800A, "Invalid drive number" },
- {0x800A, "General error" },
- {0x800A, "No element addressed" },
- {0xffff, "Unknown" }
+ {0x0000, "No error"},
+ {0x1001, "No IDN"},
+ {0x1009, "Invalid access to element 1"},
+ {0x2001, "No Name"},
+ {0x2002, "Name transmission too short"},
+ {0x2003, "Name transmission too long"},
+ {0x2004, "Name cannot be changed (read only)"},
+ {0x2005, "Name is write-protected at this time"},
+ {0x3002, "Attribute transmission too short"},
+ {0x3003, "Attribute transmission too long"},
+ {0x3004, "Attribute cannot be changed (read only)"},
+ {0x3005, "Attribute is write-protected at this time"},
+ {0x4001, "No units"},
+ {0x4002, "Unit transmission too short"},
+ {0x4003, "Unit transmission too long"},
+ {0x4004, "Unit cannot be changed (read only)"},
+ {0x4005, "Unit is write-protected at this time"},
+ {0x5001, "No minimum input value"},
+ {0x5002, "Minimum input value transmission too short"},
+ {0x5003, "Minimum input value transmission too long"},
+ {0x5004, "Minimum input value cannot be changed (read only)"},
+ {0x5005, "Minimum input value is write-protected at this time"},
+ {0x6001, "No maximum input value"},
+ {0x6002, "Maximum input value transmission too short"},
+ {0x6003, "Maximum input value transmission too long"},
+ {0x6004, "Maximum input value cannot be changed (read only)"},
+ {0x6005, "Maximum input value is write-protected at this time"},
+ {0x7002, "Operation data transmission too short"},
+ {0x7003, "Operation data transmission too long"},
+ {0x7004, "Operation data cannot be changed (read only)"},
+ {0x7005, "Operation data is write-protected at this time (state)"},
+ {0x7006, "Operation data is smaller than the minimum input value"},
+ {0x7007, "Operation data is smaller than the maximum input value"},
+ {0x7008, "Invalid operation data:Configured IDN will not be supported"},
+ {0x7009, "Operation data write protected by a password"},
+ {0x700A, "Operation data is write protected, it is configured cyclically"},
+ {0x700B, "Invalid indirect addressing: (e.g., data container, list handling)"},
+ {0x700C, "Operation data is write protected, due to other settings"},
+ {0x700D, "Reserved"},
+ {0x7010, "Procedure command already active"},
+ {0x7011, "Procedure command not interruptible"},
+ {0x7012, "Procedure command at this time not executable (state)"},
+ {0x7013, "Procedure command not executable (invalid or false parameters)"},
+ {0x7014, "No data state"},
+ {0x8001, "No default value"},
+ {0x8002, "Default value transmission too long"},
+ {0x8004, "Default value cannot be changed, read only"},
+ {0x800A, "Invalid drive number"},
+ {0x800A, "General error"},
+ {0x800A, "No element addressed"},
+ {0xffff, "Unknown"},
};
/** MBX error list definition */
const ec_mbxerrorlist_t ec_mbxerrorlist[] = {
- {0x0000, "No error" },
- {0x0001, "Syntax of 6 octet Mailbox Header is wrong" },
- {0x0002, "The mailbox protocol is not supported" },
- {0x0003, "Channel Field contains wrong value"},
- {0x0004, "The service is no supported"},
- {0x0005, "Invalid mailbox header"},
- {0x0006, "Length of received mailbox data is too short"},
- {0x0007, "No more memory in slave"},
- {0x0008, "The length of data is inconsistent"},
- {0xffff, "Unknown"}
+ {0x0000, "No error"},
+ {0x0001, "Syntax of 6 octet Mailbox Header is wrong"},
+ {0x0002, "The mailbox protocol is not supported"},
+ {0x0003, "Channel Field contains wrong value"},
+ {0x0004, "The service is no supported"},
+ {0x0005, "Invalid mailbox header"},
+ {0x0006, "Length of received mailbox data is too short"},
+ {0x0007, "No more memory in slave"},
+ {0x0008, "The length of data is inconsistent"},
+ {0xffff, "Unknown"},
};
/** Look up text string that belongs to SDO error code.
* @param[in] sdoerrorcode = SDO error code as defined in EtherCAT protocol
* @return readable string
*/
-const char* ec_sdoerror2string( uint32 sdoerrorcode)
+const char *ec_sdoerror2string(uint32 sdoerrorcode)
{
int i = 0;
- while ( (ec_sdoerrorlist[i].errorcode != 0xffffffffUL) &&
- (ec_sdoerrorlist[i].errorcode != sdoerrorcode) )
+ while ((ec_sdoerrorlist[i].errorcode != 0xffffffffUL) &&
+ (ec_sdoerrorlist[i].errorcode != sdoerrorcode))
{
i++;
}
* @param[in] ALstatuscode = AL status code as defined in EtherCAT protocol
* @return readable string
*/
-char* ec_ALstatuscode2string( uint16 ALstatuscode)
+char *ec_ALstatuscode2string(uint16 ALstatuscode)
{
int i = 0;
- while ( (ec_ALstatuscodelist[i].ALstatuscode != 0xffff) &&
- (ec_ALstatuscodelist[i].ALstatuscode != ALstatuscode) )
+ while ((ec_ALstatuscodelist[i].ALstatuscode != 0xffff) &&
+ (ec_ALstatuscodelist[i].ALstatuscode != ALstatuscode))
{
i++;
}
- return (char *) ec_ALstatuscodelist[i].ALstatuscodedescription;
+ return (char *)ec_ALstatuscodelist[i].ALstatuscodedescription;
}
/** Look up text string that belongs to SoE error code.
* @param[in] errorcode = SoE error code as defined in EtherCAT protocol
* @return readable string
*/
-char* ec_soeerror2string( uint16 errorcode)
+char *ec_soeerror2string(uint16 errorcode)
{
int i = 0;
- while ( (ec_soeerrorlist[i].errorcode != 0xffff) &&
- (ec_soeerrorlist[i].errorcode != errorcode) )
+ while ((ec_soeerrorlist[i].errorcode != 0xffff) &&
+ (ec_soeerrorlist[i].errorcode != errorcode))
{
i++;
}
- return (char *) ec_soeerrorlist[i].errordescription;
+ return (char *)ec_soeerrorlist[i].errordescription;
}
/** Look up text string that belongs to MBX error code.
* @param[in] errorcode = MBX error code as defined in EtherCAT protocol
* @return readable string
*/
-char* ec_mbxerror2string( uint16 errorcode)
+char *ec_mbxerror2string(uint16 errorcode)
{
int i = 0;
- while ( (ec_mbxerrorlist[i].errorcode != 0xffff) &&
- (ec_mbxerrorlist[i].errorcode != errorcode) )
+ while ((ec_mbxerrorlist[i].errorcode != 0xffff) &&
+ (ec_mbxerrorlist[i].errorcode != errorcode))
{
i++;
}
- return (char *) ec_mbxerrorlist[i].errordescription;
+ return (char *)ec_mbxerrorlist[i].errordescription;
}
/** Convert an error to text string.
* @param[in] Ec = Struct describing the error.
* @return readable string
*/
-char* ecx_err2string(const ec_errort Ec)
+char *ecx_err2string(const ec_errort Ec)
{
char timestr[20];
- sprintf(timestr, "Time:%12.3f", Ec.Time.sec + (Ec.Time.usec / 1000000.0) );
+ sprintf(timestr, "Time:%12.3f", Ec.Time.sec + (Ec.Time.usec / 1000000.0));
switch (Ec.Etype)
{
- case EC_ERR_TYPE_SDO_ERROR:
- {
- sprintf(estring, "%s SDO slave:%d index:%4.4x.%2.2x error:%8.8x %s\n",
- timestr, Ec.Slave, Ec.Index, Ec.SubIdx, (unsigned)Ec.AbortCode, ec_sdoerror2string(Ec.AbortCode));
- break;
- }
- case EC_ERR_TYPE_EMERGENCY:
- {
- sprintf(estring, "%s EMERGENCY slave:%d error:%4.4x\n",
- timestr, Ec.Slave, Ec.ErrorCode);
- break;
- }
- case EC_ERR_TYPE_PACKET_ERROR:
- {
- sprintf(estring, "%s PACKET slave:%d index:%4.4x.%2.2x error:%d\n",
- timestr, Ec.Slave, Ec.Index, Ec.SubIdx, Ec.ErrorCode);
- break;
- }
- case EC_ERR_TYPE_SDOINFO_ERROR:
- {
- sprintf(estring, "%s SDO slave:%d index:%4.4x.%2.2x error:%8.8x %s\n",
- timestr, Ec.Slave, Ec.Index, Ec.SubIdx, (unsigned)Ec.AbortCode, ec_sdoerror2string(Ec.AbortCode));
- break;
- }
- case EC_ERR_TYPE_SOE_ERROR:
- {
- sprintf(estring, "%s SoE slave:%d IDN:%4.4x error:%4.4x %s\n",
- timestr, Ec.Slave, Ec.Index, (unsigned)Ec.AbortCode, ec_soeerror2string(Ec.ErrorCode));
- break;
- }
- case EC_ERR_TYPE_MBX_ERROR:
- {
- sprintf(estring, "%s MBX slave:%d error:%4.4x %s\n",
- timestr, Ec.Slave, Ec.ErrorCode, ec_mbxerror2string(Ec.ErrorCode));
- break;
- }
- default:
- {
- sprintf(estring, "%s error:%8.8x\n",
- timestr, (unsigned)Ec.AbortCode);
- break;
- }
+ case EC_ERR_TYPE_SDO_ERROR:
+ {
+ sprintf(estring, "%s SDO slave:%d index:%4.4x.%2.2x error:%8.8x %s\n",
+ timestr, Ec.Slave, Ec.Index, Ec.SubIdx, (unsigned)Ec.AbortCode, ec_sdoerror2string(Ec.AbortCode));
+ break;
+ }
+ case EC_ERR_TYPE_EMERGENCY:
+ {
+ sprintf(estring, "%s EMERGENCY slave:%d error:%4.4x\n",
+ timestr, Ec.Slave, Ec.ErrorCode);
+ break;
+ }
+ case EC_ERR_TYPE_PACKET_ERROR:
+ {
+ sprintf(estring, "%s PACKET slave:%d index:%4.4x.%2.2x error:%d\n",
+ timestr, Ec.Slave, Ec.Index, Ec.SubIdx, Ec.ErrorCode);
+ break;
+ }
+ case EC_ERR_TYPE_SDOINFO_ERROR:
+ {
+ sprintf(estring, "%s SDO slave:%d index:%4.4x.%2.2x error:%8.8x %s\n",
+ timestr, Ec.Slave, Ec.Index, Ec.SubIdx, (unsigned)Ec.AbortCode, ec_sdoerror2string(Ec.AbortCode));
+ break;
+ }
+ case EC_ERR_TYPE_SOE_ERROR:
+ {
+ sprintf(estring, "%s SoE slave:%d IDN:%4.4x error:%4.4x %s\n",
+ timestr, Ec.Slave, Ec.Index, (unsigned)Ec.AbortCode, ec_soeerror2string(Ec.ErrorCode));
+ break;
+ }
+ case EC_ERR_TYPE_MBX_ERROR:
+ {
+ sprintf(estring, "%s MBX slave:%d error:%4.4x %s\n",
+ timestr, Ec.Slave, Ec.ErrorCode, ec_mbxerror2string(Ec.ErrorCode));
+ break;
+ }
+ default:
+ {
+ sprintf(estring, "%s error:%8.8x\n",
+ timestr, (unsigned)Ec.AbortCode);
+ break;
+ }
}
- return (char*) estring;
+ return (char *)estring;
}
/** Look up error in ec_errorlist and convert to text string.
* @param[in] context = context struct
* @return readable string
*/
-char* ecx_elist2string(ecx_contextt *context)
+char *ecx_elist2string(ecx_contextt *context)
{
ec_errort Ec;
typedef struct PACKED
{
ec_mbxheadert MbxHeader;
- uint8 opCode :3;
- uint8 incomplete :1;
- uint8 error :1;
- uint8 driveNo :3;
- uint8 elementflags;
+ uint8 opCode : 3;
+ uint8 incomplete : 1;
+ uint8 error : 1;
+ uint8 driveNo : 3;
+ uint8 elementflags;
union
{
- uint16 idn;
- uint16 fragmentsleft;
+ uint16 idn;
+ uint16 fragmentsleft;
};
} ec_SoEt;
PACKED_END
{
while (NotLast)
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
(aSoEp->driveNo == driveNo) &&
(aSoEp->elementflags == elementflags))
{
- framedatasize = etohs(aSoEp->MbxHeader.length) - sizeof(ec_SoEt) + sizeof(ec_mbxheadert);
+ framedatasize = etohs(aSoEp->MbxHeader.length) - sizeof(ec_SoEt) + sizeof(ec_mbxheadert);
totalsize += framedatasize;
/* Does parameter fit in parameter buffer ? */
if (totalsize <= *psize)
}
}
}
- if(MbxIn) ecx_dropmbx(context, MbxIn);
- if(MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
SoEp->incomplete = 0;
if (framedatasize > maxdata)
{
- framedatasize = maxdata; /* segmented transfer needed */
+ framedatasize = maxdata; /* segmented transfer needed */
NotLast = TRUE;
SoEp->incomplete = 1;
SoEp->fragmentsleft = (uint16)(psize / maxdata);
{
if (!NotLast || !ecx_mbxempty(context, slave, timeout))
{
- if(MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
MbxIn = NULL;
/* read slave response */
wkc = ecx_mbxreceive(context, slave, &MbxIn, timeout);
}
}
}
- if(MbxIn) ecx_dropmbx(context, MbxIn);
- if(MbxOut) ecx_dropmbx(context, MbxOut);
+ if (MbxIn) ecx_dropmbx(context, MbxIn);
+ if (MbxOut) ecx_dropmbx(context, MbxOut);
return wkc;
}
int ecx_readIDNmap(ecx_contextt *context, uint16 slave, uint32 *Osize, uint32 *Isize)
{
int retVal = 0;
- int wkc;
+ int wkc;
int psize;
uint8 driveNr;
uint16 entries, itemcount;
- ec_SoEmappingt SoEmapping;
- ec_SoEattributet SoEattribute;
+ ec_SoEmappingt SoEmapping;
+ ec_SoEattributet SoEattribute;
*Isize = 0;
*Osize = 0;
- for(driveNr = 0; driveNr < EC_SOE_MAX_DRIVES; driveNr++)
+ for (driveNr = 0; driveNr < EC_SOE_MAX_DRIVES; driveNr++)
{
psize = sizeof(SoEmapping);
/* read output mapping via SoE */
{
/* command word (uint16) is always mapped but not in list */
*Osize += 16;
- for (itemcount = 0 ; itemcount < entries ; itemcount++)
+ for (itemcount = 0; itemcount < entries; itemcount++)
{
psize = sizeof(SoEattribute);
/* read attribute of each IDN in mapping list */
{
/* status word (uint16) is always mapped but not in list */
*Isize += 16;
- for (itemcount = 0 ; itemcount < entries ; itemcount++)
+ for (itemcount = 0; itemcount < entries; itemcount++)
{
psize = sizeof(SoEattribute);
/* read attribute of each IDN in mapping list */
#include <stdio.h>
-
/*****************************************************************************
*
* FUNCTION: main
#include "ethercat.h"
-
char IOmap[4096];
char IOmap2[4096];
* ec_slave[0] is reserved for the master. Structure gets filled
* in by the configuration function ec_config().
*/
-ec_slavet ec_slave[EC_MAXSLAVE];
-ec_slavet ec_slave2[EC_MAXSLAVE];
+ec_slavet ec_slave[EC_MAXSLAVE];
+ec_slavet ec_slave2[EC_MAXSLAVE];
/** number of slaves found on the network */
-int ec_slavecount;
-int ec_slavecount2;
+int ec_slavecount;
+int ec_slavecount2;
/** slave group structure */
-ec_groupt ec_groups[EC_MAXGROUP];
-ec_groupt ec_groups2[EC_MAXGROUP];
+ec_groupt ec_groups[EC_MAXGROUP];
+ec_groupt ec_groups2[EC_MAXGROUP];
/** cache for EEPROM read functions */
-static uint8 esibuf[EC_MAXEEPBUF];
-static uint8 esibuf2[EC_MAXEEPBUF];
+static uint8 esibuf[EC_MAXEEPBUF];
+static uint8 esibuf2[EC_MAXEEPBUF];
/** bitmap for filled cache buffer bytes */
-static uint32 esimap[EC_MAXEEPBITMAP];
-static uint32 esimap2[EC_MAXEEPBITMAP];
+static uint32 esimap[EC_MAXEEPBITMAP];
+static uint32 esimap2[EC_MAXEEPBITMAP];
/** current slave for EEPROM cache buffer */
-static ec_eringt ec_elist;
-static ec_eringt ec_elist2;
+static ec_eringt ec_elist;
+static ec_eringt ec_elist2;
static ec_idxstackT ec_idxstack;
static ec_idxstackT ec_idxstack2;
/** SyncManager Communication Type struct to store data of one slave */
-static ec_SMcommtypet ec_SMcommtype;
-static ec_SMcommtypet ec_SMcommtype2;
+static ec_SMcommtypet ec_SMcommtype;
+static ec_SMcommtypet ec_SMcommtype2;
/** PDO assign struct to store data of one slave */
-static ec_PDOassignt ec_PDOassign;
-static ec_PDOassignt ec_PDOassign2;
+static ec_PDOassignt ec_PDOassign;
+static ec_PDOassignt ec_PDOassign2;
/** PDO description struct to store data of one slave */
-static ec_PDOdesct ec_PDOdesc;
-static ec_PDOdesct ec_PDOdesc2;
+static ec_PDOdesct ec_PDOdesc;
+static ec_PDOdesct ec_PDOdesc2;
/** buffer for EEPROM SM data */
static ec_eepromSMt ec_SM;
static ec_eepromFMMUt ec_FMMU2;
/** Global variable TRUE if error available in error stack */
-static boolean EcatError = FALSE;
-static boolean EcatError2 = FALSE;
-
-int64 ec_DCtime;
-int64 ec_DCtime2;
-
-static ecx_portt ecx_port;
-static ecx_portt ecx_port2;
-
-
-static ecx_contextt ctx [] = {
- {
- &ecx_port,
- &ec_slave[0],
- &ec_slavecount,
- EC_MAXSLAVE,
- &ec_groups[0],
- EC_MAXGROUP,
- &esibuf[0],
- &esimap[0],
- 0,
- &ec_elist,
- &ec_idxstack,
- &EcatError,
- 0,
- 0,
- &ec_DCtime,
- &ec_SMcommtype,
- &ec_PDOassign,
- &ec_PDOdesc,
- &ec_SM,
- &ec_FMMU
- },
- {
- &ecx_port2,
- &ec_slave2[0],
- &ec_slavecount2,
- EC_MAXSLAVE,
- &ec_groups2[0],
- EC_MAXGROUP,
- &esibuf2[0],
- &esimap2[0],
- 0,
- &ec_elist2,
- &ec_idxstack2,
- &EcatError2,
- 0,
- 0,
- &ec_DCtime2,
- &ec_SMcommtype2,
- &ec_PDOassign2,
- &ec_PDOdesc2,
- &ec_SM2,
- &ec_FMMU2
- }
-};
+static boolean EcatError = FALSE;
+static boolean EcatError2 = FALSE;
+
+int64 ec_DCtime;
+int64 ec_DCtime2;
+
+static ecx_portt ecx_port;
+static ecx_portt ecx_port2;
+
+static ecx_contextt ctx[] = {
+ {&ecx_port,
+ &ec_slave[0],
+ &ec_slavecount,
+ EC_MAXSLAVE,
+ &ec_groups[0],
+ EC_MAXGROUP,
+ &esibuf[0],
+ &esimap[0],
+ 0,
+ &ec_elist,
+ &ec_idxstack,
+ &EcatError,
+ 0,
+ 0,
+ &ec_DCtime,
+ &ec_SMcommtype,
+ &ec_PDOassign,
+ &ec_PDOdesc,
+ &ec_SM,
+ &ec_FMMU},
+ {&ecx_port2,
+ &ec_slave2[0],
+ &ec_slavecount2,
+ EC_MAXSLAVE,
+ &ec_groups2[0],
+ EC_MAXGROUP,
+ &esibuf2[0],
+ &esimap2[0],
+ 0,
+ &ec_elist2,
+ &ec_idxstack2,
+ &EcatError2,
+ 0,
+ 0,
+ &ec_DCtime2,
+ &ec_SMcommtype2,
+ &ec_PDOassign2,
+ &ec_PDOdesc2,
+ &ec_SM2,
+ &ec_FMMU2}};
void slaveinfo(char *ifname)
{
printf("Starting slaveinfo\n");
/* initialise SOEM, bind socket to ifname */
- if (ecx_init(&ctx[0],"ie1g1") && ecx_init(&ctx[1],"ie1g0"))
+ if (ecx_init(&ctx[0], "ie1g1") && ecx_init(&ctx[1], "ie1g0"))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ecx_config_init(&ctx[0],FALSE) > 0 && ecx_config_init(&ctx[1],FALSE) > 0 )
+ if (ecx_config_init(&ctx[0], FALSE) > 0 && ecx_config_init(&ctx[1], FALSE) > 0)
{
for (ctx_count = 0; ctx_count < 2; ctx_count++)
{
ecx_config_map_group(&ctx[ctx_count], IOmap, 0);
ecx_configdc(&ctx[ctx_count]);
- while(*(ctx[ctx_count].ecaterror)) printf("%s", ecx_elist2string(&ctx[ctx_count]));
- printf("%d slaves found and configured.\n",*(ctx[ctx_count].slavecount));
- expectedWKC[ctx_count] = ( ctx[ctx_count].grouplist[0].outputsWKC * 2) + ctx[ctx_count].grouplist[0].inputsWKC;
+ while (*(ctx[ctx_count].ecaterror))
+ printf("%s", ecx_elist2string(&ctx[ctx_count]));
+ printf("%d slaves found and configured.\n", *(ctx[ctx_count].slavecount));
+ expectedWKC[ctx_count] = (ctx[ctx_count].grouplist[0].outputsWKC * 2) + ctx[ctx_count].grouplist[0].inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC[ctx_count]);
/* wait for all slaves to reach SAFE_OP state */
- ecx_statecheck(&ctx[ctx_count],0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 3);
- if (ctx[ctx_count].slavelist[ctx_count].state != EC_STATE_SAFE_OP )
+ ecx_statecheck(&ctx[ctx_count], 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 3);
+ if (ctx[ctx_count].slavelist[ctx_count].state != EC_STATE_SAFE_OP)
{
printf("Not all slaves reached safe operational state.\n");
ecx_readstate(&ctx[ctx_count]);
- for(i = 1; i <= *(ctx[ctx_count].slavecount) ; i++)
+ for (i = 1; i <= *(ctx[ctx_count].slavecount); i++)
{
- if(ctx[ctx_count].slavelist[i].state != EC_STATE_SAFE_OP)
+ if (ctx[ctx_count].slavelist[i].state != EC_STATE_SAFE_OP)
{
printf("Slave %d State=%2x StatusCode=%4x : %s\n",
- i, ctx[ctx_count].slavelist[i].state, ctx[ctx_count].slavelist[i].ALstatuscode, ec_ALstatuscode2string(ctx[ctx_count].slavelist[i].ALstatuscode));
+ i, ctx[ctx_count].slavelist[i].state, ctx[ctx_count].slavelist[i].ALstatuscode, ec_ALstatuscode2string(ctx[ctx_count].slavelist[i].ALstatuscode));
}
}
}
ecx_readstate(&ctx[ctx_count]);
- for( cnt = 1 ; cnt <= *(ctx[ctx_count].slavecount) ; cnt++)
+ for (cnt = 1; cnt <= *(ctx[ctx_count].slavecount); cnt++)
{
printf("\nSlave:%d\n Name:%s\n Output size: %dbits\n Input size: %dbits\n State: %d\n Delay: %d[ns]\n Has DC: %d\n",
- cnt, ctx[ctx_count].slavelist[cnt].name, ctx[ctx_count].slavelist[cnt].Obits, ctx[ctx_count].slavelist[cnt].Ibits,
- ctx[ctx_count].slavelist[cnt].state, ctx[ctx_count].slavelist[cnt].pdelay, ctx[ctx_count].slavelist[cnt].hasdc);
+ cnt, ctx[ctx_count].slavelist[cnt].name, ctx[ctx_count].slavelist[cnt].Obits, ctx[ctx_count].slavelist[cnt].Ibits,
+ ctx[ctx_count].slavelist[cnt].state, ctx[ctx_count].slavelist[cnt].pdelay, ctx[ctx_count].slavelist[cnt].hasdc);
if (ctx[ctx_count].slavelist[cnt].hasdc)
{
printf(" DCParentport:%d\n", ctx[ctx_count].slavelist[cnt].parentport);
}
- printf(" Activeports:%d.%d.%d.%d\n", (ctx[ctx_count].slavelist[cnt].activeports & 0x01) > 0 ,
- (ctx[ctx_count].slavelist[cnt].activeports & 0x02) > 0 ,
- (ctx[ctx_count].slavelist[cnt].activeports & 0x04) > 0 ,
- (ctx[ctx_count].slavelist[cnt].activeports & 0x08) > 0 );
+ printf(" Activeports:%d.%d.%d.%d\n", (ctx[ctx_count].slavelist[cnt].activeports & 0x01) > 0,
+ (ctx[ctx_count].slavelist[cnt].activeports & 0x02) > 0,
+ (ctx[ctx_count].slavelist[cnt].activeports & 0x04) > 0,
+ (ctx[ctx_count].slavelist[cnt].activeports & 0x08) > 0);
printf(" Configured address: %4.4x\n", ctx[ctx_count].slavelist[cnt].configadr);
printf(" Man: %8.8x ID: %8.8x Rev: %8.8x\n", (int)ctx[ctx_count].slavelist[cnt].eep_man,
- (int)ctx[ctx_count].slavelist[cnt].eep_id, (int)ctx[ctx_count].slavelist[cnt].eep_rev);
- for(nSM = 0 ; nSM < EC_MAXSM ; nSM++)
+ (int)ctx[ctx_count].slavelist[cnt].eep_id, (int)ctx[ctx_count].slavelist[cnt].eep_rev);
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
- if(ctx[ctx_count].slavelist[cnt].SM[nSM].StartAddr > 0)
- printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n",nSM, ctx[ctx_count].slavelist[cnt].SM[nSM].StartAddr,
- ctx[ctx_count].slavelist[cnt].SM[nSM].SMlength,(int)ctx[ctx_count].slavelist[cnt].SM[nSM].SMflags,
- ctx[ctx_count].slavelist[cnt].SMtype[nSM]);
+ if (ctx[ctx_count].slavelist[cnt].SM[nSM].StartAddr > 0)
+ printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n", nSM, ctx[ctx_count].slavelist[cnt].SM[nSM].StartAddr,
+ ctx[ctx_count].slavelist[cnt].SM[nSM].SMlength, (int)ctx[ctx_count].slavelist[cnt].SM[nSM].SMflags,
+ ctx[ctx_count].slavelist[cnt].SMtype[nSM]);
}
- for(j = 0 ; j < ctx[ctx_count].slavelist[cnt].FMMUunused ; j++)
+ for (j = 0; j < ctx[ctx_count].slavelist[cnt].FMMUunused; j++)
{
printf(" FMMU%1d Ls:%8.8x Ll:%4d Lsb:%d Leb:%d Ps:%4.4x Psb:%d Ty:%2.2x Act:%2.2x\n", j,
- (int)ctx[ctx_count].slavelist[cnt].FMMU[j].LogStart, ctx[ctx_count].slavelist[cnt].FMMU[j].LogLength,
- ctx[ctx_count].slavelist[cnt].FMMU[j].LogStartbit, ctx[ctx_count].slavelist[cnt].FMMU[j].LogEndbit,
- ctx[ctx_count].slavelist[cnt].FMMU[j].PhysStart, ctx[ctx_count].slavelist[cnt].FMMU[j].PhysStartBit,
- ctx[ctx_count].slavelist[cnt].FMMU[j].FMMUtype, ctx[ctx_count].slavelist[cnt].FMMU[j].FMMUactive);
+ (int)ctx[ctx_count].slavelist[cnt].FMMU[j].LogStart, ctx[ctx_count].slavelist[cnt].FMMU[j].LogLength,
+ ctx[ctx_count].slavelist[cnt].FMMU[j].LogStartbit, ctx[ctx_count].slavelist[cnt].FMMU[j].LogEndbit,
+ ctx[ctx_count].slavelist[cnt].FMMU[j].PhysStart, ctx[ctx_count].slavelist[cnt].FMMU[j].PhysStartBit,
+ ctx[ctx_count].slavelist[cnt].FMMU[j].FMMUtype, ctx[ctx_count].slavelist[cnt].FMMU[j].FMMUactive);
}
printf(" FMMUfunc 0:%d 1:%d 2:%d 3:%d\n",
- ctx[ctx_count].slavelist[cnt].FMMU0func, ctx[ctx_count].slavelist[cnt].FMMU1func, ctx[ctx_count].slavelist[cnt].FMMU2func,
- ctx[ctx_count].slavelist[cnt].FMMU3func);
+ ctx[ctx_count].slavelist[cnt].FMMU0func, ctx[ctx_count].slavelist[cnt].FMMU1func, ctx[ctx_count].slavelist[cnt].FMMU2func,
+ ctx[ctx_count].slavelist[cnt].FMMU3func);
printf(" MBX length wr: %d rd: %d MBX protocols : %2.2x\n", ctx[ctx_count].slavelist[cnt].mbx_l,
- ctx[ctx_count].slavelist[cnt].mbx_rl, ctx[ctx_count].slavelist[cnt].mbx_proto);
+ ctx[ctx_count].slavelist[cnt].mbx_rl, ctx[ctx_count].slavelist[cnt].mbx_proto);
ssigen = ecx_siifind(&ctx[ctx_count], cnt, ECT_SII_GENERAL);
/* SII general section */
if (ssigen)
ctx[ctx_count].slavelist[cnt].FoEdetails = ecx_siigetbyte(&ctx[ctx_count], cnt, ssigen + 0x08);
ctx[ctx_count].slavelist[cnt].EoEdetails = ecx_siigetbyte(&ctx[ctx_count], cnt, ssigen + 0x09);
ctx[ctx_count].slavelist[cnt].SoEdetails = ecx_siigetbyte(&ctx[ctx_count], cnt, ssigen + 0x0a);
- if((ecx_siigetbyte(&ctx[ctx_count], cnt, ssigen + 0x0d) & 0x02) > 0)
+ if ((ecx_siigetbyte(&ctx[ctx_count], cnt, ssigen + 0x0d) & 0x02) > 0)
{
ctx[ctx_count].slavelist[cnt].blockLRW = 1;
ctx[ctx_count].slavelist[0].blockLRW++;
ctx[ctx_count].slavelist[0].Ebuscurrent += ctx[ctx_count].slavelist[cnt].Ebuscurrent;
}
printf(" CoE details: %2.2x FoE details: %2.2x EoE details: %2.2x SoE details: %2.2x\n",
- ctx[ctx_count].slavelist[cnt].CoEdetails, ctx[ctx_count].slavelist[cnt].FoEdetails, ctx[ctx_count].slavelist[cnt].EoEdetails, ctx[ctx_count].slavelist[cnt].SoEdetails);
+ ctx[ctx_count].slavelist[cnt].CoEdetails, ctx[ctx_count].slavelist[cnt].FoEdetails, ctx[ctx_count].slavelist[cnt].EoEdetails, ctx[ctx_count].slavelist[cnt].SoEdetails);
printf(" Ebus current: %d[mA]\n only LRD/LWR:%d\n",
- ctx[ctx_count].slavelist[cnt].Ebuscurrent, ctx[ctx_count].slavelist[cnt].blockLRW);
+ ctx[ctx_count].slavelist[cnt].Ebuscurrent, ctx[ctx_count].slavelist[cnt].blockLRW);
}
}
/* send one valid process data to make outputs in slaves happy*/
ecx_send_processdata(&ctx[0]);
ecx_send_processdata(&ctx[1]);
- ecx_receive_processdata(&ctx[0],EC_TIMEOUTRET);
- ecx_receive_processdata(&ctx[1],EC_TIMEOUTRET);
+ ecx_receive_processdata(&ctx[0], EC_TIMEOUTRET);
+ ecx_receive_processdata(&ctx[1], EC_TIMEOUTRET);
/* request OP state for all slaves */
ecx_writestate(&ctx[0], 0);
ecx_writestate(&ctx[1], 0);
{
ecx_send_processdata(&ctx[0]);
ecx_send_processdata(&ctx[1]);
- ecx_receive_processdata(&ctx[0],EC_TIMEOUTRET);
- ecx_receive_processdata(&ctx[1],EC_TIMEOUTRET);
- ecx_statecheck(&ctx[0],0, EC_STATE_OPERATIONAL, 50000);
- ecx_statecheck(&ctx[1],0, EC_STATE_OPERATIONAL, 50000);
- }
- while (chk-- && (ctx[0].slavelist[0].state != EC_STATE_OPERATIONAL) && (ctx[1].slavelist[0].state != EC_STATE_OPERATIONAL));
-
+ ecx_receive_processdata(&ctx[0], EC_TIMEOUTRET);
+ ecx_receive_processdata(&ctx[1], EC_TIMEOUTRET);
+ ecx_statecheck(&ctx[0], 0, EC_STATE_OPERATIONAL, 50000);
+ ecx_statecheck(&ctx[1], 0, EC_STATE_OPERATIONAL, 50000);
+ } while (chk-- && (ctx[0].slavelist[0].state != EC_STATE_OPERATIONAL) && (ctx[1].slavelist[0].state != EC_STATE_OPERATIONAL));
*(ctx[0].slavelist[6].outputs) = 0xFF;
*(ctx[1].slavelist[1].outputs) = 0x0F;
- if (ctx[0].slavelist[0].state == EC_STATE_OPERATIONAL && ctx[1].slavelist[0].state == EC_STATE_OPERATIONAL )
+ if (ctx[0].slavelist[0].state == EC_STATE_OPERATIONAL && ctx[1].slavelist[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
/* cyclic loop */
- start_RT_trace (1);
+ start_RT_trace(1);
wkc_count = 0;
inOP = TRUE;
- for(i = 1; i <= 10000; i++)
+ for (i = 1; i <= 10000; i++)
{
for (ctx_count = 0; ctx_count < 2; ctx_count++)
{
/* Receive processdata */
- log_RT_event('R',(WORD)(1 + ctx_count * 10));
+ log_RT_event('R', (WORD)(1 + ctx_count * 10));
wkc[ctx_count] = ecx_receive_processdata(&ctx[ctx_count], 0);
- log_RT_event('R',(WORD)(99 + ctx_count * 100));
+ log_RT_event('R', (WORD)(99 + ctx_count * 100));
}
for (ctx_count = 0; ctx_count < 2; ctx_count++)
{
/* Send processdata */
- log_RT_event('S',(WORD)(1 + ctx_count * 10));
+ log_RT_event('S', (WORD)(1 + ctx_count * 10));
if (!ecx_send_processdata(&ctx[ctx_count]))
{
- printf (" Frame no: %d on master %d,Not sentOK\n", i,ctx_count);
+ printf(" Frame no: %d on master %d,Not sentOK\n", i, ctx_count);
}
- log_RT_event('S',(WORD)(99 + ctx_count * 100));
+ log_RT_event('S', (WORD)(99 + ctx_count * 100));
}
knRtSleep(1);
for (ctx_count = 0; ctx_count < 2; ctx_count++)
{
- if(wkc[ctx_count] >= expectedWKC[ctx_count])
+ if (wkc[ctx_count] >= expectedWKC[ctx_count])
{
}
else
{
- printf (" Frame no: %d on master %d , wc not wkc >= expectedWKC, %d\n",i, ctx_count, wkc[ctx_count]);
+ printf(" Frame no: %d on master %d , wc not wkc >= expectedWKC, %d\n", i, ctx_count, wkc[ctx_count]);
}
}
}
- stop_RT_trace ();
+ stop_RT_trace();
inOP = FALSE;
-
}
}
else
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
-
-void main(int argc, char* argv[])
+void main(int argc, char *argv[])
{
printf("SOEM (Simple Open EtherCAT Master)\nSlaveinfo\n");
}
else
{
- printf("Usage: slaveinfo ifname [options]\nifname = eth0 for example\nOptions :\n -sdo : print SDO info\n -map : print mapping\n");
+ printf("Usage: slaveinfo ifname [options]\nifname = eth0 for example\nOptions :\n -sdo : print SDO info\n -map : print mapping\n");
}
printf("End program\n");
-
}
-
#include "ethercat.h"
-#define MAXBUF 32768
-#define STDBUF 2048
-#define MINBUF 128
+#define MAXBUF 32768
+#define STDBUF 2048
+#define MINBUF 128
-#define MODE_NONE 0
-#define MODE_READBIN 1
-#define MODE_READINTEL 2
-#define MODE_WRITEBIN 3
-#define MODE_WRITEINTEL 4
-#define MODE_WRITEALIAS 5
-#define MODE_INFO 6
+#define MODE_NONE 0
+#define MODE_READBIN 1
+#define MODE_READINTEL 2
+#define MODE_WRITEBIN 3
+#define MODE_WRITEINTEL 4
+#define MODE_WRITEALIAS 5
+#define MODE_INFO 6
-#define MAXSLENGTH 256
+#define MAXSLENGTH 256
uint8 ebuf[MAXBUF];
uint8 ob;
int os;
int slave;
int alias;
-struct timeval tstart,tend, tdif;
+struct timeval tstart, tend, tdif;
int wkc;
int mode;
char sline[MAXSLENGTH];
int cc = 0, c;
fp = fopen(fname, "rb");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
while (((c = fgetc(fp)) != EOF) && (cc < MAXBUF))
ebuf[cc++] = (uint8)c;
int hstart, hlength, sum;
fp = fopen(fname, "r");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
hstart = MAXBUF;
hlength = 0;
{
memset(sline, 0x00, MAXSLENGTH);
sc = 0;
- while (((c = fgetc(fp)) != EOF) && (c != 0x0A) && (sc < (MAXSLENGTH -1)))
+ while (((c = fgetc(fp)) != EOF) && (c != 0x0A) && (sc < (MAXSLENGTH - 1)))
sline[sc++] = (uint8)c;
if ((c != EOF) && ((sc < 11) || (sline[0] != ':')))
{
}
if (c != EOF)
{
- sn = sscanf(sline , ":%2x%4x%2x", &ll, &ladr, <);
+ sn = sscanf(sline, ":%2x%4x%2x", &ll, &ladr, <);
if ((sn == 3) && ((ladr + ll) <= MAXBUF) && (lt == 0))
{
sum = ll + (ladr >> 8) + (ladr & 0xff) + lt;
- if(ladr < hstart) hstart = ladr;
- for(i = 0; i < ll ; i++)
+ if (ladr < hstart) hstart = ladr;
+ for (i = 0; i < ll; i++)
{
sn = sscanf(&sline[9 + (i << 1)], "%2x", &lval);
ebuf[ladr + i] = (uint8)lval;
sum += (uint8)lval;
}
- if(((ladr + ll) - hstart) > hlength)
+ if (((ladr + ll) - hstart) > hlength)
hlength = (ladr + ll) - hstart;
sum = (0x100 - sum) & 0xff;
sn = sscanf(&sline[9 + (i << 1)], "%2x", &lval);
}
}
}
- }
- while (c != EOF);
+ } while (c != EOF);
if (retval)
{
*length = hlength;
int cc;
fp = fopen(fname, "wb");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
- for (cc = 0 ; cc < length ; cc++)
- fputc( ebuf[cc], fp);
+ for (cc = 0; cc < length; cc++)
+ fputc(ebuf[cc], fp);
fclose(fp);
return 1;
int cc = 0, ll, sum, i;
fp = fopen(fname, "w");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
while (cc < length)
{
uint64 b8;
uint8 eepctl;
- if((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
{
aiadr = 1 - slave;
eepctl = 2;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
eepctl = 0;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
estat = 0x0000;
aiadr = 1 - slave;
- wkc=ec_APRD(aiadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET); /* read eeprom status */
+ wkc = ec_APRD(aiadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET); /* read eeprom status */
estat = etohs(estat);
if (estat & EC_ESTAT_R64)
{
ainc = 8;
- for (i = start ; i < (start + length) ; i+=ainc)
+ for (i = start; i < (start + length); i += ainc)
{
- b8 = ec_readeepromAP(aiadr, i >> 1 , EC_TIMEOUTEEP);
+ b8 = ec_readeepromAP(aiadr, i >> 1, EC_TIMEOUTEEP);
ebuf[i] = b8;
- ebuf[i+1] = b8 >> 8;
- ebuf[i+2] = b8 >> 16;
- ebuf[i+3] = b8 >> 24;
- ebuf[i+4] = b8 >> 32;
- ebuf[i+5] = b8 >> 40;
- ebuf[i+6] = b8 >> 48;
- ebuf[i+7] = b8 >> 56;
+ ebuf[i + 1] = b8 >> 8;
+ ebuf[i + 2] = b8 >> 16;
+ ebuf[i + 3] = b8 >> 24;
+ ebuf[i + 4] = b8 >> 32;
+ ebuf[i + 5] = b8 >> 40;
+ ebuf[i + 6] = b8 >> 48;
+ ebuf[i + 7] = b8 >> 56;
}
}
else
{
- for (i = start ; i < (start + length) ; i+=ainc)
+ for (i = start; i < (start + length); i += ainc)
{
- b4 = ec_readeepromAP(aiadr, i >> 1 , EC_TIMEOUTEEP);
+ b4 = ec_readeepromAP(aiadr, i >> 1, EC_TIMEOUTEEP);
ebuf[i] = b4;
- ebuf[i+1] = b4 >> 8;
- ebuf[i+2] = b4 >> 16;
- ebuf[i+3] = b4 >> 24;
+ ebuf[i + 1] = b4 >> 8;
+ ebuf[i + 2] = b4 >> 16;
+ ebuf[i + 3] = b4 >> 24;
}
}
uint8 eepctl;
int ret;
- if((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
{
aiadr = 1 - slave;
eepctl = 2;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
eepctl = 0;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
aiadr = 1 - slave;
wbuf = (uint16 *)&ebuf[0];
- for (i = start ; i < (start + length) ; i+=2)
+ for (i = start; i < (start + length); i += 2)
{
- ret = ec_writeeepromAP(aiadr, i >> 1 , *(wbuf + (i >> 1)), EC_TIMEOUTEEP);
+ ret = ec_writeeepromAP(aiadr, i >> 1, *(wbuf + (i >> 1)), EC_TIMEOUTEEP);
if (++dc >= 100)
{
dc = 0;
uint8 eepctl;
int ret;
- if((ec_slavecount >= slave) && (slave > 0) && (alias <= 0xffff))
+ if ((ec_slavecount >= slave) && (slave > 0) && (alias <= 0xffff))
{
aiadr = 1 - slave;
eepctl = 2;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* force Eeprom from PDI */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
eepctl = 0;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET); /* set Eeprom to master */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
- ret = ec_writeeepromAP(aiadr, 0x04 , alias, EC_TIMEOUTEEP);
+ ret = ec_writeeepromAP(aiadr, 0x04, alias, EC_TIMEOUTEEP);
return ret;
}
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
w = 0x0000;
- wkc = ec_BRD(0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
- if (wkc > 0)
- {
+ wkc = ec_BRD(0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
+ if (wkc > 0)
+ {
ec_slavecount = wkc;
- printf("%d slaves found.\n",ec_slavecount);
- if((ec_slavecount >= slave) && (slave > 0))
+ printf("%d slaves found.\n", ec_slavecount);
+ if ((ec_slavecount >= slave) && (slave > 0))
{
if ((mode == MODE_INFO) || (mode == MODE_READBIN) || (mode == MODE_READINTEL))
{
- rc = gettimeofday(&tstart, NULL);
+ rc = gettimeofday(&tstart, NULL);
eeprom_read(slave, 0x0000, MINBUF); // read first 128 bytes
wbuf = (uint16 *)&ebuf[0];
printf("Slave %d data\n", slave);
- printf(" PDI Control : %4.4X\n",*(wbuf + 0x00));
- printf(" PDI Config : %4.4X\n",*(wbuf + 0x01));
- printf(" Config Alias : %4.4X\n",*(wbuf + 0x04));
- printf(" Checksum : %4.4X\n",*(wbuf + 0x07));
- printf(" Vendor ID : %8.8X\n",*(uint32 *)(wbuf + 0x08));
- printf(" Product Code : %8.8X\n",*(uint32 *)(wbuf + 0x0A));
- printf(" Revision Number : %8.8X\n",*(uint32 *)(wbuf + 0x0C));
- printf(" Serial Number : %8.8X\n",*(uint32 *)(wbuf + 0x0E));
- printf(" Mailbox Protocol : %4.4X\n",*(wbuf + 0x1C));
+ printf(" PDI Control : %4.4X\n", *(wbuf + 0x00));
+ printf(" PDI Config : %4.4X\n", *(wbuf + 0x01));
+ printf(" Config Alias : %4.4X\n", *(wbuf + 0x04));
+ printf(" Checksum : %4.4X\n", *(wbuf + 0x07));
+ printf(" Vendor ID : %8.8X\n", *(uint32 *)(wbuf + 0x08));
+ printf(" Product Code : %8.8X\n", *(uint32 *)(wbuf + 0x0A));
+ printf(" Revision Number : %8.8X\n", *(uint32 *)(wbuf + 0x0C));
+ printf(" Serial Number : %8.8X\n", *(uint32 *)(wbuf + 0x0E));
+ printf(" Mailbox Protocol : %4.4X\n", *(wbuf + 0x1C));
esize = (*(wbuf + 0x3E) + 1) * 128;
if (esize > MAXBUF) esize = MAXBUF;
- printf(" Size : %4.4X = %d bytes\n",*(wbuf + 0x3E), esize);
- printf(" Version : %4.4X\n",*(wbuf + 0x3F));
+ printf(" Size : %4.4X = %d bytes\n", *(wbuf + 0x3E), esize);
+ printf(" Version : %4.4X\n", *(wbuf + 0x3F));
}
if ((mode == MODE_READBIN) || (mode == MODE_READINTEL))
{
if (esize > MINBUF)
eeprom_read(slave, MINBUF, esize - MINBUF); // read reminder
- rc = gettimeofday(&tend, NULL);
+ rc = gettimeofday(&tend, NULL);
timersub(&tend, &tstart, &tdif);
if (mode == MODE_READINTEL) output_intelhex(fname, esize);
- if (mode == MODE_READBIN) output_bin(fname, esize);
+ if (mode == MODE_READBIN) output_bin(fname, esize);
- printf("\nTotal EEPROM read time :%ldms\n", (tdif.tv_usec+(tdif.tv_sec*1000000L)) / 1000);
+ printf("\nTotal EEPROM read time :%ldms\n", (tdif.tv_usec + (tdif.tv_sec * 1000000L)) / 1000);
}
if ((mode == MODE_WRITEBIN) || (mode == MODE_WRITEINTEL))
{
estart = 0;
if (mode == MODE_WRITEINTEL) rc = input_intelhex(fname, &estart, &esize);
- if (mode == MODE_WRITEBIN) rc = input_bin(fname, &esize);
+ if (mode == MODE_WRITEBIN) rc = input_bin(fname, &esize);
if (rc > 0)
{
wbuf = (uint16 *)&ebuf[0];
printf("Slave %d\n", slave);
- printf(" Vendor ID : %8.8X\n",*(uint32 *)(wbuf + 0x08));
- printf(" Product Code : %8.8X\n",*(uint32 *)(wbuf + 0x0A));
- printf(" Revision Number : %8.8X\n",*(uint32 *)(wbuf + 0x0C));
- printf(" Serial Number : %8.8X\n",*(uint32 *)(wbuf + 0x0E));
+ printf(" Vendor ID : %8.8X\n", *(uint32 *)(wbuf + 0x08));
+ printf(" Product Code : %8.8X\n", *(uint32 *)(wbuf + 0x0A));
+ printf(" Revision Number : %8.8X\n", *(uint32 *)(wbuf + 0x0C));
+ printf(" Serial Number : %8.8X\n", *(uint32 *)(wbuf + 0x0E));
printf("Busy");
fflush(stdout);
- rc = gettimeofday(&tstart, NULL);
+ rc = gettimeofday(&tstart, NULL);
eeprom_write(slave, estart, esize);
- rc = gettimeofday(&tend, NULL);
+ rc = gettimeofday(&tend, NULL);
timersub(&tend, &tstart, &tdif);
- printf("\nTotal EEPROM write time :%ldms\n", (tdif.tv_usec+(tdif.tv_sec*1000000L)) / 1000);
+ printf("\nTotal EEPROM write time :%ldms\n", (tdif.tv_usec + (tdif.tv_sec * 1000000L)) / 1000);
}
else
printf("Error reading file, abort.\n");
}
if (mode == MODE_WRITEALIAS)
- {
- if(eeprom_writealias(slave, alias))
- printf("Alias %4.4X written successfully to slave %d\n");
- else
- printf("Alias not written\n");
- }
+ {
+ if (eeprom_writealias(slave, alias))
+ printf("Alias %4.4X written successfully to slave %d\n");
+ else
+ printf("Alias not written\n");
+ }
}
else
printf("Slave number outside range.\n");
ec_close();
}
else
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
int main(int argc, char *argv[])
if (argc > 3)
{
slave = atoi(argv[2]);
- if ((strncmp(argv[3], "-i", sizeof("-i")) == 0)) mode = MODE_INFO;
- if (argc > 4)
- {
- if ((strncmp(argv[3], "-r", sizeof("-r")) == 0)) mode = MODE_READBIN;
- if ((strncmp(argv[3], "-ri", sizeof("-ri")) == 0)) mode = MODE_READINTEL;
- if ((strncmp(argv[3], "-w", sizeof("-w")) == 0)) mode = MODE_WRITEBIN;
- if ((strncmp(argv[3], "-wi", sizeof("-wi")) == 0)) mode = MODE_WRITEINTEL;
- if ((strncmp(argv[3], "-walias", sizeof("-walias")) == 0))
- {
- mode = MODE_WRITEALIAS;
- alias = atoi(argv[4]);
- }
+ if ((strncmp(argv[3], "-i", sizeof("-i")) == 0)) mode = MODE_INFO;
+ if (argc > 4)
+ {
+ if ((strncmp(argv[3], "-r", sizeof("-r")) == 0)) mode = MODE_READBIN;
+ if ((strncmp(argv[3], "-ri", sizeof("-ri")) == 0)) mode = MODE_READINTEL;
+ if ((strncmp(argv[3], "-w", sizeof("-w")) == 0)) mode = MODE_WRITEBIN;
+ if ((strncmp(argv[3], "-wi", sizeof("-wi")) == 0)) mode = MODE_WRITEINTEL;
+ if ((strncmp(argv[3], "-walias", sizeof("-walias")) == 0))
+ {
+ mode = MODE_WRITEALIAS;
+ alias = atoi(argv[4]);
+ }
}
/* start tool */
- eepromtool(argv[1],slave,mode,argv[4]);
+ eepromtool(argv[1], slave, mode, argv[4]);
}
else
{
OSAL_THREAD_HANDLE threadrt, thread1;
int expectedWKC;
int mappingdone, dorun, inOP, dowkccheck;
-int adapterisbound, conf_io_size, currentgroup;
+int adapterisbound, conf_io_size, currentgroup;
int64_t cycletime = 1000000;
#define NSEC_PER_MSEC 1000000
-#define NSEC_PER_SEC 1000000000
+#define NSEC_PER_SEC 1000000000
/* add ns to timespec */
void add_timespec(struct timespec *ts, int64 addtime)
sec = (addtime - nsec) / NSEC_PER_SEC;
ts->tv_sec += sec;
ts->tv_nsec += nsec;
- if ( ts->tv_nsec >= NSEC_PER_SEC )
+ if (ts->tv_nsec >= NSEC_PER_SEC)
{
nsec = ts->tv_nsec % NSEC_PER_SEC;
ts->tv_sec += (ts->tv_nsec - nsec) / NSEC_PER_SEC;
int64 timeerror;
/* PI calculation to get linux time synced to DC time */
-void ec_sync(int64 reftime, int64 cycletime , int64 *offsettime)
+void ec_sync(int64 reftime, int64 cycletime, int64 *offsettime)
{
static int64 integral = 0;
int64 delta;
delta = (reftime - syncoffset) % cycletime;
- if(delta> (cycletime / 2)) { delta = delta - cycletime; }
+ if (delta > (cycletime / 2))
+ {
+ delta = delta - cycletime;
+ }
timeerror = -delta;
integral += timeerror;
*offsettime = (timeerror * pgain) + (integral * igain);
/* RT EtherCAT thread */
OSAL_THREAD_FUNC_RT ecatthread(void)
{
- struct timespec ts, tleft;
+ struct timespec ts, tleft;
int ht, wkc;
static int64_t toff = 0;
dorun = 0;
- while(!mappingdone) { osal_usleep(100); }
+ while (!mappingdone)
+ {
+ osal_usleep(100);
+ }
clock_gettime(CLOCK_MONOTONIC, &ts);
ht = (ts.tv_nsec / 1000000) + 1; /* round to nearest ms */
ts.tv_nsec = ht * 1000000;
ecx_send_processdata(&ecx_context);
- while(1)
+ while (1)
{
/* calculate next cycle start */
add_timespec(&ts, cycletime + toff);
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &ts, &tleft);
if (dorun > 0)
{
- wkc = ecx_receive_processdata(&ecx_context, EC_TIMEOUTRET);
- if(wkc != expectedWKC) dowkccheck++; else dowkccheck = 0;
- if (ec_slave[0].hasdc && (wkc > 0))
- {
- /* calulate toff to get linux time and DC synced */
- ec_sync(ec_DCtime, cycletime, &toff);
- }
- ecx_mbxhandler(&ecx_context, 0, 4);
- ecx_send_processdata(&ecx_context);
+ wkc = ecx_receive_processdata(&ecx_context, EC_TIMEOUTRET);
+ if (wkc != expectedWKC)
+ dowkccheck++;
+ else
+ dowkccheck = 0;
+ if (ec_slave[0].hasdc && (wkc > 0))
+ {
+ /* calulate toff to get linux time and DC synced */
+ ec_sync(ec_DCtime, cycletime, &toff);
+ }
+ ecx_mbxhandler(&ecx_context, 0, 4);
+ ecx_send_processdata(&ecx_context);
}
}
}
-OSAL_THREAD_FUNC ecatcheck( void)
+OSAL_THREAD_FUNC ecatcheck(void)
{
- int slave;
+ int slave;
- while(1)
- {
- if( inOP && ((dowkccheck > 2) || ec_group[currentgroup].docheckstate))
- {
- /* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
- ec_readstate();
- for (slave = 1; slave <= ec_slavecount; slave++)
+ while (1)
+ {
+ if (inOP && ((dowkccheck > 2) || ec_group[currentgroup].docheckstate))
+ {
+ /* one ore more slaves are not responding */
+ ec_group[currentgroup].docheckstate = FALSE;
+ ec_readstate();
+ for (slave = 1; slave <= ec_slavecount; slave++)
+ {
+ if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_group[currentgroup].docheckstate = TRUE;
+ if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
- {
- printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
- ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
- ec_writestate(slave);
- }
- else if(ec_slave[slave].state == EC_STATE_SAFE_OP)
- {
- printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
- ec_slave[slave].state = EC_STATE_OPERATIONAL;
- ec_writestate(slave);
- }
- else if(ec_slave[slave].state > EC_STATE_NONE)
- {
- if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n",slave);
- }
- }
- else if(!ec_slave[slave].islost)
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
+ ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ec_writestate(slave);
+ }
+ else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ {
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
+ ec_slave[slave].state = EC_STATE_OPERATIONAL;
+ ec_writestate(slave);
+ }
+ else if (ec_slave[slave].state > EC_STATE_NONE)
+ {
+ if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
{
- /* re-check state */
- ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
- {
- ec_slave[slave].islost = TRUE;
- printf("ERROR : slave %d lost\n",slave);
- }
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slave);
}
}
- if (ec_slave[slave].islost)
+ else if (!ec_slave[slave].islost)
{
- if(ec_slave[slave].state <= EC_STATE_INIT)
+ /* re-check state */
+ ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (ec_slave[slave].state == EC_STATE_NONE)
{
- if (ec_recover_slave(slave, EC_TIMEOUTMON))
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n",slave);
- }
+ ec_slave[slave].islost = TRUE;
+ printf("ERROR : slave %d lost\n", slave);
}
- else
+ }
+ }
+ if (ec_slave[slave].islost)
+ {
+ if (ec_slave[slave].state <= EC_STATE_INIT)
+ {
+ if (ec_recover_slave(slave, EC_TIMEOUTMON))
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found. State %2.2x\n",slave, ec_slave[slave].state);
+ printf("MESSAGE : slave %d recovered\n", slave);
}
}
+ else
+ {
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d found. State %2.2x\n", slave, ec_slave[slave].state);
+ }
}
- if(!ec_group[currentgroup].docheckstate)
- printf("OK : all slaves resumed OPERATIONAL.\n");
- dowkccheck = 0;
- }
- osal_usleep(10000);
- }
+ }
+ if (!ec_group[currentgroup].docheckstate)
+ printf("OK : all slaves resumed OPERATIONAL.\n");
+ dowkccheck = 0;
+ }
+ osal_usleep(10000);
+ }
}
void ethercatstartup(char *ifname)
{
- printf("EtherCAT Startup\n");
- int rv = ecx_init(&ecx_context, ifname);
- if(rv)
- {
- adapterisbound = 1;
- ecx_config_init(&ecx_context, FALSE);
- if(ec_slavecount > 0)
- {
- if(forceByteAlignment)
- conf_io_size = ecx_config_map_group_aligned(&ecx_context, &IOmap, 0);
- else
- conf_io_size = ecx_config_map_group(&ecx_context, &IOmap, 0);
- expectedWKC = (ecx_context.grouplist[0].outputsWKC * 2) + ecx_context.grouplist[0].inputsWKC;
- mappingdone = 1;
- ecx_configdc(&ecx_context);
- int sdoslave = -1;
- for(int si = 1 ; si <= *ecx_context.slavecount ; si++ )
+ printf("EtherCAT Startup\n");
+ int rv = ecx_init(&ecx_context, ifname);
+ if (rv)
+ {
+ adapterisbound = 1;
+ ecx_config_init(&ecx_context, FALSE);
+ if (ec_slavecount > 0)
+ {
+ if (forceByteAlignment)
+ conf_io_size = ecx_config_map_group_aligned(&ecx_context, &IOmap, 0);
+ else
+ conf_io_size = ecx_config_map_group(&ecx_context, &IOmap, 0);
+ expectedWKC = (ecx_context.grouplist[0].outputsWKC * 2) + ecx_context.grouplist[0].inputsWKC;
+ mappingdone = 1;
+ ecx_configdc(&ecx_context);
+ int sdoslave = -1;
+ for (int si = 1; si <= *ecx_context.slavecount; si++)
+ {
+ ec_slavet *slave = &ecx_context.slavelist[si];
+ printf("Slave %d name:%s man:%8.8x id:%8.8x rev:%d ser:%d\n", si, slave->name, slave->eep_man, slave->eep_id, slave->eep_rev, slave->eep_ser);
+ if (slave->CoEdetails > 0)
{
- ec_slavet *slave = &ecx_context.slavelist[si];
- printf("Slave %d name:%s man:%8.8x id:%8.8x rev:%d ser:%d\n", si, slave->name, slave->eep_man, slave->eep_id, slave->eep_rev, slave->eep_ser);
- if(slave->CoEdetails > 0)
- {
- ecx_slavembxcyclic(&ecx_context, si);
- sdoslave = si;
- printf(" Slave added to cyclic mailbox handler\n");
- }
+ ecx_slavembxcyclic(&ecx_context, si);
+ sdoslave = si;
+ printf(" Slave added to cyclic mailbox handler\n");
}
- dorun = 1;
- osal_usleep(1000000);
- ecx_context.slavelist[0].state = EC_STATE_OPERATIONAL;
- ecx_writestate(&ecx_context, 0);
- ecx_statecheck(&ecx_context, 0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
- inOP = 1;
- printf("EtherCAT OP\n");
- uint32_t aval = 0;
- int avals = sizeof(aval);
- for(int i = 0 ; i < 100 ; i++)
+ }
+ dorun = 1;
+ osal_usleep(1000000);
+ ecx_context.slavelist[0].state = EC_STATE_OPERATIONAL;
+ ecx_writestate(&ecx_context, 0);
+ ecx_statecheck(&ecx_context, 0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
+ inOP = 1;
+ printf("EtherCAT OP\n");
+ uint32_t aval = 0;
+ int avals = sizeof(aval);
+ for (int i = 0; i < 100; i++)
+ {
+ printf("Cycle %d timeerror %ld\n", i, timeerror);
+ if (sdoslave > 0)
{
- printf("Cycle %d timeerror %ld\n", i, timeerror);
- if(sdoslave >0)
- {
- aval = 0;
- int rval = ecx_SDOread(&ecx_context, sdoslave, 0x1018, 0x02, FALSE, &avals, &aval, EC_TIMEOUTRXM);
- printf(" Slave %d Rval %d Prodcode %8.8x\n", sdoslave, rval , aval);
- }
- osal_usleep(100000);
+ aval = 0;
+ int rval = ecx_SDOread(&ecx_context, sdoslave, 0x1018, 0x02, FALSE, &avals, &aval, EC_TIMEOUTRXM);
+ printf(" Slave %d Rval %d Prodcode %8.8x\n", sdoslave, rval, aval);
}
- inOP = 0;
- printf("EtherCAT to safe-OP\n");
- ecx_context.slavelist[0].state = EC_STATE_SAFE_OP;
- ecx_writestate(&ecx_context, 0);
- ecx_statecheck(&ecx_context, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
- printf("EtherCAT to INIT\n");
- ecx_context.slavelist[0].state = EC_STATE_INIT;
- ecx_writestate(&ecx_context, 0);
- ecx_statecheck(&ecx_context, 0, EC_STATE_INIT, EC_TIMEOUTSTATE);
- }
- }
+ osal_usleep(100000);
+ }
+ inOP = 0;
+ printf("EtherCAT to safe-OP\n");
+ ecx_context.slavelist[0].state = EC_STATE_SAFE_OP;
+ ecx_writestate(&ecx_context, 0);
+ ecx_statecheck(&ecx_context, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ printf("EtherCAT to INIT\n");
+ ecx_context.slavelist[0].state = EC_STATE_INIT;
+ ecx_writestate(&ecx_context, 0);
+ ecx_statecheck(&ecx_context, 0, EC_STATE_INIT, EC_TIMEOUTSTATE);
+ }
+ }
}
int main(int argc, char *argv[])
}
else
{
- ec_adaptert * adapter = NULL;
+ ec_adaptert *adapter = NULL;
printf("Usage: coetest ifname1\nifname = eth0 for example\n");
- printf ("\nAvailable adapters:\n");
- adapter = ec_find_adapters ();
+ printf("\nAvailable adapters:\n");
+ adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf (" - %s (%s)\n", adapter->name, adapter->desc);
+ printf(" - %s (%s)\n", adapter->name, adapter->desc);
adapter = adapter->next;
}
ec_free_adapters(adapter);
typedef struct PACKED
{
- uint8 status;
- uint8 counter;
- uint8 din;
- int32 ain[2];
- uint32 tsain;
- int32 enc[2];
+ uint8 status;
+ uint8 counter;
+ uint8 din;
+ int32 ain[2];
+ uint32 tsain;
+ int32 enc[2];
} in_EBOXt;
typedef struct PACKED
{
- uint8 counter;
- int16 stream[100];
+ uint8 counter;
+ int16 stream[100];
} in_EBOX_streamt;
typedef struct PACKED
{
- uint8 control;
- uint8 dout;
- int16 aout[2];
- uint16 pwmout[2];
+ uint8 control;
+ uint8 dout;
+ int16 aout[2];
+ uint16 pwmout[2];
} out_EBOXt;
typedef struct PACKED
{
- uint8 control;
+ uint8 control;
} out_EBOX_streamt;
// total samples to capture
struct sched_param schedp;
char IOmap[4096];
pthread_t thread1;
-struct timeval tv,t1,t2;
+struct timeval tv, t1, t2;
int dorun = 0;
-int deltat, tmax=0;
+int deltat, tmax = 0;
int64 toff;
int DCdiff;
int os;
uint32 ob;
int16 ob2;
uint8 ob3;
-pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-int64 integral=0;
+int64 integral = 0;
uint32 cyclecount;
-in_EBOX_streamt *in_EBOX;
+in_EBOX_streamt *in_EBOX;
out_EBOX_streamt *out_EBOX;
-double ain[2];
-int ainc;
-int streampos;
-int16 stream1[MAXSTREAM];
-int16 stream2[MAXSTREAM];
+double ain[2];
+int ainc;
+int streampos;
+int16 stream1[MAXSTREAM];
+int16 stream2[MAXSTREAM];
int output_cvs(char *fname, int length)
{
FILE *fp;
- int i;
+ int i;
fp = fopen(fname, "w");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
for (i = 0; i < length; i++)
{
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ec_config_init(FALSE) > 0 )
+ if (ec_config_init(FALSE) > 0)
{
- printf("%d slaves found and configured.\n",ec_slavecount);
+ printf("%d slaves found and configured.\n", ec_slavecount);
// check if first slave is an E/BOX
- if (( ec_slavecount >= 1 ) &&
- (strcmp(ec_slave[1].name,"E/BOX") == 0))
+ if ((ec_slavecount >= 1) &&
+ (strcmp(ec_slave[1].name, "E/BOX") == 0))
{
// reprogram PDO mapping to set slave in stream mode
// this can only be done in pre-OP state
- os=sizeof(ob2); ob2 = 0x1601;
- ec_SDOwrite(1,0x1c12,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
- os=sizeof(ob2); ob2 = 0x1a01;
- ec_SDOwrite(1,0x1c13,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1601;
+ ec_SDOwrite(1, 0x1c12, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1a01;
+ ec_SDOwrite(1, 0x1c13, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
}
ec_config_map(&IOmap);
ec_configdc();
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
/* configure DC options for every DC capable slave found in the list */
- printf("DC capable : %d\n",ec_configdc());
+ printf("DC capable : %d\n", ec_configdc());
/* check configuration */
- if (( ec_slavecount >= 1 ) &&
- (strcmp(ec_slave[1].name,"E/BOX") == 0)
- )
+ if ((ec_slavecount >= 1) &&
+ (strcmp(ec_slave[1].name, "E/BOX") == 0))
{
printf("E/BOX found.\n");
/* connect struct pointers to slave I/O pointers */
- in_EBOX = (in_EBOX_streamt*) ec_slave[1].inputs;
- out_EBOX = (out_EBOX_streamt*) ec_slave[1].outputs;
+ in_EBOX = (in_EBOX_streamt *)ec_slave[1].inputs;
+ out_EBOX = (out_EBOX_streamt *)ec_slave[1].outputs;
/* read indevidual slave state and store in ec_slave[] */
ec_readstate();
- for(cnt = 1; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
printf("Slave:%d Name:%s Output size:%3dbits Input size:%3dbits State:%2d delay:%d.%d\n",
- cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
- ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
+ cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
+ ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
}
printf("Request operational state for all slaves\n");
/* request OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach OP state */
- ec_statecheck(0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ ec_statecheck(0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
ain[0] = 0;
ain[1] = 0;
ainc = 0;
dorun = 1;
- usleep(100000); // wait for linux to sync on DC
+ usleep(100000); // wait for linux to sync on DC
ec_dcsync0(1, TRUE, SYNC0TIME, 0); // SYNC0 on slave 1
/* acyclic loop 20ms */
- for(i = 1; i <= 200; i++)
+ for (i = 1; i <= 200; i++)
{
/* read DC difference register for slave 2 */
- // ec_FPRD(ec_slave[1].configadr, ECT_REG_DCSYSDIFF, sizeof(DCdiff), &DCdiff, EC_TIMEOUTRET);
- // if(DCdiff<0) { DCdiff = - (int32)((uint32)DCdiff & 0x7ffffff); }
+ // ec_FPRD(ec_slave[1].configadr, ECT_REG_DCSYSDIFF, sizeof(DCdiff), &DCdiff, EC_TIMEOUTRET);
+ // if(DCdiff<0) { DCdiff = - (int32)((uint32)DCdiff & 0x7ffffff); }
printf("PD cycle %5d DCtime %12lld Cnt:%3d Data: %6d %6d %6d %6d %6d %6d %6d %6d \n",
- cyclecount, ec_DCtime, in_EBOX->counter, in_EBOX->stream[0], in_EBOX->stream[1],
+ cyclecount, ec_DCtime, in_EBOX->counter, in_EBOX->stream[0], in_EBOX->stream[1],
in_EBOX->stream[2], in_EBOX->stream[3], in_EBOX->stream[4], in_EBOX->stream[5],
in_EBOX->stream[98], in_EBOX->stream[99]);
usleep(20000);
}
dorun = 0;
- // printf("\nCnt %d : Ain0 = %f Ain2 = %f\n", ainc, ain[0] / ainc, ain[1] / ainc);
+ // printf("\nCnt %d : Ain0 = %f Ain2 = %f\n", ainc, ain[0] / ainc, ain[1] / ainc);
}
else
{
/* request SAFE_OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
ec_slave[0].state = EC_STATE_PRE_OP;
/* request SAFE_OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach state */
- ec_statecheck(0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE);
- if (( ec_slavecount >= 1 ) &&
- (strcmp(ec_slave[1].name,"E/BOX") == 0))
+ ec_statecheck(0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE);
+ if ((ec_slavecount >= 1) &&
+ (strcmp(ec_slave[1].name, "E/BOX") == 0))
{
// restore PDO to standard mode
// this can only be done is pre-op state
- os=sizeof(ob2); ob2 = 0x1600;
- ec_SDOwrite(1,0x1c12,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
- os=sizeof(ob2); ob2 = 0x1a00;
- ec_SDOwrite(1,0x1c13,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1600;
+ ec_SDOwrite(1, 0x1c12, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1a00;
+ ec_SDOwrite(1, 0x1c13, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
}
printf("Streampos %d\n", streampos);
output_cvs("stream.txt", streampos);
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
sec = (addtime - nsec) / NSEC_PER_SEC;
ts->tv_sec += sec;
ts->tv_nsec += nsec;
- if ( ts->tv_nsec >= NSEC_PER_SEC )
+ if (ts->tv_nsec >= NSEC_PER_SEC)
{
nsec = ts->tv_nsec % NSEC_PER_SEC;
ts->tv_sec += (ts->tv_nsec - nsec) / NSEC_PER_SEC;
}
/* PI calculation to get linux time synced to DC time */
-void ec_sync(int64 reftime, int64 cycletime , int64 *offsettime)
+void ec_sync(int64 reftime, int64 cycletime, int64 *offsettime)
{
int64 delta;
/* set linux sync point 50us later than DC sync, just as example */
delta = (reftime - 50000) % cycletime;
- if(delta> (cycletime /2)) { delta= delta - cycletime; }
- if(delta>0){ integral++; }
- if(delta<0){ integral--; }
- *offsettime = -(delta / 100) - (integral /20);
+ if (delta > (cycletime / 2))
+ {
+ delta = delta - cycletime;
+ }
+ if (delta > 0)
+ {
+ integral++;
+ }
+ if (delta < 0)
+ {
+ integral--;
+ }
+ *offsettime = -(delta / 100) - (integral / 20);
}
/* RT EtherCAT thread */
-void ecatthread( void *ptr )
+void ecatthread(void *ptr)
{
- struct timespec ts;
- struct timeval tp;
+ struct timespec ts;
+ struct timeval tp;
int ht;
int i;
int pcounter = 0;
pthread_mutex_lock(&mutex);
gettimeofday(&tp, NULL);
- /* Convert from timeval to timespec */
- ts.tv_sec = tp.tv_sec;
+ /* Convert from timeval to timespec */
+ ts.tv_sec = tp.tv_sec;
ht = (tp.tv_usec / 1000) + 1; /* round to nearest ms */
ts.tv_nsec = ht * 1000000;
- cycletime = *(int*)ptr * 1000; /* cycletime in ns */
+ cycletime = *(int *)ptr * 1000; /* cycletime in ns */
toff = 0;
dorun = 0;
- while(1)
+ while (1)
{
/* calculate next cycle start */
add_timespec(&ts, cycletime + toff);
/* wait to cycle start */
pthread_cond_timedwait(&cond, &mutex, &ts);
- if (dorun>0)
+ if (dorun > 0)
{
gettimeofday(&tp, NULL);
cyclecount++;
-
- if((in_EBOX->counter != pcounter) && (streampos < (MAXSTREAM - 1)))
+ if ((in_EBOX->counter != pcounter) && (streampos < (MAXSTREAM - 1)))
{
// check if we have timing problems in master
// if so, overwrite stream data so it shows up clearly in plots.
- if(in_EBOX->counter > (pcounter + 1))
+ if (in_EBOX->counter > (pcounter + 1))
{
- for(i = 0 ; i < 50 ; i++)
+ for (i = 0; i < 50; i++)
{
- stream1[streampos] = 20000;
+ stream1[streampos] = 20000;
stream2[streampos++] = -20000;
}
}
else
{
- for(i = 0 ; i < 50 ; i++)
+ for (i = 0; i < 50; i++)
{
- stream1[streampos] = in_EBOX->stream[i * 2];
+ stream1[streampos] = in_EBOX->stream[i * 2];
stream2[streampos++] = in_EBOX->stream[(i * 2) + 1];
}
}
int main(int argc, char *argv[])
{
int ctime;
- struct sched_param param;
- int policy = SCHED_OTHER;
+ struct sched_param param;
+ int policy = SCHED_OTHER;
printf("SOEM (Simple Open EtherCAT Master)\nE/BOX test\n");
do
{
usleep(1000);
- }
- while (dorun);
+ } while (dorun);
if (argc > 1)
{
dorun = 1;
- if( argc > 2)
+ if (argc > 2)
ctime = atoi(argv[2]);
else
ctime = 1000; // 1ms cycle time
/* create RT thread */
- pthread_create( &thread1, NULL, (void *) &ecatthread, (void*) &ctime);
+ pthread_create(&thread1, NULL, (void *)&ecatthread, (void *)&ctime);
memset(¶m, 0, sizeof(param));
/* give it higher priority */
param.sched_priority = 40;
/** \file
* \brief Example code for Simple Open EtherCAT master EoE
- *
+ *
* This example will run the follwing EoE functions
* SetIP
* GetIP
* Loop
* Send fragment data (Layer 2 0x88A4)
* Receive fragment data (Layer 2 0x88A4)
- *
+ *
* For this to work, a special slave test code is running that
* will bounce the sent 0x88A4 back to receive.
- *
+ *
* Usage : eoe_test [ifname1]
* ifname is NIC interface, f.e. eth0
*
int size_of_rx = sizeof(rxbuf);
/** registered EoE hook */
-int eoe_hook(ecx_contextt * context, uint16 slave, void * eoembx)
+int eoe_hook(ecx_contextt *context, uint16 slave, void *eoembx)
{
int wkc;
/* Pass received Mbx data to EoE recevive fragment function that
- * that will start/continue fill an Ethernet frame buffer
- */
+ * that will start/continue fill an Ethernet frame buffer
+ */
size_of_rx = sizeof(rxbuf);
wkc = ecx_EOEreadfragment(eoembx,
- &rxfragmentno,
- &rxframesize,
- &rxframeoffset,
- &rxframeno,
- &size_of_rx,
- rxbuf);
+ &rxfragmentno,
+ &rxframesize,
+ &rxframeoffset,
+ &rxframeno,
+ &size_of_rx,
+ rxbuf);
printf("Read frameno %d, fragmentno %d\n", rxframeno, rxfragmentno);
/* wkc == 1 would mean a frame is complete , last fragment flag have been set and all
- * other checks must have past
- */
+ * other checks must have past
+ */
if (wkc > 0)
{
ec_etherheadert *bp = (ec_etherheadert *)rxbuf;
ecx_contextt *context = (ecx_contextt *)lpParam;
int wkc;
ec_mbxbuft MbxIn;
- ec_mbxheadert * MbxHdr = (ec_mbxheadert *)MbxIn;
+ ec_mbxheadert *MbxHdr = (ec_mbxheadert *)MbxIn;
int ixme;
ec_setupheader(&txbuf);
txbuf[ixme] = (uint8)rand();
}
/* Send a made up frame to trigger a fragmented transfer
- * Used with a special bound impelmentaion of SOES. Will
- * trigger a fragmented transfer back of the same frame.
- */
+ * Used with a special bound impelmentaion of SOES. Will
+ * trigger a fragmented transfer back of the same frame.
+ */
ecx_EOEsend(context, 1, 0, sizeof(txbuf), txbuf, EC_TIMEOUTRXM);
for (;;)
}
}
-void test_eoe(ecx_contextt * context)
+void test_eoe(ecx_contextt *context)
{
/* Set the HOOK */
ecx_EOEdefinehook(context, eoe_hook);
EOE_IP4_ADDR_TO_U32(&ipsettings.ip, 192, 168, 9, 200);
EOE_IP4_ADDR_TO_U32(&ipsettings.subnet, 255, 255, 255, 0);
EOE_IP4_ADDR_TO_U32(&ipsettings.default_gateway, 0, 0, 0, 0);
-
+
/* Send a set IP request */
ecx_EOEsetIp(context, 1, 0, &ipsettings, EC_TIMEOUTRXM);
ecx_EOEgetIp(context, 1, 0, &re_ipsettings, EC_TIMEOUTRXM);
/* Trigger an MBX read request, to be replaced by slave Mbx
- * full notification via polling of FMMU status process data
- */
+ * full notification via polling of FMMU status process data
+ */
printf("recieved IP (%d.%d.%d.%d)\n",
- eoe_ip4_addr1(&re_ipsettings.ip),
- eoe_ip4_addr2(&re_ipsettings.ip),
- eoe_ip4_addr3(&re_ipsettings.ip),
- eoe_ip4_addr4(&re_ipsettings.ip));
+ eoe_ip4_addr1(&re_ipsettings.ip),
+ eoe_ip4_addr2(&re_ipsettings.ip),
+ eoe_ip4_addr3(&re_ipsettings.ip),
+ eoe_ip4_addr4(&re_ipsettings.ip));
printf("recieved subnet (%d.%d.%d.%d)\n",
- eoe_ip4_addr1(&re_ipsettings.subnet),
- eoe_ip4_addr2(&re_ipsettings.subnet),
- eoe_ip4_addr3(&re_ipsettings.subnet),
- eoe_ip4_addr4(&re_ipsettings.subnet));
+ eoe_ip4_addr1(&re_ipsettings.subnet),
+ eoe_ip4_addr2(&re_ipsettings.subnet),
+ eoe_ip4_addr3(&re_ipsettings.subnet),
+ eoe_ip4_addr4(&re_ipsettings.subnet));
printf("recieved gateway (%d.%d.%d.%d)\n",
- eoe_ip4_addr1(&re_ipsettings.default_gateway),
- eoe_ip4_addr2(&re_ipsettings.default_gateway),
- eoe_ip4_addr3(&re_ipsettings.default_gateway),
- eoe_ip4_addr4(&re_ipsettings.default_gateway));
+ eoe_ip4_addr1(&re_ipsettings.default_gateway),
+ eoe_ip4_addr2(&re_ipsettings.default_gateway),
+ eoe_ip4_addr3(&re_ipsettings.default_gateway),
+ eoe_ip4_addr4(&re_ipsettings.default_gateway));
/* Create a asyncronous EoE reader */
osal_thread_create(&thread2, 128000, &mailbox_reader, &ecx_context);
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ec_config_init(FALSE) > 0 )
+ if (ec_config_init(FALSE) > 0)
{
- printf("%d slaves found and configured.\n",ec_slavecount);
+ printf("%d slaves found and configured.\n", ec_slavecount);
ec_config_map(&IOmap);
printf("Slaves mapped, state to SAFE_OP.\n");
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
oloop = ec_slave[0].Obytes;
if ((oloop == 0) && (ec_slave[0].Obits > 0)) oloop = 1;
if ((iloop == 0) && (ec_slave[0].Ibits > 0)) iloop = 1;
if (iloop > 8) iloop = 8;
- printf("segments : %d : %d %d %d %d\n",ec_group[0].nsegments ,ec_group[0].IOsegment[0],ec_group[0].IOsegment[1],ec_group[0].IOsegment[2],ec_group[0].IOsegment[3]);
+ printf("segments : %d : %d %d %d %d\n", ec_group[0].nsegments, ec_group[0].IOsegment[0], ec_group[0].IOsegment[1], ec_group[0].IOsegment[2], ec_group[0].IOsegment[3]);
printf("Request operational state for all slaves\n");
expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
/* Simple EoE test */
test_eoe(&ecx_context);
-
+
/* request OP state for all slaves */
ec_writestate(0);
chk = 200;
ec_send_processdata();
ec_receive_processdata(EC_TIMEOUTRET);
ec_statecheck(0, EC_STATE_OPERATIONAL, 50000);
- }
- while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ } while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
globalwkc = expectedWKC;
inOP = TRUE;
/* cyclic loop */
- for(i = 1; i <= 10000; i++)
+ for (i = 1; i <= 10000; i++)
{
ec_send_processdata();
globalwkc = ec_receive_processdata(EC_TIMEOUTRET * 5);
#if PRINT_EOE_INFO_INSTEAD
int j;
- if(globalwkc >= expectedWKC)
+ if (globalwkc >= expectedWKC)
{
printf("Processdata cycle %4d, WKC %d , O:", i, globalwkc);
- for(j = 0 ; j < oloop; j++)
+ for (j = 0; j < oloop; j++)
{
printf(" %2.2x", *(ec_slave[0].outputs + j));
}
printf(" I:");
- for(j = 0 ; j < iloop; j++)
+ for (j = 0; j < iloop; j++)
{
printf(" %2.2x", *(ec_slave[0].inputs + j));
}
- printf(" T:%"PRId64"\r",ec_DCtime);
+ printf(" T:%" PRId64 "\r", ec_DCtime);
needlf = TRUE;
}
#endif
{
printf("Not all slaves reached operational state.\n");
ec_readstate();
- for(i = 1; i<=ec_slavecount ; i++)
+ for (i = 1; i <= ec_slavecount; i++)
{
- if(ec_slave[i].state != EC_STATE_OPERATIONAL)
+ if (ec_slave[i].state != EC_STATE_OPERATIONAL)
{
printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
- i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
+ i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
}
}
}
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
-OSAL_THREAD_FUNC ecatcheck( void *ptr )
+OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
int slave;
- (void)ptr; /* Not used */
+ (void)ptr; /* Not used */
- while(1)
+ while (1)
{
- if( inOP && ((globalwkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ if (inOP && ((globalwkc < expectedWKC) || ec_group[currentgroup].docheckstate))
{
if (globalwkc < expectedWKC)
{
ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
ec_writestate(slave);
}
- else if(ec_slave[slave].state == EC_STATE_SAFE_OP)
+ else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
{
printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
ec_slave[slave].state = EC_STATE_OPERATIONAL;
ec_writestate(slave);
}
- else if(ec_slave[slave].state > EC_STATE_NONE)
+ else if (ec_slave[slave].state > EC_STATE_NONE)
{
if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n",slave);
+ printf("MESSAGE : slave %d reconfigured\n", slave);
}
}
- else if(!ec_slave[slave].islost)
+ else if (!ec_slave[slave].islost)
{
/* re-check state */
ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
if (ec_slave[slave].state == EC_STATE_NONE)
{
ec_slave[slave].islost = TRUE;
- printf("ERROR : slave %d lost\n",slave);
+ printf("ERROR : slave %d lost\n", slave);
}
}
}
if (ec_slave[slave].islost)
{
- if(ec_slave[slave].state == EC_STATE_NONE)
+ if (ec_slave[slave].state == EC_STATE_NONE)
{
if (ec_recover_slave(slave, EC_TIMEOUTMON))
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n",slave);
+ printf("MESSAGE : slave %d recovered\n", slave);
}
}
else
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n",slave);
+ printf("MESSAGE : slave %d found\n", slave);
}
}
}
- if(!ec_group[currentgroup].docheckstate)
+ if (!ec_group[currentgroup].docheckstate)
printf("OK : all slaves resumed OPERATIONAL.\n");
}
osal_usleep(10000);
int input_bin(char *fname, int *length)
{
- FILE *fp;
-
- int cc = 0, c;
-
- fp = fopen(fname, "rb");
- if(fp == NULL)
- return 0;
- while (((c = fgetc(fp)) != EOF) && (cc < FWBUFSIZE))
- filebuffer[cc++] = (uint8)c;
- *length = cc;
- fclose(fp);
- return 1;
+ FILE *fp;
+
+ int cc = 0, c;
+
+ fp = fopen(fname, "rb");
+ if (fp == NULL)
+ return 0;
+ while (((c = fgetc(fp)) != EOF) && (cc < FWBUFSIZE))
+ filebuffer[cc++] = (uint8)c;
+ *length = cc;
+ fclose(fp);
+ return 1;
}
-
void boottest(char *ifname, uint16 slave, char *filename)
{
- printf("Starting firmware update example\n");
-
- /* initialise SOEM, bind socket to ifname */
- if (ec_init(ifname))
- {
- printf("ec_init on %s succeeded.\n",ifname);
- /* find and auto-config slaves */
-
-
- if ( ec_config_init(FALSE) > 0 )
- {
- printf("%d slaves found and configured.\n",ec_slavecount);
-
- /* wait for all slaves to reach PRE_OP state */
- ec_statecheck(0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE * 4);
-
- printf("Request init state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_INIT;
- ec_writestate(slave);
-
- /* wait for slave to reach INIT state */
- ec_statecheck(slave, EC_STATE_INIT, EC_TIMEOUTSTATE * 4);
- printf("Slave %d state to INIT.\n", slave);
-
- /* read BOOT mailbox data, master -> slave */
- data = ec_readeeprom(slave, ECT_SII_BOOTRXMBX, EC_TIMEOUTEEP);
- ec_slave[slave].SM[0].StartAddr = (uint16)LO_WORD(data);
- ec_slave[slave].SM[0].SMlength = (uint16)HI_WORD(data);
- /* store boot write mailbox address */
- ec_slave[slave].mbx_wo = (uint16)LO_WORD(data);
- /* store boot write mailbox size */
- ec_slave[slave].mbx_l = (uint16)HI_WORD(data);
-
- /* read BOOT mailbox data, slave -> master */
- data = ec_readeeprom(slave, ECT_SII_BOOTTXMBX, EC_TIMEOUTEEP);
- ec_slave[slave].SM[1].StartAddr = (uint16)LO_WORD(data);
- ec_slave[slave].SM[1].SMlength = (uint16)HI_WORD(data);
- /* store boot read mailbox address */
- ec_slave[slave].mbx_ro = (uint16)LO_WORD(data);
- /* store boot read mailbox size */
- ec_slave[slave].mbx_rl = (uint16)HI_WORD(data);
-
- printf(" SM0 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[0].StartAddr, ec_slave[slave].SM[0].SMlength,
- (int)ec_slave[slave].SM[0].SMflags);
- printf(" SM1 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[1].StartAddr, ec_slave[slave].SM[1].SMlength,
- (int)ec_slave[slave].SM[1].SMflags);
- /* program SM0 mailbox in for slave */
- ec_FPWR (ec_slave[slave].configadr, ECT_REG_SM0, sizeof(ec_smt), &ec_slave[slave].SM[0], EC_TIMEOUTRET);
- /* program SM1 mailbox out for slave */
- ec_FPWR (ec_slave[slave].configadr, ECT_REG_SM1, sizeof(ec_smt), &ec_slave[slave].SM[1], EC_TIMEOUTRET);
-
- printf("Request BOOT state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_BOOT;
- ec_writestate(slave);
-
- /* wait for slave to reach BOOT state */
- if (ec_statecheck(slave, EC_STATE_BOOT, EC_TIMEOUTSTATE * 10) == EC_STATE_BOOT)
- {
- printf("Slave %d state to BOOT.\n", slave);
-
- if (input_bin(filename, &filesize))
- {
- printf("File read OK, %d bytes.\n",filesize);
- printf("FoE write....");
- j = ec_FOEwrite(slave, filename, 0, filesize , &filebuffer, EC_TIMEOUTSTATE);
- printf("result %d.\n",j);
- printf("Request init state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_INIT;
- ec_writestate(slave);
- }
- else
- printf("File not read OK.\n");
- }
-
- }
- else
- {
- printf("No slaves found!\n");
- }
- printf("End firmware update example, close socket\n");
- /* stop SOEM, close socket */
- ec_close();
- }
- else
- {
- printf("No socket connection on %s\nExcecute as root\n",ifname);
- }
+ printf("Starting firmware update example\n");
+
+ /* initialise SOEM, bind socket to ifname */
+ if (ec_init(ifname))
+ {
+ printf("ec_init on %s succeeded.\n", ifname);
+ /* find and auto-config slaves */
+
+ if (ec_config_init(FALSE) > 0)
+ {
+ printf("%d slaves found and configured.\n", ec_slavecount);
+
+ /* wait for all slaves to reach PRE_OP state */
+ ec_statecheck(0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE * 4);
+
+ printf("Request init state for slave %d\n", slave);
+ ec_slave[slave].state = EC_STATE_INIT;
+ ec_writestate(slave);
+
+ /* wait for slave to reach INIT state */
+ ec_statecheck(slave, EC_STATE_INIT, EC_TIMEOUTSTATE * 4);
+ printf("Slave %d state to INIT.\n", slave);
+
+ /* read BOOT mailbox data, master -> slave */
+ data = ec_readeeprom(slave, ECT_SII_BOOTRXMBX, EC_TIMEOUTEEP);
+ ec_slave[slave].SM[0].StartAddr = (uint16)LO_WORD(data);
+ ec_slave[slave].SM[0].SMlength = (uint16)HI_WORD(data);
+ /* store boot write mailbox address */
+ ec_slave[slave].mbx_wo = (uint16)LO_WORD(data);
+ /* store boot write mailbox size */
+ ec_slave[slave].mbx_l = (uint16)HI_WORD(data);
+
+ /* read BOOT mailbox data, slave -> master */
+ data = ec_readeeprom(slave, ECT_SII_BOOTTXMBX, EC_TIMEOUTEEP);
+ ec_slave[slave].SM[1].StartAddr = (uint16)LO_WORD(data);
+ ec_slave[slave].SM[1].SMlength = (uint16)HI_WORD(data);
+ /* store boot read mailbox address */
+ ec_slave[slave].mbx_ro = (uint16)LO_WORD(data);
+ /* store boot read mailbox size */
+ ec_slave[slave].mbx_rl = (uint16)HI_WORD(data);
+
+ printf(" SM0 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[0].StartAddr, ec_slave[slave].SM[0].SMlength,
+ (int)ec_slave[slave].SM[0].SMflags);
+ printf(" SM1 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[1].StartAddr, ec_slave[slave].SM[1].SMlength,
+ (int)ec_slave[slave].SM[1].SMflags);
+ /* program SM0 mailbox in for slave */
+ ec_FPWR(ec_slave[slave].configadr, ECT_REG_SM0, sizeof(ec_smt), &ec_slave[slave].SM[0], EC_TIMEOUTRET);
+ /* program SM1 mailbox out for slave */
+ ec_FPWR(ec_slave[slave].configadr, ECT_REG_SM1, sizeof(ec_smt), &ec_slave[slave].SM[1], EC_TIMEOUTRET);
+
+ printf("Request BOOT state for slave %d\n", slave);
+ ec_slave[slave].state = EC_STATE_BOOT;
+ ec_writestate(slave);
+
+ /* wait for slave to reach BOOT state */
+ if (ec_statecheck(slave, EC_STATE_BOOT, EC_TIMEOUTSTATE * 10) == EC_STATE_BOOT)
+ {
+ printf("Slave %d state to BOOT.\n", slave);
+
+ if (input_bin(filename, &filesize))
+ {
+ printf("File read OK, %d bytes.\n", filesize);
+ printf("FoE write....");
+ j = ec_FOEwrite(slave, filename, 0, filesize, &filebuffer, EC_TIMEOUTSTATE);
+ printf("result %d.\n", j);
+ printf("Request init state for slave %d\n", slave);
+ ec_slave[slave].state = EC_STATE_INIT;
+ ec_writestate(slave);
+ }
+ else
+ printf("File not read OK.\n");
+ }
+ }
+ else
+ {
+ printf("No slaves found!\n");
+ }
+ printf("End firmware update example, close socket\n");
+ /* stop SOEM, close socket */
+ ec_close();
+ }
+ else
+ {
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
+ }
}
int main(int argc, char *argv[])
{
- printf("SOEM (Simple Open EtherCAT Master)\nFirmware update example\n");
-
- if (argc > 3)
- {
- argslave = atoi(argv[2]);
- boottest(argv[1], argslave, argv[3]);
- }
- else
- {
- printf("Usage: firm_update ifname1 slave fname\n");
- printf("ifname = eth0 for example\n");
- printf("slave = slave number in EtherCAT order 1..n\n");
- printf("fname = binary file to store in slave\n");
- printf("CAUTION! Using the wrong file can result in a bricked slave!\n");
- }
-
- printf("End program\n");
- return (0);
+ printf("SOEM (Simple Open EtherCAT Master)\nFirmware update example\n");
+
+ if (argc > 3)
+ {
+ argslave = atoi(argv[2]);
+ boottest(argv[1], argslave, argv[3]);
+ }
+ else
+ {
+ printf("Usage: firm_update ifname1 slave fname\n");
+ printf("ifname = eth0 for example\n");
+ printf("slave = slave number in EtherCAT order 1..n\n");
+ printf("fname = binary file to store in slave\n");
+ printf("CAUTION! Using the wrong file can result in a bricked slave!\n");
+ }
+
+ printf("End program\n");
+ return (0);
}
#include "ethercat.h"
-#define NSEC_PER_SEC 1000000000
+#define NSEC_PER_SEC 1000000000
#define EC_TIMEOUTMON 500
struct sched_param schedp;
boolean inOP;
uint8 currentgroup = 0;
-
void redtest(char *ifname, char *ifname2)
{
int cnt, i, j, oloop, iloop;
printf("Starting Redundant test\n");
/* initialise SOEM, bind socket to ifname */
- (void) ifname2;
-// if (ec_init_redundant(ifname, ifname2))
+ (void)ifname2;
+ // if (ec_init_redundant(ifname, ifname2))
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ec_config(FALSE, &IOmap) > 0 )
+ if (ec_config(FALSE, &IOmap) > 0)
{
- printf("%d slaves found and configured.\n",ec_slavecount);
+ printf("%d slaves found and configured.\n", ec_slavecount);
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
/* configure DC options for every DC capable slave found in the list */
ec_configdc();
/* read indevidual slave state and store in ec_slave[] */
ec_readstate();
- for(cnt = 1; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
printf("Slave:%d Name:%s Output size:%3dbits Input size:%3dbits State:%2d delay:%d.%d\n",
- cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
- ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
+ cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
+ ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
printf(" Out:%p,%4d In:%p,%4d\n",
- ec_slave[cnt].outputs, ec_slave[cnt].Obytes, ec_slave[cnt].inputs, ec_slave[cnt].Ibytes);
+ ec_slave[cnt].outputs, ec_slave[cnt].Obytes, ec_slave[cnt].inputs, ec_slave[cnt].Ibytes);
/* check for EL2004 or EL2008 */
- if( !digout && ((ec_slave[cnt].eep_id == 0x0af83052) || (ec_slave[cnt].eep_id == 0x07d83052)))
+ if (!digout && ((ec_slave[cnt].eep_id == 0x0af83052) || (ec_slave[cnt].eep_id == 0x07d83052)))
{
digout = ec_slave[cnt].outputs;
}
/* activate cyclic process data */
dorun = 1;
/* wait for all slaves to reach OP state */
- ec_statecheck(0, EC_STATE_OPERATIONAL, 5 * EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_OPERATIONAL, 5 * EC_TIMEOUTSTATE);
oloop = ec_slave[0].Obytes;
if ((oloop == 0) && (ec_slave[0].Obits > 0)) oloop = 1;
if (oloop > 8) oloop = 8;
iloop = ec_slave[0].Ibytes;
if ((iloop == 0) && (ec_slave[0].Ibits > 0)) iloop = 1;
if (iloop > 8) iloop = 8;
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
inOP = TRUE;
/* acyclic loop 5000 x 20ms = 10s */
- for(i = 1; i <= 5000; i++)
+ for (i = 1; i <= 5000; i++)
{
- printf("Processdata cycle %5d , Wck %3d, DCtime %12"PRId64", dt %12"PRId64", O:",
- dorun, wkc , ec_DCtime, gl_delta);
- for(j = 0 ; j < oloop; j++)
+ printf("Processdata cycle %5d , Wck %3d, DCtime %12" PRId64 ", dt %12" PRId64 ", O:",
+ dorun, wkc, ec_DCtime, gl_delta);
+ for (j = 0; j < oloop; j++)
{
printf(" %2.2x", *(ec_slave[0].outputs + j));
}
printf(" I:");
- for(j = 0 ; j < iloop; j++)
+ for (j = 0; j < iloop; j++)
{
printf(" %2.2x", *(ec_slave[0].inputs + j));
}
else
{
printf("Not all slaves reached operational state.\n");
- ec_readstate();
- for(i = 1; i<=ec_slavecount ; i++)
- {
- if(ec_slave[i].state != EC_STATE_OPERATIONAL)
- {
- printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
+ ec_readstate();
+ for (i = 1; i <= ec_slavecount; i++)
+ {
+ if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ {
+ printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
- }
- }
+ }
+ }
}
printf("Request safe operational state for all slaves\n");
ec_slave[0].state = EC_STATE_SAFE_OP;
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
sec = (addtime - nsec) / NSEC_PER_SEC;
ts->tv_sec += sec;
ts->tv_nsec += nsec;
- if ( ts->tv_nsec >= NSEC_PER_SEC )
+ if (ts->tv_nsec >= NSEC_PER_SEC)
{
nsec = ts->tv_nsec % NSEC_PER_SEC;
ts->tv_sec += (ts->tv_nsec - nsec) / NSEC_PER_SEC;
}
/* PI calculation to get linux time synced to DC time */
-void ec_sync(int64 reftime, int64 cycletime , int64 *offsettime)
+void ec_sync(int64 reftime, int64 cycletime, int64 *offsettime)
{
static int64 integral = 0;
int64 delta;
/* set linux sync point 50us later than DC sync, just as example */
delta = (reftime - 50000) % cycletime;
- if(delta> (cycletime / 2)) { delta= delta - cycletime; }
- if(delta>0){ integral++; }
- if(delta<0){ integral--; }
+ if (delta > (cycletime / 2))
+ {
+ delta = delta - cycletime;
+ }
+ if (delta > 0)
+ {
+ integral++;
+ }
+ if (delta < 0)
+ {
+ integral--;
+ }
*offsettime = -(delta / 100) - (integral / 20);
gl_delta = delta;
}
/* RT EtherCAT thread */
OSAL_THREAD_FUNC_RT ecatthread(void *ptr)
{
- struct timespec ts, tleft;
+ struct timespec ts, tleft;
int ht;
int64 cycletime;
clock_gettime(CLOCK_MONOTONIC, &ts);
ht = (ts.tv_nsec / 1000000) + 1; /* round to nearest ms */
ts.tv_nsec = ht * 1000000;
- if (ts.tv_nsec >= NSEC_PER_SEC) {
+ if (ts.tv_nsec >= NSEC_PER_SEC)
+ {
ts.tv_sec++;
ts.tv_nsec -= NSEC_PER_SEC;
}
- cycletime = *(int*)ptr * 1000; /* cycletime in ns */
+ cycletime = *(int *)ptr * 1000; /* cycletime in ns */
toff = 0;
dorun = 0;
ec_send_processdata();
- while(1)
+ while (1)
{
/* calculate next cycle start */
add_timespec(&ts, cycletime + toff);
/* wait to cycle start */
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &ts, &tleft);
- if (dorun>0)
+ if (dorun > 0)
{
wkc = ec_receive_processdata(EC_TIMEOUTRET);
dorun++;
/* if we have some digital output, cycle */
- if( digout ) *digout = (uint8) ((dorun / 16) & 0xff);
+ if (digout) *digout = (uint8)((dorun / 16) & 0xff);
if (ec_slave[0].hasdc)
{
}
}
-OSAL_THREAD_FUNC ecatcheck( void *ptr )
+OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
- int slave;
+ int slave;
- (void) ptr;
+ (void)ptr;
- while(1)
- {
- if( inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
- {
- if (needlf)
- {
- needlf = FALSE;
- printf("\n");
- }
- /* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
- ec_readstate();
- for (slave = 1; slave <= ec_slavecount; slave++)
+ while (1)
+ {
+ if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ {
+ if (needlf)
+ {
+ needlf = FALSE;
+ printf("\n");
+ }
+ /* one ore more slaves are not responding */
+ ec_group[currentgroup].docheckstate = FALSE;
+ ec_readstate();
+ for (slave = 1; slave <= ec_slavecount; slave++)
+ {
+ if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_group[currentgroup].docheckstate = TRUE;
+ if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
- {
- printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
- ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
- ec_writestate(slave);
- }
- else if(ec_slave[slave].state == EC_STATE_SAFE_OP)
- {
- printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
- ec_slave[slave].state = EC_STATE_OPERATIONAL;
- ec_writestate(slave);
- }
- else if(ec_slave[slave].state > EC_STATE_NONE)
- {
- if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n",slave);
- }
- }
- else if(!ec_slave[slave].islost)
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
+ ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ec_writestate(slave);
+ }
+ else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ {
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
+ ec_slave[slave].state = EC_STATE_OPERATIONAL;
+ ec_writestate(slave);
+ }
+ else if (ec_slave[slave].state > EC_STATE_NONE)
+ {
+ if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
{
- /* re-check state */
- ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
- {
- ec_slave[slave].islost = TRUE;
- printf("ERROR : slave %d lost\n",slave);
- }
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slave);
}
}
- if (ec_slave[slave].islost)
+ else if (!ec_slave[slave].islost)
{
- if(ec_slave[slave].state == EC_STATE_NONE)
+ /* re-check state */
+ ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (ec_slave[slave].state == EC_STATE_NONE)
{
- if (ec_recover_slave(slave, EC_TIMEOUTMON))
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n",slave);
- }
+ ec_slave[slave].islost = TRUE;
+ printf("ERROR : slave %d lost\n", slave);
}
- else
+ }
+ }
+ if (ec_slave[slave].islost)
+ {
+ if (ec_slave[slave].state == EC_STATE_NONE)
+ {
+ if (ec_recover_slave(slave, EC_TIMEOUTMON))
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n",slave);
+ printf("MESSAGE : slave %d recovered\n", slave);
}
}
+ else
+ {
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slave);
+ }
}
- if(!ec_group[currentgroup].docheckstate)
- printf("OK : all slaves resumed OPERATIONAL.\n");
- }
- osal_usleep(10000);
- }
+ }
+ if (!ec_group[currentgroup].docheckstate)
+ printf("OK : all slaves resumed OPERATIONAL.\n");
+ }
+ osal_usleep(10000);
+ }
}
#define stack64k (64 * 1024)
ctime = atoi(argv[3]);
/* create RT thread */
- osal_thread_create_rt(&thread1, stack64k * 2, &ecatthread, (void*) &ctime);
+ osal_thread_create_rt(&thread1, stack64k * 2, &ecatthread, (void *)&ctime);
/* create thread to handle slave error handling in OP */
osal_thread_create(&thread2, stack64k * 4, &ecatcheck, NULL);
/* start acyclic part */
- redtest(argv[1],argv[2]);
+ redtest(argv[1], argv[2]);
}
else
{
#include <defBF537.h>
-#define pPORTFIO_SET ((vuint16_t *)PORTFIO_SET)
-#define pPORTFIO_CLEAR ((vuint16_t *)PORTFIO_CLEAR)
-#define pPORTFIO_DIR ((vuint16_t *)PORTFIO_DIR)
-
-#define EK1100_1 1
-#define EL4001_1 2
-#define EL3061_1 3
-#define EL1008_1 4
-#define EL1008_2 5
-#define EL2622_1 6
-#define EL2622_2 7
-#define EL2622_3 8
-#define EL2622_4 9
-#define NUMBER_OF_SLAVES 9
-
+#define pPORTFIO_SET ((vuint16_t *)PORTFIO_SET)
+#define pPORTFIO_CLEAR ((vuint16_t *)PORTFIO_CLEAR)
+#define pPORTFIO_DIR ((vuint16_t *)PORTFIO_DIR)
+
+#define EK1100_1 1
+#define EL4001_1 2
+#define EL3061_1 3
+#define EL1008_1 4
+#define EL1008_2 5
+#define EL2622_1 6
+#define EL2622_2 7
+#define EL2622_3 8
+#define EL2622_4 9
+#define NUMBER_OF_SLAVES 9
typedef struct
{
- uint8 in1;
- uint8 in2;
- uint8 in3;
- uint8 in4;
- uint8 in5;
- uint8 in6;
- uint8 in7;
- uint8 in8;
+ uint8 in1;
+ uint8 in2;
+ uint8 in3;
+ uint8 in4;
+ uint8 in5;
+ uint8 in6;
+ uint8 in7;
+ uint8 in8;
} in_EL1008_t;
typedef struct
{
- uint8 out1;
- uint8 out2;
+ uint8 out1;
+ uint8 out2;
} out_EL2622_t;
typedef struct
{
- int16 out1;
+ int16 out1;
} out_EL4001_t;
typedef struct
{
- int32 in1;
+ int32 in1;
} in_EL3061_t;
-out_EL4001_t slave_EL4001_1;
-in_EL3061_t slave_EL3061_1;
-in_EL1008_t slave_EL1008_1;
-in_EL1008_t slave_EL1008_2;
-out_EL2622_t slave_EL2622_1;
-out_EL2622_t slave_EL2622_2;
-out_EL2622_t slave_EL2622_3;
+out_EL4001_t slave_EL4001_1;
+in_EL3061_t slave_EL3061_1;
+in_EL1008_t slave_EL1008_1;
+in_EL1008_t slave_EL1008_2;
+out_EL2622_t slave_EL2622_1;
+out_EL2622_t slave_EL2622_2;
+out_EL2622_t slave_EL2622_3;
uint32 network_configuration(void)
{
return 0;
/* Verify slave by slave that it is correct*/
- if (strcmp(ec_slave[EK1100_1].name,"EK1100"))
+ if (strcmp(ec_slave[EK1100_1].name, "EK1100"))
return 0;
- else if (strcmp(ec_slave[EL4001_1].name,"EL4001"))
+ else if (strcmp(ec_slave[EL4001_1].name, "EL4001"))
return 0;
- else if (strcmp(ec_slave[EL3061_1].name,"EL3061"))
+ else if (strcmp(ec_slave[EL3061_1].name, "EL3061"))
return 0;
- else if (strcmp(ec_slave[EL1008_1].name,"EL1008"))
+ else if (strcmp(ec_slave[EL1008_1].name, "EL1008"))
return 0;
- else if (strcmp(ec_slave[EL1008_2].name,"EL1008"))
+ else if (strcmp(ec_slave[EL1008_2].name, "EL1008"))
return 0;
- else if (strcmp(ec_slave[EL2622_1].name,"EL2622"))
+ else if (strcmp(ec_slave[EL2622_1].name, "EL2622"))
return 0;
- else if (strcmp(ec_slave[EL2622_2].name,"EL2622"))
+ else if (strcmp(ec_slave[EL2622_2].name, "EL2622"))
return 0;
- else if (strcmp(ec_slave[EL2622_3].name,"EL2622"))
+ else if (strcmp(ec_slave[EL2622_3].name, "EL2622"))
return 0;
- else if (strcmp(ec_slave[EL2622_4].name,"EL2622"))
+ else if (strcmp(ec_slave[EL2622_4].name, "EL2622"))
return 0;
- return 1;
+ return 1;
}
-int32 get_input_int32(uint16 slave_no,uint8 module_index)
+int32 get_input_int32(uint16 slave_no, uint8 module_index)
{
int32 return_value;
uint8 *data_ptr;
return return_value;
}
-void set_input_int32 (uint16 slave_no, uint8 module_index, int32 value)
+void set_input_int32(uint16 slave_no, uint8 module_index, int32 value)
{
uint8 *data_ptr;
/* Get the IO map pointer from the ec_slave struct */
*data_ptr++ = (value >> 24) & 0xFF;
}
-uint8 get_input_bit (uint16 slave_no,uint8 module_index)
+uint8 get_input_bit(uint16 slave_no, uint8 module_index)
{
/* Get the the startbit position in slaves IO byte */
uint8 startbit = ec_slave[slave_no].Istartbit;
/* Mask bit and return boolean 0 or 1 */
- if (*ec_slave[slave_no].inputs & BIT (module_index - 1 + startbit))
+ if (*ec_slave[slave_no].inputs & BIT(module_index - 1 + startbit))
return 1;
else
return 0;
}
-int16 get_output_int16(uint16 slave_no,uint8 module_index)
+int16 get_output_int16(uint16 slave_no, uint8 module_index)
{
int16 return_value;
uint8 *data_ptr;
return return_value;
}
-void set_output_int16 (uint16 slave_no, uint8 module_index, int16 value)
+void set_output_int16(uint16 slave_no, uint8 module_index, int16 value)
{
uint8 *data_ptr;
/* Get the IO map pointer from the ec_slave struct */
*data_ptr++ = (value >> 8) & 0xFF;
}
-uint8 get_output_bit (uint16 slave_no,uint8 module_index)
+uint8 get_output_bit(uint16 slave_no, uint8 module_index)
{
/* Get the the startbit position in slaves IO byte */
uint8 startbit = ec_slave[slave_no].Ostartbit;
/* Mask bit and return boolean 0 or 1 */
- if (*ec_slave[slave_no].outputs & BIT (module_index - 1 + startbit))
+ if (*ec_slave[slave_no].outputs & BIT(module_index - 1 + startbit))
return 1;
else
return 0;
}
-void set_output_bit (uint16 slave_no, uint8 module_index, uint8 value)
+void set_output_bit(uint16 slave_no, uint8 module_index, uint8 value)
{
/* Get the the startbit position in slaves IO byte */
uint8 startbit = ec_slave[slave_no].Ostartbit;
*ec_slave[slave_no].outputs |= (1 << (module_index - 1 + startbit));
}
-
-extern tt_sched_t * tt_sched[];
+extern tt_sched_t *tt_sched[];
char IOmap[128];
int dorun = 0;
uint8_t load1s, load5s, load10s;
uint32_t error_counter = 0;
-void tt_error (uint32_t task_ix);
-void tt_error (uint32_t task_ix)
+void tt_error(uint32_t task_ix);
+void tt_error(uint32_t task_ix)
{
error_counter++;
}
-static void my_cyclic_callback (void * arg)
+static void my_cyclic_callback(void *arg)
{
while (1)
{
- stats_get_load (&load1s, &load5s, &load10s);
- rprintp ("Processor load was %d:%d:%d (1s:5s:10s) with TT errors: %d\n",
- load1s, load5s, load10s,error_counter);
+ stats_get_load(&load1s, &load5s, &load10s);
+ rprintp("Processor load was %d:%d:%d (1s:5s:10s) with TT errors: %d\n",
+ load1s, load5s, load10s, error_counter);
task_delay(20000);
}
}
-
-void read_io (void * arg)
+void read_io(void *arg)
{
/* Function connected to cyclic TTOS task
* The function is executed cyclic according
* sceduel specified in schedule.tt
*/
- *pPORTFIO_SET = BIT (6);
+ *pPORTFIO_SET = BIT(6);
/* Send and receive processdata
* Note that you need som synchronization
* case you modifey IO in local application
*/
ec_send_processdata();
ec_receive_processdata(EC_TIMEOUTRET);
- *pPORTFIO_CLEAR = BIT (6);
+ *pPORTFIO_CLEAR = BIT(6);
}
-
void simpletest(void *arg)
{
char *ifname = arg;
int cnt, i, j;
- *pPORTFIO_DIR |= BIT (6);
+ *pPORTFIO_DIR |= BIT(6);
rprintp("Starting simple test\n");
rprintp("ec_init succeeded.\n");
/* find and auto-config slaves */
- if ( ec_config_init(FALSE) > 0 )
+ if (ec_config_init(FALSE) > 0)
{
- rprintp("%d slaves found and configured.\n",ec_slavecount);
+ rprintp("%d slaves found and configured.\n", ec_slavecount);
/* Check network setup */
if (network_configuration())
rprintp("Slaves mapped, state to SAFE_OP.\n");
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
/* Print som information on the mapped network */
- for( cnt = 1 ; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
rprintp("\nSlave:%d\n Name:%s\n Output size: %dbits\n Input size: %dbits\n State: %d\n Delay: %d[ns]\n Has DC: %d\n",
cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
rprintp(" Outputs address: %x\n", ec_slave[cnt].outputs);
rprintp(" Inputs address: %x\n", ec_slave[cnt].inputs);
- for(j = 0 ; j < ec_slave[cnt].FMMUunused ; j++)
+ for (j = 0; j < ec_slave[cnt].FMMUunused; j++)
{
rprintp(" FMMU%1d Ls:%x Ll:%4d Lsb:%d Leb:%d Ps:%x Psb:%d Ty:%x Act:%x\n", j,
(int)ec_slave[cnt].FMMU[j].LogStart, ec_slave[cnt].FMMU[j].LogLength, ec_slave[cnt].FMMU[j].LogStartbit,
ec_slave[cnt].FMMU[j].FMMUtype, ec_slave[cnt].FMMU[j].FMMUactive);
}
rprintp(" FMMUfunc 0:%d 1:%d 2:%d 3:%d\n",
- ec_slave[cnt].FMMU0func, ec_slave[cnt].FMMU1func, ec_slave[cnt].FMMU2func, ec_slave[cnt].FMMU3func);
-
+ ec_slave[cnt].FMMU0func, ec_slave[cnt].FMMU1func, ec_slave[cnt].FMMU2func, ec_slave[cnt].FMMU3func);
}
rprintp("Request operational state for all slaves\n");
/* request OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach OP state */
- ec_statecheck(0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ ec_statecheck(0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
rprintp("Operational state reached for all slaves.\n");
}
{
rprintp("Not all slaves reached operational state.\n");
ec_readstate();
- for(i = 1; i<=ec_slavecount ; i++)
+ for (i = 1; i <= ec_slavecount; i++)
{
- if(ec_slave[i].state != EC_STATE_OPERATIONAL)
+ if (ec_slave[i].state != EC_STATE_OPERATIONAL)
{
rprintp("Slave %d State=0x%04x StatusCode=0x%04x\n",
i, ec_slave[i].state, ec_slave[i].ALstatuscode);
}
}
-
/* Simple blinking lamps BOX demo */
uint8 digout = 0;
slave_EL4001_1.out1 = (int16)0x3FFF;
- set_output_int16(EL4001_1,0,slave_EL4001_1.out1);
+ set_output_int16(EL4001_1, 0, slave_EL4001_1.out1);
- task_spawn ("t_StatsPrint", my_cyclic_callback, 20, 1024, (void *)NULL);
- tt_start_wait (tt_sched[0]);
+ task_spawn("t_StatsPrint", my_cyclic_callback, 20, 1024, (void *)NULL);
+ tt_start_wait(tt_sched[0]);
- while(1)
+ while (1)
{
dorun = 0;
- slave_EL1008_1.in1 = get_input_bit(EL1008_1,1); // Start button
- slave_EL1008_1.in2 = get_input_bit(EL1008_1,2); // Turnkey RIGHT
- slave_EL1008_1.in3 = get_input_bit(EL1008_1,3); // Turnkey LEFT
+ slave_EL1008_1.in1 = get_input_bit(EL1008_1, 1); // Start button
+ slave_EL1008_1.in2 = get_input_bit(EL1008_1, 2); // Turnkey RIGHT
+ slave_EL1008_1.in3 = get_input_bit(EL1008_1, 3); // Turnkey LEFT
/* (Turnkey MIDDLE + Start button) OR Turnkey RIGHT OR Turnkey LEFT
Turnkey LEFT: Light positions bottom to top. Loop, slow operation.
digout = 0;
/* *ec_slave[6].outputs = digout; */
/* set_output_bit(slave_name #,index as 1 output on module , value */
- set_output_bit(EL2622_1,1,(digout & BIT (0))); /* Start button */
- set_output_bit(EL2622_1,2,(digout & BIT (1))); /* Turnkey RIGHT */
- set_output_bit(EL2622_2,1,(digout & BIT (2))); /* Turnkey LEFT */
- set_output_bit(EL2622_2,2,(digout & BIT (3)));
- set_output_bit(EL2622_3,1,(digout & BIT (4)));
- set_output_bit(EL2622_3,2,(digout & BIT (5)));
-
- while(dorun < 95)
+ set_output_bit(EL2622_1, 1, (digout & BIT(0))); /* Start button */
+ set_output_bit(EL2622_1, 2, (digout & BIT(1))); /* Turnkey RIGHT */
+ set_output_bit(EL2622_2, 1, (digout & BIT(2))); /* Turnkey LEFT */
+ set_output_bit(EL2622_2, 2, (digout & BIT(3)));
+ set_output_bit(EL2622_3, 1, (digout & BIT(4)));
+ set_output_bit(EL2622_3, 2, (digout & BIT(5)));
+
+ while (dorun < 95)
{
dorun++;
else
task_delay(tick_from_ms(5));
- digout = (uint8) (digout | BIT((dorun / 16) & 0xFF));
+ digout = (uint8)(digout | BIT((dorun / 16) & 0xFF));
- set_output_bit(EL2622_1,1,(digout & BIT (0))); /* LED1 */
- set_output_bit(EL2622_1,2,(digout & BIT (1))); /* LED2 */
- set_output_bit(EL2622_2,1,(digout & BIT (2))); /* LED3 */
- set_output_bit(EL2622_2,2,(digout & BIT (3))); /* LED4 */
- set_output_bit(EL2622_3,1,(digout & BIT (4))); /* LED5 */
- set_output_bit(EL2622_3,2,(digout & BIT (5))); /* LED6 */
+ set_output_bit(EL2622_1, 1, (digout & BIT(0))); /* LED1 */
+ set_output_bit(EL2622_1, 2, (digout & BIT(1))); /* LED2 */
+ set_output_bit(EL2622_2, 1, (digout & BIT(2))); /* LED3 */
+ set_output_bit(EL2622_2, 2, (digout & BIT(3))); /* LED4 */
+ set_output_bit(EL2622_3, 1, (digout & BIT(4))); /* LED5 */
+ set_output_bit(EL2622_3, 2, (digout & BIT(5))); /* LED6 */
- slave_EL1008_1.in1 = get_input_bit(EL1008_1,2); /* Turnkey RIGHT */
- slave_EL1008_1.in2 = get_input_bit(EL1008_1,3); /* Turnkey LEFT */
- slave_EL3061_1.in1 = get_input_int32(EL3061_1,0); /* Read AI */
+ slave_EL1008_1.in1 = get_input_bit(EL1008_1, 2); /* Turnkey RIGHT */
+ slave_EL1008_1.in2 = get_input_bit(EL1008_1, 3); /* Turnkey LEFT */
+ slave_EL3061_1.in1 = get_input_int32(EL3061_1, 0); /* Read AI */
}
}
task_delay(tick_from_ms(2));
-
}
}
else
rprintp("End program\n");
}
-static void test_osal_timer_timeout_us (const uint32 timeout_us)
+static void test_osal_timer_timeout_us(const uint32 timeout_us)
{
osal_timert timer;
- ASSERT (timeout_us > 4000);
+ ASSERT(timeout_us > 4000);
- osal_timer_start (&timer, timeout_us);
- ASSERT (osal_timer_is_expired (&timer) == false);
- osal_usleep (timeout_us - 2000);
- ASSERT (osal_timer_is_expired (&timer) == false);
- osal_usleep (4000);
- ASSERT (osal_timer_is_expired (&timer));
+ osal_timer_start(&timer, timeout_us);
+ ASSERT(osal_timer_is_expired(&timer) == false);
+ osal_usleep(timeout_us - 2000);
+ ASSERT(osal_timer_is_expired(&timer) == false);
+ osal_usleep(4000);
+ ASSERT(osal_timer_is_expired(&timer));
}
-static void test_osal_timer (void)
+static void test_osal_timer(void)
{
- test_osal_timer_timeout_us (10*1000); /* 10ms */
- test_osal_timer_timeout_us (100*1000); /* 100ms */
- test_osal_timer_timeout_us (1000*1000); /* 1s */
- test_osal_timer_timeout_us (2000*1000); /* 2s */
+ test_osal_timer_timeout_us(10 * 1000); /* 10ms */
+ test_osal_timer_timeout_us(100 * 1000); /* 100ms */
+ test_osal_timer_timeout_us(1000 * 1000); /* 1s */
+ test_osal_timer_timeout_us(2000 * 1000); /* 2s */
}
-#define USECS_PER_SEC 1000000
-#define USECS_PER_TICK (USECS_PER_SEC / CFG_TICKS_PER_SECOND)
+#define USECS_PER_SEC 1000000
+#define USECS_PER_TICK (USECS_PER_SEC / CFG_TICKS_PER_SECOND)
#ifndef ABS
#define ABS(x) ((x) < 0 ? -(x) : (x))
#endif
-static int32 time_difference_us (const ec_timet stop, const ec_timet start)
+static int32 time_difference_us(const ec_timet stop, const ec_timet start)
{
int32 difference_us;
- ASSERT (stop.sec >= start.sec);
+ ASSERT(stop.sec >= start.sec);
if (stop.sec == start.sec)
{
- ASSERT (stop.usec >= start.usec);
+ ASSERT(stop.usec >= start.usec);
}
difference_us = (stop.sec - start.sec) * USECS_PER_SEC;
difference_us += ((int32)stop.usec - (int32)start.usec);
- ASSERT (difference_us >= 0);
+ ASSERT(difference_us >= 0);
return difference_us;
}
* Test osal_current_time() by using it for measuring how long an osal_usleep()
* takes, in specified number of microseconds.
*/
-static void test_osal_current_time_for_delay_us (const int32 sleep_time_us)
+static void test_osal_current_time_for_delay_us(const int32 sleep_time_us)
{
ec_timet start;
ec_timet stop;
const int32 usleep_accuracy_us = USECS_PER_TICK;
boolean is_deviation_within_tolerance;
- start = osal_current_time ();
- osal_usleep (sleep_time_us);
- stop = osal_current_time ();
+ start = osal_current_time();
+ osal_usleep(sleep_time_us);
+ stop = osal_current_time();
- measurement_us = time_difference_us (stop, start);
- deviation_us = ABS (measurement_us - sleep_time_us);
+ measurement_us = time_difference_us(stop, start);
+ deviation_us = ABS(measurement_us - sleep_time_us);
is_deviation_within_tolerance = deviation_us <= usleep_accuracy_us;
- ASSERT (is_deviation_within_tolerance);
+ ASSERT(is_deviation_within_tolerance);
}
-static void test_osal_current_time (void)
+static void test_osal_current_time(void)
{
- test_osal_current_time_for_delay_us (0);
- test_osal_current_time_for_delay_us (1);
- test_osal_current_time_for_delay_us (500);
- test_osal_current_time_for_delay_us (999);
- test_osal_current_time_for_delay_us (USECS_PER_TICK);
- test_osal_current_time_for_delay_us (USECS_PER_TICK-1);
- test_osal_current_time_for_delay_us (USECS_PER_TICK+1);
- test_osal_current_time_for_delay_us (2 * 1000 * 1000); /* 2s */
+ test_osal_current_time_for_delay_us(0);
+ test_osal_current_time_for_delay_us(1);
+ test_osal_current_time_for_delay_us(500);
+ test_osal_current_time_for_delay_us(999);
+ test_osal_current_time_for_delay_us(USECS_PER_TICK);
+ test_osal_current_time_for_delay_us(USECS_PER_TICK - 1);
+ test_osal_current_time_for_delay_us(USECS_PER_TICK + 1);
+ test_osal_current_time_for_delay_us(2 * 1000 * 1000); /* 2s */
}
#include <lwip/inet.h>
-static void test_oshw_htons (void)
+static void test_oshw_htons(void)
{
- uint16 network;
- uint16 host;
+ uint16 network;
+ uint16 host;
- host = 0x1234;
- network = oshw_htons (host);
- ASSERT (network == htons (host));
+ host = 0x1234;
+ network = oshw_htons(host);
+ ASSERT(network == htons(host));
}
-static void test_oshw_ntohs (void)
+static void test_oshw_ntohs(void)
{
- uint16 host;
- uint16 network;
+ uint16 host;
+ uint16 network;
- network = 0x1234;
- host = oshw_ntohs (network);
- ASSERT (host == ntohs (network));
+ network = 0x1234;
+ host = oshw_ntohs(network);
+ ASSERT(host == ntohs(network));
}
-int main (void)
+int main(void)
{
- test_oshw_htons ();
- test_oshw_ntohs ();
- test_osal_timer ();
- test_osal_current_time ();
+ test_oshw_htons();
+ test_oshw_ntohs();
+ test_osal_timer();
+ test_osal_current_time();
rprintp("SOEM (Simple Open EtherCAT Master)\nSimple test\n");
- task_spawn ("simpletest", simpletest, 9, 8192, NULL);
+ task_spawn("simpletest", simpletest, 9, 8192, NULL);
return (0);
}
-
typedef struct PACKED
{
- uint8 status;
- uint8 counter;
- uint8 din;
- int32 ain[2];
- uint32 tsain;
- int32 enc[2];
+ uint8 status;
+ uint8 counter;
+ uint8 din;
+ int32 ain[2];
+ uint32 tsain;
+ int32 enc[2];
} in_EBOXt;
typedef struct PACKED
{
- uint8 counter;
- int16 stream[100];
+ uint8 counter;
+ int16 stream[100];
} in_EBOX_streamt;
typedef struct PACKED
{
- uint8 control;
- uint8 dout;
- int16 aout[2];
- uint16 pwmout[2];
+ uint8 control;
+ uint8 dout;
+ int16 aout[2];
+ uint16 pwmout[2];
} out_EBOXt;
typedef struct PACKED
{
- uint8 control;
+ uint8 control;
} out_EBOX_streamt;
// total samples to capture
struct sched_param schedp;
char IOmap[4096];
pthread_t thread1;
-struct timeval tv,t1,t2;
+struct timeval tv, t1, t2;
int dorun = 0;
-int deltat, tmax=0;
+int deltat, tmax = 0;
int64 toff;
int DCdiff;
int os;
uint32 ob;
int16 ob2;
uint8 ob3;
-pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-int64 integral=0;
+int64 integral = 0;
uint32 cyclecount;
-in_EBOX_streamt *in_EBOX;
+in_EBOX_streamt *in_EBOX;
out_EBOX_streamt *out_EBOX;
-double ain[2];
-int ainc;
-int streampos;
-int16 stream1[MAXSTREAM];
-int16 stream2[MAXSTREAM];
+double ain[2];
+int ainc;
+int streampos;
+int16 stream1[MAXSTREAM];
+int16 stream2[MAXSTREAM];
int output_cvs(char *fname, int length)
{
FILE *fp;
- int i;
+ int i;
fp = fopen(fname, "w");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
for (i = 0; i < length; i++)
{
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ec_config_init(FALSE) > 0 )
+ if (ec_config_init(FALSE) > 0)
{
- printf("%d slaves found and configured.\n",ec_slavecount);
+ printf("%d slaves found and configured.\n", ec_slavecount);
// check if first slave is an E/BOX
- if (( ec_slavecount >= 1 ) &&
- (strcmp(ec_slave[1].name,"E/BOX") == 0))
+ if ((ec_slavecount >= 1) &&
+ (strcmp(ec_slave[1].name, "E/BOX") == 0))
{
// reprogram PDO mapping to set slave in stream mode
// this can only be done in pre-OP state
- os=sizeof(ob2); ob2 = 0x1601;
- ec_SDOwrite(1,0x1c12,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
- os=sizeof(ob2); ob2 = 0x1a01;
- ec_SDOwrite(1,0x1c13,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1601;
+ ec_SDOwrite(1, 0x1c12, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1a01;
+ ec_SDOwrite(1, 0x1c13, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
}
ec_config_map(&IOmap);
ec_configdc();
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
/* configure DC options for every DC capable slave found in the list */
- printf("DC capable : %d\n",ec_configdc());
+ printf("DC capable : %d\n", ec_configdc());
/* check configuration */
- if (( ec_slavecount >= 1 ) &&
- (strcmp(ec_slave[1].name,"E/BOX") == 0)
- )
+ if ((ec_slavecount >= 1) &&
+ (strcmp(ec_slave[1].name, "E/BOX") == 0))
{
printf("E/BOX found.\n");
/* connect struct pointers to slave I/O pointers */
- in_EBOX = (in_EBOX_streamt*) ec_slave[1].inputs;
- out_EBOX = (out_EBOX_streamt*) ec_slave[1].outputs;
+ in_EBOX = (in_EBOX_streamt *)ec_slave[1].inputs;
+ out_EBOX = (out_EBOX_streamt *)ec_slave[1].outputs;
/* read indevidual slave state and store in ec_slave[] */
ec_readstate();
- for(cnt = 1; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
printf("Slave:%d Name:%s Output size:%3dbits Input size:%3dbits State:%2d delay:%d.%d\n",
- cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
- ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
+ cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
+ ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
}
printf("Request operational state for all slaves\n");
/* request OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach OP state */
- ec_statecheck(0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ ec_statecheck(0, EC_STATE_OPERATIONAL, EC_TIMEOUTSTATE);
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
ain[0] = 0;
ain[1] = 0;
ainc = 0;
dorun = 1;
- usleep(100000); // wait for linux to sync on DC
+ usleep(100000); // wait for linux to sync on DC
ec_dcsync0(1, TRUE, SYNC0TIME, 0); // SYNC0 on slave 1
/* acyclic loop 20ms */
- for(i = 1; i <= 200; i++)
+ for (i = 1; i <= 200; i++)
{
/* read DC difference register for slave 2 */
- // ec_FPRD(ec_slave[1].configadr, ECT_REG_DCSYSDIFF, sizeof(DCdiff), &DCdiff, EC_TIMEOUTRET);
- // if(DCdiff<0) { DCdiff = - (int32)((uint32)DCdiff & 0x7ffffff); }
+ // ec_FPRD(ec_slave[1].configadr, ECT_REG_DCSYSDIFF, sizeof(DCdiff), &DCdiff, EC_TIMEOUTRET);
+ // if(DCdiff<0) { DCdiff = - (int32)((uint32)DCdiff & 0x7ffffff); }
printf("PD cycle %5d DCtime %12lld Cnt:%3d Data: %6d %6d %6d %6d %6d %6d %6d %6d \n",
- cyclecount, ec_DCtime, in_EBOX->counter, in_EBOX->stream[0], in_EBOX->stream[1],
+ cyclecount, ec_DCtime, in_EBOX->counter, in_EBOX->stream[0], in_EBOX->stream[1],
in_EBOX->stream[2], in_EBOX->stream[3], in_EBOX->stream[4], in_EBOX->stream[5],
in_EBOX->stream[98], in_EBOX->stream[99]);
usleep(20000);
}
dorun = 0;
- // printf("\nCnt %d : Ain0 = %f Ain2 = %f\n", ainc, ain[0] / ainc, ain[1] / ainc);
+ // printf("\nCnt %d : Ain0 = %f Ain2 = %f\n", ainc, ain[0] / ainc, ain[1] / ainc);
}
else
{
/* request SAFE_OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
ec_slave[0].state = EC_STATE_PRE_OP;
/* request SAFE_OP state for all slaves */
ec_writestate(0);
/* wait for all slaves to reach state */
- ec_statecheck(0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE);
- if (( ec_slavecount >= 1 ) &&
- (strcmp(ec_slave[1].name,"E/BOX") == 0))
+ ec_statecheck(0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE);
+ if ((ec_slavecount >= 1) &&
+ (strcmp(ec_slave[1].name, "E/BOX") == 0))
{
// restore PDO to standard mode
// this can only be done is pre-op state
- os=sizeof(ob2); ob2 = 0x1600;
- ec_SDOwrite(1,0x1c12,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
- os=sizeof(ob2); ob2 = 0x1a00;
- ec_SDOwrite(1,0x1c13,01,FALSE,os,&ob2,EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1600;
+ ec_SDOwrite(1, 0x1c12, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
+ os = sizeof(ob2);
+ ob2 = 0x1a00;
+ ec_SDOwrite(1, 0x1c13, 01, FALSE, os, &ob2, EC_TIMEOUTRXM);
}
printf("Streampos %d\n", streampos);
output_cvs("stream.txt", streampos);
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
sec = (addtime - nsec) / NSEC_PER_SEC;
ts->tv_sec += sec;
ts->tv_nsec += nsec;
- if ( ts->tv_nsec >= NSEC_PER_SEC )
+ if (ts->tv_nsec >= NSEC_PER_SEC)
{
nsec = ts->tv_nsec % NSEC_PER_SEC;
ts->tv_sec += (ts->tv_nsec - nsec) / NSEC_PER_SEC;
}
/* PI calculation to get linux time synced to DC time */
-void ec_sync(int64 reftime, int64 cycletime , int64 *offsettime)
+void ec_sync(int64 reftime, int64 cycletime, int64 *offsettime)
{
int64 delta;
/* set linux sync point 50us later than DC sync, just as example */
delta = (reftime - 50000) % cycletime;
- if(delta> (cycletime /2)) { delta= delta - cycletime; }
- if(delta>0){ integral++; }
- if(delta<0){ integral--; }
- *offsettime = -(delta / 100) - (integral /20);
+ if (delta > (cycletime / 2))
+ {
+ delta = delta - cycletime;
+ }
+ if (delta > 0)
+ {
+ integral++;
+ }
+ if (delta < 0)
+ {
+ integral--;
+ }
+ *offsettime = -(delta / 100) - (integral / 20);
}
/* RT EtherCAT thread */
-void ecatthread( void *ptr )
+void ecatthread(void *ptr)
{
- struct timespec ts;
- struct timeval tp;
+ struct timespec ts;
+ struct timeval tp;
int rc;
int ht;
int i;
int64 cycletime;
rc = pthread_mutex_lock(&mutex);
- rc = gettimeofday(&tp, NULL);
+ rc = gettimeofday(&tp, NULL);
- /* Convert from timeval to timespec */
- ts.tv_sec = tp.tv_sec;
+ /* Convert from timeval to timespec */
+ ts.tv_sec = tp.tv_sec;
ht = (tp.tv_usec / 1000) + 1; /* round to nearest ms */
ts.tv_nsec = ht * 1000000;
- cycletime = *(int*)ptr * 1000; /* cycletime in ns */
+ cycletime = *(int *)ptr * 1000; /* cycletime in ns */
toff = 0;
dorun = 0;
- while(1)
+ while (1)
{
/* calculate next cycle start */
add_timespec(&ts, cycletime + toff);
/* wait to cycle start */
rc = pthread_cond_timedwait(&cond, &mutex, &ts);
- if (dorun>0)
+ if (dorun > 0)
{
- rc = gettimeofday(&tp, NULL);
+ rc = gettimeofday(&tp, NULL);
ec_send_processdata();
cyclecount++;
-
- if((in_EBOX->counter != pcounter) && (streampos < (MAXSTREAM - 1)))
+ if ((in_EBOX->counter != pcounter) && (streampos < (MAXSTREAM - 1)))
{
// check if we have timing problems in master
// if so, overwrite stream data so it shows up clearly in plots.
- if(in_EBOX->counter > (pcounter + 1))
+ if (in_EBOX->counter > (pcounter + 1))
{
- for(i = 0 ; i < 50 ; i++)
+ for (i = 0; i < 50; i++)
{
- stream1[streampos] = 20000;
+ stream1[streampos] = 20000;
stream2[streampos++] = -20000;
}
}
else
{
- for(i = 0 ; i < 50 ; i++)
+ for (i = 0; i < 50; i++)
{
- stream1[streampos] = in_EBOX->stream[i * 2];
+ stream1[streampos] = in_EBOX->stream[i * 2];
stream2[streampos++] = in_EBOX->stream[(i * 2) + 1];
}
}
{
int iret1;
int ctime;
- struct sched_param param;
- int policy = SCHED_OTHER;
+ struct sched_param param;
+ int policy = SCHED_OTHER;
printf("SOEM (Simple Open EtherCAT Master)\nE/BOX test\n");
do
{
usleep(1000);
- }
- while (dorun);
+ } while (dorun);
if (argc > 1)
{
dorun = 1;
- if( argc > 2)
+ if (argc > 2)
ctime = atoi(argv[2]);
else
ctime = 1000; // 1ms cycle time
/* create RT thread */
- iret1 = pthread_create( &thread1, NULL, (void *) &ecatthread, (void*) &ctime);
+ iret1 = pthread_create(&thread1, NULL, (void *)&ecatthread, (void *)&ctime);
memset(¶m, 0, sizeof(param));
/* give it higher priority */
param.sched_priority = 40;
#include "ethercat.h"
-#define MAXBUF 32768
-#define STDBUF 2048
-#define MINBUF 128
+#define MAXBUF 32768
+#define STDBUF 2048
+#define MINBUF 128
-#define MODE_NONE 0
-#define MODE_READBIN 1
-#define MODE_READINTEL 2
-#define MODE_WRITEBIN 3
-#define MODE_WRITEINTEL 4
+#define MODE_NONE 0
+#define MODE_READBIN 1
+#define MODE_READINTEL 2
+#define MODE_WRITEBIN 3
+#define MODE_WRITEINTEL 4
-#define MAXSLENGTH 256
+#define MAXSLENGTH 256
uint8 ebuf[MAXBUF];
uint8 ob;
uint16 ow;
int os;
int slave;
-ec_timet tstart,tend, tdif;
+ec_timet tstart, tend, tdif;
int wkc;
int mode;
char sline[MAXSLENGTH];
int cc = 0, c;
fp = fopen(fname, "rb");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
while (((c = fgetc(fp)) != EOF) && (cc < MAXBUF))
ebuf[cc++] = (uint8)c;
int hstart, hlength, sum;
fp = fopen(fname, "r");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
hstart = MAXBUF;
hlength = 0;
{
memset(sline, 0x00, MAXSLENGTH);
sc = 0;
- while (((c = fgetc(fp)) != EOF) && (c != 0x0A) && (sc < (MAXSLENGTH -1)))
+ while (((c = fgetc(fp)) != EOF) && (c != 0x0A) && (sc < (MAXSLENGTH - 1)))
sline[sc++] = (uint8)c;
if ((c != EOF) && ((sc < 11) || (sline[0] != ':')))
{
}
if (c != EOF)
{
- sn = sscanf(sline , ":%2x%4x%2x", &ll, &ladr, <);
+ sn = sscanf(sline, ":%2x%4x%2x", &ll, &ladr, <);
if ((sn == 3) && ((ladr + ll) <= MAXBUF) && (lt == 0))
{
sum = ll + (ladr >> 8) + (ladr & 0xff) + lt;
- if(ladr < hstart) hstart = ladr;
- for(i = 0; i < ll ; i++)
+ if (ladr < hstart) hstart = ladr;
+ for (i = 0; i < ll; i++)
{
sn = sscanf(&sline[9 + (i << 1)], "%2x", &lval);
ebuf[ladr + i] = (uint8)lval;
sum += (uint8)lval;
}
- if(((ladr + ll) - hstart) > hlength)
+ if (((ladr + ll) - hstart) > hlength)
hlength = (ladr + ll) - hstart;
sum = (0x100 - sum) & 0xff;
sn = sscanf(&sline[9 + (i << 1)], "%2x", &lval);
}
}
}
- }
- while (c != EOF);
+ } while (c != EOF);
if (retval)
{
*length = hlength;
int cc;
fp = fopen(fname, "wb");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
- for (cc = 0 ; cc < length ; cc++)
- fputc( ebuf[cc], fp);
+ for (cc = 0; cc < length; cc++)
+ fputc(ebuf[cc], fp);
fclose(fp);
return 1;
int cc = 0, ll, sum, i;
fp = fopen(fname, "w");
- if(fp == NULL)
+ if (fp == NULL)
return 0;
while (cc < length)
{
uint64 b8;
uint8 eepctl;
- if((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
{
aiadr = 1 - slave;
eepctl = 2;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET3); /* force Eeprom from PDI */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET3); /* force Eeprom from PDI */
eepctl = 0;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET3); /* set Eeprom to master */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET3); /* set Eeprom to master */
estat = 0x0000;
aiadr = 1 - slave;
- wkc=ec_APRD(aiadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET3); /* read eeprom status */
+ wkc = ec_APRD(aiadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET3); /* read eeprom status */
estat = etohs(estat);
if (estat & EC_ESTAT_R64)
{
ainc = 8;
- for (i = start ; i < (start + length) ; i+=ainc)
+ for (i = start; i < (start + length); i += ainc)
{
- b8 = ec_readeepromAP(aiadr, i >> 1 , EC_TIMEOUTEEP);
- ebuf[i] = (uint8) b8;
- ebuf[i+1] = (uint8) (b8 >> 8);
- ebuf[i+2] = (uint8) (b8 >> 16);
- ebuf[i+3] = (uint8) (b8 >> 24);
- ebuf[i+4] = (uint8) (b8 >> 32);
- ebuf[i+5] = (uint8) (b8 >> 40);
- ebuf[i+6] = (uint8) (b8 >> 48);
- ebuf[i+7] = (uint8) (b8 >> 56);
+ b8 = ec_readeepromAP(aiadr, i >> 1, EC_TIMEOUTEEP);
+ ebuf[i] = (uint8)b8;
+ ebuf[i + 1] = (uint8)(b8 >> 8);
+ ebuf[i + 2] = (uint8)(b8 >> 16);
+ ebuf[i + 3] = (uint8)(b8 >> 24);
+ ebuf[i + 4] = (uint8)(b8 >> 32);
+ ebuf[i + 5] = (uint8)(b8 >> 40);
+ ebuf[i + 6] = (uint8)(b8 >> 48);
+ ebuf[i + 7] = (uint8)(b8 >> 56);
}
}
else
{
- for (i = start ; i < (start + length) ; i+=ainc)
+ for (i = start; i < (start + length); i += ainc)
{
- b4 = (uint32)ec_readeepromAP(aiadr, i >> 1 , EC_TIMEOUTEEP);
- ebuf[i] = (uint8) b4;
- ebuf[i+1] = (uint8) (b4 >> 8);
- ebuf[i+2] = (uint8) (b4 >> 16);
- ebuf[i+3] = (uint8) (b4 >> 24);
+ b4 = (uint32)ec_readeepromAP(aiadr, i >> 1, EC_TIMEOUTEEP);
+ ebuf[i] = (uint8)b4;
+ ebuf[i + 1] = (uint8)(b4 >> 8);
+ ebuf[i + 2] = (uint8)(b4 >> 16);
+ ebuf[i + 3] = (uint8)(b4 >> 24);
}
}
uint8 eepctl;
int ret;
- if((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
{
aiadr = 1 - slave;
eepctl = 2;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET3); /* force Eeprom from PDI */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET3); /* force Eeprom from PDI */
eepctl = 0;
- wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl , EC_TIMEOUTRET3); /* set Eeprom to master */
+ wkc = ec_APWR(aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET3); /* set Eeprom to master */
aiadr = 1 - slave;
wbuf = (uint16 *)&ebuf[0];
- for (i = start ; i < (start + length) ; i+=2)
+ for (i = start; i < (start + length); i += 2)
{
- ret = ec_writeeepromAP(aiadr, i >> 1 , *(wbuf + (i >> 1)), EC_TIMEOUTEEP);
+ ret = ec_writeeepromAP(aiadr, i >> 1, *(wbuf + (i >> 1)), EC_TIMEOUTEEP);
if (++dc >= 100)
{
dc = 0;
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
w = 0x0000;
- wkc = ec_BRD(0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
- if (wkc > 0)
- {
+ wkc = ec_BRD(0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
+ if (wkc > 0)
+ {
ec_slavecount = wkc;
- printf("%d slaves found.\n",ec_slavecount);
- if((ec_slavecount >= slave) && (slave > 0))
+ printf("%d slaves found.\n", ec_slavecount);
+ if ((ec_slavecount >= slave) && (slave > 0))
{
if ((mode == MODE_READBIN) || (mode == MODE_READINTEL))
{
wbuf = (uint16 *)&ebuf[0];
printf("Slave %d data\n", slave);
- printf(" PDI Control : %4.4X\n",*(wbuf + 0x00));
- printf(" PDI Config : %4.4X\n",*(wbuf + 0x01));
- printf(" Config Alias : %4.4X\n",*(wbuf + 0x04));
- printf(" Checksum : %4.4X\n",*(wbuf + 0x07));
- printf(" Vendor ID : %8.8X\n",*(uint32 *)(wbuf + 0x08));
- printf(" Product Code : %8.8X\n",*(uint32 *)(wbuf + 0x0A));
- printf(" Revision Number : %8.8X\n",*(uint32 *)(wbuf + 0x0C));
- printf(" Serial Number : %8.8X\n",*(uint32 *)(wbuf + 0x0E));
- printf(" Mailbox Protocol : %4.4X\n",*(wbuf + 0x1C));
+ printf(" PDI Control : %4.4X\n", *(wbuf + 0x00));
+ printf(" PDI Config : %4.4X\n", *(wbuf + 0x01));
+ printf(" Config Alias : %4.4X\n", *(wbuf + 0x04));
+ printf(" Checksum : %4.4X\n", *(wbuf + 0x07));
+ printf(" Vendor ID : %8.8X\n", *(uint32 *)(wbuf + 0x08));
+ printf(" Product Code : %8.8X\n", *(uint32 *)(wbuf + 0x0A));
+ printf(" Revision Number : %8.8X\n", *(uint32 *)(wbuf + 0x0C));
+ printf(" Serial Number : %8.8X\n", *(uint32 *)(wbuf + 0x0E));
+ printf(" Mailbox Protocol : %4.4X\n", *(wbuf + 0x1C));
esize = (*(wbuf + 0x3E) + 1) * 128;
if (esize > MAXBUF) esize = MAXBUF;
- printf(" Size : %4.4X = %d bytes\n",*(wbuf + 0x3E), esize);
- printf(" Version : %4.4X\n",*(wbuf + 0x3F));
+ printf(" Size : %4.4X = %d bytes\n", *(wbuf + 0x3E), esize);
+ printf(" Version : %4.4X\n", *(wbuf + 0x3F));
if (esize > MINBUF)
eeprom_read(slave, MINBUF, esize - MINBUF); // read reminder
tend = osal_current_time();
osal_time_diff(&tstart, &tend, &tdif);
if (mode == MODE_READINTEL) output_intelhex(fname, esize);
- if (mode == MODE_READBIN) output_bin(fname, esize);
+ if (mode == MODE_READBIN) output_bin(fname, esize);
- printf("\nTotal EEPROM read time :%ldms\n", (tdif.usec+(tdif.sec*1000000L)) / 1000);
+ printf("\nTotal EEPROM read time :%ldms\n", (tdif.usec + (tdif.sec * 1000000L)) / 1000);
}
if ((mode == MODE_WRITEBIN) || (mode == MODE_WRITEINTEL))
{
estart = 0;
if (mode == MODE_WRITEINTEL) rc = input_intelhex(fname, &estart, &esize);
- if (mode == MODE_WRITEBIN) rc = input_bin(fname, &esize);
+ if (mode == MODE_WRITEBIN) rc = input_bin(fname, &esize);
if (rc > 0)
{
wbuf = (uint16 *)&ebuf[0];
printf("Slave %d\n", slave);
- printf(" Vendor ID : %8.8X\n",*(uint32 *)(wbuf + 0x08));
- printf(" Product Code : %8.8X\n",*(uint32 *)(wbuf + 0x0A));
- printf(" Revision Number : %8.8X\n",*(uint32 *)(wbuf + 0x0C));
- printf(" Serial Number : %8.8X\n",*(uint32 *)(wbuf + 0x0E));
+ printf(" Vendor ID : %8.8X\n", *(uint32 *)(wbuf + 0x08));
+ printf(" Product Code : %8.8X\n", *(uint32 *)(wbuf + 0x0A));
+ printf(" Revision Number : %8.8X\n", *(uint32 *)(wbuf + 0x0C));
+ printf(" Serial Number : %8.8X\n", *(uint32 *)(wbuf + 0x0E));
printf("Busy");
fflush(stdout);
tend = osal_current_time();
osal_time_diff(&tstart, &tend, &tdif);
- printf("\nTotal EEPROM write time :%ldms\n", (tdif.usec+(tdif.sec*1000000L)) / 1000);
+ printf("\nTotal EEPROM write time :%ldms\n", (tdif.usec + (tdif.sec * 1000000L)) / 1000);
}
else
printf("Error reading file, abort.\n");
ec_close();
}
else
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
int main(int argc, char *argv[])
{
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
printf("SOEM (Simple Open EtherCAT Master)\nEEPROM tool\n");
if (argc > 4)
{
slave = atoi(argv[2]);
mode = MODE_NONE;
- if ((strncmp(argv[3], "-r", sizeof("-r")) == 0)) mode = MODE_READBIN;
+ if ((strncmp(argv[3], "-r", sizeof("-r")) == 0)) mode = MODE_READBIN;
if ((strncmp(argv[3], "-ri", sizeof("-ri")) == 0)) mode = MODE_READINTEL;
- if ((strncmp(argv[3], "-w", sizeof("-w")) == 0)) mode = MODE_WRITEBIN;
+ if ((strncmp(argv[3], "-w", sizeof("-w")) == 0)) mode = MODE_WRITEBIN;
if ((strncmp(argv[3], "-wi", sizeof("-wi")) == 0)) mode = MODE_WRITEINTEL;
/* start tool */
- eepromtool(argv[1],slave,mode,argv[4]);
+ eepromtool(argv[1], slave, mode, argv[4]);
}
else
{
printf(" -ri read EEPROM, output Intel Hex format\n");
printf(" -w write EEPROM, input binary format\n");
printf(" -wi write EEPROM, input Intel Hex format\n");
- /* Print the list */
- printf ("Available adapters\n");
- head = adapter = ec_find_adapters ();
+ /* Print the list */
+ printf("Available adapters\n");
+ head = adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf ("Description : %s, Device to use for wpcap: %s\n", adapter->desc,adapter->name);
+ printf("Description : %s, Device to use for wpcap: %s\n", adapter->desc, adapter->name);
adapter = adapter->next;
}
ec_free_adapters(adapter);
int input_bin(char *fname, int *length)
{
- FILE *fp;
-
- int cc = 0, c;
-
- fp = fopen(fname, "rb");
- if(fp == NULL)
- return 0;
- while (((c = fgetc(fp)) != EOF) && (cc < FWBUFSIZE))
- filebuffer[cc++] = (uint8)c;
- *length = cc;
- fclose(fp);
- return 1;
+ FILE *fp;
+
+ int cc = 0, c;
+
+ fp = fopen(fname, "rb");
+ if (fp == NULL)
+ return 0;
+ while (((c = fgetc(fp)) != EOF) && (cc < FWBUFSIZE))
+ filebuffer[cc++] = (uint8)c;
+ *length = cc;
+ fclose(fp);
+ return 1;
}
-
void boottest(char *ifname, uint16 slave, char *filename)
{
- printf("Starting firmware update example\n");
-
- /* initialise SOEM, bind socket to ifname */
- if (ec_init(ifname))
- {
- printf("ec_init on %s succeeded.\n",ifname);
- /* find and auto-config slaves */
-
-
- if ( ec_config_init(FALSE) > 0 )
- {
- printf("%d slaves found and configured.\n",ec_slavecount);
-
- printf("Request init state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_INIT;
- ec_writestate(slave);
-
- /* wait for slave to reach INIT state */
- ec_statecheck(slave, EC_STATE_INIT, EC_TIMEOUTSTATE * 4);
- printf("Slave %d state to INIT.\n", slave);
-
- /* read BOOT mailbox data, master -> slave */
- data = ec_readeeprom(slave, ECT_SII_BOOTRXMBX, EC_TIMEOUTEEP);
- ec_slave[slave].SM[0].StartAddr = (uint16)LO_WORD(data);
- ec_slave[slave].SM[0].SMlength = (uint16)HI_WORD(data);
- /* store boot write mailbox address */
- ec_slave[slave].mbx_wo = (uint16)LO_WORD(data);
- /* store boot write mailbox size */
- ec_slave[slave].mbx_l = (uint16)HI_WORD(data);
-
- /* read BOOT mailbox data, slave -> master */
- data = ec_readeeprom(slave, ECT_SII_BOOTTXMBX, EC_TIMEOUTEEP);
- ec_slave[slave].SM[1].StartAddr = (uint16)LO_WORD(data);
- ec_slave[slave].SM[1].SMlength = (uint16)HI_WORD(data);
- /* store boot read mailbox address */
- ec_slave[slave].mbx_ro = (uint16)LO_WORD(data);
- /* store boot read mailbox size */
- ec_slave[slave].mbx_rl = (uint16)HI_WORD(data);
-
- printf(" SM0 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[0].StartAddr, ec_slave[slave].SM[0].SMlength,
- (int)ec_slave[slave].SM[0].SMflags);
- printf(" SM1 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[1].StartAddr, ec_slave[slave].SM[1].SMlength,
- (int)ec_slave[slave].SM[1].SMflags);
- /* program SM0 mailbox in for slave */
- ec_FPWR (ec_slave[slave].configadr, ECT_REG_SM0, sizeof(ec_smt), &ec_slave[slave].SM[0], EC_TIMEOUTRET);
- /* program SM1 mailbox out for slave */
- ec_FPWR (ec_slave[slave].configadr, ECT_REG_SM1, sizeof(ec_smt), &ec_slave[slave].SM[1], EC_TIMEOUTRET);
-
- printf("Request BOOT state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_BOOT;
- ec_writestate(slave);
-
- /* wait for slave to reach BOOT state */
- if (ec_statecheck(slave, EC_STATE_BOOT, EC_TIMEOUTSTATE * 10) == EC_STATE_BOOT)
- {
- printf("Slave %d state to BOOT.\n", slave);
-
- if (input_bin(filename, &filesize))
- {
- printf("File read OK, %d bytes.\n",filesize);
- printf("FoE write....");
- j = ec_FOEwrite(slave, filename, 0, filesize , &filebuffer, EC_TIMEOUTSTATE);
- printf("result %d.\n",j);
- printf("Request init state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_INIT;
- ec_writestate(slave);
- }
- else
- printf("File not read OK.\n");
- }
-
- }
- else
- {
- printf("No slaves found!\n");
- }
- printf("End firmware update example, close socket\n");
- /* stop SOEM, close socket */
- ec_close();
- }
- else
- {
- printf("No socket connection on %s\nExcecute as root\n",ifname);
- }
+ printf("Starting firmware update example\n");
+
+ /* initialise SOEM, bind socket to ifname */
+ if (ec_init(ifname))
+ {
+ printf("ec_init on %s succeeded.\n", ifname);
+ /* find and auto-config slaves */
+
+ if (ec_config_init(FALSE) > 0)
+ {
+ printf("%d slaves found and configured.\n", ec_slavecount);
+
+ printf("Request init state for slave %d\n", slave);
+ ec_slave[slave].state = EC_STATE_INIT;
+ ec_writestate(slave);
+
+ /* wait for slave to reach INIT state */
+ ec_statecheck(slave, EC_STATE_INIT, EC_TIMEOUTSTATE * 4);
+ printf("Slave %d state to INIT.\n", slave);
+
+ /* read BOOT mailbox data, master -> slave */
+ data = ec_readeeprom(slave, ECT_SII_BOOTRXMBX, EC_TIMEOUTEEP);
+ ec_slave[slave].SM[0].StartAddr = (uint16)LO_WORD(data);
+ ec_slave[slave].SM[0].SMlength = (uint16)HI_WORD(data);
+ /* store boot write mailbox address */
+ ec_slave[slave].mbx_wo = (uint16)LO_WORD(data);
+ /* store boot write mailbox size */
+ ec_slave[slave].mbx_l = (uint16)HI_WORD(data);
+
+ /* read BOOT mailbox data, slave -> master */
+ data = ec_readeeprom(slave, ECT_SII_BOOTTXMBX, EC_TIMEOUTEEP);
+ ec_slave[slave].SM[1].StartAddr = (uint16)LO_WORD(data);
+ ec_slave[slave].SM[1].SMlength = (uint16)HI_WORD(data);
+ /* store boot read mailbox address */
+ ec_slave[slave].mbx_ro = (uint16)LO_WORD(data);
+ /* store boot read mailbox size */
+ ec_slave[slave].mbx_rl = (uint16)HI_WORD(data);
+
+ printf(" SM0 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[0].StartAddr, ec_slave[slave].SM[0].SMlength,
+ (int)ec_slave[slave].SM[0].SMflags);
+ printf(" SM1 A:%4.4x L:%4d F:%8.8x\n", ec_slave[slave].SM[1].StartAddr, ec_slave[slave].SM[1].SMlength,
+ (int)ec_slave[slave].SM[1].SMflags);
+ /* program SM0 mailbox in for slave */
+ ec_FPWR(ec_slave[slave].configadr, ECT_REG_SM0, sizeof(ec_smt), &ec_slave[slave].SM[0], EC_TIMEOUTRET);
+ /* program SM1 mailbox out for slave */
+ ec_FPWR(ec_slave[slave].configadr, ECT_REG_SM1, sizeof(ec_smt), &ec_slave[slave].SM[1], EC_TIMEOUTRET);
+
+ printf("Request BOOT state for slave %d\n", slave);
+ ec_slave[slave].state = EC_STATE_BOOT;
+ ec_writestate(slave);
+
+ /* wait for slave to reach BOOT state */
+ if (ec_statecheck(slave, EC_STATE_BOOT, EC_TIMEOUTSTATE * 10) == EC_STATE_BOOT)
+ {
+ printf("Slave %d state to BOOT.\n", slave);
+
+ if (input_bin(filename, &filesize))
+ {
+ printf("File read OK, %d bytes.\n", filesize);
+ printf("FoE write....");
+ j = ec_FOEwrite(slave, filename, 0, filesize, &filebuffer, EC_TIMEOUTSTATE);
+ printf("result %d.\n", j);
+ printf("Request init state for slave %d\n", slave);
+ ec_slave[slave].state = EC_STATE_INIT;
+ ec_writestate(slave);
+ }
+ else
+ printf("File not read OK.\n");
+ }
+ }
+ else
+ {
+ printf("No slaves found!\n");
+ }
+ printf("End firmware update example, close socket\n");
+ /* stop SOEM, close socket */
+ ec_close();
+ }
+ else
+ {
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
+ }
}
int main(int argc, char *argv[])
{
- printf("SOEM (Simple Open EtherCAT Master)\nFirmware update example\n");
-
- if (argc > 3)
- {
- argslave = atoi(argv[2]);
- boottest(argv[1], argslave, argv[3]);
- }
- else
- {
- printf("Usage: firm_update ifname1 slave fname\n");
- printf("ifname = eth0 for example\n");
- printf("slave = slave number in EtherCAT order 1..n\n");
- printf("fname = binary file to store in slave\n");
- printf("CAUTION! Using the wrong file can result in a bricked slave!\n");
- }
-
- printf("End program\n");
- return (0);
+ printf("SOEM (Simple Open EtherCAT Master)\nFirmware update example\n");
+
+ if (argc > 3)
+ {
+ argslave = atoi(argv[2]);
+ boottest(argv[1], argslave, argv[3]);
+ }
+ else
+ {
+ printf("Usage: firm_update ifname1 slave fname\n");
+ printf("ifname = eth0 for example\n");
+ printf("slave = slave number in EtherCAT order 1..n\n");
+ printf("fname = binary file to store in slave\n");
+ printf("CAUTION! Using the wrong file can result in a bricked slave!\n");
+ }
+
+ printf("End program\n");
+ return (0);
}
int os;
uint8 ob;
uint16 ob2;
-pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
-pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
uint8 *digout = 0;
int wcounter;
/* initialise SOEM, bind socket to ifname */
if (ec_init_redundant(ifname, ifname2))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ec_config(FALSE, &IOmap) > 0 )
+ if (ec_config(FALSE, &IOmap) > 0)
{
- printf("%d slaves found and configured.\n",ec_slavecount);
+ printf("%d slaves found and configured.\n", ec_slavecount);
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
/* configure DC options for every DC capable slave found in the list */
ec_configdc();
/* read indevidual slave state and store in ec_slave[] */
ec_readstate();
- for(cnt = 1; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
printf("Slave:%d Name:%s Output size:%3dbits Input size:%3dbits State:%2d delay:%d.%d\n",
- cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
- ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
+ cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
+ ec_slave[cnt].state, (int)ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
printf(" Out:%8.8x,%4d In:%8.8x,%4d\n",
- (int)ec_slave[cnt].outputs, ec_slave[cnt].Obytes, (int)ec_slave[cnt].inputs, ec_slave[cnt].Ibytes);
+ (int)ec_slave[cnt].outputs, ec_slave[cnt].Obytes, (int)ec_slave[cnt].inputs, ec_slave[cnt].Ibytes);
/* check for EL2004 or EL2008 */
- if( !digout && ((ec_slave[cnt].eep_id == 0x07d43052) || (ec_slave[cnt].eep_id == 0x07d83052)))
+ if (!digout && ((ec_slave[cnt].eep_id == 0x07d43052) || (ec_slave[cnt].eep_id == 0x07d83052)))
{
digout = ec_slave[cnt].outputs;
}
iloop = ec_slave[0].Ibytes;
if ((iloop == 0) && (ec_slave[0].Ibits > 0)) iloop = 1;
if (iloop > 8) iloop = 8;
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
dorun = 1;
/* acyclic loop 5000 x 20ms = 10s */
- for(i = 1; i <= 5000; i++)
+ for (i = 1; i <= 5000; i++)
{
- printf("Processdata cycle %5d , Wck %3d, DCtime %12lld, O:", dorun, wcounter , ec_DCtime);
- for(j = 0 ; j < oloop; j++)
+ printf("Processdata cycle %5d , Wck %3d, DCtime %12lld, O:", dorun, wcounter, ec_DCtime);
+ for (j = 0; j < oloop; j++)
{
printf(" %2.2x", *(ec_slave[0].outputs + j));
}
printf(" I:");
- for(j = 0 ; j < iloop; j++)
+ for (j = 0; j < iloop; j++)
{
printf(" %2.2x", *(ec_slave[0].inputs + j));
}
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
sec = (addtime - nsec) / NSEC_PER_SEC;
ts->tv_sec += sec;
ts->tv_nsec += nsec;
- if ( ts->tv_nsec >= NSEC_PER_SEC )
+ if (ts->tv_nsec >= NSEC_PER_SEC)
{
nsec = ts->tv_nsec % NSEC_PER_SEC;
ts->tv_sec += (ts->tv_nsec - nsec) / NSEC_PER_SEC;
}
/* PI calculation to get linux time synced to DC time */
-void ec_sync(int64 reftime, int64 cycletime , int64 *offsettime)
+void ec_sync(int64 reftime, int64 cycletime, int64 *offsettime)
{
static int64 integral = 0;
int64 delta;
/* set linux sync point 50us later than DC sync, just as example */
delta = (reftime - 50000) % cycletime;
- if(delta> (cycletime / 2)) { delta= delta - cycletime; }
- if(delta>0){ integral++; }
- if(delta<0){ integral--; }
+ if (delta > (cycletime / 2))
+ {
+ delta = delta - cycletime;
+ }
+ if (delta > 0)
+ {
+ integral++;
+ }
+ if (delta < 0)
+ {
+ integral--;
+ }
*offsettime = -(delta / 100) - (integral / 20);
}
/* RT EtherCAT thread */
-void ecatthread( void *ptr )
+void ecatthread(void *ptr)
{
- struct timespec ts;
- struct timeval tp;
+ struct timespec ts;
+ struct timeval tp;
int rc;
int ht;
int64 cycletime;
rc = pthread_mutex_lock(&mutex);
- rc = gettimeofday(&tp, NULL);
+ rc = gettimeofday(&tp, NULL);
- /* Convert from timeval to timespec */
- ts.tv_sec = tp.tv_sec;
+ /* Convert from timeval to timespec */
+ ts.tv_sec = tp.tv_sec;
ht = (tp.tv_usec / 1000) + 1; /* round to nearest ms */
ts.tv_nsec = ht * 1000000;
- cycletime = *(int*)ptr * 1000; /* cycletime in ns */
+ cycletime = *(int *)ptr * 1000; /* cycletime in ns */
toff = 0;
dorun = 0;
- while(1)
+ while (1)
{
/* calculate next cycle start */
add_timespec(&ts, cycletime + toff);
/* wait to cycle start */
rc = pthread_cond_timedwait(&cond, &mutex, &ts);
- if (dorun>0)
+ if (dorun > 0)
{
- rc = gettimeofday(&tp, NULL);
+ rc = gettimeofday(&tp, NULL);
ec_send_processdata();
dorun++;
/* if we have some digital output, cycle */
- if( digout ) *digout = (uint8) ((dorun / 16) & 0xff);
+ if (digout) *digout = (uint8)((dorun / 16) & 0xff);
if (ec_slave[0].hasdc)
{
{
int iret1;
int ctime;
- struct sched_param param;
- int policy = SCHED_OTHER;
+ struct sched_param param;
+ int policy = SCHED_OTHER;
printf("SOEM (Simple Open EtherCAT Master)\nRedundancy test\n");
do
{
usleep(1000);
- }
- while (dorun);
+ } while (dorun);
if (argc > 3)
{
dorun = 1;
ctime = atoi(argv[3]);
/* create RT thread */
- iret1 = pthread_create( &thread1, NULL, (void *) &ecatthread, (void*) &ctime);
+ iret1 = pthread_create(&thread1, NULL, (void *)&ecatthread, (void *)&ctime);
memset(¶m, 0, sizeof(param));
/* give it higher priority */
param.sched_priority = 40;
iret1 = pthread_setschedparam(thread1, policy, ¶m);
/* start acyclic part */
- redtest(argv[1],argv[2]);
+ redtest(argv[1], argv[2]);
}
else
{
#include <stdio.h>
#include <string.h>
-//#include <Mmsystem.h>
+// #include <Mmsystem.h>
#include "osal.h"
#include "ethercat.h"
uint8 currentgroup = 0;
/* most basic RT thread for process data, just does IO transfer */
-void CALLBACK RTthread(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
+void CALLBACK RTthread(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
{
- IOmap[0]++;
+ IOmap[0]++;
- ec_send_processdata();
- wkc = ec_receive_processdata(EC_TIMEOUTRET);
- rtcnt++;
- /* do RT control stuff here */
+ ec_send_processdata();
+ wkc = ec_receive_processdata(EC_TIMEOUTRET);
+ rtcnt++;
+ /* do RT control stuff here */
}
int EL7031setup(uint16 slave)
{
- int retval;
- uint16 u16val;
+ int retval;
+ uint16 u16val;
- // map velocity
- uint16 map_1c12[4] = {0x0003, 0x1601, 0x1602, 0x1604};
- uint16 map_1c13[3] = {0x0002, 0x1a01, 0x1a03};
+ // map velocity
+ uint16 map_1c12[4] = {0x0003, 0x1601, 0x1602, 0x1604};
+ uint16 map_1c13[3] = {0x0002, 0x1a01, 0x1a03};
- retval = 0;
+ retval = 0;
- // Set PDO mapping using Complete Access
- // Strange, writing CA works, reading CA doesn't
- // This is a protocol error of the slave.
- retval += ec_SDOwrite(slave, 0x1c12, 0x00, TRUE, sizeof(map_1c12), &map_1c12, EC_TIMEOUTSAFE);
- retval += ec_SDOwrite(slave, 0x1c13, 0x00, TRUE, sizeof(map_1c13), &map_1c13, EC_TIMEOUTSAFE);
+ // Set PDO mapping using Complete Access
+ // Strange, writing CA works, reading CA doesn't
+ // This is a protocol error of the slave.
+ retval += ec_SDOwrite(slave, 0x1c12, 0x00, TRUE, sizeof(map_1c12), &map_1c12, EC_TIMEOUTSAFE);
+ retval += ec_SDOwrite(slave, 0x1c13, 0x00, TRUE, sizeof(map_1c13), &map_1c13, EC_TIMEOUTSAFE);
- // bug in EL7031 old firmware, CompleteAccess for reading is not supported even if the slave says it is.
- ec_slave[slave].CoEdetails &= ~ECT_COEDET_SDOCA;
+ // bug in EL7031 old firmware, CompleteAccess for reading is not supported even if the slave says it is.
+ ec_slave[slave].CoEdetails &= ~ECT_COEDET_SDOCA;
- // set some motor parameters, just as example
- u16val = 1200; // max motor current in mA
-// retval += ec_SDOwrite(slave, 0x8010, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
- u16val = 150; // motor coil resistance in 0.01ohm
-// retval += ec_SDOwrite(slave, 0x8010, 0x04, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
+ // set some motor parameters, just as example
+ u16val = 1200; // max motor current in mA
+ // retval += ec_SDOwrite(slave, 0x8010, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
+ u16val = 150; // motor coil resistance in 0.01ohm
+ // retval += ec_SDOwrite(slave, 0x8010, 0x04, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
- // set other nescessary parameters as needed
- // .....
+ // set other nescessary parameters as needed
+ // .....
- while(EcatError) printf("%s", ec_elist2string());
+ while (EcatError)
+ printf("%s", ec_elist2string());
- printf("EL7031 slave %d set, retval = %d\n", slave, retval);
- return 1;
+ printf("EL7031 slave %d set, retval = %d\n", slave, retval);
+ return 1;
}
int AEPsetup(uint16 slave)
{
- int retval;
- uint8 u8val;
- uint16 u16val;
-
- retval = 0;
-
- u8val = 0;
- retval += ec_SDOwrite(slave, 0x1c12, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
- u16val = 0x1603;
- retval += ec_SDOwrite(slave, 0x1c12, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTRXM);
- u8val = 1;
- retval += ec_SDOwrite(slave, 0x1c12, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
-
- u8val = 0;
- retval += ec_SDOwrite(slave, 0x1c13, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
- u16val = 0x1a03;
- retval += ec_SDOwrite(slave, 0x1c13, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTRXM);
- u8val = 1;
- retval += ec_SDOwrite(slave, 0x1c13, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
-
- u8val = 8;
- retval += ec_SDOwrite(slave, 0x6060, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
-
- // set some motor parameters, just as example
- u16val = 1200; // max motor current in mA
-// retval += ec_SDOwrite(slave, 0x8010, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
- u16val = 150; // motor coil resistance in 0.01ohm
-// retval += ec_SDOwrite(slave, 0x8010, 0x04, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
-
- // set other nescessary parameters as needed
- // .....
-
- while(EcatError) printf("%s", ec_elist2string());
-
- printf("AEP slave %d set, retval = %d\n", slave, retval);
- return 1;
+ int retval;
+ uint8 u8val;
+ uint16 u16val;
+
+ retval = 0;
+
+ u8val = 0;
+ retval += ec_SDOwrite(slave, 0x1c12, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
+ u16val = 0x1603;
+ retval += ec_SDOwrite(slave, 0x1c12, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTRXM);
+ u8val = 1;
+ retval += ec_SDOwrite(slave, 0x1c12, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
+
+ u8val = 0;
+ retval += ec_SDOwrite(slave, 0x1c13, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
+ u16val = 0x1a03;
+ retval += ec_SDOwrite(slave, 0x1c13, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTRXM);
+ u8val = 1;
+ retval += ec_SDOwrite(slave, 0x1c13, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
+
+ u8val = 8;
+ retval += ec_SDOwrite(slave, 0x6060, 0x00, FALSE, sizeof(u8val), &u8val, EC_TIMEOUTRXM);
+
+ // set some motor parameters, just as example
+ u16val = 1200; // max motor current in mA
+ // retval += ec_SDOwrite(slave, 0x8010, 0x01, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
+ u16val = 150; // motor coil resistance in 0.01ohm
+ // retval += ec_SDOwrite(slave, 0x8010, 0x04, FALSE, sizeof(u16val), &u16val, EC_TIMEOUTSAFE);
+
+ // set other nescessary parameters as needed
+ // .....
+
+ while (EcatError)
+ printf("%s", ec_elist2string());
+
+ printf("AEP slave %d set, retval = %d\n", slave, retval);
+ return 1;
}
void simpletest(char *ifname)
{
- int i, j, oloop, iloop, wkc_count, chk, slc;
- UINT mmResult;
+ int i, j, oloop, iloop, wkc_count, chk, slc;
+ UINT mmResult;
- needlf = FALSE;
- inOP = FALSE;
+ needlf = FALSE;
+ inOP = FALSE;
printf("Starting simple test\n");
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
+ if (ec_config_init(FALSE) > 0)
+ {
+ printf("%d slaves found and configured.\n", ec_slavecount);
- if ( ec_config_init(FALSE) > 0 )
- {
- printf("%d slaves found and configured.\n",ec_slavecount);
-
- if((ec_slavecount > 1))
+ if ((ec_slavecount > 1))
{
- for(slc = 1; slc <= ec_slavecount; slc++)
- {
- // beckhoff EL7031, using ec_slave[].name is not very reliable
- if((ec_slave[slc].eep_man == 0x00000002) && (ec_slave[slc].eep_id == 0x1b773052))
- {
- printf("Found %s at position %d\n", ec_slave[slc].name, slc);
- // link slave specific setup to preop->safeop hook
- ec_slave[slc].PO2SOconfig = &EL7031setup;
- }
- // Copley Controls EAP, using ec_slave[].name is not very reliable
- if((ec_slave[slc].eep_man == 0x000000ab) && (ec_slave[slc].eep_id == 0x00000380))
- {
- printf("Found %s at position %d\n", ec_slave[slc].name, slc);
- // link slave specific setup to preop->safeop hook
- ec_slave[slc].PO2SOconfig = &AEPsetup;
- }
- }
+ for (slc = 1; slc <= ec_slavecount; slc++)
+ {
+ // beckhoff EL7031, using ec_slave[].name is not very reliable
+ if ((ec_slave[slc].eep_man == 0x00000002) && (ec_slave[slc].eep_id == 0x1b773052))
+ {
+ printf("Found %s at position %d\n", ec_slave[slc].name, slc);
+ // link slave specific setup to preop->safeop hook
+ ec_slave[slc].PO2SOconfig = &EL7031setup;
+ }
+ // Copley Controls EAP, using ec_slave[].name is not very reliable
+ if ((ec_slave[slc].eep_man == 0x000000ab) && (ec_slave[slc].eep_id == 0x00000380))
+ {
+ printf("Found %s at position %d\n", ec_slave[slc].name, slc);
+ // link slave specific setup to preop->safeop hook
+ ec_slave[slc].PO2SOconfig = &AEPsetup;
+ }
+ }
}
-
ec_config_map(&IOmap);
ec_configdc();
printf("Slaves mapped, state to SAFE_OP.\n");
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
oloop = ec_slave[0].Obytes;
if ((oloop == 0) && (ec_slave[0].Obits > 0)) oloop = 1;
if ((iloop == 0) && (ec_slave[0].Ibits > 0)) iloop = 1;
if (iloop > 8) iloop = 8;
- printf("segments : %d : %d %d %d %d\n",ec_group[0].nsegments ,ec_group[0].IOsegment[0],ec_group[0].IOsegment[1],ec_group[0].IOsegment[2],ec_group[0].IOsegment[3]);
+ printf("segments : %d : %d %d %d %d\n", ec_group[0].nsegments, ec_group[0].IOsegment[0], ec_group[0].IOsegment[1], ec_group[0].IOsegment[2], ec_group[0].IOsegment[3]);
printf("Request operational state for all slaves\n");
expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
do
{
ec_statecheck(0, EC_STATE_OPERATIONAL, 50000);
- }
- while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));
- if (ec_slave[0].state == EC_STATE_OPERATIONAL )
+ } while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));
+ if (ec_slave[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
wkc_count = 0;
inOP = TRUE;
-
/* cyclic loop, reads data from RT thread */
- for(i = 1; i <= 500; i++)
+ for (i = 1; i <= 500; i++)
{
- if(wkc >= expectedWKC)
- {
- printf("Processdata cycle %4d, WKC %d , O:", rtcnt, wkc);
-
- for(j = 0 ; j < oloop; j++)
- {
- printf(" %2.2x", *(ec_slave[0].outputs + j));
- }
-
- printf(" I:");
- for(j = 0 ; j < iloop; j++)
- {
- printf(" %2.2x", *(ec_slave[0].inputs + j));
- }
- printf(" T:%lld\r",ec_DCtime);
- needlf = TRUE;
- }
- osal_usleep(50000);
+ if (wkc >= expectedWKC)
+ {
+ printf("Processdata cycle %4d, WKC %d , O:", rtcnt, wkc);
+
+ for (j = 0; j < oloop; j++)
+ {
+ printf(" %2.2x", *(ec_slave[0].outputs + j));
+ }
+ printf(" I:");
+ for (j = 0; j < iloop; j++)
+ {
+ printf(" %2.2x", *(ec_slave[0].inputs + j));
+ }
+ printf(" T:%lld\r", ec_DCtime);
+ needlf = TRUE;
+ }
+ osal_usleep(50000);
}
inOP = FALSE;
}
else
{
- printf("Not all slaves reached operational state.\n");
- ec_readstate();
- for(i = 1; i<=ec_slavecount ; i++)
- {
- if(ec_slave[i].state != EC_STATE_OPERATIONAL)
- {
- printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
- i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
- }
- }
+ printf("Not all slaves reached operational state.\n");
+ ec_readstate();
+ for (i = 1; i <= ec_slavecount; i++)
+ {
+ if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ {
+ printf("Slave %d State=0x%2.2x StatusCode=0x%4.4x : %s\n",
+ i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
+ }
+ }
}
/* stop RT thread */
ec_slave[0].state = EC_STATE_INIT;
/* request INIT state for all slaves */
ec_writestate(0);
- }
- else
- {
- printf("No slaves found!\n");
- }
- printf("End simple test, close socket\n");
- /* stop SOEM, close socket */
- ec_close();
- }
- else
- {
- printf("No socket connection on %s\nExcecute as root\n",ifname);
- }
+ }
+ else
+ {
+ printf("No slaves found!\n");
+ }
+ printf("End simple test, close socket\n");
+ /* stop SOEM, close socket */
+ ec_close();
+ }
+ else
+ {
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
+ }
}
-//DWORD WINAPI ecatcheck( LPVOID lpParam )
+// DWORD WINAPI ecatcheck( LPVOID lpParam )
OSAL_THREAD_FUNC ecatcheck(void *lpParam)
{
- int slave;
+ int slave;
- while(1)
- {
- if( inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
- {
- if (needlf)
- {
- needlf = FALSE;
- printf("\n");
- }
- /* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
- ec_readstate();
- for (slave = 1; slave <= ec_slavecount; slave++)
+ while (1)
+ {
+ if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ {
+ if (needlf)
+ {
+ needlf = FALSE;
+ printf("\n");
+ }
+ /* one ore more slaves are not responding */
+ ec_group[currentgroup].docheckstate = FALSE;
+ ec_readstate();
+ for (slave = 1; slave <= ec_slavecount; slave++)
+ {
+ if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_group[currentgroup].docheckstate = TRUE;
+ if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
- {
- printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
- ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
- ec_writestate(slave);
- }
- else if(ec_slave[slave].state == EC_STATE_SAFE_OP)
- {
- printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
- ec_slave[slave].state = EC_STATE_OPERATIONAL;
- ec_writestate(slave);
- }
- else if(ec_slave[slave].state > EC_STATE_NONE)
- {
- if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n",slave);
- }
- }
- else if(!ec_slave[slave].islost)
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slave);
+ ec_slave[slave].state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ec_writestate(slave);
+ }
+ else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ {
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slave);
+ ec_slave[slave].state = EC_STATE_OPERATIONAL;
+ ec_writestate(slave);
+ }
+ else if (ec_slave[slave].state > EC_STATE_NONE)
+ {
+ if (ec_reconfig_slave(slave, EC_TIMEOUTMON))
{
- /* re-check state */
- ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
- {
- ec_slave[slave].islost = TRUE;
- printf("ERROR : slave %d lost\n",slave);
- }
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slave);
}
}
- if (ec_slave[slave].islost)
+ else if (!ec_slave[slave].islost)
{
- if(ec_slave[slave].state == EC_STATE_NONE)
+ /* re-check state */
+ ec_statecheck(slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (ec_slave[slave].state == EC_STATE_NONE)
{
- if (ec_recover_slave(slave, EC_TIMEOUTMON))
- {
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n",slave);
- }
+ ec_slave[slave].islost = TRUE;
+ printf("ERROR : slave %d lost\n", slave);
}
- else
+ }
+ }
+ if (ec_slave[slave].islost)
+ {
+ if (ec_slave[slave].state == EC_STATE_NONE)
+ {
+ if (ec_recover_slave(slave, EC_TIMEOUTMON))
{
ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n",slave);
+ printf("MESSAGE : slave %d recovered\n", slave);
}
}
+ else
+ {
+ ec_slave[slave].islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slave);
+ }
}
- if(!ec_group[currentgroup].docheckstate)
- printf("OK : all slaves resumed OPERATIONAL.\n");
- }
- osal_usleep(10000);
- }
+ }
+ if (!ec_group[currentgroup].docheckstate)
+ printf("OK : all slaves resumed OPERATIONAL.\n");
+ }
+ osal_usleep(10000);
+ }
- return 0;
+ return 0;
}
char ifbuf[1024];
int main(int argc, char *argv[])
{
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
printf("SOEM (Simple Open EtherCAT Master)\nSimple test\n");
if (argc > 1)
else
{
printf("Usage: simple_test ifname1\n");
- /* Print the list */
- printf ("Available adapters\n");
- head = adapter = ec_find_adapters ();
+ /* Print the list */
+ printf("Available adapters\n");
+ head = adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf ("Description : %s, Device to use for wpcap: %s\n", adapter->desc,adapter->name);
+ printf("Description : %s, Device to use for wpcap: %s\n", adapter->desc, adapter->name);
adapter = adapter->next;
}
ec_free_adapters(adapter);
char usdo[128];
char hstr[1024];
-char* dtype2string(uint16 dtype)
+char *dtype2string(uint16 dtype)
{
- switch(dtype)
- {
- case ECT_BOOLEAN:
- sprintf(hstr, "BOOLEAN");
- break;
- case ECT_INTEGER8:
- sprintf(hstr, "INTEGER8");
- break;
- case ECT_INTEGER16:
- sprintf(hstr, "INTEGER16");
- break;
- case ECT_INTEGER32:
- sprintf(hstr, "INTEGER32");
- break;
- case ECT_INTEGER24:
- sprintf(hstr, "INTEGER24");
- break;
- case ECT_INTEGER64:
- sprintf(hstr, "INTEGER64");
- break;
- case ECT_UNSIGNED8:
- sprintf(hstr, "UNSIGNED8");
- break;
- case ECT_UNSIGNED16:
- sprintf(hstr, "UNSIGNED16");
- break;
- case ECT_UNSIGNED32:
- sprintf(hstr, "UNSIGNED32");
- break;
- case ECT_UNSIGNED24:
- sprintf(hstr, "UNSIGNED24");
- break;
- case ECT_UNSIGNED64:
- sprintf(hstr, "UNSIGNED64");
- break;
- case ECT_REAL32:
- sprintf(hstr, "REAL32");
- break;
- case ECT_REAL64:
- sprintf(hstr, "REAL64");
- break;
- case ECT_BIT1:
- sprintf(hstr, "BIT1");
- break;
- case ECT_BIT2:
- sprintf(hstr, "BIT2");
- break;
- case ECT_BIT3:
- sprintf(hstr, "BIT3");
- break;
- case ECT_BIT4:
- sprintf(hstr, "BIT4");
- break;
- case ECT_BIT5:
- sprintf(hstr, "BIT5");
- break;
- case ECT_BIT6:
- sprintf(hstr, "BIT6");
- break;
- case ECT_BIT7:
- sprintf(hstr, "BIT7");
- break;
- case ECT_BIT8:
- sprintf(hstr, "BIT8");
- break;
- case ECT_VISIBLE_STRING:
- sprintf(hstr, "VISIBLE_STRING");
- break;
- case ECT_OCTET_STRING:
- sprintf(hstr, "OCTET_STRING");
- break;
- default:
- sprintf(hstr, "Type 0x%4.4X", dtype);
- }
- return hstr;
+ switch (dtype)
+ {
+ case ECT_BOOLEAN:
+ sprintf(hstr, "BOOLEAN");
+ break;
+ case ECT_INTEGER8:
+ sprintf(hstr, "INTEGER8");
+ break;
+ case ECT_INTEGER16:
+ sprintf(hstr, "INTEGER16");
+ break;
+ case ECT_INTEGER32:
+ sprintf(hstr, "INTEGER32");
+ break;
+ case ECT_INTEGER24:
+ sprintf(hstr, "INTEGER24");
+ break;
+ case ECT_INTEGER64:
+ sprintf(hstr, "INTEGER64");
+ break;
+ case ECT_UNSIGNED8:
+ sprintf(hstr, "UNSIGNED8");
+ break;
+ case ECT_UNSIGNED16:
+ sprintf(hstr, "UNSIGNED16");
+ break;
+ case ECT_UNSIGNED32:
+ sprintf(hstr, "UNSIGNED32");
+ break;
+ case ECT_UNSIGNED24:
+ sprintf(hstr, "UNSIGNED24");
+ break;
+ case ECT_UNSIGNED64:
+ sprintf(hstr, "UNSIGNED64");
+ break;
+ case ECT_REAL32:
+ sprintf(hstr, "REAL32");
+ break;
+ case ECT_REAL64:
+ sprintf(hstr, "REAL64");
+ break;
+ case ECT_BIT1:
+ sprintf(hstr, "BIT1");
+ break;
+ case ECT_BIT2:
+ sprintf(hstr, "BIT2");
+ break;
+ case ECT_BIT3:
+ sprintf(hstr, "BIT3");
+ break;
+ case ECT_BIT4:
+ sprintf(hstr, "BIT4");
+ break;
+ case ECT_BIT5:
+ sprintf(hstr, "BIT5");
+ break;
+ case ECT_BIT6:
+ sprintf(hstr, "BIT6");
+ break;
+ case ECT_BIT7:
+ sprintf(hstr, "BIT7");
+ break;
+ case ECT_BIT8:
+ sprintf(hstr, "BIT8");
+ break;
+ case ECT_VISIBLE_STRING:
+ sprintf(hstr, "VISIBLE_STRING");
+ break;
+ case ECT_OCTET_STRING:
+ sprintf(hstr, "OCTET_STRING");
+ break;
+ default:
+ sprintf(hstr, "Type 0x%4.4X", dtype);
+ }
+ return hstr;
}
-char* SDO2string(uint16 slave, uint16 index, uint8 subidx, uint16 dtype)
+char *SDO2string(uint16 slave, uint16 index, uint8 subidx, uint16 dtype)
{
int l = sizeof(usdo) - 1, i;
uint8 *u8;
}
else
{
- switch(dtype)
+ switch (dtype)
{
- case ECT_BOOLEAN:
- u8 = (uint8*) &usdo[0];
- if (*u8) sprintf(hstr, "TRUE");
- else sprintf(hstr, "FALSE");
- break;
- case ECT_INTEGER8:
- i8 = (int8*) &usdo[0];
- sprintf(hstr, "0x%2.2x %d", *i8, *i8);
- break;
- case ECT_INTEGER16:
- i16 = (int16*) &usdo[0];
- sprintf(hstr, "0x%4.4x %d", *i16, *i16);
- break;
- case ECT_INTEGER32:
- case ECT_INTEGER24:
- i32 = (int32*) &usdo[0];
- sprintf(hstr, "0x%8.8x %d", *i32, *i32);
- break;
- case ECT_INTEGER64:
- i64 = (int64*) &usdo[0];
- sprintf(hstr, "0x%16.16"PRIx64" %"PRId64, *i64, *i64);
- break;
- case ECT_UNSIGNED8:
- u8 = (uint8*) &usdo[0];
- sprintf(hstr, "0x%2.2x %u", *u8, *u8);
- break;
- case ECT_UNSIGNED16:
- u16 = (uint16*) &usdo[0];
- sprintf(hstr, "0x%4.4x %u", *u16, *u16);
- break;
- case ECT_UNSIGNED32:
- case ECT_UNSIGNED24:
- u32 = (uint32*) &usdo[0];
- sprintf(hstr, "0x%8.8x %u", *u32, *u32);
- break;
- case ECT_UNSIGNED64:
- u64 = (uint64*) &usdo[0];
- sprintf(hstr, "0x%16.16"PRIx64" %"PRIu64, *u64, *u64);
- break;
- case ECT_REAL32:
- sr = (float*) &usdo[0];
- sprintf(hstr, "%f", *sr);
- break;
- case ECT_REAL64:
- dr = (double*) &usdo[0];
- sprintf(hstr, "%f", *dr);
- break;
- case ECT_BIT1:
- case ECT_BIT2:
- case ECT_BIT3:
- case ECT_BIT4:
- case ECT_BIT5:
- case ECT_BIT6:
- case ECT_BIT7:
- case ECT_BIT8:
- u8 = (uint8*) &usdo[0];
- sprintf(hstr, "0x%x", *u8);
- break;
- case ECT_VISIBLE_STRING:
- strcpy(hstr, usdo);
- break;
- case ECT_OCTET_STRING:
- hstr[0] = 0x00;
- for (i = 0 ; i < l ; i++)
- {
- sprintf(es, "0x%2.2x ", usdo[i]);
- strcat( hstr, es);
- }
- break;
- default:
- sprintf(hstr, "Unknown type");
+ case ECT_BOOLEAN:
+ u8 = (uint8 *)&usdo[0];
+ if (*u8)
+ sprintf(hstr, "TRUE");
+ else
+ sprintf(hstr, "FALSE");
+ break;
+ case ECT_INTEGER8:
+ i8 = (int8 *)&usdo[0];
+ sprintf(hstr, "0x%2.2x %d", *i8, *i8);
+ break;
+ case ECT_INTEGER16:
+ i16 = (int16 *)&usdo[0];
+ sprintf(hstr, "0x%4.4x %d", *i16, *i16);
+ break;
+ case ECT_INTEGER32:
+ case ECT_INTEGER24:
+ i32 = (int32 *)&usdo[0];
+ sprintf(hstr, "0x%8.8x %d", *i32, *i32);
+ break;
+ case ECT_INTEGER64:
+ i64 = (int64 *)&usdo[0];
+ sprintf(hstr, "0x%16.16" PRIx64 " %" PRId64, *i64, *i64);
+ break;
+ case ECT_UNSIGNED8:
+ u8 = (uint8 *)&usdo[0];
+ sprintf(hstr, "0x%2.2x %u", *u8, *u8);
+ break;
+ case ECT_UNSIGNED16:
+ u16 = (uint16 *)&usdo[0];
+ sprintf(hstr, "0x%4.4x %u", *u16, *u16);
+ break;
+ case ECT_UNSIGNED32:
+ case ECT_UNSIGNED24:
+ u32 = (uint32 *)&usdo[0];
+ sprintf(hstr, "0x%8.8x %u", *u32, *u32);
+ break;
+ case ECT_UNSIGNED64:
+ u64 = (uint64 *)&usdo[0];
+ sprintf(hstr, "0x%16.16" PRIx64 " %" PRIu64, *u64, *u64);
+ break;
+ case ECT_REAL32:
+ sr = (float *)&usdo[0];
+ sprintf(hstr, "%f", *sr);
+ break;
+ case ECT_REAL64:
+ dr = (double *)&usdo[0];
+ sprintf(hstr, "%f", *dr);
+ break;
+ case ECT_BIT1:
+ case ECT_BIT2:
+ case ECT_BIT3:
+ case ECT_BIT4:
+ case ECT_BIT5:
+ case ECT_BIT6:
+ case ECT_BIT7:
+ case ECT_BIT8:
+ u8 = (uint8 *)&usdo[0];
+ sprintf(hstr, "0x%x", *u8);
+ break;
+ case ECT_VISIBLE_STRING:
+ strcpy(hstr, usdo);
+ break;
+ case ECT_OCTET_STRING:
+ hstr[0] = 0x00;
+ for (i = 0; i < l; i++)
+ {
+ sprintf(es, "0x%2.2x ", usdo[i]);
+ strcat(hstr, es);
+ }
+ break;
+ default:
+ sprintf(hstr, "Unknown type");
}
return hstr;
}
/** Read PDO assign structure */
int si_PDOassign(uint16 slave, uint16 PDOassign, int mapoffset, int bitoffset)
{
- uint16 idxloop, nidx, subidxloop, rdat, idx, subidx;
- uint8 subcnt;
- int wkc, bsize = 0, rdl;
- int32 rdat2;
- uint8 bitlen, obj_subidx;
- uint16 obj_idx;
- int abs_offset, abs_bit;
-
- rdl = sizeof(rdat); rdat = 0;
- /* read PDO assign subindex 0 ( = number of PDO's) */
- wkc = ec_SDOread(slave, PDOassign, 0x00, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
- rdat = etohs(rdat);
- /* positive result from slave ? */
- if ((wkc > 0) && (rdat > 0))
- {
- /* number of available sub indexes */
- nidx = rdat;
- bsize = 0;
- /* read all PDO's */
- for (idxloop = 1; idxloop <= nidx; idxloop++)
- {
- rdl = sizeof(rdat); rdat = 0;
- /* read PDO assign */
- wkc = ec_SDOread(slave, PDOassign, (uint8)idxloop, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
- /* result is index of PDO */
- idx = etohl(rdat);
- if (idx > 0)
+ uint16 idxloop, nidx, subidxloop, rdat, idx, subidx;
+ uint8 subcnt;
+ int wkc, bsize = 0, rdl;
+ int32 rdat2;
+ uint8 bitlen, obj_subidx;
+ uint16 obj_idx;
+ int abs_offset, abs_bit;
+
+ rdl = sizeof(rdat);
+ rdat = 0;
+ /* read PDO assign subindex 0 ( = number of PDO's) */
+ wkc = ec_SDOread(slave, PDOassign, 0x00, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
+ rdat = etohs(rdat);
+ /* positive result from slave ? */
+ if ((wkc > 0) && (rdat > 0))
+ {
+ /* number of available sub indexes */
+ nidx = rdat;
+ bsize = 0;
+ /* read all PDO's */
+ for (idxloop = 1; idxloop <= nidx; idxloop++)
+ {
+ rdl = sizeof(rdat);
+ rdat = 0;
+ /* read PDO assign */
+ wkc = ec_SDOread(slave, PDOassign, (uint8)idxloop, FALSE, &rdl, &rdat, EC_TIMEOUTRXM);
+ /* result is index of PDO */
+ idx = etohl(rdat);
+ if (idx > 0)
+ {
+ rdl = sizeof(subcnt);
+ subcnt = 0;
+ /* read number of subindexes of PDO */
+ wkc = ec_SDOread(slave, idx, 0x00, FALSE, &rdl, &subcnt, EC_TIMEOUTRXM);
+ subidx = subcnt;
+ /* for each subindex */
+ for (subidxloop = 1; subidxloop <= subidx; subidxloop++)
{
- rdl = sizeof(subcnt); subcnt = 0;
- /* read number of subindexes of PDO */
- wkc = ec_SDOread(slave,idx, 0x00, FALSE, &rdl, &subcnt, EC_TIMEOUTRXM);
- subidx = subcnt;
- /* for each subindex */
- for (subidxloop = 1; subidxloop <= subidx; subidxloop++)
- {
- rdl = sizeof(rdat2); rdat2 = 0;
- /* read SDO that is mapped in PDO */
- wkc = ec_SDOread(slave, idx, (uint8)subidxloop, FALSE, &rdl, &rdat2, EC_TIMEOUTRXM);
- rdat2 = etohl(rdat2);
- /* extract bitlength of SDO */
- bitlen = LO_BYTE(rdat2);
- bsize += bitlen;
- obj_idx = (uint16)(rdat2 >> 16);
- obj_subidx = (uint8)((rdat2 >> 8) & 0x000000ff);
- abs_offset = mapoffset + (bitoffset / 8);
- abs_bit = bitoffset % 8;
- ODlist.Slave = slave;
- ODlist.Index[0] = obj_idx;
- OElist.Entries = 0;
- wkc = 0;
- /* read object entry from dictionary if not a filler (0x0000:0x00) */
- if(obj_idx || obj_subidx)
- wkc = ec_readOEsingle(0, obj_subidx, &ODlist, &OElist);
- printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
- if((wkc > 0) && OElist.Entries)
- {
- printf(" %-12s %s\n", dtype2string(OElist.DataType[obj_subidx]), OElist.Name[obj_subidx]);
- }
- else
- printf("\n");
- bitoffset += bitlen;
- };
+ rdl = sizeof(rdat2);
+ rdat2 = 0;
+ /* read SDO that is mapped in PDO */
+ wkc = ec_SDOread(slave, idx, (uint8)subidxloop, FALSE, &rdl, &rdat2, EC_TIMEOUTRXM);
+ rdat2 = etohl(rdat2);
+ /* extract bitlength of SDO */
+ bitlen = LO_BYTE(rdat2);
+ bsize += bitlen;
+ obj_idx = (uint16)(rdat2 >> 16);
+ obj_subidx = (uint8)((rdat2 >> 8) & 0x000000ff);
+ abs_offset = mapoffset + (bitoffset / 8);
+ abs_bit = bitoffset % 8;
+ ODlist.Slave = slave;
+ ODlist.Index[0] = obj_idx;
+ OElist.Entries = 0;
+ wkc = 0;
+ /* read object entry from dictionary if not a filler (0x0000:0x00) */
+ if (obj_idx || obj_subidx)
+ wkc = ec_readOEsingle(0, obj_subidx, &ODlist, &OElist);
+ printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
+ if ((wkc > 0) && OElist.Entries)
+ {
+ printf(" %-12s %s\n", dtype2string(OElist.DataType[obj_subidx]), OElist.Name[obj_subidx]);
+ }
+ else
+ printf("\n");
+ bitoffset += bitlen;
};
- };
- };
- /* return total found bitlength (PDO) */
- return bsize;
+ };
+ };
+ };
+ /* return total found bitlength (PDO) */
+ return bsize;
}
int si_map_sdo(int slave)
{
- int wkc, rdl;
- int retVal = 0;
- uint8 nSM, iSM, tSM;
- int Tsize, outputs_bo, inputs_bo;
- uint8 SMt_bug_add;
-
- printf("PDO mapping according to CoE :\n");
- SMt_bug_add = 0;
- outputs_bo = 0;
- inputs_bo = 0;
- rdl = sizeof(nSM); nSM = 0;
- /* read SyncManager Communication Type object count */
- wkc = ec_SDOread(slave, ECT_SDO_SMCOMMTYPE, 0x00, FALSE, &rdl, &nSM, EC_TIMEOUTRXM);
- /* positive result from slave ? */
- if ((wkc > 0) && (nSM > 2))
- {
- /* make nSM equal to number of defined SM */
- nSM--;
- /* limit to maximum number of SM defined, if true the slave can't be configured */
- if (nSM > EC_MAXSM)
- nSM = EC_MAXSM;
- /* iterate for every SM type defined */
- for (iSM = 2 ; iSM <= nSM ; iSM++)
- {
- rdl = sizeof(tSM); tSM = 0;
- /* read SyncManager Communication Type */
- wkc = ec_SDOread(slave, ECT_SDO_SMCOMMTYPE, iSM + 1, FALSE, &rdl, &tSM, EC_TIMEOUTRXM);
- if (wkc > 0)
+ int wkc, rdl;
+ int retVal = 0;
+ uint8 nSM, iSM, tSM;
+ int Tsize, outputs_bo, inputs_bo;
+ uint8 SMt_bug_add;
+
+ printf("PDO mapping according to CoE :\n");
+ SMt_bug_add = 0;
+ outputs_bo = 0;
+ inputs_bo = 0;
+ rdl = sizeof(nSM);
+ nSM = 0;
+ /* read SyncManager Communication Type object count */
+ wkc = ec_SDOread(slave, ECT_SDO_SMCOMMTYPE, 0x00, FALSE, &rdl, &nSM, EC_TIMEOUTRXM);
+ /* positive result from slave ? */
+ if ((wkc > 0) && (nSM > 2))
+ {
+ /* make nSM equal to number of defined SM */
+ nSM--;
+ /* limit to maximum number of SM defined, if true the slave can't be configured */
+ if (nSM > EC_MAXSM)
+ nSM = EC_MAXSM;
+ /* iterate for every SM type defined */
+ for (iSM = 2; iSM <= nSM; iSM++)
+ {
+ rdl = sizeof(tSM);
+ tSM = 0;
+ /* read SyncManager Communication Type */
+ wkc = ec_SDOread(slave, ECT_SDO_SMCOMMTYPE, iSM + 1, FALSE, &rdl, &tSM, EC_TIMEOUTRXM);
+ if (wkc > 0)
+ {
+ if ((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
{
- if((iSM == 2) && (tSM == 2)) // SM2 has type 2 == mailbox out, this is a bug in the slave!
- {
- SMt_bug_add = 1; // try to correct, this works if the types are 0 1 2 3 and should be 1 2 3 4
- printf("Activated SM type workaround, possible incorrect mapping.\n");
- }
- if(tSM)
- tSM += SMt_bug_add; // only add if SMt > 0
+ SMt_bug_add = 1; // try to correct, this works if the types are 0 1 2 3 and should be 1 2 3 4
+ printf("Activated SM type workaround, possible incorrect mapping.\n");
+ }
+ if (tSM)
+ tSM += SMt_bug_add; // only add if SMt > 0
- if (tSM == 3) // outputs
- {
- /* read the assign RXPDO */
- printf(" SM%1d outputs\n addr b index: sub bitl data_type name\n", iSM);
- Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap[0]), outputs_bo );
- outputs_bo += Tsize;
- }
- if (tSM == 4) // inputs
- {
- /* read the assign TXPDO */
- printf(" SM%1d inputs\n addr b index: sub bitl data_type name\n", iSM);
- Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap[0]), inputs_bo );
- inputs_bo += Tsize;
- }
+ if (tSM == 3) // outputs
+ {
+ /* read the assign RXPDO */
+ printf(" SM%1d outputs\n addr b index: sub bitl data_type name\n", iSM);
+ Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap[0]), outputs_bo);
+ outputs_bo += Tsize;
}
- }
- }
+ if (tSM == 4) // inputs
+ {
+ /* read the assign TXPDO */
+ printf(" SM%1d inputs\n addr b index: sub bitl data_type name\n", iSM);
+ Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap[0]), inputs_bo);
+ inputs_bo += Tsize;
+ }
+ }
+ }
+ }
- /* found some I/O bits ? */
- if ((outputs_bo > 0) || (inputs_bo > 0))
- retVal = 1;
- return retVal;
+ /* found some I/O bits ? */
+ if ((outputs_bo > 0) || (inputs_bo > 0))
+ retVal = 1;
+ return retVal;
}
int si_siiPDO(uint16 slave, uint8 t, int mapoffset, int bitoffset)
{
- uint16 a , w, c, e, er, Size;
- uint8 eectl;
- uint16 obj_idx;
- uint8 obj_subidx;
- uint8 obj_name;
- uint8 obj_datatype;
- uint8 bitlen;
- int totalsize;
- ec_eepromPDOt eepPDO;
- ec_eepromPDOt *PDO;
- int abs_offset, abs_bit;
- char str_name[EC_MAXNAME + 1];
-
- eectl = ec_slave[slave].eep_pdi;
- Size = 0;
- totalsize = 0;
- PDO = &eepPDO;
- PDO->nPDO = 0;
- PDO->Length = 0;
- PDO->Index[1] = 0;
- for (c = 0 ; c < EC_MAXSM ; c++) PDO->SMbitsize[c] = 0;
- if (t > 1)
- t = 1;
- PDO->Startpos = ec_siifind(slave, ECT_SII_PDO + t);
- if (PDO->Startpos > 0)
- {
- a = PDO->Startpos;
- w = ec_siigetbyte(slave, a++);
- w += (ec_siigetbyte(slave, a++) << 8);
- PDO->Length = w;
- c = 1;
- /* traverse through all PDOs */
- do
- {
- PDO->nPDO++;
- PDO->Index[PDO->nPDO] = ec_siigetbyte(slave, a++);
- PDO->Index[PDO->nPDO] += (ec_siigetbyte(slave, a++) << 8);
- PDO->BitSize[PDO->nPDO] = 0;
- c++;
- /* number of entries in PDO */
- e = ec_siigetbyte(slave, a++);
- PDO->SyncM[PDO->nPDO] = ec_siigetbyte(slave, a++);
- a++;
- obj_name = ec_siigetbyte(slave, a++);
- a += 2;
- c += 2;
- if (PDO->SyncM[PDO->nPDO] < EC_MAXSM) /* active and in range SM? */
+ uint16 a, w, c, e, er, Size;
+ uint8 eectl;
+ uint16 obj_idx;
+ uint8 obj_subidx;
+ uint8 obj_name;
+ uint8 obj_datatype;
+ uint8 bitlen;
+ int totalsize;
+ ec_eepromPDOt eepPDO;
+ ec_eepromPDOt *PDO;
+ int abs_offset, abs_bit;
+ char str_name[EC_MAXNAME + 1];
+
+ eectl = ec_slave[slave].eep_pdi;
+ Size = 0;
+ totalsize = 0;
+ PDO = &eepPDO;
+ PDO->nPDO = 0;
+ PDO->Length = 0;
+ PDO->Index[1] = 0;
+ for (c = 0; c < EC_MAXSM; c++)
+ PDO->SMbitsize[c] = 0;
+ if (t > 1)
+ t = 1;
+ PDO->Startpos = ec_siifind(slave, ECT_SII_PDO + t);
+ if (PDO->Startpos > 0)
+ {
+ a = PDO->Startpos;
+ w = ec_siigetbyte(slave, a++);
+ w += (ec_siigetbyte(slave, a++) << 8);
+ PDO->Length = w;
+ c = 1;
+ /* traverse through all PDOs */
+ do
+ {
+ PDO->nPDO++;
+ PDO->Index[PDO->nPDO] = ec_siigetbyte(slave, a++);
+ PDO->Index[PDO->nPDO] += (ec_siigetbyte(slave, a++) << 8);
+ PDO->BitSize[PDO->nPDO] = 0;
+ c++;
+ /* number of entries in PDO */
+ e = ec_siigetbyte(slave, a++);
+ PDO->SyncM[PDO->nPDO] = ec_siigetbyte(slave, a++);
+ a++;
+ obj_name = ec_siigetbyte(slave, a++);
+ a += 2;
+ c += 2;
+ if (PDO->SyncM[PDO->nPDO] < EC_MAXSM) /* active and in range SM? */
+ {
+ str_name[0] = 0;
+ if (obj_name)
+ ec_siistring(str_name, slave, obj_name);
+ if (t)
+ printf(" SM%1d RXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
+ else
+ printf(" SM%1d TXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
+ printf(" addr b index: sub bitl data_type name\n");
+ /* read all entries defined in PDO */
+ for (er = 1; er <= e; er++)
{
- str_name[0] = 0;
- if(obj_name)
+ c += 4;
+ obj_idx = ec_siigetbyte(slave, a++);
+ obj_idx += (ec_siigetbyte(slave, a++) << 8);
+ obj_subidx = ec_siigetbyte(slave, a++);
+ obj_name = ec_siigetbyte(slave, a++);
+ obj_datatype = ec_siigetbyte(slave, a++);
+ bitlen = ec_siigetbyte(slave, a++);
+ abs_offset = mapoffset + (bitoffset / 8);
+ abs_bit = bitoffset % 8;
+
+ PDO->BitSize[PDO->nPDO] += bitlen;
+ a += 2;
+
+ str_name[0] = 0;
+ if (obj_name)
ec_siistring(str_name, slave, obj_name);
- if (t)
- printf(" SM%1d RXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
- else
- printf(" SM%1d TXPDO 0x%4.4X %s\n", PDO->SyncM[PDO->nPDO], PDO->Index[PDO->nPDO], str_name);
- printf(" addr b index: sub bitl data_type name\n");
- /* read all entries defined in PDO */
- for (er = 1; er <= e; er++)
- {
- c += 4;
- obj_idx = ec_siigetbyte(slave, a++);
- obj_idx += (ec_siigetbyte(slave, a++) << 8);
- obj_subidx = ec_siigetbyte(slave, a++);
- obj_name = ec_siigetbyte(slave, a++);
- obj_datatype = ec_siigetbyte(slave, a++);
- bitlen = ec_siigetbyte(slave, a++);
- abs_offset = mapoffset + (bitoffset / 8);
- abs_bit = bitoffset % 8;
-
- PDO->BitSize[PDO->nPDO] += bitlen;
- a += 2;
- str_name[0] = 0;
- if(obj_name)
- ec_siistring(str_name, slave, obj_name);
-
- printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
- printf(" %-12s %s\n", dtype2string(obj_datatype), str_name);
- bitoffset += bitlen;
- totalsize += bitlen;
- }
- PDO->SMbitsize[ PDO->SyncM[PDO->nPDO] ] += PDO->BitSize[PDO->nPDO];
- Size += PDO->BitSize[PDO->nPDO];
- c++;
+ printf(" [0x%4.4X.%1d] 0x%4.4X:0x%2.2X 0x%2.2X", abs_offset, abs_bit, obj_idx, obj_subidx, bitlen);
+ printf(" %-12s %s\n", dtype2string(obj_datatype), str_name);
+ bitoffset += bitlen;
+ totalsize += bitlen;
}
- else /* PDO deactivated because SM is 0xff or > EC_MAXSM */
- {
- c += 4 * e;
- a += 8 * e;
- c++;
- }
- if (PDO->nPDO >= (EC_MAXEEPDO - 1)) c = PDO->Length; /* limit number of PDO entries in buffer */
- }
- while (c < PDO->Length);
- }
- if (eectl) ec_eeprom2pdi(slave); /* if eeprom control was previously pdi then restore */
- return totalsize;
+ PDO->SMbitsize[PDO->SyncM[PDO->nPDO]] += PDO->BitSize[PDO->nPDO];
+ Size += PDO->BitSize[PDO->nPDO];
+ c++;
+ }
+ else /* PDO deactivated because SM is 0xff or > EC_MAXSM */
+ {
+ c += 4 * e;
+ a += 8 * e;
+ c++;
+ }
+ if (PDO->nPDO >= (EC_MAXEEPDO - 1)) c = PDO->Length; /* limit number of PDO entries in buffer */
+ } while (c < PDO->Length);
+ }
+ if (eectl) ec_eeprom2pdi(slave); /* if eeprom control was previously pdi then restore */
+ return totalsize;
}
-
int si_map_sii(int slave)
{
- int retVal = 0;
- int Tsize, outputs_bo, inputs_bo;
-
- printf("PDO mapping according to SII :\n");
-
- outputs_bo = 0;
- inputs_bo = 0;
- /* read the assign RXPDOs */
- Tsize = si_siiPDO(slave, 1, (int)(ec_slave[slave].outputs - (uint8*)&IOmap), outputs_bo );
- outputs_bo += Tsize;
- /* read the assign TXPDOs */
- Tsize = si_siiPDO(slave, 0, (int)(ec_slave[slave].inputs - (uint8*)&IOmap), inputs_bo );
- inputs_bo += Tsize;
- /* found some I/O bits ? */
- if ((outputs_bo > 0) || (inputs_bo > 0))
- retVal = 1;
- return retVal;
+ int retVal = 0;
+ int Tsize, outputs_bo, inputs_bo;
+
+ printf("PDO mapping according to SII :\n");
+
+ outputs_bo = 0;
+ inputs_bo = 0;
+ /* read the assign RXPDOs */
+ Tsize = si_siiPDO(slave, 1, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap), outputs_bo);
+ outputs_bo += Tsize;
+ /* read the assign TXPDOs */
+ Tsize = si_siiPDO(slave, 0, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap), inputs_bo);
+ inputs_bo += Tsize;
+ /* found some I/O bits ? */
+ if ((outputs_bo > 0) || (inputs_bo > 0))
+ retVal = 1;
+ return retVal;
}
void si_sdo(int cnt)
{
- int i, j;
+ int i, j;
- ODlist.Entries = 0;
- memset(&ODlist, 0, sizeof(ODlist));
- if( ec_readODlist(cnt, &ODlist))
- {
- printf(" CoE Object Description found, %d entries.\n",ODlist.Entries);
- for( i = 0 ; i < ODlist.Entries ; i++)
- {
- ec_readODdescription(i, &ODlist);
- while(EcatError) printf("%s", ec_elist2string());
- printf(" Index: %4.4x Datatype: %4.4x Objectcode: %2.2x Name: %s\n",
+ ODlist.Entries = 0;
+ memset(&ODlist, 0, sizeof(ODlist));
+ if (ec_readODlist(cnt, &ODlist))
+ {
+ printf(" CoE Object Description found, %d entries.\n", ODlist.Entries);
+ for (i = 0; i < ODlist.Entries; i++)
+ {
+ ec_readODdescription(i, &ODlist);
+ while (EcatError)
+ printf("%s", ec_elist2string());
+ printf(" Index: %4.4x Datatype: %4.4x Objectcode: %2.2x Name: %s\n",
ODlist.Index[i], ODlist.DataType[i], ODlist.ObjectCode[i], ODlist.Name[i]);
- memset(&OElist, 0, sizeof(OElist));
- ec_readOE(i, &ODlist, &OElist);
- while(EcatError) printf("%s", ec_elist2string());
- for( j = 0 ; j < ODlist.MaxSub[i]+1 ; j++)
+ memset(&OElist, 0, sizeof(OElist));
+ ec_readOE(i, &ODlist, &OElist);
+ while (EcatError)
+ printf("%s", ec_elist2string());
+ for (j = 0; j < ODlist.MaxSub[i] + 1; j++)
+ {
+ if ((OElist.DataType[j] > 0) && (OElist.BitLength[j] > 0))
{
- if ((OElist.DataType[j] > 0) && (OElist.BitLength[j] > 0))
- {
- printf(" Sub: %2.2x Datatype: %4.4x Bitlength: %4.4x Obj.access: %4.4x Name: %s\n",
- j, OElist.DataType[j], OElist.BitLength[j], OElist.ObjAccess[j], OElist.Name[j]);
- if ((OElist.ObjAccess[j] & 0x0007))
- {
- printf(" Value :%s\n", SDO2string(cnt, ODlist.Index[i], j, OElist.DataType[j]));
- }
- }
+ printf(" Sub: %2.2x Datatype: %4.4x Bitlength: %4.4x Obj.access: %4.4x Name: %s\n",
+ j, OElist.DataType[j], OElist.BitLength[j], OElist.ObjAccess[j], OElist.Name[j]);
+ if ((OElist.ObjAccess[j] & 0x0007))
+ {
+ printf(" Value :%s\n", SDO2string(cnt, ODlist.Index[i], j, OElist.DataType[j]));
+ }
}
- }
- }
- else
- {
- while(EcatError) printf("%s", ec_elist2string());
- }
+ }
+ }
+ }
+ else
+ {
+ while (EcatError)
+ printf("%s", ec_elist2string());
+ }
}
void slaveinfo(char *ifname)
{
int cnt, i, j, nSM;
- uint16 ssigen;
- int expectedWKC;
+ uint16 ssigen;
+ int expectedWKC;
printf("Starting slaveinfo\n");
/* initialise SOEM, bind socket to ifname */
if (ec_init(ifname))
{
- printf("ec_init on %s succeeded.\n",ifname);
+ printf("ec_init on %s succeeded.\n", ifname);
/* find and auto-config slaves */
- if ( ec_config(FALSE, &IOmap) > 0 )
+ if (ec_config(FALSE, &IOmap) > 0)
{
ec_configdc();
- while(EcatError) printf("%s", ec_elist2string());
- printf("%d slaves found and configured.\n",ec_slavecount);
+ while (EcatError)
+ printf("%s", ec_elist2string());
+ printf("%d slaves found and configured.\n", ec_slavecount);
expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC);
/* wait for all slaves to reach SAFE_OP state */
- ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 3);
- if (ec_slave[0].state != EC_STATE_SAFE_OP )
+ ec_statecheck(0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 3);
+ if (ec_slave[0].state != EC_STATE_SAFE_OP)
{
printf("Not all slaves reached safe operational state.\n");
ec_readstate();
- for(i = 1; i<=ec_slavecount ; i++)
+ for (i = 1; i <= ec_slavecount; i++)
{
- if(ec_slave[i].state != EC_STATE_SAFE_OP)
+ if (ec_slave[i].state != EC_STATE_SAFE_OP)
{
printf("Slave %d State=%2x StatusCode=%4x : %s\n",
- i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
+ i, ec_slave[i].state, ec_slave[i].ALstatuscode, ec_ALstatuscode2string(ec_slave[i].ALstatuscode));
}
}
}
-
ec_readstate();
- for( cnt = 1 ; cnt <= ec_slavecount ; cnt++)
+ for (cnt = 1; cnt <= ec_slavecount; cnt++)
{
printf("\nSlave:%d\n Name:%s\n Output size: %dbits\n Input size: %dbits\n State: %d\n Delay: %d[ns]\n Has DC: %d\n",
- cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
- ec_slave[cnt].state, ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
+ cnt, ec_slave[cnt].name, ec_slave[cnt].Obits, ec_slave[cnt].Ibits,
+ ec_slave[cnt].state, ec_slave[cnt].pdelay, ec_slave[cnt].hasdc);
if (ec_slave[cnt].hasdc) printf(" DCParentport:%d\n", ec_slave[cnt].parentport);
- printf(" Activeports:%d.%d.%d.%d\n", (ec_slave[cnt].activeports & 0x01) > 0 ,
- (ec_slave[cnt].activeports & 0x02) > 0 ,
- (ec_slave[cnt].activeports & 0x04) > 0 ,
- (ec_slave[cnt].activeports & 0x08) > 0 );
+ printf(" Activeports:%d.%d.%d.%d\n", (ec_slave[cnt].activeports & 0x01) > 0,
+ (ec_slave[cnt].activeports & 0x02) > 0,
+ (ec_slave[cnt].activeports & 0x04) > 0,
+ (ec_slave[cnt].activeports & 0x08) > 0);
printf(" Configured address: %4.4x\n", ec_slave[cnt].configadr);
printf(" Man: %8.8x ID: %8.8x Rev: %8.8x\n", (int)ec_slave[cnt].eep_man, (int)ec_slave[cnt].eep_id, (int)ec_slave[cnt].eep_rev);
- for(nSM = 0 ; nSM < EC_MAXSM ; nSM++)
+ for (nSM = 0; nSM < EC_MAXSM; nSM++)
{
- if(ec_slave[cnt].SM[nSM].StartAddr > 0)
- printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n",nSM, ec_slave[cnt].SM[nSM].StartAddr, ec_slave[cnt].SM[nSM].SMlength,
+ if (ec_slave[cnt].SM[nSM].StartAddr > 0)
+ printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n", nSM, ec_slave[cnt].SM[nSM].StartAddr, ec_slave[cnt].SM[nSM].SMlength,
(int)ec_slave[cnt].SM[nSM].SMflags, ec_slave[cnt].SMtype[nSM]);
}
- for(j = 0 ; j < ec_slave[cnt].FMMUunused ; j++)
+ for (j = 0; j < ec_slave[cnt].FMMUunused; j++)
{
printf(" FMMU%1d Ls:%8.8x Ll:%4d Lsb:%d Leb:%d Ps:%4.4x Psb:%d Ty:%2.2x Act:%2.2x\n", j,
- (int)ec_slave[cnt].FMMU[j].LogStart, ec_slave[cnt].FMMU[j].LogLength, ec_slave[cnt].FMMU[j].LogStartbit,
- ec_slave[cnt].FMMU[j].LogEndbit, ec_slave[cnt].FMMU[j].PhysStart, ec_slave[cnt].FMMU[j].PhysStartBit,
- ec_slave[cnt].FMMU[j].FMMUtype, ec_slave[cnt].FMMU[j].FMMUactive);
+ (int)ec_slave[cnt].FMMU[j].LogStart, ec_slave[cnt].FMMU[j].LogLength, ec_slave[cnt].FMMU[j].LogStartbit,
+ ec_slave[cnt].FMMU[j].LogEndbit, ec_slave[cnt].FMMU[j].PhysStart, ec_slave[cnt].FMMU[j].PhysStartBit,
+ ec_slave[cnt].FMMU[j].FMMUtype, ec_slave[cnt].FMMU[j].FMMUactive);
}
printf(" FMMUfunc 0:%d 1:%d 2:%d 3:%d\n",
- ec_slave[cnt].FMMU0func, ec_slave[cnt].FMMU1func, ec_slave[cnt].FMMU2func, ec_slave[cnt].FMMU3func);
+ ec_slave[cnt].FMMU0func, ec_slave[cnt].FMMU1func, ec_slave[cnt].FMMU2func, ec_slave[cnt].FMMU3func);
printf(" MBX length wr: %d rd: %d MBX protocols : %2.2x\n", ec_slave[cnt].mbx_l, ec_slave[cnt].mbx_rl, ec_slave[cnt].mbx_proto);
ssigen = ec_siifind(cnt, ECT_SII_GENERAL);
/* SII general section */
ec_slave[cnt].FoEdetails = ec_siigetbyte(cnt, ssigen + 0x08);
ec_slave[cnt].EoEdetails = ec_siigetbyte(cnt, ssigen + 0x09);
ec_slave[cnt].SoEdetails = ec_siigetbyte(cnt, ssigen + 0x0a);
- if((ec_siigetbyte(cnt, ssigen + 0x0d) & 0x02) > 0)
+ if ((ec_siigetbyte(cnt, ssigen + 0x0d) & 0x02) > 0)
{
ec_slave[cnt].blockLRW = 1;
ec_slave[0].blockLRW++;
ec_slave[0].Ebuscurrent += ec_slave[cnt].Ebuscurrent;
}
printf(" CoE details: %2.2x FoE details: %2.2x EoE details: %2.2x SoE details: %2.2x\n",
- ec_slave[cnt].CoEdetails, ec_slave[cnt].FoEdetails, ec_slave[cnt].EoEdetails, ec_slave[cnt].SoEdetails);
+ ec_slave[cnt].CoEdetails, ec_slave[cnt].FoEdetails, ec_slave[cnt].EoEdetails, ec_slave[cnt].SoEdetails);
printf(" Ebus current: %d[mA]\n only LRD/LWR:%d\n",
- ec_slave[cnt].Ebuscurrent, ec_slave[cnt].blockLRW);
+ ec_slave[cnt].Ebuscurrent, ec_slave[cnt].blockLRW);
if ((ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE) && printSDO)
- si_sdo(cnt);
- if(printMAP)
+ si_sdo(cnt);
+ if (printMAP)
{
- if (ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE)
- si_map_sdo(cnt);
- else
- si_map_sii(cnt);
+ if (ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE)
+ si_map_sdo(cnt);
+ else
+ si_map_sii(cnt);
}
}
}
}
else
{
- printf("No socket connection on %s\nExcecute as root\n",ifname);
+ printf("No socket connection on %s\nExcecute as root\n", ifname);
}
}
int main(int argc, char *argv[])
{
- ec_adaptert * adapter = NULL;
- ec_adaptert * head = NULL;
+ ec_adaptert *adapter = NULL;
+ ec_adaptert *head = NULL;
printf("SOEM (Simple Open EtherCAT Master)\nSlaveinfo\n");
if (argc > 1)
else
{
printf("Usage: slaveinfo ifname [options]\nifname = eth0 for example\nOptions :\n -sdo : print SDO info\n -map : print mapping\n");
- /* Print the list */
- printf ("Available adapters\n");
- head = adapter = ec_find_adapters ();
+ /* Print the list */
+ printf("Available adapters\n");
+ head = adapter = ec_find_adapters();
while (adapter != NULL)
{
- printf ("Description : %s, Device to use for wpcap: %s\n", adapter->desc,adapter->name);
+ printf("Description : %s, Device to use for wpcap: %s\n", adapter->desc, adapter->name);
adapter = adapter->next;
}
ec_free_adapters(head);
projects / 0xmirror / SOEM.git / commitdiff