mirror of
https://github.com/intrepidcs/libicsneo.git
synced 2026-08-05 01:18:36 +02:00
C2: Add Ethernet message support
This commit is contained in:
David Rebbe
committed by
Kyle Schwarz
Kyle Schwarz
parent
87f45e060e
commit
9ae3e115fc
@@ -8,6 +8,9 @@ option(LIBICSNEO_BUILD_C2_RECONNECT_EXAMPLE "Build the C2 reconnect example." ON
|
||||
option(LIBICSNEO_BUILD_C2_DEVICE_INFO_EXAMPLE "Build the C2 device info example." ON)
|
||||
option(LIBICSNEO_BUILD_C2_LIN_EXAMPLE "Build the C2 LIN example." ON)
|
||||
option(LIBICSNEO_BUILD_C2_LIN_TRANSMIT_EXAMPLE "Build the C2 LIN transmit example." ON)
|
||||
option(LIBICSNEO_BUILD_C2_ETHERNET_TRANSMIT_EXAMPLE "Build the C2 ethernet transmit example." ON)
|
||||
option(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE "Build the C2 ethernet receive example." ON)
|
||||
option(LIBICSNEO_BUILD_C2_T1S_LOOPBACK_EXAMPLE "Build the C2 RAD-Comet3 T1S loopback example." ON)
|
||||
option(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE "Build the simple C++ example." ON)
|
||||
option(LIBICSNEO_BUILD_CPP_INTERACTIVE_EXAMPLE "Build the command-line interactive C++ example." ON)
|
||||
option(LIBICSNEO_BUILD_CPP_A2B_EXAMPLE "Build the A2B example." ON)
|
||||
@@ -67,6 +70,18 @@ if(LIBICSNEO_BUILD_C2_LIN_TRANSMIT_EXAMPLE)
|
||||
add_subdirectory(c2/lin_transmit)
|
||||
endif()
|
||||
|
||||
if(LIBICSNEO_BUILD_C2_ETHERNET_TRANSMIT_EXAMPLE)
|
||||
add_subdirectory(c2/ethernet_transmit)
|
||||
endif()
|
||||
|
||||
if(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE)
|
||||
add_subdirectory(c2/ethernet_receive)
|
||||
endif()
|
||||
|
||||
if(LIBICSNEO_BUILD_C2_T1S_LOOPBACK_EXAMPLE)
|
||||
add_subdirectory(c2/t1s_loopback)
|
||||
endif()
|
||||
|
||||
if(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE)
|
||||
add_subdirectory(cpp/simple)
|
||||
endif()
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
add_executable(libicsneoc2-ethernet-receive-example src/main.c)
|
||||
target_link_libraries(libicsneoc2-ethernet-receive-example icsneoc2-static)
|
||||
|
||||
if(WIN32)
|
||||
target_compile_definitions(libicsneoc2-ethernet-receive-example PRIVATE _CRT_SECURE_NO_WARNINGS)
|
||||
endif()
|
||||
@@ -0,0 +1,223 @@
|
||||
#include <icsneo/icsneoc2.h>
|
||||
#include <icsneo/icsneoc2messages.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
void sleep_ms(uint32_t ms) {
|
||||
#ifdef _WIN32
|
||||
Sleep(ms);
|
||||
#else
|
||||
sleep(ms / 1000);
|
||||
#endif
|
||||
}
|
||||
|
||||
int print_error_code(const char* message, icsneoc2_error_t error) {
|
||||
char error_str[64];
|
||||
size_t error_str_len = sizeof(error_str);
|
||||
icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
|
||||
if(res != icsneoc2_error_success) {
|
||||
printf("%s: Failed to get string for error code %d with error code %d\n", message, error, res);
|
||||
return res;
|
||||
}
|
||||
printf("%s: \"%s\" (%u)\n", message, error_str, error);
|
||||
return (int)error;
|
||||
}
|
||||
|
||||
void print_events(void) {
|
||||
icsneoc2_event_t* events[256] = {0};
|
||||
size_t events_count = 256;
|
||||
for(size_t i = 0; i < events_count; ++i) {
|
||||
icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
|
||||
if(res != icsneoc2_error_success) {
|
||||
(void)print_error_code("\tFailed to get events", res);
|
||||
return;
|
||||
}
|
||||
if(events[i] == NULL) {
|
||||
events_count = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for(size_t i = 0; i < events_count; i++) {
|
||||
char description[255] = {0};
|
||||
size_t description_length = 255;
|
||||
icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_error_code("\tFailed to get event description", res);
|
||||
continue;
|
||||
}
|
||||
printf("\tEvent %zu: %s\n", i, description);
|
||||
}
|
||||
for(size_t i = 0; i < events_count; i++) {
|
||||
icsneoc2_event_free(events[i]);
|
||||
}
|
||||
if(events_count > 0) {
|
||||
printf("\tReceived %zu events\n", events_count);
|
||||
}
|
||||
}
|
||||
|
||||
void print_mac(const char* label, const uint8_t* mac) {
|
||||
printf("%s: %02x:%02x:%02x:%02x:%02x:%02x", label, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
||||
}
|
||||
|
||||
int process_ethernet_message(icsneoc2_message_t* message, size_t index) {
|
||||
icsneoc2_netid_t netid = 0;
|
||||
char netid_name[128] = {0};
|
||||
size_t netid_name_length = 128;
|
||||
|
||||
icsneoc2_error_t res = icsneoc2_message_netid_get(message, &netid);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("\tFailed to get netid", res);
|
||||
}
|
||||
res = icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("\tFailed to get netid name", res);
|
||||
}
|
||||
|
||||
/* Get data length first */
|
||||
size_t data_length = 0;
|
||||
res = icsneoc2_message_data_get(message, NULL, &data_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("\tFailed to get data length", res);
|
||||
}
|
||||
|
||||
printf("\t%zu) Ethernet Frame on %s (0x%x) - %zu bytes\n", index, netid_name, netid, data_length);
|
||||
|
||||
/* Get MAC addresses and EtherType if we have enough data */
|
||||
uint8_t dst_mac[6] = {0};
|
||||
uint8_t src_mac[6] = {0};
|
||||
uint16_t ether_type = 0;
|
||||
|
||||
res = icsneoc2_message_eth_mac_get(message, dst_mac, src_mac);
|
||||
if(res == icsneoc2_error_success) {
|
||||
printf("\t ");
|
||||
print_mac("Dst", dst_mac);
|
||||
printf(" ");
|
||||
print_mac("Src", src_mac);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
res = icsneoc2_message_eth_ether_type_get(message, ðer_type);
|
||||
if(res == icsneoc2_error_success) {
|
||||
printf("\t EtherType: 0x%04x\n", ether_type);
|
||||
}
|
||||
|
||||
/* Get flags */
|
||||
icsneoc2_message_eth_flags_t flags = 0;
|
||||
res = icsneoc2_message_eth_props_get(message, &flags, NULL, NULL);
|
||||
if(res == icsneoc2_error_success && flags != 0) {
|
||||
printf("\t Flags: 0x%" PRIx64, flags);
|
||||
if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR) printf(" [CRC_ERROR]");
|
||||
if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT) printf(" [FRAME_TOO_SHORT]");
|
||||
if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED) printf(" [TX_ABORTED]");
|
||||
if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED) printf(" [FCS_VERIFIED]");
|
||||
if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_PREEMPTION_ENABLED) printf(" [PREEMPTION]");
|
||||
if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_IS_T1S) printf(" [T1S]");
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/* Print data bytes */
|
||||
uint8_t data[1600] = {0};
|
||||
res = icsneoc2_message_data_get(message, data, &data_length);
|
||||
if(res == icsneoc2_error_success) {
|
||||
printf("\t Data:\n\t ");
|
||||
for(size_t x = 0; x < data_length; x++) {
|
||||
printf("0x%02x ", data[x]);
|
||||
if((x + 1) % 20 == 0 && x + 1 < data_length) {
|
||||
printf("\n\t ");
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
return icsneoc2_error_success;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
/* Open the first available device */
|
||||
printf("Opening first available device...\n");
|
||||
icsneoc2_device_t* device = NULL;
|
||||
icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to open first device", res);
|
||||
}
|
||||
|
||||
/* Get a description of the opened device */
|
||||
char description[255] = {0};
|
||||
size_t description_length = 255;
|
||||
res = icsneoc2_device_description_get(device, description, &description_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to get device description", res);
|
||||
}
|
||||
printf("Opened device: %s\n", description);
|
||||
|
||||
/* Wait for Ethernet frames to arrive */
|
||||
const int duration_seconds = 10;
|
||||
printf("Listening for Ethernet frames for %d seconds...\n", duration_seconds);
|
||||
sleep_ms(duration_seconds * 1000);
|
||||
|
||||
/* Retrieve and process messages */
|
||||
icsneoc2_message_t* messages[20000] = {0};
|
||||
size_t message_count = 20000;
|
||||
size_t eth_count = 0;
|
||||
|
||||
for(size_t i = 0; i < message_count; ++i) {
|
||||
res = icsneoc2_device_message_get(device, &messages[i], 0);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_events();
|
||||
return print_error_code("Failed to get messages", res);
|
||||
}
|
||||
if(messages[i] == NULL) {
|
||||
message_count = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
printf("Got %zu messages total, filtering for Ethernet...\n", message_count);
|
||||
|
||||
for(size_t i = 0; i < message_count; i++) {
|
||||
icsneoc2_message_t* message = messages[i];
|
||||
|
||||
/* Check if this is a TX echo (skip it) */
|
||||
bool is_tx = false;
|
||||
res = icsneoc2_message_is_transmit(message, &is_tx);
|
||||
if(res != icsneoc2_error_success || is_tx) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Check if this is an Ethernet message */
|
||||
bool is_ethernet = false;
|
||||
res = icsneoc2_message_is_ethernet(message, &is_ethernet);
|
||||
if(res != icsneoc2_error_success || !is_ethernet) {
|
||||
continue;
|
||||
}
|
||||
|
||||
process_ethernet_message(message, eth_count);
|
||||
eth_count++;
|
||||
}
|
||||
|
||||
printf("Received %zu Ethernet frames out of %zu total messages\n", eth_count, message_count);
|
||||
|
||||
/* Free all messages */
|
||||
for(size_t i = 0; i < message_count; ++i) {
|
||||
icsneoc2_message_free(messages[i]);
|
||||
}
|
||||
|
||||
/* Print any events */
|
||||
print_events();
|
||||
|
||||
/* Close the device */
|
||||
printf("Closing device...\n");
|
||||
res = icsneoc2_device_close(device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to close device", res);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
add_executable(libicsneoc2-ethernet-transmit-example src/main.c)
|
||||
target_link_libraries(libicsneoc2-ethernet-transmit-example icsneoc2-static)
|
||||
|
||||
if(WIN32)
|
||||
target_compile_definitions(libicsneoc2-ethernet-transmit-example PRIVATE _CRT_SECURE_NO_WARNINGS)
|
||||
endif()
|
||||
@@ -0,0 +1,204 @@
|
||||
#include <icsneo/icsneoc2.h>
|
||||
#include <icsneo/icsneoc2messages.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
int print_error_code(const char* message, icsneoc2_error_t error) {
|
||||
char error_str[64];
|
||||
size_t error_str_len = sizeof(error_str);
|
||||
icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
|
||||
if(res != icsneoc2_error_success) {
|
||||
printf("%s: Failed to get string for error code %d with error code %d\n", message, error, res);
|
||||
return res;
|
||||
}
|
||||
printf("%s: \"%s\" (%u)\n", message, error_str, error);
|
||||
return (int)error;
|
||||
}
|
||||
|
||||
void print_events(void) {
|
||||
icsneoc2_event_t* events[256] = {0};
|
||||
size_t events_count = 256;
|
||||
for(size_t i = 0; i < events_count; ++i) {
|
||||
icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
|
||||
if(res != icsneoc2_error_success) {
|
||||
(void)print_error_code("\tFailed to get events", res);
|
||||
return;
|
||||
}
|
||||
if(events[i] == NULL) {
|
||||
events_count = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for(size_t i = 0; i < events_count; i++) {
|
||||
char description[255] = {0};
|
||||
size_t description_length = 255;
|
||||
icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_error_code("\tFailed to get event description", res);
|
||||
continue;
|
||||
}
|
||||
printf("\tEvent %zu: %s\n", i, description);
|
||||
}
|
||||
for(size_t i = 0; i < events_count; i++) {
|
||||
icsneoc2_event_free(events[i]);
|
||||
}
|
||||
if(events_count > 0) {
|
||||
printf("\tReceived %zu events\n", events_count);
|
||||
}
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
/* Open the first available device */
|
||||
printf("Opening first available device...\n");
|
||||
icsneoc2_device_t* device = NULL;
|
||||
icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to open first device", res);
|
||||
}
|
||||
|
||||
/* Get a description of the opened device */
|
||||
char description[255] = {0};
|
||||
size_t description_length = 255;
|
||||
res = icsneoc2_device_description_get(device, description, &description_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to get device description", res);
|
||||
}
|
||||
printf("Opened device: %s\n", description);
|
||||
|
||||
icsneoc2_netid_t tx_networks[255] = {0};
|
||||
size_t tx_net_count = sizeof(tx_networks) / sizeof(tx_networks[0]);
|
||||
res = icsneoc2_device_supported_tx_networks_get(device, tx_networks, &tx_net_count);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_events();
|
||||
return print_error_code("Failed to get TX networks", res);
|
||||
}
|
||||
|
||||
/* Filter for Ethernet/AutomotiveEthernet networks */
|
||||
icsneoc2_netid_t eth_networks[64] = {0};
|
||||
char eth_names[64][128] = {{0}};
|
||||
size_t eth_count = 0;
|
||||
for(size_t i = 0; i < tx_net_count && eth_count < 64; i++) {
|
||||
/* Create a temporary message to check network type */
|
||||
icsneoc2_message_t* tmp = NULL;
|
||||
res = icsneoc2_message_eth_create(&tmp);
|
||||
if(res != icsneoc2_error_success) continue;
|
||||
res = icsneoc2_message_netid_set(tmp, tx_networks[i]);
|
||||
if(res != icsneoc2_error_success) { icsneoc2_message_free(tmp); continue; }
|
||||
icsneoc2_network_type_t ntype = 0;
|
||||
res = icsneoc2_message_network_type_get(tmp, &ntype);
|
||||
icsneoc2_message_free(tmp);
|
||||
if(res != icsneoc2_error_success) continue;
|
||||
if(ntype == icsneoc2_network_type_ethernet || ntype == icsneoc2_network_type_automotive_ethernet) {
|
||||
eth_networks[eth_count] = tx_networks[i];
|
||||
size_t name_len = 128;
|
||||
icsneoc2_netid_name_get(tx_networks[i], eth_names[eth_count], &name_len);
|
||||
eth_count++;
|
||||
}
|
||||
}
|
||||
|
||||
if(eth_count == 0) {
|
||||
printf("No Ethernet TX networks available on this device.\n");
|
||||
icsneoc2_device_close(device);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Let the user pick */
|
||||
printf("Available Ethernet TX networks:\n");
|
||||
for(size_t i = 0; i < eth_count; i++) {
|
||||
printf(" %zu) %s\n", i + 1, eth_names[i]);
|
||||
}
|
||||
printf("Select network [1-%zu]: ", eth_count);
|
||||
int selection = 0;
|
||||
if(scanf("%d", &selection) != 1 || selection < 1 || (size_t)selection > eth_count) {
|
||||
printf("Invalid selection, using first available.\n");
|
||||
selection = 1;
|
||||
}
|
||||
icsneoc2_netid_t netid = eth_networks[selection - 1];
|
||||
printf("Selected: %s\n", eth_names[selection - 1]);
|
||||
/* Transmit Ethernet frames */
|
||||
const size_t msg_count = 10;
|
||||
printf("Transmitting %zu Ethernet frames on %s...\n", msg_count, eth_names[selection - 1]);
|
||||
|
||||
for(size_t i = 0; i < msg_count; i++) {
|
||||
/* Create an Ethernet message */
|
||||
icsneoc2_message_t* message = NULL;
|
||||
res = icsneoc2_message_eth_create(&message);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_events();
|
||||
return print_error_code("Failed to create Ethernet message", res);
|
||||
}
|
||||
|
||||
/* Set the network ID */
|
||||
res = icsneoc2_message_netid_set(message, netid );
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
print_events();
|
||||
return print_error_code("Failed to set netid", res);
|
||||
}
|
||||
|
||||
/* Build Ethernet frame data:
|
||||
* Bytes 0-5: Destination MAC (00:FC:70:00:01:02)
|
||||
* Bytes 6-11: Source MAC (00:FC:70:00:01:01)
|
||||
* Bytes 12-13: EtherType (0x0800 = IPv4)
|
||||
* Bytes 14+: Payload
|
||||
*/
|
||||
uint8_t frame_data[] = {
|
||||
0x00, 0xFC, 0x70, 0x00, 0x01, 0x02, /* Destination MAC */
|
||||
0x00, 0xFC, 0x70, 0x00, 0x01, 0x01, /* Source MAC */
|
||||
0x08, 0x00, /* EtherType (IPv4) */
|
||||
0x45, 0x00, 0x00, 0x20, /* IPv4: ver/IHL, DSCP, total length (32) */
|
||||
0x00, 0x00, 0x00, 0x00, /* Identification, flags/fragment offset */
|
||||
0x40, 0x11, 0x00, 0x00, /* TTL (64), protocol (UDP), checksum (0) */
|
||||
0xC0, 0xA8, 0x01, 0x01, /* Source IP (192.168.1.1) */
|
||||
0xC0, 0xA8, 0x01, 0x02, /* Destination IP (192.168.1.2) */
|
||||
0xC3, 0x50, 0xC3, 0x51, /* UDP: src port (50000), dst port (50001) */
|
||||
0x00, 0x0C, 0x00, 0x00, /* UDP: length (12), checksum (0) */
|
||||
0x00, 0x00, 0x00, 0x00 /* UDP payload (4 bytes, frame counter) */
|
||||
};
|
||||
|
||||
/* Put the frame counter in the UDP payload */
|
||||
frame_data[42] = (uint8_t)((i >> 24) & 0xFF);
|
||||
frame_data[43] = (uint8_t)((i >> 16) & 0xFF);
|
||||
frame_data[44] = (uint8_t)((i >> 8) & 0xFF);
|
||||
frame_data[45] = (uint8_t)(i & 0xFF);
|
||||
|
||||
res = icsneoc2_message_data_set(message, frame_data, sizeof(frame_data));
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
print_events();
|
||||
return print_error_code("Failed to set frame data", res);
|
||||
}
|
||||
|
||||
/* Transmit the message */
|
||||
res = icsneoc2_device_message_transmit(device, message);
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
print_events();
|
||||
return print_error_code("Failed to transmit Ethernet frame", res);
|
||||
}
|
||||
|
||||
icsneoc2_message_free(message);
|
||||
printf("\tTransmitted frame %zu\n", i + 1);
|
||||
}
|
||||
|
||||
printf("Successfully transmitted %zu Ethernet frames\n", msg_count);
|
||||
|
||||
/* Print any events */
|
||||
print_events();
|
||||
|
||||
/* Close the device */
|
||||
printf("Closing device...\n");
|
||||
res = icsneoc2_device_close(device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to close device", res);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
add_executable(libicsneoc2-t1s-loopback-example src/main.c)
|
||||
target_link_libraries(libicsneoc2-t1s-loopback-example icsneoc2-static)
|
||||
|
||||
if(WIN32)
|
||||
target_compile_definitions(libicsneoc2-t1s-loopback-example PRIVATE _CRT_SECURE_NO_WARNINGS)
|
||||
endif()
|
||||
@@ -0,0 +1,643 @@
|
||||
#include <icsneo/icsneoc2.h>
|
||||
#include <icsneo/icsneoc2messages.h>
|
||||
#include <icsneo/icsneoc2settings.h>
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#define TX_LOCAL_ID 0u
|
||||
#define RX_LOCAL_ID 1u
|
||||
#define T1S_MAX_NODES 8u
|
||||
#define T1S_TX_OPP_TIMER 20u
|
||||
#define T1S_BURST_TIMER 64u
|
||||
#define T1S_MAX_BURST 128u
|
||||
#define LOOPBACK_ETHER_TYPE 0x9000u
|
||||
#define LOOPBACK_FRAME_SIZE 60u
|
||||
|
||||
typedef struct selectable_network {
|
||||
icsneoc2_netid_t netid;
|
||||
char name[64];
|
||||
} selectable_network_t;
|
||||
|
||||
/* Sleep for a short period while waiting for the device to apply settings. */
|
||||
static void sleep_ms(uint32_t ms);
|
||||
|
||||
/* Print a readable error string and return the same failure code to the caller. */
|
||||
static int print_error_code(const char* message, icsneoc2_error_t error);
|
||||
|
||||
/* Drain and print queued library events when the example encounters an error. */
|
||||
static void print_events(void);
|
||||
|
||||
/* Convert a netid to a readable name such as "AE 02". */
|
||||
static int get_netid_name(icsneoc2_netid_t netid, char* buffer, size_t buffer_size);
|
||||
|
||||
/* Gather the device's TX and RX networks, keeping only automotive Ethernet ports. */
|
||||
static int get_available_networks(const icsneoc2_device_t* device,
|
||||
selectable_network_t* tx_networks,
|
||||
size_t* tx_count,
|
||||
selectable_network_t* rx_networks,
|
||||
size_t* rx_count);
|
||||
|
||||
/* Prompt the user to choose one TX or RX network from the filtered list. */
|
||||
static int prompt_for_network_selection(const char* label, const selectable_network_t* networks, size_t count, icsneoc2_netid_t* selected_netid, char* selected_name, size_t selected_name_size);
|
||||
|
||||
/* Apply the small set of T1S settings needed for this two-port loopback example. */
|
||||
static int configure_t1s_port(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t local_id);
|
||||
|
||||
/* Print a MAC address in a compact human-readable form. */
|
||||
static void print_mac(const char* label, const uint8_t* mac);
|
||||
|
||||
/* Print payload bytes as hex for the TX echo and RX frame output. */
|
||||
static void print_payload_hex(const uint8_t* data, size_t length);
|
||||
|
||||
/* Build one recognizable Ethernet frame that both transmit and receive paths share. */
|
||||
static void build_loopback_frame(uint8_t* frame_data, size_t frame_size, const char* tx_name, const char* rx_name);
|
||||
|
||||
/* Check whether a received Ethernet frame matches the loopback frame this example sent. */
|
||||
static int message_matches_loopback_frame(icsneoc2_message_t* message, const uint8_t* expected, size_t expected_length, bool* matches);
|
||||
|
||||
/* Print the key details of an Ethernet message found during the loopback test. */
|
||||
static int print_ethernet_message(icsneoc2_message_t* message, const char* direction_label);
|
||||
|
||||
/* Transmit the loopback Ethernet frame on the selected TX port. */
|
||||
static int transmit_loopback_frame(icsneoc2_device_t* device, icsneoc2_netid_t tx_netid, const char* tx_name, const char* rx_name);
|
||||
|
||||
/* Poll until the example sees both the TX echo and the matching RX frame. */
|
||||
static int poll_for_loopback_messages(icsneoc2_device_t* device,
|
||||
icsneoc2_netid_t tx_netid,
|
||||
icsneoc2_netid_t rx_netid,
|
||||
const char* tx_name,
|
||||
const char* rx_name,
|
||||
const uint8_t* expected_frame,
|
||||
size_t expected_frame_length);
|
||||
|
||||
int main(void) {
|
||||
icsneoc2_device_t* device = NULL;
|
||||
icsneoc2_error_t res;
|
||||
char description[255] = {0};
|
||||
char serial[64] = {0};
|
||||
size_t description_length = sizeof(description);
|
||||
size_t serial_length = sizeof(serial);
|
||||
selectable_network_t available_tx_networks[128] = {0};
|
||||
selectable_network_t available_rx_networks[128] = {0};
|
||||
size_t available_tx_count = 0;
|
||||
size_t available_rx_count = 0;
|
||||
icsneoc2_netid_t tx_netid = 0;
|
||||
icsneoc2_netid_t rx_netid = 0;
|
||||
uint8_t expected_frame[LOOPBACK_FRAME_SIZE] = {0};
|
||||
char tx_name[64] = {0};
|
||||
char rx_name[64] = {0};
|
||||
int status = 1;
|
||||
|
||||
printf("RAD-Comet3 C2 T1S loopback example\n");
|
||||
printf("Opening first available RAD-Comet3...\n");
|
||||
|
||||
res = icsneoc2_device_open_first(icsneoc2_devicetype_rad_comet3, icsneoc2_open_options_default, &device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to open a RAD-Comet3", res);
|
||||
}
|
||||
|
||||
res = icsneoc2_device_description_get(device, description, &description_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_error_code("Failed to get device description", res);
|
||||
goto cleanup;
|
||||
}
|
||||
res = icsneoc2_device_serial_get(device, serial, &serial_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_error_code("Failed to get device serial", res);
|
||||
goto cleanup;
|
||||
}
|
||||
printf("Opened device: %s [%s]\n", description, serial);
|
||||
|
||||
if(get_available_networks(device, available_tx_networks, &available_tx_count, available_rx_networks, &available_rx_count) != 0) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if(prompt_for_network_selection("TX", available_tx_networks, available_tx_count, &tx_netid, tx_name, sizeof(tx_name)) != 0) {
|
||||
goto cleanup;
|
||||
}
|
||||
if(prompt_for_network_selection("RX", available_rx_networks, available_rx_count, &rx_netid, rx_name, sizeof(rx_name)) != 0) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
printf("Selected loopback wiring: %s connected to %s\n", tx_name, rx_name);
|
||||
|
||||
if(tx_netid == rx_netid) {
|
||||
printf("TX and RX networks are the same. This example is intended for a physical loopback between two ports.\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
// Use the same expected frame bytes for transmit and for receive-side matching.
|
||||
build_loopback_frame(expected_frame, sizeof(expected_frame), tx_name, rx_name);
|
||||
|
||||
res = icsneoc2_settings_refresh(device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_error_code("Failed to refresh device settings", res);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if(configure_t1s_port(device, tx_netid, TX_LOCAL_ID) != 0) {
|
||||
goto cleanup;
|
||||
}
|
||||
if(configure_t1s_port(device, rx_netid, RX_LOCAL_ID) != 0) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
printf("Applying T1S settings to the device.\n");
|
||||
printf("Note: icsneoc2_settings_apply() persists these settings on the device.\n");
|
||||
res = icsneoc2_settings_apply(device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
print_error_code("Failed to apply T1S settings", res);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
sleep_ms(500);
|
||||
|
||||
if(transmit_loopback_frame(device, tx_netid, tx_name, rx_name) != 0) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if(poll_for_loopback_messages(device, tx_netid, rx_netid, tx_name, rx_name, expected_frame, sizeof(expected_frame)) != 0) {
|
||||
print_events();
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
status = 0;
|
||||
|
||||
cleanup:
|
||||
if(device != NULL) {
|
||||
res = icsneoc2_device_close(device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
(void)print_error_code("Failed to close device", res);
|
||||
}
|
||||
res = icsneoc2_device_free(device);
|
||||
if(res != icsneoc2_error_success) {
|
||||
(void)print_error_code("Failed to free device", res);
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static void sleep_ms(uint32_t ms) {
|
||||
#ifdef _WIN32
|
||||
Sleep(ms);
|
||||
#else
|
||||
usleep(ms * 1000);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int print_error_code(const char* message, icsneoc2_error_t error) {
|
||||
char error_str[64] = {0};
|
||||
size_t error_str_len = sizeof(error_str);
|
||||
icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
|
||||
if(res != icsneoc2_error_success) {
|
||||
printf("%s: failed to get string for error code %u with error code %u\n", message, error, res);
|
||||
return (int)res;
|
||||
}
|
||||
printf("%s: \"%s\" (%u)\n", message, error_str, error);
|
||||
return (int)error;
|
||||
}
|
||||
|
||||
static void print_events(void) {
|
||||
icsneoc2_event_t* events[64] = {0};
|
||||
size_t count = sizeof(events) / sizeof(events[0]);
|
||||
|
||||
for(size_t i = 0; i < count; ++i) {
|
||||
icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
|
||||
if(res != icsneoc2_error_success) {
|
||||
(void)print_error_code("Failed to get events", res);
|
||||
return;
|
||||
}
|
||||
if(events[i] == NULL) {
|
||||
count = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < count; ++i) {
|
||||
char description[255] = {0};
|
||||
size_t description_length = sizeof(description);
|
||||
icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
|
||||
if(res == icsneoc2_error_success) {
|
||||
printf("Event %zu: %s\n", i, description);
|
||||
}
|
||||
icsneoc2_event_free(events[i]);
|
||||
}
|
||||
}
|
||||
|
||||
static int get_netid_name(icsneoc2_netid_t netid, char* buffer, size_t buffer_size) {
|
||||
size_t length = buffer_size;
|
||||
icsneoc2_error_t res = icsneoc2_netid_name_get(netid, buffer, &length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to get netid name", res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_available_networks(const icsneoc2_device_t* device,
|
||||
selectable_network_t* tx_networks,
|
||||
size_t* tx_count,
|
||||
selectable_network_t* rx_networks,
|
||||
size_t* rx_count) {
|
||||
icsneoc2_netid_t supported_tx_networks[128] = {0};
|
||||
icsneoc2_netid_t supported_rx_networks[128] = {0};
|
||||
size_t tx_supported_count = sizeof(supported_tx_networks) / sizeof(supported_tx_networks[0]);
|
||||
size_t rx_supported_count = sizeof(supported_rx_networks) / sizeof(supported_rx_networks[0]);
|
||||
icsneoc2_message_t* probe = NULL;
|
||||
icsneoc2_network_type_t network_type = 0;
|
||||
icsneoc2_error_t res = icsneoc2_device_supported_tx_networks_get(device, supported_tx_networks, &tx_supported_count);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to get supported TX networks", res);
|
||||
}
|
||||
res = icsneoc2_device_supported_rx_networks_get(device, supported_rx_networks, &rx_supported_count);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to get supported RX networks", res);
|
||||
}
|
||||
|
||||
*tx_count = 0;
|
||||
*rx_count = 0;
|
||||
|
||||
// Reuse one temporary Ethernet message to classify each netid by network type.
|
||||
res = icsneoc2_message_eth_create(&probe);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to create temporary Ethernet message", res);
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < tx_supported_count; ++i) {
|
||||
res = icsneoc2_message_netid_set(probe, supported_tx_networks[i]);
|
||||
if(res != icsneoc2_error_success) {
|
||||
continue;
|
||||
}
|
||||
res = icsneoc2_message_network_type_get(probe, &network_type);
|
||||
if(res != icsneoc2_error_success || network_type != icsneoc2_network_type_automotive_ethernet) {
|
||||
continue;
|
||||
}
|
||||
tx_networks[*tx_count].netid = supported_tx_networks[i];
|
||||
if(get_netid_name(supported_tx_networks[i], tx_networks[*tx_count].name, sizeof(tx_networks[*tx_count].name)) != 0) {
|
||||
icsneoc2_message_free(probe);
|
||||
return 1;
|
||||
}
|
||||
(*tx_count)++;
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < rx_supported_count; ++i) {
|
||||
res = icsneoc2_message_netid_set(probe, supported_rx_networks[i]);
|
||||
if(res != icsneoc2_error_success) {
|
||||
continue;
|
||||
}
|
||||
res = icsneoc2_message_network_type_get(probe, &network_type);
|
||||
if(res != icsneoc2_error_success || network_type != icsneoc2_network_type_automotive_ethernet) {
|
||||
continue;
|
||||
}
|
||||
rx_networks[*rx_count].netid = supported_rx_networks[i];
|
||||
if(get_netid_name(supported_rx_networks[i], rx_networks[*rx_count].name, sizeof(rx_networks[*rx_count].name)) != 0) {
|
||||
icsneoc2_message_free(probe);
|
||||
return 1;
|
||||
}
|
||||
(*rx_count)++;
|
||||
}
|
||||
icsneoc2_message_free(probe);
|
||||
|
||||
if(*tx_count == 0) {
|
||||
printf("No automotive Ethernet TX networks are available on this device.\n");
|
||||
return 1;
|
||||
}
|
||||
if(*rx_count == 0) {
|
||||
printf("No automotive Ethernet RX networks are available on this device.\n");
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int prompt_for_network_selection(const char* label, const selectable_network_t* networks, size_t count, icsneoc2_netid_t* selected_netid, char* selected_name, size_t selected_name_size) {
|
||||
char input[32] = {0};
|
||||
char* end_ptr = NULL;
|
||||
long selected_index = 0;
|
||||
|
||||
if(!label || !networks || count == 0 || !selected_netid || !selected_name || selected_name_size == 0) {
|
||||
return print_error_code("Invalid network selection parameters", icsneoc2_error_invalid_parameters);
|
||||
}
|
||||
|
||||
printf("Available automotive Ethernet %s networks:\n", label);
|
||||
for(size_t i = 0; i < count; ++i) {
|
||||
printf(" %zu) %s\n", i + 1, networks[i].name);
|
||||
}
|
||||
printf("Select %s network [1-%zu, default 1]: ", label, count);
|
||||
|
||||
if(fgets(input, sizeof(input), stdin) == NULL || input[0] == '\n') {
|
||||
selected_index = 1;
|
||||
} else {
|
||||
selected_index = strtol(input, &end_ptr, 10);
|
||||
if(end_ptr == input || selected_index < 1 || (size_t)selected_index > count) {
|
||||
printf("Invalid selection, using %s.\n", networks[0].name);
|
||||
selected_index = 1;
|
||||
}
|
||||
}
|
||||
|
||||
*selected_netid = networks[selected_index - 1].netid;
|
||||
strncpy(selected_name, networks[selected_index - 1].name, selected_name_size - 1);
|
||||
selected_name[selected_name_size - 1] = '\0';
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int configure_t1s_port(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t local_id) {
|
||||
char netid_name[64] = {0};
|
||||
icsneoc2_error_t res;
|
||||
bool termination = false;
|
||||
|
||||
if(get_netid_name(netid, netid_name, sizeof(netid_name)) != 0) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
printf("Configuring %s: PLCA on, LocalID=%u, MaxNodes=%u, TxOpp=%u, BurstTimer=%u, MaxBurst=%u\n",
|
||||
netid_name,
|
||||
(unsigned)local_id,
|
||||
(unsigned)T1S_MAX_NODES,
|
||||
(unsigned)T1S_TX_OPP_TIMER,
|
||||
(unsigned)T1S_BURST_TIMER,
|
||||
(unsigned)T1S_MAX_BURST);
|
||||
|
||||
// Keep the example explicit about the small set of T1S settings needed for loopback.
|
||||
res = icsneoc2_settings_t1s_plca_enabled_for_set(device, netid, true);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to enable T1S PLCA", res);
|
||||
res = icsneoc2_settings_t1s_local_id_set(device, netid, local_id);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S local ID", res);
|
||||
res = icsneoc2_settings_t1s_max_nodes_set(device, netid, T1S_MAX_NODES);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S max nodes", res);
|
||||
res = icsneoc2_settings_t1s_tx_opp_timer_set(device, netid, T1S_TX_OPP_TIMER);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S TX opportunity timer", res);
|
||||
res = icsneoc2_settings_t1s_burst_timer_set(device, netid, T1S_BURST_TIMER);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S burst timer", res);
|
||||
res = icsneoc2_settings_t1s_max_burst_timer_for_set(device, netid, T1S_MAX_BURST);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S max burst", res);
|
||||
|
||||
res = icsneoc2_settings_t1s_is_termination_enabled_for(device, netid, &termination);
|
||||
if(res == icsneoc2_error_success) {
|
||||
res = icsneoc2_settings_t1s_termination_for_set(device, netid, true);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to enable T1S termination", res);
|
||||
} else if(res != icsneoc2_error_get_settings_failure) {
|
||||
return print_error_code("Failed to query T1S termination support", res);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void print_mac(const char* label, const uint8_t* mac) {
|
||||
printf("%s %02x:%02x:%02x:%02x:%02x:%02x", label, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
||||
}
|
||||
|
||||
static void print_payload_hex(const uint8_t* data, size_t length) {
|
||||
for(size_t i = 0; i < length; ++i) {
|
||||
printf("%02x", data[i]);
|
||||
if(i + 1 < length) {
|
||||
printf(" ");
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void build_loopback_frame(uint8_t* frame_data, size_t frame_size, const char* tx_name, const char* rx_name) {
|
||||
const char* tx_label = tx_name ? tx_name : "TX";
|
||||
const char* rx_label = rx_name ? rx_name : "RX";
|
||||
|
||||
// Build one recognizable Ethernet frame so the receive side can match exactly what we sent.
|
||||
memset(frame_data, 0, frame_size);
|
||||
frame_data[0] = 0x00;
|
||||
frame_data[1] = 0xFC;
|
||||
frame_data[2] = 0x70;
|
||||
frame_data[3] = 0x00;
|
||||
frame_data[4] = 0x00;
|
||||
frame_data[5] = 0x02;
|
||||
frame_data[6] = 0x00;
|
||||
frame_data[7] = 0xFC;
|
||||
frame_data[8] = 0x70;
|
||||
frame_data[9] = 0x00;
|
||||
frame_data[10] = 0x00;
|
||||
frame_data[11] = 0x01;
|
||||
frame_data[12] = (uint8_t)((LOOPBACK_ETHER_TYPE >> 8) & 0xFF);
|
||||
frame_data[13] = (uint8_t)(LOOPBACK_ETHER_TYPE & 0xFF);
|
||||
snprintf((char*)&frame_data[14], frame_size - 14, "C2 T1S loopback %s->%s", tx_label, rx_label);
|
||||
}
|
||||
|
||||
static int message_matches_loopback_frame(icsneoc2_message_t* message, const uint8_t* expected, size_t expected_length, bool* matches) {
|
||||
uint8_t data[1600] = {0};
|
||||
size_t data_length = sizeof(data);
|
||||
uint16_t ether_type = 0;
|
||||
icsneoc2_error_t res;
|
||||
|
||||
if(!expected || !matches || expected_length < 14) {
|
||||
return print_error_code("Invalid loopback match output", icsneoc2_error_invalid_parameters);
|
||||
}
|
||||
|
||||
*matches = false;
|
||||
|
||||
res = icsneoc2_message_eth_ether_type_get(message, ðer_type);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to read loopback EtherType", res);
|
||||
}
|
||||
if(ether_type != LOOPBACK_ETHER_TYPE) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
res = icsneoc2_message_data_get(message, data, &data_length);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed to read loopback frame data", res);
|
||||
}
|
||||
|
||||
if(data_length < 14) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(data_length >= expected_length) {
|
||||
*matches = memcmp(data, expected, expected_length) == 0;
|
||||
} else {
|
||||
*matches = memcmp(data, expected, data_length) == 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int print_ethernet_message(icsneoc2_message_t* message, const char* direction_label) {
|
||||
icsneoc2_netid_t netid = 0;
|
||||
char netid_name[64] = {0};
|
||||
uint8_t dst_mac[6] = {0};
|
||||
uint8_t src_mac[6] = {0};
|
||||
uint16_t ether_type = 0;
|
||||
icsneoc2_message_eth_t1s_flags_t t1s_flags = 0;
|
||||
uint8_t node_id = 0;
|
||||
uint8_t burst_count = 0;
|
||||
uint8_t symbol_type = 0;
|
||||
uint8_t data[1600] = {0};
|
||||
size_t data_length = sizeof(data);
|
||||
icsneoc2_error_t res;
|
||||
|
||||
res = icsneoc2_message_netid_get(message, &netid);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to get message netid", res);
|
||||
if(get_netid_name(netid, netid_name, sizeof(netid_name)) != 0) return 1;
|
||||
|
||||
res = icsneoc2_message_data_get(message, data, &data_length);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to get Ethernet data", res);
|
||||
|
||||
printf("%s on %s: %zu bytes\n", direction_label, netid_name, data_length);
|
||||
|
||||
res = icsneoc2_message_eth_mac_get(message, dst_mac, src_mac);
|
||||
if(res == icsneoc2_error_success) {
|
||||
print_mac(" Dst", dst_mac);
|
||||
printf(" ");
|
||||
print_mac("Src", src_mac);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
res = icsneoc2_message_eth_ether_type_get(message, ðer_type);
|
||||
if(res == icsneoc2_error_success) {
|
||||
printf(" EtherType: 0x%04x\n", ether_type);
|
||||
}
|
||||
|
||||
res = icsneoc2_message_eth_t1s_props_get(message, &t1s_flags, &node_id, &burst_count, &symbol_type);
|
||||
if(res == icsneoc2_error_success && (t1s_flags != 0 || node_id != 0 || burst_count != 0 || symbol_type != 0)) {
|
||||
printf(" T1S: node=%u burst=%u symbol=%u", (unsigned)node_id, (unsigned)burst_count, (unsigned)symbol_type);
|
||||
if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL) printf(" [SYMBOL]");
|
||||
if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST) printf(" [BURST]");
|
||||
if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION) printf(" [TX_COLLISION]");
|
||||
if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE) printf(" [WAKE]");
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
printf(" Payload bytes: ");
|
||||
if(data_length > 14) {
|
||||
print_payload_hex(&data[14], data_length - 14);
|
||||
} else {
|
||||
printf("<none>\n");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int transmit_loopback_frame(icsneoc2_device_t* device, icsneoc2_netid_t tx_netid, const char* tx_name, const char* rx_name) {
|
||||
icsneoc2_message_t* message = NULL;
|
||||
icsneoc2_error_t res;
|
||||
uint8_t frame_data[LOOPBACK_FRAME_SIZE] = {0};
|
||||
|
||||
build_loopback_frame(frame_data, sizeof(frame_data), tx_name, rx_name);
|
||||
|
||||
res = icsneoc2_message_eth_create(&message);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to create Ethernet message", res);
|
||||
|
||||
res = icsneoc2_message_netid_set(message, tx_netid);
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
return print_error_code("Failed to set Ethernet netid", res);
|
||||
}
|
||||
|
||||
res = icsneoc2_message_data_set(message, frame_data, sizeof(frame_data));
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
return print_error_code("Failed to set Ethernet payload", res);
|
||||
}
|
||||
|
||||
printf("Transmitting one T1S loopback frame on %s...\n", tx_name ? tx_name : "selected TX network");
|
||||
res = icsneoc2_device_message_transmit(device, message);
|
||||
icsneoc2_message_free(message);
|
||||
if(res != icsneoc2_error_success) return print_error_code("Failed to transmit loopback frame", res);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int poll_for_loopback_messages(icsneoc2_device_t* device,
|
||||
icsneoc2_netid_t tx_netid,
|
||||
icsneoc2_netid_t rx_netid,
|
||||
const char* tx_name,
|
||||
const char* rx_name,
|
||||
const uint8_t* expected_frame,
|
||||
size_t expected_frame_length) {
|
||||
bool saw_tx_echo = false;
|
||||
bool saw_rx_frame = false;
|
||||
|
||||
printf("Polling for TX echo on %s and RX frame on %s...\n", tx_name, rx_name);
|
||||
for(size_t attempt = 0; attempt < 60 && !(saw_tx_echo && saw_rx_frame); ++attempt) {
|
||||
icsneoc2_message_t* message = NULL;
|
||||
icsneoc2_error_t res = icsneoc2_device_message_get(device, &message, 100);
|
||||
if(res != icsneoc2_error_success) {
|
||||
return print_error_code("Failed while polling for loopback messages", res);
|
||||
}
|
||||
if(message == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
bool is_ethernet = false;
|
||||
bool matches_loopback = false;
|
||||
res = icsneoc2_message_is_ethernet(message, &is_ethernet);
|
||||
if(res != icsneoc2_error_success || !is_ethernet) {
|
||||
icsneoc2_message_free(message);
|
||||
continue;
|
||||
}
|
||||
|
||||
icsneoc2_netid_t netid = 0;
|
||||
res = icsneoc2_message_netid_get(message, &netid);
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
return print_error_code("Failed to get polled netid", res);
|
||||
}
|
||||
|
||||
if(netid != tx_netid && netid != rx_netid) {
|
||||
icsneoc2_message_free(message);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Ignore unrelated traffic on the selected ports and only count the frame this example transmitted.
|
||||
if(message_matches_loopback_frame(message, expected_frame, expected_frame_length, &matches_loopback) != 0) {
|
||||
icsneoc2_message_free(message);
|
||||
return 1;
|
||||
}
|
||||
if(!matches_loopback) {
|
||||
icsneoc2_message_free(message);
|
||||
continue;
|
||||
}
|
||||
|
||||
bool is_tx = false;
|
||||
res = icsneoc2_message_is_transmit(message, &is_tx);
|
||||
if(res != icsneoc2_error_success) {
|
||||
icsneoc2_message_free(message);
|
||||
return print_error_code("Failed to determine TX status", res);
|
||||
}
|
||||
|
||||
if(netid == tx_netid && is_tx && !saw_tx_echo) {
|
||||
if(print_ethernet_message(message, "TX echo") != 0) {
|
||||
icsneoc2_message_free(message);
|
||||
return 1;
|
||||
}
|
||||
saw_tx_echo = true;
|
||||
} else if(netid == rx_netid && !saw_rx_frame) {
|
||||
if(print_ethernet_message(message, "RX frame") != 0) {
|
||||
icsneoc2_message_free(message);
|
||||
return 1;
|
||||
}
|
||||
if(is_tx) {
|
||||
printf(" Note: RX port message was also marked as transmit.\n");
|
||||
}
|
||||
saw_rx_frame = true;
|
||||
}
|
||||
|
||||
icsneoc2_message_free(message);
|
||||
}
|
||||
|
||||
if(!saw_tx_echo || !saw_rx_frame) {
|
||||
printf("Loopback incomplete: saw_tx_echo=%s, saw_rx_frame=%s\n",
|
||||
saw_tx_echo ? "true" : "false",
|
||||
saw_rx_frame ? "true" : "false");
|
||||
printf("Confirm %s is physically connected to %s and both ports are configured for 10BASE-T1S.\n", tx_name, rx_name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
printf("Loopback complete: TX echo on %s and RX frame on %s were both observed.\n", tx_name, rx_name);
|
||||
return 0;
|
||||
}
|
||||
@@ -223,8 +223,30 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
|
||||
std::cout << "\t\t Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n";
|
||||
|
||||
// The MACAddress may be printed directly or accessed with the `data` member
|
||||
std::cout << "\t\t Source:\t" << ethMessage->getSourceMAC() << "\n";
|
||||
std::cout << "\t\t Destination:\t" << ethMessage->getDestinationMAC();
|
||||
auto printMAC = [](const icsneo::MACAddress& mac) {
|
||||
std::ostringstream oss;
|
||||
for(size_t i = 0; i < mac.size(); i++) {
|
||||
oss << std::hex << std::setw(2) << std::setfill('0') << (uint32_t)mac[i];
|
||||
if(i != mac.size() - 1)
|
||||
oss << ':';
|
||||
}
|
||||
return oss.str();
|
||||
};
|
||||
if (auto destMAC = ethMessage->getDestinationMAC(); destMAC.has_value()) {
|
||||
std::cout << "\t\t Destination:\t" << printMAC(*destMAC) << "\n";
|
||||
} else {
|
||||
std::cout << "\t\t Destination:\t N/A\n";
|
||||
}
|
||||
if (auto srcMAC = ethMessage->getSourceMAC(); srcMAC.has_value()) {
|
||||
std::cout << "\t\t Source:\t" << printMAC(*srcMAC) << "\n";
|
||||
} else {
|
||||
std::cout << "\t\t Source:\t N/A\n";
|
||||
}
|
||||
if (auto etherType = ethMessage->getEtherType(); etherType.has_value()) {
|
||||
std::cout << "\t\t EtherType:\t" << std::hex << std::setw(4) << std::setfill('0') << *etherType << "\n";
|
||||
} else {
|
||||
std::cout << "\t\t EtherType:\t N/A\n";
|
||||
}
|
||||
|
||||
// Print the data
|
||||
for(size_t i = 0; i < ethMessage->data.size(); i++) {
|
||||
|
||||
@@ -208,8 +208,26 @@ int main() {
|
||||
std::cout << "\t\t Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n";
|
||||
|
||||
// The MACAddress may be printed directly or accessed with the `data` member
|
||||
std::cout << "\t\t Source:\t" << ethMessage->getSourceMAC() << "\n";
|
||||
std::cout << "\t\t Destination:\t" << ethMessage->getDestinationMAC();
|
||||
// The MACAddress may be printed directly or accessed with the `data` member
|
||||
auto printMAC = [](const icsneo::MACAddress& mac) {
|
||||
std::ostringstream oss;
|
||||
for(size_t i = 0; i < mac.size(); i++) {
|
||||
oss << std::hex << std::setw(2) << std::setfill('0') << (uint32_t)mac[i];
|
||||
if(i != mac.size() - 1)
|
||||
oss << ':';
|
||||
}
|
||||
return oss.str();
|
||||
};
|
||||
if (auto destMAC = ethMessage->getDestinationMAC(); destMAC.has_value()) {
|
||||
std::cout << "\t\t Destination:\t" << printMAC(*destMAC) << "\n";
|
||||
} else {
|
||||
std::cout << "\t\t Destination:\t N/A\n";
|
||||
}
|
||||
if (auto srcMAC = ethMessage->getSourceMAC(); srcMAC.has_value()) {
|
||||
std::cout << "\t\t Source:\t" << printMAC(*srcMAC) << "\n";
|
||||
} else {
|
||||
std::cout << "\t\t Source:\t N/A\n";
|
||||
}
|
||||
|
||||
// Print the data
|
||||
for(size_t i = 0; i < ethMessage->data.size(); i++) {
|
||||
|
||||
@@ -154,12 +154,12 @@ void setupSymbolMonitoring(std::shared_ptr<icsneo::Device>& device,
|
||||
|
||||
auto ethMsg = std::static_pointer_cast<icsneo::EthernetMessage>(frame);
|
||||
|
||||
if (!ethMsg->isT1S)
|
||||
if (!ethMsg->t1s)
|
||||
return;
|
||||
|
||||
double timestamp_ms = ethMsg->timestamp / 1000000.0;
|
||||
|
||||
if (ethMsg->isT1SSymbol) {
|
||||
if (ethMsg->t1s->isSymbol) {
|
||||
size_t numSymbols = ethMsg->data.size();
|
||||
|
||||
std::cout << std::fixed << std::setprecision(3)
|
||||
@@ -169,7 +169,7 @@ void setupSymbolMonitoring(std::shared_ptr<icsneo::Device>& device,
|
||||
if (numSymbols > 0) {
|
||||
std::cout << " (" << numSymbols << " symbol" << (numSymbols > 1 ? "s" : "") << ")";
|
||||
}
|
||||
std::cout << " | Node ID: " << (int)ethMsg->t1sNodeId << std::endl;
|
||||
std::cout << " | Node ID: " << (int)ethMsg->t1s->nodeId << std::endl;
|
||||
|
||||
for (size_t i = 0; i < numSymbols; i++) {
|
||||
uint8_t symbolValue = ethMsg->data[i];
|
||||
@@ -188,8 +188,8 @@ void setupSymbolMonitoring(std::shared_ptr<icsneo::Device>& device,
|
||||
<< std::dec << std::endl;
|
||||
}
|
||||
|
||||
if (numSymbols == 0 && ethMsg->t1sSymbolType != 0) {
|
||||
uint8_t symbolValue = ethMsg->t1sSymbolType;
|
||||
if (numSymbols == 0 && ethMsg->t1s->symbolType != 0) {
|
||||
uint8_t symbolValue = ethMsg->t1s->symbolType;
|
||||
std::string symbolName = getSymbolName(symbolValue);
|
||||
|
||||
stats.symbolCount++;
|
||||
@@ -205,20 +205,20 @@ void setupSymbolMonitoring(std::shared_ptr<icsneo::Device>& device,
|
||||
<< std::dec << " (from t1sSymbolType field)" << std::endl;
|
||||
}
|
||||
}
|
||||
else if (ethMsg->isT1SBurst) {
|
||||
else if (ethMsg->t1s->isBurst) {
|
||||
stats.burstCount++;
|
||||
std::cout << std::fixed << std::setprecision(3)
|
||||
<< "[" << std::setw(12) << timestamp_ms << " ms] "
|
||||
<< "BURST | "
|
||||
<< "Node ID: " << (int)ethMsg->t1sNodeId << " | "
|
||||
<< "Burst Count: " << (int)ethMsg->t1sBurstCount << std::endl;
|
||||
<< "Node ID: " << (int)ethMsg->t1s->nodeId << " | "
|
||||
<< "Burst Count: " << (int)ethMsg->t1s->burstCount << std::endl;
|
||||
}
|
||||
else if (ethMsg->isT1SWake) {
|
||||
else if (ethMsg->t1s->isWake) {
|
||||
stats.wakeCount++;
|
||||
std::cout << std::fixed << std::setprecision(3)
|
||||
<< "[" << std::setw(12) << timestamp_ms << " ms] "
|
||||
<< "WAKE signal detected | "
|
||||
<< "Node ID: " << (int)ethMsg->t1sNodeId << std::endl;
|
||||
<< "Node ID: " << (int)ethMsg->t1s->nodeId << std::endl;
|
||||
}
|
||||
else {
|
||||
stats.dataFrameCount++;
|
||||
@@ -226,7 +226,7 @@ void setupSymbolMonitoring(std::shared_ptr<icsneo::Device>& device,
|
||||
<< "[" << std::setw(12) << timestamp_ms << " ms] "
|
||||
<< "T1S Data Frame | "
|
||||
<< "Length: " << ethMsg->data.size() << " bytes | "
|
||||
<< "Node ID: " << (int)ethMsg->t1sNodeId << std::endl;
|
||||
<< "Node ID: " << (int)ethMsg->t1s->nodeId << std::endl;
|
||||
|
||||
if (!ethMsg->data.empty()) {
|
||||
std::cout << " Data: ";
|
||||
|
||||
@@ -47,14 +47,23 @@ def setup_ethernet_reception(device):
|
||||
def frame_handler(frame):
|
||||
nonlocal frame_count
|
||||
frame_count += 1
|
||||
dst = frame.get_destination_mac()
|
||||
src = frame.get_source_mac()
|
||||
et = frame.get_ether_type()
|
||||
|
||||
dst_str = ":".join(f"{b:02x}" for b in dst) if dst is not None else "N/A"
|
||||
src_str = ":".join(f"{b:02x}" for b in src) if src is not None else "N/A"
|
||||
et_str = f"0x{et:04x}" if et is not None else "N/A"
|
||||
|
||||
print(f"[RX {frame_count}], "
|
||||
f"Data: {[hex(b) for b in frame.data]}, "
|
||||
f"Length: {len(frame.data)}")
|
||||
frame_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.ETHERNET_01)
|
||||
f"dst={dst_str}, src={src_str}, ethertype={et_str}, "
|
||||
f"Data: {[hex(b) for b in frame.data]}, "
|
||||
f"Length: {len(frame.data)}")
|
||||
frame_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.ETHERNET_02)
|
||||
callback = icsneopy.MessageCallback(frame_handler, frame_filter)
|
||||
device.add_message_callback(callback)
|
||||
|
||||
print("CAN frame reception configured")
|
||||
print("Ethernet frame reception configured")
|
||||
return 0
|
||||
|
||||
|
||||
|
||||
@@ -97,27 +97,27 @@ def display_t1s_settings(device, network):
|
||||
"""Display T1S settings for a network."""
|
||||
print(f"\t{network} T1S Settings:")
|
||||
|
||||
settings = device.get_settings()
|
||||
settings = device.settings
|
||||
if not settings:
|
||||
print("\t Unable to read settings")
|
||||
return
|
||||
|
||||
print(f"\t PLCA Enabled: {opt_to_string(settings.get_t1s_plca_enabled(network))}")
|
||||
print(f"\t PLCA Enabled: {opt_to_string(settings.is_t1s_plca_enabled(network))}")
|
||||
print(f"\t Local ID: {opt_to_string(settings.get_t1s_local_id(network))}")
|
||||
print(f"\t Max Nodes: {opt_to_string(settings.get_t1s_max_nodes(network))}")
|
||||
print(f"\t TX Opp Timer: {opt_to_string(settings.get_t1s_tx_opp_timer(network))}")
|
||||
print(f"\t Max Burst: {opt_to_string(settings.get_t1s_max_burst(network))}")
|
||||
print(f"\t Burst Timer: {opt_to_string(settings.get_t1s_burst_timer(network))}")
|
||||
|
||||
term_enabled = settings.get_t1s_termination_enabled(network)
|
||||
term_enabled = settings.is_t1s_termination_enabled(network)
|
||||
if term_enabled is not None:
|
||||
print(f"\t Termination: {opt_to_string(term_enabled)}")
|
||||
|
||||
local_id_alt = settings.get_t1s_local_id_alternate(network)
|
||||
if local_id_alt is not None:
|
||||
print(f"\t Local ID Alternate: {opt_to_string(local_id_alt)}")
|
||||
print(f"\t Bus Dec Beacons: {opt_to_string(settings.get_t1s_bus_decoding_beacons_enabled(network))}")
|
||||
print(f"\t Bus Dec All: {opt_to_string(settings.get_t1s_bus_decoding_all_enabled(network))}")
|
||||
print(f"\t Bus Dec Beacons: {opt_to_string(settings.is_t1s_bus_decoding_beacons_enabled(network))}")
|
||||
print(f"\t Bus Dec All: {opt_to_string(settings.is_t1s_bus_decoding_all_enabled(network))}")
|
||||
|
||||
multi_id_mask = settings.get_t1s_multi_id_enable_mask(network)
|
||||
if multi_id_mask is not None:
|
||||
@@ -138,7 +138,7 @@ def configure_t1s_network(device, network):
|
||||
print(f"Configuring T1S Network: {network}")
|
||||
print("=" * 70)
|
||||
|
||||
settings = device.get_settings()
|
||||
settings = device.settings
|
||||
if not settings:
|
||||
print("Unable to read settings")
|
||||
return
|
||||
@@ -162,7 +162,7 @@ def configure_t1s_network(device, network):
|
||||
burst_timer = get_uint16_input("Burst Timer (0-65535)", 64)
|
||||
settings.set_t1s_burst_timer(network, burst_timer)
|
||||
|
||||
if settings.get_t1s_termination_enabled(network) is not None:
|
||||
if settings.is_t1s_termination_enabled(network) is not None:
|
||||
print("\n--- Termination Settings ---")
|
||||
term_enabled = get_user_confirmation("Enable Termination")
|
||||
settings.set_t1s_termination(network, term_enabled)
|
||||
@@ -187,10 +187,7 @@ def configure_t1s_network(device, network):
|
||||
multi_id = get_uint8_input(f" Multi-ID [{i}]", 0)
|
||||
settings.set_t1s_multi_id(network, i, multi_id)
|
||||
|
||||
if not device.set_settings(settings):
|
||||
print("✗ Failed to update device settings")
|
||||
else:
|
||||
print(f"\n✓ Configuration complete for {network}")
|
||||
print(f"\n[OK] Configuration staged for {network}")
|
||||
|
||||
|
||||
def main():
|
||||
@@ -217,7 +214,7 @@ def main():
|
||||
|
||||
device = None
|
||||
for d in devices:
|
||||
if d.get_type() == icsneopy.DeviceType.RADComet3:
|
||||
if d.get_type().get_device_type() == icsneopy.DeviceType.Enum.RADComet3:
|
||||
device = d
|
||||
break
|
||||
|
||||
@@ -233,24 +230,17 @@ def main():
|
||||
|
||||
print("\nOpening device... ", end="", flush=True)
|
||||
if not device.open():
|
||||
print("✗ Failed")
|
||||
print("FAIL")
|
||||
return 1
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
candidate_networks = [
|
||||
icsneopy.Network.NetID.AE_01, icsneopy.Network.NetID.AE_02,
|
||||
icsneopy.Network.NetID.AE_03, icsneopy.Network.NetID.AE_04,
|
||||
icsneopy.Network.NetID.AE_05, icsneopy.Network.NetID.AE_06,
|
||||
icsneopy.Network.NetID.AE_07, icsneopy.Network.NetID.AE_08,
|
||||
icsneopy.Network.NetID.AE_09, icsneopy.Network.NetID.AE_10
|
||||
]
|
||||
|
||||
settings = device.get_settings()
|
||||
settings = device.settings
|
||||
t1s_networks = []
|
||||
for net_id in candidate_networks:
|
||||
local_id = settings.get_t1s_local_id(net_id)
|
||||
if local_id is not None:
|
||||
t1s_networks.append(net_id)
|
||||
for net in device.get_supported_tx_networks():
|
||||
if net.get_type() != icsneopy.Network.Type.AutomotiveEthernet:
|
||||
continue
|
||||
if settings.get_t1s_local_id(net) is not None:
|
||||
t1s_networks.append(net)
|
||||
|
||||
if not t1s_networks:
|
||||
print("No T1S networks found on this device")
|
||||
@@ -273,7 +263,7 @@ def main():
|
||||
print("\nNo networks selected for configuration.")
|
||||
print("Closing device... ", end="", flush=True)
|
||||
device.close()
|
||||
print("✓")
|
||||
print("OK")
|
||||
return 0
|
||||
|
||||
print(f"\nConfiguring {len(networks_to_config)} network{'s' if len(networks_to_config) != 1 else ''}...")
|
||||
@@ -285,14 +275,14 @@ def main():
|
||||
save_to_eeprom = get_user_confirmation("Save settings to EEPROM (permanent)?")
|
||||
print("=" * 70)
|
||||
|
||||
settings = device.get_settings()
|
||||
settings = device.settings
|
||||
print(f"\nApplying settings{' to EEPROM' if save_to_eeprom else ' temporarily'}... ", end="", flush=True)
|
||||
success = settings.apply(not save_to_eeprom)
|
||||
if not success:
|
||||
print("✗ Failed")
|
||||
print("FAIL")
|
||||
device.close()
|
||||
return 1
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
print("\n" + "-" * 70)
|
||||
print("Updated T1S Settings:")
|
||||
@@ -302,7 +292,7 @@ def main():
|
||||
|
||||
print("Closing device... ", end="", flush=True)
|
||||
device.close()
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
except KeyboardInterrupt:
|
||||
print("\n\nInterrupted by user")
|
||||
|
||||
@@ -38,7 +38,7 @@ def get_user_confirmation(prompt):
|
||||
|
||||
def configure_t1s_decoding(device, network, enable_symbols, enable_beacons):
|
||||
"""Configure T1S bus decoding settings."""
|
||||
settings = device.get_settings()
|
||||
settings = device.settings
|
||||
if not settings:
|
||||
raise RuntimeError("Failed to get device settings")
|
||||
|
||||
@@ -46,21 +46,15 @@ def configure_t1s_decoding(device, network, enable_symbols, enable_beacons):
|
||||
|
||||
if not settings.set_t1s_bus_decoding_all(network, enable_symbols):
|
||||
raise RuntimeError("Failed to set T1S symbol decoding")
|
||||
if enable_symbols:
|
||||
print(" ✓ Enabled decoding of all T1S symbols")
|
||||
else:
|
||||
print(" • T1S symbol decoding disabled")
|
||||
print(f" [{'X' if enable_symbols else ' '}] Decoding of all T1S symbols")
|
||||
|
||||
if not settings.set_t1s_bus_decoding_beacons(network, enable_beacons):
|
||||
raise RuntimeError("Failed to set T1S beacon decoding")
|
||||
if enable_beacons:
|
||||
print(" ✓ Enabled T1S beacon decoding")
|
||||
else:
|
||||
print(" • T1S beacon decoding disabled")
|
||||
print(f" [{'X' if enable_beacons else ' '}] T1S beacon decoding")
|
||||
|
||||
if not device.set_settings(settings):
|
||||
if not settings.apply(True):
|
||||
raise RuntimeError("Failed to apply settings to device")
|
||||
print(" ✓ Settings applied successfully")
|
||||
print(" [OK] Settings applied successfully")
|
||||
|
||||
|
||||
def setup_symbol_monitoring(device, network):
|
||||
@@ -79,18 +73,18 @@ def setup_symbol_monitoring(device, network):
|
||||
if not isinstance(msg, icsneopy.EthernetMessage):
|
||||
return
|
||||
|
||||
if not msg.isT1S:
|
||||
if not msg.t1s:
|
||||
return
|
||||
|
||||
timestamp_ms = msg.timestamp / 1000000.0
|
||||
|
||||
if msg.isT1SSymbol:
|
||||
if msg.t1s.isSymbol:
|
||||
num_symbols = len(msg.data)
|
||||
|
||||
print(f"[{timestamp_ms:12.3f} ms] T1S Symbols", end="")
|
||||
if num_symbols > 0:
|
||||
print(f" ({num_symbols} symbol{'s' if num_symbols > 1 else ''})", end="")
|
||||
print(f" | Node ID: {msg.t1sNodeId}")
|
||||
print(f" | Node ID: {msg.t1s.nodeId}")
|
||||
|
||||
for i, symbol_value in enumerate(msg.data):
|
||||
symbol_name = T1SSymbol.get_name(symbol_value)
|
||||
@@ -105,8 +99,8 @@ def setup_symbol_monitoring(device, network):
|
||||
|
||||
print(f" [{i}] {symbol_name:10s} = 0x{symbol_value:02X}")
|
||||
|
||||
if num_symbols == 0 and msg.t1sSymbolType != 0:
|
||||
symbol_value = msg.t1sSymbolType
|
||||
if num_symbols == 0 and msg.t1s.symbolType != 0:
|
||||
symbol_value = msg.t1s.symbolType
|
||||
symbol_name = T1SSymbol.get_name(symbol_value)
|
||||
|
||||
state['symbol_count'] += 1
|
||||
@@ -119,22 +113,22 @@ def setup_symbol_monitoring(device, network):
|
||||
|
||||
print(f" {symbol_name:10s} = 0x{symbol_value:02X} (from t1sSymbolType field)")
|
||||
|
||||
elif msg.isT1SBurst:
|
||||
elif msg.t1s.isBurst:
|
||||
state['burst_count'] += 1
|
||||
print(f"[{timestamp_ms:12.3f} ms] BURST | "
|
||||
f"Node ID: {msg.t1sNodeId} | "
|
||||
f"Burst Count: {msg.t1sBurstCount}")
|
||||
f"Node ID: {msg.t1s.nodeId} | "
|
||||
f"Burst Count: {msg.t1s.burstCount}")
|
||||
|
||||
elif msg.isT1SWake:
|
||||
elif msg.t1s.isWake:
|
||||
state['wake_count'] += 1
|
||||
print(f"[{timestamp_ms:12.3f} ms] WAKE signal detected | "
|
||||
f"Node ID: {msg.t1sNodeId}")
|
||||
f"Node ID: {msg.t1s.nodeId}")
|
||||
|
||||
else:
|
||||
state['data_frame_count'] += 1
|
||||
print(f"[{timestamp_ms:12.3f} ms] T1S Data Frame | "
|
||||
f"Length: {len(msg.data)} bytes | "
|
||||
f"Node ID: {msg.t1sNodeId}")
|
||||
f"Node ID: {msg.t1s.nodeId}")
|
||||
|
||||
if msg.data and len(msg.data) > 0:
|
||||
preview = ' '.join([f"{b:02X}" for b in msg.data[:16]])
|
||||
@@ -142,7 +136,7 @@ def setup_symbol_monitoring(device, network):
|
||||
preview += " ..."
|
||||
print(f" Data: {preview}")
|
||||
|
||||
frame_filter = icsneopy.MessageFilter(network)
|
||||
frame_filter = icsneopy.MessageFilter(network.get_net_id())
|
||||
callback = icsneopy.MessageCallback(symbol_handler, frame_filter)
|
||||
device.add_message_callback(callback)
|
||||
|
||||
@@ -175,7 +169,6 @@ def main():
|
||||
device = None
|
||||
|
||||
try:
|
||||
MONITOR_NETWORK = icsneopy.Network.NetID.AE_02
|
||||
MONITOR_DURATION = 30
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
@@ -197,7 +190,7 @@ def main():
|
||||
|
||||
device = None
|
||||
for d in devices:
|
||||
if d.get_type() == icsneopy.DeviceType.RADComet3:
|
||||
if d.get_type().get_device_type() == icsneopy.DeviceType.Enum.RADComet3:
|
||||
device = d
|
||||
break
|
||||
|
||||
@@ -220,28 +213,44 @@ def main():
|
||||
|
||||
print("\nOpening device... ", end="", flush=True)
|
||||
if not device.open():
|
||||
print("✗ Failed")
|
||||
print("FAIL")
|
||||
return 1
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
print("Enabling message polling... ", end="", flush=True)
|
||||
if not device.enable_message_polling():
|
||||
print("✗ Failed")
|
||||
print("FAIL")
|
||||
device.close()
|
||||
return 1
|
||||
device.set_polling_message_limit(100000)
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
configure_t1s_decoding(device, MONITOR_NETWORK, enable_symbols, enable_beacons)
|
||||
monitor_network = None
|
||||
settings = device.settings
|
||||
for net in device.get_supported_rx_networks():
|
||||
if net.get_type() != icsneopy.Network.Type.AutomotiveEthernet:
|
||||
continue
|
||||
if settings.get_t1s_local_id(net) is not None:
|
||||
monitor_network = net
|
||||
break
|
||||
|
||||
if monitor_network is None:
|
||||
print("No T1S network found on this device")
|
||||
device.close()
|
||||
return 1
|
||||
|
||||
print(f"Monitoring network: {monitor_network}")
|
||||
|
||||
configure_t1s_decoding(device, monitor_network, enable_symbols, enable_beacons)
|
||||
|
||||
print("Going online... ", end="", flush=True)
|
||||
if not device.go_online():
|
||||
print("✗ Failed")
|
||||
print("FAIL")
|
||||
device.close()
|
||||
return 1
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
state = setup_symbol_monitoring(device, MONITOR_NETWORK)
|
||||
state = setup_symbol_monitoring(device, monitor_network)
|
||||
|
||||
print("\n" + "-" * 70)
|
||||
print(f"Monitoring T1S traffic for {MONITOR_DURATION} seconds...")
|
||||
@@ -256,7 +265,7 @@ def main():
|
||||
print("Closing device... ", end="", flush=True)
|
||||
device.close()
|
||||
time.sleep(0.1)
|
||||
print("✓")
|
||||
print("OK")
|
||||
|
||||
print_statistics(state)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user