#define ECT_MBXH_CYCLIC 1
#define ECT_MBXH_LOST 2
-/** for list of ethercat slaves detected */
+/** Slave state
+ * All slave information is put in this structure. Needed for most
+ * user interaction with slaves.
+ */
typedef struct ec_slave
{
/** state of slave */
} ec_PDOdesct;
OSAL_PACKED_END
-/** Context structure , referenced by all ecx functions*/
+/** Context structure, referenced by all ecx functions*/
struct ecx_context
{
- /** port reference, may include red_port */
- ecx_portt *port;
- /** slavelist reference */
- ec_slavet *slavelist;
+ /** @publicsection */
+ /* Network state */
+
+ /** port, may include red_port */
+ ecx_portt port;
+ /** list of detected slaves */
+ ec_slavet slavelist[EC_MAXSLAVE];
/** number of slaves found in configuration */
- int *slavecount;
- /** maximum number of slaves allowed in slavelist */
- int maxslave;
- /** grouplist reference */
- ec_groupt *grouplist;
- /** maximum number of groups allowed in grouplist */
- int maxgroup;
- /** internal, reference to eeprom cache buffer */
- uint8 *esibuf;
- /** internal, reference to eeprom cache map */
- uint32 *esimap;
+ int slavecount;
+ /** list of groups */
+ ec_groupt grouplist[EC_MAXGROUP];
+ /** ecaterror state */
+ boolean ecaterror;
+ /** last DC time from slaves */
+ int64 DCtime;
+
+ /** @privatesection */
+ /* Internal state */
+
+ /** internal, eeprom cache buffer */
+ uint8 esibuf[EC_MAXEEPBUF];
+ /** internal, eeprom cache map */
+ uint32 esimap[EC_MAXEEPBITMAP];
/** internal, current slave for eeprom cache */
uint16 esislave;
- /** internal, reference to error list */
- ec_eringt *elist;
- /** internal, reference to processdata stack buffer info */
- ec_idxstackT *idxstack;
- /** reference to ecaterror state */
- boolean *ecaterror;
- /** reference to last DC time from slaves */
- int64 *DCtime;
+ /** internal, error list */
+ ec_eringt elist;
+ /** internal, processdata stack buffer info */
+ ec_idxstackT idxstack;
/** internal, SM buffer */
- ec_SMcommtypet *SMcommtype;
+ ec_SMcommtypet SMcommtype[EC_MAX_MAPT];
/** internal, PDO assign list */
- ec_PDOassignt *PDOassign;
+ ec_PDOassignt PDOassign[EC_MAX_MAPT];
/** internal, PDO description list */
- ec_PDOdesct *PDOdesc;
+ ec_PDOdesct PDOdesc[EC_MAX_MAPT];
/** internal, SM list from eeprom */
- ec_eepromSMt *eepSM;
+ ec_eepromSMt eepSM;
/** internal, FMMU list from eeprom */
- ec_eepromFMMUt *eepFMMU;
+ ec_eepromFMMUt eepFMMU;
/** internal, mailbox pool */
- ec_mbxpoolt *mbxpool;
+ ec_mbxpoolt mbxpool;
- /* Configuration options */
+ /** @publicsection */
+ /* Configurable settings */
/** network information hook */
ec_enit *ENI;
#include "soem/soem.h"
#define EC_TIMEOUTMON 500
-
-char IOmap[4096];
-OSAL_THREAD_HANDLE threadrt, thread1;
-int expectedWKC;
-int mappingdone, dorun, inOP, dowkccheck;
-int adapterisbound, conf_io_size, currentgroup;
-int64_t cycletime = 1000000;
-#define NSEC_PER_MSEC 1000000
#define NSEC_PER_SEC 1000000000
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-static ecx_portt ecx_port;
-static ec_mbxpoolt ec_mbxpool;
+static uint8 IOmap[4096];
+static OSAL_THREAD_HANDLE threadrt, thread1;
+static int expectedWKC;
+static int mappingdone, dorun, inOP, dowkccheck;
+static int adapterisbound, conf_io_size, currentgroup;
+static int64_t cycletime = 1000000;
-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;
/* add ns to ec_timet */
void add_time_ns(ec_timet *ts, int64 addtime)
dowkccheck++;
else
dowkccheck = 0;
- if (ec_slave[0].hasdc && (wkc > 0))
+ if (ctx.slavelist[0].hasdc && (wkc > 0))
{
/* calulate toff to get linux time and DC synced */
- ec_sync(ec_DCtime, cycletime, &toff);
+ ec_sync(ctx.DCtime, cycletime, &toff);
}
ecx_mbxhandler(&ctx, 0, 4);
ecx_send_processdata(&ctx);
OSAL_THREAD_FUNC ecatcheck(void)
{
- int slave;
+ int slaveix;
while (1)
{
- if (inOP && ((dowkccheck > 2) || ec_group[currentgroup].docheckstate))
+ if (inOP && ((dowkccheck > 2) || ctx.grouplist[currentgroup].docheckstate))
{
/* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
+ ctx.grouplist[currentgroup].docheckstate = FALSE;
ecx_readstate(&ctx);
- for (slave = 1; slave <= ec_slavecount; slave++)
+ for (slaveix = 1; slaveix <= ctx.slavecount; slaveix++)
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_slavet *slave = &ctx.slavelist[slaveix];
+
+ if ((slave->group == currentgroup) && (slave->state != EC_STATE_OPERATIONAL))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
+ ctx.grouplist[currentgroup].docheckstate = TRUE;
+ if (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);
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slaveix);
+ slave->state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ else if (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);
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slaveix);
+ slave->state = EC_STATE_OPERATIONAL;
+ if (slave->mbxhandlerstate == ECT_MBXH_LOST) slave->mbxhandlerstate = ECT_MBXH_CYCLIC;
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state > EC_STATE_NONE)
+ else if (slave->state > EC_STATE_NONE)
{
- if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
+ if (ecx_reconfig_slave(&ctx, slaveix, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slaveix);
}
}
- else if (!ec_slave[slave].islost)
+ else if (!slave->islost)
{
/* re-check state */
- ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
+ ecx_statecheck(&ctx, slaveix, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (slave->state == EC_STATE_NONE)
{
- ec_slave[slave].islost = TRUE;
- ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
+ slave->islost = TRUE;
+ slave->mbxhandlerstate = ECT_MBXH_LOST;
/* zero input data for this slave */
- if (ec_slave[slave].Ibytes)
+ if (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);
+ memset(slave->inputs, 0x00, slave->Ibytes);
+ printf("zero inputs %p %d\n\r", slave->inputs, slave->Ibytes);
}
- printf("ERROR : slave %d lost\n", slave);
+ printf("ERROR : slave %d lost\n", slaveix);
}
}
}
- if (ec_slave[slave].islost)
+ if (slave->islost)
{
- if (ec_slave[slave].state <= EC_STATE_INIT)
+ if (slave->state <= EC_STATE_INIT)
{
- if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
+ if (ecx_recover_slave(&ctx, slaveix, EC_TIMEOUTMON))
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d recovered\n", slaveix);
}
}
else
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slaveix);
}
}
}
- if (!ec_group[currentgroup].docheckstate)
+ if (!ctx.grouplist[currentgroup].docheckstate)
printf("OK : all slaves resumed OPERATIONAL.\n");
dowkccheck = 0;
}
{
adapterisbound = 1;
ecx_config_init(&ctx);
- if (ec_slavecount > 0)
+ if (ctx.slavecount > 0)
{
- conf_io_size = ecx_config_map_group(&ctx, &IOmap, 0);
- expectedWKC = (ctx.grouplist[0].outputsWKC * 2) + ctx.grouplist[0].inputsWKC;
+ ec_groupt *group = &ctx.grouplist[0];
+
+ conf_io_size = ecx_config_map_group(&ctx, IOmap, 0);
+ expectedWKC = (group->outputsWKC * 2) + group->inputsWKC;
mappingdone = 1;
ecx_configdc(&ctx);
int sdoslave = -1;
- for (int si = 1; si <= *ctx.slavecount; si++)
+ for (int si = 1; si <= ctx.slavecount; si++)
{
ec_slavet *slave = &ctx.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);
int mode;
char sline[MAXSLENGTH];
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-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;
#define IHEXLENGTH 0x20
uint64 b8;
uint8 eepctl;
- if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ctx.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, 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, aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
estat = 0x0000;
aiadr = 1 - slave;
- ecx_APRD(&ctx.port[0], aiadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET); /* read eeprom status */
+ ecx_APRD(&ctx.port, aiadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET); /* read eeprom status */
estat = etohs(estat);
if (estat & EC_ESTAT_R64)
{
uint16 aiadr, *wbuf;
uint8 eepctl;
- if ((ec_slavecount >= slave) && (slave > 0) && ((start + length) <= MAXBUF))
+ if ((ctx.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, 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, aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
aiadr = 1 - slave;
wbuf = (uint16 *)&ebuf[0];
uint8 eepctl;
int ret;
- if ((ec_slavecount >= slave) && (slave > 0) && (alias <= 0xffff))
+ if ((ctx.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, 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, aiadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to master */
ret = ecx_writeeepromAP(&ctx, aiadr, 0x04, alias, EC_TIMEOUTEEP);
if (ret)
printf("ecx_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 */
+ wkc = ecx_BRD(&ctx.port, 0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE); /* detect number of slaves */
if (wkc > 0)
{
- ec_slavecount = wkc;
+ ctx.slavecount = wkc;
- printf("%d slaves found.\n", ec_slavecount);
- if ((ec_slavecount >= slave) && (slave > 0))
+ printf("%d slaves found.\n", ctx.slavecount);
+ if ((ctx.slavecount >= slave) && (slave > 0))
{
if ((mode == MODE_INFO) || (mode == MODE_READBIN) || (mode == MODE_READINTEL))
{
#define EC_TIMEOUTMON 500
-char IOmap[4096];
-OSAL_THREAD_HANDLE thread1;
-int expectedWKC;
-boolean needlf;
-volatile int wkc;
-boolean inOP;
-uint8 currentgroup = 0;
-
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-static ecx_portt ecx_port;
-static ec_mbxpoolt ec_mbxpool;
+static uint8 IOmap[4096];
+static OSAL_THREAD_HANDLE thread1;
+static int expectedWKC;
+static boolean needlf;
+static volatile int wkc;
+static boolean inOP;
+static uint8 currentgroup = 0;
extern ec_enit ec_eni;
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,
- .ENI = &ec_eni,
- .FOEhook = NULL,
- .EOEhook = NULL,
- .manualstatechange = 0,
- .userdata = NULL,
+ .ENI = &ec_eni,
};
void eni_test(char *ifname)
/* find and auto-config slaves */
if (ecx_config_init(&ctx) > 0)
{
- ecx_config_map_group(&ctx, &IOmap, 0);
+ ec_groupt *group = &ctx.grouplist[0];
+
+ ecx_config_map_group(&ctx, IOmap, 0);
ecx_configdc(&ctx);
- printf("%d slaves found and configured.\n", ec_slavecount);
+ printf("%d slaves found and configured.\n", ctx.slavecount);
/* wait for all slaves to reach SAFE_OP state */
ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
- oloop = ec_group[0].Obytes;
+ oloop = group->Obytes;
if (oloop > 8) oloop = 8;
- iloop = ec_group[0].Ibytes;
+ iloop = group->Ibytes;
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", group->nsegments, group->IOsegment[0], group->IOsegment[1], group->IOsegment[2], group->IOsegment[3]);
printf("Request operational state for all slaves\n");
- expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
+ expectedWKC = (group->outputsWKC * 2) + group->inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC);
- ec_slave[0].state = EC_STATE_OPERATIONAL;
+ ctx.slavelist[0].state = EC_STATE_OPERATIONAL;
/* send one valid process data to make outputs in slaves happy*/
ecx_send_processdata(&ctx);
ecx_receive_processdata(&ctx, EC_TIMEOUTRET);
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-- && (ctx.slavelist[0].state != EC_STATE_OPERATIONAL));
+ if (ctx.slavelist[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
inOP = TRUE;
for (j = 0; j < oloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].outputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].outputs + j));
}
printf(" I:");
for (j = 0; j < iloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].inputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].inputs + j));
}
- printf(" T:%" PRId64 "\r", ec_DCtime);
+ printf(" T:%" PRId64 "\r", ctx.DCtime);
needlf = TRUE;
}
osal_usleep(5000);
{
printf("Not all slaves reached operational state.\n");
ecx_readstate(&ctx);
- for (i = 1; i <= ec_slavecount; i++)
+ for (i = 1; i <= ctx.slavecount; i++)
{
- if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ ec_slavet *slave = &ctx.slavelist[i];
+ if (slave->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, slave->state, slave->ALstatuscode, ec_ALstatuscode2string(slave->ALstatuscode));
}
}
}
printf("\nRequest init state for all slaves\n");
- ec_slave[0].state = EC_STATE_INIT;
+ ctx.slavelist[0].state = EC_STATE_INIT;
/* request INIT state for all slaves */
ecx_writestate(&ctx, 0);
}
OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
- int slave;
+ int slaveix;
(void)ptr; /* Not used */
while (1)
{
- if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ if (inOP && ((wkc < expectedWKC) || ctx.grouplist[currentgroup].docheckstate))
{
- printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ec_group[currentgroup].docheckstate);
+ printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ctx.grouplist[currentgroup].docheckstate);
if (needlf)
{
needlf = FALSE;
printf("\n");
}
/* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
+ ctx.grouplist[currentgroup].docheckstate = FALSE;
ecx_readstate(&ctx);
- for (slave = 1; slave <= ec_slavecount; slave++)
+ for (slaveix = 1; slaveix <= ctx.slavecount; slaveix++)
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_slavet *slave = &ctx.slavelist[slaveix];
+
+ if ((slave->group == currentgroup) && (slave->state != EC_STATE_OPERATIONAL))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
+ ctx.grouplist[currentgroup].docheckstate = TRUE;
+ if (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);
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slaveix);
+ slave->state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ else if (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);
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slaveix);
+ slave->state = EC_STATE_OPERATIONAL;
+ if (slave->mbxhandlerstate == ECT_MBXH_LOST) slave->mbxhandlerstate = ECT_MBXH_CYCLIC;
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state > EC_STATE_NONE)
+ else if (slave->state > EC_STATE_NONE)
{
- if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
+ if (ecx_reconfig_slave(&ctx, slaveix, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slaveix);
}
}
- else if (!ec_slave[slave].islost)
+ else if (!slave->islost)
{
/* re-check state */
- ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
+ ecx_statecheck(&ctx, slaveix, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (slave->state == EC_STATE_NONE)
{
- ec_slave[slave].islost = TRUE;
- ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
+ slave->islost = TRUE;
+ slave->mbxhandlerstate = ECT_MBXH_LOST;
/* zero input data for this slave */
- if (ec_slave[slave].Ibytes)
+ if (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);
+ memset(slave->inputs, 0x00, slave->Ibytes);
+ printf("zero inputs %p %d\n\r", slave->inputs, slave->Ibytes);
}
- printf("ERROR : slave %d lost\n", slave);
+ printf("ERROR : slave %d lost\n", slaveix);
}
}
}
- if (ec_slave[slave].islost)
+ if (slave->islost)
{
- if (ec_slave[slave].state <= EC_STATE_INIT)
+ if (slave->state <= EC_STATE_INIT)
{
- if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
+ if (ecx_recover_slave(&ctx, slaveix, EC_TIMEOUTMON))
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d recovered\n", slaveix);
}
}
else
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slaveix);
}
}
}
- if (!ec_group[currentgroup].docheckstate)
+ if (!ctx.grouplist[currentgroup].docheckstate)
printf("OK : all slaves resumed OPERATIONAL.\n");
}
osal_usleep(10000);
#define EC_TIMEOUTMON 500
-char IOmap[4096];
-OSAL_THREAD_HANDLE thread1;
-OSAL_THREAD_HANDLE thread2;
-int expectedWKC;
-boolean needlf;
-volatile int wkc;
-boolean inOP;
-uint8 currentgroup = 0;
+static uint8 IOmap[4096];
+static OSAL_THREAD_HANDLE thread1;
+static OSAL_THREAD_HANDLE thread2;
+static int expectedWKC;
+static boolean needlf;
+static volatile int wkc;
+static boolean inOP;
+static uint8 currentgroup = 0;
#ifndef PACKET_LOG
#define PACKET_LOG 0
uint8_t rx[ETHERNET_FRAME_SIZE];
uint8_t tx[ETHERNET_FRAME_SIZE];
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-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;
/** registered EoE hook */
int eoe_hook(ecx_contextt *context, uint16 slave, void *eoembx)
/* find and auto-config slaves */
if (ecx_config_init(&ctx) > 0)
{
- ecx_config_map_group(&ctx, &IOmap, 0);
+ ec_groupt *group = &ctx.grouplist[0];
+
+ ecx_config_map_group(&ctx, IOmap, 0);
ecx_configdc(&ctx);
- for (int si = 1; si <= ec_slavecount; si++)
+ for (int si = 1; si <= ctx.slavecount; si++)
{
- if (ec_slave[si].CoEdetails > 0)
+ if (ctx.slavelist[si].CoEdetails > 0)
{
ecx_slavembxcyclic(&ctx, si);
printf(" Slave added to cyclic mailbox handler\n");
test_eoe(&ctx);
- printf("%d slaves found and configured.\n", ec_slavecount);
+ printf("%d slaves found and configured.\n", ctx.slavecount);
/* wait for all slaves to reach SAFE_OP state */
ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
- oloop = ec_group[0].Obytes;
+ oloop = group->Obytes;
if (oloop > 8) oloop = 8;
- iloop = ec_group[0].Ibytes;
+ iloop = group->Ibytes;
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", group->nsegments, group->IOsegment[0], group->IOsegment[1], group->IOsegment[2], group->IOsegment[3]);
printf("Request operational state for all slaves\n");
- expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
+ expectedWKC = (group->outputsWKC * 2) + group->inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC);
- ec_slave[0].state = EC_STATE_OPERATIONAL;
+ ctx.slavelist[0].state = EC_STATE_OPERATIONAL;
/* send one valid process data to make outputs in slaves happy*/
ecx_send_processdata(&ctx);
ecx_receive_processdata(&ctx, EC_TIMEOUTRET);
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-- && (ctx.slavelist[0].state != EC_STATE_OPERATIONAL));
+ if (ctx.slavelist[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
inOP = TRUE;
for (int j = 0; j < oloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].outputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].outputs + j));
}
printf(" I:");
for (int j = 0; j < iloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].inputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].inputs + j));
}
- printf(" T:%" PRId64 "\r", ec_DCtime);
+ printf(" T:%" PRId64 "\r", ctx.DCtime);
needlf = TRUE;
}
#endif
{
printf("Not all slaves reached operational state.\n");
ecx_readstate(&ctx);
- for (i = 1; i <= ec_slavecount; i++)
+ for (i = 1; i <= ctx.slavecount; i++)
{
- if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ if (ctx.slavelist[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, ctx.slavelist[i].state, ctx.slavelist[i].ALstatuscode, ec_ALstatuscode2string(ctx.slavelist[i].ALstatuscode));
}
}
}
printf("\nRequest init state for all slaves\n");
- ec_slave[0].state = EC_STATE_INIT;
+ ctx.slavelist[0].state = EC_STATE_INIT;
/* request INIT state for all slaves */
ecx_writestate(&ctx, 0);
}
OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
- int slave;
+ int slaveix;
(void)ptr; /* Not used */
while (1)
{
- if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ if (inOP && ((wkc < expectedWKC) || ctx.grouplist[currentgroup].docheckstate))
{
- printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ec_group[currentgroup].docheckstate);
+ printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ctx.grouplist[currentgroup].docheckstate);
if (needlf)
{
needlf = FALSE;
printf("\n");
}
/* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
+ ctx.grouplist[currentgroup].docheckstate = FALSE;
ecx_readstate(&ctx);
- for (slave = 1; slave <= ec_slavecount; slave++)
+ for (slaveix = 1; slaveix <= ctx.slavecount; slaveix++)
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_slavet *slave = &ctx.slavelist[slaveix];
+
+ if ((slave->group == currentgroup) && (slave->state != EC_STATE_OPERATIONAL))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
+ ctx.grouplist[currentgroup].docheckstate = TRUE;
+ if (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);
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slaveix);
+ slave->state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ else if (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);
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slaveix);
+ slave->state = EC_STATE_OPERATIONAL;
+ if (slave->mbxhandlerstate == ECT_MBXH_LOST) slave->mbxhandlerstate = ECT_MBXH_CYCLIC;
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state > EC_STATE_NONE)
+ else if (slave->state > EC_STATE_NONE)
{
- if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
+ if (ecx_reconfig_slave(&ctx, slaveix, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slaveix);
}
}
- else if (!ec_slave[slave].islost)
+ else if (!slave->islost)
{
/* re-check state */
- ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
+ ecx_statecheck(&ctx, slaveix, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (slave->state == EC_STATE_NONE)
{
- ec_slave[slave].islost = TRUE;
- ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
+ slave->islost = TRUE;
+ slave->mbxhandlerstate = ECT_MBXH_LOST;
/* zero input data for this slave */
- if (ec_slave[slave].Ibytes)
+ if (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);
+ memset(slave->inputs, 0x00, slave->Ibytes);
+ printf("zero inputs %p %d\n\r", slave->inputs, slave->Ibytes);
}
- printf("ERROR : slave %d lost\n", slave);
+ printf("ERROR : slave %d lost\n", slaveix);
}
}
}
- if (ec_slave[slave].islost)
+ if (slave->islost)
{
- if (ec_slave[slave].state <= EC_STATE_INIT)
+ if (slave->state <= EC_STATE_INIT)
{
- if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
+ if (ecx_recover_slave(&ctx, slaveix, EC_TIMEOUTMON))
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d recovered\n", slaveix);
}
}
else
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slaveix);
}
}
}
- if (!ec_group[currentgroup].docheckstate)
+ if (!ctx.grouplist[currentgroup].docheckstate)
printf("OK : all slaves resumed OPERATIONAL.\n");
}
osal_usleep(10000);
uint16 argslave;
boolean forceByteAlignment = FALSE;
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-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;
int input_bin(char *fname, int *length)
{
/* find and auto-config slaves */
if (ecx_config_init(&ctx) > 0)
{
- printf("%d slaves found and configured.\n", ec_slavecount);
+ printf("%d slaves found and configured.\n", ctx.slavecount);
/* wait for all slaves to reach PRE_OP state */
ecx_statecheck(&ctx, 0, EC_STATE_PRE_OP, EC_TIMEOUTSTATE * 4);
printf("Request init state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_INIT;
+ ctx.slavelist[slave].state = EC_STATE_INIT;
ecx_writestate(&ctx, slave);
/* wait for slave to reach INIT state */
/* read BOOT mailbox data, master -> slave */
data = ecx_readeeprom(&ctx, 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);
+ ctx.slavelist[slave].SM[0].StartAddr = (uint16)LO_WORD(data);
+ ctx.slavelist[slave].SM[0].SMlength = (uint16)HI_WORD(data);
/* store boot write mailbox address */
- ec_slave[slave].mbx_wo = (uint16)LO_WORD(data);
+ ctx.slavelist[slave].mbx_wo = (uint16)LO_WORD(data);
/* store boot write mailbox size */
- ec_slave[slave].mbx_l = (uint16)HI_WORD(data);
+ ctx.slavelist[slave].mbx_l = (uint16)HI_WORD(data);
/* read BOOT mailbox data, slave -> master */
data = ecx_readeeprom(&ctx, 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);
+ ctx.slavelist[slave].SM[1].StartAddr = (uint16)LO_WORD(data);
+ ctx.slavelist[slave].SM[1].SMlength = (uint16)HI_WORD(data);
/* store boot read mailbox address */
- ec_slave[slave].mbx_ro = (uint16)LO_WORD(data);
+ ctx.slavelist[slave].mbx_ro = (uint16)LO_WORD(data);
/* store boot read mailbox size */
- ec_slave[slave].mbx_rl = (uint16)HI_WORD(data);
+ ctx.slavelist[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);
+ printf(" SM0 A:%4.4x L:%4d F:%8.8x\n", ctx.slavelist[slave].SM[0].StartAddr, ctx.slavelist[slave].SM[0].SMlength,
+ (int)ctx.slavelist[slave].SM[0].SMflags);
+ printf(" SM1 A:%4.4x L:%4d F:%8.8x\n", ctx.slavelist[slave].SM[1].StartAddr, ctx.slavelist[slave].SM[1].SMlength,
+ (int)ctx.slavelist[slave].SM[1].SMflags);
/* program SM0 mailbox in for slave */
- ecx_FPWR(ctx.port, ec_slave[slave].configadr, ECT_REG_SM0, sizeof(ec_smt), &ec_slave[slave].SM[0], EC_TIMEOUTRET);
+ ecx_FPWR(&ctx.port, ctx.slavelist[slave].configadr, ECT_REG_SM0, sizeof(ec_smt), &ctx.slavelist[slave].SM[0], EC_TIMEOUTRET);
/* program SM1 mailbox out for slave */
- ecx_FPWR(ctx.port, ec_slave[slave].configadr, ECT_REG_SM1, sizeof(ec_smt), &ec_slave[slave].SM[1], EC_TIMEOUTRET);
+ ecx_FPWR(&ctx.port, ctx.slavelist[slave].configadr, ECT_REG_SM1, sizeof(ec_smt), &ctx.slavelist[slave].SM[1], EC_TIMEOUTRET);
printf("Request BOOT state for slave %d\n", slave);
- ec_slave[slave].state = EC_STATE_BOOT;
+ ctx.slavelist[slave].state = EC_STATE_BOOT;
ecx_writestate(&ctx, slave);
/* wait for slave to reach BOOT state */
j = ecx_FOEwrite(&ctx, 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;
+ ctx.slavelist[slave].state = EC_STATE_INIT;
ecx_writestate(&ctx, slave);
}
else
#include "soem/soem.h"
-#define NSEC_PER_SEC 1000000000
#define EC_TIMEOUTMON 500
+#define NSEC_PER_SEC 1000000000
+
+static uint8 IOmap[4096];
+static OSAL_THREAD_HANDLE thread1;
+static OSAL_THREAD_HANDLE thread2;
+static int expectedWKC;
+static boolean needlf;
+static volatile int wkc;
+static boolean inOP;
+static uint8 currentgroup = 0;
+static uint8 *digout = NULL;
+static int dorun = 0;
+static int64 toff, gl_delta;
-char IOmap[4096];
-OSAL_THREAD_HANDLE thread1;
-OSAL_THREAD_HANDLE thread2;
-int expectedWKC;
-boolean needlf;
-volatile int wkc;
-boolean inOP;
-uint8 currentgroup = 0;
-uint8 *digout = NULL;
-int dorun = 0;
-int64 toff, gl_delta;
-
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-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;
void redtest(char *ifname, char *ifname2)
{
/* find and auto-config slaves */
if (ecx_config_init(&ctx) > 0)
{
- ecx_config_map_group(&ctx, &IOmap, 0);
+ ec_groupt *group = &ctx.grouplist[0];
- printf("%d slaves found and configured.\n", ec_slavecount);
+ ecx_config_map_group(&ctx, IOmap, 0);
+
+ printf("%d slaves found and configured.\n", ctx.slavecount);
/* wait for all slaves to reach SAFE_OP state */
ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE);
ecx_configdc(&ctx);
- /* read indevidual slave state and store in ec_slave[] */
+ /* read indevidual slave state and store in ctx.slavelist[] */
ecx_readstate(&ctx);
- for (cnt = 1; cnt <= ec_slavecount; cnt++)
+ for (cnt = 1; cnt <= ctx.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, ctx.slavelist[cnt].name, ctx.slavelist[cnt].Obits, ctx.slavelist[cnt].Ibits,
+ ctx.slavelist[cnt].state, (int)ctx.slavelist[cnt].pdelay, ctx.slavelist[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);
+ ctx.slavelist[cnt].outputs, ctx.slavelist[cnt].Obytes, ctx.slavelist[cnt].inputs, ctx.slavelist[cnt].Ibytes);
/* check for EL2004 or EL2008 */
- if (!digout && ((ec_slave[cnt].eep_id == 0x0af83052) || (ec_slave[cnt].eep_id == 0x07d83052)))
+ if (!digout && ((ctx.slavelist[cnt].eep_id == 0x0af83052) || (ctx.slavelist[cnt].eep_id == 0x07d83052)))
{
- digout = ec_slave[cnt].outputs;
+ digout = ctx.slavelist[cnt].outputs;
}
}
- expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
+ expectedWKC = (group->outputsWKC * 2) + group->inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC);
printf("Request operational state for all slaves\n");
- ec_slave[0].state = EC_STATE_OPERATIONAL;
+ ctx.slavelist[0].state = EC_STATE_OPERATIONAL;
/* request OP state for all slaves */
ecx_writestate(&ctx, 0);
/* activate cyclic process data */
/* wait for all slaves to reach OP state */
ecx_statecheck(&ctx, 0, EC_STATE_OPERATIONAL, 5 * EC_TIMEOUTSTATE);
- oloop = ec_group[0].Obytes;
+ oloop = group->Obytes;
if (oloop > 8) oloop = 8;
- iloop = ec_group[0].Ibytes;
+ iloop = group->Ibytes;
if (iloop > 8) iloop = 8;
- if (ec_slave[0].state == EC_STATE_OPERATIONAL)
+ if (ctx.slavelist[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
inOP = TRUE;
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);
+ dorun, wkc, ctx.DCtime, gl_delta);
for (j = 0; j < oloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].outputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].outputs + j));
}
printf(" I:");
for (j = 0; j < iloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].inputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].inputs + j));
}
printf("\r");
fflush(stdout);
{
printf("Not all slaves reached operational state.\n");
ecx_readstate(&ctx);
- for (i = 1; i <= ec_slavecount; i++)
+ for (i = 1; i <= ctx.slavecount; i++)
{
- if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ ec_slavet *slave = &ctx.slavelist[i];
+ if (slave->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, slave->state, slave->ALstatuscode, ec_ALstatuscode2string(slave->ALstatuscode));
}
}
}
printf("Request safe operational state for all slaves\n");
- ec_slave[0].state = EC_STATE_SAFE_OP;
+ ctx.slavelist[0].state = EC_STATE_SAFE_OP;
/* request SAFE_OP state for all slaves */
ecx_writestate(&ctx, 0);
}
/* if we have some digital output, cycle */
if (digout) *digout = (uint8)((dorun / 16) & 0xff);
- if (ec_slave[0].hasdc)
+ if (ctx.slavelist[0].hasdc)
{
/* calulate toff to get linux time and DC synced */
- ec_sync(ec_DCtime, cycletime, &toff);
+ ec_sync(ctx.DCtime, cycletime, &toff);
}
ecx_send_processdata(&ctx);
}
OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
- int slave;
+ int slaveix;
(void)ptr; /* Not used */
while (1)
{
- if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ if (inOP && ((wkc < expectedWKC) || ctx.grouplist[currentgroup].docheckstate))
{
if (needlf)
{
printf("\n");
}
/* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
+ ctx.grouplist[currentgroup].docheckstate = FALSE;
ecx_readstate(&ctx);
- for (slave = 1; slave <= ec_slavecount; slave++)
+ for (slaveix = 1; slaveix <= ctx.slavecount; slaveix++)
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_slavet *slave = &ctx.slavelist[slaveix];
+
+ if ((slave->group == currentgroup) && (slave->state != EC_STATE_OPERATIONAL))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
+ ctx.grouplist[currentgroup].docheckstate = TRUE;
+ if (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);
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slaveix);
+ slave->state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ else if (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);
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slaveix);
+ slave->state = EC_STATE_OPERATIONAL;
+ if (slave->mbxhandlerstate == ECT_MBXH_LOST) slave->mbxhandlerstate = ECT_MBXH_CYCLIC;
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state > EC_STATE_NONE)
+ else if (slave->state > EC_STATE_NONE)
{
- if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
+ if (ecx_reconfig_slave(&ctx, slaveix, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slaveix);
}
}
- else if (!ec_slave[slave].islost)
+ else if (!slave->islost)
{
/* re-check state */
- ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
+ ecx_statecheck(&ctx, slaveix, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (slave->state == EC_STATE_NONE)
{
- ec_slave[slave].islost = TRUE;
- ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
+ slave->islost = TRUE;
+ slave->mbxhandlerstate = ECT_MBXH_LOST;
/* zero input data for this slave */
- if (ec_slave[slave].Ibytes)
+ if (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);
+ memset(slave->inputs, 0x00, slave->Ibytes);
+ printf("zero inputs %p %d\n\r", slave->inputs, slave->Ibytes);
}
- printf("ERROR : slave %d lost\n", slave);
+ printf("ERROR : slave %d lost\n", slaveix);
}
}
}
- if (ec_slave[slave].islost)
+ if (slave->islost)
{
- if (ec_slave[slave].state <= EC_STATE_INIT)
+ if (slave->state <= EC_STATE_INIT)
{
- if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
+ if (ecx_recover_slave(&ctx, slaveix, EC_TIMEOUTMON))
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d recovered\n", slaveix);
}
}
else
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slaveix);
}
}
}
- if (!ec_group[currentgroup].docheckstate)
+ if (!ctx.grouplist[currentgroup].docheckstate)
printf("OK : all slaves resumed OPERATIONAL.\n");
}
osal_usleep(10000);
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;
- ec_mbxpoolt mbxpool;
} 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->mbxpool = &fieldbus->mbxpool;
- context->FOEhook = NULL;
- context->EOEhook = NULL;
- context->manualstatechange = 0;
}
static int
int i;
context = &fieldbus->context;
- grp = fieldbus->grouplist + fieldbus->group;
+ grp = context->grouplist + fieldbus->group;
printf("Initializing SOEM on '%s'... ", fieldbus->iface);
if (!ecx_init(context, fieldbus->iface))
printf("no slaves found\n");
return FALSE;
}
- printf("%d slaves found\n", fieldbus->slavecount);
+ printf("%d slaves found\n", context->slavecount);
printf("Sequential mapping of I/O... ");
ecx_config_map_group(context, fieldbus->map, fieldbus->group);
printf("Setting operational state..");
/* Act on slave 0 (a virtual slave used for broadcasting) */
- slave = fieldbus->slavelist;
+ slave = context->slavelist;
slave->state = EC_STATE_OPERATIONAL;
ecx_writestate(context, 0);
/* Poll the result ten times before giving up */
printf(" failed,");
ecx_readstate(context);
- for (i = 1; i <= fieldbus->slavecount; ++i)
+ for (i = 1; i <= context->slavecount; ++i)
{
- slave = fieldbus->slavelist + i;
+ slave = context->slavelist + i;
if (slave->state != EC_STATE_OPERATIONAL)
{
printf(" slave %d is 0x%04X (AL-status=0x%04X %s)",
context = &fieldbus->context;
/* Act on slave 0 (a virtual slave used for broadcasting) */
- slave = fieldbus->slavelist;
+ slave = context->slavelist;
printf("Requesting init state on all slaves... ");
slave->state = EC_STATE_INIT;
static boolean
fieldbus_dump(Fieldbus *fieldbus)
{
+ ecx_contextt *context;
ec_groupt *grp;
uint32 n;
int wkc, expected_wkc;
- grp = fieldbus->grouplist + fieldbus->group;
+ context = &fieldbus->context;
+ grp = context->grouplist + fieldbus->group;
wkc = fieldbus_roundtrip(fieldbus);
expected_wkc = grp->outputsWKC * 2 + grp->inputsWKC;
{
printf(" %02X", grp->inputs[n]);
}
- printf(" T: %lld\r", (long long)fieldbus->DCtime);
+ printf(" T: %lld\r", (long long)context->DCtime);
return TRUE;
}
grp = context->grouplist + fieldbus->group;
grp->docheckstate = FALSE;
ecx_readstate(context);
- for (i = 1; i <= fieldbus->slavecount; ++i)
+ for (i = 1; i <= context->slavecount; ++i)
{
slave = context->slavelist + i;
if (slave->group != fieldbus->group)
#define EC_TIMEOUTMON 500
-char IOmap[4096];
-OSAL_THREAD_HANDLE thread1;
-int expectedWKC;
-boolean needlf;
-volatile int wkc;
-boolean inOP;
-uint8 currentgroup = 0;
+static uint8 IOmap[4096];
+static OSAL_THREAD_HANDLE thread1;
+static int expectedWKC;
+static boolean needlf;
+static volatile int wkc;
+static boolean inOP;
+static uint8 currentgroup = 0;
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-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;
void simpletest(char *ifname)
{
/* find and auto-config slaves */
if (ecx_config_init(&ctx) > 0)
{
- ecx_config_map_group(&ctx, &IOmap, 0);
+ ec_groupt *group = &ctx.grouplist[0];
+
+ ecx_config_map_group(&ctx, IOmap, 0);
ecx_configdc(&ctx);
- printf("%d slaves found and configured.\n", ec_slavecount);
+ printf("%d slaves found and configured.\n", ctx.slavecount);
/* wait for all slaves to reach SAFE_OP state */
ecx_statecheck(&ctx, 0, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4);
- oloop = ec_group[0].Obytes;
+ oloop = group->Obytes;
if (oloop > 8) oloop = 8;
- iloop = ec_group[0].Ibytes;
+ iloop = group->Ibytes;
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", group->nsegments, group->IOsegment[0], group->IOsegment[1], group->IOsegment[2], group->IOsegment[3]);
printf("Request operational state for all slaves\n");
- expectedWKC = (ec_group[0].outputsWKC * 2) + ec_group[0].inputsWKC;
+ expectedWKC = (group->outputsWKC * 2) + group->inputsWKC;
printf("Calculated workcounter %d\n", expectedWKC);
- ec_slave[0].state = EC_STATE_OPERATIONAL;
+ ctx.slavelist[0].state = EC_STATE_OPERATIONAL;
/* send one valid process data to make outputs in slaves happy*/
ecx_send_processdata(&ctx);
ecx_receive_processdata(&ctx, EC_TIMEOUTRET);
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-- && (ctx.slavelist[0].state != EC_STATE_OPERATIONAL));
+ if (ctx.slavelist[0].state == EC_STATE_OPERATIONAL)
{
printf("Operational state reached for all slaves.\n");
inOP = TRUE;
for (j = 0; j < oloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].outputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].outputs + j));
}
printf(" I:");
for (j = 0; j < iloop; j++)
{
- printf(" %2.2x", *(ec_slave[0].inputs + j));
+ printf(" %2.2x", *(ctx.slavelist[0].inputs + j));
}
- printf(" T:%" PRId64 "\r", ec_DCtime);
+ printf(" T:%" PRId64 "\r", ctx.DCtime);
needlf = TRUE;
}
osal_usleep(5000);
{
printf("Not all slaves reached operational state.\n");
ecx_readstate(&ctx);
- for (i = 1; i <= ec_slavecount; i++)
+ for (i = 1; i <= ctx.slavecount; i++)
{
- if (ec_slave[i].state != EC_STATE_OPERATIONAL)
+ ec_slavet *slave = &ctx.slavelist[i];
+ if (slave->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, slave->state, slave->ALstatuscode, ec_ALstatuscode2string(slave->ALstatuscode));
}
}
}
printf("\nRequest init state for all slaves\n");
- ec_slave[0].state = EC_STATE_INIT;
+ ctx.slavelist[0].state = EC_STATE_INIT;
/* request INIT state for all slaves */
ecx_writestate(&ctx, 0);
}
OSAL_THREAD_FUNC ecatcheck(void *ptr)
{
- int slave;
+ int slaveix;
(void)ptr; /* Not used */
while (1)
{
- if (inOP && ((wkc < expectedWKC) || ec_group[currentgroup].docheckstate))
+ if (inOP && ((wkc < expectedWKC) || ctx.grouplist[currentgroup].docheckstate))
{
- printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ec_group[currentgroup].docheckstate);
+ printf("check wkc=%d/%d docheckstate=%d!\n", wkc, expectedWKC, ctx.grouplist[currentgroup].docheckstate);
if (needlf)
{
needlf = FALSE;
printf("\n");
}
/* one ore more slaves are not responding */
- ec_group[currentgroup].docheckstate = FALSE;
+ ctx.grouplist[currentgroup].docheckstate = FALSE;
ecx_readstate(&ctx);
- for (slave = 1; slave <= ec_slavecount; slave++)
+ for (slaveix = 1; slaveix <= ctx.slavecount; slaveix++)
{
- if ((ec_slave[slave].group == currentgroup) && (ec_slave[slave].state != EC_STATE_OPERATIONAL))
+ ec_slavet *slave = &ctx.slavelist[slaveix];
+
+ if ((slave->group == currentgroup) && (slave->state != EC_STATE_OPERATIONAL))
{
- ec_group[currentgroup].docheckstate = TRUE;
- if (ec_slave[slave].state == (EC_STATE_SAFE_OP + EC_STATE_ERROR))
+ ctx.grouplist[currentgroup].docheckstate = TRUE;
+ if (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);
+ printf("ERROR : slave %d is in SAFE_OP + ERROR, attempting ack.\n", slaveix);
+ slave->state = (EC_STATE_SAFE_OP + EC_STATE_ACK);
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state == EC_STATE_SAFE_OP)
+ else if (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);
+ printf("WARNING : slave %d is in SAFE_OP, change to OPERATIONAL.\n", slaveix);
+ slave->state = EC_STATE_OPERATIONAL;
+ if (slave->mbxhandlerstate == ECT_MBXH_LOST) slave->mbxhandlerstate = ECT_MBXH_CYCLIC;
+ ecx_writestate(&ctx, slaveix);
}
- else if (ec_slave[slave].state > EC_STATE_NONE)
+ else if (slave->state > EC_STATE_NONE)
{
- if (ecx_reconfig_slave(&ctx, slave, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
+ if (ecx_reconfig_slave(&ctx, slaveix, EC_TIMEOUTMON) >= EC_STATE_PRE_OP)
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d reconfigured\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d reconfigured\n", slaveix);
}
}
- else if (!ec_slave[slave].islost)
+ else if (!slave->islost)
{
/* re-check state */
- ecx_statecheck(&ctx, slave, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
- if (ec_slave[slave].state == EC_STATE_NONE)
+ ecx_statecheck(&ctx, slaveix, EC_STATE_OPERATIONAL, EC_TIMEOUTRET);
+ if (slave->state == EC_STATE_NONE)
{
- ec_slave[slave].islost = TRUE;
- ec_slave[slave].mbxhandlerstate = ECT_MBXH_LOST;
+ slave->islost = TRUE;
+ slave->mbxhandlerstate = ECT_MBXH_LOST;
/* zero input data for this slave */
- if (ec_slave[slave].Ibytes)
+ if (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);
+ memset(slave->inputs, 0x00, slave->Ibytes);
+ printf("zero inputs %p %d\n\r", slave->inputs, slave->Ibytes);
}
- printf("ERROR : slave %d lost\n", slave);
+ printf("ERROR : slave %d lost\n", slaveix);
}
}
}
- if (ec_slave[slave].islost)
+ if (slave->islost)
{
- if (ec_slave[slave].state <= EC_STATE_INIT)
+ if (slave->state <= EC_STATE_INIT)
{
- if (ecx_recover_slave(&ctx, slave, EC_TIMEOUTMON))
+ if (ecx_recover_slave(&ctx, slaveix, EC_TIMEOUTMON))
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d recovered\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d recovered\n", slaveix);
}
}
else
{
- ec_slave[slave].islost = FALSE;
- printf("MESSAGE : slave %d found\n", slave);
+ slave->islost = FALSE;
+ printf("MESSAGE : slave %d found\n", slaveix);
}
}
}
- if (!ec_group[currentgroup].docheckstate)
+ if (!ctx.grouplist[currentgroup].docheckstate)
printf("OK : all slaves resumed OPERATIONAL.\n");
}
osal_usleep(10000);
#include "soem/soem.h"
-static char IOmap[4096];
+static uint8 IOmap[4096];
static ec_ODlistt ODlist;
static ec_OElistt OElist;
static boolean printSDO = FALSE;
static boolean printMAP = FALSE;
static char usdo[128];
-static ec_slavet ec_slave[EC_MAXSLAVE];
-static int ec_slavecount;
-static ec_groupt ec_group[EC_MAXGROUP];
-static uint8 ec_esibuf[EC_MAXEEPBUF];
-static uint32 ec_esimap[EC_MAXEEPBITMAP];
-static ec_eringt ec_elist;
-static ec_idxstackT ec_idxstack;
-static ec_SMcommtypet ec_SMcommtype[EC_MAX_MAPT];
-static ec_PDOassignt ec_PDOassign[EC_MAX_MAPT];
-static ec_PDOdesct ec_PDOdesc[EC_MAX_MAPT];
-static ec_eepromSMt ec_SM;
-static ec_eepromFMMUt ec_FMMU;
-static boolean EcatError = FALSE;
-static int64 ec_DCtime;
-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;
#define OTYPE_VAR 0x0007
#define OTYPE_ARRAY 0x0008
memset(&usdo, 0, sizeof(usdo));
ecx_SDOread(&ctx, slave, index, subidx, FALSE, &l, &usdo, EC_TIMEOUTRXM);
- if (EcatError)
+ if (ctx.ecaterror)
{
return ecx_elist2string(&ctx);
}
{
/* 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);
+ Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ctx.slavelist[slave].outputs - IOmap), 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);
+
+ Tsize = si_PDOassign(slave, ECT_SDO_PDOASSIGN + iSM, (int)(ctx.slavelist[slave].inputs - IOmap), inputs_bo);
inputs_bo += Tsize;
}
}
int abs_offset, abs_bit;
char str_name[EC_MAXNAME + 1];
- eectl = ec_slave[slave].eep_pdi;
+ eectl = ctx.slavelist[slave].eep_pdi;
totalsize = 0;
PDO = &eepPDO;
outputs_bo = 0;
inputs_bo = 0;
/* read the assign RXPDOs */
- Tsize = si_siiPDO(slave, 1, (int)(ec_slave[slave].outputs - (uint8 *)&IOmap), outputs_bo);
+ Tsize = si_siiPDO(slave, 1, (int)(ctx.slavelist[slave].outputs - IOmap), outputs_bo);
outputs_bo += Tsize;
/* read the assign TXPDOs */
- Tsize = si_siiPDO(slave, 0, (int)(ec_slave[slave].inputs - (uint8 *)&IOmap), inputs_bo);
+ Tsize = si_siiPDO(slave, 0, (int)(ctx.slavelist[slave].inputs - IOmap), inputs_bo);
inputs_bo += Tsize;
/* found some I/O bits ? */
if ((outputs_bo > 0) || (inputs_bo > 0))
char name[128] = {0};
ecx_readODdescription(&ctx, i, &ODlist);
- while (EcatError)
+ while (ctx.ecaterror)
printf(" - %s\n", ecx_elist2string(&ctx));
snprintf(name, sizeof(name) - 1, "\"%s\"", ODlist.Name[i]);
if (ODlist.ObjectCode[i] == OTYPE_VAR)
}
memset(&OElist, 0, sizeof(OElist));
ecx_readOE(&ctx, i, &ODlist, &OElist);
- while (EcatError)
+ while (ctx.ecaterror)
printf("- %s\n", ecx_elist2string(&ctx));
if (ODlist.ObjectCode[i] != OTYPE_VAR)
}
else
{
- while (EcatError)
+ while (ctx.ecaterror)
printf("%s", ecx_elist2string(&ctx));
}
}
/* find and auto-config slaves */
if (ecx_config_init(&ctx) > 0)
{
- ecx_config_map_group(&ctx, &IOmap, 0);
+ ec_groupt *group = &ctx.grouplist[0];
+
+ ecx_config_map_group(&ctx, IOmap, 0);
ecx_configdc(&ctx);
- while (EcatError)
+ while (ctx.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("%d slaves found and configured.\n", ctx.slavecount);
+ expectedWKC = (group->outputsWKC * 2) + group->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)
+ if (ctx.slavelist[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 <= ctx.slavecount; i++)
{
- if (ec_slave[i].state != EC_STATE_SAFE_OP)
+ if (ctx.slavelist[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, ctx.slavelist[i].state, ctx.slavelist[i].ALstatuscode, ec_ALstatuscode2string(ctx.slavelist[i].ALstatuscode));
}
}
}
ecx_readstate(&ctx);
- for (cnt = 1; cnt <= ec_slavecount; cnt++)
+ for (cnt = 1; cnt <= ctx.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);
- 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(" 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);
+ cnt, ctx.slavelist[cnt].name, ctx.slavelist[cnt].Obits, ctx.slavelist[cnt].Ibits,
+ ctx.slavelist[cnt].state, ctx.slavelist[cnt].pdelay, ctx.slavelist[cnt].hasdc);
+ if (ctx.slavelist[cnt].hasdc) printf(" DCParentport:%d\n", ctx.slavelist[cnt].parentport);
+ printf(" Activeports:%d.%d.%d.%d\n", (ctx.slavelist[cnt].activeports & 0x01) > 0,
+ (ctx.slavelist[cnt].activeports & 0x02) > 0,
+ (ctx.slavelist[cnt].activeports & 0x04) > 0,
+ (ctx.slavelist[cnt].activeports & 0x08) > 0);
+ printf(" Configured address: %4.4x\n", ctx.slavelist[cnt].configadr);
+ printf(" Man: %8.8x ID: %8.8x Rev: %8.8x\n", (int)ctx.slavelist[cnt].eep_man, (int)ctx.slavelist[cnt].eep_id, (int)ctx.slavelist[cnt].eep_rev);
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),
- etohl(ec_slave[cnt].SM[nSM].SMflags), ec_slave[cnt].SMtype[nSM]);
+ if (ctx.slavelist[cnt].SM[nSM].StartAddr > 0)
+ printf(" SM%1d A:%4.4x L:%4d F:%8.8x Type:%d\n", nSM, etohs(ctx.slavelist[cnt].SM[nSM].StartAddr), etohs(ctx.slavelist[cnt].SM[nSM].SMlength),
+ etohl(ctx.slavelist[cnt].SM[nSM].SMflags), ctx.slavelist[cnt].SMtype[nSM]);
}
- for (j = 0; j < ec_slave[cnt].FMMUunused; j++)
+ for (j = 0; j < ctx.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,
- 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(ctx.slavelist[cnt].FMMU[j].LogStart), etohs(ctx.slavelist[cnt].FMMU[j].LogLength), ctx.slavelist[cnt].FMMU[j].LogStartbit,
+ ctx.slavelist[cnt].FMMU[j].LogEndbit, etohs(ctx.slavelist[cnt].FMMU[j].PhysStart), ctx.slavelist[cnt].FMMU[j].PhysStartBit,
+ ctx.slavelist[cnt].FMMU[j].FMMUtype, ctx.slavelist[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);
- 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);
+ ctx.slavelist[cnt].FMMU0func, ctx.slavelist[cnt].FMMU1func, ctx.slavelist[cnt].FMMU2func, ctx.slavelist[cnt].FMMU3func);
+ printf(" MBX length wr: %d rd: %d MBX protocols : %2.2x\n", ctx.slavelist[cnt].mbx_l, ctx.slavelist[cnt].mbx_rl, ctx.slavelist[cnt].mbx_proto);
ssigen = ecx_siifind(&ctx, cnt, ECT_SII_GENERAL);
/* SII general section */
if (ssigen)
{
- ec_slave[cnt].CoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x07);
- 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);
+ ctx.slavelist[cnt].CoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x07);
+ ctx.slavelist[cnt].FoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x08);
+ ctx.slavelist[cnt].EoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x09);
+ ctx.slavelist[cnt].SoEdetails = ecx_siigetbyte(&ctx, cnt, ssigen + 0x0a);
if ((ecx_siigetbyte(&ctx, cnt, ssigen + 0x0d) & 0x02) > 0)
{
- ec_slave[cnt].blockLRW = 1;
- ec_slave[0].blockLRW++;
+ ctx.slavelist[cnt].blockLRW = 1;
+ ctx.slavelist[0].blockLRW++;
}
- ec_slave[cnt].Ebuscurrent = ecx_siigetbyte(&ctx, cnt, ssigen + 0x0e);
- ec_slave[cnt].Ebuscurrent += ecx_siigetbyte(&ctx, cnt, ssigen + 0x0f) << 8;
- ec_slave[0].Ebuscurrent += ec_slave[cnt].Ebuscurrent;
+ ctx.slavelist[cnt].Ebuscurrent = ecx_siigetbyte(&ctx, cnt, ssigen + 0x0e);
+ ctx.slavelist[cnt].Ebuscurrent += ecx_siigetbyte(&ctx, cnt, ssigen + 0x0f) << 8;
+ ctx.slavelist[0].Ebuscurrent += ctx.slavelist[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);
+ ctx.slavelist[cnt].CoEdetails, ctx.slavelist[cnt].FoEdetails, ctx.slavelist[cnt].EoEdetails, ctx.slavelist[cnt].SoEdetails);
printf(" Ebus current: %d[mA]\n only LRD/LWR:%d\n",
- ec_slave[cnt].Ebuscurrent, ec_slave[cnt].blockLRW);
- if ((ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE) && printSDO)
+ ctx.slavelist[cnt].Ebuscurrent, ctx.slavelist[cnt].blockLRW);
+ if ((ctx.slavelist[cnt].mbx_proto & ECT_MBXPROT_COE) && printSDO)
si_sdo(cnt);
if (printMAP)
{
- if (ec_slave[cnt].mbx_proto & ECT_MBXPROT_COE)
+ if (ctx.slavelist[cnt].mbx_proto & ECT_MBXPROT_COE)
si_map_sdo(cnt);
else
si_map_sii(cnt);
Ec.Slave = Slave;
Ec.Index = Index;
Ec.SubIdx = SubIdx;
- *(context->ecaterror) = TRUE;
+ context->ecaterror = TRUE;
Ec.Etype = EC_ERR_TYPE_SDO_ERROR;
Ec.AbortCode = AbortCode;
ecx_pusherror(context, &Ec);
Ec.Slave = Slave;
Ec.Index = Index;
Ec.SubIdx = SubIdx;
- *(context->ecaterror) = TRUE;
+ context->ecaterror = TRUE;
Ec.Etype = EC_ERR_TYPE_SDOINFO_ERROR;
Ec.AbortCode = AbortCode;
ecx_pusherror(context, &Ec);
void ecx_init_context(ecx_contextt *context)
{
int lp;
- *(context->slavecount) = 0;
+ context->slavecount = 0;
/* clean ec_slave array */
- memset(context->slavelist, 0x00, sizeof(ec_slavet) * context->maxslave);
- memset(context->grouplist, 0x00, sizeof(ec_groupt) * context->maxgroup);
+ memset(context->slavelist, 0x00, sizeof(context->slavelist));
+ memset(context->grouplist, 0x00, sizeof(context->grouplist));
/* 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 < EC_MAXGROUP; lp++)
{
/* default start address per group entry */
context->grouplist[lp].logstartaddr = lp << EC_LOGGROUPOFFSET;
/* 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" */
- if (wkc < context->maxslave)
+ if (wkc < EC_MAXSLAVE)
{
- *(context->slavecount) = wkc;
+ context->slavecount = wkc;
}
else
{
EC_PRINT("Error: too many slaves on network: num_slaves=%d, max_slaves=%d\n",
- wkc, context->maxslave);
+ wkc, EC_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 */
}
/* If slave has SII and same slave ID done before, use previous data.
static int ecx_lookup_prev_sii(ecx_contextt *context, uint16 slave)
{
int i, nSM;
- if ((slave > 1) && (*(context->slavecount) > 0))
+ if ((slave > 1) && (context->slavecount > 0))
{
i = 1;
while (((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
if (wkc > 0)
{
ecx_set_slaves_to_default(context);
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
ADPh = (uint16)(1 - slave);
- val16 = ecx_APRDw(context->port, ADPh, ECT_REG_PDICTL, EC_TIMEOUTRET3); /* read interface type of slave */
+ val16 = ecx_APRDw(&context->port, ADPh, ECT_REG_PDICTL, EC_TIMEOUTRET3); /* read interface type of slave */
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 */
{
b = 0; /* pass all frames for following slaves */
}
- ecx_APWRw(context->port, ADPh, ECT_REG_DLCTL, htoes(b), EC_TIMEOUTRET3); /* set non ecat frame behaviour */
- configadr = ecx_APRDw(context->port, ADPh, ECT_REG_STADR, EC_TIMEOUTRET3);
+ ecx_APWRw(&context->port, ADPh, ECT_REG_DLCTL, htoes(b), EC_TIMEOUTRET3); /* set non ecat frame behaviour */
+ configadr = ecx_APRDw(&context->port, ADPh, ECT_REG_STADR, EC_TIMEOUTRET3);
configadr = etohs(configadr);
context->slavelist[slave].configadr = configadr;
- ecx_FPRD(context->port, configadr, ECT_REG_ALIAS, sizeof(aliasadr), &aliasadr, EC_TIMEOUTRET3);
+ ecx_FPRD(&context->port, configadr, ECT_REG_ALIAS, sizeof(aliasadr), &aliasadr, EC_TIMEOUTRET3);
context->slavelist[slave].aliasadr = etohs(aliasadr);
- ecx_FPRD(context->port, configadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET3);
+ ecx_FPRD(&context->port, configadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET3);
estat = etohs(estat);
if (estat & EC_ESTAT_R64) /* check if slave can read 8 byte chunks */
{
}
ecx_readeeprom1(context, slave, ECT_SII_MANUF); /* Manuf */
}
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* Manuf */
context->slavelist[slave].eep_man = etohl(eedat);
ecx_readeeprom1(context, slave, ECT_SII_ID); /* ID */
}
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* ID */
context->slavelist[slave].eep_id = etohl(eedat);
ecx_readeeprom1(context, slave, ECT_SII_REV); /* revision */
}
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* revision */
context->slavelist[slave].eep_rev = etohl(eedat);
ecx_readeeprom1(context, slave, ECT_SII_SER); /* serial number */
}
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* serial number */
context->slavelist[slave].eep_ser = etohl(eedat);
ecx_readeeprom1(context, slave, ECT_SII_RXMBXADR); /* write mailbox address + mailboxsize */
}
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* write mailbox address and mailboxsize */
context->slavelist[slave].mbx_wo = (uint16)LO_WORD(etohl(eedat));
ecx_readeeprom1(context, slave, ECT_SII_TXMBXADR); /* read mailbox offset */
}
}
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
if (context->slavelist[slave].mbx_l > 0)
{
ecx_readeeprom1(context, slave, ECT_SII_MBXPROTO);
}
configadr = context->slavelist[slave].configadr;
- val16 = ecx_FPRDw(context->port, configadr, ECT_REG_ESCSUP, EC_TIMEOUTRET3);
+ val16 = ecx_FPRDw(&context->port, configadr, ECT_REG_ESCSUP, EC_TIMEOUTRET3);
if ((etohs(val16) & 0x04) > 0) /* Support DC? */
{
context->slavelist[slave].hasdc = TRUE;
{
context->slavelist[slave].hasdc = FALSE;
}
- topology = ecx_FPRDw(context->port, configadr, ECT_REG_DLSTAT, EC_TIMEOUTRET3); /* extract topology from DL status */
+ topology = ecx_FPRDw(&context->port, configadr, ECT_REG_DLSTAT, EC_TIMEOUTRET3); /* extract topology from DL status */
topology = etohs(topology);
h = 0;
b = 0;
b |= 0x08;
}
/* ptype = Physical type*/
- val16 = ecx_FPRDw(context->port, configadr, ECT_REG_PORTDES, EC_TIMEOUTRET3);
+ val16 = ecx_FPRDw(&context->port, configadr, ECT_REG_PORTDES, EC_TIMEOUTRET3);
context->slavelist[slave].ptype = LO_BYTE(etohs(val16));
context->slavelist[slave].topology = h;
context->slavelist[slave].activeports = b;
(unsigned int)context->slavelist[slave].eep_id);
}
/* SII SM section */
- nSM = ecx_siiSM(context, slave, context->eepSM);
+ nSM = ecx_siiSM(context, slave, &context->eepSM);
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].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].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 (ecx_siiFMMU(context, slave, &context->eepFMMU))
{
- if (context->eepFMMU->FMMU0 != 0xff)
+ if (context->eepFMMU.FMMU0 != 0xff)
{
- context->slavelist[slave].FMMU0func = context->eepFMMU->FMMU0;
+ context->slavelist[slave].FMMU0func = context->eepFMMU.FMMU0;
}
- if (context->eepFMMU->FMMU1 != 0xff)
+ if (context->eepFMMU.FMMU1 != 0xff)
{
- context->slavelist[slave].FMMU1func = context->eepFMMU->FMMU1;
+ context->slavelist[slave].FMMU1func = context->eepFMMU.FMMU1;
}
- if (context->eepFMMU->FMMU2 != 0xff)
+ if (context->eepFMMU.FMMU2 != 0xff)
{
- context->slavelist[slave].FMMU2func = context->eepFMMU->FMMU2;
+ context->slavelist[slave].FMMU2func = context->eepFMMU.FMMU2;
}
- if (context->eepFMMU->FMMU3 != 0xff)
+ if (context->eepFMMU.FMMU3 != 0xff)
{
- context->slavelist[slave].FMMU3func = context->eepFMMU->FMMU3;
+ 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,
+ ecx_FPWR(&context->port, configadr, ECT_REG_SM0, sizeof(ec_smt) * 2,
&(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
}
/* some slaves need eeprom available to PDI in init->preop transition */
if (context->manualstatechange == 0)
{
/* request pre_op for slave */
- ecx_FPWRw(context->port,
+ ecx_FPWRw(&context->port,
configadr,
ECT_REG_ALCTL,
htoes(EC_STATE_PRE_OP | EC_STATE_ACK),
static int ecx_lookup_mapping(ecx_contextt *context, uint16 slave, uint32 *Osize, uint32 *Isize)
{
int i, nSM;
- if ((slave > 1) && (*(context->slavecount) > 0))
+ if ((slave > 1) && (context->slavecount > 0))
{
i = 1;
while (((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
EC_PRINT(" SM programming\n");
if (!context->slavelist[slave].mbx_l && context->slavelist[slave].SM[0].StartAddr)
{
- ecx_FPWR(context->port, configadr, ECT_REG_SM0,
+ ecx_FPWR(&context->port, configadr, ECT_REG_SM0,
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],
}
if (!context->slavelist[slave].mbx_l && context->slavelist[slave].SM[1].StartAddr)
{
- ecx_FPWR(context->port, configadr, ECT_REG_SM1,
+ ecx_FPWR(&context->port, configadr, ECT_REG_SM1,
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],
context->slavelist[slave].SM[nSM].SMflags =
htoel(etohl(context->slavelist[slave].SM[nSM].SMflags) | ~EC_SMENABLEMASK);
}
- ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt))),
+ ecx_FPWR(&context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt))),
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],
ecx_mapt[thrn].running = 0;
}
/* find CoE and SoE mapping of slaves in multiple threads */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
if (!group || (group == context->slavelist[slave].group))
{
}
} while (thrc);
/* find SII mapping of slave and program SM */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
if (!group || (group == context->slavelist[slave].group))
{
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),
+ ecx_FPWR(&context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
}
if (!context->slavelist[slave].inputs)
context->slavelist[slave].FMMU[FMMUc].FMMUtype = 2;
context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
/* program FMMU for output */
- ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
+ ecx_FPWR(&context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
}
if (!context->slavelist[slave].outputs)
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),
+ ecx_FPWR(&context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
position = etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
uint32 segmentsize = 0;
uint32 segmentmaxsize = (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM); /* first segment must account for DC overhead */
- if ((*(context->slavecount) > 0) && (group < context->maxgroup))
+ if ((context->slavecount > 0) && (group < EC_MAXGROUP))
{
EC_PRINT("ec_config_map_group IOmap:%p group:%d\n", pIOmap, group);
LogAddr = context->grouplist[group].logstartaddr;
ecx_config_find_mappings(context, group);
/* do output mapping of slave and program FMMUs */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
}
/* do input mapping of slave and program FMMUs */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
if (!group || (group == context->slavelist[slave].group))
context->grouplist[group].Obytes;
/* do mbxstatus mapping of slave and program FMMUs */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
if (!group || (group == context->slavelist[slave].group))
}
/* Do post mapping actions */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
if (!group || (group == context->slavelist[slave].group))
if (context->manualstatechange == 0)
{
/* request safe_op for slave */
- ecx_FPWRw(context->port,
+ ecx_FPWRw(&context->port,
configadr,
ECT_REG_ALCTL,
htoes(EC_STATE_SAFE_OP),
uint32 segmentsize = 0;
uint32 segmentmaxsize = (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM);
- if ((*(context->slavecount) > 0) && (group < context->maxgroup))
+ if ((context->slavecount > 0) && (group < EC_MAXGROUP))
{
EC_PRINT("ec_config_map_group IOmap:%p group:%d\n", pIOmap, group);
mLogAddr = context->grouplist[group].logstartaddr;
ecx_config_find_mappings(context, group);
/* do IO mapping of slave and program FMMUs */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
siLogAddr = soLogAddr = mLogAddr;
context->grouplist[group].mbxstatus = (uint8 *)pIOmap + context->grouplist[group].Obytes + context->grouplist[group].Ibytes;
/* Move calculated inputs with OBytes offset */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
if (!group || (group == context->slavelist[slave].group))
{
}
/* Do mbxstatus mapping of slave and program FMMUs */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
if (!group || (group == context->slavelist[slave].group))
}
/* Do post mapping actions */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
configadr = context->slavelist[slave].configadr;
if (!group || (group == context->slavelist[slave].group))
if (context->manualstatechange == 0)
{
/* request safe_op for slave */
- ecx_FPWRw(context->port,
+ ecx_FPWRw(&context->port,
configadr,
ECT_REG_ALCTL,
htoes(EC_STATE_SAFE_OP),
ADPh = (uint16)(1 - slave);
/* check if we found another slave than the requested */
readadr = 0xfffe;
- wkc = ecx_APRD(context->port, ADPh, ECT_REG_STADR, sizeof(readadr), &readadr, timeout);
+ wkc = ecx_APRD(&context->port, ADPh, ECT_REG_STADR, sizeof(readadr), &readadr, timeout);
/* correct slave found, finished */
if (readadr == configadr)
{
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 */
}
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) ==
+ if ((ecx_FPRDw(&context->port, EC_TEMPNODE, ECT_REG_ALIAS, timeout) ==
htoes(context->slavelist[slave].aliasadr)) &&
(ecx_readeeprom(context, slave, ECT_SII_ID, EC_TIMEOUTEEP) ==
htoel(context->slavelist[slave].eep_id)) &&
(ecx_readeeprom(context, slave, ECT_SII_REV, EC_TIMEOUTEEP) ==
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;
}
{
if (context->slavelist[slave].SM[nSM].StartAddr)
{
- ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt))),
+ ecx_FPWR(&context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt))),
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)
{
{
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++)
{
- ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc)),
+ ecx_FPWR(&context->port, configadr, (uint16)(ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc)),
sizeof(ec_fmmut), &context->slavelist[slave].FMMU[FMMUc], timeout);
}
}
RA = 0;
/* stop cyclic operation, ready for next trigger */
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET);
+ (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 */
}
h = 0;
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCUC, sizeof(h), &h, EC_TIMEOUTRET); /* write access to ethercat */
+ (void)ecx_FPWR(&context->port, slaveh, ECT_REG_DCCUC, sizeof(h), &h, EC_TIMEOUTRET); /* write access to ethercat */
t1 = 0;
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCSYSTIME, sizeof(t1), &t1, EC_TIMEOUTRET); /* read local time of slave */
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCSYSTIME, sizeof(t1), &t1, EC_TIMEOUTRET); /* read local time of slave */
t1 = etohll(t1);
/* Calculate first trigger time, always a whole multiple of CyclTime rounded up
/* first trigger at T1 + CyclTime + SyncDelay + CyclShift in ns */
}
t = htoell(t);
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSTART0, sizeof(t), &t, EC_TIMEOUTRET); /* SYNC0 start time */
+ (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_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET); /* activate cyclic operation */
+ (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;
RA = 0;
/* stop cyclic operation, ready for next trigger */
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET);
+ (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 */
}
h = 0;
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCCUC, sizeof(h), &h, EC_TIMEOUTRET); /* write access to ethercat */
+ (void)ecx_FPWR(&context->port, slaveh, ECT_REG_DCCUC, sizeof(h), &h, EC_TIMEOUTRET); /* write access to ethercat */
t1 = 0;
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCSYSTIME, sizeof(t1), &t1, EC_TIMEOUTRET); /* read local time of slave */
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCSYSTIME, sizeof(t1), &t1, EC_TIMEOUTRET); /* read local time of slave */
t1 = etohll(t1);
/* Calculate first trigger time, always a whole multiple of TrueCyclTime rounded up
/* first trigger at T1 + CyclTime + SyncDelay + CyclShift in ns */
}
t = htoell(t);
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSTART0, sizeof(t), &t, EC_TIMEOUTRET); /* SYNC0 start time */
+ (void)ecx_FPWR(&context->port, slaveh, ECT_REG_DCSTART0, sizeof(t), &t, EC_TIMEOUTRET); /* SYNC0 start time */
tc = htoel(CyclTime0);
- (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 */
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_DCSYNCACT, sizeof(RA), &RA, EC_TIMEOUTRET); /* activate cyclic operation */
+ (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->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.tv_sec -= 946684800UL; /* EtherCAT uses 2000-01-01 as epoch start instead of 1970-01-01 */
mastertime64 = ((uint64)mastertime.tv_sec * 1000 * 1000 * 1000) + (uint64)mastertime.tv_nsec;
- for (i = 1; i <= *(context->slavecount); i++)
+ for (i = 1; i <= context->slavecount; i++)
{
context->slavelist[i].consumedports = context->slavelist[i].activeports;
if (context->slavelist[i].hasdc)
parenthold = 0;
prevDCslave = i;
slaveh = context->slavelist[i].configadr;
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCTIME0, sizeof(ht), &ht, EC_TIMEOUTRET);
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCTIME0, sizeof(ht), &ht, EC_TIMEOUTRET);
context->slavelist[i].DCrtA = etohl(ht);
/* 64bit latched DCrecvTimeA of each specific slave */
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCSOF, sizeof(hrt), &hrt, EC_TIMEOUTRET);
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCSOF, sizeof(hrt), &hrt, EC_TIMEOUTRET);
/* use it as offset in order to set local time around 0 + mastertime */
hrt = htoell(-etohll(hrt) + mastertime64);
/* save it in the offset register */
- (void)ecx_FPWR(context->port, slaveh, ECT_REG_DCSYSOFFSET, sizeof(hrt), &hrt, EC_TIMEOUTRET);
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCTIME1, sizeof(ht), &ht, EC_TIMEOUTRET);
+ (void)ecx_FPWR(&context->port, slaveh, ECT_REG_DCSYSOFFSET, sizeof(hrt), &hrt, EC_TIMEOUTRET);
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCTIME1, sizeof(ht), &ht, EC_TIMEOUTRET);
context->slavelist[i].DCrtB = etohl(ht);
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCTIME2, sizeof(ht), &ht, EC_TIMEOUTRET);
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCTIME2, sizeof(ht), &ht, EC_TIMEOUTRET);
context->slavelist[i].DCrtC = etohl(ht);
- (void)ecx_FPRD(context->port, slaveh, ECT_REG_DCTIME3, sizeof(ht), &ht, EC_TIMEOUTRET);
+ (void)ecx_FPRD(&context->port, slaveh, ECT_REG_DCTIME3, sizeof(ht), &ht, EC_TIMEOUTRET);
context->slavelist[i].DCrtD = etohl(ht);
/* make list of active ports and their time stamps */
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);
+ (void)ecx_FPWR(&context->port, slaveh, ECT_REG_DCSYSDELAY, sizeof(ht), &ht, EC_TIMEOUTRET);
}
}
else
*
* Initialisation, state set and read, mailbox primitives, EEPROM primitives,
* SII reading and processdata exchange.
- *
- * Defines ec_slave[]. All slave information is put in this structure.
- * Needed for most user interaction with slaves.
*/
#include "soem/soem.h"
*/
void ecx_pusherror(ecx_contextt *context, const ec_errort *Ec)
{
- context->elist->Error[context->elist->head] = *Ec;
- context->elist->Error[context->elist->head].Signal = TRUE;
- context->elist->head++;
- if (context->elist->head > EC_MAXELIST)
+ context->elist.Error[context->elist.head] = *Ec;
+ context->elist.Error[context->elist.head].Signal = TRUE;
+ context->elist.head++;
+ if (context->elist.head > EC_MAXELIST)
{
- context->elist->head = 0;
+ context->elist.head = 0;
}
- if (context->elist->head == context->elist->tail)
+ if (context->elist.head == context->elist.tail)
{
- context->elist->tail++;
+ context->elist.tail++;
}
- if (context->elist->tail > EC_MAXELIST)
+ if (context->elist.tail > EC_MAXELIST)
{
- context->elist->tail = 0;
+ context->elist.tail = 0;
}
- *(context->ecaterror) = TRUE;
+ context->ecaterror = TRUE;
}
/** Pops an error from the list.
*/
boolean ecx_poperror(ecx_contextt *context, ec_errort *Ec)
{
- boolean notEmpty = (context->elist->head != context->elist->tail);
+ boolean notEmpty = (context->elist.head != context->elist.tail);
- *Ec = context->elist->Error[context->elist->tail];
- context->elist->Error[context->elist->tail].Signal = FALSE;
+ *Ec = context->elist.Error[context->elist.tail];
+ context->elist.Error[context->elist.tail].Signal = FALSE;
if (notEmpty)
{
- context->elist->tail++;
- if (context->elist->tail > EC_MAXELIST)
+ context->elist.tail++;
+ if (context->elist.tail > EC_MAXELIST)
{
- context->elist->tail = 0;
+ context->elist.tail = 0;
}
}
else
{
- *(context->ecaterror) = FALSE;
+ context->ecaterror = FALSE;
}
return notEmpty;
}
*/
boolean ecx_iserror(ecx_contextt *context)
{
- return (context->elist->head != context->elist->tail);
+ return (context->elist.head != context->elist.tail);
}
/** Report packet error
Ec.Slave = Slave;
Ec.Index = Index;
Ec.SubIdx = SubIdx;
- *(context->ecaterror) = TRUE;
+ context->ecaterror = TRUE;
Ec.Etype = EC_ERR_TYPE_PACKET_ERROR;
Ec.ErrorCode = ErrorCode;
ecx_pusherror(context, &Ec);
int ecx_init(ecx_contextt *context, const char *ifname)
{
ecx_initmbxpool(context);
- return ecx_setupnic(context->port, ifname, FALSE);
+ return ecx_setupnic(&context->port, ifname, FALSE);
}
/** Initialise lib in redundant NIC mode
ec_etherheadert *ehp;
ecx_initmbxpool(context);
- context->port->redport = redport;
- ecx_setupnic(context->port, ifname, FALSE);
- rval = ecx_setupnic(context->port, if2name, TRUE);
+ context->port.redport = redport;
+ ecx_setupnic(&context->port, ifname, FALSE);
+ rval = ecx_setupnic(&context->port, if2name, TRUE);
/* prepare "dummy" BRD tx frame for redundant operation */
- ehp = (ec_etherheadert *)&(context->port->txbuf2);
+ ehp = (ec_etherheadert *)&(context->port.txbuf2);
ehp->sa1 = oshw_htons(secMAC[0]);
zbuf = 0;
- ecx_setupdatagram(context->port, &(context->port->txbuf2), EC_CMD_BRD, 0, 0x0000, 0x0000, 2, &zbuf);
- context->port->txbuflength2 = ETH_HEADERSIZE + EC_HEADERSIZE + EC_WKCSIZE + 2;
+ ecx_setupdatagram(&context->port, &(context->port.txbuf2), EC_CMD_BRD, 0, 0x0000, 0x0000, 2, &zbuf);
+ context->port.txbuflength2 = ETH_HEADERSIZE + EC_HEADERSIZE + EC_WKCSIZE + 2;
return rval;
}
*/
void ecx_close(ecx_contextt *context)
{
- osal_mutex_destroy(context->mbxpool->mbxmutex);
- ecx_closenic(context->port);
+ osal_mutex_destroy(context->mbxpool.mbxmutex);
+ ecx_closenic(&context->port);
}
/**
ec_mbxbuft *ecx_getmbx(ecx_contextt *context)
{
ec_mbxbuft *mbx = NULL;
- ec_mbxpoolt *mbxpool = context->mbxpool;
+ ec_mbxpoolt *mbxpool = &context->mbxpool;
osal_mutex_lock(mbxpool->mbxmutex);
if (mbxpool->listcount > 0)
{
*/
int ecx_dropmbx(ecx_contextt *context, ec_mbxbuft *mbx)
{
- ec_mbxpoolt *mbxpool = context->mbxpool;
+ ec_mbxpoolt *mbxpool = &context->mbxpool;
int item = mbx - &(mbxpool->mbx[0]);
EC_PRINT("dropmbx item:%d mbx:%p\n\r", item, mbx);
if ((item >= 0) && (item < EC_MBXPOOLSIZE))
int ecx_initmbxpool(ecx_contextt *context)
{
int retval = 0;
- ec_mbxpoolt *mbxpool = context->mbxpool;
+ ec_mbxpoolt *mbxpool = &context->mbxpool;
mbxpool->mbxmutex = (osal_mutext *)osal_mutex_create();
for (int item = 0; item < EC_MBXPOOLSIZE; item++)
{
uint16 sldatapos[MAX_FPRD_MULTI];
int slcnt;
- port = context->port;
+ port = &context->port;
idx = ecx_getindex(port);
slcnt = 0;
ecx_setupdatagram(port, &(port->txbuf[idx]), EC_CMD_FPRD, idx,
return wkc;
}
-/** Read all slave states in ec_slave.
+/** Read all slave states in slavelist.
* @warning The BOOT state is actually higher than INIT and PRE_OP (see state representation)
* @param[in] context = context struct
* @return lowest state found
/* Try to establish the state of all slaves sending only one broadcast datagram.
* This way a number of datagrams equal to the number of slaves will be sent only if needed.*/
rval = 0;
- wkc = ecx_BRD(context->port, 0, ECT_REG_ALSTAT, sizeof(rval), &rval, EC_TIMEOUTRET);
+ wkc = ecx_BRD(&context->port, 0, ECT_REG_ALSTAT, sizeof(rval), &rval, EC_TIMEOUTRET);
- if (wkc >= *(context->slavecount))
+ if (wkc >= context->slavecount)
{
allslavespresent = TRUE;
}
* (even if different from 0) should be ignored and
* the slaves have reached the same state so the internal state
* can be updated without sending any datagram. */
- for (slave = 1; slave <= *(context->slavecount); slave++)
+ for (slave = 1; slave <= context->slavecount; slave++)
{
context->slavelist[slave].ALstatuscode = 0x0000;
context->slavelist[slave].state = bitwisestate;
fslave = 1;
do
{
- lslave = (uint16) * (context->slavecount);
+ lslave = (uint16)context->slavecount;
if ((lslave - fslave) >= MAX_FPRD_MULTI)
{
lslave = fslave + MAX_FPRD_MULTI - 1;
context->slavelist[0].ALstatuscode |= context->slavelist[slave].ALstatuscode;
}
fslave = lslave + 1;
- } while (lslave < *(context->slavecount));
+ } while (lslave < context->slavecount);
context->slavelist[0].state = lowest;
}
if (slave == 0)
{
slstate = htoes(context->slavelist[slave].state);
- ret = ecx_BWR(context->port, 0, ECT_REG_ALCTL, sizeof(slstate),
+ ret = ecx_BWR(&context->port, 0, ECT_REG_ALCTL, sizeof(slstate),
&slstate, EC_TIMEOUTRET3);
}
else
{
configadr = context->slavelist[slave].configadr;
- ret = ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL,
+ ret = ecx_FPWRw(&context->port, configadr, ECT_REG_ALCTL,
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
{
slstat.alstatus = 0;
slstat.alstatuscode = 0;
- ecx_FPRD(context->port, configadr, ECT_REG_ALSTAT, sizeof(slstat), &slstat, EC_TIMEOUTRET);
+ ecx_FPRD(&context->port, configadr, ECT_REG_ALSTAT, sizeof(slstat), &slstat, EC_TIMEOUTRET);
rval = etohs(slstat.alstatus);
context->slavelist[slave].ALstatuscode = etohs(slstat.alstatuscode);
}
else
{
uint16 configadr = context->slavelist[slave].configadr;
- wkc = ecx_FPRD(context->port, configadr, ECT_REG_SM1STAT, sizeof(uint8), SMstat, EC_TIMEOUTRET);
+ wkc = ecx_FPRD(&context->port, configadr, ECT_REG_SM1STAT, sizeof(uint8), SMstat, EC_TIMEOUTRET);
}
return wkc;
}
{
uint16 hu16;
uint16 configadr = context->slavelist[slave].configadr;
- int wkc = ecx_FPRD(context->port, configadr, ECT_REG_SM1STAT, sizeof(hu16), &hu16, EC_TIMEOUTRET);
+ int wkc = ecx_FPRD(&context->port, configadr, ECT_REG_SM1STAT, sizeof(hu16), &hu16, EC_TIMEOUTRET);
*SMstatex = etohs(hu16);
return wkc;
}
do
{
SMstat = 0;
- wkc = ecx_FPRD(context->port, configadr, ECT_REG_SM0STAT, sizeof(SMstat), &SMstat, EC_TIMEOUTRET);
+ wkc = ecx_FPRD(&context->port, configadr, ECT_REG_SM0STAT, sizeof(SMstat), &SMstat, EC_TIMEOUTRET);
SMstat = etohs(SMstat);
if (((SMstat & 0x08) != 0) && (timeout > EC_LOCALDELAY))
{
break;
case 2:
SMstatex = htoes(slaveitem->mbxinstateex);
- if (ecx_FPWR(context->port, configadr, ECT_REG_SM1STAT, sizeof(SMstatex), &(slaveitem->mbxinstateex), EC_TIMEOUTRET) > 0)
+ if (ecx_FPWR(&context->port, configadr, ECT_REG_SM1STAT, sizeof(SMstatex), &(slaveitem->mbxinstateex), EC_TIMEOUTRET) > 0)
{
slaveitem->mbxrmpstate++;
}
case 3:
/* wait for repeat ack */
SMstatex = htoes(slaveitem->mbxinstateex);
- wkc2 = ecx_FPRD(context->port, configadr, ECT_REG_SM1CONTR, sizeof(SMcontr), &SMcontr, EC_TIMEOUTRET);
+ 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;
{
/* keep track of work limit */
if (++limitcnt >= limit) maxcnt = 0;
- wkc = ecx_FPRD(context->port, configadr, mbxro, mbxl, mbx, EC_TIMEOUTRET); /* get mailbox */
+ wkc = ecx_FPRD(&context->port, configadr, mbxro, mbxl, mbx, EC_TIMEOUTRET); /* get mailbox */
if (wkc > 0)
{
mbxh = (ec_mbxheadert *)mbx;
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);
+ wkc = ecx_FPWR(&context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET);
if (wkc > 0)
{
mbxqueue->mbxstate[ticketloc] = EC_MBXQUEUESTATE_DONE; // mbx tx ok
{
mbxwo = context->slavelist[slave].mbx_wo;
/* write slave in mailbox 1st try*/
- wkc = ecx_FPWR(context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET3);
+ wkc = ecx_FPWR(&context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET3);
/* if failed wait for empty mailbox */
if ((wkc <= 0) && ecx_mbxempty(context, slave, timeout))
{
/* retry */
- wkc = ecx_FPWR(context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET3);
+ wkc = ecx_FPWR(&context->port, configadr, mbxwo, mbxl, mbx, EC_TIMEOUTRET3);
}
if (wkc < 0) wkc = 0;
}
mbxh = (ec_mbxheadert *)mbxin;
do
{
- wkc = ecx_FPRD(context->port, configadr, mbxro, mbxl, mbxin, EC_TIMEOUTRET); /* get mailbox */
- if ((wkc > 0) && ((mbxh->mbxtype & 0x0f) == 0x00)) /* Mailbox error response? */
+ wkc = ecx_FPRD(&context->port, configadr, mbxro, mbxl, mbxin, EC_TIMEOUTRET); /* get mailbox */
+ if ((wkc > 0) && ((mbxh->mbxtype & 0x0f) == 0x00)) /* Mailbox error response? */
{
MBXEp = (ec_mbxerrort *)mbxin;
ecx_mbxerror(context, slave, etohs(MBXEp->Detail));
} while ((wkc2 <= 0) && (osal_timer_is_expired(&timer) == FALSE));
SMstatex ^= 0x0200; /* toggle repeat request */
SMstatex = htoes(SMstatex);
- wkc2 = ecx_FPWR(context->port, configadr, ECT_REG_SM1STAT, sizeof(SMstatex), &SMstatex, EC_TIMEOUTRET);
+ wkc2 = ecx_FPWR(&context->port, configadr, ECT_REG_SM1STAT, sizeof(SMstatex), &SMstatex, EC_TIMEOUTRET);
SMstatex = etohs(SMstatex);
do /* wait for toggle ack */
{
- wkc2 = ecx_FPRD(context->port, configadr, ECT_REG_SM1CONTR, sizeof(SMcontr), &SMcontr, EC_TIMEOUTRET);
+ 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));
do /* wait for read mailbox available */
{
eepctl = 2;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* force Eeprom from PDI */
+ 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 */
+ 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;
}
eepctl = 1;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCFG, sizeof(eepctl), &eepctl, EC_TIMEOUTRET); /* set Eeprom to PDI */
+ 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;
}
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 */
if ((*estat & EC_ESTAT_BUSY) == 0)
if (estat & EC_ESTAT_EMASK) /* error bits are set */
{
estat = htoes(EC_ECMD_NOP); /* clear error bits */
- wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPCTL, sizeof(estat), &estat, EC_TIMEOUTRET3);
+ wkc = ecx_APWR(&context->port, aiadr, ECT_REG_EEPCTL, sizeof(estat), &estat, EC_TIMEOUTRET3);
}
do
cnt = 0;
do
{
- wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
+ wkc = ecx_APWR(&context->port, aiadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
cnt = 0;
do
{
- wkc = ecx_APRD(context->port, aiadr, ECT_REG_EEPDAT, sizeof(edat64), &edat64, EC_TIMEOUTRET);
+ wkc = ecx_APRD(&context->port, aiadr, ECT_REG_EEPDAT, sizeof(edat64), &edat64, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
else
cnt = 0;
do
{
- wkc = ecx_APRD(context->port, aiadr, ECT_REG_EEPDAT, sizeof(edat32), &edat32, EC_TIMEOUTRET);
+ wkc = ecx_APRD(&context->port, aiadr, ECT_REG_EEPDAT, sizeof(edat32), &edat32, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
edat64 = (uint64)edat32;
}
if (estat & EC_ESTAT_EMASK) /* error bits are set */
{
estat = htoes(EC_ECMD_NOP); /* clear error bits */
- wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPCTL, sizeof(estat), &estat, EC_TIMEOUTRET3);
+ wkc = ecx_APWR(&context->port, aiadr, ECT_REG_EEPCTL, sizeof(estat), &estat, EC_TIMEOUTRET3);
}
do
{
cnt = 0;
do
{
- wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPDAT, sizeof(data), &data, EC_TIMEOUTRET);
+ wkc = ecx_APWR(&context->port, aiadr, ECT_REG_EEPDAT, sizeof(data), &data, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
ed.comm = EC_ECMD_WRITE;
cnt = 0;
do
{
- wkc = ecx_APWR(context->port, aiadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
+ wkc = ecx_APWR(&context->port, aiadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
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 */
if ((*estat & EC_ESTAT_BUSY) == 0)
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
cnt = 0;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
+ wkc = ecx_FPWR(&context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
cnt = 0;
do
{
- wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat64), &edat64, EC_TIMEOUTRET);
+ 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);
+ wkc = ecx_FPRD(&context->port, configadr, ECT_REG_EEPDAT, sizeof(edat32), &edat32, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
edat64 = (uint64)edat32;
}
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
{
cnt = 0;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPDAT, sizeof(data), &data, EC_TIMEOUTRET);
+ wkc = ecx_FPWR(&context->port, configadr, ECT_REG_EEPDAT, sizeof(data), &data, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
ed.comm = EC_ECMD_WRITE;
ed.addr = eeproma;
cnt = 0;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
+ wkc = ecx_FPWR(&context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
if (wkc)
{
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);
}
ed.comm = htoes(EC_ECMD_READ);
ed.addr = htoes(eeproma);
ed.d2 = 0x0000;
do
{
- wkc = ecx_FPWR(context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
+ wkc = ecx_FPWR(&context->port, configadr, ECT_REG_EEPCTL, sizeof(ed), &ed, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
}
{
do
{
- wkc = ecx_FPRD(context->port, configadr, ECT_REG_EEPDAT, sizeof(edat), &edat, EC_TIMEOUTRET);
+ wkc = ecx_FPRD(&context->port, configadr, ECT_REG_EEPDAT, sizeof(edat), &edat, EC_TIMEOUTRET);
} while ((wkc <= 0) && (cnt++ < EC_DEFAULTRETRIES));
}
*/
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;
- context->idxstack->length[context->idxstack->pushed] = length;
- context->idxstack->dcoffset[context->idxstack->pushed] = DCO;
- context->idxstack->pushed++;
+ context->idxstack.idx[context->idxstack.pushed] = idx;
+ context->idxstack.data[context->idxstack.pushed] = data;
+ context->idxstack.length[context->idxstack.pushed] = length;
+ context->idxstack.dcoffset[context->idxstack.pushed] = DCO;
+ context->idxstack.pushed++;
}
}
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++;
+ rval = context->idxstack.pulled;
+ context->idxstack.pulled++;
}
return rval;
static void ecx_clearindex(ecx_contextt *context)
{
- context->idxstack->pushed = 0;
- context->idxstack->pulled = 0;
+ context->idxstack.pushed = 0;
+ context->idxstack.pulled = 0;
}
/** Transmit processdata to slaves.
sublength = (uint16)context->grouplist[group].IOsegment[currentsegment++];
}
/* get new index */
- idx = ecx_getindex(context->port);
+ idx = ecx_getindex(&context->port);
w1 = LO_WORD(LogAdr);
w2 = HI_WORD(LogAdr);
DCO = 0;
- ecx_setupdatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_LRD, idx, w1, w2, sublength, data);
+ ecx_setupdatagram(&context->port, &(context->port.txbuf[idx]), EC_CMD_LRD, idx, w1, w2, sublength, data);
if (first)
{
/* FPRMW in second datagram */
- DCO = ecx_adddatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_FRMW, idx, FALSE,
+ 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);
+ ECT_REG_DCSYSTIME, sizeof(int64), &context->DCtime);
first = FALSE;
}
/* send frame */
- ecx_outframe_red(context->port, idx);
+ ecx_outframe_red(&context->port, idx);
/* push index and data pointer on stack */
ecx_pushindex(context, idx, data, sublength, DCO);
length -= sublength;
sublength = (uint16)length;
}
/* get new index */
- idx = ecx_getindex(context->port);
+ idx = ecx_getindex(&context->port);
w1 = LO_WORD(LogAdr);
w2 = HI_WORD(LogAdr);
DCO = 0;
- ecx_setupdatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_LWR, idx, w1, w2, sublength, data);
+ ecx_setupdatagram(&context->port, &(context->port.txbuf[idx]), EC_CMD_LWR, idx, w1, w2, sublength, data);
if (first)
{
/* FPRMW in second datagram */
- DCO = ecx_adddatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_FRMW, idx, FALSE,
+ 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);
+ ECT_REG_DCSYSTIME, sizeof(int64), &context->DCtime);
first = FALSE;
}
/* send frame */
- ecx_outframe_red(context->port, idx);
+ ecx_outframe_red(&context->port, idx);
/* push index and data pointer on stack */
ecx_pushindex(context, idx, data, sublength, DCO);
length -= sublength;
{
sublength = (uint16)context->grouplist[group].IOsegment[currentsegment++];
/* get new index */
- idx = ecx_getindex(context->port);
+ idx = ecx_getindex(&context->port);
w1 = LO_WORD(LogAdr);
w2 = HI_WORD(LogAdr);
DCO = 0;
- ecx_setupdatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_LRW, idx, w1, w2, sublength, data);
+ ecx_setupdatagram(&context->port, &(context->port.txbuf[idx]), EC_CMD_LRW, idx, w1, w2, sublength, data);
if (first)
{
/* FPRMW in second datagram */
- DCO = ecx_adddatagram(context->port, &(context->port->txbuf[idx]), EC_CMD_FRMW, idx, FALSE,
+ 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);
+ ECT_REG_DCSYSTIME, sizeof(int64), &context->DCtime);
first = FALSE;
}
/* send frame */
- ecx_outframe_red(context->port, idx);
+ ecx_outframe_red(&context->port, idx);
/* push index and data pointer on stack.
* the iomapinputoffset compensate for where the inputs are stored
* in the IOmap if we use an overlapping IOmap. If a regular IOmap
/* just to prevent compiler warning for unused group */
wkc2 = group;
- idxstack = context->idxstack;
- rxbuf = context->port->rxbuf;
+ idxstack = &context->idxstack;
+ rxbuf = context->port.rxbuf;
/* get first index */
pos = ecx_pullindex(context);
/* read the same number of frames as send */
while (pos >= 0)
{
idx = idxstack->idx[pos];
- wkc2 = ecx_waitinframe(context->port, idx, timeout);
+ wkc2 = ecx_waitinframe(&context->port, idx, timeout);
/* check if there is input data in frame */
if (wkc2 > EC_NOFRAME)
{
memcpy(&le_wkc, &(rxbuf[idx][EC_HEADERSIZE + idxstack->length[pos]]), EC_WKCSIZE);
wkc = etohs(le_wkc);
memcpy(&le_DCtime, &(rxbuf[idx][idxstack->dcoffset[pos]]), sizeof(le_DCtime));
- *(context->DCtime) = etohll(le_DCtime);
+ context->DCtime = etohll(le_DCtime);
}
else
{
/* output WKC counts 2 times when using LRW, emulate the same for LWR */
wkc = etohs(le_wkc) * 2;
memcpy(&le_DCtime, &(rxbuf[idx][idxstack->dcoffset[pos]]), sizeof(le_DCtime));
- *(context->DCtime) = etohll(le_DCtime);
+ context->DCtime = etohll(le_DCtime);
}
else
{
}
}
/* release buffer */
- ecx_setbufstat(context->port, idx, EC_BUF_EMPTY);
+ ecx_setbufstat(&context->port, idx, EC_BUF_EMPTY);
/* get next index */
pos = ecx_pullindex(context);
}
Ec.Slave = Slave;
Ec.Index = idn;
Ec.SubIdx = 0;
- *(context->ecaterror) = TRUE;
+ context->ecaterror = TRUE;
Ec.Etype = EC_ERR_TYPE_SOE_ERROR;
Ec.ErrorCode = Error;
ecx_pusherror(context, &Ec);
projects / 0xmirror / SOEM.git / commitdiff