EC100 ARM Industriecomputer Entwicklungshandbuch

EC100 ARM Industriecomputer Entwicklungshandbuch – Auf dem EC100 sind Node-RED 4.0 und NeuronEX-Lite bereits vorinstalliert, sodass er sofort für die Entwicklung von Edge-Anwendungen einsatzbereit ist.

Node-RED bietet eine visuelle Drag-and-Drop-Programmieroberfläche für die schnelle Erstellung von Geschäftslogik, während NeuronEX-Lite als schlanke Edge-Computing-Plattform dient, die durch Multiprotokoll-Kompatibilität eine Geräteanbindung im Millisekundenbereich ermöglicht. Diese Kombination vereinfacht die Entwicklung erheblich und ermöglicht die schnelle Bereitstellung von industriellen IoT-Lösungen.

Vorbereitung der Entwicklung

1. SSH-Tools

Wir empfehlen die Verwendung von MobaXterm, oder Sie können ein Programm Ihrer Wahl wählen. SSH-Tool.

2. Debugging-Tool für die serielle Schnittstelle

Wir empfehlen, XCOM zu verwenden oder Ihr bevorzugtes Spiel auszuwählen. Debugging-Tool für die serielle Schnittstelle.

3. Hardware-Tools

Zu den gängigen Debugging-Tools gehören: CAN-zu-USB-Adapter, 485-zu-USB-Adapter, Netzwerkkabel usw. Bitte stellen Sie diese selbst bereit.

4. Toolchain für die Cross-Kompilierung

Toolchain für die Cross-Kompilierung

Softwareumgebung

Betriebssystem: Embedded Linux 20.04.1; teilweise beschnitten

Node.js: v22.16.0

Python: python3.8

Shell: bash

GLIBC: 2.31

Peripherieschnittstellen

1. Serielle Schnittstelle

Der EC100 verfügt über zwei integrierte RS485-Transceiver.

Anmerkung: Bei der RS485-Übertragung und dem Empfang müssen sich die Benutzer keine Gedanken über den Wechsel zwischen Senden und Empfangen machen, da dies automatisch von der Hardware übernommen wird.

1.1. Schnelltest

Verwenden Sie zum Testen das Tool „minicom“. Genaue Anweisungen zur Verwendung finden Sie bei einer Suche auf Baidu oder bei DeepSeek.

1.2. Beispiel für einen Code-Test

#include

#include

#include

#include

#include

#include

#include

#include

#define BUFFER_SIZE 256

typedef struct {

int baud_rate; // Baudrate

int data_bits; // Datenbits (5, 6, 7, 8)

int stop_bits; // Stoppbits (1, 2)

char parity; // Parität (N: keine, O: ungerade, E: gerade)

} SerialConfig;

int set_serial_attr(int fd, SerialConfig *config)

{

struct termios tty;

if (tcgetattr(fd, &tty) < 0) { perror("tcgetattr"); return -1; } // Baudrate festlegen speed_t speed;

switch (config->baud_rate) {

Fall 9600: Geschwindigkeit = B9600; break;

Fall 19200: Geschwindigkeit = B19200; break;

Fall 38400: Geschwindigkeit = B38400; Pause;

Fall 57600: Geschwindigkeit = B57600; break;

Fall 115200: Geschwindigkeit = B115200; break;

Standard:

fprintf(stderr, "Nicht unterstützte Baudrate, es wird 115200 verwendet\n");

Geschwindigkeit = B115200;

}

cfsetispeed(&tty, speed);

cfsetospeed(&tty, speed);

// Daten festlegen

bits tty.c_cflag &= ~CSIZE;

switch (config->data_bits) {

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

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

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

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

Standard:

fprintf(stderr, "Nicht unterstützte Datenbits, es werden 8 verwendet\n");

tty.c_cflag |= CS8;

}

// Stoppbits setzen

if (config->stop_bits == 2) {

tty.c_cflag |= CSTOPB; } else {

tty.c_cflag &= ~CSTOPB; }

// Parität festlegen

switch (config->parity) {

Fall 'N':

Fall 'n': tty.c_cflag &= ~PARENB; // Keine Paritätsprüfung

Zeilumbruch;

Fall 'O':

case 'o': tty.c_cflag |= PARENB; // Ungerade Parität

tty.c_cflag |= PARODD; break;

Fall 'E':

case 'e': tty.c_cflag |= PARENB; // Gerade Parität

tty.c_cflag &= ~PARODD; break;

Standard:

fprintf(stderr, "Nicht unterstützte Parität, verwende N\n");

tty.c_cflag &= ~PARENB;

}

// Weitere Einstellungen

tty.c_cflag |= (CLOCAL | CREAD); // Empfänger- und lokalen Modus aktivieren

tty.c_cflag &= ~CRTSCTS; // Hardware-Flusskontrolle deaktivieren

tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // Roh-Eingabemodus

tty.c_oflag &= ~OPOST; // Rohausgabemodus

tty.c_cc[VMIN] = 1; // Mindestanzahl der zu lesenden Zeichen

tty.c_cc[VTIME] = 0; // Lese-Timeout (Einheit: 0,1 s)

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, "Verwendung: %s \n", argv[0]);

exit(EXIT_FAILURE);

}

portname = argv[1]; // Konfiguration der seriellen Schnittstelle

SerialConfig config = { .baud_rate = 115200, // Baudrate

.data_bits = 8, // Datenbits

.stop_bits = 1, // Stoppbits

.parity = 'N' // Parität (N: keine, O: ungerade, E: gerade)

};

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("Echo-Test für die serielle Schnittstelle läuft auf %s\n", portname);

printf("Konfiguration: %d Baudrate, %d Datenbits, %d Stoppbit, %c Parität\n", config.baud_rate, config.data_bits, config.stop_bits, config.parity);

printf("Drücken Sie Strg+C, um das Programm zu beenden.\n");

fd_set readfds;

char buffer[BUFFER_SIZE];

int n;

while (1) {

FD_ZERO(&readfds);

FD_SET(fd, &readfds); // Unbegrenzt auf eingehende Daten warten (kein 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("%d Bytes empfangen: %s\n", n, buffer); // Daten zurücksenden

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

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

perror("read");

Zeilumbruch;

}

}

}

}

close(fd);

return 0;

}

Kompilieren:  gcc rs485_example.c -o rs485_example

RS485-1-Testlauf: ./rs485_example/dev/ttyS4

2. LED

Das EC100 verfügt über insgesamt 4 Kontrollleuchten, von denen 2 vom Benutzer programmiert werden können.

Hinweis: Der IO-Index wird auf der Grundlage der IO-Nummer berechnet.

2.1. Schnelltest

#!/bin/bash

# Prüft, ob ein GPIO-Index angegeben wurde
if [ -z "$1" ]; then
echo "Verwendung: $0 "
exit 1
fi

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

# Prüfen, ob der GPIO bereits exportiert ist
if [ ! -d "$GPIO_PATH" ]; then
echo "GPIO $GPIO wird exportiert..."
echo "$GPIO" > "$EXPORT_PATH"
if [ $? -ne 0 ]; then
echo "Der Export des GPIO $GPIO ist fehlgeschlagen. Überprüfen Sie die Berechtigungen oder ob er gerade verwendet wird."
exit 1
fi
else
echo "GPIO $GPIO ist bereits exportiert."
fi

# GPIO-Richtung auf "Ausgang" setzen
echo "out" > "$GPIO_PATH/direction"

# Den Anfangswert auf "low" setzen
echo 0 > "$GPIO_PATH/value"

echo "GPIO $GPIO wird alle 1 Sekunde umgeschaltet. Drücke Strg+C, um den Vorgang zu beenden."

# Umschalt-Schleife starten
while true; do
echo 1 >"$GPIO_PATH/value"
sleep 1
echo 0 >"$GPIO_PATH/value"
sleep 1
done

Testlauf: bash led_example.sh 38

2.2. Beispiel für einen Code-Test

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/gpio.h>
#include <errno.h>

#define GPIO_CHIP "/dev/gpiochip1"     // Use gpiochip1
#define GPIO_LINE 38%32     // Offset of the GPIO to control within chip1
#define PERIOD_US 500000     // Period time (microseconds)

int main() {
struct gpiohandle_request req;
struct gpiohandle_data data;
int fd, ret;

// Open the GPIO character device
fd = open(GPIO_CHIP, O_RDWR);
if (fd < 0) {
perror("Failed to open GPIO device");
return EXIT_FAILURE;
}

// Configure GPIO request
memset(&req, 0, sizeof(req));
req.lineoffsets[0] = GPIO_LINE; // GPIO line number
req.flags = GPIOHANDLE_REQUEST_OUTPUT; // Set as output mode
req.default_values[0] = 0; // Initial value set to low
strcpy(req.consumer_label, "gpio-toggle"); // Consumer label
req.lines = 1; // Number of GPIO lines to control

// Request GPIO control
ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req);
if (ret < 0) {
perror("Failed to get GPIO handle");
close(fd);
return EXIT_FAILURE;
}

// Close GPIO character device (we already have line handle)
close(fd);

printf("Controlling GPIO chip1 line %d, period %.1f seconds...\n", GPIO_LINE, PERIOD_US/1000000.0);

// Periodically toggle GPIO level
while (1) {
data.values[0] = 1; // High level
ret = ioctl(req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &amp;data);
if (ret < 0) {
perror("Failed to set GPIO high level");
break;
}
usleep(PERIOD_US/2);

data.values[0] = 0; // Low level
ret = ioctl(req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);
if (ret < 0) {
perror("Failed to set GPIO low level");
break;
}

usleep(PERIOD_US/2);
}

// Close GPIO line handle
close(req.fd);

return EXIT_SUCCESS;
}

Testlauf:  ./led_example

3. CAN FD

Der EC100 verfügt über zwei Hochgeschwindigkeits-CAN-Schnittstellen

#Zunächst can0 und can1 initialisieren, Baudrate 500k wählen, canfd verwenden, dann can0 zum Empfangen von Daten und can1 zum Senden von Daten auswählen

ip link set can0 down

ip link set can1 down

ip link set can0 type can bitrate 500000 sample-point 0.8 dbitrate 2000000 sample-point 0.8 fd on

ip link set can1 type can bitrate 500000 sample-point 0.8 dbitrate 2000000 sample-point 0.8 fd on

ip link set can0 up

ip link set can1 up

echo 4096 > /sys/class/net/can0/tx_queue_len

echo 4096 > /sys/class/net/can1/tx_queue_len

candump can0 &

cansend can1 001234EF#00.11.22.33.44.55.66.77

3.2. Beispiel für eine Code-Prüfung

#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 the 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 the 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;
}

Zusammenstellung:  gcc can_example.c -o can_example

Testlauf:  ./can_example

4. Schaltflächen

EC100-Tasten: Internes Programm, das zum Neustarten oder Zurücksetzen der Konfiguration der Webseite des Geräts verwendet wird

Neustart: 1 Sekunde lang drücken und loslassen

Zurücksetzen + Neustart: Drücken Sie die Taste länger als 5 Sekunden

5. Hardware-Watchdog

Der Hardware-Watchdog des EC100 ist standardmäßig aktiviert und wird vom internen Programm verwaltet.

Watchdog-Zyklus: <30 Sekunden

Hinweis: Wenn das interne Programm angehalten wird, müssen Sie den Watchdog-Feed-Dienst manuell übernehmen; andernfalls wird das Gerät in regelmäßigen Abständen neu gestartet.

6. Netzwerkanschlüsse

Die Netzwerkanschlüsse sind in WAN- und LAN-Anschlüsse unterteilt, die vom internen Netzwerkprogramm verwaltet werden; die Konfiguration muss über die Weboberfläche erfolgen. Weitere Informationen finden Sie unter:

Dies ist eine Yuque-Inhaltskarte. Klicken Sie auf den Link, um sie anzuzeigen: https://iotrouter.yuque.com/zn3vdn/ec/go5fnig7b5xumq79?singleDoc

7. Mobilfunk

Der EC100 unterstützt 4G-Kommunikation (4G-Version); die Modulidentifizierung und die Einwahl werden vom internen Programm verwaltet, sodass sich die Benutzer darum nicht kümmern müssen. Weitere Informationen finden Sie unter:

Dies ist eine Yueque-Inhaltskarte; klicken Sie auf den Link, um sie anzuzeigen: https://iotrouter.yuque.com/zn3vdn/ec/go5fnig7b5xumq79?singleDoc

Softwareanwendungen

1. Internes Managementprogramm

Um die Bedienung zu vereinfachen, ist der EC100 mit dem integrierten Verwaltungsprogramm iotrouter ausgestattet, das beim Systemstart automatisch gestartet wird. Das Verwaltungsprogramm umfasst unter anderem die folgenden Funktionen:

• Geräteinitialisierung
• Netzwerkmanagement
• Aufsichtsbehörde
• Tastenüberwachung
• Firewall
• Gerätekonfigurationsdienst (Standardport 80; der Port für den Empfang kann geändert werden; Datei: /usr/local/src/iotrouter/web/user-config.js)
• Funktion zum Durchsuchen von Benutzerdateien (Standardpfad: /home; Pfad kann geändert werden; Datei: /usr/local/src/iotrouter/web/user-config.js)

Hinweis: Interne Programme müssen aktiv bleiben; andernfalls kann es vorkommen, dass das Gerät nicht normal hochfährt. Falls Benutzer interne Verwaltungsprogramme deaktivieren müssen, müssen sie die oben genannten Verwaltungsprogramm-Dienste selbst übernehmen.

2. NeuronEX

Auf dem EC100 ist NeuronEX-Lite vorinstalliert, das beim Systemstart automatisch gestartet wird und auf Port 8085 lauscht. Weitere Informationen finden Sie unter:

Dies ist eine Yuque-Inhaltskarte; klicken Sie auf den Link, um sie anzuzeigen: https://iotrouter.yuque.com/zn3vdn/ec/hdsb71i79vmfr8wd?singleDoc

• Servicestatus prüfen: systemctl status neuronex
• Dienst neu starten: systemctl restart neuronex
• Haltestelle: systemctl stop neuronex
• Dienststart deaktivieren: systemctl disable neuronex

3. Node-RED

EC100 verfügt über ein integriertes Node-RED, das beim Systemstart automatisch gestartet wird und auf Port 1880 lauscht. Weitere Informationen finden Sie unter:

Dies ist eine Yueque-Inhaltskarte. Klicken Sie auf den Link, um sie anzuzeigen: https://iotrouter.yuque.com/zn3vdn/ec/hdsb71i79vmfr8wd?singleDoc

• Servicestatus prüfen: systemctl status node-red
• Dienst neu starten: systemctl restart node-red
• Haltestelle: systemctl stop node-red
• Automatischen Start des Dienstes deaktivieren: systemctl disable node-red

4. Von Anwendern entwickelte Programme

Anwenderprogramme werden von den Benutzern frei entwickelt und laufen eigenständig, allerdings müssen die Benutzer den Arbeitsspeicher und den Speicherplatz verwalten, um Systemstörungen zu vermeiden. Software kann zur Autostart-Funktion des Systems hinzugefügt werden:

• /etc/rc.local
• systemd-Dienst
• /etc/init.d-System

Unser Unternehmen bietet außerdem maßgeschneiderte Softwareentwicklungsdienstleistungen an. Bitte Wenden Sie sich an unsere Vertriebsmitarbeiter falls Sie etwas benötigen.

Brennen von Bildern

Wann wird das Brennen von Images verwendet? Bei der Nutzung des Geräts kann es vorkommen, dass Benutzer versehentlich wichtige Systemdateien löschen, Systemkonfigurationsparameter (wie beispielsweise kritische Registrierungseinträge) falsch ändern oder versehentlich die Systempartition formatieren, was dazu führt, dass das System nicht mehr hochfahren kann oder fehlerhaft funktioniert. In solchen Fällen kann durch das Brennen des System-Images für das entsprechende Gerät das System schnell wieder in seinen ursprünglichen Normalzustand versetzt werden.

1. Brennwerkzeuge

Das Brenn-Toolkit ist umfangreich; wenden Sie sich bitte an den technischen Support oder den Vertrieb, um es zu erhalten.

Fahrer: Fahrer

Werkzeug: Brennwerkzeug

*.img: Werks-Image

2. Treiberinstallation

Installieren: \DriverDriverInstall.exe

3. Verbrennen

• Öffnen Sie die Datei „\tool\RKDevTool.exe“.
• Klicken Sie auf „Firmware aktualisieren“, um zur Brennoberfläche zu gelangen.
• Klicken Sie auf „Firmware“, um das Image auszuwählen.

Schließen Sie den Watchdog des EC100 kurz (der Watchdog muss während des Brennvorgangs kurzgeschlossen werden; das Gerät startet sonst unendlich oft neu).

Halten Sie die Download-Taste gedrückt, um den EC100 einzuschalten.

Während des Brennvorgangs erscheint unten die Meldung “Found One MASKROM Device”, was darauf hinweist, dass das Gerät erkannt wurde.

Klicken Sie auf “Upgrade”, um den Brennvorgang zu starten. Das Brennprotokoll wird daraufhin im Protokollfenster auf der rechten Seite angezeigt.

In der letzten Zeile wird “Success” angezeigt, was bedeutet, dass das Brennen erfolgreich war.