EC100 ARM Industriecomputer Entwicklungshandbuch

EC100 ARM Industriecomputer Entwicklungshandbuch – The EC100 comes pre-installed with Node-RED 4.0 and NeuronEX-Lite, making it ready for edge application development out of the box.

Node-RED provides a visual, drag-and-drop programming interface for rapid business logic building, while NeuronEX-Lite serves as a lightweight edge computing platform that supports millisecond-level device connectivity through multi-protocol compatibility. This combination greatly simplifies development and enables fast deployment of industrial IoT solutions.

Development Preparation

1.SSH Tools

We recommend using MobaXterm, or you can choose your preferred SSH tool.

https://iotrouter.yuque.com/attachments/yuque/0/2025/zip/40387797/1751447985727-10cb8014-e57d-4f95-85f2-722b2f822d6f.zip

2. Serial port debugging tool

We recommend using XCOM, or choose your preferred serial port debugging tool

https://iotrouter.yuque.com/attachments/yuque/0/2025/zip/40387797/1751448098345-cc351ada-aa82-4de7-b0bf-b6a909e637bc.zip

3. Hardware Tools

Common debugging tools include: CAN-to-USB tools / 485-to-USB tools / network cables, etc. Please prepare these on your own.

4. Cross-Compilation Toolchain

https://iotrouter.yuque.com/attachments/yuque/0/2025/tar/40387797/1751447691686-3001e3bf-2f16-43d3-a4d7-55c4705dff97.tar

Software Environment

OS: Ubuntu 20.04.1; partially cropped

NodeJs: v22.16.0

Python: python3.8

Shell: bash

GLIBC: 2.31

Peripheral Interfaces

1. Serial Port

The EC100 comes with two built-in RS485 transceivers.

Anmerkung: With RS485 transmission and reception, users do not need to worry about switching between transmission and reception, as the hardware will handle it automatically.

1.1. Quick test

Use the minicom tool for testing. For specific usage instructions, please search Baidu or consult DeepSeek.

1.2. Code test example

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <termios.h>

#include <errno.h>

#include <sys/select.h>

#define BUFFER_SIZE 256

typedef struct {

int baud_rate; // Baud rate

int data_bits; // Data bits (5,6,7,8)

int stop_bits; // Stop bits (1,2)

char parity; // Parity (N: None, O: Odd, E: Even)

} SerialConfig;

int set_serial_attr(int fd, SerialConfig *config)

{

struct termios tty;

if (tcgetattr(fd, &tty) < 0) { perror(“tcgetattr”); return -1; } // Set baud rate speed_t speed;

switch (config->baud_rate) {

case 9600: speed = B9600; break;

case 19200: speed = B19200; break;

case 38400: speed = B38400; break;

case 57600: speed = B57600; break;

case 115200: speed = B115200; break;

default:

fprintf(stderr, “Unsupported baud rate, using 115200\n”);

speed = B115200;

}

cfsetispeed(&tty, speed);

cfsetospeed(&tty, speed);

// Set data

bits tty.c_cflag &= ~CSIZE;

switch (config->data_bits) {

case 5: tty.c_cflag |= CS5; break;

case 6: tty.c_cflag |= CS6; break;

case 7: tty.c_cflag |= CS7; break;

case 8: tty.c_cflag |= CS8; break;

default:

fprintf(stderr, “Unsupported data bits, using 8\n”);

tty.c_cflag |= CS8;

}

// Set stop bits

if (config->stop_bits == 2) {

tty.c_cflag |= CSTOPB; } else {

tty.c_cflag &= ~CSTOPB; }

// Set parity

switch (config->parity) {

case ‘N’:

case ‘n’: tty.c_cflag &= ~PARENB; // No parity

break;

case ‘O’:

case ‘o’: tty.c_cflag |= PARENB; // Odd parity

tty.c_cflag |= PARODD; break;

case ‘E’:

case ‘e’: tty.c_cflag |= PARENB; // Even parity

tty.c_cflag &= ~PARODD; break;

default:

fprintf(stderr, “Unsupported parity, using N\n”);

tty.c_cflag &= ~PARENB;

}

// Other settings

tty.c_cflag |= (CLOCAL | CREAD); // Enable receiver and local mode

tty.c_cflag &= ~CRTSCTS; // Disable hardware flow control

tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // Raw input mode

tty.c_oflag &= ~OPOST; // Raw output mode

tty.c_cc[VMIN] = 1; // Minimum number of characters to read

tty.c_cc[VTIME] = 0; // Read timeout (unit: 0.1s)

if (tcsetattr(fd, TCSANOW, &tty) < 0) {

perror(“tcsetattr”);

return -1; }

return 0;

}

int main(int argc, char *argv[]) {

int fd;

char *portname;

if (argc < 2) {

fprintf(stderr, “Usage: %s <serial_port>\n”, argv[0]);

exit(EXIT_FAILURE);

}

portname = argv[1]; // Serial port configuration

SerialConfig config = { .baud_rate = 115200, // Baud rate

.data_bits = 8, // Data bits

.stop_bits = 1, // Stop bits

.parity = ‘N’ // Parity (N: None, O: Odd, E: Even)

};

fd = open(portname, O_RDWR | O_NOCTTY | O_NONBLOCK);

if (fd < 0) {

perror(“open”);

exit(EXIT_FAILURE);

}

if (set_serial_attr(fd, &config)) {

close(fd);

exit(EXIT_FAILURE);

}

printf(“Serial port echo test running on %s\n”, portname);

printf(“Configuration: %d baud, %d data bits, %d stop bit, %c parity\n”, config.baud_rate, config.data_bits, config.stop_bits, config.parity);

printf(“Press Ctrl+C to exit.\n”);

fd_set readfds;

char buffer[BUFFER_SIZE];

int n;

while (1) {

FD_ZERO(&readfds);

FD_SET(fd, &readfds); // Wait indefinitely for incoming data (no timeout)

if (select(fd + 1, &readfds, NULL, NULL, NULL) < 0) {

perror(“select”);

break; }

if (FD_ISSET(fd, &readfds)) {

n = read(fd, buffer, BUFFER_SIZE – 1);

if (n > 0) {

buffer[n] = ‘\0’;

printf(“Received %d bytes: %s\n”, n, buffer); // Echo data back

write(fd, buffer, n); } else if (n < 0) {

if (errno != EAGAIN && errno != EWOULDBLOCK) {

perror(“read”);

break;

}

}

}

}

close(fd);

return 0;

}

Compile:  gcc rs485_example.c -o rs485_example

RS485-1 test run: ./rs485_example/dev/ttyS4

2. LED

EC100 has a total of 4 indicator lights, 2 of which can be programmed by the user.

Note: The IO index is calculated based on the IO number.

2.1. Quick test

#!/bin/bash

# Check if a GPIO index is provided
if [ -z “$1” ]; then
echo “Usage: $0 <gpio_number>”
exit 1
fi

GPIO=$1
GPIO_PATH=”/sys/class/gpio/gpio$GPIO”
EXPORT_PATH=”/sys/class/gpio/export”

# Check if the GPIO is already exported
if [ ! -d “$GPIO_PATH” ]; then
echo “Exporting GPIO $GPIO…”
echo “$GPIO” > “$EXPORT_PATH”
if [ $? -ne 0 ]; then
echo “Failed to export GPIO $GPIO. Check permissions or if it’s in use.”
exit 1
fi
else
echo “GPIO $GPIO is already exported.”
fi

# Set GPIO direction to output
echo “out” > “$GPIO_PATH/direction”

# Set the initial value to low
echo 0 > “$GPIO_PATH/value”

echo “Toggling GPIO $GPIO every 1 second. Press Ctrl+C to stop.”

# Start toggle loop
while true; do
echo 1 >”$GPIO_PATH/value”
sleep 1
echo 0 >”$GPIO_PATH/value”
sleep 1
done

Test run: bash led_example.sh 38

2.2. Code test example

Test run:  ./led_example

3. CAN FD

EC100 has two high-speed CAN interfaces

3.2. Example of code testing

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <net/if.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <linux/can.h>

#include <linux/can/raw.h>

#include <fcntl.h>

#include <errno.h>

#include <stdint.h>

#define CAN_INTERFACE “can0”
#define BITRATE 500000
#define DATA_BITRATE 2000000
#define SAMPLE_POINT 0.8
#define TX_QUEUE_LEN 4096

// Configure CAN FD interface
int setup_can_fd_interface(const char *ifname) {
char cmd[512];
FILE *fp;

// Bring interface down
snprintf(cmd, sizeof(cmd), “ip link set %s down”, ifname);
system(cmd);

// Set CAN FD parameters
snprintf(cmd, sizeof(cmd),
“ip link set %s type can bitrate %d sample-point %.1f ”
“dbitrate %d dsample-point %.1f fd on”,
ifname, BITRATE, SAMPLE_POINT, DATA_BITRATE, SAMPLE_POINT);
if (system(cmd) != 0) {
fprintf(stderr, “Failed to configure CAN FD interface %s\n”, ifname);
return -1;
}

// Set TX queue length
snprintf(cmd, sizeof(cmd), “/sys/class/net/%s/tx_queue_len”, ifname);
fp = fopen(cmd, “w”);
if (fp == NULL) {
perror(“Failed to open tx_queue_len”);
return -1;
}
fprintf(fp, “%d”, TX_QUEUE_LEN);
fclose(fp);

// Bring interface up
snprintf(cmd, sizeof(cmd), “ip link set %s up”, ifname);
if (system(cmd) != 0) {
fprintf(stderr, “Failed to bring up CAN interface %s\n”, ifname);
return -1;
}

printf(“CAN FD interface %s configured:\n”, ifname);
printf(” Bitrate: %d\n”, BITRATE);
printf(” Data bitrate: %d\n”, DATA_BITRATE);
printf(” Sample point: %.1f\n”, SAMPLE_POINT);
printf(” TX queue length: %d\n”, TX_QUEUE_LEN);

return 0;
}

// Send a CAN FD frame
int send_can_fd_frame(int sock, uint32_t can_id, uint8_t *data, uint8_t len) {
struct canfd_frame frame;

memset(&frame, 0, sizeof(frame));
frame.can_id = can_id;
frame.len = len;
memcpy(frame.data, data, len);
frame.flags = CANFD_BRS; // Enable bit rate switching

int nbytes = write(sock, &frame, sizeof(frame));
if (nbytes != sizeof(frame)) {
perror(“CAN FD frame send failed”);
return -1;
}

printf(“Sent CAN FD frame: ID 0x%08X, data: “, can_id);
for (int i = 0; i < len; i++) {
printf(“%02X “, data[i]);
}
printf(“\n”);

return 0;
}

// Receive CAN messages (supports classic CAN and CAN FD)
void receive_can_messages(int sock) {
struct canfd_frame frame;
int nbytes;

printf(“Starting to receive CAN messages (Ctrl+C to stop)…\n”);

while (1) {
nbytes = read(sock, &frame, sizeof(frame));
if (nbytes < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
continue;
}
perror(“CAN frame read failed”);
break;

}

if (nbytes == CAN_MTU) {
// Classic CAN frame
printf(“Received CAN frame: ID 0x%08X, DLC %d, data: “,
frame.can_id, frame.len);
}else if (nbytes == CANFD_MTU) {
// CAN FD frame
printf(“Received CAN FD frame: ID 0x%08X, DLC %d, data: “,
frame.can_id, frame.len);
}else {

printf(“Received frame with unexpected size %d\n”, nbytes);
continue;
}

for (int i = 0; i < frame.len; i++) {
printf(“%02X “, frame.data[i]);
}
printf(“\n”);
}
}

int main() {
int s;
struct sockaddr_can addr;
struct ifreq ifr;

// Configure CAN FD interface
if (setup_can_fd_interface(CAN_INTERFACE) < 0) {
return 1;
}

// Create socket
if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
perror(“Socket creation failed”);
return 1;
}

// Enable CAN FD support
int enable_canfd = 1;
if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &enable_canfd, sizeof(enable_canfd)) < 0) {
perror(“Failed to enable CAN FD support”);
close(s);
return 1;
}

// Specify CAN interface
strcpy(ifr.ifr_name, CAN_INTERFACE);
if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
perror(“IOCTL SIOCGIFINDEX failed”);
close(s);
return 1;
}

// Bind socket to CAN interface
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
if (bind(s, (struct sockaddr *)&addr, sizeof(addr))< 0) {
perror(“Bind failed”);
close(s);
return 1;
}

// Send test CAN FD frame (ID 0x001234EF, data 00.11.22.33.44.55.66.77)
uint8_t test_data[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
if (send_can_fd_frame(s, 0x001234EF, test_data, sizeof(test_data)) < 0) {
close(s);
return 1;
}

// Start receiving CAN messages
receive_can_messages(s);

close(s);
return 0;
}