From bb195056ea825c6b962fcc0e7dfe6b27807052ea Mon Sep 17 00:00:00 2001 From: David Kim Date: Tue, 14 Feb 2023 14:46:49 -0800 Subject: [PATCH 01/37] Structuring jsd driver for el6001 --- src/CMakeLists.txt | 1 + src/jsd.c | 1 + src/jsd_el6001.c | 124 ++++++++++++++++++++++++++++++++ src/jsd_el6001.h | 31 ++++++++ src/jsd_el6001_pub.h | 57 +++++++++++++++ src/jsd_el6001_types.h | 160 +++++++++++++++++++++++++++++++++++++++++ src/jsd_types.h | 3 + 7 files changed, 377 insertions(+) create mode 100644 src/jsd_el6001.c create mode 100644 src/jsd_el6001.h create mode 100644 src/jsd_el6001_pub.h create mode 100644 src/jsd_el6001_types.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 016bb9d..7d382b2 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -19,6 +19,7 @@ add_library(jsd-lib STATIC jsd_el3318.c jsd_el3162.c jsd_el4102.c + jsd_el6001.c jsd_ild1900.c ) diff --git a/src/jsd.c b/src/jsd.c index 2c14055..a74647a 100644 --- a/src/jsd.c +++ b/src/jsd.c @@ -17,6 +17,7 @@ #include "jsd/jsd_el3356.h" #include "jsd/jsd_el3602.h" #include "jsd/jsd_el4102.h" +#include "jsd/jsd_el6001.h" #include "jsd/jsd_ild1900.h" #include "jsd/jsd_jed0101.h" #include "jsd/jsd_jed0200.h" diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c new file mode 100644 index 0000000..57dd180 --- /dev/null +++ b/src/jsd_el6001.c @@ -0,0 +1,124 @@ +#include "jsd/jsd_el6001.h" + +#include + +#include "jsd/jsd.h" +#include "jsd/jsd_sdo.h" + +static bool jsd_el6001_statusword_bit_is_set(const jsd_t* self, uint16_t slave_id, int bit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(bit >= 0); + assert(bit < JSD_EL6001_NUM_STATUS_WORD_BITS); + + return self->slave_states[slave_id].el6001.statusword & (1 << bit); +} + +static int jsd_el6001_check_for_faults(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + + if (state->statusword != state->statusword_last) + { + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_FIFO_BUFFER_FULL)) + { + ERROR("EL6001[%d]: FIFO buffer is full", slave_id); + } + + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_PARITY_ERROR)) + { + ERROR("EL6001[%d]: Parity error", slave_id); + } + + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_FRAMING_ERROR)) + { + ERROR("EL6001[%d]: Framing error", slave_id); + } + + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_OVERRUN_ERROR)) + { + ERROR("EL6001[%d]: Overrun error", slave_id); + } + } + + return 0; +} + +/**************************************************** + * Public functions + ****************************************************/ + +const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == + JSD_EL6001_PRODUCT_CODE); + + return &self->slave_states[slave_id].el6001; +} + +void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == + JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + + jsd_el6001_txpdo_data_t* txpdo = + (jsd_el6001_txpdo_data_t*)self->ecx_context.slavelist[slave_id].inputs; + + // jsd_el3602_rxpdo_t* rxpdo = + // (jsd_el3602_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; + + // state->control_word_terminal_last = state->control_word_terminal; + // state->control_word = rxpdo->control_word; + + state->statusword_last = state->statusword; + state->statusword = txpdo->statusword; +} + +void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == + JSD_EL6001_PRODUCT_CODE); + + // read PDOs, updates status_word + jsd_el6001_read_PDO_data(self, slave_id); + + jsd_el6001_check_for_faults(self, slave_id); + +} + +// void jsd_el6001_write_single_channel(jsd_t* self, uint16_t slave_id, +// uint8_t channel, double output) { +// assert(self); +// assert(self->ecx_context.slavelist[slave_id].eep_id == +// JSD_EL6001_PRODUCT_CODE); +// } + +// void jsd_el6001_write_all_channels(jsd_t* self, uint16_t slave_id, +// double output[JSD_EL6001_NUM_CHANNELS]) { +// // for (int ch = 0; ch < JSD_EL6001_NUM_CHANNELS; ++ch) { +// // jsd_el6001_write_single_channel(self, slave_id, ch, output[ch]); +// // } +// } + +/**************************************************** + * Private functions + ****************************************************/ + +bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == + JSD_EL6001_PRODUCT_CODE); + assert(self->ecx_context.slavelist[slave_id].eep_man == + JSD_BECKHOFF_VENDOR_ID); + + jsd_slave_config_t* config = &self->slave_configs[slave_id]; + + // No PO2SO callback for 4102 devices, so set the success flag now + config->PO2SO_success = true; + + return true; +} diff --git a/src/jsd_el6001.h b/src/jsd_el6001.h new file mode 100644 index 0000000..3f28290 --- /dev/null +++ b/src/jsd_el6001.h @@ -0,0 +1,31 @@ +#ifndef JSD_EL6001_H +#define JSD_EL6001_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "jsd/jsd_el6001_pub.h" + +/** + * @brief Initializes EL6001 + * + * @param self Pointer to JSD context + * @param slave_id Index of device on EtherCAT bus + * @return true on success, false on failure + */ +bool jsd_el6001_init(jsd_t* self, uint16_t slave_id); + +/** + * @brief Read PDO data with SOEM IOmap + * + * @param self pointer JSD context + * @param slave_id index of device on EtherCAT bus + */ +void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h new file mode 100644 index 0000000..54f3fe2 --- /dev/null +++ b/src/jsd_el6001_pub.h @@ -0,0 +1,57 @@ +#ifndef JSD_EL6001_PUB_H +#define JSD_EL6001_PUB_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "jsd/jsd_pub.h" +#include "jsd/jsd_el6001_types.h" + +/** + * @brief Read the EL6001 device state + * + * Note: this device does not provide PDO feedback on state. This function reads + * back the command sent to the EL6001 device. + * + * @param self Pointer to JSD context + * @param slave_id Slave ID of EL6001 device + * @return Pointer to EL6001 device state + */ +const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); + +/** + * @brief Writes the set commands into the SOEM IOmap and processes asynchronous + * SDO responses + * + * @param self Pointer to JSD context + * @param slave_id Slave ID of EL6001 device + */ +void jsd_el6001_process(jsd_t* self, uint16_t slave_id); + +/** + * @brief Sets the voltage (V) command for the given channel + * + * @param self Pointer to JSD context + * @param slave_id Slave ID of EL6001 device + * @param channel Device channel to command + * @param output Commanded voltage. Provided value is clamped within [0-10]. + */ +void jsd_el4102_write_single_channel(jsd_t* self, uint16_t slave_id, + uint8_t channel, double output); + +/** + * @brief Sets the voltage (V) command for each channel + * + * @param self Pointer to JSD context + * @param slave_id Slave ID of EL6001 device + * @param output Commanded voltages. Provided values are clamped within [0-10]. + */ +void jsd_el4102_write_all_channels(jsd_t* self, uint16_t slave_id, + double output[JSD_EL6001_NUM_CHANNELS]); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h new file mode 100644 index 0000000..ea3ebc7 --- /dev/null +++ b/src/jsd_el6001_types.h @@ -0,0 +1,160 @@ +#ifndef JSD_EL6001_TYPES_H +#define JSD_EL6001_TYPES_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "jsd/jsd_common_device_types.h" + +#define JSD_EL6001_PRODUCT_CODE (uint32_t)0x17853052 //17713052 in old ecat driver + +#define JSD_EL6001_NUM_CHANNELS 1 + +#define JSD_EL6001_NUM_DATA_BYTES 22 + +typedef enum +{ + JSD_EL6001_CONTROL_WORD_TRANSMIT_REQUEST = 0, ///< Toggle to notify terminal that DataOut bytes contain number of bytes indicated via + ///< OL bits. Terminal acknowledges receipt of data via toggle of SW0 + JSD_EL6001_CONTROL_WORD_RECEIVE_ACCEPTED, ///< Controller acknowledges receipt of data via toggle of this bit + JSD_EL6001_CONTROL_WORD_INIT_REQUEST, ///< 1: Controller requests terminal to initialize. Terminal acknowledges completion by SW2 + ///< 0: Controller once again request terminal to prepare for serial data exchange + JSD_EL6001_CONTROL_WORD_SEND_CONTINUOUS, ///< Rising edge (0->1): Continuous sending of data from the FIFO buffer. + ///< Send buffer is filled (<= 128 bytes) by controller. Buffer content is sent with + ///< rising edge of this bit. Terminal acknowledges the data transfer to controller + ///< through setting of bit SW2. SW2 is cancelled with CW3 + JSD_EL6001_CONTROL_WORD_RESERVED_0, + JSD_EL6001_CONTROL_WORD_RESERVED_1, + JSD_EL6001_CONTROL_WORD_RESERVED_2, + JSD_EL6001_CONTROL_WORD_RESERVED_3, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_0, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_1, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_2, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_3, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_4, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_5, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_6, + JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_7, + JSD_EL6001_NUM_CONTROL_WORD_BITS + +} jsd_el6001_control_word_bit_t; + + +typedef enum +{ + JSD_EL6001_STATUS_WORD_TRANSMIT_ACCEPTED = 0, ///< Toggle acknowledges receipt of data. Only now new data can be transmitted + ///< from controller to terminal. + JSD_EL6001_STATUS_WORD_RECEIVE_REQUEST, ///< Toggle notifies the controller that DataIn bytes contain number of bytes in IL bits + ///< Controller must acknowledge receipt of data in control byte via toggling CW1. + ///< Only then new data can be transferred from terminal to controller. + JSD_EL6001_STATUS_WORD_INIT_ACCEPTED, ///< 1: init completed by terminal. 0: terminal ready for serial data exchange. + JSD_EL6001_STATUS_WORD_FIFO_BUFFER_FULL, ///< 1: all incoming data will be lost until buffer is not full + JSD_EL6001_STATUS_WORD_PARITY_ERROR, ///< A parity error has occurred + JSD_EL6001_STATUS_WORD_FRAMING_ERROR, ///< A framing error has occurred + JSD_EL6001_STATUS_WORD_OVERRUN_ERROR, ///< An overrun error has occurred + JSD_EL6001_STATUS_WORD_RESERVED, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_0, ///< = 8 (BIT08) + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_1, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_2, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_3, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_4, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_5, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_6, + JSD_EL6001_STATUS_WORD_INPUT_LENGTH_7, ///< = 15 (BIT15) + JSD_EL6001_NUM_STATUS_WORD_BITS ///< = 16 + +} jsd_el6001_status_word_bit_t; + +/** + * @brief Set using object 0x8000:11 to one of the following values + */ +typedef enum +{ + JSD_EL6001_BAUD_RATE_2400 = 4, + JSD_EL6001_BAUD_RATE_4800 = 5, + JSD_EL6001_BAUD_RATE_9600 = 6, + JSD_EL6001_BAUD_RATE_19200 = 7, + JSD_EL6001_BAUD_RATE_38400 = 8, + JSD_EL6001_BAUD_RATE_57600 = 9, + JSD_EL6001_BAUD_RATE_115200 = 10, + JSD_EL6001_BAUD_RATE_12000 = 14, + JSD_EL6001_BAUD_RATE_14400 = 15, + +} jsd_el6001_baud_rate_t; + +/** + * @brief Configuration struct for EL6001 device initialization + */ +typedef struct { +} jsd_el6001_config_t; + +/** + * @brief RxPDO struct used to set device command data in SOEM IOmap + * + * Note: struct order matters and must be packed. + */ +typedef struct __attribute__((__packed__)) { + // jsd_el6001_rxpdo_channel_t channel[JSD_EL6001_NUM_CHANNELS]; + uint16_t controlword; +} jsd_el6001_rxpdo_t; + +/** + * @brief TxPDO struct used to read data in SOEM IOmap + * + * Note: struct order matters and must be packed. + */ +typedef struct __attribute__((__packed__)) { + uint16_t statusword; +} jsd_el6001_txpdo_data_t; + +/** + * @brief EL6001 state data + */ +typedef struct +{ + int baud_rate; + uint16_t statusword; + uint16_t statusword_last; + bool ready; + + uint16_t controlword_terminal; + uint16_t controlword_terminal_last; + uint16_t controlword_user; + uint16_t controlword_user_last; + + int num_receive_bytes; + uint8_t received_bytes[JSD_EL6001_NUM_DATA_BYTES]; + int read_errors; + int num_bytes_received; + + uint8_t transmit_bytes[JSD_EL6001_NUM_DATA_BYTES]; + uint8_t transmit_bytes_prev[JSD_EL6001_NUM_DATA_BYTES]; + bool transmit_data; + bool user_requests_to_transmit_data; + int autoincrement_byte; + + bool timeout_active; + double timeout_sec; + double timer_start_sec; + bool timed_out; + bool checksum_failed; + + // Persistent receiving of bytes + int expected_num_bytes_to_receive; + uint8_t persistent_received_bytes[JSD_EL6001_NUM_DATA_BYTES]; + int num_persistent_bytes_received; + bool received_all_persistent_bytes; + bool received_first_byte_of_msg; + bool user_requests_to_transmit_data_persistently; + + // ecat_el6001_hsm_state_t state; + // ecat_el6001_hsm_state_t transmit_state; + +} jsd_el6001_state_t; + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/src/jsd_types.h b/src/jsd_types.h index eb880af..3f02ad0 100644 --- a/src/jsd_types.h +++ b/src/jsd_types.h @@ -20,6 +20,7 @@ extern "C" { #include "jsd/jsd_el3356_types.h" #include "jsd/jsd_el3602_types.h" #include "jsd/jsd_el4102_types.h" +#include "jsd/jsd_el6001_types.h" #include "jsd/jsd_ild1900_types.h" #include "jsd/jsd_jed0101_types.h" #include "jsd/jsd_jed0200_types.h" @@ -44,6 +45,7 @@ typedef struct { jsd_el3318_config_t el3318; jsd_el3162_config_t el3162; jsd_el4102_config_t el4102; + jsd_el6001_config_t el6001; jsd_ild1900_config_t ild1900; }; bool PO2SO_success; // reserved for internal use @@ -65,6 +67,7 @@ typedef struct { jsd_el3318_state_t el3318; jsd_el3162_state_t el3162; jsd_el4102_state_t el4102; + jsd_el6001_state_t el6001; jsd_ild1900_state_t ild1900; }; From d515989bfaf17cac376acf67fde21e741998920a Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 16 Feb 2023 15:02:05 -0800 Subject: [PATCH 02/37] Building up jsd6001 driver --- src/jsd_el6001.c | 376 ++++++++++++++++++++++++++++++++++++++++- src/jsd_el6001_pub.h | 8 +- src/jsd_el6001_types.h | 122 ++++++++----- 3 files changed, 458 insertions(+), 48 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 57dd180..c6b3140 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -1,19 +1,109 @@ #include "jsd/jsd_el6001.h" #include +#include #include "jsd/jsd.h" #include "jsd/jsd_sdo.h" +#define HEX_FORMAT "0x%02X" + +// Print functions +static void jsd_el6001_print_controlword(const char* prefix, uint16_t controlword, uint16_t slave_id) { + uint8_t output_length = controlword >> JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0; + + MSG( + "EL6001 ID %d: %s("HEX_FORMAT"), %s%s%s%s%d output bytes", + slave_id, + prefix, + controlword, + (controlword & (1 << JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)) ? "Transmit Request | " : "", + (controlword & (1 << JSD_EL6001_CONTROLWORD_RECEIVE_ACCEPTED)) ? "Receive Accepted | " : "", + (controlword & (1 << JSD_EL6001_CONTROLWORD_INIT_REQUEST)) ? "Init Request | " : "", + (controlword & (1 << JSD_EL6001_CONTROLWORD_SEND_CONTINUOUS)) ? "Send Continuous | " : "", + output_length); +} + +static char* jsd_el6001_sms_to_string(jsd_el6001_sms_t sms) { + switch (sms) + { + case JSD_EL6001_SMS_INITING: return "INITING_SERIAL_COMMUNICATION"; + case JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT: return "WAITING_FOR_INIT_TO_COMPLETE"; + case JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION: return "READY_FOR_SERIAL_COMMUNICATION"; + case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: return "WAITING_FOR_TRANSMIT_REQUEST_FROM_USER"; + case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: return "WAITING_FOR_TRANSMIT_CONFIRMATION_FROM_TERMINAL"; + + default: assert(0); break; + } +} + +// Controlwords +static void jsd_el6001_set_controlword(jsd_t* self, uint16_t slave_id, uint16_t control_word) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_print_controlword("Setting control word of: ", control_word, slave_id); + self->slave_states[slave_id].el6001.controlword_user = control_word; +} + +static uint16_t jsd_el6001_set_controlword_bit(const jsd_t* self, uint16_t slave_id, int bit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(bit >= 0); + assert(bit < JSD_EL6001_NUM_CONTROLWORD_BITS); + + return self->slave_states[slave_id].el6001.controlword_user | (1 << bit); +} + +static uint16_t jsd_el6001_clear_controlword_bit(const jsd_t* self, uint16_t slave_id, int bit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(bit >= 0); + assert(bit < JSD_EL6001_NUM_CONTROLWORD_BITS); + + return self->slave_states[slave_id].el6001.controlword_user & ~(1 << bit); +} + +static uint16_t jsd_el6001_toggle_controlword_bit(const jsd_t* self, uint16_t slave_id, int bit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(bit >= 0); + assert(bit < JSD_EL6001_NUM_CONTROLWORD_BITS); + + return self->slave_states[slave_id].el6001.controlword_user ^ (1 << bit); +} + +// Statuswords static bool jsd_el6001_statusword_bit_is_set(const jsd_t* self, uint16_t slave_id, int bit) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); assert(bit >= 0); - assert(bit < JSD_EL6001_NUM_STATUS_WORD_BITS); + assert(bit < JSD_EL6001_NUM_STATUSWORD_BITS); return self->slave_states[slave_id].el6001.statusword & (1 << bit); } +static bool jsd_el6001_statusword_bit_went_high(const jsd_t* self, uint16_t slave_id, int bit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(bit >= 0); + assert(bit < JSD_EL6001_NUM_STATUSWORD_BITS); + + return( !(self->slave_states[slave_id].el6001.statusword_last & (1 << bit)) + && (self->slave_states[slave_id].el6001.statusword & (1 << bit))); +} + +static bool jsd_el6001_statusword_bit_was_toggled(const jsd_t* self, uint16_t slave_id, int bit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(bit >= 0); + assert(bit < JSD_EL6001_NUM_STATUSWORD_BITS); + + return( (self->slave_states[slave_id].el6001.statusword_last & (1 << bit)) + != (self->slave_states[slave_id].el6001.statusword & (1 << bit)) ); +} + +// Fault check static int jsd_el6001_check_for_faults(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); @@ -22,22 +112,22 @@ static int jsd_el6001_check_for_faults(jsd_t* self, uint16_t slave_id) { if (state->statusword != state->statusword_last) { - if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_FIFO_BUFFER_FULL)) + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUSWORD_FIFO_BUFFER_FULL)) { ERROR("EL6001[%d]: FIFO buffer is full", slave_id); } - if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_PARITY_ERROR)) + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUSWORD_PARITY_ERROR)) { ERROR("EL6001[%d]: Parity error", slave_id); } - if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_FRAMING_ERROR)) + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUSWORD_FRAMING_ERROR)) { ERROR("EL6001[%d]: Framing error", slave_id); } - if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUS_WORD_OVERRUN_ERROR)) + if (jsd_el6001_statusword_bit_is_set(self, slave_id, JSD_EL6001_STATUSWORD_OVERRUN_ERROR)) { ERROR("EL6001[%d]: Overrun error", slave_id); } @@ -46,6 +136,197 @@ static int jsd_el6001_check_for_faults(jsd_t* self, uint16_t slave_id) { return 0; } +// State Machine States +static int jsd_el6001_transition_sms(jsd_el6001_sms_t sms, jsd_el6001_sms_t* sms_ptr) { + assert(sms_ptr != NULL); + + *sms_ptr = sms; + MSG_DEBUG("Transitioning to %s state", jsd_el6001_sms_to_string(sms)); + + return 0; +} + +static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { + int i; + int8_t checksum = 0; + + // sum each individual byte + for (i = 0; i < num_bytes; ++i) + { + checksum += data[i]; + } + + return checksum; +} + + +//---------------------------------------------------------------------------// +// RECEIVE + +static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + + int i; + int num_bytes_received = 0; + int8_t expected_checksum; + int8_t checksum; + bool ok = true; + + state->checksum_failed = false; + + // If terminal requests computer to receive data (ie. RECEIVE_REQUEST bit was toggled), indicating there's + // newly received data, read the data bytes + if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_RECEIVE_REQUEST)) + { + state->received_all_persistent_bytes = false; + + // Get number of data bytes received from the status word + num_bytes_received = (state->statusword & JSD_EL6001_STATUSWORD_INPUT_LENGTH_BIT_MASK) >> JSD_EL6001_STATUSWORD_INPUT_LENGTH_0; + MSG_DEBUG("EL6001[%d]: num bytes received: %d", slave_id, num_bytes_received); + + // assert number of bytes received is not above terminal capacity + if(num_bytes_received > JSD_EL6001_NUM_DATA_BYTES) + { + ERROR("Received more data than can handle"); + assert(0); + } + + if (!state->received_first_byte_of_msg) + { + state->num_persistent_bytes_received = 0; + } + + // Need to prevent IOOB on the persistent received bytes + if(state->num_persistent_bytes_received + num_bytes_received > JSD_EL6001_MAX_NUM_DATA_BYTES) + { + ERROR("EL6001[%d]: Number of received bytes larger than persistence window. " + "num_persistent_bytes_received = %d. " + "num_bytes_received = %d. " + "ECAT_EL6001_MAX_NUM_DATA_BYTES = %d. ", + slave_id, + state->num_persistent_bytes_received, + num_bytes_received, + JSD_EL6001_MAX_NUM_DATA_BYTES); + + state->num_persistent_bytes_received = 0; + state->received_first_byte_of_msg = false; + } + + // Store the received data bytes + for (i = 0; i < num_bytes_received; ++i) + { + state->persistent_received_bytes[state->num_persistent_bytes_received + i] = state->received_bytes[i]; + } + + // increment number of persistent bytes by number received on this iteration + state->num_persistent_bytes_received += num_bytes_received; + + // if first byte of persistent receipt wasn't received yet, set number of + // bytes to receive from the first byte of the message + if (!state->received_first_byte_of_msg) + { + /// Always set number of expected bytes based on the first byte of the packet + + state->expected_num_bytes_to_receive = ( + 1 /*num_bytes byte*/ + + state->received_bytes[0] + + 1 /*checksum byte*/); + + state->received_first_byte_of_msg = true; + } + + // If there's a more than one whole expected packet, drop the earlier ones. Increment the error counter. + if (state->num_persistent_bytes_received > 2 * state->expected_num_bytes_to_receive) + { + int packets_to_drop = floor(state->num_persistent_bytes_received / state->expected_num_bytes_to_receive) - 1; + int bytes_to_drop = packets_to_drop * state->expected_num_bytes_to_receive; + + ERROR( + "EL6001 id %d: " + "Received %d persistent bytes, but expected_num_bytes_to_receive = %d. " + "Dropping %d stale packets (%d bytes).", + slave_id, + state->num_persistent_bytes_received, + state->expected_num_bytes_to_receive, + packets_to_drop, + bytes_to_drop); + + ++state->read_errors; + + // Dropping all packets before the latest whole packet + // Shift the persistent bytes over by bytes_to_drop + for (i = 0; i < (state->num_persistent_bytes_received - bytes_to_drop); ++i) + { + state->persistent_received_bytes[i] = state->persistent_received_bytes[i + bytes_to_drop]; + } + state->num_persistent_bytes_received -= bytes_to_drop; + } + + // If we received one whole packet, parse it. Checksum is last byte + if (state->num_persistent_bytes_received >= state->expected_num_bytes_to_receive) + { + MSG_DEBUG("EL6001 id %d: Received all expected %d bytes", slave_id, state->expected_num_bytes_to_receive); + + expected_checksum = state->persistent_received_bytes[state->expected_num_bytes_to_receive - 1]; + checksum = jsd_el6001_compute_checksum( + state->persistent_received_bytes, + state->expected_num_bytes_to_receive - 1/*checksum*/); + if (expected_checksum != checksum) + { + ERROR("EL6001 id %d: Checksum invalid. Expected: %d, Computed: %d", slave_id, expected_checksum, checksum); + state->checksum_failed = true; + ++state->read_errors; + //ok = false; + } + + // No Partial Packet + if (state->num_persistent_bytes_received == state->expected_num_bytes_to_receive) + { + // Received all expected bytes without errors. User must use this + // before the next loop + state->received_all_persistent_bytes = true; + + // reset first byte check + state->received_first_byte_of_msg = false; + } + else + { + // Copy partial packet to front of queue + ERROR( + "EL6001 id %d: " + "Full and partial packet received in one cycle. " + "Received %d persistent bytes, but expected num bytes to receive " + "is %d.", + slave_id, + state->num_persistent_bytes_received, + state->expected_num_bytes_to_receive); + + ++state->read_errors; + + state->num_persistent_bytes_received -= state->expected_num_bytes_to_receive; + for (i = 0; i < state->num_persistent_bytes_received; ++i) + { + state->persistent_received_bytes[i] = + state->persistent_received_bytes[i + state->expected_num_bytes_to_receive]; + } + } + } + + // Tell terminal that data was received, so that new data can be received from the terminal + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_RECEIVE_ACCEPTED)); + + MSG_DEBUG("EL6001 id %d: num bytes received = %d", slave_id, num_bytes_received); + } + + // Set for user to know number of bytes received + state->num_bytes_received = num_bytes_received; + + return ok ? 0 : -1; +} + /**************************************************** * Public functions ****************************************************/ @@ -76,6 +357,30 @@ void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id) { state->statusword_last = state->statusword; state->statusword = txpdo->statusword; + + // TODO: check whether we can receive packed data as array + state->received_bytes[0] = txpdo->data_in_0; + state->received_bytes[1] = txpdo->data_in_1; + state->received_bytes[2] = txpdo->data_in_2; + state->received_bytes[3] = txpdo->data_in_3; + state->received_bytes[4] = txpdo->data_in_4; + state->received_bytes[5] = txpdo->data_in_5; + state->received_bytes[6] = txpdo->data_in_6; + state->received_bytes[7] = txpdo->data_in_7; + state->received_bytes[8] = txpdo->data_in_8; + state->received_bytes[9] = txpdo->data_in_9; + state->received_bytes[10] = txpdo->data_in_10; + state->received_bytes[11] = txpdo->data_in_11; + state->received_bytes[12] = txpdo->data_in_12; + state->received_bytes[13] = txpdo->data_in_13; + state->received_bytes[14] = txpdo->data_in_14; + state->received_bytes[15] = txpdo->data_in_15; + state->received_bytes[16] = txpdo->data_in_16; + state->received_bytes[17] = txpdo->data_in_17; + state->received_bytes[18] = txpdo->data_in_18; + state->received_bytes[19] = txpdo->data_in_19; + state->received_bytes[20] = txpdo->data_in_20; + state->received_bytes[21] = txpdo->data_in_21; } void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { @@ -83,10 +388,66 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + // read PDOs, updates status_word jsd_el6001_read_PDO_data(self, slave_id); + // check for faults in statuswords jsd_el6001_check_for_faults(self, slave_id); + + // Main state machine + switch (state->sms){ + case JSD_EL6001_SMS_INITING: + { + // Request Beckhoff terminal to initialize + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_set_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_INIT_REQUEST)); + jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT, &self->slave_states[slave_id].el6001.sms); + } + break; + + case JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT: // Waiting for Beckhoff terminal to initialize + { + if (jsd_el6001_statusword_bit_went_high(self, slave_id, JSD_EL6001_STATUSWORD_INIT_ACCEPTED)) + { + // Clear init request in order to make terminal ready for serial communication + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_INIT_REQUEST)); + jsd_el6001_transition_sms(JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, &self->slave_states[slave_id].el6001.sms); + } + } + break; + + case JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION: + { + // Normal operation state machine state + // receive serial data + if (jsd_el6001_receive_data(self, slave_id) != 0) + { + return; + } + + // // If any of the bytes to transmit have changed, write them to the bus + // size_t byte_ndx; + // for (byte_ndx = 0; byte_ndx < ECAT_EL6001_NUM_DATA_BYTES; byte_ndx++) + // { + // if (data->transmit_bytes[byte_ndx] != data->transmit_bytes_prev[byte_ndx]) + // { + // EC_WRITE_U8( + // self->domain_pd_output + self->offsets_output[id][ECAT_EL6001_DATA_OUT_BYTE_00 + byte_ndx], + // state->transmit_bytes[byte_ndx]); + // } + // data->transmit_bytes_prev[byte_ndx] = data->transmit_bytes[byte_ndx]; + // } + + // // transmit user serial data + // ecat_el6001_transmit_data(self, id); + } + break; + + default: + assert(0); + break; + } } @@ -116,9 +477,12 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { JSD_BECKHOFF_VENDOR_ID); jsd_slave_config_t* config = &self->slave_configs[slave_id]; + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; - // No PO2SO callback for 4102 devices, so set the success flag now + // TODO No PO2SO callback for 4102 devices, so set the success flag now config->PO2SO_success = true; + state->sms = JSD_EL6001_SMS_INITING; // TODO: This used to be done in configure_sdos + return true; } diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 54f3fe2..9280bef 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -23,7 +23,13 @@ const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); /** * @brief Writes the set commands into the SOEM IOmap and processes asynchronous * SDO responses - * + * Reads Process Data Objects + * Writes control word to transition through states + * Writes control word to transmit and receive data + * After this function (in between jsd_process calls: + * User can affect control word number of output bytes + * User can affect transmit request bit + * * @param self Pointer to JSD context * @param slave_id Slave ID of EL6001 device */ diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index ea3ebc7..3095673 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -7,64 +7,68 @@ extern "C" { #include "jsd/jsd_common_device_types.h" -#define JSD_EL6001_PRODUCT_CODE (uint32_t)0x17853052 //17713052 in old ecat driver +#define JSD_EL6001_PRODUCT_CODE (uint32_t)0x17853052 // TODO: 17713052 in old ecat driver #define JSD_EL6001_NUM_CHANNELS 1 #define JSD_EL6001_NUM_DATA_BYTES 22 +#define JSD_EL6001_MAX_NUM_DATA_BYTES 100 + +#define JSD_EL6001_STATUSWORD_INPUT_LENGTH_BIT_MASK 0xFF00 ///< Bits 8-15 define the number of input bytes available for transfer from terminal to computer + typedef enum { - JSD_EL6001_CONTROL_WORD_TRANSMIT_REQUEST = 0, ///< Toggle to notify terminal that DataOut bytes contain number of bytes indicated via + JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST = 0, ///< Toggle to notify terminal that DataOut bytes contain number of bytes indicated via ///< OL bits. Terminal acknowledges receipt of data via toggle of SW0 - JSD_EL6001_CONTROL_WORD_RECEIVE_ACCEPTED, ///< Controller acknowledges receipt of data via toggle of this bit - JSD_EL6001_CONTROL_WORD_INIT_REQUEST, ///< 1: Controller requests terminal to initialize. Terminal acknowledges completion by SW2 + JSD_EL6001_CONTROLWORD_RECEIVE_ACCEPTED, ///< Controller acknowledges receipt of data via toggle of this bit + JSD_EL6001_CONTROLWORD_INIT_REQUEST, ///< 1: Controller requests terminal to initialize. Terminal acknowledges completion by SW2 ///< 0: Controller once again request terminal to prepare for serial data exchange - JSD_EL6001_CONTROL_WORD_SEND_CONTINUOUS, ///< Rising edge (0->1): Continuous sending of data from the FIFO buffer. + JSD_EL6001_CONTROLWORD_SEND_CONTINUOUS, ///< Rising edge (0->1): Continuous sending of data from the FIFO buffer. ///< Send buffer is filled (<= 128 bytes) by controller. Buffer content is sent with ///< rising edge of this bit. Terminal acknowledges the data transfer to controller ///< through setting of bit SW2. SW2 is cancelled with CW3 - JSD_EL6001_CONTROL_WORD_RESERVED_0, - JSD_EL6001_CONTROL_WORD_RESERVED_1, - JSD_EL6001_CONTROL_WORD_RESERVED_2, - JSD_EL6001_CONTROL_WORD_RESERVED_3, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_0, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_1, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_2, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_3, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_4, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_5, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_6, - JSD_EL6001_CONTROL_WORD_OUTPUT_LENGTH_7, - JSD_EL6001_NUM_CONTROL_WORD_BITS - -} jsd_el6001_control_word_bit_t; + JSD_EL6001_CONTROLWORD_RESERVED_0, + JSD_EL6001_CONTROLWORD_RESERVED_1, + JSD_EL6001_CONTROLWORD_RESERVED_2, + JSD_EL6001_CONTROLWORD_RESERVED_3, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_1, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_2, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_3, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_4, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_5, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_6, + JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_7, + JSD_EL6001_NUM_CONTROLWORD_BITS + +} jsd_el6001_controlword_bit_t; typedef enum { - JSD_EL6001_STATUS_WORD_TRANSMIT_ACCEPTED = 0, ///< Toggle acknowledges receipt of data. Only now new data can be transmitted + JSD_EL6001_STATUSWORD_TRANSMIT_ACCEPTED = 0, ///< Toggle acknowledges receipt of data. Only now new data can be transmitted ///< from controller to terminal. - JSD_EL6001_STATUS_WORD_RECEIVE_REQUEST, ///< Toggle notifies the controller that DataIn bytes contain number of bytes in IL bits + JSD_EL6001_STATUSWORD_RECEIVE_REQUEST, ///< Toggle notifies the controller that DataIn bytes contain number of bytes in IL bits ///< Controller must acknowledge receipt of data in control byte via toggling CW1. ///< Only then new data can be transferred from terminal to controller. - JSD_EL6001_STATUS_WORD_INIT_ACCEPTED, ///< 1: init completed by terminal. 0: terminal ready for serial data exchange. - JSD_EL6001_STATUS_WORD_FIFO_BUFFER_FULL, ///< 1: all incoming data will be lost until buffer is not full - JSD_EL6001_STATUS_WORD_PARITY_ERROR, ///< A parity error has occurred - JSD_EL6001_STATUS_WORD_FRAMING_ERROR, ///< A framing error has occurred - JSD_EL6001_STATUS_WORD_OVERRUN_ERROR, ///< An overrun error has occurred - JSD_EL6001_STATUS_WORD_RESERVED, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_0, ///< = 8 (BIT08) - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_1, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_2, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_3, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_4, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_5, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_6, - JSD_EL6001_STATUS_WORD_INPUT_LENGTH_7, ///< = 15 (BIT15) - JSD_EL6001_NUM_STATUS_WORD_BITS ///< = 16 - -} jsd_el6001_status_word_bit_t; + JSD_EL6001_STATUSWORD_INIT_ACCEPTED, ///< 1: init completed by terminal. 0: terminal ready for serial data exchange. + JSD_EL6001_STATUSWORD_FIFO_BUFFER_FULL, ///< 1: all incoming data will be lost until buffer is not full + JSD_EL6001_STATUSWORD_PARITY_ERROR, ///< A parity error has occurred + JSD_EL6001_STATUSWORD_FRAMING_ERROR, ///< A framing error has occurred + JSD_EL6001_STATUSWORD_OVERRUN_ERROR, ///< An overrun error has occurred + JSD_EL6001_STATUSWORD_RESERVED, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_0, ///< = 8 (BIT08) + JSD_EL6001_STATUSWORD_INPUT_LENGTH_1, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_2, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_3, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_4, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_5, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_6, + JSD_EL6001_STATUSWORD_INPUT_LENGTH_7, ///< = 15 (BIT15) + JSD_EL6001_NUM_STATUSWORD_BITS ///< = 16 + +} jsd_el6001_statusword_bit_t; /** * @brief Set using object 0x8000:11 to one of the following values @@ -105,9 +109,45 @@ typedef struct __attribute__((__packed__)) { * Note: struct order matters and must be packed. */ typedef struct __attribute__((__packed__)) { - uint16_t statusword; + uint16_t statusword; //0x6000:01 - 10 + uint8_t data_in_0; + uint8_t data_in_1; + uint8_t data_in_2; + uint8_t data_in_3; + uint8_t data_in_4; + uint8_t data_in_5; + uint8_t data_in_6; + uint8_t data_in_7; + uint8_t data_in_8; + uint8_t data_in_9; + uint8_t data_in_10; + uint8_t data_in_11; + uint8_t data_in_12; + uint8_t data_in_13; + uint8_t data_in_14; + uint8_t data_in_15; + uint8_t data_in_16; + uint8_t data_in_17; + uint8_t data_in_18; + uint8_t data_in_19; + uint8_t data_in_20; + uint8_t data_in_21; } jsd_el6001_txpdo_data_t; +/** + * @brief State Machine States needed for communication via serial RS232 interface + */ +typedef enum +{ + JSD_EL6001_SMS_INITING = 0, + JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT, + JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, + JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, + JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, + JSD_EL6001_SMS_NUM_STATES + +} jsd_el6001_sms_t; + /** * @brief EL6001 state data */ @@ -148,7 +188,7 @@ typedef struct bool received_first_byte_of_msg; bool user_requests_to_transmit_data_persistently; - // ecat_el6001_hsm_state_t state; + jsd_el6001_sms_t sms; // ecat_el6001_hsm_state_t transmit_state; } jsd_el6001_state_t; From fe111bea2ed4f0f6d3c61dcf59a67db07994e9d7 Mon Sep 17 00:00:00 2001 From: David Kim Date: Tue, 21 Feb 2023 19:51:01 -0800 Subject: [PATCH 03/37] Adding transmit/receive --- src/jsd_el6001.c | 156 +++++++++++++++++++++++++++++++++-------- src/jsd_el6001_pub.h | 20 +----- src/jsd_el6001_types.h | 4 +- 3 files changed, 128 insertions(+), 52 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index c6b3140..ceb4611 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -162,12 +162,13 @@ static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { //---------------------------------------------------------------------------// // RECEIVE +//---------------------------------------------------------------------------// static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; int i; int num_bytes_received = 0; @@ -190,7 +191,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // assert number of bytes received is not above terminal capacity if(num_bytes_received > JSD_EL6001_NUM_DATA_BYTES) { - ERROR("Received more data than can handle"); + ERROR("Terminal received more data than can handle"); assert(0); } @@ -213,6 +214,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { state->num_persistent_bytes_received = 0; state->received_first_byte_of_msg = false; + ++state->read_errors; } // Store the received data bytes @@ -278,8 +280,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { { ERROR("EL6001 id %d: Checksum invalid. Expected: %d, Computed: %d", slave_id, expected_checksum, checksum); state->checksum_failed = true; - ++state->read_errors; - //ok = false; + ++state->read_errors; } // No Partial Packet @@ -327,6 +328,103 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { return ok ? 0 : -1; } +//---------------------------------------------------------------------------// +// TRANSMIT +//---------------------------------------------------------------------------// + +static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + + switch (state->transmit_state) + { + case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: + if (state->user_requests_to_transmit_data) + { + // Tell terminal that data is available to transmit and then transition + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + + jsd_el6001_transition_state(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + + state->timer_start_sec = jsd_time_get_mono_time_sec(); + + // Reset user transmit variable + state->user_requests_to_transmit_data = false; + } + else if (state->user_requests_to_transmit_data_persistently) + { + if (jsd_el6001_all_persistent_data_was_received(self, slave_id)) + { + // Tell terminal that data is available to transmit and then transition + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + + jsd_el6001_transition_state(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + + state->timer_start_sec = jsd_time_get_mono_time_sec(); + } + else + { + double time_since_last_transmit = ecat_timer_get_time_sec() - self->data[id].timer_start_sec; + if ( + self->data[id].timeout_active + && (time_since_last_transmit > self->data[id].timeout_sec)) + { + MSG_ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for persistent data.", id, time_since_last_transmit); + MSG_ERROR("EL6001 id %d: Clearing persistent data buffer in order to transmit fresh data in the next cycle.", id); + self->data[id].num_persistent_bytes_received = 0; + self->data[id].received_all_persistent_bytes = 1; + self->data[id].received_first_byte_of_msg = false; + } + } + } + break; + + case ECAT_EL6001_HSM_WAITING_FOR_TRANSMIT_CONFIRMATION: + { + double time_since_last_transmit = ecat_timer_get_time_sec() - self->data[id].timer_start_sec; + if (self->data[id].timeout_active && (time_since_last_transmit > self->data[id].timeout_sec)) + { + MSG_ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for transmit confirmation.", id, time_since_last_transmit); + ecat_el6001_transition_state( + ECAT_EL6001_HSM_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, + &self->data[id].transmit_state); + } + else if (ecat_el6001_status_word_bit_was_toggled(self, id, ECAT_EL6001_STATUS_WORD_TRANSMIT_ACCEPTED)) + { + // Beckhoff terminal transmitted data. + MSG_SILENT("Transmit accepted"); + + // Go back to waiting for another transmit request + ecat_el6001_transition_state( + ECAT_EL6001_HSM_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, + &self->data[id].transmit_state); + + // Start timeout timer + self->data[id].timer_start_sec = ecat_timer_get_time_sec(); + + //Increment the successful transmit counter + if (self->data[id].autoincrement_byte >= 0) + { + ecat_el6001_set_transmit_data_8bits( + self, + id, + self->data[id].autoincrement_byte, + self->data[id].transmit_bytes[self->data[id].autoincrement_byte] + 1); + } + } + } + break; + + default: + assert(0); + break; + } + + return 0; +} + /**************************************************** * Public functions ****************************************************/ @@ -423,23 +521,25 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { // receive serial data if (jsd_el6001_receive_data(self, slave_id) != 0) { + assert(0); return; } - // // If any of the bytes to transmit have changed, write them to the bus - // size_t byte_ndx; - // for (byte_ndx = 0; byte_ndx < ECAT_EL6001_NUM_DATA_BYTES; byte_ndx++) - // { - // if (data->transmit_bytes[byte_ndx] != data->transmit_bytes_prev[byte_ndx]) - // { - // EC_WRITE_U8( - // self->domain_pd_output + self->offsets_output[id][ECAT_EL6001_DATA_OUT_BYTE_00 + byte_ndx], - // state->transmit_bytes[byte_ndx]); - // } - // data->transmit_bytes_prev[byte_ndx] = data->transmit_bytes[byte_ndx]; - // } - - // // transmit user serial data + // If any of the bytes to transmit have changed, write them to the bus + size_t byte_ndx; + for (byte_ndx = 0; byte_ndx < JSD_EL6001_NUM_DATA_BYTES; byte_ndx++) + { + if (state->transmit_bytes[byte_ndx] != state->transmit_bytes_prev[byte_ndx]) + { + // Write to RxPDO + // EC_WRITE_U8( + // self->domain_pd_output + self->offsets_output[id][ECAT_EL6001_DATA_OUT_BYTE_00 + byte_ndx], + // state->transmit_bytes[byte_ndx]); + } + state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; + } + + // transmit user serial data // ecat_el6001_transmit_data(self, id); } break; @@ -451,19 +551,13 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { } -// void jsd_el6001_write_single_channel(jsd_t* self, uint16_t slave_id, -// uint8_t channel, double output) { -// assert(self); -// assert(self->ecx_context.slavelist[slave_id].eep_id == -// JSD_EL6001_PRODUCT_CODE); -// } - -// void jsd_el6001_write_all_channels(jsd_t* self, uint16_t slave_id, -// double output[JSD_EL6001_NUM_CHANNELS]) { -// // for (int ch = 0; ch < JSD_EL6001_NUM_CHANNELS; ++ch) { -// // jsd_el6001_write_single_channel(self, slave_id, ch, output[ch]); -// // } -// } +bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == + JSD_EL6001_PRODUCT_CODE); + + return self->slave_states[slave_id].el6001.received_all_persistent_bytes; +} /**************************************************** * Private functions diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 9280bef..44360e3 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -35,26 +35,8 @@ const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_process(jsd_t* self, uint16_t slave_id); -/** - * @brief Sets the voltage (V) command for the given channel - * - * @param self Pointer to JSD context - * @param slave_id Slave ID of EL6001 device - * @param channel Device channel to command - * @param output Commanded voltage. Provided value is clamped within [0-10]. - */ -void jsd_el4102_write_single_channel(jsd_t* self, uint16_t slave_id, - uint8_t channel, double output); +bool jsd_el6001_all_persistent_data_was_received(jsd_t* self, uint16_t slave_id); -/** - * @brief Sets the voltage (V) command for each channel - * - * @param self Pointer to JSD context - * @param slave_id Slave ID of EL6001 device - * @param output Commanded voltages. Provided values are clamped within [0-10]. - */ -void jsd_el4102_write_all_channels(jsd_t* self, uint16_t slave_id, - double output[JSD_EL6001_NUM_CHANNELS]); #ifdef __cplusplus } diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index 3095673..71b5049 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -182,14 +182,14 @@ typedef struct // Persistent receiving of bytes int expected_num_bytes_to_receive; - uint8_t persistent_received_bytes[JSD_EL6001_NUM_DATA_BYTES]; + uint8_t persistent_received_bytes[JSD_EL6001_MAX_NUM_DATA_BYTES]; int num_persistent_bytes_received; bool received_all_persistent_bytes; bool received_first_byte_of_msg; bool user_requests_to_transmit_data_persistently; jsd_el6001_sms_t sms; - // ecat_el6001_hsm_state_t transmit_state; + jsd_el6001_sms_t transmit_state; } jsd_el6001_state_t; From 33b668cf85092989eacfbbcec69ad73224821895 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 22 Feb 2023 09:32:20 -0800 Subject: [PATCH 04/37] Finished transmit --- src/jsd_el6001.c | 69 ++++++++++++++++++++++-------------------- src/jsd_el6001.h | 4 +++ src/jsd_el6001_pub.h | 1 - src/jsd_el6001_types.h | 51 +++++++++++++++++++++++++++++++ 4 files changed, 91 insertions(+), 34 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index ceb4611..6d2f1e7 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -346,7 +346,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_state(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); state->timer_start_sec = jsd_time_get_mono_time_sec(); @@ -360,58 +360,48 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_state(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); state->timer_start_sec = jsd_time_get_mono_time_sec(); } else { - double time_since_last_transmit = ecat_timer_get_time_sec() - self->data[id].timer_start_sec; - if ( - self->data[id].timeout_active - && (time_since_last_transmit > self->data[id].timeout_sec)) + double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; + if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { - MSG_ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for persistent data.", id, time_since_last_transmit); - MSG_ERROR("EL6001 id %d: Clearing persistent data buffer in order to transmit fresh data in the next cycle.", id); - self->data[id].num_persistent_bytes_received = 0; - self->data[id].received_all_persistent_bytes = 1; - self->data[id].received_first_byte_of_msg = false; + ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for persistent data.", slave_id, time_since_last_transmit); + ERROR("EL6001 id %d: Clearing persistent data buffer in order to transmit fresh data in the next cycle.", slave_id); + state->num_persistent_bytes_received = 0; + state->received_all_persistent_bytes = 1; + state->received_first_byte_of_msg = false; } } } break; - case ECAT_EL6001_HSM_WAITING_FOR_TRANSMIT_CONFIRMATION: + case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: { - double time_since_last_transmit = ecat_timer_get_time_sec() - self->data[id].timer_start_sec; - if (self->data[id].timeout_active && (time_since_last_transmit > self->data[id].timeout_sec)) + double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; + if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { - MSG_ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for transmit confirmation.", id, time_since_last_transmit); - ecat_el6001_transition_state( - ECAT_EL6001_HSM_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, - &self->data[id].transmit_state); + ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); + jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } - else if (ecat_el6001_status_word_bit_was_toggled(self, id, ECAT_EL6001_STATUS_WORD_TRANSMIT_ACCEPTED)) + else if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_TRANSMIT_ACCEPTED)) { // Beckhoff terminal transmitted data. - MSG_SILENT("Transmit accepted"); + MSG_DEBUG("Transmit accepted"); // Go back to waiting for another transmit request - ecat_el6001_transition_state( - ECAT_EL6001_HSM_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, - &self->data[id].transmit_state); + jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); // Start timeout timer - self->data[id].timer_start_sec = ecat_timer_get_time_sec(); + state->timer_start_sec = jsd_time_get_mono_time_sec(); //Increment the successful transmit counter - if (self->data[id].autoincrement_byte >= 0) + if (state->autoincrement_byte >= 0) { - ecat_el6001_set_transmit_data_8bits( - self, - id, - self->data[id].autoincrement_byte, - self->data[id].transmit_bytes[self->data[id].autoincrement_byte] + 1); + jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); } } } @@ -487,6 +477,8 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { JSD_EL6001_PRODUCT_CODE); jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + + jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; // read PDOs, updates status_word jsd_el6001_read_PDO_data(self, slave_id); @@ -531,6 +523,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { { if (state->transmit_bytes[byte_ndx] != state->transmit_bytes_prev[byte_ndx]) { + rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; // Write to RxPDO // EC_WRITE_U8( // self->domain_pd_output + self->offsets_output[id][ECAT_EL6001_DATA_OUT_BYTE_00 + byte_ndx], @@ -540,7 +533,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { } // transmit user serial data - // ecat_el6001_transmit_data(self, id); + jsd_el6001_transmit_data(self, slave_id); } break; @@ -553,12 +546,22 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == - JSD_EL6001_PRODUCT_CODE); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); return self->slave_states[slave_id].el6001.received_all_persistent_bytes; } +int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(byte < JSD_EL6001_DATA_OUT_BYTE_21); + assert(byte >= 0); + + self->slave_states[slave_id].el6001.transmit_bytes[byte] = value; + + return 0; +} + /**************************************************** * Private functions ****************************************************/ diff --git a/src/jsd_el6001.h b/src/jsd_el6001.h index 3f28290..fa762d3 100644 --- a/src/jsd_el6001.h +++ b/src/jsd_el6001.h @@ -24,6 +24,10 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); +bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id); + +int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); + #ifdef __cplusplus } #endif diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 44360e3..1d05cd9 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -35,7 +35,6 @@ const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_process(jsd_t* self, uint16_t slave_id); -bool jsd_el6001_all_persistent_data_was_received(jsd_t* self, uint16_t slave_id); #ifdef __cplusplus diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index 71b5049..4d5c18b 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -17,6 +17,35 @@ extern "C" { #define JSD_EL6001_STATUSWORD_INPUT_LENGTH_BIT_MASK 0xFF00 ///< Bits 8-15 define the number of input bytes available for transfer from terminal to computer +typedef enum +{ + JSD_EL6001_CONTROLWORD = 0, + JSD_EL6001_DATA_OUT_BYTE_00, + JSD_EL6001_DATA_OUT_BYTE_01, + JSD_EL6001_DATA_OUT_BYTE_02, + JSD_EL6001_DATA_OUT_BYTE_03, + JSD_EL6001_DATA_OUT_BYTE_04, + JSD_EL6001_DATA_OUT_BYTE_05, + JSD_EL6001_DATA_OUT_BYTE_06, + JSD_EL6001_DATA_OUT_BYTE_07, + JSD_EL6001_DATA_OUT_BYTE_08, + JSD_EL6001_DATA_OUT_BYTE_09, + JSD_EL6001_DATA_OUT_BYTE_10, + JSD_EL6001_DATA_OUT_BYTE_11, + JSD_EL6001_DATA_OUT_BYTE_12, + JSD_EL6001_DATA_OUT_BYTE_13, + JSD_EL6001_DATA_OUT_BYTE_14, + JSD_EL6001_DATA_OUT_BYTE_15, + JSD_EL6001_DATA_OUT_BYTE_16, + JSD_EL6001_DATA_OUT_BYTE_17, + JSD_EL6001_DATA_OUT_BYTE_18, + JSD_EL6001_DATA_OUT_BYTE_19, + JSD_EL6001_DATA_OUT_BYTE_20, + JSD_EL6001_DATA_OUT_BYTE_21, + JSD_EL6001_NUM_PDO_ENTRIES_OUTPUT, + +} jsd_el6001_rxpdo_entries_t; + typedef enum { JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST = 0, ///< Toggle to notify terminal that DataOut bytes contain number of bytes indicated via @@ -101,6 +130,28 @@ typedef struct { typedef struct __attribute__((__packed__)) { // jsd_el6001_rxpdo_channel_t channel[JSD_EL6001_NUM_CHANNELS]; uint16_t controlword; + uint8_t data_out_0; + uint8_t data_out_1; + uint8_t data_out_2; + uint8_t data_out_3; + uint8_t data_out_4; + uint8_t data_out_5; + uint8_t data_out_6; + uint8_t data_out_7; + uint8_t data_out_8; + uint8_t data_out_9; + uint8_t data_out_10; + uint8_t data_out_11; + uint8_t data_out_12; + uint8_t data_out_13; + uint8_t data_out_14; + uint8_t data_out_15; + uint8_t data_out_16; + uint8_t data_out_17; + uint8_t data_out_18; + uint8_t data_out_19; + uint8_t data_out_20; + uint8_t data_out_21; } jsd_el6001_rxpdo_t; /** From 49ce628bfe431289b15d1ed2deaf773cbc72106b Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 22 Feb 2023 10:25:51 -0800 Subject: [PATCH 05/37] Added controlword write --- src/jsd_el6001.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++-- src/jsd_el6001.h | 2 ++ 2 files changed, 65 insertions(+), 2 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 6d2f1e7..753d974 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -73,6 +73,20 @@ static uint16_t jsd_el6001_toggle_controlword_bit(const jsd_t* self, uint16_t sl return self->slave_states[slave_id].el6001.controlword_user ^ (1 << bit); } +static void jsd_el6001_write_controlword(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; + + jsd_el6001_print_controlword("Writing controlword to EtherCAT register of: ", state->controlword_user, slave_id); + + state->controlword_terminal_last = state->controlword_terminal; + rxpdo->controlword = state->controlword_user; + +} + // Statuswords static bool jsd_el6001_statusword_bit_is_set(const jsd_t* self, uint16_t slave_id, int bit) { assert(self); @@ -402,6 +416,8 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { if (state->autoincrement_byte >= 0) { jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); + // write into RxPDO + jsd_el6001_write_PDO_data(self, slave_id); } } } @@ -471,6 +487,44 @@ void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id) { state->received_bytes[21] = txpdo->data_in_21; } +void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == + JSD_EL6001_PRODUCT_CODE); + + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + + jsd_el6001_rxpdo_t* rxpdo = + (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; + + state->controlword_terminal_last = state->controlword_terminal; + rxpdo->controlword = state->controlword_user; + + // TODO: check whether we can receive packed data as array + rxpdo->data_out_0 = state->transmit_bytes[0]; + rxpdo->data_out_1 = state->transmit_bytes[1]; + rxpdo->data_out_2 = state->transmit_bytes[2]; + rxpdo->data_out_3 = state->transmit_bytes[3]; + rxpdo->data_out_4 = state->transmit_bytes[4]; + rxpdo->data_out_5 = state->transmit_bytes[5]; + rxpdo->data_out_6 = state->transmit_bytes[6]; + rxpdo->data_out_7 = state->transmit_bytes[7]; + rxpdo->data_out_8 = state->transmit_bytes[8]; + rxpdo->data_out_9 = state->transmit_bytes[9]; + rxpdo->data_out_10 = state->transmit_bytes[10]; + rxpdo->data_out_11 = state->transmit_bytes[11]; + rxpdo->data_out_12 = state->transmit_bytes[12]; + rxpdo->data_out_13 = state->transmit_bytes[13]; + rxpdo->data_out_14 = state->transmit_bytes[14]; + rxpdo->data_out_15 = state->transmit_bytes[15]; + rxpdo->data_out_16 = state->transmit_bytes[16]; + rxpdo->data_out_17 = state->transmit_bytes[17]; + rxpdo->data_out_18 = state->transmit_bytes[18]; + rxpdo->data_out_19 = state->transmit_bytes[19]; + rxpdo->data_out_20 = state->transmit_bytes[20]; + rxpdo->data_out_21 = state->transmit_bytes[21]; +} + void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == @@ -478,7 +532,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; - jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; + // jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; // read PDOs, updates status_word jsd_el6001_read_PDO_data(self, slave_id); @@ -523,7 +577,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { { if (state->transmit_bytes[byte_ndx] != state->transmit_bytes_prev[byte_ndx]) { - rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; + // rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; // Write to RxPDO // EC_WRITE_U8( // self->domain_pd_output + self->offsets_output[id][ECAT_EL6001_DATA_OUT_BYTE_00 + byte_ndx], @@ -542,6 +596,13 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { break; } + // If the controlword has changed, write it and update the "last" (most recent) value. + if (state->controlword_user != state->controlword_user_last) + { + jsd_el6001_write_controlword(self, slave_id); + state->controlword_user_last = state->controlword_user; + } + } bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { diff --git a/src/jsd_el6001.h b/src/jsd_el6001.h index fa762d3..be60c99 100644 --- a/src/jsd_el6001.h +++ b/src/jsd_el6001.h @@ -24,6 +24,8 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); +void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id); + bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id); int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); From 7007fe899ca215d346b403849092fb3dd9af91d8 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 1 Mar 2023 14:53:30 -0800 Subject: [PATCH 06/37] Adding SDO config function --- src/jsd_el6001.c | 84 +++++++++++++++++++++++++++++++++++++++--- src/jsd_el6001.h | 15 ++++++++ src/jsd_el6001_types.h | 18 ++++----- 3 files changed, 102 insertions(+), 15 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 753d974..14a324c 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -8,6 +8,18 @@ #define HEX_FORMAT "0x%02X" +const char* jsd_el6001_baud_rate_strings[] = { + [JSD_EL6001_BAUD_RATE_2400] = "2400 bps", + [JSD_EL6001_BAUD_RATE_4800] = "4800 bps", + [JSD_EL6001_BAUD_RATE_9600] = "9600 bps", + [JSD_EL6001_BAUD_RATE_12000] = "12000 bps", + [JSD_EL6001_BAUD_RATE_14400] = "14400 bps", + [JSD_EL6001_BAUD_RATE_19200] = "19200 bps", + [JSD_EL6001_BAUD_RATE_38400] = "38400 bps", + [JSD_EL6001_BAUD_RATE_57600] = "57600 bps", + [JSD_EL6001_BAUD_RATE_115200] = "115200 bps", +}; + // Print functions static void jsd_el6001_print_controlword(const char* prefix, uint16_t controlword, uint16_t slave_id) { uint8_t output_length = controlword >> JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0; @@ -220,7 +232,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { ERROR("EL6001[%d]: Number of received bytes larger than persistence window. " "num_persistent_bytes_received = %d. " "num_bytes_received = %d. " - "ECAT_EL6001_MAX_NUM_DATA_BYTES = %d. ", + "JSD_EL6001_MAX_NUM_DATA_BYTES = %d. ", slave_id, state->num_persistent_bytes_received, num_bytes_received, @@ -534,7 +546,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { // jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; - // read PDOs, updates status_word + // read PDOs, updates statusword jsd_el6001_read_PDO_data(self, slave_id); // check for faults in statuswords @@ -546,7 +558,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { { // Request Beckhoff terminal to initialize jsd_el6001_set_controlword(self, slave_id, jsd_el6001_set_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_INIT_REQUEST)); - jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT, &self->slave_states[slave_id].el6001.sms); + jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT, &state->sms); } break; @@ -556,7 +568,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { { // Clear init request in order to make terminal ready for serial communication jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_INIT_REQUEST)); - jsd_el6001_transition_sms(JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, &self->slave_states[slave_id].el6001.sms); + jsd_el6001_transition_sms(JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, &state->sms); } } break; @@ -580,7 +592,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { // rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; // Write to RxPDO // EC_WRITE_U8( - // self->domain_pd_output + self->offsets_output[id][ECAT_EL6001_DATA_OUT_BYTE_00 + byte_ndx], + // self->domain_pd_output + self->offsets_output[id][JSD_EL6001_DATA_OUT_BYTE_00 + byte_ndx], // state->transmit_bytes[byte_ndx]); } state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; @@ -623,6 +635,25 @@ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, return 0; } +int jsd_el6001_set_baud_rate(jsd_t* self, uint16_t slave_id, jsd_el6001_baud_rate_t baud_rate) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert( + (baud_rate == JSD_EL6001_BAUD_RATE_2400) + || (baud_rate == JSD_EL6001_BAUD_RATE_4800) + || (baud_rate == JSD_EL6001_BAUD_RATE_9600) + || (baud_rate == JSD_EL6001_BAUD_RATE_19200) + || (baud_rate == JSD_EL6001_BAUD_RATE_38400) + || (baud_rate == JSD_EL6001_BAUD_RATE_57600) + || (baud_rate == JSD_EL6001_BAUD_RATE_115200) + || (baud_rate == JSD_EL6001_BAUD_RATE_12000) + || (baud_rate == JSD_EL6001_BAUD_RATE_14400)); + + self->slave_states[slave_id].el6001.baud_rate = baud_rate; + + return 0; +} + /**************************************************** * Private functions ****************************************************/ @@ -637,10 +668,51 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { jsd_slave_config_t* config = &self->slave_configs[slave_id]; jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; - // TODO No PO2SO callback for 4102 devices, so set the success flag now + // TODO No PO2SO callback for 6001 devices, so set the success flag now config->PO2SO_success = true; state->sms = JSD_EL6001_SMS_INITING; // TODO: This used to be done in configure_sdos return true; } + +int jsd_el6001_PO2SO_config(ecx_contextt* ecx_context, uint16_t slave_id) { + assert(ecx_context); + assert(ecx_context->slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + // Since this function prototype is forced by SOEM, we have embedded a + // reference to jsd.slave_configs within th ecx_context and extract it here + jsd_slave_config_t* slave_configs = + (jsd_slave_config_t*)ecx_context->userdata; + + jsd_slave_config_t* config = &slave_configs[slave_id]; + + // Reset to factory default + uint32_t reset_word = JSD_BECKHOFF_RESET_WORD; + if (!jsd_sdo_set_param_blocking(ecx_context, slave_id, JSD_BECKHOFF_RESET_SDO, + JSD_BECKHOFF_RESET_SUBIND, JSD_SDO_DATA_U32, + &reset_word)) { + return 0; + } + + MSG("Configuring slave no: %u, SII inferred name: %s", slave_id, + ecx_context->slavelist[slave_id].name); + MSG("\t Configured name: %s", config->name); + + MSG("\t baud rate: %s", jsd_el6001_baud_rate_strings[config->el6001.baud_rate]); + + uint32_t sdo_channel_index = 0x8000; + + // Set Baud Rate + assert(config->el6001.baud_rate >= JSD_EL6001_BAUD_RATE_2400 && + config->el6001.baud_rate <= JSD_EL6001_BAUD_RATE_14400); + uint8_t baud_rate = config->el6001.baud_rate; + if (!jsd_sdo_set_param_blocking(ecx_context, slave_id, sdo_channel_index, + 0x11, JSD_SDO_DATA_U8, &baud_rate)) { + return 0; + } + + config->PO2SO_success = true; + return 1; +} + diff --git a/src/jsd_el6001.h b/src/jsd_el6001.h index be60c99..567a358 100644 --- a/src/jsd_el6001.h +++ b/src/jsd_el6001.h @@ -16,6 +16,21 @@ extern "C" { */ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id); +/** + * @brief Configuration function called by SOEM upon a PreOp to SafeOp state + * transition that (re)configures EL6001 device settings + * + * @param ecx_context SOEM context pointer + * @param slave_id index of device on EtherCAT bus + * @return 1 on success, 0 on failure + */ +int jsd_el6001_PO2SO_config(ecx_contextt* ecx_context, uint16_t slave_id); + +/** + * @brief Setting Baud Rate on the terminal + */ +int jsd_el6001_set_baud_rate(jsd_t *self, uint16_t slave_id, jsd_el6001_baud_rate_t baud_rate); + /** * @brief Read PDO data with SOEM IOmap * diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index 4d5c18b..e4b0ba4 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -120,6 +120,7 @@ typedef enum * @brief Configuration struct for EL6001 device initialization */ typedef struct { + jsd_el6001_baud_rate_t baud_rate; } jsd_el6001_config_t; /** @@ -127,11 +128,10 @@ typedef struct { * * Note: struct order matters and must be packed. */ -typedef struct __attribute__((__packed__)) { - // jsd_el6001_rxpdo_channel_t channel[JSD_EL6001_NUM_CHANNELS]; - uint16_t controlword; - uint8_t data_out_0; - uint8_t data_out_1; +typedef struct __attribute__((__packed__)) { + uint16_t controlword; //0x3003:0x01: 2byte + uint8_t data_out_0; //0x3003:0x02: 1byte + uint8_t data_out_1; //0x3003:0x03 uint8_t data_out_2; uint8_t data_out_3; uint8_t data_out_4; @@ -151,7 +151,7 @@ typedef struct __attribute__((__packed__)) { uint8_t data_out_18; uint8_t data_out_19; uint8_t data_out_20; - uint8_t data_out_21; + uint8_t data_out_21; //0x3003:0x17 } jsd_el6001_rxpdo_t; /** @@ -160,8 +160,8 @@ typedef struct __attribute__((__packed__)) { * Note: struct order matters and must be packed. */ typedef struct __attribute__((__packed__)) { - uint16_t statusword; //0x6000:01 - 10 - uint8_t data_in_0; + uint16_t statusword; //0x3103:01 + uint8_t data_in_0; //0x3103:02 uint8_t data_in_1; uint8_t data_in_2; uint8_t data_in_3; @@ -182,7 +182,7 @@ typedef struct __attribute__((__packed__)) { uint8_t data_in_18; uint8_t data_in_19; uint8_t data_in_20; - uint8_t data_in_21; + uint8_t data_in_21; //0x3103:17 } jsd_el6001_txpdo_data_t; /** From 786ee0fe183e68a81f59cb2bd2204e750e866b57 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 1 Mar 2023 15:00:33 -0800 Subject: [PATCH 07/37] Added function pointer for sdo configuration --- src/jsd_el6001.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 14a324c..6109090 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -665,13 +665,12 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { assert(self->ecx_context.slavelist[slave_id].eep_man == JSD_BECKHOFF_VENDOR_ID); - jsd_slave_config_t* config = &self->slave_configs[slave_id]; - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + ec_slavet* slaves = self->ecx_context.slavelist; + ec_slavet* slave = &slaves[slave_id]; - // TODO No PO2SO callback for 6001 devices, so set the success flag now - config->PO2SO_success = true; - - state->sms = JSD_EL6001_SMS_INITING; // TODO: This used to be done in configure_sdos + slave->PO2SOconfigx = jsd_el6001_PO2SO_config; + + self->slave_states[slave_id].el6001.sms = JSD_EL6001_SMS_INITING; // TODO: This used to be done in configure_sdos return true; } From 103fa80b15f20b91db8cbeb83d85eff8d3307ca8 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 1 Mar 2023 15:11:28 -0800 Subject: [PATCH 08/37] Added autoincrement func for test --- src/jsd_el6001.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 6109090..8ec5861 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -670,8 +670,18 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { slave->PO2SOconfigx = jsd_el6001_PO2SO_config; + // Initialize main state machine self->slave_states[slave_id].el6001.sms = JSD_EL6001_SMS_INITING; // TODO: This used to be done in configure_sdos + // Initialize transmit state machine + self->slave_states[slave_id].el6001.transmit_state = JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER; + + // Initialize timeout timer + self->slave_states[slave_id].el6001.timer_start_sec = jsd_time_get_mono_time_sec(); + + // Initialize the autoincrement byte to -1 (none, or unknown) + self->slave_states[slave_id].el6001.autoincrement_byte = -1; + return true; } @@ -715,3 +725,12 @@ int jsd_el6001_PO2SO_config(ecx_contextt* ecx_context, uint16_t slave_id) { return 1; } +void jsd_el6001_set_autoincrement_byte(jsd_t* self, uint16_t slave_id, int byte) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(byte >= 0); + assert(byte <= JSD_EL6001_MAX_NUM_DATA_BYTES); + + self->slave_states[slave_id].el6001.autoincrement_byte = byte; +} + From 1c7febdda197fbec0a910775f0c18599e4c8c574 Mon Sep 17 00:00:00 2001 From: David Kim Date: Mon, 6 Mar 2023 12:00:28 -0800 Subject: [PATCH 09/37] Added device test for el6001 --- src/jsd_el6001_pub.h | 1 + test/CMakeLists.txt | 5 ++ test/device/jsd_el6001_test.c | 141 ++++++++++++++++++++++++++++++++++ 3 files changed, 147 insertions(+) create mode 100644 test/device/jsd_el6001_test.c diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 1d05cd9..bdca29a 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -35,6 +35,7 @@ const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_process(jsd_t* self, uint16_t slave_id); +void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); #ifdef __cplusplus diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 248c6fe..f26b4f5 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -107,6 +107,11 @@ if(BUILD_JSD_TESTS) jsd_test_utils.c) target_link_libraries(jsd_el4102_test ${jsd_test_libs}) + add_executable(jsd_el6001_test + device/jsd_el6001_test.c + jsd_test_utils.c) + target_link_libraries(jsd_el6001_test ${jsd_test_libs}) + add_executable(jsd_ild1900_test device/jsd_ild1900_test.c jsd_test_utils.c) diff --git a/test/device/jsd_el6001_test.c b/test/device/jsd_el6001_test.c new file mode 100644 index 0000000..7ceef42 --- /dev/null +++ b/test/device/jsd_el6001_test.c @@ -0,0 +1,141 @@ +#include +#include + +// device includes as necessary by application +#include "jsd/jsd_el6001_pub.h" +#include "jsd/jsd_el6001_types.h" +#include "jsd_test_utils.h" + +extern bool quit; +extern FILE* file; +uint8_t slave_id; + +void telemetry_header() { + if (!file) { + return; + } + fprintf(file, "EL6001_controlword_last, EL6001_controlword, "); + fprintf(file, "EL6001_data_out_0, EL6001_data_out_1, "); + fprintf(file, "EL6001_data_out_2, EL6001_data_out_3, "); + fprintf(file, "EL6001_data_out_4, EL6001_data_out_5, "); + fprintf(file, "EL6001_data_out_6, EL6001_data_out_7, "); + fprintf(file, "EL6001_data_out_8, EL6001_data_out_9, "); + fprintf(file, "EL6001_data_out_10, EL6001_data_out_11, "); + fprintf(file, "EL6001_data_out_12, EL6001_data_out_13, "); + fprintf(file, "EL6001_data_out_14, EL6001_data_out_15, "); + fprintf(file, "EL6001_data_out_16, EL6001_data_out_17, "); + fprintf(file, "EL6001_data_out_18, EL6001_data_out_19, "); + fprintf(file, "EL6001_data_out_20, EL6001_data_out_21, "); + + fprintf(file, "EL6001_statusword_last, EL6001_statusword, "); + fprintf(file, "EL6001_data_in_0, EL6001_data_in_1, "); + fprintf(file, "EL6001_data_in_2, EL6001_data_in_3, "); + fprintf(file, "EL6001_data_in_4, EL6001_data_in_5, "); + fprintf(file, "EL6001_data_in_6, EL6001_data_in_7, "); + fprintf(file, "EL6001_data_in_8, EL6001_data_in_9, "); + fprintf(file, "EL6001_data_in_10, EL6001_data_in_11, "); + fprintf(file, "EL6001_data_in_12, EL6001_data_in_13, "); + fprintf(file, "EL6001_data_in_14, EL6001_data_in_15, "); + fprintf(file, "EL6001_data_in_16, EL6001_data_in_17, "); + fprintf(file, "EL6001_data_in_18, EL6001_data_in_19, "); + fprintf(file, "EL6001_data_in_20, EL6001_data_in_21, "); + + fprintf(file, "\n"); +} + +void telemetry_data(void* self) { + assert(self); + + if (!file) { + return; + } + + single_device_server_t* sds = (single_device_server_t*)self; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + + fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); + fprintf(file, "%u, %u,", state->transmit_bytes[0], state->transmit_bytes[1]); + fprintf(file, "%u, %u,", state->transmit_bytes[2], state->transmit_bytes[3]); + fprintf(file, "%u, %u,", state->transmit_bytes[4], state->transmit_bytes[5]); + fprintf(file, "%u, %u,", state->transmit_bytes[6], state->transmit_bytes[7]); + fprintf(file, "%u, %u,", state->transmit_bytes[8], state->transmit_bytes[9]); + fprintf(file, "%u, %u,", state->transmit_bytes[10], state->transmit_bytes[11]); + fprintf(file, "%u, %u,", state->transmit_bytes[12], state->transmit_bytes[13]); + fprintf(file, "%u, %u,", state->transmit_bytes[14], state->transmit_bytes[15]); + fprintf(file, "%u, %u,", state->transmit_bytes[16], state->transmit_bytes[17]); + fprintf(file, "%u, %u,", state->transmit_bytes[18], state->transmit_bytes[19]); + fprintf(file, "%u, %u,", state->transmit_bytes[20], state->transmit_bytes[21]); + + fprintf(file, "%u, %u,", state->statusword_last, state->statusword); + fprintf(file, "%u, %u,", state->received_bytes[0], state->received_bytes[1]); + fprintf(file, "%u, %u,", state->received_bytes[2], state->received_bytes[3]); + fprintf(file, "%u, %u,", state->received_bytes[4], state->received_bytes[5]); + fprintf(file, "%u, %u,", state->received_bytes[6], state->received_bytes[7]); + fprintf(file, "%u, %u,", state->received_bytes[8], state->received_bytes[9]); + fprintf(file, "%u, %u,", state->received_bytes[10], state->received_bytes[11]); + fprintf(file, "%u, %u,", state->received_bytes[12], state->received_bytes[13]); + fprintf(file, "%u, %u,", state->received_bytes[14], state->received_bytes[15]); + fprintf(file, "%u, %u,", state->received_bytes[16], state->received_bytes[17]); + fprintf(file, "%u, %u,", state->received_bytes[18], state->received_bytes[19]); + fprintf(file, "%u, %u,", state->received_bytes[20], state->received_bytes[21]); + + fprintf(file, "\n"); + fflush(file); +} + +void print_info(void* self) { + assert(self); + + single_device_server_t* sds = (single_device_server_t*)self; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + MSG("Controlword_user: %u ", state->controlword_user); +} + +void extract_data(void* self) { + single_device_server_t* sds = (single_device_server_t*)self; + jsd_el6001_read_PDO_data(sds->jsd, slave_id); +} + +void command(void* self) { (void)self; }; + + +int main(int argc, char* argv[]) { + if (argc != 4) { + ERROR("Expecting exactly 3 arguments"); + MSG("Usage: jsd_el6001_test "); + MSG("Example: $ jsd_el6001_test eth0 2 1000"); + return 0; + } + + char* ifname = strdup(argv[1]); + slave_id = atoi(argv[2]); + uint32_t loop_freq_hz = atoi(argv[3]); + + MSG("Configuring device %s, using slave %d", ifname, slave_id); + MSG("Using frequency of %i hz", loop_freq_hz); + + single_device_server_t sds; + + sds_set_telemetry_header_callback(&sds, telemetry_header); + sds_set_telemetry_data_callback(&sds, telemetry_data); + sds_set_print_info_callback(&sds, print_info); + sds_set_extract_data_callback(&sds, extract_data); + sds_set_command_callback(&sds, command); + + sds_setup(&sds, loop_freq_hz); + + // set device configuration here + jsd_slave_config_t my_config = {0}; + + my_config.el6001.baud_rate = JSD_EL6001_BAUD_RATE_115200; + + snprintf(my_config.name, JSD_NAME_LEN, "my_el6001_device"); + my_config.configuration_active = true; + my_config.product_code = JSD_EL6001_PRODUCT_CODE; + + jsd_set_slave_config(sds.jsd, slave_id, my_config); + + sds_run(&sds, ifname, "/tmp/jsd_el6001.csv"); + + return 0; +} From 3e5bab891ebf6e24c3cc6a1f71699525ee87e7f3 Mon Sep 17 00:00:00 2001 From: David Kim Date: Mon, 6 Mar 2023 15:39:25 -0800 Subject: [PATCH 10/37] Added communication test --- src/jsd_el6001.c | 15 +++ src/jsd_el6001_pub.h | 3 + test/CMakeLists.txt | 5 + test/device/jsd_el6001_comm_test.c | 170 +++++++++++++++++++++++++++++ 4 files changed, 193 insertions(+) create mode 100644 test/device/jsd_el6001_comm_test.c diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 8ec5861..45b76f8 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -654,6 +654,21 @@ int jsd_el6001_set_baud_rate(jsd_t* self, uint16_t slave_id, jsd_el6001_baud_rat return 0; } +int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + // Set number of output bytes by setting bits 8-15 of the control word to that number + // Write the control word so the terminal know number of bytes to send + jsd_el6001_set_controlword(self, slave_id, + self->slave_states[slave_id].el6001.controlword_user | (num_bytes_to_transmit << JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0)); + + // Set bool to advance transmit state machine + self->slave_states[slave_id].el6001.user_requests_to_transmit_data = true; + + return 0; +} + /**************************************************** * Private functions ****************************************************/ diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index bdca29a..3006ed6 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -37,6 +37,9 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id); void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); +int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); + +int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); #ifdef __cplusplus } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index f26b4f5..69a57be 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -112,6 +112,11 @@ if(BUILD_JSD_TESTS) jsd_test_utils.c) target_link_libraries(jsd_el6001_test ${jsd_test_libs}) + add_executable(jsd_el6001_comm_test + device/jsd_el6001_comm_test.c + jsd_test_utils.c) + target_link_libraries(jsd_el6001_comm_test ${jsd_test_libs}) + add_executable(jsd_ild1900_test device/jsd_ild1900_test.c jsd_test_utils.c) diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c new file mode 100644 index 0000000..9cac109 --- /dev/null +++ b/test/device/jsd_el6001_comm_test.c @@ -0,0 +1,170 @@ +#include +#include + +// device includes as necessary by application +#include "jsd/jsd_el6001_pub.h" +#include "jsd/jsd_el6001_types.h" +#include "jsd_test_utils.h" + +#define HEX_FORMAT "0x%02X" +#define LOOP_FREQUENCY_HZ (500) // Rate to update ethercat devices +#define USER_LOOP_FREQUENCY_HZ (1) // Rate to send and receive user commands in test +#define NSEC_PER_SEC (1000000000L) +#define LOOP_PERIOD_NS (NSEC_PER_SEC / LOOP_FREQUENCY_HZ) // ns +#define USER_LOOP_RATE_SEC (1.0 / USER_LOOP_FREQUENCY_HZ) // sec +#define PRINT_RATE_HZ (1) // Hz +#define NUM_RESOLVERS (1) +#define MAX_NUM_RESOLVERS (6) +#define ID 0 +#define OP_CODE_SEND_DATA (1) +#define NUM_BYTES_BEFORE_RESOLVERS (2) +#define NUM_BYTES_PER_RESOLVER (3) +#define NUM_RESOLVER_BYTES (NUM_BYTES_PER_RESOLVER * MAX_NUM_RESOLVERS) +#define TOTAL_NUM_BYTES (NUM_BYTES_BEFORE_RESOLVERS + NUM_RESOLVER_BYTES + 1/*checksum*/) + +extern bool quit; +extern FILE* file; +uint8_t slave_id; + +void telemetry_header() { + if (!file) { + return; + } + fprintf(file, "EL6001_controlword_last, EL6001_controlword, "); + fprintf(file, "EL6001_data_out_0, EL6001_data_out_1, "); + fprintf(file, "EL6001_data_out_2, EL6001_data_out_3, "); + fprintf(file, "EL6001_data_out_4, EL6001_data_out_5, "); + fprintf(file, "EL6001_data_out_6, EL6001_data_out_7, "); + fprintf(file, "EL6001_data_out_8, EL6001_data_out_9, "); + fprintf(file, "EL6001_data_out_10, EL6001_data_out_11, "); + fprintf(file, "EL6001_data_out_12, EL6001_data_out_13, "); + fprintf(file, "EL6001_data_out_14, EL6001_data_out_15, "); + fprintf(file, "EL6001_data_out_16, EL6001_data_out_17, "); + fprintf(file, "EL6001_data_out_18, EL6001_data_out_19, "); + fprintf(file, "EL6001_data_out_20, EL6001_data_out_21, "); + + fprintf(file, "EL6001_statusword_last, EL6001_statusword, "); + fprintf(file, "EL6001_data_in_0, EL6001_data_in_1, "); + fprintf(file, "EL6001_data_in_2, EL6001_data_in_3, "); + fprintf(file, "EL6001_data_in_4, EL6001_data_in_5, "); + fprintf(file, "EL6001_data_in_6, EL6001_data_in_7, "); + fprintf(file, "EL6001_data_in_8, EL6001_data_in_9, "); + fprintf(file, "EL6001_data_in_10, EL6001_data_in_11, "); + fprintf(file, "EL6001_data_in_12, EL6001_data_in_13, "); + fprintf(file, "EL6001_data_in_14, EL6001_data_in_15, "); + fprintf(file, "EL6001_data_in_16, EL6001_data_in_17, "); + fprintf(file, "EL6001_data_in_18, EL6001_data_in_19, "); + fprintf(file, "EL6001_data_in_20, EL6001_data_in_21, "); + + fprintf(file, "\n"); +} + +void telemetry_data(void* self) { + assert(self); + + if (!file) { + return; + } + + single_device_server_t* sds = (single_device_server_t*)self; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + + fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); + fprintf(file, "%u, %u,", state->transmit_bytes[0], state->transmit_bytes[1]); + fprintf(file, "%u, %u,", state->transmit_bytes[2], state->transmit_bytes[3]); + fprintf(file, "%u, %u,", state->transmit_bytes[4], state->transmit_bytes[5]); + fprintf(file, "%u, %u,", state->transmit_bytes[6], state->transmit_bytes[7]); + fprintf(file, "%u, %u,", state->transmit_bytes[8], state->transmit_bytes[9]); + fprintf(file, "%u, %u,", state->transmit_bytes[10], state->transmit_bytes[11]); + fprintf(file, "%u, %u,", state->transmit_bytes[12], state->transmit_bytes[13]); + fprintf(file, "%u, %u,", state->transmit_bytes[14], state->transmit_bytes[15]); + fprintf(file, "%u, %u,", state->transmit_bytes[16], state->transmit_bytes[17]); + fprintf(file, "%u, %u,", state->transmit_bytes[18], state->transmit_bytes[19]); + fprintf(file, "%u, %u,", state->transmit_bytes[20], state->transmit_bytes[21]); + + fprintf(file, "%u, %u,", state->statusword_last, state->statusword); + fprintf(file, "%u, %u,", state->received_bytes[0], state->received_bytes[1]); + fprintf(file, "%u, %u,", state->received_bytes[2], state->received_bytes[3]); + fprintf(file, "%u, %u,", state->received_bytes[4], state->received_bytes[5]); + fprintf(file, "%u, %u,", state->received_bytes[6], state->received_bytes[7]); + fprintf(file, "%u, %u,", state->received_bytes[8], state->received_bytes[9]); + fprintf(file, "%u, %u,", state->received_bytes[10], state->received_bytes[11]); + fprintf(file, "%u, %u,", state->received_bytes[12], state->received_bytes[13]); + fprintf(file, "%u, %u,", state->received_bytes[14], state->received_bytes[15]); + fprintf(file, "%u, %u,", state->received_bytes[16], state->received_bytes[17]); + fprintf(file, "%u, %u,", state->received_bytes[18], state->received_bytes[19]); + fprintf(file, "%u, %u,", state->received_bytes[20], state->received_bytes[21]); + + fprintf(file, "\n"); + fflush(file); +} + +void print_info(void* self) { + assert(self); + + single_device_server_t* sds = (single_device_server_t*)self; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + MSG("Controlword_user: %u ", state->controlword_user); +} + +void extract_data(void* self) { + single_device_server_t* sds = (single_device_server_t*)self; + jsd_el6001_read_PDO_data(sds->jsd, slave_id); +} + +void command(void* self) { (void)self; }; + + +int main(int argc, char* argv[]) { + if (argc != 4) { + ERROR("Expecting exactly 3 arguments"); + MSG("Usage: jsd_el6001_test "); + MSG("Example: $ jsd_el6001_test eth0 2 1000"); + return 0; + } + + char* ifname = strdup(argv[1]); + slave_id = atoi(argv[2]); + uint32_t loop_freq_hz = atoi(argv[3]); + + MSG("Configuring device %s, using slave %d", ifname, slave_id); + MSG("Using frequency of %i hz", loop_freq_hz); + + single_device_server_t sds; + + sds_set_telemetry_header_callback(&sds, telemetry_header); + sds_set_telemetry_data_callback(&sds, telemetry_data); + sds_set_print_info_callback(&sds, print_info); + sds_set_extract_data_callback(&sds, extract_data); + sds_set_command_callback(&sds, command); + + sds_setup(&sds, loop_freq_hz); + + // set device configuration here + jsd_slave_config_t my_config = {0}; + + my_config.el6001.baud_rate = JSD_EL6001_BAUD_RATE_115200; + + snprintf(my_config.name, JSD_NAME_LEN, "my_el6001_device"); + my_config.configuration_active = true; + my_config.product_code = JSD_EL6001_PRODUCT_CODE; + + jsd_set_slave_config(sds.jsd, slave_id, my_config); + + int8_t counter = 0; + + // initiate first transmit and for next time all data is received to prevent idle loop + // transmit data does not get deleted automatically + MSG("Transmitting opcode %d and counter %d", OP_CODE_SEND_DATA, counter); + jsd_el6001_set_transmit_data_8bits(sds.jsd, ID, 0/*byte_number*/, OP_CODE_SEND_DATA/*value*/); + jsd_el6001_set_transmit_data_8bits(sds.jsd, ID, 1/*byte_number*/, ++counter/*value*/); + jsd_el6001_request_transmit_data(sds.jsd, ID, 2/*num_bytes*/); + // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); + // ecat_el6001_set_persistent_transmit_data(ecat->el6001, ID, 2/*num_bytes*/, true); + // ecat_el6001_set_timeout_sec(ecat->el6001, ID, 1.0, true); + // ecat_el6001_set_autoincrement_byte(ecat->el6001, ID, 1); + + // sds_run(&sds, ifname, "/tmp/jsd_el6001.csv"); + + return 0; +} From 1b5b2942faf9e45da83527a02a4b84011eb89c65 Mon Sep 17 00:00:00 2001 From: David Kim Date: Tue, 7 Mar 2023 09:25:22 -0800 Subject: [PATCH 11/37] Added pub func for set persistent transmit data --- src/jsd_el6001_pub.h | 2 ++ test/device/jsd_el6001_comm_test.c | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 3006ed6..630c848 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -41,6 +41,8 @@ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); +int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit, bool state); + #ifdef __cplusplus } #endif diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index 9cac109..11007ae 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -159,6 +159,8 @@ int main(int argc, char* argv[]) { jsd_el6001_set_transmit_data_8bits(sds.jsd, ID, 0/*byte_number*/, OP_CODE_SEND_DATA/*value*/); jsd_el6001_set_transmit_data_8bits(sds.jsd, ID, 1/*byte_number*/, ++counter/*value*/); jsd_el6001_request_transmit_data(sds.jsd, ID, 2/*num_bytes*/); + + jsd_el6001_process(sds.jsd, slave_id); // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); // ecat_el6001_set_persistent_transmit_data(ecat->el6001, ID, 2/*num_bytes*/, true); // ecat_el6001_set_timeout_sec(ecat->el6001, ID, 1.0, true); From 4a1d8814da4b4753e61f1457fc0ce87ac80e7c66 Mon Sep 17 00:00:00 2001 From: casah-testbeds Date: Tue, 7 Mar 2023 10:20:03 -0800 Subject: [PATCH 12/37] Running test on playground --- src/jsd.c | 4 +++ src/jsd_el6001.c | 4 +-- src/jsd_el6001_types.h | 2 +- test/device/jsd_el6001_comm_test.c | 19 +++++++++-- test/device/jsd_el6001_test.c | 51 +++++++++++++++--------------- 5 files changed, 49 insertions(+), 31 deletions(-) diff --git a/src/jsd.c b/src/jsd.c index a74647a..3d9114e 100644 --- a/src/jsd.c +++ b/src/jsd.c @@ -482,6 +482,10 @@ bool jsd_init_single_device(jsd_t* self, uint16_t slave_id) { return jsd_el4102_init(self, slave_id); break; } + case JSD_EL6001_PRODUCT_CODE: { + return jsd_el6001_init(self, slave_id); + break; + } case JSD_ILD1900_PRODUCT_CODE: { return jsd_ild1900_init(self, slave_id); break; diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 45b76f8..76527f6 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -54,7 +54,7 @@ static void jsd_el6001_set_controlword(jsd_t* self, uint16_t slave_id, uint16_t assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_print_controlword("Setting control word of: ", control_word, slave_id); + jsd_el6001_print_controlword("Setting controlword of: ", control_word, slave_id); self->slave_states[slave_id].el6001.controlword_user = control_word; } @@ -624,7 +624,7 @@ bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t sla return self->slave_states[slave_id].el6001.received_all_persistent_bytes; } -int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value) { +int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); assert(byte < JSD_EL6001_DATA_OUT_BYTE_21); diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index e4b0ba4..e4f28ba 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -7,7 +7,7 @@ extern "C" { #include "jsd/jsd_common_device_types.h" -#define JSD_EL6001_PRODUCT_CODE (uint32_t)0x17853052 // TODO: 17713052 in old ecat driver +#define JSD_EL6001_PRODUCT_CODE (uint32_t)0x17713052 #define JSD_EL6001_NUM_CHANNELS 1 diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index 11007ae..bf816b6 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -105,6 +105,7 @@ void print_info(void* self) { single_device_server_t* sds = (single_device_server_t*)self; const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); MSG("Controlword_user: %u ", state->controlword_user); + MSG("Statusword: %u ", state->statusword); } void extract_data(void* self) { @@ -151,16 +152,28 @@ int main(int argc, char* argv[]) { jsd_set_slave_config(sds.jsd, slave_id, my_config); + if (!jsd_init(sds.jsd, ifname, 1)) { + ERROR("Could not init jsd"); + return 0; + } + + jsd_read(sds.jsd, EC_TIMEOUTRET); + int8_t counter = 0; // initiate first transmit and for next time all data is received to prevent idle loop // transmit data does not get deleted automatically MSG("Transmitting opcode %d and counter %d", OP_CODE_SEND_DATA, counter); - jsd_el6001_set_transmit_data_8bits(sds.jsd, ID, 0/*byte_number*/, OP_CODE_SEND_DATA/*value*/); - jsd_el6001_set_transmit_data_8bits(sds.jsd, ID, 1/*byte_number*/, ++counter/*value*/); - jsd_el6001_request_transmit_data(sds.jsd, ID, 2/*num_bytes*/); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 0/*byte_number*/, OP_CODE_SEND_DATA/*value*/); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 1/*byte_number*/, ++counter/*value*/); + jsd_el6001_request_transmit_data(sds.jsd, slave_id, 2/*num_bytes*/); jsd_el6001_process(sds.jsd, slave_id); + + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); + MSG("Controlword_user: %u ", state->controlword_user); + MSG("Statusword: %u ", state->statusword); + // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); // ecat_el6001_set_persistent_transmit_data(ecat->el6001, ID, 2/*num_bytes*/, true); // ecat_el6001_set_timeout_sec(ecat->el6001, ID, 1.0, true); diff --git a/test/device/jsd_el6001_test.c b/test/device/jsd_el6001_test.c index 7ceef42..7aede79 100644 --- a/test/device/jsd_el6001_test.c +++ b/test/device/jsd_el6001_test.c @@ -53,31 +53,31 @@ void telemetry_data(void* self) { single_device_server_t* sds = (single_device_server_t*)self; const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); - fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); - fprintf(file, "%u, %u,", state->transmit_bytes[0], state->transmit_bytes[1]); - fprintf(file, "%u, %u,", state->transmit_bytes[2], state->transmit_bytes[3]); - fprintf(file, "%u, %u,", state->transmit_bytes[4], state->transmit_bytes[5]); - fprintf(file, "%u, %u,", state->transmit_bytes[6], state->transmit_bytes[7]); - fprintf(file, "%u, %u,", state->transmit_bytes[8], state->transmit_bytes[9]); - fprintf(file, "%u, %u,", state->transmit_bytes[10], state->transmit_bytes[11]); - fprintf(file, "%u, %u,", state->transmit_bytes[12], state->transmit_bytes[13]); - fprintf(file, "%u, %u,", state->transmit_bytes[14], state->transmit_bytes[15]); - fprintf(file, "%u, %u,", state->transmit_bytes[16], state->transmit_bytes[17]); - fprintf(file, "%u, %u,", state->transmit_bytes[18], state->transmit_bytes[19]); - fprintf(file, "%u, %u,", state->transmit_bytes[20], state->transmit_bytes[21]); - - fprintf(file, "%u, %u,", state->statusword_last, state->statusword); - fprintf(file, "%u, %u,", state->received_bytes[0], state->received_bytes[1]); - fprintf(file, "%u, %u,", state->received_bytes[2], state->received_bytes[3]); - fprintf(file, "%u, %u,", state->received_bytes[4], state->received_bytes[5]); - fprintf(file, "%u, %u,", state->received_bytes[6], state->received_bytes[7]); - fprintf(file, "%u, %u,", state->received_bytes[8], state->received_bytes[9]); - fprintf(file, "%u, %u,", state->received_bytes[10], state->received_bytes[11]); - fprintf(file, "%u, %u,", state->received_bytes[12], state->received_bytes[13]); - fprintf(file, "%u, %u,", state->received_bytes[14], state->received_bytes[15]); - fprintf(file, "%u, %u,", state->received_bytes[16], state->received_bytes[17]); - fprintf(file, "%u, %u,", state->received_bytes[18], state->received_bytes[19]); - fprintf(file, "%u, %u,", state->received_bytes[20], state->received_bytes[21]); + fprintf(file, "%u, %u, ", state->controlword_user_last, state->controlword_user); + fprintf(file, "%u, %u, ", state->transmit_bytes[0], state->transmit_bytes[1]); + fprintf(file, "%u, %u, ", state->transmit_bytes[2], state->transmit_bytes[3]); + fprintf(file, "%u, %u, ", state->transmit_bytes[4], state->transmit_bytes[5]); + fprintf(file, "%u, %u, ", state->transmit_bytes[6], state->transmit_bytes[7]); + fprintf(file, "%u, %u, ", state->transmit_bytes[8], state->transmit_bytes[9]); + fprintf(file, "%u, %u, ", state->transmit_bytes[10], state->transmit_bytes[11]); + fprintf(file, "%u, %u, ", state->transmit_bytes[12], state->transmit_bytes[13]); + fprintf(file, "%u, %u, ", state->transmit_bytes[14], state->transmit_bytes[15]); + fprintf(file, "%u, %u, ", state->transmit_bytes[16], state->transmit_bytes[17]); + fprintf(file, "%u, %u, ", state->transmit_bytes[18], state->transmit_bytes[19]); + fprintf(file, "%u, %u, ", state->transmit_bytes[20], state->transmit_bytes[21]); + + fprintf(file, "%u, %u, ", state->statusword_last, state->statusword); + fprintf(file, "%u, %u, ", state->received_bytes[0], state->received_bytes[1]); + fprintf(file, "%u, %u, ", state->received_bytes[2], state->received_bytes[3]); + fprintf(file, "%u, %u, ", state->received_bytes[4], state->received_bytes[5]); + fprintf(file, "%u, %u, ", state->received_bytes[6], state->received_bytes[7]); + fprintf(file, "%u, %u, ", state->received_bytes[8], state->received_bytes[9]); + fprintf(file, "%u, %u, ", state->received_bytes[10], state->received_bytes[11]); + fprintf(file, "%u, %u, ", state->received_bytes[12], state->received_bytes[13]); + fprintf(file, "%u, %u, ", state->received_bytes[14], state->received_bytes[15]); + fprintf(file, "%u, %u, ", state->received_bytes[16], state->received_bytes[17]); + fprintf(file, "%u, %u, ", state->received_bytes[18], state->received_bytes[19]); + fprintf(file, "%u, %u, ", state->received_bytes[20], state->received_bytes[21]); fprintf(file, "\n"); fflush(file); @@ -89,6 +89,7 @@ void print_info(void* self) { single_device_server_t* sds = (single_device_server_t*)self; const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); MSG("Controlword_user: %u ", state->controlword_user); + MSG("Statusword: %u ", state->statusword); } void extract_data(void* self) { From cf17352f0009e468ce44dbc66e7aa39d81772da0 Mon Sep 17 00:00:00 2001 From: casah-testbeds Date: Tue, 7 Mar 2023 12:48:01 -0800 Subject: [PATCH 13/37] Refined communication test --- src/jsd_el6001.c | 4 +++- test/device/jsd_el6001_comm_test.c | 18 ++++++++++++++---- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 76527f6..4c891c6 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -369,6 +369,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: if (state->user_requests_to_transmit_data) { + MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); @@ -416,9 +417,10 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { else if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_TRANSMIT_ACCEPTED)) { // Beckhoff terminal transmitted data. - MSG_DEBUG("Transmit accepted"); + MSG_DEBUG("Transmit accepted, data has been transmitted"); // Go back to waiting for another transmit request + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); // Start timeout timer diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index bf816b6..33419e2 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -160,6 +160,8 @@ int main(int argc, char* argv[]) { jsd_read(sds.jsd, EC_TIMEOUTRET); int8_t counter = 0; + bool quit = false; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); // initiate first transmit and for next time all data is received to prevent idle loop // transmit data does not get deleted automatically @@ -168,11 +170,19 @@ int main(int argc, char* argv[]) { jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 1/*byte_number*/, ++counter/*value*/); jsd_el6001_request_transmit_data(sds.jsd, slave_id, 2/*num_bytes*/); - jsd_el6001_process(sds.jsd, slave_id); + while(!quit){ + jsd_read(sds.jsd, EC_TIMEOUTRET); + + jsd_el6001_process(sds.jsd, slave_id); - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); - MSG("Controlword_user: %u ", state->controlword_user); - MSG("Statusword: %u ", state->statusword); + jsd_write(sds.jsd); + + MSG("Controlword_user: %u ", state->controlword_user); + MSG("Statusword: %u ", state->statusword); + + sleep(1); + //jsd_timer_process(sds.jsd_timer); + } // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); // ecat_el6001_set_persistent_transmit_data(ecat->el6001, ID, 2/*num_bytes*/, true); From 3ca4b115375355a31ce171d5896dbd82a3a9ee80 Mon Sep 17 00:00:00 2001 From: David Kim Date: Tue, 7 Mar 2023 13:00:19 -0800 Subject: [PATCH 14/37] using jsd timer --- src/jsd_el6001.c | 4 +--- test/device/jsd_el6001_comm_test.c | 7 +++---- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 4c891c6..f3231ba 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -429,9 +429,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { //Increment the successful transmit counter if (state->autoincrement_byte >= 0) { - jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); - // write into RxPDO - jsd_el6001_write_PDO_data(self, slave_id); + jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); } } } diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index 33419e2..e839525 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -175,13 +175,12 @@ int main(int argc, char* argv[]) { jsd_el6001_process(sds.jsd, slave_id); - jsd_write(sds.jsd); - MSG("Controlword_user: %u ", state->controlword_user); MSG("Statusword: %u ", state->statusword); - sleep(1); - //jsd_timer_process(sds.jsd_timer); + jsd_write(sds.jsd); + + jsd_timer_process(sds.jsd_timer); } // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); From 30a6b9701392f12c13e34e7f5dcab8270064e999 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 8 Mar 2023 14:31:53 -0800 Subject: [PATCH 15/37] Code cleaning --- src/jsd_el6001.c | 30 ++++++++++++------------------ src/jsd_el6001.h | 12 ------------ src/jsd_el6001_pub.h | 8 +++++++- test/device/jsd_el6001_comm_test.c | 2 +- test/device/jsd_el6001_test.c | 2 +- 5 files changed, 21 insertions(+), 33 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index f3231ba..a62ea19 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -185,6 +185,14 @@ static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { return checksum; } +// data control +static bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + return self->slave_states[slave_id].el6001.received_all_persistent_bytes; +} + //---------------------------------------------------------------------------// // RECEIVE @@ -455,22 +463,15 @@ const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id) { return &self->slave_states[slave_id].el6001; } -void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id) { +void jsd_el6001_read(jsd_t* self, uint16_t slave_id) { assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == - JSD_EL6001_PRODUCT_CODE); - + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; jsd_el6001_txpdo_data_t* txpdo = (jsd_el6001_txpdo_data_t*)self->ecx_context.slavelist[slave_id].inputs; - // jsd_el3602_rxpdo_t* rxpdo = - // (jsd_el3602_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; - - // state->control_word_terminal_last = state->control_word_terminal; - // state->control_word = rxpdo->control_word; - state->statusword_last = state->statusword; state->statusword = txpdo->statusword; @@ -547,7 +548,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { // jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; // read PDOs, updates statusword - jsd_el6001_read_PDO_data(self, slave_id); + jsd_el6001_read(self, slave_id); // check for faults in statuswords jsd_el6001_check_for_faults(self, slave_id); @@ -617,13 +618,6 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { } -bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { - assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - - return self->slave_states[slave_id].el6001.received_all_persistent_bytes; -} - int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); diff --git a/src/jsd_el6001.h b/src/jsd_el6001.h index 567a358..4073872 100644 --- a/src/jsd_el6001.h +++ b/src/jsd_el6001.h @@ -31,20 +31,8 @@ int jsd_el6001_PO2SO_config(ecx_contextt* ecx_context, uint16_t slave_id); */ int jsd_el6001_set_baud_rate(jsd_t *self, uint16_t slave_id, jsd_el6001_baud_rate_t baud_rate); -/** - * @brief Read PDO data with SOEM IOmap - * - * @param self pointer JSD context - * @param slave_id index of device on EtherCAT bus - */ -void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); - void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id); -bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id); - -int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); - #ifdef __cplusplus } #endif diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 630c848..fac05cc 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -35,7 +35,13 @@ const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_process(jsd_t* self, uint16_t slave_id); -void jsd_el6001_read_PDO_data(jsd_t* self, uint16_t slave_id); +/** + * @brief Get PDO data and update state data + * + * @param self pointer JSD context + * @param slave_id index of device on EtherCAT bus + */ +void jsd_el6001_read(jsd_t* self, uint16_t slave_id); int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index e839525..b22cbf5 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -110,7 +110,7 @@ void print_info(void* self) { void extract_data(void* self) { single_device_server_t* sds = (single_device_server_t*)self; - jsd_el6001_read_PDO_data(sds->jsd, slave_id); + jsd_el6001_read(sds->jsd, slave_id); } void command(void* self) { (void)self; }; diff --git a/test/device/jsd_el6001_test.c b/test/device/jsd_el6001_test.c index 7aede79..0633c34 100644 --- a/test/device/jsd_el6001_test.c +++ b/test/device/jsd_el6001_test.c @@ -94,7 +94,7 @@ void print_info(void* self) { void extract_data(void* self) { single_device_server_t* sds = (single_device_server_t*)self; - jsd_el6001_read_PDO_data(sds->jsd, slave_id); + jsd_el6001_read(sds->jsd, slave_id); } void command(void* self) { (void)self; }; From 01f8f21256480272dd21e9f2d2a78a4c987d2a2a Mon Sep 17 00:00:00 2001 From: casah-testbeds Date: Tue, 21 Mar 2023 15:02:22 -0700 Subject: [PATCH 16/37] fixed pushing to rxpdo while transmitting --- src/jsd_el6001.c | 1 + test/device/jsd_el6001_comm_test.c | 12 +++++++----- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index a62ea19..3c7bb86 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -595,6 +595,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { // EC_WRITE_U8( // self->domain_pd_output + self->offsets_output[id][JSD_EL6001_DATA_OUT_BYTE_00 + byte_ndx], // state->transmit_bytes[byte_ndx]); + jsd_el6001_write_PDO_data(self, slave_id); } state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; } diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index b22cbf5..555b7bf 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -159,16 +159,17 @@ int main(int argc, char* argv[]) { jsd_read(sds.jsd, EC_TIMEOUTRET); - int8_t counter = 0; - bool quit = false; + int8_t counter = 2; + // bool quit = false; const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); // initiate first transmit and for next time all data is received to prevent idle loop // transmit data does not get deleted automatically MSG("Transmitting opcode %d and counter %d", OP_CODE_SEND_DATA, counter); - jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 0/*byte_number*/, OP_CODE_SEND_DATA/*value*/); - jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 1/*byte_number*/, ++counter/*value*/); - jsd_el6001_request_transmit_data(sds.jsd, slave_id, 2/*num_bytes*/); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 0/*byte_number*/, 1); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 1/*byte_number*/, 0); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 2/*byte_number*/, 2); + jsd_el6001_request_transmit_data(sds.jsd, slave_id, 3/*num_bytes*/); while(!quit){ jsd_read(sds.jsd, EC_TIMEOUTRET); @@ -180,6 +181,7 @@ int main(int argc, char* argv[]) { jsd_write(sds.jsd); + // sleep(1.0); jsd_timer_process(sds.jsd_timer); } From ce7f261ca7e01c6bd4d9b3004e3f4881891dd45a Mon Sep 17 00:00:00 2001 From: casah-testbeds Date: Tue, 21 Mar 2023 16:27:02 -0700 Subject: [PATCH 17/37] Rearranging writing register command --- src/jsd_el6001.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 3c7bb86..bf97133 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -380,7 +380,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - + jsd_el6001_write_PDO_data(self, slave_id); // populate RxPDO to be exchanged in next process loop jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); state->timer_start_sec = jsd_time_get_mono_time_sec(); @@ -595,13 +595,13 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { // EC_WRITE_U8( // self->domain_pd_output + self->offsets_output[id][JSD_EL6001_DATA_OUT_BYTE_00 + byte_ndx], // state->transmit_bytes[byte_ndx]); - jsd_el6001_write_PDO_data(self, slave_id); } state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; } // transmit user serial data jsd_el6001_transmit_data(self, slave_id); + // jsd_el6001_write_PDO_data(self, slave_id); } break; From 03cdbcfe1c12684cb0b177cba8bece0470f49b7d Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 22 Mar 2023 14:22:13 -0700 Subject: [PATCH 18/37] Fixing state machine pipeline --- src/jsd_el6001.c | 50 ++++++++++++++---------------- test/device/jsd_el6001_comm_test.c | 9 ++++-- 2 files changed, 30 insertions(+), 29 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index bf97133..68d504f 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -379,8 +379,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { { MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_write_PDO_data(self, slave_id); // populate RxPDO to be exchanged in next process loop + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); state->timer_start_sec = jsd_time_get_mono_time_sec(); @@ -416,19 +415,22 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: { + // Clear out transmit request + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { - ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); + ERROR("EL6001 id %d: Transmit request timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); + // jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } else if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_TRANSMIT_ACCEPTED)) { // Beckhoff terminal transmitted data. - MSG_DEBUG("Transmit accepted, data has been transmitted"); + MSG_DEBUG("Transmit request accepted, data has been transmitted"); // Go back to waiting for another transmit request - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + // jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); // Start timeout timer @@ -544,11 +546,6 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { JSD_EL6001_PRODUCT_CODE); jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; - - // jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; - - // read PDOs, updates statusword - jsd_el6001_read(self, slave_id); // check for faults in statuswords jsd_el6001_check_for_faults(self, slave_id); @@ -584,24 +581,23 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { return; } - // If any of the bytes to transmit have changed, write them to the bus - size_t byte_ndx; - for (byte_ndx = 0; byte_ndx < JSD_EL6001_NUM_DATA_BYTES; byte_ndx++) - { - if (state->transmit_bytes[byte_ndx] != state->transmit_bytes_prev[byte_ndx]) - { - // rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; - // Write to RxPDO - // EC_WRITE_U8( - // self->domain_pd_output + self->offsets_output[id][JSD_EL6001_DATA_OUT_BYTE_00 + byte_ndx], - // state->transmit_bytes[byte_ndx]); - } - state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; - } + // // If any of the bytes to transmit have changed, write them to the bus + // size_t byte_ndx; + // for (byte_ndx = 0; byte_ndx < JSD_EL6001_NUM_DATA_BYTES; byte_ndx++) + // { + // if (state->transmit_bytes[byte_ndx] != state->transmit_bytes_prev[byte_ndx]) + // { + // // rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; + // // Write to RxPDO + // // EC_WRITE_U8( + // // self->domain_pd_output + self->offsets_output[id][JSD_EL6001_DATA_OUT_BYTE_00 + byte_ndx], + // // state->transmit_bytes[byte_ndx]); + // } + // state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; + // } // transmit user serial data - jsd_el6001_transmit_data(self, slave_id); - // jsd_el6001_write_PDO_data(self, slave_id); + jsd_el6001_transmit_data(self, slave_id); } break; @@ -617,6 +613,8 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { state->controlword_user_last = state->controlword_user; } + // Write slave state into RxPDO + jsd_el6001_write_PDO_data(self, slave_id); } int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value) { diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index 555b7bf..fcb0985 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -172,13 +172,16 @@ int main(int argc, char* argv[]) { jsd_el6001_request_transmit_data(sds.jsd, slave_id, 3/*num_bytes*/); while(!quit){ - jsd_read(sds.jsd, EC_TIMEOUTRET); - - jsd_el6001_process(sds.jsd, slave_id); + jsd_read(sds.jsd, EC_TIMEOUTRET); + + // read PDOs, updates statusword + jsd_el6001_read(sds.jsd, slave_id); MSG("Controlword_user: %u ", state->controlword_user); MSG("Statusword: %u ", state->statusword); + jsd_el6001_process(sds.jsd, slave_id); + jsd_write(sds.jsd); // sleep(1.0); From 016a0677ce479471f12c01bce8b612327154cb48 Mon Sep 17 00:00:00 2001 From: casah-testbeds Date: Thu, 23 Mar 2023 11:47:07 -0700 Subject: [PATCH 19/37] Fixed transmit state machine by clearing data length correctly --- src/jsd_el6001.c | 106 ++++++++++++++++++++++++++--------------------- 1 file changed, 59 insertions(+), 47 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 68d504f..028e63a 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -85,19 +85,19 @@ static uint16_t jsd_el6001_toggle_controlword_bit(const jsd_t* self, uint16_t sl return self->slave_states[slave_id].el6001.controlword_user ^ (1 << bit); } -static void jsd_el6001_write_controlword(jsd_t* self, uint16_t slave_id) { - assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); +// static void jsd_el6001_write_controlword(jsd_t* self, uint16_t slave_id) { +// assert(self); +// assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; - jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; +// jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; +// jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; - jsd_el6001_print_controlword("Writing controlword to EtherCAT register of: ", state->controlword_user, slave_id); +// jsd_el6001_print_controlword("Writing controlword to EtherCAT register of: ", state->controlword_user, slave_id); - state->controlword_terminal_last = state->controlword_terminal; - rxpdo->controlword = state->controlword_user; +// state->controlword_terminal_last = state->controlword_terminal; +// rxpdo->controlword = state->controlword_user; -} +// } // Statuswords static bool jsd_el6001_statusword_bit_is_set(const jsd_t* self, uint16_t slave_id, int bit) { @@ -381,6 +381,8 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + // Write into RxPDO + // jsd_el6001_write_PDO_data(self, slave_id); state->timer_start_sec = jsd_time_get_mono_time_sec(); @@ -415,22 +417,20 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: { - // Clear out transmit request - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { - ERROR("EL6001 id %d: Transmit request timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); - // jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + ERROR("EL6001 id %d: Transmit request timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } else if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_TRANSMIT_ACCEPTED)) { // Beckhoff terminal transmitted data. - MSG_DEBUG("Transmit request accepted, data has been transmitted"); + MSG_DEBUG("Transmit request accepted, data transmit confirmed"); - // Go back to waiting for another transmit request - // jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + // Go back to waiting for another transmit request + jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); //clear data_out_length + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); // Start timeout timer @@ -513,31 +513,39 @@ void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; state->controlword_terminal_last = state->controlword_terminal; - rxpdo->controlword = state->controlword_user; - // TODO: check whether we can receive packed data as array - rxpdo->data_out_0 = state->transmit_bytes[0]; - rxpdo->data_out_1 = state->transmit_bytes[1]; - rxpdo->data_out_2 = state->transmit_bytes[2]; - rxpdo->data_out_3 = state->transmit_bytes[3]; - rxpdo->data_out_4 = state->transmit_bytes[4]; - rxpdo->data_out_5 = state->transmit_bytes[5]; - rxpdo->data_out_6 = state->transmit_bytes[6]; - rxpdo->data_out_7 = state->transmit_bytes[7]; - rxpdo->data_out_8 = state->transmit_bytes[8]; - rxpdo->data_out_9 = state->transmit_bytes[9]; - rxpdo->data_out_10 = state->transmit_bytes[10]; - rxpdo->data_out_11 = state->transmit_bytes[11]; - rxpdo->data_out_12 = state->transmit_bytes[12]; - rxpdo->data_out_13 = state->transmit_bytes[13]; - rxpdo->data_out_14 = state->transmit_bytes[14]; - rxpdo->data_out_15 = state->transmit_bytes[15]; - rxpdo->data_out_16 = state->transmit_bytes[16]; - rxpdo->data_out_17 = state->transmit_bytes[17]; - rxpdo->data_out_18 = state->transmit_bytes[18]; - rxpdo->data_out_19 = state->transmit_bytes[19]; - rxpdo->data_out_20 = state->transmit_bytes[20]; - rxpdo->data_out_21 = state->transmit_bytes[21]; + if(state->controlword_user_last != state->controlword_user){ + MSG_DEBUG("Writing a controlword as it has been updated"); + rxpdo->controlword = state->controlword_user; + state->controlword_user_last = state->controlword_user; + } + + if(state->controlword_user & (1 << JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)){ + MSG_DEBUG("User request to transmit, populating data_out stream"); + // TODO: check whether we can receive packed data as array + rxpdo->data_out_0 = state->transmit_bytes[0]; + rxpdo->data_out_1 = state->transmit_bytes[1]; + rxpdo->data_out_2 = state->transmit_bytes[2]; + rxpdo->data_out_3 = state->transmit_bytes[3]; + rxpdo->data_out_4 = state->transmit_bytes[4]; + rxpdo->data_out_5 = state->transmit_bytes[5]; + rxpdo->data_out_6 = state->transmit_bytes[6]; + rxpdo->data_out_7 = state->transmit_bytes[7]; + rxpdo->data_out_8 = state->transmit_bytes[8]; + rxpdo->data_out_9 = state->transmit_bytes[9]; + rxpdo->data_out_10 = state->transmit_bytes[10]; + rxpdo->data_out_11 = state->transmit_bytes[11]; + rxpdo->data_out_12 = state->transmit_bytes[12]; + rxpdo->data_out_13 = state->transmit_bytes[13]; + rxpdo->data_out_14 = state->transmit_bytes[14]; + rxpdo->data_out_15 = state->transmit_bytes[15]; + rxpdo->data_out_16 = state->transmit_bytes[16]; + rxpdo->data_out_17 = state->transmit_bytes[17]; + rxpdo->data_out_18 = state->transmit_bytes[18]; + rxpdo->data_out_19 = state->transmit_bytes[19]; + rxpdo->data_out_20 = state->transmit_bytes[20]; + rxpdo->data_out_21 = state->transmit_bytes[21]; + } } void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { @@ -556,6 +564,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { { // Request Beckhoff terminal to initialize jsd_el6001_set_controlword(self, slave_id, jsd_el6001_set_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_INIT_REQUEST)); + // jsd_el6001_write_controlword(self, slave_id); jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT, &state->sms); } break; @@ -566,6 +575,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { { // Clear init request in order to make terminal ready for serial communication jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_INIT_REQUEST)); + // jsd_el6001_write_controlword(self, slave_id); jsd_el6001_transition_sms(JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, &state->sms); } } @@ -606,12 +616,12 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { break; } - // If the controlword has changed, write it and update the "last" (most recent) value. - if (state->controlword_user != state->controlword_user_last) - { - jsd_el6001_write_controlword(self, slave_id); - state->controlword_user_last = state->controlword_user; - } + // // If the controlword has changed, write it and update the "last" (most recent) value. + // if (state->controlword_user != state->controlword_user_last) + // { + // jsd_el6001_write_controlword(self, slave_id); + // state->controlword_user_last = state->controlword_user; + // } // Write slave state into RxPDO jsd_el6001_write_PDO_data(self, slave_id); @@ -652,7 +662,9 @@ int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_byt assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); // Set number of output bytes by setting bits 8-15 of the control word to that number - // Write the control word so the terminal know number of bytes to send + // Write the controlword so the terminal know number of bytes to send + MSG("Clearing out any previous data output length"); + jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user | (num_bytes_to_transmit << JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0)); From ea67fec1f96eae0619cb37843d6b7fe0ab24316e Mon Sep 17 00:00:00 2001 From: David Kim Date: Mon, 27 Mar 2023 11:13:20 -0700 Subject: [PATCH 20/37] Debugging receive data --- src/jsd_el6001.c | 69 +++++++++++++++++++++++++++--------------- src/jsd_el6001_types.h | 5 ++- 2 files changed, 48 insertions(+), 26 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 028e63a..68a9d51 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -216,11 +216,12 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // newly received data, read the data bytes if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_RECEIVE_REQUEST)) { + MSG("EL6001[%d]: New data arrived at the terminal", slave_id); state->received_all_persistent_bytes = false; // Get number of data bytes received from the status word num_bytes_received = (state->statusword & JSD_EL6001_STATUSWORD_INPUT_LENGTH_BIT_MASK) >> JSD_EL6001_STATUSWORD_INPUT_LENGTH_0; - MSG_DEBUG("EL6001[%d]: num bytes received: %d", slave_id, num_bytes_received); + MSG_DEBUG("EL6001[%d]: Terminal received %d bytes, waiting to accept reception from controller", slave_id, num_bytes_received); // assert number of bytes received is not above terminal capacity if(num_bytes_received > JSD_EL6001_NUM_DATA_BYTES) @@ -229,7 +230,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { assert(0); } - if (!state->received_first_byte_of_msg) + if (!state->received_first_byte_of_packet) { state->num_persistent_bytes_received = 0; } @@ -247,13 +248,14 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { JSD_EL6001_MAX_NUM_DATA_BYTES); state->num_persistent_bytes_received = 0; - state->received_first_byte_of_msg = false; + state->received_first_byte_of_packet = false; ++state->read_errors; } // Store the received data bytes for (i = 0; i < num_bytes_received; ++i) { + //state->received_bytes[] : Data is already populated while read PDO state->persistent_received_bytes[state->num_persistent_bytes_received + i] = state->received_bytes[i]; } @@ -262,16 +264,22 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // if first byte of persistent receipt wasn't received yet, set number of // bytes to receive from the first byte of the message - if (!state->received_first_byte_of_msg) + if (!state->received_first_byte_of_packet) { - /// Always set number of expected bytes based on the first byte of the packet - - state->expected_num_bytes_to_receive = ( - 1 /*num_bytes byte*/ - + state->received_bytes[0] - + 1 /*checksum byte*/); + MSG_DEBUG("EL6001[%d]: Received the first byte of a data packet", slave_id); + if(state->use_first_byte_as_packet_length){ + /// Always set number of expected bytes based on the first byte of the packet + state->expected_num_bytes_to_receive = ( + 1 /*num_bytes byte*/ + + state->received_bytes[0] + + 1 /*checksum byte*/); + } + else{ + state->expected_num_bytes_to_receive = num_bytes_received; + } - state->received_first_byte_of_msg = true; + MSG_DEBUG("EL6001[%d]: Expecting %d byte of data packet", slave_id, state->expected_num_bytes_to_receive); + state->received_first_byte_of_packet = true; } // If there's a more than one whole expected packet, drop the earlier ones. Increment the error counter. @@ -304,17 +312,19 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // If we received one whole packet, parse it. Checksum is last byte if (state->num_persistent_bytes_received >= state->expected_num_bytes_to_receive) { - MSG_DEBUG("EL6001 id %d: Received all expected %d bytes", slave_id, state->expected_num_bytes_to_receive); - - expected_checksum = state->persistent_received_bytes[state->expected_num_bytes_to_receive - 1]; - checksum = jsd_el6001_compute_checksum( - state->persistent_received_bytes, - state->expected_num_bytes_to_receive - 1/*checksum*/); - if (expected_checksum != checksum) - { - ERROR("EL6001 id %d: Checksum invalid. Expected: %d, Computed: %d", slave_id, expected_checksum, checksum); - state->checksum_failed = true; - ++state->read_errors; + MSG_DEBUG("EL6001 id %d: Received all expected %d bytes of data packet", slave_id, state->expected_num_bytes_to_receive); + + if(state->use_last_byte_as_checksum){ + expected_checksum = state->persistent_received_bytes[state->expected_num_bytes_to_receive - 1]; + checksum = jsd_el6001_compute_checksum( + state->persistent_received_bytes, + state->expected_num_bytes_to_receive - 1/*checksum*/); + if (expected_checksum != checksum) + { + ERROR("EL6001 id %d: Checksum invalid. Expected: %d, Computed: %d", slave_id, expected_checksum, checksum); + state->checksum_failed = true; + ++state->read_errors; + } } // No Partial Packet @@ -325,7 +335,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { state->received_all_persistent_bytes = true; // reset first byte check - state->received_first_byte_of_msg = false; + state->received_first_byte_of_packet = false; } else { @@ -353,7 +363,12 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // Tell terminal that data was received, so that new data can be received from the terminal jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_RECEIVE_ACCEPTED)); - MSG_DEBUG("EL6001 id %d: num bytes received = %d", slave_id, num_bytes_received); + MSG_DEBUG("EL6001[%d]: Data transferred with num bytes %d", slave_id, num_bytes_received); + + // Printout received data + for(int i=0; i < num_bytes_received; i++){ + MSG_DEBUG("EL6001[%d]: Received data_in[%d]: %d", slave_id, i, state->received_bytes[i]); + } } // Set for user to know number of bytes received @@ -409,7 +424,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { ERROR("EL6001 id %d: Clearing persistent data buffer in order to transmit fresh data in the next cycle.", slave_id); state->num_persistent_bytes_received = 0; state->received_all_persistent_bytes = 1; - state->received_first_byte_of_msg = false; + state->received_first_byte_of_packet = false; } } } @@ -699,6 +714,10 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { // Initialize timeout timer self->slave_states[slave_id].el6001.timer_start_sec = jsd_time_get_mono_time_sec(); + // Initialize packet config TODO: Link with fastcat config + self->slave_states[slave_id].el6001.use_first_byte_as_packet_length = false; + self->slave_states[slave_id].el6001.use_last_byte_as_checksum = false; + // Initialize the autoincrement byte to -1 (none, or unknown) self->slave_states[slave_id].el6001.autoincrement_byte = -1; diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index e4f28ba..dbb45a3 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -121,6 +121,7 @@ typedef enum */ typedef struct { jsd_el6001_baud_rate_t baud_rate; + bool use_first_byte_as_packet_length; } jsd_el6001_config_t; /** @@ -236,7 +237,9 @@ typedef struct uint8_t persistent_received_bytes[JSD_EL6001_MAX_NUM_DATA_BYTES]; int num_persistent_bytes_received; bool received_all_persistent_bytes; - bool received_first_byte_of_msg; + bool use_first_byte_as_packet_length; + bool received_first_byte_of_packet; + bool use_last_byte_as_checksum; bool user_requests_to_transmit_data_persistently; jsd_el6001_sms_t sms; From 1887177535bb9eb0fe165deaf764fe04c896cb85 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 29 Mar 2023 10:44:23 -0700 Subject: [PATCH 21/37] Splited on sms and transmit_sms --- src/jsd_el6001.c | 37 +++++++++++++++++++++++++++---------- src/jsd_el6001_types.h | 18 ++++++++++++++---- 2 files changed, 41 insertions(+), 14 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 68a9d51..125d44a 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -41,9 +41,17 @@ static char* jsd_el6001_sms_to_string(jsd_el6001_sms_t sms) { { case JSD_EL6001_SMS_INITING: return "INITING_SERIAL_COMMUNICATION"; case JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT: return "WAITING_FOR_INIT_TO_COMPLETE"; - case JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION: return "READY_FOR_SERIAL_COMMUNICATION"; - case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: return "WAITING_FOR_TRANSMIT_REQUEST_FROM_USER"; - case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: return "WAITING_FOR_TRANSMIT_CONFIRMATION_FROM_TERMINAL"; + case JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION: return "READY_FOR_SERIAL_COMMUNICATION"; + + default: assert(0); break; + } +} + +static char* jsd_el6001_transmit_sms_to_string(jsd_el6001_transmit_sms_t sms) { + switch (sms) + { + case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: return "WAITING_FOR_TRANSMIT_REQUEST_FROM_USER"; + case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: return "WAITING_FOR_TRANSMIT_CONFIRMATION_FROM_TERMINAL"; default: assert(0); break; } @@ -172,6 +180,15 @@ static int jsd_el6001_transition_sms(jsd_el6001_sms_t sms, jsd_el6001_sms_t* sms return 0; } +static int jsd_el6001_transition_transmit_sms(jsd_el6001_transmit_sms_t sms, jsd_el6001_transmit_sms_t* sms_ptr) { + assert(sms_ptr != NULL); + + *sms_ptr = sms; + MSG_DEBUG("Transitioning to %s state", jsd_el6001_transmit_sms_to_string(sms)); + + return 0; +} + static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { int i; int8_t checksum = 0; @@ -389,13 +406,13 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { switch (state->transmit_state) { - case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: + case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: if (state->user_requests_to_transmit_data) { MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); // Write into RxPDO // jsd_el6001_write_PDO_data(self, slave_id); @@ -411,7 +428,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); state->timer_start_sec = jsd_time_get_mono_time_sec(); } @@ -430,13 +447,13 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { } break; - case JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: + case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: { double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { ERROR("EL6001 id %d: Transmit request timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); - jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } else if (jsd_el6001_statusword_bit_was_toggled(self, slave_id, JSD_EL6001_STATUSWORD_TRANSMIT_ACCEPTED)) { @@ -446,7 +463,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Go back to waiting for another transmit request jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); //clear data_out_length jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_sms(JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); // Start timeout timer state->timer_start_sec = jsd_time_get_mono_time_sec(); @@ -709,7 +726,7 @@ bool jsd_el6001_init(jsd_t* self, uint16_t slave_id) { self->slave_states[slave_id].el6001.sms = JSD_EL6001_SMS_INITING; // TODO: This used to be done in configure_sdos // Initialize transmit state machine - self->slave_states[slave_id].el6001.transmit_state = JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER; + self->slave_states[slave_id].el6001.transmit_state = JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER; // Initialize timeout timer self->slave_states[slave_id].el6001.timer_start_sec = jsd_time_get_mono_time_sec(); diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index dbb45a3..8c1dbf2 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -122,6 +122,7 @@ typedef enum typedef struct { jsd_el6001_baud_rate_t baud_rate; bool use_first_byte_as_packet_length; + bool use_last_byte_as_checksum; } jsd_el6001_config_t; /** @@ -193,13 +194,22 @@ typedef enum { JSD_EL6001_SMS_INITING = 0, JSD_EL6001_SMS_WAITING_FOR_TERMINAL_TO_INIT, - JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, - JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, - JSD_EL6001_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, + JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION, JSD_EL6001_SMS_NUM_STATES } jsd_el6001_sms_t; +/** + * @brief Transmit State Machine States needed for communication via serial RS232 interface + */ +typedef enum +{ + JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER = 0, + JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, + JSD_EL6001_TRANSMIT_SMS_NUM_STATES + +} jsd_el6001_transmit_sms_t; + /** * @brief EL6001 state data */ @@ -243,7 +253,7 @@ typedef struct bool user_requests_to_transmit_data_persistently; jsd_el6001_sms_t sms; - jsd_el6001_sms_t transmit_state; + jsd_el6001_transmit_sms_t transmit_state; } jsd_el6001_state_t; From d0b66cf04a70e974ece3b287b3645337e1d585ca Mon Sep 17 00:00:00 2001 From: David Kim Date: Tue, 25 Apr 2023 11:27:07 -0700 Subject: [PATCH 22/37] Fix for making rxpdo, txpdo as array --- src/jsd_el6001.c | 95 +++++++++++++++++++++++------------------- src/jsd_el6001_types.h | 92 ++++++++++++++++++++-------------------- 2 files changed, 98 insertions(+), 89 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 125d44a..8ea72b2 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -510,28 +510,31 @@ void jsd_el6001_read(jsd_t* self, uint16_t slave_id) { state->statusword = txpdo->statusword; // TODO: check whether we can receive packed data as array - state->received_bytes[0] = txpdo->data_in_0; - state->received_bytes[1] = txpdo->data_in_1; - state->received_bytes[2] = txpdo->data_in_2; - state->received_bytes[3] = txpdo->data_in_3; - state->received_bytes[4] = txpdo->data_in_4; - state->received_bytes[5] = txpdo->data_in_5; - state->received_bytes[6] = txpdo->data_in_6; - state->received_bytes[7] = txpdo->data_in_7; - state->received_bytes[8] = txpdo->data_in_8; - state->received_bytes[9] = txpdo->data_in_9; - state->received_bytes[10] = txpdo->data_in_10; - state->received_bytes[11] = txpdo->data_in_11; - state->received_bytes[12] = txpdo->data_in_12; - state->received_bytes[13] = txpdo->data_in_13; - state->received_bytes[14] = txpdo->data_in_14; - state->received_bytes[15] = txpdo->data_in_15; - state->received_bytes[16] = txpdo->data_in_16; - state->received_bytes[17] = txpdo->data_in_17; - state->received_bytes[18] = txpdo->data_in_18; - state->received_bytes[19] = txpdo->data_in_19; - state->received_bytes[20] = txpdo->data_in_20; - state->received_bytes[21] = txpdo->data_in_21; + for(int i = 0; i < JSD_EL6001_NUM_DATA_BYTES; i ++){ + state->received_bytes[i] = txpdo->data_in[i]; + } + // state->received_bytes[0] = txpdo->data_in_0; + // state->received_bytes[1] = txpdo->data_in_1; + // state->received_bytes[2] = txpdo->data_in_2; + // state->received_bytes[3] = txpdo->data_in_3; + // state->received_bytes[4] = txpdo->data_in_4; + // state->received_bytes[5] = txpdo->data_in_5; + // state->received_bytes[6] = txpdo->data_in_6; + // state->received_bytes[7] = txpdo->data_in_7; + // state->received_bytes[8] = txpdo->data_in_8; + // state->received_bytes[9] = txpdo->data_in_9; + // state->received_bytes[10] = txpdo->data_in_10; + // state->received_bytes[11] = txpdo->data_in_11; + // state->received_bytes[12] = txpdo->data_in_12; + // state->received_bytes[13] = txpdo->data_in_13; + // state->received_bytes[14] = txpdo->data_in_14; + // state->received_bytes[15] = txpdo->data_in_15; + // state->received_bytes[16] = txpdo->data_in_16; + // state->received_bytes[17] = txpdo->data_in_17; + // state->received_bytes[18] = txpdo->data_in_18; + // state->received_bytes[19] = txpdo->data_in_19; + // state->received_bytes[20] = txpdo->data_in_20; + // state->received_bytes[21] = txpdo->data_in_21; } void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { @@ -554,29 +557,33 @@ void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { if(state->controlword_user & (1 << JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)){ MSG_DEBUG("User request to transmit, populating data_out stream"); + uint8_t output_length = rxpdo->controlword >> JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0; // TODO: check whether we can receive packed data as array - rxpdo->data_out_0 = state->transmit_bytes[0]; - rxpdo->data_out_1 = state->transmit_bytes[1]; - rxpdo->data_out_2 = state->transmit_bytes[2]; - rxpdo->data_out_3 = state->transmit_bytes[3]; - rxpdo->data_out_4 = state->transmit_bytes[4]; - rxpdo->data_out_5 = state->transmit_bytes[5]; - rxpdo->data_out_6 = state->transmit_bytes[6]; - rxpdo->data_out_7 = state->transmit_bytes[7]; - rxpdo->data_out_8 = state->transmit_bytes[8]; - rxpdo->data_out_9 = state->transmit_bytes[9]; - rxpdo->data_out_10 = state->transmit_bytes[10]; - rxpdo->data_out_11 = state->transmit_bytes[11]; - rxpdo->data_out_12 = state->transmit_bytes[12]; - rxpdo->data_out_13 = state->transmit_bytes[13]; - rxpdo->data_out_14 = state->transmit_bytes[14]; - rxpdo->data_out_15 = state->transmit_bytes[15]; - rxpdo->data_out_16 = state->transmit_bytes[16]; - rxpdo->data_out_17 = state->transmit_bytes[17]; - rxpdo->data_out_18 = state->transmit_bytes[18]; - rxpdo->data_out_19 = state->transmit_bytes[19]; - rxpdo->data_out_20 = state->transmit_bytes[20]; - rxpdo->data_out_21 = state->transmit_bytes[21]; + for(uint8_t i = 0; i < output_length; i++){ + rxpdo->data_out[i] = state->transmit_bytes[i]; + // rxpdo->data_out_0 = state->transmit_bytes[0]; + // rxpdo->data_out_1 = state->transmit_bytes[1]; + // rxpdo->data_out_2 = state->transmit_bytes[2]; + // rxpdo->data_out_3 = state->transmit_bytes[3]; + // rxpdo->data_out_4 = state->transmit_bytes[4]; + // rxpdo->data_out_5 = state->transmit_bytes[5]; + // rxpdo->data_out_6 = state->transmit_bytes[6]; + // rxpdo->data_out_7 = state->transmit_bytes[7]; + // rxpdo->data_out_8 = state->transmit_bytes[8]; + // rxpdo->data_out_9 = state->transmit_bytes[9]; + // rxpdo->data_out_10 = state->transmit_bytes[10]; + // rxpdo->data_out_11 = state->transmit_bytes[11]; + // rxpdo->data_out_12 = state->transmit_bytes[12]; + // rxpdo->data_out_13 = state->transmit_bytes[13]; + // rxpdo->data_out_14 = state->transmit_bytes[14]; + // rxpdo->data_out_15 = state->transmit_bytes[15]; + // rxpdo->data_out_16 = state->transmit_bytes[16]; + // rxpdo->data_out_17 = state->transmit_bytes[17]; + // rxpdo->data_out_18 = state->transmit_bytes[18]; + // rxpdo->data_out_19 = state->transmit_bytes[19]; + // rxpdo->data_out_20 = state->transmit_bytes[20]; + // rxpdo->data_out_21 = state->transmit_bytes[21]; + } } } diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index 8c1dbf2..dd4cfbf 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -132,28 +132,29 @@ typedef struct { */ typedef struct __attribute__((__packed__)) { uint16_t controlword; //0x3003:0x01: 2byte - uint8_t data_out_0; //0x3003:0x02: 1byte - uint8_t data_out_1; //0x3003:0x03 - uint8_t data_out_2; - uint8_t data_out_3; - uint8_t data_out_4; - uint8_t data_out_5; - uint8_t data_out_6; - uint8_t data_out_7; - uint8_t data_out_8; - uint8_t data_out_9; - uint8_t data_out_10; - uint8_t data_out_11; - uint8_t data_out_12; - uint8_t data_out_13; - uint8_t data_out_14; - uint8_t data_out_15; - uint8_t data_out_16; - uint8_t data_out_17; - uint8_t data_out_18; - uint8_t data_out_19; - uint8_t data_out_20; - uint8_t data_out_21; //0x3003:0x17 + uint8_t data_out[JSD_EL6001_NUM_DATA_BYTES]; + // uint8_t data_out_0; //0x3003:0x02: 1byte + // uint8_t data_out_1; //0x3003:0x03 + // uint8_t data_out_2; + // uint8_t data_out_3; + // uint8_t data_out_4; + // uint8_t data_out_5; + // uint8_t data_out_6; + // uint8_t data_out_7; + // uint8_t data_out_8; + // uint8_t data_out_9; + // uint8_t data_out_10; + // uint8_t data_out_11; + // uint8_t data_out_12; + // uint8_t data_out_13; + // uint8_t data_out_14; + // uint8_t data_out_15; + // uint8_t data_out_16; + // uint8_t data_out_17; + // uint8_t data_out_18; + // uint8_t data_out_19; + // uint8_t data_out_20; + // uint8_t data_out_21; //0x3003:0x17 } jsd_el6001_rxpdo_t; /** @@ -162,29 +163,30 @@ typedef struct __attribute__((__packed__)) { * Note: struct order matters and must be packed. */ typedef struct __attribute__((__packed__)) { - uint16_t statusword; //0x3103:01 - uint8_t data_in_0; //0x3103:02 - uint8_t data_in_1; - uint8_t data_in_2; - uint8_t data_in_3; - uint8_t data_in_4; - uint8_t data_in_5; - uint8_t data_in_6; - uint8_t data_in_7; - uint8_t data_in_8; - uint8_t data_in_9; - uint8_t data_in_10; - uint8_t data_in_11; - uint8_t data_in_12; - uint8_t data_in_13; - uint8_t data_in_14; - uint8_t data_in_15; - uint8_t data_in_16; - uint8_t data_in_17; - uint8_t data_in_18; - uint8_t data_in_19; - uint8_t data_in_20; - uint8_t data_in_21; //0x3103:17 + uint16_t statusword; //0x3103:01 + uint8_t data_in[JSD_EL6001_NUM_DATA_BYTES]; + // uint8_t data_in_0; //0x3103:02 + // uint8_t data_in_1; + // uint8_t data_in_2; + // uint8_t data_in_3; + // uint8_t data_in_4; + // uint8_t data_in_5; + // uint8_t data_in_6; + // uint8_t data_in_7; + // uint8_t data_in_8; + // uint8_t data_in_9; + // uint8_t data_in_10; + // uint8_t data_in_11; + // uint8_t data_in_12; + // uint8_t data_in_13; + // uint8_t data_in_14; + // uint8_t data_in_15; + // uint8_t data_in_16; + // uint8_t data_in_17; + // uint8_t data_in_18; + // uint8_t data_in_19; + // uint8_t data_in_20; + // uint8_t data_in_21; //0x3103:17 } jsd_el6001_txpdo_data_t; /** From 048d6a2d83107b6a8376286cb16505dff8893a02 Mon Sep 17 00:00:00 2001 From: David Kim Date: Mon, 1 May 2023 11:07:32 -0700 Subject: [PATCH 23/37] Fixed persistent transmit --- src/jsd_el6001.c | 86 ++++++++++++++++++++++---------------------- src/jsd_el6001_pub.h | 2 +- 2 files changed, 45 insertions(+), 43 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 8ea72b2..d9df37b 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -203,12 +203,12 @@ static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { } // data control -static bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { - assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); +// static bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { +// assert(self); +// assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - return self->slave_states[slave_id].el6001.received_all_persistent_bytes; -} +// return self->slave_states[slave_id].el6001.received_all_persistent_bytes; +// } //---------------------------------------------------------------------------// @@ -411,10 +411,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { { MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); - // Write into RxPDO - // jsd_el6001_write_PDO_data(self, slave_id); + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); state->timer_start_sec = jsd_time_get_mono_time_sec(); @@ -423,34 +420,17 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { } else if (state->user_requests_to_transmit_data_persistently) { - if (jsd_el6001_all_persistent_data_was_received(self, slave_id)) - { - // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); - - state->timer_start_sec = jsd_time_get_mono_time_sec(); - } - else - { - double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; - if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) - { - ERROR("EL6001 id %d: Transmit timed out after %f seconds while waiting for persistent data.", slave_id, time_since_last_transmit); - ERROR("EL6001 id %d: Clearing persistent data buffer in order to transmit fresh data in the next cycle.", slave_id); - state->num_persistent_bytes_received = 0; - state->received_all_persistent_bytes = 1; - state->received_first_byte_of_packet = false; - } - } + // Tell terminal that data is available to transmit and then transition + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); } + + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); break; case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: { double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; - if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) + if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { ERROR("EL6001 id %d: Transmit request timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); @@ -460,19 +440,22 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Beckhoff terminal transmitted data. MSG_DEBUG("Transmit request accepted, data transmit confirmed"); - // Go back to waiting for another transmit request - jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); //clear data_out_length - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); - - // Start timeout timer - state->timer_start_sec = jsd_time_get_mono_time_sec(); - - //Increment the successful transmit counter - if (state->autoincrement_byte >= 0) + if (!state->user_requests_to_transmit_data_persistently) { - jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); + // Go back to waiting for another transmit request + jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); //clear data_out_length + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); } + else if (state->user_requests_to_transmit_data_persistently) + { + // Start timeout timer + state->timer_start_sec = jsd_time_get_mono_time_sec(); + + //Increment the successful transmit counter + state->autoincrement_byte++; + } + + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } } break; @@ -713,6 +696,25 @@ int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_byt return 0; } +int jsd_el6001_set_persistent_transmit_data(jsd_t *self, uint16_t slave_id, int num_bytes_to_transmit, bool flag) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + // Set up the timer for detecting a timeout while waiting for persistent + // receive during attempt at persistent transmit + self->slave_states[slave_id].el6001.timer_start_sec = jsd_time_get_mono_time_sec(); + + // Set number of output bytes by setting bits 8-15 of the control word to that number + // Write the control word so the terminal knows number of bytes to send + jsd_el6001_set_controlword(self, slave_id, + self->slave_states[slave_id].el6001.controlword_user | (num_bytes_to_transmit << JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0)); + + // Set bool to advance transmit state machine + self->slave_states[slave_id].el6001.user_requests_to_transmit_data_persistently = flag; + + return 0; +} + /**************************************************** * Private functions ****************************************************/ diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index fac05cc..b9ebf0a 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -47,7 +47,7 @@ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); -int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit, bool state); +int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit, bool flag); #ifdef __cplusplus } From d4fff0b33fc0a7c6f67519076682c4e62d6645ca Mon Sep 17 00:00:00 2001 From: Casah Admin Date: Wed, 28 Jun 2023 11:37:56 -0700 Subject: [PATCH 24/37] fixing el6001 driver --- .clang-format | 0 .doxyfile.in | 0 .gitignore | 0 CHANGELOG.md | 0 CMakeLists.txt | 0 LICENSE.md | 0 README.md | 0 TROUBLESHOOTING.md | 0 docs/JPL-logo-color.png | Bin src/CMakeLists.txt | 0 src/jsd.c | 0 src/jsd.h | 0 src/jsd_ati_fts.c | 0 src/jsd_ati_fts.h | 0 src/jsd_ati_fts_pub.h | 0 src/jsd_ati_fts_types.h | 0 src/jsd_common_device_types.c | 0 src/jsd_common_device_types.h | 0 src/jsd_egd.c | 0 src/jsd_egd.h | 0 src/jsd_egd_pub.h | 0 src/jsd_egd_types.h | 0 src/jsd_el2124.c | 0 src/jsd_el2124.h | 0 src/jsd_el2124_pub.h | 0 src/jsd_el2124_types.h | 0 src/jsd_el3104.c | 0 src/jsd_el3104.h | 0 src/jsd_el3104_pub.h | 0 src/jsd_el3104_types.h | 0 src/jsd_el3162.c | 0 src/jsd_el3162.h | 0 src/jsd_el3162_pub.h | 0 src/jsd_el3162_types.h | 0 src/jsd_el3202.c | 0 src/jsd_el3202.h | 0 src/jsd_el3202_pub.h | 0 src/jsd_el3202_types.h | 0 src/jsd_el3208.c | 0 src/jsd_el3208.h | 0 src/jsd_el3208_pub.h | 0 src/jsd_el3208_types.h | 0 src/jsd_el3318.c | 0 src/jsd_el3318.h | 0 src/jsd_el3318_pub.h | 0 src/jsd_el3318_types.h | 0 src/jsd_el3356.c | 0 src/jsd_el3356.h | 0 src/jsd_el3356_pub.h | 0 src/jsd_el3356_types.h | 0 src/jsd_el3602.c | 0 src/jsd_el3602.h | 0 src/jsd_el3602_pub.h | 0 src/jsd_el3602_types.h | 0 src/jsd_el4102.c | 0 src/jsd_el4102.h | 0 src/jsd_el4102_pub.h | 0 src/jsd_el4102_types.h | 0 src/jsd_el6001.c | 12 ++--- src/jsd_elmo_common.c | 0 src/jsd_elmo_common.h | 0 src/jsd_elmo_common_types.h | 0 src/jsd_epd.c | 0 src/jsd_epd.h | 0 src/jsd_epd_pub.h | 0 src/jsd_epd_types.h | 0 src/jsd_error_cirq.c | 0 src/jsd_error_cirq.h | 0 src/jsd_ild1900.c | 0 src/jsd_ild1900.h | 0 src/jsd_ild1900_pub.h | 0 src/jsd_ild1900_types.h | 0 src/jsd_include_defs.h | 0 src/jsd_jed0101.c | 0 src/jsd_jed0101.h | 0 src/jsd_jed0101_pub.h | 0 src/jsd_jed0101_types.h | 0 src/jsd_jed0200.c | 0 src/jsd_jed0200.h | 0 src/jsd_jed0200_pub.h | 0 src/jsd_jed0200_types.h | 0 src/jsd_print.h | 59 +++++++++++++++-------- src/jsd_pub.h | 0 src/jsd_sdo.c | 0 src/jsd_sdo.h | 0 src/jsd_sdo_pub.h | 0 src/jsd_time.h | 0 src/jsd_timer.c | 0 src/jsd_timer.h | 0 src/jsd_types.h | 0 test/CMakeLists.txt | 0 test/device/jsd_ati_fts_test.c | 0 test/device/jsd_beckhoff_latency_test.c | 0 test/device/jsd_device_test_template.c | 0 test/device/jsd_egd_csp_sine_test.c | 0 test/device/jsd_egd_test.c | 0 test/device/jsd_el2124_test.c | 0 test/device/jsd_el3104_test.c | 0 test/device/jsd_el3162_test.c | 0 test/device/jsd_el3202_test.c | 0 test/device/jsd_el3208_test.c | 0 test/device/jsd_el3318_test.c | 0 test/device/jsd_el3356_test.c | 0 test/device/jsd_el3602_test.c | 0 test/device/jsd_el4102_test.c | 0 test/device/jsd_epd_csp_sine_test.c | 0 test/device/jsd_epd_cst_test.c | 0 test/device/jsd_epd_csv_sine_test.c | 0 test/device/jsd_epd_prof_pos_test.c | 0 test/device/jsd_epd_prof_torque_test.c | 0 test/device/jsd_epd_prof_vel_test.c | 0 test/device/jsd_ild1900_test.c | 0 test/device/jsd_jed0101_test.c | 0 test/device/jsd_jed0200_test.c | 0 test/device/jsd_minimal_example_el3602.c | 0 test/jsd_test_utils.c | 0 test/jsd_test_utils.h | 0 test/unit/jsd_alloc_free_test.c | 0 test/unit/jsd_epd_lc_to_do_test.c | 0 test/unit/jsd_error_cirq_test.c | 0 test/unit/jsd_soem_init_close_test.c | 0 tools/CMakeLists.txt | 0 tools/jsd_egd_tlc_tty.c | 0 tools/jsd_slaveinfo.c | 0 124 files changed, 44 insertions(+), 27 deletions(-) mode change 100644 => 100755 .clang-format mode change 100644 => 100755 .doxyfile.in mode change 100644 => 100755 .gitignore mode change 100644 => 100755 CHANGELOG.md mode change 100644 => 100755 CMakeLists.txt mode change 100644 => 100755 LICENSE.md mode change 100644 => 100755 README.md mode change 100644 => 100755 TROUBLESHOOTING.md mode change 100644 => 100755 docs/JPL-logo-color.png mode change 100644 => 100755 src/CMakeLists.txt mode change 100644 => 100755 src/jsd.c mode change 100644 => 100755 src/jsd.h mode change 100644 => 100755 src/jsd_ati_fts.c mode change 100644 => 100755 src/jsd_ati_fts.h mode change 100644 => 100755 src/jsd_ati_fts_pub.h mode change 100644 => 100755 src/jsd_ati_fts_types.h mode change 100644 => 100755 src/jsd_common_device_types.c mode change 100644 => 100755 src/jsd_common_device_types.h mode change 100644 => 100755 src/jsd_egd.c mode change 100644 => 100755 src/jsd_egd.h mode change 100644 => 100755 src/jsd_egd_pub.h mode change 100644 => 100755 src/jsd_egd_types.h mode change 100644 => 100755 src/jsd_el2124.c mode change 100644 => 100755 src/jsd_el2124.h mode change 100644 => 100755 src/jsd_el2124_pub.h mode change 100644 => 100755 src/jsd_el2124_types.h mode change 100644 => 100755 src/jsd_el3104.c mode change 100644 => 100755 src/jsd_el3104.h mode change 100644 => 100755 src/jsd_el3104_pub.h mode change 100644 => 100755 src/jsd_el3104_types.h mode change 100644 => 100755 src/jsd_el3162.c mode change 100644 => 100755 src/jsd_el3162.h mode change 100644 => 100755 src/jsd_el3162_pub.h mode change 100644 => 100755 src/jsd_el3162_types.h mode change 100644 => 100755 src/jsd_el3202.c mode change 100644 => 100755 src/jsd_el3202.h mode change 100644 => 100755 src/jsd_el3202_pub.h mode change 100644 => 100755 src/jsd_el3202_types.h mode change 100644 => 100755 src/jsd_el3208.c mode change 100644 => 100755 src/jsd_el3208.h mode change 100644 => 100755 src/jsd_el3208_pub.h mode change 100644 => 100755 src/jsd_el3208_types.h mode change 100644 => 100755 src/jsd_el3318.c mode change 100644 => 100755 src/jsd_el3318.h mode change 100644 => 100755 src/jsd_el3318_pub.h mode change 100644 => 100755 src/jsd_el3318_types.h mode change 100644 => 100755 src/jsd_el3356.c mode change 100644 => 100755 src/jsd_el3356.h mode change 100644 => 100755 src/jsd_el3356_pub.h mode change 100644 => 100755 src/jsd_el3356_types.h mode change 100644 => 100755 src/jsd_el3602.c mode change 100644 => 100755 src/jsd_el3602.h mode change 100644 => 100755 src/jsd_el3602_pub.h mode change 100644 => 100755 src/jsd_el3602_types.h mode change 100644 => 100755 src/jsd_el4102.c mode change 100644 => 100755 src/jsd_el4102.h mode change 100644 => 100755 src/jsd_el4102_pub.h mode change 100644 => 100755 src/jsd_el4102_types.h mode change 100644 => 100755 src/jsd_elmo_common.c mode change 100644 => 100755 src/jsd_elmo_common.h mode change 100644 => 100755 src/jsd_elmo_common_types.h mode change 100644 => 100755 src/jsd_epd.c mode change 100644 => 100755 src/jsd_epd.h mode change 100644 => 100755 src/jsd_epd_pub.h mode change 100644 => 100755 src/jsd_epd_types.h mode change 100644 => 100755 src/jsd_error_cirq.c mode change 100644 => 100755 src/jsd_error_cirq.h mode change 100644 => 100755 src/jsd_ild1900.c mode change 100644 => 100755 src/jsd_ild1900.h mode change 100644 => 100755 src/jsd_ild1900_pub.h mode change 100644 => 100755 src/jsd_ild1900_types.h mode change 100644 => 100755 src/jsd_include_defs.h mode change 100644 => 100755 src/jsd_jed0101.c mode change 100644 => 100755 src/jsd_jed0101.h mode change 100644 => 100755 src/jsd_jed0101_pub.h mode change 100644 => 100755 src/jsd_jed0101_types.h mode change 100644 => 100755 src/jsd_jed0200.c mode change 100644 => 100755 src/jsd_jed0200.h mode change 100644 => 100755 src/jsd_jed0200_pub.h mode change 100644 => 100755 src/jsd_jed0200_types.h mode change 100644 => 100755 src/jsd_pub.h mode change 100644 => 100755 src/jsd_sdo.c mode change 100644 => 100755 src/jsd_sdo.h mode change 100644 => 100755 src/jsd_sdo_pub.h mode change 100644 => 100755 src/jsd_time.h mode change 100644 => 100755 src/jsd_timer.c mode change 100644 => 100755 src/jsd_timer.h mode change 100644 => 100755 src/jsd_types.h mode change 100644 => 100755 test/CMakeLists.txt mode change 100644 => 100755 test/device/jsd_ati_fts_test.c mode change 100644 => 100755 test/device/jsd_beckhoff_latency_test.c mode change 100644 => 100755 test/device/jsd_device_test_template.c mode change 100644 => 100755 test/device/jsd_egd_csp_sine_test.c mode change 100644 => 100755 test/device/jsd_egd_test.c mode change 100644 => 100755 test/device/jsd_el2124_test.c mode change 100644 => 100755 test/device/jsd_el3104_test.c mode change 100644 => 100755 test/device/jsd_el3162_test.c mode change 100644 => 100755 test/device/jsd_el3202_test.c mode change 100644 => 100755 test/device/jsd_el3208_test.c mode change 100644 => 100755 test/device/jsd_el3318_test.c mode change 100644 => 100755 test/device/jsd_el3356_test.c mode change 100644 => 100755 test/device/jsd_el3602_test.c mode change 100644 => 100755 test/device/jsd_el4102_test.c mode change 100644 => 100755 test/device/jsd_epd_csp_sine_test.c mode change 100644 => 100755 test/device/jsd_epd_cst_test.c mode change 100644 => 100755 test/device/jsd_epd_csv_sine_test.c mode change 100644 => 100755 test/device/jsd_epd_prof_pos_test.c mode change 100644 => 100755 test/device/jsd_epd_prof_torque_test.c mode change 100644 => 100755 test/device/jsd_epd_prof_vel_test.c mode change 100644 => 100755 test/device/jsd_ild1900_test.c mode change 100644 => 100755 test/device/jsd_jed0101_test.c mode change 100644 => 100755 test/device/jsd_jed0200_test.c mode change 100644 => 100755 test/device/jsd_minimal_example_el3602.c mode change 100644 => 100755 test/jsd_test_utils.c mode change 100644 => 100755 test/jsd_test_utils.h mode change 100644 => 100755 test/unit/jsd_alloc_free_test.c mode change 100644 => 100755 test/unit/jsd_epd_lc_to_do_test.c mode change 100644 => 100755 test/unit/jsd_error_cirq_test.c mode change 100644 => 100755 test/unit/jsd_soem_init_close_test.c mode change 100644 => 100755 tools/CMakeLists.txt mode change 100644 => 100755 tools/jsd_egd_tlc_tty.c mode change 100644 => 100755 tools/jsd_slaveinfo.c diff --git a/.clang-format b/.clang-format old mode 100644 new mode 100755 diff --git a/.doxyfile.in b/.doxyfile.in old mode 100644 new mode 100755 diff --git a/.gitignore b/.gitignore old mode 100644 new mode 100755 diff --git a/CHANGELOG.md b/CHANGELOG.md old mode 100644 new mode 100755 diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100644 new mode 100755 diff --git a/LICENSE.md b/LICENSE.md old mode 100644 new mode 100755 diff --git a/README.md b/README.md old mode 100644 new mode 100755 diff --git a/TROUBLESHOOTING.md b/TROUBLESHOOTING.md old mode 100644 new mode 100755 diff --git a/docs/JPL-logo-color.png b/docs/JPL-logo-color.png old mode 100644 new mode 100755 diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt old mode 100644 new mode 100755 diff --git a/src/jsd.c b/src/jsd.c old mode 100644 new mode 100755 diff --git a/src/jsd.h b/src/jsd.h old mode 100644 new mode 100755 diff --git a/src/jsd_ati_fts.c b/src/jsd_ati_fts.c old mode 100644 new mode 100755 diff --git a/src/jsd_ati_fts.h b/src/jsd_ati_fts.h old mode 100644 new mode 100755 diff --git a/src/jsd_ati_fts_pub.h b/src/jsd_ati_fts_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_ati_fts_types.h b/src/jsd_ati_fts_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_common_device_types.c b/src/jsd_common_device_types.c old mode 100644 new mode 100755 diff --git a/src/jsd_common_device_types.h b/src/jsd_common_device_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_egd.c b/src/jsd_egd.c old mode 100644 new mode 100755 diff --git a/src/jsd_egd.h b/src/jsd_egd.h old mode 100644 new mode 100755 diff --git a/src/jsd_egd_pub.h b/src/jsd_egd_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_egd_types.h b/src/jsd_egd_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el2124.c b/src/jsd_el2124.c old mode 100644 new mode 100755 diff --git a/src/jsd_el2124.h b/src/jsd_el2124.h old mode 100644 new mode 100755 diff --git a/src/jsd_el2124_pub.h b/src/jsd_el2124_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el2124_types.h b/src/jsd_el2124_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3104.c b/src/jsd_el3104.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3104.h b/src/jsd_el3104.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3104_pub.h b/src/jsd_el3104_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3104_types.h b/src/jsd_el3104_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3162.c b/src/jsd_el3162.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3162.h b/src/jsd_el3162.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3162_pub.h b/src/jsd_el3162_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3162_types.h b/src/jsd_el3162_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3202.c b/src/jsd_el3202.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3202.h b/src/jsd_el3202.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3202_pub.h b/src/jsd_el3202_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3202_types.h b/src/jsd_el3202_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3208.c b/src/jsd_el3208.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3208.h b/src/jsd_el3208.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3208_pub.h b/src/jsd_el3208_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3208_types.h b/src/jsd_el3208_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3318.c b/src/jsd_el3318.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3318.h b/src/jsd_el3318.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3318_pub.h b/src/jsd_el3318_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3318_types.h b/src/jsd_el3318_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3356.c b/src/jsd_el3356.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3356.h b/src/jsd_el3356.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3356_pub.h b/src/jsd_el3356_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3356_types.h b/src/jsd_el3356_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3602.c b/src/jsd_el3602.c old mode 100644 new mode 100755 diff --git a/src/jsd_el3602.h b/src/jsd_el3602.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3602_pub.h b/src/jsd_el3602_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el3602_types.h b/src/jsd_el3602_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el4102.c b/src/jsd_el4102.c old mode 100644 new mode 100755 diff --git a/src/jsd_el4102.h b/src/jsd_el4102.h old mode 100644 new mode 100755 diff --git a/src/jsd_el4102_pub.h b/src/jsd_el4102_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_el4102_types.h b/src/jsd_el4102_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index d9df37b..44b5fce 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -402,8 +402,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; - + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; switch (state->transmit_state) { case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: @@ -411,20 +410,19 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { { MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); state->timer_start_sec = jsd_time_get_mono_time_sec(); // Reset user transmit variable state->user_requests_to_transmit_data = false; + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); } else if (state->user_requests_to_transmit_data_persistently) { // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); } - - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + break; case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: @@ -605,7 +603,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { case JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION: { - // Normal operation state machine state + // Normal operation state machine state // receive serial data if (jsd_el6001_receive_data(self, slave_id) != 0) { diff --git a/src/jsd_elmo_common.c b/src/jsd_elmo_common.c old mode 100644 new mode 100755 diff --git a/src/jsd_elmo_common.h b/src/jsd_elmo_common.h old mode 100644 new mode 100755 diff --git a/src/jsd_elmo_common_types.h b/src/jsd_elmo_common_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_epd.c b/src/jsd_epd.c old mode 100644 new mode 100755 diff --git a/src/jsd_epd.h b/src/jsd_epd.h old mode 100644 new mode 100755 diff --git a/src/jsd_epd_pub.h b/src/jsd_epd_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_epd_types.h b/src/jsd_epd_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_error_cirq.c b/src/jsd_error_cirq.c old mode 100644 new mode 100755 diff --git a/src/jsd_error_cirq.h b/src/jsd_error_cirq.h old mode 100644 new mode 100755 diff --git a/src/jsd_ild1900.c b/src/jsd_ild1900.c old mode 100644 new mode 100755 diff --git a/src/jsd_ild1900.h b/src/jsd_ild1900.h old mode 100644 new mode 100755 diff --git a/src/jsd_ild1900_pub.h b/src/jsd_ild1900_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_ild1900_types.h b/src/jsd_ild1900_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_include_defs.h b/src/jsd_include_defs.h old mode 100644 new mode 100755 diff --git a/src/jsd_jed0101.c b/src/jsd_jed0101.c old mode 100644 new mode 100755 diff --git a/src/jsd_jed0101.h b/src/jsd_jed0101.h old mode 100644 new mode 100755 diff --git a/src/jsd_jed0101_pub.h b/src/jsd_jed0101_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_jed0101_types.h b/src/jsd_jed0101_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_jed0200.c b/src/jsd_jed0200.c old mode 100644 new mode 100755 diff --git a/src/jsd_jed0200.h b/src/jsd_jed0200.h old mode 100644 new mode 100755 diff --git a/src/jsd_jed0200_pub.h b/src/jsd_jed0200_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_jed0200_types.h b/src/jsd_jed0200_types.h old mode 100644 new mode 100755 diff --git a/src/jsd_print.h b/src/jsd_print.h index 9f1e72f..7089310 100644 --- a/src/jsd_print.h +++ b/src/jsd_print.h @@ -5,35 +5,54 @@ extern "C" { #endif -#include +#include "jsd/jsd_time.h" +#include "cfw/cfw_log.h" + #include -#ifdef DEBUG -#define MSG_DEBUG(M, ...) \ - fprintf(stderr, "[ DEBUG ] [%lf] (%s:%d) " M "\n", jsd_time_get_time_sec(), \ - __FILE__, __LINE__, ##__VA_ARGS__) +#if CFW_LOG_VERBOSITY >= 1 +#define ERROR(M, ...) \ + cfw_log_print(CFW_ERROR, __FILE__, __LINE__, M, ##__VA_ARGS__) #else -#define MSG_DEBUG(M, ...) +#define ERROR(M, ...) \ + do { \ + } while (0) #endif -#define MSG(M, ...) \ - fprintf(stderr, "[ INFO ] [%lf] (%s:%d) " M "\n", jsd_time_get_time_sec(), \ - __FILE__, __LINE__, ##__VA_ARGS__) - -#define WARNING(M, ...) \ - fprintf(stderr, "\033[1;33m[ WARN ] [%lf] (%s:%d) " M "\033[0m\n", \ - jsd_time_get_time_sec(), __FILE__, __LINE__, ##__VA_ARGS__) +#if CFW_LOG_VERBOSITY >= 2 +#define WARNING(M, ...) \ + cfw_log_print(CFW_WARN, __FILE__, __LINE__, M, ##__VA_ARGS__) +#else +#define WARNING(M, ...) \ + do { \ + } while (0) +#endif -#define ERROR(M, ...) \ - fprintf(stderr, "\033[1;31m[ ERROR ] [%lf] (%s:%d) " M "\033[0m\n", \ - jsd_time_get_time_sec(), __FILE__, __LINE__, ##__VA_ARGS__) +#if CFW_LOG_VERBOSITY >=3 +#define MSG(M, ...) \ + cfw_log_print(CFW_INFO, __FILE__, __LINE__, M, ##__VA_ARGS__) +#define SUCCESS(M, ...) \ + cfw_log_print(CFW_INFO, __FILE__, __LINE__, M, ##__VA_ARGS__) +#else +#define MSG(M, ...) \ + do { \ + } while (0) +#define SUCCESS(M, ...) \ + do { \ + } while (0) +#endif -#define SUCCESS(M, ...) \ - fprintf(stderr, "\033[1;32m[SUCCESS] [%lf] (%s:%d) " M "\033[0m\n", \ - jsd_time_get_time_sec(), __FILE__, __LINE__, ##__VA_ARGS__) +#if CFW_LOG_VERBOSITY >= 4 +#define MSG_DEBUG(M, ...) \ + cfw_log_print(CFW_DEBUG, __FILE__, __LINE__, M, ##__VA_ARGS__) +#else +#define MSG_DEBUG(M, ...) \ + do { \ + } while (0) +#endif #ifdef __cplusplus } #endif -#endif \ No newline at end of file +#endif diff --git a/src/jsd_pub.h b/src/jsd_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_sdo.c b/src/jsd_sdo.c old mode 100644 new mode 100755 diff --git a/src/jsd_sdo.h b/src/jsd_sdo.h old mode 100644 new mode 100755 diff --git a/src/jsd_sdo_pub.h b/src/jsd_sdo_pub.h old mode 100644 new mode 100755 diff --git a/src/jsd_time.h b/src/jsd_time.h old mode 100644 new mode 100755 diff --git a/src/jsd_timer.c b/src/jsd_timer.c old mode 100644 new mode 100755 diff --git a/src/jsd_timer.h b/src/jsd_timer.h old mode 100644 new mode 100755 diff --git a/src/jsd_types.h b/src/jsd_types.h old mode 100644 new mode 100755 diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt old mode 100644 new mode 100755 diff --git a/test/device/jsd_ati_fts_test.c b/test/device/jsd_ati_fts_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_beckhoff_latency_test.c b/test/device/jsd_beckhoff_latency_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_device_test_template.c b/test/device/jsd_device_test_template.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_egd_csp_sine_test.c b/test/device/jsd_egd_csp_sine_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_egd_test.c b/test/device/jsd_egd_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el2124_test.c b/test/device/jsd_el2124_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3104_test.c b/test/device/jsd_el3104_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3162_test.c b/test/device/jsd_el3162_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3202_test.c b/test/device/jsd_el3202_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3208_test.c b/test/device/jsd_el3208_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3318_test.c b/test/device/jsd_el3318_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3356_test.c b/test/device/jsd_el3356_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el3602_test.c b/test/device/jsd_el3602_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_el4102_test.c b/test/device/jsd_el4102_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_epd_csp_sine_test.c b/test/device/jsd_epd_csp_sine_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_epd_cst_test.c b/test/device/jsd_epd_cst_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_epd_csv_sine_test.c b/test/device/jsd_epd_csv_sine_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_epd_prof_pos_test.c b/test/device/jsd_epd_prof_pos_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_epd_prof_torque_test.c b/test/device/jsd_epd_prof_torque_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_epd_prof_vel_test.c b/test/device/jsd_epd_prof_vel_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_ild1900_test.c b/test/device/jsd_ild1900_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_jed0101_test.c b/test/device/jsd_jed0101_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_jed0200_test.c b/test/device/jsd_jed0200_test.c old mode 100644 new mode 100755 diff --git a/test/device/jsd_minimal_example_el3602.c b/test/device/jsd_minimal_example_el3602.c old mode 100644 new mode 100755 diff --git a/test/jsd_test_utils.c b/test/jsd_test_utils.c old mode 100644 new mode 100755 diff --git a/test/jsd_test_utils.h b/test/jsd_test_utils.h old mode 100644 new mode 100755 diff --git a/test/unit/jsd_alloc_free_test.c b/test/unit/jsd_alloc_free_test.c old mode 100644 new mode 100755 diff --git a/test/unit/jsd_epd_lc_to_do_test.c b/test/unit/jsd_epd_lc_to_do_test.c old mode 100644 new mode 100755 diff --git a/test/unit/jsd_error_cirq_test.c b/test/unit/jsd_error_cirq_test.c old mode 100644 new mode 100755 diff --git a/test/unit/jsd_soem_init_close_test.c b/test/unit/jsd_soem_init_close_test.c old mode 100644 new mode 100755 diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt old mode 100644 new mode 100755 diff --git a/tools/jsd_egd_tlc_tty.c b/tools/jsd_egd_tlc_tty.c old mode 100644 new mode 100755 diff --git a/tools/jsd_slaveinfo.c b/tools/jsd_slaveinfo.c old mode 100644 new mode 100755 From 352d0f3b9526f5a8bf230ced1d084909c1726504 Mon Sep 17 00:00:00 2001 From: Casah Admin Date: Wed, 28 Jun 2023 11:42:08 -0700 Subject: [PATCH 25/37] Revert "fixing el6001 driver" This reverts commit d4fff0b33fc0a7c6f67519076682c4e62d6645ca. --- .clang-format | 0 .doxyfile.in | 0 .gitignore | 0 CHANGELOG.md | 0 CMakeLists.txt | 0 LICENSE.md | 0 README.md | 0 TROUBLESHOOTING.md | 0 docs/JPL-logo-color.png | Bin src/CMakeLists.txt | 0 src/jsd.c | 0 src/jsd.h | 0 src/jsd_ati_fts.c | 0 src/jsd_ati_fts.h | 0 src/jsd_ati_fts_pub.h | 0 src/jsd_ati_fts_types.h | 0 src/jsd_common_device_types.c | 0 src/jsd_common_device_types.h | 0 src/jsd_egd.c | 0 src/jsd_egd.h | 0 src/jsd_egd_pub.h | 0 src/jsd_egd_types.h | 0 src/jsd_el2124.c | 0 src/jsd_el2124.h | 0 src/jsd_el2124_pub.h | 0 src/jsd_el2124_types.h | 0 src/jsd_el3104.c | 0 src/jsd_el3104.h | 0 src/jsd_el3104_pub.h | 0 src/jsd_el3104_types.h | 0 src/jsd_el3162.c | 0 src/jsd_el3162.h | 0 src/jsd_el3162_pub.h | 0 src/jsd_el3162_types.h | 0 src/jsd_el3202.c | 0 src/jsd_el3202.h | 0 src/jsd_el3202_pub.h | 0 src/jsd_el3202_types.h | 0 src/jsd_el3208.c | 0 src/jsd_el3208.h | 0 src/jsd_el3208_pub.h | 0 src/jsd_el3208_types.h | 0 src/jsd_el3318.c | 0 src/jsd_el3318.h | 0 src/jsd_el3318_pub.h | 0 src/jsd_el3318_types.h | 0 src/jsd_el3356.c | 0 src/jsd_el3356.h | 0 src/jsd_el3356_pub.h | 0 src/jsd_el3356_types.h | 0 src/jsd_el3602.c | 0 src/jsd_el3602.h | 0 src/jsd_el3602_pub.h | 0 src/jsd_el3602_types.h | 0 src/jsd_el4102.c | 0 src/jsd_el4102.h | 0 src/jsd_el4102_pub.h | 0 src/jsd_el4102_types.h | 0 src/jsd_el6001.c | 12 +++-- src/jsd_elmo_common.c | 0 src/jsd_elmo_common.h | 0 src/jsd_elmo_common_types.h | 0 src/jsd_epd.c | 0 src/jsd_epd.h | 0 src/jsd_epd_pub.h | 0 src/jsd_epd_types.h | 0 src/jsd_error_cirq.c | 0 src/jsd_error_cirq.h | 0 src/jsd_ild1900.c | 0 src/jsd_ild1900.h | 0 src/jsd_ild1900_pub.h | 0 src/jsd_ild1900_types.h | 0 src/jsd_include_defs.h | 0 src/jsd_jed0101.c | 0 src/jsd_jed0101.h | 0 src/jsd_jed0101_pub.h | 0 src/jsd_jed0101_types.h | 0 src/jsd_jed0200.c | 0 src/jsd_jed0200.h | 0 src/jsd_jed0200_pub.h | 0 src/jsd_jed0200_types.h | 0 src/jsd_print.h | 59 ++++++++--------------- src/jsd_pub.h | 0 src/jsd_sdo.c | 0 src/jsd_sdo.h | 0 src/jsd_sdo_pub.h | 0 src/jsd_time.h | 0 src/jsd_timer.c | 0 src/jsd_timer.h | 0 src/jsd_types.h | 0 test/CMakeLists.txt | 0 test/device/jsd_ati_fts_test.c | 0 test/device/jsd_beckhoff_latency_test.c | 0 test/device/jsd_device_test_template.c | 0 test/device/jsd_egd_csp_sine_test.c | 0 test/device/jsd_egd_test.c | 0 test/device/jsd_el2124_test.c | 0 test/device/jsd_el3104_test.c | 0 test/device/jsd_el3162_test.c | 0 test/device/jsd_el3202_test.c | 0 test/device/jsd_el3208_test.c | 0 test/device/jsd_el3318_test.c | 0 test/device/jsd_el3356_test.c | 0 test/device/jsd_el3602_test.c | 0 test/device/jsd_el4102_test.c | 0 test/device/jsd_epd_csp_sine_test.c | 0 test/device/jsd_epd_cst_test.c | 0 test/device/jsd_epd_csv_sine_test.c | 0 test/device/jsd_epd_prof_pos_test.c | 0 test/device/jsd_epd_prof_torque_test.c | 0 test/device/jsd_epd_prof_vel_test.c | 0 test/device/jsd_ild1900_test.c | 0 test/device/jsd_jed0101_test.c | 0 test/device/jsd_jed0200_test.c | 0 test/device/jsd_minimal_example_el3602.c | 0 test/jsd_test_utils.c | 0 test/jsd_test_utils.h | 0 test/unit/jsd_alloc_free_test.c | 0 test/unit/jsd_epd_lc_to_do_test.c | 0 test/unit/jsd_error_cirq_test.c | 0 test/unit/jsd_soem_init_close_test.c | 0 tools/CMakeLists.txt | 0 tools/jsd_egd_tlc_tty.c | 0 tools/jsd_slaveinfo.c | 0 124 files changed, 27 insertions(+), 44 deletions(-) mode change 100755 => 100644 .clang-format mode change 100755 => 100644 .doxyfile.in mode change 100755 => 100644 .gitignore mode change 100755 => 100644 CHANGELOG.md mode change 100755 => 100644 CMakeLists.txt mode change 100755 => 100644 LICENSE.md mode change 100755 => 100644 README.md mode change 100755 => 100644 TROUBLESHOOTING.md mode change 100755 => 100644 docs/JPL-logo-color.png mode change 100755 => 100644 src/CMakeLists.txt mode change 100755 => 100644 src/jsd.c mode change 100755 => 100644 src/jsd.h mode change 100755 => 100644 src/jsd_ati_fts.c mode change 100755 => 100644 src/jsd_ati_fts.h mode change 100755 => 100644 src/jsd_ati_fts_pub.h mode change 100755 => 100644 src/jsd_ati_fts_types.h mode change 100755 => 100644 src/jsd_common_device_types.c mode change 100755 => 100644 src/jsd_common_device_types.h mode change 100755 => 100644 src/jsd_egd.c mode change 100755 => 100644 src/jsd_egd.h mode change 100755 => 100644 src/jsd_egd_pub.h mode change 100755 => 100644 src/jsd_egd_types.h mode change 100755 => 100644 src/jsd_el2124.c mode change 100755 => 100644 src/jsd_el2124.h mode change 100755 => 100644 src/jsd_el2124_pub.h mode change 100755 => 100644 src/jsd_el2124_types.h mode change 100755 => 100644 src/jsd_el3104.c mode change 100755 => 100644 src/jsd_el3104.h mode change 100755 => 100644 src/jsd_el3104_pub.h mode change 100755 => 100644 src/jsd_el3104_types.h mode change 100755 => 100644 src/jsd_el3162.c mode change 100755 => 100644 src/jsd_el3162.h mode change 100755 => 100644 src/jsd_el3162_pub.h mode change 100755 => 100644 src/jsd_el3162_types.h mode change 100755 => 100644 src/jsd_el3202.c mode change 100755 => 100644 src/jsd_el3202.h mode change 100755 => 100644 src/jsd_el3202_pub.h mode change 100755 => 100644 src/jsd_el3202_types.h mode change 100755 => 100644 src/jsd_el3208.c mode change 100755 => 100644 src/jsd_el3208.h mode change 100755 => 100644 src/jsd_el3208_pub.h mode change 100755 => 100644 src/jsd_el3208_types.h mode change 100755 => 100644 src/jsd_el3318.c mode change 100755 => 100644 src/jsd_el3318.h mode change 100755 => 100644 src/jsd_el3318_pub.h mode change 100755 => 100644 src/jsd_el3318_types.h mode change 100755 => 100644 src/jsd_el3356.c mode change 100755 => 100644 src/jsd_el3356.h mode change 100755 => 100644 src/jsd_el3356_pub.h mode change 100755 => 100644 src/jsd_el3356_types.h mode change 100755 => 100644 src/jsd_el3602.c mode change 100755 => 100644 src/jsd_el3602.h mode change 100755 => 100644 src/jsd_el3602_pub.h mode change 100755 => 100644 src/jsd_el3602_types.h mode change 100755 => 100644 src/jsd_el4102.c mode change 100755 => 100644 src/jsd_el4102.h mode change 100755 => 100644 src/jsd_el4102_pub.h mode change 100755 => 100644 src/jsd_el4102_types.h mode change 100755 => 100644 src/jsd_elmo_common.c mode change 100755 => 100644 src/jsd_elmo_common.h mode change 100755 => 100644 src/jsd_elmo_common_types.h mode change 100755 => 100644 src/jsd_epd.c mode change 100755 => 100644 src/jsd_epd.h mode change 100755 => 100644 src/jsd_epd_pub.h mode change 100755 => 100644 src/jsd_epd_types.h mode change 100755 => 100644 src/jsd_error_cirq.c mode change 100755 => 100644 src/jsd_error_cirq.h mode change 100755 => 100644 src/jsd_ild1900.c mode change 100755 => 100644 src/jsd_ild1900.h mode change 100755 => 100644 src/jsd_ild1900_pub.h mode change 100755 => 100644 src/jsd_ild1900_types.h mode change 100755 => 100644 src/jsd_include_defs.h mode change 100755 => 100644 src/jsd_jed0101.c mode change 100755 => 100644 src/jsd_jed0101.h mode change 100755 => 100644 src/jsd_jed0101_pub.h mode change 100755 => 100644 src/jsd_jed0101_types.h mode change 100755 => 100644 src/jsd_jed0200.c mode change 100755 => 100644 src/jsd_jed0200.h mode change 100755 => 100644 src/jsd_jed0200_pub.h mode change 100755 => 100644 src/jsd_jed0200_types.h mode change 100755 => 100644 src/jsd_pub.h mode change 100755 => 100644 src/jsd_sdo.c mode change 100755 => 100644 src/jsd_sdo.h mode change 100755 => 100644 src/jsd_sdo_pub.h mode change 100755 => 100644 src/jsd_time.h mode change 100755 => 100644 src/jsd_timer.c mode change 100755 => 100644 src/jsd_timer.h mode change 100755 => 100644 src/jsd_types.h mode change 100755 => 100644 test/CMakeLists.txt mode change 100755 => 100644 test/device/jsd_ati_fts_test.c mode change 100755 => 100644 test/device/jsd_beckhoff_latency_test.c mode change 100755 => 100644 test/device/jsd_device_test_template.c mode change 100755 => 100644 test/device/jsd_egd_csp_sine_test.c mode change 100755 => 100644 test/device/jsd_egd_test.c mode change 100755 => 100644 test/device/jsd_el2124_test.c mode change 100755 => 100644 test/device/jsd_el3104_test.c mode change 100755 => 100644 test/device/jsd_el3162_test.c mode change 100755 => 100644 test/device/jsd_el3202_test.c mode change 100755 => 100644 test/device/jsd_el3208_test.c mode change 100755 => 100644 test/device/jsd_el3318_test.c mode change 100755 => 100644 test/device/jsd_el3356_test.c mode change 100755 => 100644 test/device/jsd_el3602_test.c mode change 100755 => 100644 test/device/jsd_el4102_test.c mode change 100755 => 100644 test/device/jsd_epd_csp_sine_test.c mode change 100755 => 100644 test/device/jsd_epd_cst_test.c mode change 100755 => 100644 test/device/jsd_epd_csv_sine_test.c mode change 100755 => 100644 test/device/jsd_epd_prof_pos_test.c mode change 100755 => 100644 test/device/jsd_epd_prof_torque_test.c mode change 100755 => 100644 test/device/jsd_epd_prof_vel_test.c mode change 100755 => 100644 test/device/jsd_ild1900_test.c mode change 100755 => 100644 test/device/jsd_jed0101_test.c mode change 100755 => 100644 test/device/jsd_jed0200_test.c mode change 100755 => 100644 test/device/jsd_minimal_example_el3602.c mode change 100755 => 100644 test/jsd_test_utils.c mode change 100755 => 100644 test/jsd_test_utils.h mode change 100755 => 100644 test/unit/jsd_alloc_free_test.c mode change 100755 => 100644 test/unit/jsd_epd_lc_to_do_test.c mode change 100755 => 100644 test/unit/jsd_error_cirq_test.c mode change 100755 => 100644 test/unit/jsd_soem_init_close_test.c mode change 100755 => 100644 tools/CMakeLists.txt mode change 100755 => 100644 tools/jsd_egd_tlc_tty.c mode change 100755 => 100644 tools/jsd_slaveinfo.c diff --git a/.clang-format b/.clang-format old mode 100755 new mode 100644 diff --git a/.doxyfile.in b/.doxyfile.in old mode 100755 new mode 100644 diff --git a/.gitignore b/.gitignore old mode 100755 new mode 100644 diff --git a/CHANGELOG.md b/CHANGELOG.md old mode 100755 new mode 100644 diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/LICENSE.md b/LICENSE.md old mode 100755 new mode 100644 diff --git a/README.md b/README.md old mode 100755 new mode 100644 diff --git a/TROUBLESHOOTING.md b/TROUBLESHOOTING.md old mode 100755 new mode 100644 diff --git a/docs/JPL-logo-color.png b/docs/JPL-logo-color.png old mode 100755 new mode 100644 diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/src/jsd.c b/src/jsd.c old mode 100755 new mode 100644 diff --git a/src/jsd.h b/src/jsd.h old mode 100755 new mode 100644 diff --git a/src/jsd_ati_fts.c b/src/jsd_ati_fts.c old mode 100755 new mode 100644 diff --git a/src/jsd_ati_fts.h b/src/jsd_ati_fts.h old mode 100755 new mode 100644 diff --git a/src/jsd_ati_fts_pub.h b/src/jsd_ati_fts_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_ati_fts_types.h b/src/jsd_ati_fts_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_common_device_types.c b/src/jsd_common_device_types.c old mode 100755 new mode 100644 diff --git a/src/jsd_common_device_types.h b/src/jsd_common_device_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_egd.c b/src/jsd_egd.c old mode 100755 new mode 100644 diff --git a/src/jsd_egd.h b/src/jsd_egd.h old mode 100755 new mode 100644 diff --git a/src/jsd_egd_pub.h b/src/jsd_egd_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_egd_types.h b/src/jsd_egd_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el2124.c b/src/jsd_el2124.c old mode 100755 new mode 100644 diff --git a/src/jsd_el2124.h b/src/jsd_el2124.h old mode 100755 new mode 100644 diff --git a/src/jsd_el2124_pub.h b/src/jsd_el2124_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el2124_types.h b/src/jsd_el2124_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3104.c b/src/jsd_el3104.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3104.h b/src/jsd_el3104.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3104_pub.h b/src/jsd_el3104_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3104_types.h b/src/jsd_el3104_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3162.c b/src/jsd_el3162.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3162.h b/src/jsd_el3162.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3162_pub.h b/src/jsd_el3162_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3162_types.h b/src/jsd_el3162_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3202.c b/src/jsd_el3202.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3202.h b/src/jsd_el3202.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3202_pub.h b/src/jsd_el3202_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3202_types.h b/src/jsd_el3202_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3208.c b/src/jsd_el3208.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3208.h b/src/jsd_el3208.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3208_pub.h b/src/jsd_el3208_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3208_types.h b/src/jsd_el3208_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3318.c b/src/jsd_el3318.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3318.h b/src/jsd_el3318.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3318_pub.h b/src/jsd_el3318_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3318_types.h b/src/jsd_el3318_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3356.c b/src/jsd_el3356.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3356.h b/src/jsd_el3356.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3356_pub.h b/src/jsd_el3356_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3356_types.h b/src/jsd_el3356_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3602.c b/src/jsd_el3602.c old mode 100755 new mode 100644 diff --git a/src/jsd_el3602.h b/src/jsd_el3602.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3602_pub.h b/src/jsd_el3602_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el3602_types.h b/src/jsd_el3602_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el4102.c b/src/jsd_el4102.c old mode 100755 new mode 100644 diff --git a/src/jsd_el4102.h b/src/jsd_el4102.h old mode 100755 new mode 100644 diff --git a/src/jsd_el4102_pub.h b/src/jsd_el4102_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_el4102_types.h b/src/jsd_el4102_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 44b5fce..d9df37b 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -402,7 +402,8 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + switch (state->transmit_state) { case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: @@ -410,19 +411,20 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { { MSG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + state->timer_start_sec = jsd_time_get_mono_time_sec(); // Reset user transmit variable state->user_requests_to_transmit_data = false; - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); } else if (state->user_requests_to_transmit_data_persistently) { // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); } - + + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); break; case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: @@ -603,7 +605,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { case JSD_EL6001_SMS_READY_FOR_SERIAL_COMMUNICATION: { - // Normal operation state machine state + // Normal operation state machine state // receive serial data if (jsd_el6001_receive_data(self, slave_id) != 0) { diff --git a/src/jsd_elmo_common.c b/src/jsd_elmo_common.c old mode 100755 new mode 100644 diff --git a/src/jsd_elmo_common.h b/src/jsd_elmo_common.h old mode 100755 new mode 100644 diff --git a/src/jsd_elmo_common_types.h b/src/jsd_elmo_common_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_epd.c b/src/jsd_epd.c old mode 100755 new mode 100644 diff --git a/src/jsd_epd.h b/src/jsd_epd.h old mode 100755 new mode 100644 diff --git a/src/jsd_epd_pub.h b/src/jsd_epd_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_epd_types.h b/src/jsd_epd_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_error_cirq.c b/src/jsd_error_cirq.c old mode 100755 new mode 100644 diff --git a/src/jsd_error_cirq.h b/src/jsd_error_cirq.h old mode 100755 new mode 100644 diff --git a/src/jsd_ild1900.c b/src/jsd_ild1900.c old mode 100755 new mode 100644 diff --git a/src/jsd_ild1900.h b/src/jsd_ild1900.h old mode 100755 new mode 100644 diff --git a/src/jsd_ild1900_pub.h b/src/jsd_ild1900_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_ild1900_types.h b/src/jsd_ild1900_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_include_defs.h b/src/jsd_include_defs.h old mode 100755 new mode 100644 diff --git a/src/jsd_jed0101.c b/src/jsd_jed0101.c old mode 100755 new mode 100644 diff --git a/src/jsd_jed0101.h b/src/jsd_jed0101.h old mode 100755 new mode 100644 diff --git a/src/jsd_jed0101_pub.h b/src/jsd_jed0101_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_jed0101_types.h b/src/jsd_jed0101_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_jed0200.c b/src/jsd_jed0200.c old mode 100755 new mode 100644 diff --git a/src/jsd_jed0200.h b/src/jsd_jed0200.h old mode 100755 new mode 100644 diff --git a/src/jsd_jed0200_pub.h b/src/jsd_jed0200_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_jed0200_types.h b/src/jsd_jed0200_types.h old mode 100755 new mode 100644 diff --git a/src/jsd_print.h b/src/jsd_print.h index 7089310..9f1e72f 100644 --- a/src/jsd_print.h +++ b/src/jsd_print.h @@ -5,54 +5,35 @@ extern "C" { #endif -#include "jsd/jsd_time.h" -#include "cfw/cfw_log.h" - +#include #include -#if CFW_LOG_VERBOSITY >= 1 -#define ERROR(M, ...) \ - cfw_log_print(CFW_ERROR, __FILE__, __LINE__, M, ##__VA_ARGS__) +#ifdef DEBUG +#define MSG_DEBUG(M, ...) \ + fprintf(stderr, "[ DEBUG ] [%lf] (%s:%d) " M "\n", jsd_time_get_time_sec(), \ + __FILE__, __LINE__, ##__VA_ARGS__) #else -#define ERROR(M, ...) \ - do { \ - } while (0) +#define MSG_DEBUG(M, ...) #endif -#if CFW_LOG_VERBOSITY >= 2 -#define WARNING(M, ...) \ - cfw_log_print(CFW_WARN, __FILE__, __LINE__, M, ##__VA_ARGS__) -#else -#define WARNING(M, ...) \ - do { \ - } while (0) -#endif +#define MSG(M, ...) \ + fprintf(stderr, "[ INFO ] [%lf] (%s:%d) " M "\n", jsd_time_get_time_sec(), \ + __FILE__, __LINE__, ##__VA_ARGS__) -#if CFW_LOG_VERBOSITY >=3 -#define MSG(M, ...) \ - cfw_log_print(CFW_INFO, __FILE__, __LINE__, M, ##__VA_ARGS__) -#define SUCCESS(M, ...) \ - cfw_log_print(CFW_INFO, __FILE__, __LINE__, M, ##__VA_ARGS__) -#else -#define MSG(M, ...) \ - do { \ - } while (0) -#define SUCCESS(M, ...) \ - do { \ - } while (0) -#endif +#define WARNING(M, ...) \ + fprintf(stderr, "\033[1;33m[ WARN ] [%lf] (%s:%d) " M "\033[0m\n", \ + jsd_time_get_time_sec(), __FILE__, __LINE__, ##__VA_ARGS__) -#if CFW_LOG_VERBOSITY >= 4 -#define MSG_DEBUG(M, ...) \ - cfw_log_print(CFW_DEBUG, __FILE__, __LINE__, M, ##__VA_ARGS__) -#else -#define MSG_DEBUG(M, ...) \ - do { \ - } while (0) -#endif +#define ERROR(M, ...) \ + fprintf(stderr, "\033[1;31m[ ERROR ] [%lf] (%s:%d) " M "\033[0m\n", \ + jsd_time_get_time_sec(), __FILE__, __LINE__, ##__VA_ARGS__) + +#define SUCCESS(M, ...) \ + fprintf(stderr, "\033[1;32m[SUCCESS] [%lf] (%s:%d) " M "\033[0m\n", \ + jsd_time_get_time_sec(), __FILE__, __LINE__, ##__VA_ARGS__) #ifdef __cplusplus } #endif -#endif +#endif \ No newline at end of file diff --git a/src/jsd_pub.h b/src/jsd_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_sdo.c b/src/jsd_sdo.c old mode 100755 new mode 100644 diff --git a/src/jsd_sdo.h b/src/jsd_sdo.h old mode 100755 new mode 100644 diff --git a/src/jsd_sdo_pub.h b/src/jsd_sdo_pub.h old mode 100755 new mode 100644 diff --git a/src/jsd_time.h b/src/jsd_time.h old mode 100755 new mode 100644 diff --git a/src/jsd_timer.c b/src/jsd_timer.c old mode 100755 new mode 100644 diff --git a/src/jsd_timer.h b/src/jsd_timer.h old mode 100755 new mode 100644 diff --git a/src/jsd_types.h b/src/jsd_types.h old mode 100755 new mode 100644 diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/test/device/jsd_ati_fts_test.c b/test/device/jsd_ati_fts_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_beckhoff_latency_test.c b/test/device/jsd_beckhoff_latency_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_device_test_template.c b/test/device/jsd_device_test_template.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_egd_csp_sine_test.c b/test/device/jsd_egd_csp_sine_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_egd_test.c b/test/device/jsd_egd_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el2124_test.c b/test/device/jsd_el2124_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3104_test.c b/test/device/jsd_el3104_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3162_test.c b/test/device/jsd_el3162_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3202_test.c b/test/device/jsd_el3202_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3208_test.c b/test/device/jsd_el3208_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3318_test.c b/test/device/jsd_el3318_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3356_test.c b/test/device/jsd_el3356_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el3602_test.c b/test/device/jsd_el3602_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_el4102_test.c b/test/device/jsd_el4102_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_epd_csp_sine_test.c b/test/device/jsd_epd_csp_sine_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_epd_cst_test.c b/test/device/jsd_epd_cst_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_epd_csv_sine_test.c b/test/device/jsd_epd_csv_sine_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_epd_prof_pos_test.c b/test/device/jsd_epd_prof_pos_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_epd_prof_torque_test.c b/test/device/jsd_epd_prof_torque_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_epd_prof_vel_test.c b/test/device/jsd_epd_prof_vel_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_ild1900_test.c b/test/device/jsd_ild1900_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_jed0101_test.c b/test/device/jsd_jed0101_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_jed0200_test.c b/test/device/jsd_jed0200_test.c old mode 100755 new mode 100644 diff --git a/test/device/jsd_minimal_example_el3602.c b/test/device/jsd_minimal_example_el3602.c old mode 100755 new mode 100644 diff --git a/test/jsd_test_utils.c b/test/jsd_test_utils.c old mode 100755 new mode 100644 diff --git a/test/jsd_test_utils.h b/test/jsd_test_utils.h old mode 100755 new mode 100644 diff --git a/test/unit/jsd_alloc_free_test.c b/test/unit/jsd_alloc_free_test.c old mode 100755 new mode 100644 diff --git a/test/unit/jsd_epd_lc_to_do_test.c b/test/unit/jsd_epd_lc_to_do_test.c old mode 100755 new mode 100644 diff --git a/test/unit/jsd_error_cirq_test.c b/test/unit/jsd_error_cirq_test.c old mode 100755 new mode 100644 diff --git a/test/unit/jsd_soem_init_close_test.c b/test/unit/jsd_soem_init_close_test.c old mode 100755 new mode 100644 diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/tools/jsd_egd_tlc_tty.c b/tools/jsd_egd_tlc_tty.c old mode 100755 new mode 100644 diff --git a/tools/jsd_slaveinfo.c b/tools/jsd_slaveinfo.c old mode 100755 new mode 100644 From c08c60edcf648d855aca427d9f8c4bddc39c8cb4 Mon Sep 17 00:00:00 2001 From: Casah Admin Date: Wed, 28 Jun 2023 11:54:17 -0700 Subject: [PATCH 26/37] fixing state machine for transmit --- src/jsd_el6001.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index d9df37b..24e51d5 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -417,14 +417,16 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Reset user transmit variable state->user_requests_to_transmit_data = false; + + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); } else if (state->user_requests_to_transmit_data_persistently) { // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - } - - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + } break; case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: From 224c8740f14980f9ba1a5fd74a126d74cd9f0700 Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 13 Jul 2023 10:03:57 -0700 Subject: [PATCH 27/37] fix for workflow for math lib import --- src/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e5f4c18..15b3d8e 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -34,8 +34,8 @@ target_include_directories( ) find_package(Threads REQUIRED) -target_link_libraries(jsd-lib - PUBLIC soem +target_link_libraries(jsd-lib + PUBLIC soem m PRIVATE Threads::Threads PRIVATE rt ) From e5174becdc5cab0a0fc1f422829c4df5472fa952 Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 13 Jul 2023 10:11:38 -0700 Subject: [PATCH 28/37] Clean up code --- src/jsd_el6001_types.h | 48 ++---------------------------------------- 1 file changed, 2 insertions(+), 46 deletions(-) diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index dd4cfbf..706366f 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -132,29 +132,7 @@ typedef struct { */ typedef struct __attribute__((__packed__)) { uint16_t controlword; //0x3003:0x01: 2byte - uint8_t data_out[JSD_EL6001_NUM_DATA_BYTES]; - // uint8_t data_out_0; //0x3003:0x02: 1byte - // uint8_t data_out_1; //0x3003:0x03 - // uint8_t data_out_2; - // uint8_t data_out_3; - // uint8_t data_out_4; - // uint8_t data_out_5; - // uint8_t data_out_6; - // uint8_t data_out_7; - // uint8_t data_out_8; - // uint8_t data_out_9; - // uint8_t data_out_10; - // uint8_t data_out_11; - // uint8_t data_out_12; - // uint8_t data_out_13; - // uint8_t data_out_14; - // uint8_t data_out_15; - // uint8_t data_out_16; - // uint8_t data_out_17; - // uint8_t data_out_18; - // uint8_t data_out_19; - // uint8_t data_out_20; - // uint8_t data_out_21; //0x3003:0x17 + uint8_t data_out[JSD_EL6001_NUM_DATA_BYTES]; //0x3003:0x02 ~ 0x3003:0x17 } jsd_el6001_rxpdo_t; /** @@ -164,29 +142,7 @@ typedef struct __attribute__((__packed__)) { */ typedef struct __attribute__((__packed__)) { uint16_t statusword; //0x3103:01 - uint8_t data_in[JSD_EL6001_NUM_DATA_BYTES]; - // uint8_t data_in_0; //0x3103:02 - // uint8_t data_in_1; - // uint8_t data_in_2; - // uint8_t data_in_3; - // uint8_t data_in_4; - // uint8_t data_in_5; - // uint8_t data_in_6; - // uint8_t data_in_7; - // uint8_t data_in_8; - // uint8_t data_in_9; - // uint8_t data_in_10; - // uint8_t data_in_11; - // uint8_t data_in_12; - // uint8_t data_in_13; - // uint8_t data_in_14; - // uint8_t data_in_15; - // uint8_t data_in_16; - // uint8_t data_in_17; - // uint8_t data_in_18; - // uint8_t data_in_19; - // uint8_t data_in_20; - // uint8_t data_in_21; //0x3103:17 + uint8_t data_in[JSD_EL6001_NUM_DATA_BYTES]; //0x3103:0x02 ~ 0x3103:0x17 } jsd_el6001_txpdo_data_t; /** From 18ce1717a9bc123ddd7aa29303daf6a4ca2aca01 Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 13 Jul 2023 10:32:08 -0700 Subject: [PATCH 29/37] Fixing persistent transmit sms --- src/jsd_el6001.c | 133 +++++++++-------------------------------------- 1 file changed, 25 insertions(+), 108 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 24e51d5..bce0ff1 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -93,20 +93,6 @@ static uint16_t jsd_el6001_toggle_controlword_bit(const jsd_t* self, uint16_t sl return self->slave_states[slave_id].el6001.controlword_user ^ (1 << bit); } -// static void jsd_el6001_write_controlword(jsd_t* self, uint16_t slave_id) { -// assert(self); -// assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - -// jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; -// jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; - -// jsd_el6001_print_controlword("Writing controlword to EtherCAT register of: ", state->controlword_user, slave_id); - -// state->controlword_terminal_last = state->controlword_terminal; -// rxpdo->controlword = state->controlword_user; - -// } - // Statuswords static bool jsd_el6001_statusword_bit_is_set(const jsd_t* self, uint16_t slave_id, int bit) { assert(self); @@ -203,12 +189,12 @@ static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { } // data control -// static bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { -// assert(self); -// assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); +static bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); -// return self->slave_states[slave_id].el6001.received_all_persistent_bytes; -// } + return self->slave_states[slave_id].el6001.received_all_persistent_bytes; +} //---------------------------------------------------------------------------// @@ -409,30 +395,22 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: if (state->user_requests_to_transmit_data) { - MSG("Confirmed user request to transmit data, setting controlword to transmit request"); + DEBUG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); + state->timer_start_sec = jsd_time_get_mono_time_sec(); // Reset user transmit variable state->user_requests_to_transmit_data = false; - - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); - } - else if (state->user_requests_to_transmit_data_persistently) - { - // Tell terminal that data is available to transmit and then transition - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); - - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); } break; case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION: { double time_since_last_transmit = jsd_time_get_mono_time_sec() - state->timer_start_sec; - if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) + if (state->timeout_active && (time_since_last_transmit > state->timeout_sec)) { ERROR("EL6001 id %d: Transmit request timed out after %f seconds while waiting for transmit confirmation.", slave_id, time_since_last_transmit); jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); @@ -442,22 +420,24 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Beckhoff terminal transmitted data. MSG_DEBUG("Transmit request accepted, data transmit confirmed"); - if (!state->user_requests_to_transmit_data_persistently) - { + if (state->user_requests_to_transmit_data_persistently){ + // Start timeout timer + state->timer_start_sec = jsd_time_get_mono_time_sec(); + // Request another transmit by toggling transmit_request + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + } + else if(!state->user_requests_to_transmit_data_persistently){ // Go back to waiting for another transmit request jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); //clear data_out_length - jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); + jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } - else if (state->user_requests_to_transmit_data_persistently) - { - // Start timeout timer - state->timer_start_sec = jsd_time_get_mono_time_sec(); - //Increment the successful transmit counter - state->autoincrement_byte++; + //Increment the successful transmit counter + if (state->autoincrement_byte >= 0) + { + jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); } - - jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER, &state->transmit_state); } } break; @@ -534,6 +514,7 @@ void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { state->controlword_terminal_last = state->controlword_terminal; + if(state->controlword_user_last != state->controlword_user){ MSG_DEBUG("Writing a controlword as it has been updated"); rxpdo->controlword = state->controlword_user; @@ -542,32 +523,9 @@ void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { if(state->controlword_user & (1 << JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)){ MSG_DEBUG("User request to transmit, populating data_out stream"); - uint8_t output_length = rxpdo->controlword >> JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0; - // TODO: check whether we can receive packed data as array + uint8_t output_length = rxpdo->controlword >> JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0; for(uint8_t i = 0; i < output_length; i++){ rxpdo->data_out[i] = state->transmit_bytes[i]; - // rxpdo->data_out_0 = state->transmit_bytes[0]; - // rxpdo->data_out_1 = state->transmit_bytes[1]; - // rxpdo->data_out_2 = state->transmit_bytes[2]; - // rxpdo->data_out_3 = state->transmit_bytes[3]; - // rxpdo->data_out_4 = state->transmit_bytes[4]; - // rxpdo->data_out_5 = state->transmit_bytes[5]; - // rxpdo->data_out_6 = state->transmit_bytes[6]; - // rxpdo->data_out_7 = state->transmit_bytes[7]; - // rxpdo->data_out_8 = state->transmit_bytes[8]; - // rxpdo->data_out_9 = state->transmit_bytes[9]; - // rxpdo->data_out_10 = state->transmit_bytes[10]; - // rxpdo->data_out_11 = state->transmit_bytes[11]; - // rxpdo->data_out_12 = state->transmit_bytes[12]; - // rxpdo->data_out_13 = state->transmit_bytes[13]; - // rxpdo->data_out_14 = state->transmit_bytes[14]; - // rxpdo->data_out_15 = state->transmit_bytes[15]; - // rxpdo->data_out_16 = state->transmit_bytes[16]; - // rxpdo->data_out_17 = state->transmit_bytes[17]; - // rxpdo->data_out_18 = state->transmit_bytes[18]; - // rxpdo->data_out_19 = state->transmit_bytes[19]; - // rxpdo->data_out_20 = state->transmit_bytes[20]; - // rxpdo->data_out_21 = state->transmit_bytes[21]; } } } @@ -615,21 +573,6 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { return; } - // // If any of the bytes to transmit have changed, write them to the bus - // size_t byte_ndx; - // for (byte_ndx = 0; byte_ndx < JSD_EL6001_NUM_DATA_BYTES; byte_ndx++) - // { - // if (state->transmit_bytes[byte_ndx] != state->transmit_bytes_prev[byte_ndx]) - // { - // // rxpdo->data_out_0 = state->transmit_bytes[byte_ndx]; - // // Write to RxPDO - // // EC_WRITE_U8( - // // self->domain_pd_output + self->offsets_output[id][JSD_EL6001_DATA_OUT_BYTE_00 + byte_ndx], - // // state->transmit_bytes[byte_ndx]); - // } - // state->transmit_bytes_prev[byte_ndx] = state->transmit_bytes[byte_ndx]; - // } - // transmit user serial data jsd_el6001_transmit_data(self, slave_id); } @@ -639,13 +582,6 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { assert(0); break; } - - // // If the controlword has changed, write it and update the "last" (most recent) value. - // if (state->controlword_user != state->controlword_user_last) - // { - // jsd_el6001_write_controlword(self, slave_id); - // state->controlword_user_last = state->controlword_user; - // } // Write slave state into RxPDO jsd_el6001_write_PDO_data(self, slave_id); @@ -698,25 +634,6 @@ int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_byt return 0; } -int jsd_el6001_set_persistent_transmit_data(jsd_t *self, uint16_t slave_id, int num_bytes_to_transmit, bool flag) { - assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - - // Set up the timer for detecting a timeout while waiting for persistent - // receive during attempt at persistent transmit - self->slave_states[slave_id].el6001.timer_start_sec = jsd_time_get_mono_time_sec(); - - // Set number of output bytes by setting bits 8-15 of the control word to that number - // Write the control word so the terminal knows number of bytes to send - jsd_el6001_set_controlword(self, slave_id, - self->slave_states[slave_id].el6001.controlword_user | (num_bytes_to_transmit << JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0)); - - // Set bool to advance transmit state machine - self->slave_states[slave_id].el6001.user_requests_to_transmit_data_persistently = flag; - - return 0; -} - /**************************************************** * Private functions ****************************************************/ From 79340f755a6131375616f07c272630dc6064c905 Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 13 Jul 2023 10:35:57 -0700 Subject: [PATCH 30/37] fixing printout --- src/jsd_el6001.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index bce0ff1..5ed8e60 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -395,7 +395,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { case JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_REQUEST_FROM_USER: if (state->user_requests_to_transmit_data) { - DEBUG("Confirmed user request to transmit data, setting controlword to transmit request"); + MSG_DEBUG("Confirmed user request to transmit data, setting controlword to transmit request"); // Tell terminal that data is available to transmit and then transition jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); jsd_el6001_transition_transmit_sms(JSD_EL6001_TRANSMIT_SMS_WAITING_FOR_TRANSMIT_CONFIRMATION, &state->transmit_state); From f74fe7662fa08ebaaa447d6971ffff1efda74976 Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 13 Jul 2023 10:38:18 -0700 Subject: [PATCH 31/37] Removing unused function --- src/jsd_el6001.c | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 5ed8e60..cface42 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -188,15 +188,6 @@ static int8_t jsd_el6001_compute_checksum(uint8_t data[], int num_bytes) { return checksum; } -// data control -static bool jsd_el6001_all_persistent_data_was_received(const jsd_t* self, uint16_t slave_id) { - assert(self); - assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - - return self->slave_states[slave_id].el6001.received_all_persistent_bytes; -} - - //---------------------------------------------------------------------------// // RECEIVE //---------------------------------------------------------------------------// From 2ba1e4528345d06cf3f3287496750c4ab3fbd6c5 Mon Sep 17 00:00:00 2001 From: David Kim Date: Thu, 13 Jul 2023 13:11:47 -0700 Subject: [PATCH 32/37] Added loopback test --- src/jsd_el6001.c | 11 ++ src/jsd_el6001_pub.h | 2 +- test/CMakeLists.txt | 5 + test/device/jsd_el6001_comm_test.c | 7 - test/device/jsd_el6001_loopback_test.c | 207 +++++++++++++++++++++++++ 5 files changed, 224 insertions(+), 8 deletions(-) create mode 100644 test/device/jsd_el6001_loopback_test.c diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index cface42..8590b0c 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -625,6 +625,17 @@ int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_byt return 0; } +int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, bool is_persistent) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + // Set bool to advance transmit state machine + self->slave_states[slave_id].el6001.user_requests_to_transmit_data_persistently = is_persistent; + MSG("Setting transmit data as persistent: %s", is_persistent? "yes" : "no"); + + return 0; +} + /**************************************************** * Private functions ****************************************************/ diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index b9ebf0a..3010976 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -47,7 +47,7 @@ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); -int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit, bool flag); +int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, bool is_persistent); #ifdef __cplusplus } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 2aa7e51..7147bea 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -121,6 +121,11 @@ if(BUILD_JSD_TESTS) jsd_test_utils.c) target_link_libraries(jsd_el6001_comm_test ${jsd_test_libs}) + add_executable(jsd_el6001_loopback_test + device/jsd_el6001_loopback_test.c + jsd_test_utils.c) + target_link_libraries(jsd_el6001_loopback_test ${jsd_test_libs}) + add_executable(jsd_ild1900_test device/jsd_ild1900_test.c jsd_test_utils.c) diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index fcb0985..4a6addb 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -187,13 +187,6 @@ int main(int argc, char* argv[]) { // sleep(1.0); jsd_timer_process(sds.jsd_timer); } - - // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); - // ecat_el6001_set_persistent_transmit_data(ecat->el6001, ID, 2/*num_bytes*/, true); - // ecat_el6001_set_timeout_sec(ecat->el6001, ID, 1.0, true); - // ecat_el6001_set_autoincrement_byte(ecat->el6001, ID, 1); - - // sds_run(&sds, ifname, "/tmp/jsd_el6001.csv"); return 0; } diff --git a/test/device/jsd_el6001_loopback_test.c b/test/device/jsd_el6001_loopback_test.c new file mode 100644 index 0000000..3a36e2b --- /dev/null +++ b/test/device/jsd_el6001_loopback_test.c @@ -0,0 +1,207 @@ +#include +#include + +// device includes as necessary by application +#include "jsd/jsd_el6001_pub.h" +#include "jsd/jsd_el6001_types.h" +#include "jsd_test_utils.h" + +#define HEX_FORMAT "0x%02X" +#define LOOP_FREQUENCY_HZ (500) // Rate to update ethercat devices +#define USER_LOOP_FREQUENCY_HZ (1) // Rate to send and receive user commands in test +#define NSEC_PER_SEC (1000000000L) +#define LOOP_PERIOD_NS (NSEC_PER_SEC / LOOP_FREQUENCY_HZ) // ns +#define USER_LOOP_RATE_SEC (1.0 / USER_LOOP_FREQUENCY_HZ) // sec +#define PRINT_RATE_HZ (1) // Hz +#define NUM_RESOLVERS (1) +#define MAX_NUM_RESOLVERS (6) +#define ID 0 +#define OP_CODE_SEND_DATA (1) +#define NUM_BYTES_BEFORE_RESOLVERS (2) +#define NUM_BYTES_PER_RESOLVER (3) +#define NUM_RESOLVER_BYTES (NUM_BYTES_PER_RESOLVER * MAX_NUM_RESOLVERS) +#define TOTAL_NUM_BYTES (NUM_BYTES_BEFORE_RESOLVERS + NUM_RESOLVER_BYTES + 1/*checksum*/) + +extern bool quit; +extern FILE* file; +uint8_t slave_id; + +void telemetry_header() { + if (!file) { + return; + } + fprintf(file, "EL6001_controlword_last, EL6001_controlword, "); + fprintf(file, "EL6001_data_out_0, EL6001_data_out_1, "); + fprintf(file, "EL6001_data_out_2, EL6001_data_out_3, "); + fprintf(file, "EL6001_data_out_4, EL6001_data_out_5, "); + fprintf(file, "EL6001_data_out_6, EL6001_data_out_7, "); + fprintf(file, "EL6001_data_out_8, EL6001_data_out_9, "); + fprintf(file, "EL6001_data_out_10, EL6001_data_out_11, "); + fprintf(file, "EL6001_data_out_12, EL6001_data_out_13, "); + fprintf(file, "EL6001_data_out_14, EL6001_data_out_15, "); + fprintf(file, "EL6001_data_out_16, EL6001_data_out_17, "); + fprintf(file, "EL6001_data_out_18, EL6001_data_out_19, "); + fprintf(file, "EL6001_data_out_20, EL6001_data_out_21, "); + + fprintf(file, "EL6001_statusword_last, EL6001_statusword, "); + fprintf(file, "EL6001_data_in_0, EL6001_data_in_1, "); + fprintf(file, "EL6001_data_in_2, EL6001_data_in_3, "); + fprintf(file, "EL6001_data_in_4, EL6001_data_in_5, "); + fprintf(file, "EL6001_data_in_6, EL6001_data_in_7, "); + fprintf(file, "EL6001_data_in_8, EL6001_data_in_9, "); + fprintf(file, "EL6001_data_in_10, EL6001_data_in_11, "); + fprintf(file, "EL6001_data_in_12, EL6001_data_in_13, "); + fprintf(file, "EL6001_data_in_14, EL6001_data_in_15, "); + fprintf(file, "EL6001_data_in_16, EL6001_data_in_17, "); + fprintf(file, "EL6001_data_in_18, EL6001_data_in_19, "); + fprintf(file, "EL6001_data_in_20, EL6001_data_in_21, "); + + fprintf(file, "\n"); +} + +void telemetry_data(void* self) { + assert(self); + + if (!file) { + return; + } + + single_device_server_t* sds = (single_device_server_t*)self; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + + fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); + fprintf(file, "%u, %u,", state->transmit_bytes[0], state->transmit_bytes[1]); + fprintf(file, "%u, %u,", state->transmit_bytes[2], state->transmit_bytes[3]); + fprintf(file, "%u, %u,", state->transmit_bytes[4], state->transmit_bytes[5]); + fprintf(file, "%u, %u,", state->transmit_bytes[6], state->transmit_bytes[7]); + fprintf(file, "%u, %u,", state->transmit_bytes[8], state->transmit_bytes[9]); + fprintf(file, "%u, %u,", state->transmit_bytes[10], state->transmit_bytes[11]); + fprintf(file, "%u, %u,", state->transmit_bytes[12], state->transmit_bytes[13]); + fprintf(file, "%u, %u,", state->transmit_bytes[14], state->transmit_bytes[15]); + fprintf(file, "%u, %u,", state->transmit_bytes[16], state->transmit_bytes[17]); + fprintf(file, "%u, %u,", state->transmit_bytes[18], state->transmit_bytes[19]); + fprintf(file, "%u, %u,", state->transmit_bytes[20], state->transmit_bytes[21]); + + fprintf(file, "%u, %u,", state->statusword_last, state->statusword); + fprintf(file, "%u, %u,", state->received_bytes[0], state->received_bytes[1]); + fprintf(file, "%u, %u,", state->received_bytes[2], state->received_bytes[3]); + fprintf(file, "%u, %u,", state->received_bytes[4], state->received_bytes[5]); + fprintf(file, "%u, %u,", state->received_bytes[6], state->received_bytes[7]); + fprintf(file, "%u, %u,", state->received_bytes[8], state->received_bytes[9]); + fprintf(file, "%u, %u,", state->received_bytes[10], state->received_bytes[11]); + fprintf(file, "%u, %u,", state->received_bytes[12], state->received_bytes[13]); + fprintf(file, "%u, %u,", state->received_bytes[14], state->received_bytes[15]); + fprintf(file, "%u, %u,", state->received_bytes[16], state->received_bytes[17]); + fprintf(file, "%u, %u,", state->received_bytes[18], state->received_bytes[19]); + fprintf(file, "%u, %u,", state->received_bytes[20], state->received_bytes[21]); + + fprintf(file, "\n"); + fflush(file); +} + +void print_info(void* self) { + assert(self); + + single_device_server_t* sds = (single_device_server_t*)self; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + MSG("Controlword_user: %u ", state->controlword_user); + MSG("Statusword: %u ", state->statusword); +} + +void extract_data(void* self) { + single_device_server_t* sds = (single_device_server_t*)self; + jsd_el6001_read(sds->jsd, slave_id); +} + +void command(void* self) { (void)self; }; + + +int main(int argc, char* argv[]) { + if (argc != 4) { + ERROR("Expecting exactly 3 arguments"); + MSG("Usage: jsd_el6001_test "); + MSG("Example: $ jsd_el6001_test eth0 2 1000"); + return 0; + } + + char* ifname = strdup(argv[1]); + slave_id = atoi(argv[2]); + uint32_t loop_freq_hz = atoi(argv[3]); + + MSG("Configuring device %s, using slave %d", ifname, slave_id); + MSG("Using frequency of %i hz", loop_freq_hz); + + single_device_server_t sds; + + sds_set_telemetry_header_callback(&sds, telemetry_header); + sds_set_telemetry_data_callback(&sds, telemetry_data); + sds_set_print_info_callback(&sds, print_info); + sds_set_extract_data_callback(&sds, extract_data); + sds_set_command_callback(&sds, command); + + sds_setup(&sds, loop_freq_hz); + + // set device configuration here + jsd_slave_config_t my_config = {0}; + + my_config.el6001.baud_rate = JSD_EL6001_BAUD_RATE_115200; + + snprintf(my_config.name, JSD_NAME_LEN, "my_el6001_device"); + my_config.configuration_active = true; + my_config.product_code = JSD_EL6001_PRODUCT_CODE; + + jsd_set_slave_config(sds.jsd, slave_id, my_config); + + if (!jsd_init(sds.jsd, ifname, 1)) { + ERROR("Could not init jsd"); + return 0; + } + + jsd_read(sds.jsd, EC_TIMEOUTRET); + + int8_t counter = 2; + const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); + + // initiate first transmit and for next time all data is received to prevent idle loop + // transmit data does not get deleted automatically + + jsd_el6001_set_persistent_transmit_data(sds.jsd, slave_id, 1); + MSG("Transmitting opcode %d and counter %d", OP_CODE_SEND_DATA, counter); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 0/*byte_number*/, 1); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 1/*byte_number*/, 0); + jsd_el6001_set_transmit_data_8bits(sds.jsd, slave_id, 2/*byte_number*/, 2); + jsd_el6001_request_transmit_data(sds.jsd, slave_id, 3/*num_bytes*/); + + while(!quit){ + jsd_read(sds.jsd, EC_TIMEOUTRET); + + // read PDOs, updates statusword + jsd_el6001_read(sds.jsd, slave_id); + + MSG("Controlword_user: %u ", state->controlword_user); + MSG("Statusword: %u ", state->statusword); + + if(state->num_bytes_received > 0){ + MSG("Received data of size %d", state->num_bytes_received); + for(int i=0; i < state->num_bytes_received; i++){ + MSG("Received data byte: %d value: %d", i, state->received_bytes[i]); + } + } + + jsd_el6001_process(sds.jsd, slave_id); + + jsd_write(sds.jsd); + + // sleep(1.0); + jsd_timer_process(sds.jsd_timer); + } + + // ecat_el6001_set_expected_num_bytes_to_receive(ecat->el6001, ID, TOTAL_NUM_BYTES); + // ecat_el6001_set_persistent_transmit_data(ecat->el6001, ID, 2/*num_bytes*/, true); + // ecat_el6001_set_timeout_sec(ecat->el6001, ID, 1.0, true); + // ecat_el6001_set_autoincrement_byte(ecat->el6001, ID, 1); + + // sds_run(&sds, ifname, "/tmp/jsd_el6001.csv"); + + return 0; +} From 8aba8c6450cafbfca0631dff0c042362af215f0f Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 23 Aug 2023 10:49:32 -0700 Subject: [PATCH 33/37] Removed unused rxpdo entries --- src/jsd_el6001.c | 2 +- src/jsd_el6001_types.h | 29 ----------------------------- 2 files changed, 1 insertion(+), 30 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 8590b0c..192d2cc 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -581,7 +581,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - assert(byte < JSD_EL6001_DATA_OUT_BYTE_21); + assert(byte < JSD_EL6001_NUM_DATA_BYTES); assert(byte >= 0); self->slave_states[slave_id].el6001.transmit_bytes[byte] = value; diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index 706366f..6bb6660 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -17,35 +17,6 @@ extern "C" { #define JSD_EL6001_STATUSWORD_INPUT_LENGTH_BIT_MASK 0xFF00 ///< Bits 8-15 define the number of input bytes available for transfer from terminal to computer -typedef enum -{ - JSD_EL6001_CONTROLWORD = 0, - JSD_EL6001_DATA_OUT_BYTE_00, - JSD_EL6001_DATA_OUT_BYTE_01, - JSD_EL6001_DATA_OUT_BYTE_02, - JSD_EL6001_DATA_OUT_BYTE_03, - JSD_EL6001_DATA_OUT_BYTE_04, - JSD_EL6001_DATA_OUT_BYTE_05, - JSD_EL6001_DATA_OUT_BYTE_06, - JSD_EL6001_DATA_OUT_BYTE_07, - JSD_EL6001_DATA_OUT_BYTE_08, - JSD_EL6001_DATA_OUT_BYTE_09, - JSD_EL6001_DATA_OUT_BYTE_10, - JSD_EL6001_DATA_OUT_BYTE_11, - JSD_EL6001_DATA_OUT_BYTE_12, - JSD_EL6001_DATA_OUT_BYTE_13, - JSD_EL6001_DATA_OUT_BYTE_14, - JSD_EL6001_DATA_OUT_BYTE_15, - JSD_EL6001_DATA_OUT_BYTE_16, - JSD_EL6001_DATA_OUT_BYTE_17, - JSD_EL6001_DATA_OUT_BYTE_18, - JSD_EL6001_DATA_OUT_BYTE_19, - JSD_EL6001_DATA_OUT_BYTE_20, - JSD_EL6001_DATA_OUT_BYTE_21, - JSD_EL6001_NUM_PDO_ENTRIES_OUTPUT, - -} jsd_el6001_rxpdo_entries_t; - typedef enum { JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST = 0, ///< Toggle to notify terminal that DataOut bytes contain number of bytes indicated via From 386b38c9dd4598a386f7c186d0947c127667d76a Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 23 Aug 2023 11:11:04 -0700 Subject: [PATCH 34/37] Added full payload transmit function --- src/jsd_el6001.c | 13 +++++++++++++ src/jsd_el6001_pub.h | 2 ++ 2 files changed, 15 insertions(+) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 192d2cc..5570583 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -589,6 +589,19 @@ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, return 0; } +int jsd_el6001_set_transmit_data_payload(jsd_t* self, uint16_t slave_id, uint8_t* data_in, uint8_t data_len) { + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + assert(data_len < JSD_EL6001_NUM_DATA_BYTES); + + uint8_t index; + for(index = 0; index < data_len; index++){ + self->slave_states[slave_id].el6001.transmit_bytes[index] = *(data_in+index*sizeof(uint8_t)); + } + + return 0; +} + int jsd_el6001_set_baud_rate(jsd_t* self, uint16_t slave_id, jsd_el6001_baud_rate_t baud_rate) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 3010976..227ff29 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -45,6 +45,8 @@ void jsd_el6001_read(jsd_t* self, uint16_t slave_id); int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); +int jsd_el6001_set_transmit_data_payload(jsd_t* self, uint16_t slave_id, uint8_t* data_in, uint8_t data_len); + int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, bool is_persistent); From 6de146733d87dfcdf22a84ee1fec48d258d6e429 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 23 Aug 2023 11:17:56 -0700 Subject: [PATCH 35/37] Updated with memcpy func, updated function description --- src/jsd_el6001.c | 30 +++--------------------------- src/jsd_el6001_pub.h | 16 ++++++++++++++++ 2 files changed, 19 insertions(+), 27 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 5570583..b0ad325 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -2,6 +2,7 @@ #include #include +#include #include "jsd/jsd.h" #include "jsd/jsd_sdo.h" @@ -469,28 +470,6 @@ void jsd_el6001_read(jsd_t* self, uint16_t slave_id) { for(int i = 0; i < JSD_EL6001_NUM_DATA_BYTES; i ++){ state->received_bytes[i] = txpdo->data_in[i]; } - // state->received_bytes[0] = txpdo->data_in_0; - // state->received_bytes[1] = txpdo->data_in_1; - // state->received_bytes[2] = txpdo->data_in_2; - // state->received_bytes[3] = txpdo->data_in_3; - // state->received_bytes[4] = txpdo->data_in_4; - // state->received_bytes[5] = txpdo->data_in_5; - // state->received_bytes[6] = txpdo->data_in_6; - // state->received_bytes[7] = txpdo->data_in_7; - // state->received_bytes[8] = txpdo->data_in_8; - // state->received_bytes[9] = txpdo->data_in_9; - // state->received_bytes[10] = txpdo->data_in_10; - // state->received_bytes[11] = txpdo->data_in_11; - // state->received_bytes[12] = txpdo->data_in_12; - // state->received_bytes[13] = txpdo->data_in_13; - // state->received_bytes[14] = txpdo->data_in_14; - // state->received_bytes[15] = txpdo->data_in_15; - // state->received_bytes[16] = txpdo->data_in_16; - // state->received_bytes[17] = txpdo->data_in_17; - // state->received_bytes[18] = txpdo->data_in_18; - // state->received_bytes[19] = txpdo->data_in_19; - // state->received_bytes[20] = txpdo->data_in_20; - // state->received_bytes[21] = txpdo->data_in_21; } void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { @@ -593,11 +572,8 @@ int jsd_el6001_set_transmit_data_payload(jsd_t* self, uint16_t slave_id, uint8_t assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); assert(data_len < JSD_EL6001_NUM_DATA_BYTES); - - uint8_t index; - for(index = 0; index < data_len; index++){ - self->slave_states[slave_id].el6001.transmit_bytes[index] = *(data_in+index*sizeof(uint8_t)); - } + + memcpy(self->slave_states[slave_id].el6001.transmit_bytes, data_in, data_len*sizeof(uint8_t)); return 0; } diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 227ff29..e979e0e 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -43,8 +43,24 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id); */ void jsd_el6001_read(jsd_t* self, uint16_t slave_id); +/** + * @brief Set a transmission buffer at specific byte index + * + * @param self pointer JSD context + * @param slave_id index of device on EtherCAT bus + * @param byte index of transmit buffer + * @param value 1byte data to be populated + */ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, uint8_t value); +/** + * @brief Set a transmission full buffer at specific byte index + * + * @param self pointer JSD context + * @param slave_id index of device on EtherCAT bus + * @param data_in pointer of array to be populated in transmit buffer + * @param data_len length of data buffer to be populated + */ int jsd_el6001_set_transmit_data_payload(jsd_t* self, uint16_t slave_id, uint8_t* data_in, uint8_t data_len); int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); From a490e02f206fea6c7048a051b52bf9f93faa7c69 Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 23 Aug 2023 11:47:19 -0700 Subject: [PATCH 36/37] Separated public and private state --- src/jsd_el6001.c | 50 +++++++++++----------- src/jsd_el6001_pub.h | 2 +- src/jsd_el6001_types.h | 30 ++++++++----- src/jsd_types.h | 2 +- test/device/jsd_el6001_comm_test.c | 50 +++++++++++----------- test/device/jsd_el6001_loopback_test.c | 58 +++++++++++++------------- test/device/jsd_el6001_test.c | 56 ++++++++++++------------- 7 files changed, 128 insertions(+), 120 deletions(-) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index b0ad325..8520f0a 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -129,7 +129,7 @@ static int jsd_el6001_check_for_faults(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_private_state_t* state = &self->slave_states[slave_id].el6001; if (state->statusword != state->statusword_last) { @@ -197,7 +197,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_private_state_t* state = &self->slave_states[slave_id].el6001; int i; int num_bytes_received = 0; @@ -251,7 +251,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { for (i = 0; i < num_bytes_received; ++i) { //state->received_bytes[] : Data is already populated while read PDO - state->persistent_received_bytes[state->num_persistent_bytes_received + i] = state->received_bytes[i]; + state->pub.persistent_received_bytes[state->num_persistent_bytes_received + i] = state->pub.received_bytes[i]; } // increment number of persistent bytes by number received on this iteration @@ -266,7 +266,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { /// Always set number of expected bytes based on the first byte of the packet state->expected_num_bytes_to_receive = ( 1 /*num_bytes byte*/ - + state->received_bytes[0] + + state->pub.received_bytes[0] + 1 /*checksum byte*/); } else{ @@ -299,7 +299,7 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // Shift the persistent bytes over by bytes_to_drop for (i = 0; i < (state->num_persistent_bytes_received - bytes_to_drop); ++i) { - state->persistent_received_bytes[i] = state->persistent_received_bytes[i + bytes_to_drop]; + state->pub.persistent_received_bytes[i] = state->pub.persistent_received_bytes[i + bytes_to_drop]; } state->num_persistent_bytes_received -= bytes_to_drop; } @@ -310,9 +310,9 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { MSG_DEBUG("EL6001 id %d: Received all expected %d bytes of data packet", slave_id, state->expected_num_bytes_to_receive); if(state->use_last_byte_as_checksum){ - expected_checksum = state->persistent_received_bytes[state->expected_num_bytes_to_receive - 1]; + expected_checksum = state->pub.persistent_received_bytes[state->expected_num_bytes_to_receive - 1]; checksum = jsd_el6001_compute_checksum( - state->persistent_received_bytes, + state->pub.persistent_received_bytes, state->expected_num_bytes_to_receive - 1/*checksum*/); if (expected_checksum != checksum) { @@ -349,8 +349,8 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { state->num_persistent_bytes_received -= state->expected_num_bytes_to_receive; for (i = 0; i < state->num_persistent_bytes_received; ++i) { - state->persistent_received_bytes[i] = - state->persistent_received_bytes[i + state->expected_num_bytes_to_receive]; + state->pub.persistent_received_bytes[i] = + state->pub.persistent_received_bytes[i + state->expected_num_bytes_to_receive]; } } } @@ -362,12 +362,12 @@ static int jsd_el6001_receive_data(jsd_t* self, uint16_t slave_id) { // Printout received data for(int i=0; i < num_bytes_received; i++){ - MSG_DEBUG("EL6001[%d]: Received data_in[%d]: %d", slave_id, i, state->received_bytes[i]); + MSG_DEBUG("EL6001[%d]: Received data_in[%d]: %d", slave_id, i, state->pub.received_bytes[i]); } } // Set for user to know number of bytes received - state->num_bytes_received = num_bytes_received; + state->pub.num_bytes_received = num_bytes_received; return ok ? 0 : -1; } @@ -380,7 +380,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_private_state_t* state = &self->slave_states[slave_id].el6001; switch (state->transmit_state) { @@ -412,13 +412,13 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { // Beckhoff terminal transmitted data. MSG_DEBUG("Transmit request accepted, data transmit confirmed"); - if (state->user_requests_to_transmit_data_persistently){ + if (state->pub.user_requests_to_transmit_data_persistently){ // Start timeout timer state->timer_start_sec = jsd_time_get_mono_time_sec(); // Request another transmit by toggling transmit_request jsd_el6001_set_controlword(self, slave_id, jsd_el6001_toggle_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); } - else if(!state->user_requests_to_transmit_data_persistently){ + else if(!state->pub.user_requests_to_transmit_data_persistently){ // Go back to waiting for another transmit request jsd_el6001_set_controlword(self, slave_id, self->slave_states[slave_id].el6001.controlword_user & 0x00FF); //clear data_out_length jsd_el6001_set_controlword(self, slave_id, jsd_el6001_clear_controlword_bit(self, slave_id, JSD_EL6001_CONTROLWORD_TRANSMIT_REQUEST)); @@ -428,7 +428,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { //Increment the successful transmit counter if (state->autoincrement_byte >= 0) { - jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->transmit_bytes[state->autoincrement_byte] + 1); + jsd_el6001_set_transmit_data_8bits(self, slave_id, state->autoincrement_byte, state->pub.transmit_bytes[state->autoincrement_byte] + 1); } } } @@ -446,7 +446,7 @@ static int jsd_el6001_transmit_data(jsd_t *self, uint16_t slave_id) { * Public functions ****************************************************/ -const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id) { +const jsd_el6001_private_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); @@ -458,7 +458,7 @@ void jsd_el6001_read(jsd_t* self, uint16_t slave_id) { assert(self); assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_private_state_t* state = &self->slave_states[slave_id].el6001; jsd_el6001_txpdo_data_t* txpdo = (jsd_el6001_txpdo_data_t*)self->ecx_context.slavelist[slave_id].inputs; @@ -468,7 +468,7 @@ void jsd_el6001_read(jsd_t* self, uint16_t slave_id) { // TODO: check whether we can receive packed data as array for(int i = 0; i < JSD_EL6001_NUM_DATA_BYTES; i ++){ - state->received_bytes[i] = txpdo->data_in[i]; + state->pub.received_bytes[i] = txpdo->data_in[i]; } } @@ -477,7 +477,7 @@ void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_private_state_t* state = &self->slave_states[slave_id].el6001; jsd_el6001_rxpdo_t* rxpdo = (jsd_el6001_rxpdo_t*)self->ecx_context.slavelist[slave_id].outputs; @@ -495,7 +495,7 @@ void jsd_el6001_write_PDO_data(jsd_t* self, uint16_t slave_id) { MSG_DEBUG("User request to transmit, populating data_out stream"); uint8_t output_length = rxpdo->controlword >> JSD_EL6001_CONTROLWORD_OUTPUT_LENGTH_0; for(uint8_t i = 0; i < output_length; i++){ - rxpdo->data_out[i] = state->transmit_bytes[i]; + rxpdo->data_out[i] = state->pub.transmit_bytes[i]; } } } @@ -505,7 +505,7 @@ void jsd_el6001_process(jsd_t* self, uint16_t slave_id) { assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); - jsd_el6001_state_t* state = &self->slave_states[slave_id].el6001; + jsd_el6001_private_state_t* state = &self->slave_states[slave_id].el6001; // check for faults in statuswords jsd_el6001_check_for_faults(self, slave_id); @@ -563,7 +563,7 @@ int jsd_el6001_set_transmit_data_8bits(jsd_t* self, uint16_t slave_id, int byte, assert(byte < JSD_EL6001_NUM_DATA_BYTES); assert(byte >= 0); - self->slave_states[slave_id].el6001.transmit_bytes[byte] = value; + self->slave_states[slave_id].el6001.pub.transmit_bytes[byte] = value; return 0; } @@ -573,7 +573,7 @@ int jsd_el6001_set_transmit_data_payload(jsd_t* self, uint16_t slave_id, uint8_t assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); assert(data_len < JSD_EL6001_NUM_DATA_BYTES); - memcpy(self->slave_states[slave_id].el6001.transmit_bytes, data_in, data_len*sizeof(uint8_t)); + memcpy(self->slave_states[slave_id].el6001.pub.transmit_bytes, data_in, data_len*sizeof(uint8_t)); return 0; } @@ -592,7 +592,7 @@ int jsd_el6001_set_baud_rate(jsd_t* self, uint16_t slave_id, jsd_el6001_baud_rat || (baud_rate == JSD_EL6001_BAUD_RATE_12000) || (baud_rate == JSD_EL6001_BAUD_RATE_14400)); - self->slave_states[slave_id].el6001.baud_rate = baud_rate; + self->slave_states[slave_id].el6001.pub.baud_rate = baud_rate; return 0; } @@ -619,7 +619,7 @@ int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, bool assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); // Set bool to advance transmit state machine - self->slave_states[slave_id].el6001.user_requests_to_transmit_data_persistently = is_persistent; + self->slave_states[slave_id].el6001.pub.user_requests_to_transmit_data_persistently = is_persistent; MSG("Setting transmit data as persistent: %s", is_persistent? "yes" : "no"); return 0; diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index e979e0e..6ff6a75 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -18,7 +18,7 @@ extern "C" { * @param slave_id Slave ID of EL6001 device * @return Pointer to EL6001 device state */ -const jsd_el6001_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); +const jsd_el6001_private_state_t* jsd_el6001_get_state(jsd_t* self, uint16_t slave_id); /** * @brief Writes the set commands into the SOEM IOmap and processes asynchronous diff --git a/src/jsd_el6001_types.h b/src/jsd_el6001_types.h index 6bb6660..241d9c2 100644 --- a/src/jsd_el6001_types.h +++ b/src/jsd_el6001_types.h @@ -145,6 +145,20 @@ typedef enum typedef struct { int baud_rate; + + uint8_t received_bytes[JSD_EL6001_NUM_DATA_BYTES]; // Data payload buffer received + uint8_t persistent_received_bytes[JSD_EL6001_MAX_NUM_DATA_BYTES]; + int num_bytes_received; + + uint8_t transmit_bytes[JSD_EL6001_NUM_DATA_BYTES]; + + bool user_requests_to_transmit_data_persistently; + +} jsd_el6001_state_t; + +typedef struct +{ + jsd_el6001_state_t pub; uint16_t statusword; uint16_t statusword_last; bool ready; @@ -154,12 +168,8 @@ typedef struct uint16_t controlword_user; uint16_t controlword_user_last; - int num_receive_bytes; - uint8_t received_bytes[JSD_EL6001_NUM_DATA_BYTES]; - int read_errors; - int num_bytes_received; - - uint8_t transmit_bytes[JSD_EL6001_NUM_DATA_BYTES]; + int read_errors; + uint8_t transmit_bytes_prev[JSD_EL6001_NUM_DATA_BYTES]; bool transmit_data; bool user_requests_to_transmit_data; @@ -172,19 +182,17 @@ typedef struct bool checksum_failed; // Persistent receiving of bytes - int expected_num_bytes_to_receive; - uint8_t persistent_received_bytes[JSD_EL6001_MAX_NUM_DATA_BYTES]; + int expected_num_bytes_to_receive; int num_persistent_bytes_received; bool received_all_persistent_bytes; bool use_first_byte_as_packet_length; bool received_first_byte_of_packet; bool use_last_byte_as_checksum; - bool user_requests_to_transmit_data_persistently; - + jsd_el6001_sms_t sms; jsd_el6001_transmit_sms_t transmit_state; -} jsd_el6001_state_t; +} jsd_el6001_private_state_t; #ifdef __cplusplus } diff --git a/src/jsd_types.h b/src/jsd_types.h index f5cff47..7864ad2 100644 --- a/src/jsd_types.h +++ b/src/jsd_types.h @@ -69,7 +69,7 @@ typedef struct { jsd_el3318_state_t el3318; jsd_el3162_state_t el3162; jsd_el4102_state_t el4102; - jsd_el6001_state_t el6001; + jsd_el6001_private_state_t el6001; jsd_ild1900_state_t ild1900; jsd_epd_private_state_t epd; }; diff --git a/test/device/jsd_el6001_comm_test.c b/test/device/jsd_el6001_comm_test.c index 4a6addb..f3dbacc 100644 --- a/test/device/jsd_el6001_comm_test.c +++ b/test/device/jsd_el6001_comm_test.c @@ -67,33 +67,33 @@ void telemetry_data(void* self) { } single_device_server_t* sds = (single_device_server_t*)self; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); - fprintf(file, "%u, %u,", state->transmit_bytes[0], state->transmit_bytes[1]); - fprintf(file, "%u, %u,", state->transmit_bytes[2], state->transmit_bytes[3]); - fprintf(file, "%u, %u,", state->transmit_bytes[4], state->transmit_bytes[5]); - fprintf(file, "%u, %u,", state->transmit_bytes[6], state->transmit_bytes[7]); - fprintf(file, "%u, %u,", state->transmit_bytes[8], state->transmit_bytes[9]); - fprintf(file, "%u, %u,", state->transmit_bytes[10], state->transmit_bytes[11]); - fprintf(file, "%u, %u,", state->transmit_bytes[12], state->transmit_bytes[13]); - fprintf(file, "%u, %u,", state->transmit_bytes[14], state->transmit_bytes[15]); - fprintf(file, "%u, %u,", state->transmit_bytes[16], state->transmit_bytes[17]); - fprintf(file, "%u, %u,", state->transmit_bytes[18], state->transmit_bytes[19]); - fprintf(file, "%u, %u,", state->transmit_bytes[20], state->transmit_bytes[21]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[0], state->pub.transmit_bytes[1]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[2], state->pub.transmit_bytes[3]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[4], state->pub.transmit_bytes[5]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[6], state->pub.transmit_bytes[7]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[8], state->pub.transmit_bytes[9]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[10], state->pub.transmit_bytes[11]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[12], state->pub.transmit_bytes[13]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[14], state->pub.transmit_bytes[15]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[16], state->pub.transmit_bytes[17]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[18], state->pub.transmit_bytes[19]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[20], state->pub.transmit_bytes[21]); fprintf(file, "%u, %u,", state->statusword_last, state->statusword); - fprintf(file, "%u, %u,", state->received_bytes[0], state->received_bytes[1]); - fprintf(file, "%u, %u,", state->received_bytes[2], state->received_bytes[3]); - fprintf(file, "%u, %u,", state->received_bytes[4], state->received_bytes[5]); - fprintf(file, "%u, %u,", state->received_bytes[6], state->received_bytes[7]); - fprintf(file, "%u, %u,", state->received_bytes[8], state->received_bytes[9]); - fprintf(file, "%u, %u,", state->received_bytes[10], state->received_bytes[11]); - fprintf(file, "%u, %u,", state->received_bytes[12], state->received_bytes[13]); - fprintf(file, "%u, %u,", state->received_bytes[14], state->received_bytes[15]); - fprintf(file, "%u, %u,", state->received_bytes[16], state->received_bytes[17]); - fprintf(file, "%u, %u,", state->received_bytes[18], state->received_bytes[19]); - fprintf(file, "%u, %u,", state->received_bytes[20], state->received_bytes[21]); + fprintf(file, "%u, %u,", state->pub.received_bytes[0], state->pub.received_bytes[1]); + fprintf(file, "%u, %u,", state->pub.received_bytes[2], state->pub.received_bytes[3]); + fprintf(file, "%u, %u,", state->pub.received_bytes[4], state->pub.received_bytes[5]); + fprintf(file, "%u, %u,", state->pub.received_bytes[6], state->pub.received_bytes[7]); + fprintf(file, "%u, %u,", state->pub.received_bytes[8], state->pub.received_bytes[9]); + fprintf(file, "%u, %u,", state->pub.received_bytes[10], state->pub.received_bytes[11]); + fprintf(file, "%u, %u,", state->pub.received_bytes[12], state->pub.received_bytes[13]); + fprintf(file, "%u, %u,", state->pub.received_bytes[14], state->pub.received_bytes[15]); + fprintf(file, "%u, %u,", state->pub.received_bytes[16], state->pub.received_bytes[17]); + fprintf(file, "%u, %u,", state->pub.received_bytes[18], state->pub.received_bytes[19]); + fprintf(file, "%u, %u,", state->pub.received_bytes[20], state->pub.received_bytes[21]); fprintf(file, "\n"); fflush(file); @@ -103,7 +103,7 @@ void print_info(void* self) { assert(self); single_device_server_t* sds = (single_device_server_t*)self; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); MSG("Controlword_user: %u ", state->controlword_user); MSG("Statusword: %u ", state->statusword); } @@ -161,7 +161,7 @@ int main(int argc, char* argv[]) { int8_t counter = 2; // bool quit = false; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); // initiate first transmit and for next time all data is received to prevent idle loop // transmit data does not get deleted automatically diff --git a/test/device/jsd_el6001_loopback_test.c b/test/device/jsd_el6001_loopback_test.c index 3a36e2b..338939a 100644 --- a/test/device/jsd_el6001_loopback_test.c +++ b/test/device/jsd_el6001_loopback_test.c @@ -67,33 +67,33 @@ void telemetry_data(void* self) { } single_device_server_t* sds = (single_device_server_t*)self; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); - fprintf(file, "%u, %u,", state->transmit_bytes[0], state->transmit_bytes[1]); - fprintf(file, "%u, %u,", state->transmit_bytes[2], state->transmit_bytes[3]); - fprintf(file, "%u, %u,", state->transmit_bytes[4], state->transmit_bytes[5]); - fprintf(file, "%u, %u,", state->transmit_bytes[6], state->transmit_bytes[7]); - fprintf(file, "%u, %u,", state->transmit_bytes[8], state->transmit_bytes[9]); - fprintf(file, "%u, %u,", state->transmit_bytes[10], state->transmit_bytes[11]); - fprintf(file, "%u, %u,", state->transmit_bytes[12], state->transmit_bytes[13]); - fprintf(file, "%u, %u,", state->transmit_bytes[14], state->transmit_bytes[15]); - fprintf(file, "%u, %u,", state->transmit_bytes[16], state->transmit_bytes[17]); - fprintf(file, "%u, %u,", state->transmit_bytes[18], state->transmit_bytes[19]); - fprintf(file, "%u, %u,", state->transmit_bytes[20], state->transmit_bytes[21]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[0], state->pub.transmit_bytes[1]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[2], state->pub.transmit_bytes[3]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[4], state->pub.transmit_bytes[5]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[6], state->pub.transmit_bytes[7]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[8], state->pub.transmit_bytes[9]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[10], state->pub.transmit_bytes[11]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[12], state->pub.transmit_bytes[13]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[14], state->pub.transmit_bytes[15]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[16], state->pub.transmit_bytes[17]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[18], state->pub.transmit_bytes[19]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[20], state->pub.transmit_bytes[21]); fprintf(file, "%u, %u,", state->statusword_last, state->statusword); - fprintf(file, "%u, %u,", state->received_bytes[0], state->received_bytes[1]); - fprintf(file, "%u, %u,", state->received_bytes[2], state->received_bytes[3]); - fprintf(file, "%u, %u,", state->received_bytes[4], state->received_bytes[5]); - fprintf(file, "%u, %u,", state->received_bytes[6], state->received_bytes[7]); - fprintf(file, "%u, %u,", state->received_bytes[8], state->received_bytes[9]); - fprintf(file, "%u, %u,", state->received_bytes[10], state->received_bytes[11]); - fprintf(file, "%u, %u,", state->received_bytes[12], state->received_bytes[13]); - fprintf(file, "%u, %u,", state->received_bytes[14], state->received_bytes[15]); - fprintf(file, "%u, %u,", state->received_bytes[16], state->received_bytes[17]); - fprintf(file, "%u, %u,", state->received_bytes[18], state->received_bytes[19]); - fprintf(file, "%u, %u,", state->received_bytes[20], state->received_bytes[21]); + fprintf(file, "%u, %u,", state->pub.received_bytes[0], state->pub.received_bytes[1]); + fprintf(file, "%u, %u,", state->pub.received_bytes[2], state->pub.received_bytes[3]); + fprintf(file, "%u, %u,", state->pub.received_bytes[4], state->pub.received_bytes[5]); + fprintf(file, "%u, %u,", state->pub.received_bytes[6], state->pub.received_bytes[7]); + fprintf(file, "%u, %u,", state->pub.received_bytes[8], state->pub.received_bytes[9]); + fprintf(file, "%u, %u,", state->pub.received_bytes[10], state->pub.received_bytes[11]); + fprintf(file, "%u, %u,", state->pub.received_bytes[12], state->pub.received_bytes[13]); + fprintf(file, "%u, %u,", state->pub.received_bytes[14], state->pub.received_bytes[15]); + fprintf(file, "%u, %u,", state->pub.received_bytes[16], state->pub.received_bytes[17]); + fprintf(file, "%u, %u,", state->pub.received_bytes[18], state->pub.received_bytes[19]); + fprintf(file, "%u, %u,", state->pub.received_bytes[20], state->pub.received_bytes[21]); fprintf(file, "\n"); fflush(file); @@ -103,7 +103,7 @@ void print_info(void* self) { assert(self); single_device_server_t* sds = (single_device_server_t*)self; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); MSG("Controlword_user: %u ", state->controlword_user); MSG("Statusword: %u ", state->statusword); } @@ -160,7 +160,7 @@ int main(int argc, char* argv[]) { jsd_read(sds.jsd, EC_TIMEOUTRET); int8_t counter = 2; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds.jsd, slave_id); // initiate first transmit and for next time all data is received to prevent idle loop // transmit data does not get deleted automatically @@ -181,10 +181,10 @@ int main(int argc, char* argv[]) { MSG("Controlword_user: %u ", state->controlword_user); MSG("Statusword: %u ", state->statusword); - if(state->num_bytes_received > 0){ - MSG("Received data of size %d", state->num_bytes_received); - for(int i=0; i < state->num_bytes_received; i++){ - MSG("Received data byte: %d value: %d", i, state->received_bytes[i]); + if(state->pub.num_bytes_received > 0){ + MSG("Received data of size %d", state->pub.num_bytes_received); + for(int i=0; i < state->pub.num_bytes_received; i++){ + MSG("Received data byte: %d value: %d", i, state->pub.received_bytes[i]); } } diff --git a/test/device/jsd_el6001_test.c b/test/device/jsd_el6001_test.c index 0633c34..1adc2e1 100644 --- a/test/device/jsd_el6001_test.c +++ b/test/device/jsd_el6001_test.c @@ -51,33 +51,33 @@ void telemetry_data(void* self) { } single_device_server_t* sds = (single_device_server_t*)self; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); - - fprintf(file, "%u, %u, ", state->controlword_user_last, state->controlword_user); - fprintf(file, "%u, %u, ", state->transmit_bytes[0], state->transmit_bytes[1]); - fprintf(file, "%u, %u, ", state->transmit_bytes[2], state->transmit_bytes[3]); - fprintf(file, "%u, %u, ", state->transmit_bytes[4], state->transmit_bytes[5]); - fprintf(file, "%u, %u, ", state->transmit_bytes[6], state->transmit_bytes[7]); - fprintf(file, "%u, %u, ", state->transmit_bytes[8], state->transmit_bytes[9]); - fprintf(file, "%u, %u, ", state->transmit_bytes[10], state->transmit_bytes[11]); - fprintf(file, "%u, %u, ", state->transmit_bytes[12], state->transmit_bytes[13]); - fprintf(file, "%u, %u, ", state->transmit_bytes[14], state->transmit_bytes[15]); - fprintf(file, "%u, %u, ", state->transmit_bytes[16], state->transmit_bytes[17]); - fprintf(file, "%u, %u, ", state->transmit_bytes[18], state->transmit_bytes[19]); - fprintf(file, "%u, %u, ", state->transmit_bytes[20], state->transmit_bytes[21]); - - fprintf(file, "%u, %u, ", state->statusword_last, state->statusword); - fprintf(file, "%u, %u, ", state->received_bytes[0], state->received_bytes[1]); - fprintf(file, "%u, %u, ", state->received_bytes[2], state->received_bytes[3]); - fprintf(file, "%u, %u, ", state->received_bytes[4], state->received_bytes[5]); - fprintf(file, "%u, %u, ", state->received_bytes[6], state->received_bytes[7]); - fprintf(file, "%u, %u, ", state->received_bytes[8], state->received_bytes[9]); - fprintf(file, "%u, %u, ", state->received_bytes[10], state->received_bytes[11]); - fprintf(file, "%u, %u, ", state->received_bytes[12], state->received_bytes[13]); - fprintf(file, "%u, %u, ", state->received_bytes[14], state->received_bytes[15]); - fprintf(file, "%u, %u, ", state->received_bytes[16], state->received_bytes[17]); - fprintf(file, "%u, %u, ", state->received_bytes[18], state->received_bytes[19]); - fprintf(file, "%u, %u, ", state->received_bytes[20], state->received_bytes[21]); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + + fprintf(file, "%u, %u,", state->controlword_user_last, state->controlword_user); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[0], state->pub.transmit_bytes[1]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[2], state->pub.transmit_bytes[3]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[4], state->pub.transmit_bytes[5]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[6], state->pub.transmit_bytes[7]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[8], state->pub.transmit_bytes[9]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[10], state->pub.transmit_bytes[11]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[12], state->pub.transmit_bytes[13]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[14], state->pub.transmit_bytes[15]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[16], state->pub.transmit_bytes[17]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[18], state->pub.transmit_bytes[19]); + fprintf(file, "%u, %u,", state->pub.transmit_bytes[20], state->pub.transmit_bytes[21]); + + fprintf(file, "%u, %u,", state->statusword_last, state->statusword); + fprintf(file, "%u, %u,", state->pub.received_bytes[0], state->pub.received_bytes[1]); + fprintf(file, "%u, %u,", state->pub.received_bytes[2], state->pub.received_bytes[3]); + fprintf(file, "%u, %u,", state->pub.received_bytes[4], state->pub.received_bytes[5]); + fprintf(file, "%u, %u,", state->pub.received_bytes[6], state->pub.received_bytes[7]); + fprintf(file, "%u, %u,", state->pub.received_bytes[8], state->pub.received_bytes[9]); + fprintf(file, "%u, %u,", state->pub.received_bytes[10], state->pub.received_bytes[11]); + fprintf(file, "%u, %u,", state->pub.received_bytes[12], state->pub.received_bytes[13]); + fprintf(file, "%u, %u,", state->pub.received_bytes[14], state->pub.received_bytes[15]); + fprintf(file, "%u, %u,", state->pub.received_bytes[16], state->pub.received_bytes[17]); + fprintf(file, "%u, %u,", state->pub.received_bytes[18], state->pub.received_bytes[19]); + fprintf(file, "%u, %u,", state->pub.received_bytes[20], state->pub.received_bytes[21]); fprintf(file, "\n"); fflush(file); @@ -87,7 +87,7 @@ void print_info(void* self) { assert(self); single_device_server_t* sds = (single_device_server_t*)self; - const jsd_el6001_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); + const jsd_el6001_private_state_t* state = jsd_el6001_get_state(sds->jsd, slave_id); MSG("Controlword_user: %u ", state->controlword_user); MSG("Statusword: %u ", state->statusword); } From 112edb58b0ffe681197f77277c0627db28b2d01e Mon Sep 17 00:00:00 2001 From: David Kim Date: Wed, 23 Aug 2023 13:22:11 -0700 Subject: [PATCH 37/37] Added read out function --- src/jsd_el6001.c | 15 +++++++++++++++ src/jsd_el6001_pub.h | 9 +++++++++ 2 files changed, 24 insertions(+) diff --git a/src/jsd_el6001.c b/src/jsd_el6001.c index 8520f0a..73f4f1b 100644 --- a/src/jsd_el6001.c +++ b/src/jsd_el6001.c @@ -625,6 +625,21 @@ int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, bool return 0; } +int jsd_el6001_read_received_data(jsd_t* self, uint16_t slave_id, uint8_t* read_buffer){ + assert(self); + assert(self->ecx_context.slavelist[slave_id].eep_id == JSD_EL6001_PRODUCT_CODE); + + if(self->slave_states[slave_id].el6001.pub.num_bytes_received > 0){ + memcpy(read_buffer, self->slave_states[slave_id].el6001.pub.received_bytes, self->slave_states[slave_id].el6001.pub.num_bytes_received); + } + else{ + MSG("There is no data received at the terminal"); + return 1; + } + + return 0; +} + /**************************************************** * Private functions ****************************************************/ diff --git a/src/jsd_el6001_pub.h b/src/jsd_el6001_pub.h index 6ff6a75..21cc5dd 100644 --- a/src/jsd_el6001_pub.h +++ b/src/jsd_el6001_pub.h @@ -66,6 +66,15 @@ int jsd_el6001_set_transmit_data_payload(jsd_t* self, uint16_t slave_id, uint8_t int jsd_el6001_request_transmit_data(jsd_t* self, uint16_t slave_id, int num_bytes_to_transmit); int jsd_el6001_set_persistent_transmit_data(jsd_t* self, uint16_t slave_id, bool is_persistent); + +/** + * @brief Readout current data buffer + * + * @param self pointer JSD context + * @param slave_id index of device on EtherCAT bus + * @param read_buffer pointer of array of received data + */ +int jsd_el6001_read_received_data(jsd_t* self, uint16_t slave_id, uint8_t* read_buffer); #ifdef __cplusplus }