EtherCATライブラリ

typedef struct {

    EthercatDcSyncMode DcSyncMode;
    uint32_t StaticDriftCompensationFrames;

    uint32_t StateMachineTimeoutI2P;
    uint32_t StateMachineTimeoutP2S;
    uint32_t StateMachineTimeoutS2O;
    uint32_t ScanNetworkTimeout;
    uint32_t StartMasterTimeout;
    uint32_t StartDeviceTimeout;

    uint32_t ErrorDetectWkcMultipleFaultsThreshold;
    uint32_t ErrorDetectMultipleLostFramesThreshold;
    uint32_t EnableErrorBusReactionSyncUnitToSafeOp:1,
             EnableErrorBusReactionSyncUnitToSafeOpAutoRestart:1,
             IgnoreBiosOverride:1;

} EthercatMasterSettings;

#include "Ethercat.h"

EthercatMaster master;

void setup() {
  Serial.begin(115200);
  while (!Serial);

  master.begin(); // Initialize EtherCAT Master in Pre-OP state

  Serial.println("Starting EtherCAT Master...");

  // Print Out All Slave Information
  for (int i = 0; i < master.getSlaveCount(); i++) {
    Serial.print("Slave ");
    Serial.print(i);
    Serial.print(" VID: ");
    Serial.print(master.getVendorID(i), HEX);
    Serial.print(", PID: ");
    Serial.print(master.getProductCode(i), HEX);
    Serial.print(", Rev: ");
    Serial.print(master.getRevisionNumber(i), HEX);
    Serial.print(", Ser: ");
    Serial.print(master.getSerialNumber(i), HEX);
    Serial.print(", Alias: ");
    Serial.print(master.getAliasAddress(i));
    Serial.println();
  }
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic slave;

char name[256];

void setup() {
  Serial.begin(115200);
  while (!Serial);

  master.begin(); // Initialize EtherCAT Master in Pre-Operational state

  for (int i = 0; i < master.getSlaveCount(); i++) {
    slave.attach(i, master); // Attach the slave to the master
    Serial.print("Slave ");
    Serial.println(i);

    Serial.print("                Name: ");
    Serial.println(slave.getDeviceName(name, 256));

    Serial.print("           Vendor ID: 0x");
    Serial.println(slave.getVendorID(), HEX);

    Serial.print("        Product Code: 0x");
    Serial.println(slave.getProductCode(), HEX);

    Serial.print("     Revision Number: 0x");
    Serial.println(slave.getRevisionNumber(), HEX);

    Serial.print("       Serial Number: 0x");
    Serial.println(slave.getSerialNumber(), HEX);

    Serial.print("       Alias Address: ");
    Serial.println(slave.getAliasAddress());

    Serial.print("    Mailbox Protocol: 0x");
    Serial.println(slave.getMailboxProtocol(), HEX);

    Serial.print("         CoE Details: 0x");
    Serial.println(slave.getCoEDetails(), HEX);

    Serial.print("         FoE Details: 0x");
    Serial.println(slave.getFoEDetails(), HEX);

    Serial.print("         EoE Details: 0x");
    Serial.println(slave.getEoEDetails(), HEX);

    Serial.print("        SoE Channels: ");
    Serial.println(slave.getSoEChannels());

    Serial.print("        DC Supported: ");
    Serial.println(slave.isSupportDC());
  }
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_CiA402 slave;

char name[256];

void setup() {
  Serial.begin(115200);
  while (!Serial);

  master.begin();  // Initialize EtherCAT Master in Pre-Operational state

  for (int i = 0; i < master.getSlaveCount(); i++) {
    // Attach the slave to the master
    if (slave.attach(i, master) < 0) {
      continue; // Skip this slave if attachment fails
    }

    Serial.print("Slave ");
    Serial.println(i);

    Serial.print("                Name: ");
    Serial.println(slave.getDeviceName(name, 256));

    Serial.print("           Vendor ID: 0x");
    Serial.println(slave.getVendorID(), HEX);

    Serial.print("        Product Code: 0x");
    Serial.println(slave.getProductCode(), HEX);

    Serial.print("     Revision Number: 0x");
    Serial.println(slave.getRevisionNumber(), HEX);

    Serial.print("       Serial Number: 0x");
    Serial.println(slave.getSerialNumber(), HEX);

    Serial.print("       Alias Address: ");
    Serial.println(slave.getAliasAddress());

    Serial.print("    Mailbox Protocol: 0x");
    Serial.println(slave.getMailboxProtocol(), HEX);

    Serial.print("         CoE Details: 0x");
    Serial.println(slave.getCoEDetails(), HEX);

    Serial.print("         FoE Details: 0x");
    Serial.println(slave.getFoEDetails(), HEX);

    Serial.print("         EoE Details: 0x");
    Serial.println(slave.getEoEDetails(), HEX);

    Serial.print("        SoE Channels: ");
    Serial.println(slave.getSoEChannels());

    Serial.print("        DC Supported: ");
    Serial.println(slave.isSupportDC());
  }
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  master.begin();
  device.attach(0, master);

  Serial.print("1C12h.0 => ");
  Serial.println(device.sdoUpload8(0x1C12, 0x00));

  Serial.print("1C13h.0 => ");
  Serial.println(device.sdoUpload8(0x1C13, 0x00));
  // ...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  uint8_t value;

  master.begin();
  device.attach(0, master);

  if (device.sdoUpload(0x1C12, 0x00, &value, sizeof(value)) >= 0) {
    Serial.print("1C12h.0 => ");
    Serial.println(value);
  }

  if (device.sdoUpload(0x1C13, 0x00, &value, sizeof(value)) >= 0) {
    Serial.print("1C13h.0 => ");
    Serial.println(value);
  }
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  uint32_t abortcode;
  uint8_t value;

  master.begin();
  device.attach(0, master);

  if (device.sdoUpload(0xFFFF, 0xFF, &value, sizeof(value), &abortcode) == ECAT_ERR_DEVICE_COE_ERROR) {
    Serial.print("Abort Code: 0x");
    Serial.println(abortcode, HEX);
  }
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  master.begin();
  device.attach(0, master);

  device.sdoDownload8(0x1C12, 0x00, 0);
  device.sdoDownload8(0x1C13, 0x00, 0);
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  uint8_t value;

  master.begin();
  device.attach(0, master);

  value = 0;
  device.sdoDownload(0x1C12, 0x00, &value, sizeof(value));
  value = 0;
  device.sdoDownload(0x1C13, 0x00, &value, sizeof(value));
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  uint32_t abortcode;
  uint8_t value = 0x01;

  master.begin();
  device.attach(0, master);

  if (device.sdoDownload(0xFFFF, 0xFF, &value, sizeof(value), &abortcode) == ECAT_ERR_DEVICE_COE_ERROR) {
    char buf[20];
    sprintf(buf, "Abort Code: 0x%08lX", abortcode);
    Serial.println(buf);
  }
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  uint8_t assign_nr, mapping_nr;
  uint16_t mapping;
  uint32_t entry;

  master.begin();
  device.attach(0, master);

  // RxPDO Mapping List
  assign_nr = device.sdoUpload8(0x1C12, 0x00);
  for (int m = 0; m < assign_nr; m++) {
    mapping = device.sdoUpload16(0x1C12, m + 1);
    Serial.print("  RxPDO");
    Serial.print(m + 1);
    Serial.print(" (");
    Serial.print(mapping, HEX);
    Serial.println("h)");

    mapping_nr = device.sdoUpload8(mapping, 0x00);
    for (int n = 0; n < mapping_nr; n++) {
      entry = device.sdoUpload32(mapping, n + 1);
      Serial.print("    ");
      char entryBuf[11];  // "XXXXXXXXh" + null
      sprintf(entryBuf, "%08lXh", entry);
      Serial.println(entryBuf);
    }
  }

  // TxPDO Mapping List
  assign_nr = device.sdoUpload8(0x1C13, 0x00);
  for (int m = 0; m < assign_nr; m++) {
    mapping = device.sdoUpload16(0x1C13, m + 1);
    Serial.print("  TxPDO");
    Serial.print(m + 1);
    Serial.print(" (");
    Serial.print(mapping, HEX);
    Serial.println("h)");

    mapping_nr = device.sdoUpload8(mapping, 0x00);
    for (int n = 0; n < mapping_nr; n++) {
      entry = device.sdoUpload32(mapping, n + 1);
      Serial.print("    ");
      char entryBuf[11];
      sprintf(entryBuf, "%08lXh", entry);
      Serial.println(entryBuf);
    }
  }
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  master.begin();
  device.attach(0, master);
  // 1C12
  device.sdoDownload8(0x1C12, 0x00, 0);
  device.sdoDownload8(0x1601, 0x00, 0);
  device.sdoDownload32(0x1601, 0x01, 0x60400010);
  device.sdoDownload32(0x1601, 0x02, 0x607A0020);
  device.sdoDownload32(0x1601, 0x03, 0x60FF0020);
  device.sdoDownload32(0x1601, 0x04, 0x60710010);
  device.sdoDownload32(0x1601, 0x05, 0x60600008);
  device.sdoDownload8(0x1601, 0x00, 5);
  device.sdoDownload16(0x1C12, 0x1601, 1);
  device.sdoDownload8(0x1C12, 0x00, 1);
  // 1C13
  device.sdoDownload8(0x1C13, 0x00, 0);
  device.sdoDownload8(0x1A01, 0x00, 0);
  device.sdoDownload32(0x1A01, 0x01, 0x60410010);
  device.sdoDownload32(0x1A01, 0x02, 0x60640020);
  device.sdoDownload32(0x1A01, 0x03, 0x606C0020);
  device.sdoDownload32(0x1A01, 0x04, 0x60770010);
  device.sdoDownload32(0x1A01, 0x05, 0x60610008);
  device.sdoDownload8(0x1A01, 0x00, 5);
  device.sdoDownload16(0x1C13, 0x1A01, 1);
  device.sdoDownload8(0x1C13, 0x00, 1);
  //...
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  master.begin();
  device.attach(0, master);
  master.start();
}

void loop() {
  // Read and display the state of PDO bits
  Serial.print("Bit0 => ");
  Serial.print(device.pdoBitRead(0)); // Read PDO bit 0
  Serial.print(", Bit9 => ");
  Serial.println(device.pdoBitRead(9)); // Read PDO bit 9

  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  Serial.begin(115200);

  master.begin();
  device.attach(0, master);
  master.start();
}

void loop() {
  // Read specific bits using pdoRead8 and print their values
  Serial.print("Bit0 => ");
  Serial.print((device.pdoRead8(0) >> 0) & 1);
  Serial.print(", Bit9 => ");
  Serial.println((device.pdoRead8(1) >> 1) & 1);

  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

uint16_t value;

void setup() {
  Serial.begin(115200);

  master.begin();
  device.attach(0, master);
  master.start();
}

void loop() {
  device.pdoRead(0, &value, sizeof(value));

  Serial.print("Bit0 => ");
  Serial.print((value >> 0) & 1);
  Serial.print(", Bit9 => ");
  Serial.println((value >> 9) & 1);

  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  master.begin();
  device.attach(0, master);
  master.start();
}

void loop() {
  device.pdoBitWrite(0, 1);
  device.pdoBitWrite(9, 1);
  delay(1000);

  device.pdoBitWrite(0, 0);
  device.pdoBitWrite(9, 0);
  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

void setup() {
  master.begin();
  device.attach(0, master);
  master.start();
}

void loop() {
  device.pdoWrite8(0, 0x01);
  device.pdoWrite8(1, 0x02);
  delay(1000);
  
  device.pdoWrite8(0, 0x00);
  device.pdoWrite8(1, 0x00);
  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

uint16_t value;

void setup() {
  master.begin();
  device.attach(0, master);
  master.start();
}

void loop() {
  value = 0x0201;
  device.pdoWrite(0, &value, sizeof(value));
  delay(1000);
  
  value = 0x0000;
  device.pdoWrite(0, &value, sizeof(value));
  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

int toggle = 0;
int cycle_count = 0;

void MyCyclicCallback()
{
  if (++cycle_count < 1000)
    return;

  cycle_count = 0;

  toggle = !toggle;
  device.pdoBitWrite(0, toggle);
  device.pdoBitWrite(9, toggle);
}

void setup() {
  Serial.begin(115200);

  master.begin();
  device.attach(0, master);
  master.attachCyclicCallback(MyCyclicCallback);
  master.start(1000000);  // 1ms cycle
}

void loop() {
  // put your main code here, to run repeatedly:

}

#include "Ethercat.h"

#define GRAVITY (9.80665)

EthercatMaster master;
EthercatDevice_Generic device;

int toggle = 0;
int cycle_count = 0;
double S = 0.0, T = 0.0;

double s = 0.0, t = 0.0;


void MyCyclicCallback()
{
  S = (GRAVITY * T * T) / 2.0;
  T += 0.001; 

  if (++cycle_count < 1000)
    return;
  cycle_count = 0;

  toggle = !toggle;
  device.pdoBitWrite(0, toggle);
  device.pdoBitWrite(9, toggle);
}

void setup() {
  Serial.begin(115200);

  master.begin();
  device.attach(0, master);
  master.attachCyclicCallback(MyCyclicCallback, true);
  master.start(1000000);
}

void loop() {
  s = (GRAVITY * t * t) / 2.0;
  t += 1.0;

  Serial.print("S = ");
  Serial.println(s, 6);

  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

// Error counters
int wkc_single_fault_cnt = 0;
int wkc_multiple_faults_cnt = 0;
int single_lost_frame_cnt = 0;
int multiple_lost_frames_cnt = 0;
int cable_broken_cnt = 0;
int wait_ack_timeout_cnt = 0;

// Error callback function
void myErroCallback(uint32_t errorcode) {
  switch (errorcode) {
    case ECAT_ERR_WKC_SINGLE_FAULT:
      wkc_single_fault_cnt++;
      break;
    case ECAT_ERR_WKC_MULTIPLE_FAULTS:
      wkc_multiple_faults_cnt++;
      break;
    case ECAT_ERR_SINGLE_LOST_FRAME:
      single_lost_frame_cnt++;
      break;
    case ECAT_ERR_MULTIPLE_LOST_FRAMES:
      multiple_lost_frames_cnt++;
      break;
    case ECAT_ERR_CABLE_BROKEN:
      cable_broken_cnt++;
      break;
    case ECAT_ERR_WAIT_ACK_TIMEOUT:
      wait_ack_timeout_cnt++;
      break;
  }
}

void setup() {
  Serial.begin(115200);

  master.attachErrorCallback(myErroCallback);
  master.begin(); 
  master.start(); 
}

void loop() {

  Serial.print("ECAT_ERR_WKC_SINGLE_FAULT     = ");
  Serial.println(wkc_single_fault_cnt);
  Serial.print("ECAT_ERR_WKC_MULTIPLE_FAULTS  = ");
  Serial.println(wkc_multiple_faults_cnt);
  Serial.print("ECAT_ERR_SINGLE_LOST_FRAME    = ");
  Serial.println(single_lost_frame_cnt);
  Serial.print("ECAT_ERR_MULTIPLE_LOST_FRAMES = ");
  Serial.println(multiple_lost_frames_cnt);
  Serial.print("ECAT_ERR_CABLE_BROKEN         = ");
  Serial.println(cable_broken_cnt);
  Serial.print("ECAT_ERR_WAIT_ACK_TIMEOUT     = ");
  Serial.println(wait_ack_timeout_cnt);

  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

// Event counters
int state_changed_cnt = 0;
int cable_reconnected_cnt = 0;

// Event callback function
void myEventCallback(uint32_t eventcode) {
  switch (eventcode) {
    case ECAT_EVT_STATE_CHANGED:
      state_changed_cnt++;
      break;
    case ECAT_EVT_CABLE_RECONNECTED:
      cable_reconnected_cnt++;
      break;
  }
}

void setup() {
  Serial.begin(115200);

  master.attachEventCallback(myEventCallback);
  master.begin();
  master.start();
}

void loop() {
  Serial.print("ECAT_EVT_STATE_CHANGED     = ");
  Serial.println(state_changed_cnt);
  Serial.print("ECAT_EVT_CABLE_RECONNECTED = ");
  Serial.println(cable_reconnected_cnt);
  delay(1000);
}

#include "Ethercat.h"

EthercatMaster master;
EthercatDevice_Generic device;

uint32_t position = 0;

// Cyclic callback function, executed every 1ms
void MyCyclicCallback() {
  // Check if the device is in "Operation Enable" state (0x27)
  if ((device.pdoRead8(0) & 0x6F) != 0x27)
    return;

  // Increment target position by 1000 and write it to PDO
  device.pdoWrite32(2, position += 1000);
}

void setup() {
  Serial.begin(115200);
  while (!Serial);  // Wait for Serial to be ready

  master.begin();

  device.attach(0, master);             // Attach slave device (slave ID 0)
  device.setDc(1000000);                // Enable Distributed Clock (1ms cycle)
  device.sdoDownload8(0x6060, 0x00, 8); // Set mode of operation to CSP (mode 8)

  // Register the cyclic callback function
  master.attachCyclicCallback(MyCyclicCallback);
  master.start(1000000, ECAT_SYNC);     // Start EtherCAT master with 1ms sync cycle

  // Read current position and set as initial target position
  position = device.pdoRead32(2);
  device.pdoWrite32(2, position);

  // Transition through CiA 402 state machine to reach "Operation Enable"
  device.pdoWrite8(0, 0x80); // Shutdown
  delay(1000);
  device.pdoWrite8(0, 0x06); // Switch On
  delay(1000);
  device.pdoWrite8(0, 0x07); // Enable Voltage
  delay(1000);
  device.pdoWrite8(0, 0x0F); // Operation Enable
  delay(1000);
}

void loop() {
  // put your main code here, to run repeatedly:

}