From 18f3501aabdd30268c12264d6c03ce7f7dd86d5a Mon Sep 17 00:00:00 2001 From: saifullah-N Date: Sat, 28 Jan 2023 12:15:33 +0530 Subject: [PATCH 1/4] removed em-60 select option in UI --- src/js/tool-view.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/js/tool-view.js b/src/js/tool-view.js index c7d653b..b48c3fd 100644 --- a/src/js/tool-view.js +++ b/src/js/tool-view.js @@ -82,10 +82,10 @@ module.exports = { name: "OMRON MX2", unsupported: true, }, - { - id: "EM60", - name: "EM60", - }, + // { + // id: "EM60", + // name: "EM60", + // }, ], }; }, From 1974f0b583ad04744ec62595d290c473446d29cf Mon Sep 17 00:00:00 2001 From: saifullah-N Date: Sun, 29 Jan 2023 12:38:44 +0530 Subject: [PATCH 2/4] removedd all changes related to EM-60 --- src/avr/src/spindle.c | 291 ++++++++++-------- src/avr/src/spindle.h | 17 +- src/avr/src/vfd_spindle.c | 459 +++++++++++++++-------------- src/js/modbus-reg.js | 26 +- src/js/tool-view.js | 437 +++++++++++++-------------- src/pug/templates/tool-view.pug | 65 +--- src/resources/config-template.json | 4 +- 7 files changed, 656 insertions(+), 643 deletions(-) diff --git a/src/avr/src/spindle.c b/src/avr/src/spindle.c index 9610329..59826b0 100644 --- a/src/avr/src/spindle.c +++ b/src/avr/src/spindle.c @@ -33,20 +33,19 @@ #include "config.h" #include "command.h" #include "exec.h" -#include "estop.h" #include "util.h" #include "state.h" #include - -typedef struct { +typedef struct +{ float dist; float speed; } sync_speed_t; - -static struct { +static struct +{ spindle_type_t type; float override; sync_speed_t sync_speed; @@ -62,120 +61,154 @@ static struct { spindle_type_t next_type; } spindle = { - .type = SPINDLE_TYPE_DISABLED, - .override = 1, - .sync_speed = {-1, 0} -}; + .type = SPINDLE_TYPE_DISABLED, + .override = 1, + .sync_speed = {-1, 0}}; - -static float _get_power() { - switch (spindle.type) { - case SPINDLE_TYPE_DISABLED: return 0; - case SPINDLE_TYPE_PWM: return pwm_get(); - case SPINDLE_TYPE_HUANYANG: return huanyang_get(); - default: return vfd_spindle_get(); +static float _get_power() +{ + switch (spindle.type) + { + case SPINDLE_TYPE_DISABLED: + return 0; + case SPINDLE_TYPE_PWM: + return pwm_get(); + case SPINDLE_TYPE_HUANYANG: + return huanyang_get(); + default: + return vfd_spindle_get(); } } - -static float _speed_to_power(float speed) { +static float _speed_to_power(float speed) +{ bool negative = speed < 0; float power = fabs(speed * spindle.override); - if (power < spindle.min_rpm) power = 0; - else if (spindle.max_rpm <= power) power = 1; - else power *= spindle.inv_max_rpm; + if (power < spindle.min_rpm) + power = 0; + else if (spindle.max_rpm <= power) + power = 1; + else + power *= spindle.inv_max_rpm; return (negative ^ spindle.reversed) ? -power : power; } - -static void _set_speed(float speed) { +static void _set_speed(float speed) +{ spindle.speed = speed; float power = _speed_to_power(speed); - if (estop_triggered()) power = 0; + switch (spindle.type) + { + case SPINDLE_TYPE_DISABLED: + break; - switch (spindle.type) { - case SPINDLE_TYPE_DISABLED: break; - - case SPINDLE_TYPE_PWM: { + case SPINDLE_TYPE_PWM: + { // PWM speed updates must be synchronized with stepper movement spindle.sync_speed.dist = 0; spindle.sync_speed.speed = speed; break; } - case SPINDLE_TYPE_HUANYANG: huanyang_set(power); break; - default: vfd_spindle_set(power); break; + case SPINDLE_TYPE_HUANYANG: + huanyang_set(power); + break; + default: + vfd_spindle_set(power); + break; } } - -static void _deinit_cb() { +static void _deinit_cb() +{ spindle.type = spindle.next_type; spindle.next_type = SPINDLE_TYPE_DISABLED; - switch (spindle.type) { - case SPINDLE_TYPE_DISABLED: break; - case SPINDLE_TYPE_PWM: pwm_init(); break; - case SPINDLE_TYPE_HUANYANG: huanyang_init(); break; - default: vfd_spindle_init(); break; + switch (spindle.type) + { + case SPINDLE_TYPE_DISABLED: + break; + case SPINDLE_TYPE_PWM: + pwm_init(); + break; + case SPINDLE_TYPE_HUANYANG: + huanyang_init(); + break; + default: + vfd_spindle_init(); + break; } spindle_update_speed(); } - -static void _set_type(spindle_type_t type) { - if (type == spindle.type) return; +static void _set_type(spindle_type_t type) +{ + if (type == spindle.type) + return; spindle_type_t old_type = spindle.type; spindle.next_type = type; spindle.type = SPINDLE_TYPE_DISABLED; - switch (old_type) { - case SPINDLE_TYPE_DISABLED: _deinit_cb(); break; - case SPINDLE_TYPE_PWM: pwm_deinit(_deinit_cb); break; - case SPINDLE_TYPE_HUANYANG: huanyang_deinit(_deinit_cb); break; - default: vfd_spindle_deinit(_deinit_cb); break; + switch (old_type) + { + case SPINDLE_TYPE_DISABLED: + _deinit_cb(); + break; + case SPINDLE_TYPE_PWM: + pwm_deinit(_deinit_cb); + break; + case SPINDLE_TYPE_HUANYANG: + huanyang_deinit(_deinit_cb); + break; + default: + vfd_spindle_deinit(_deinit_cb); + break; } } +spindle_type_t spindle_get_type() { return spindle.type; } -spindle_type_t spindle_get_type() {return spindle.type;} - - -static power_update_t _get_power_update() { +static power_update_t _get_power_update() +{ float power = _speed_to_power(spindle.speed); // Handle dynamic power - if (state_get() == STATE_RUNNING && spindle.dynamic_power && spindle.inv_feed) { + if (state_get() == STATE_RUNNING && spindle.dynamic_power && spindle.inv_feed) + { float scale = spindle.inv_feed * exec_get_velocity(); - if (scale < 1) power *= scale; + if (scale < 1) + power *= scale; } return pwm_get_update(power); } - void spindle_load_power_updates(power_update_t updates[], float minD, - float maxD) { + float maxD) +{ float stepD = (maxD - minD) * (1.0 / POWER_MAX_UPDATES); float d = minD + 1e-3; // Starting distance - for (unsigned i = 0; i < POWER_MAX_UPDATES; i++) { + for (unsigned i = 0; i < POWER_MAX_UPDATES; i++) + { bool changed = false; d += stepD; // Ending distance for this power step - while (true) { + while (true) + { // Load new sync speed if needed and available if (spindle.sync_speed.dist < 0 && command_peek() == COMMAND_sync_speed) spindle.sync_speed = *(sync_speed_t *)(command_next() + 1); // Exit if we don't have a speed or it's not ready to be set - if (spindle.sync_speed.dist == -1 || d < spindle.sync_speed.dist) break; + if (spindle.sync_speed.dist == -1 || d < spindle.sync_speed.dist) + break; // Load sync speed spindle.sync_speed.dist = -1; // Mark done @@ -183,127 +216,138 @@ void spindle_load_power_updates(power_update_t updates[], float minD, changed = true; } - if (spindle.type == SPINDLE_TYPE_PWM) updates[i] = _get_power_update(); - else { + if (spindle.type == SPINDLE_TYPE_PWM) + updates[i] = _get_power_update(); + else + { updates[i].state = POWER_IGNORE; - if (changed) spindle_update_speed(); + if (changed) + spindle_update_speed(); } } } - // Called from hi-priority stepper interrupt -void spindle_update(const power_update_t &update) {pwm_update(update);} -void spindle_update_speed() {_set_speed(spindle.speed);} - +void spindle_update(const power_update_t &update) { pwm_update(update); } +void spindle_update_speed() { _set_speed(spindle.speed); } // Called from lo-priority stepper interrupt -void spindle_idle() { - if (spindle.sync_speed.dist != -1) { +void spindle_idle() +{ + if (spindle.sync_speed.dist != -1) + { spindle.sync_speed.dist = -1; // Mark done spindle.speed = spindle.sync_speed.speed; - if (spindle.type == SPINDLE_TYPE_PWM) spindle_update(_get_power_update()); - else spindle_update_speed(); + if (spindle.type == SPINDLE_TYPE_PWM) + spindle_update(_get_power_update()); + else + spindle_update_speed(); } } - -void spindle_stop() {_set_speed(0);} // Only called when steppers have halted -void spindle_estop() {_set_type(SPINDLE_TYPE_DISABLED);} - +void spindle_stop() { _set_speed(0); } // Only called when steppers have halted +void spindle_estop() { _set_type(SPINDLE_TYPE_DISABLED); } // Var callbacks -uint8_t get_tool_type() {return spindle.type;} -void set_tool_type(uint8_t value) {_set_type((spindle_type_t)value);} -bool get_tool_reversed() {return spindle.reversed;} +uint8_t get_tool_type() { return spindle.type; } +void set_tool_type(uint8_t value) { _set_type((spindle_type_t)value); } +bool get_tool_reversed() { return spindle.reversed; } - -void set_tool_reversed(bool reversed) { - if (spindle.reversed == reversed) return; +void set_tool_reversed(bool reversed) +{ + if (spindle.reversed == reversed) + return; spindle.reversed = reversed; spindle_update_speed(); } +float get_speed() { return _get_power() * spindle.max_rpm; } +float get_max_spin() { return spindle.max_rpm; } -float get_speed() {return _get_power() * spindle.max_rpm;} -float get_max_spin() {return spindle.max_rpm;} - - -void set_max_spin(float value) { - if (spindle.max_rpm != value) { +void set_max_spin(float value) +{ + if (spindle.max_rpm != value) + { spindle.max_rpm = value; spindle.inv_max_rpm = 1 / value; spindle_update_speed(); } } +float get_min_spin() { return spindle.min_rpm; } -float get_min_spin() {return spindle.min_rpm;} - - -void set_min_spin(float value) { - if (spindle.min_rpm != value) { +void set_min_spin(float value) +{ + if (spindle.min_rpm != value) + { spindle.min_rpm = value; spindle_update_speed(); } } - -uint16_t get_spindle_status() { - switch (spindle.type) { - case SPINDLE_TYPE_DISABLED: return 0; - case SPINDLE_TYPE_PWM: return 0; - case SPINDLE_TYPE_HUANYANG: return huanyang_get_status(); - default: return vfd_get_status(); +uint16_t get_spindle_status() +{ + switch (spindle.type) + { + case SPINDLE_TYPE_DISABLED: + return 0; + case SPINDLE_TYPE_PWM: + return 0; + case SPINDLE_TYPE_HUANYANG: + return huanyang_get_status(); + default: + return vfd_get_status(); } } +uint16_t get_speed_override() { return spindle.override * 1000; } -uint16_t get_speed_override() {return spindle.override * 1000;} - - -void set_speed_override(uint16_t value) { +void set_speed_override(uint16_t value) +{ value *= 0.001; - if (spindle.override != value) { + if (spindle.override != value) + { spindle.override = value; spindle_update_speed(); } } +bool get_dynamic_power() { return spindle.dynamic_power; } -bool get_dynamic_power() {return spindle.dynamic_power;} - - -void set_dynamic_power(bool enable) { - if (spindle.dynamic_power != enable) { +void set_dynamic_power(bool enable) +{ + if (spindle.dynamic_power != enable) + { spindle.dynamic_power = enable; spindle_update_speed(); } } +float get_inverse_feed() { return spindle.inv_feed; } -float get_inverse_feed() {return spindle.inv_feed;} - - -void set_inverse_feed(float iF) { - if (spindle.inv_feed != iF) { +void set_inverse_feed(float iF) +{ + if (spindle.inv_feed != iF) + { spindle.inv_feed = iF; spindle_update_speed(); } } - // Command callbacks -stat_t command_sync_speed(char *cmd) { +stat_t command_sync_speed(char *cmd) +{ sync_speed_t s; cmd++; // Skip command code // Get distance and speed - if (!decode_float(&cmd, &s.dist) || s.dist < 0) return STAT_BAD_FLOAT; - if (!decode_float(&cmd, &s.speed)) return STAT_BAD_FLOAT; + if (!decode_float(&cmd, &s.dist) || s.dist < 0) + return STAT_BAD_FLOAT; + if (!decode_float(&cmd, &s.speed)) + return STAT_BAD_FLOAT; // Queue command_push(COMMAND_sync_speed, &s); @@ -311,21 +355,21 @@ stat_t command_sync_speed(char *cmd) { return STAT_OK; } +unsigned command_sync_speed_size() { return sizeof(sync_speed_t); } -unsigned command_sync_speed_size() {return sizeof(sync_speed_t);} - - -void command_sync_speed_exec(void *data) { +void command_sync_speed_exec(void *data) +{ _set_speed(((sync_speed_t *)data)->speed); } - -stat_t command_speed(char *cmd) { +stat_t command_speed(char *cmd) +{ cmd++; // Skip command code // Get speed float speed; - if (!decode_float(&cmd, &speed)) return STAT_BAD_FLOAT; + if (!decode_float(&cmd, &speed)) + return STAT_BAD_FLOAT; // Queue command_push(COMMAND_speed, &speed); @@ -333,6 +377,5 @@ stat_t command_speed(char *cmd) { return STAT_OK; } - -unsigned command_speed_size() {return sizeof(float);} -void command_speed_exec(void *data) {_set_speed(*(float *)data);} +unsigned command_speed_size() { return sizeof(float); } +void command_speed_exec(void *data) { _set_speed(*(float *)data); } \ No newline at end of file diff --git a/src/avr/src/spindle.h b/src/avr/src/spindle.h index 6b92f4a..5635fd2 100644 --- a/src/avr/src/spindle.h +++ b/src/avr/src/spindle.h @@ -30,22 +30,22 @@ #include #include - -typedef enum { +typedef enum +{ POWER_IGNORE, POWER_FORWARD, POWER_REVERSE } power_state_t; - -typedef struct { +typedef struct +{ power_state_t state; float power; uint16_t period; // Used by PWM } power_update_t; - -typedef enum { +typedef enum +{ SPINDLE_TYPE_DISABLED, SPINDLE_TYPE_PWM, SPINDLE_TYPE_HUANYANG, @@ -58,13 +58,10 @@ typedef enum { SPINDLE_TYPE_SUNFAR_E300, SPINDLE_TYPE_OMRON_MX2, SPINDLE_TYPE_V70, - SPINDLE_TYPE_EM60, } spindle_type_t; - typedef void (*deinit_cb_t)(); - spindle_type_t spindle_get_type(); void spindle_stop(); void spindle_estop(); @@ -72,4 +69,4 @@ void spindle_load_power_updates(power_update_t updates[], float minD, float maxD); void spindle_update(const power_update_t &update); void spindle_update_speed(); -void spindle_idle(); +void spindle_idle(); \ No newline at end of file diff --git a/src/avr/src/vfd_spindle.c b/src/avr/src/vfd_spindle.c index 381c604..143364e 100644 --- a/src/avr/src/vfd_spindle.c +++ b/src/avr/src/vfd_spindle.c @@ -38,8 +38,8 @@ #include #include - -typedef enum { +typedef enum +{ REG_DISABLED, REG_CONNECT_WRITE, @@ -49,7 +49,6 @@ typedef enum { REG_FREQ_SET, REG_FREQ_SIGN_SET, - REG_FREQ_SCALED_SET, REG_STOP_WRITE, REG_FWD_WRITE, @@ -64,138 +63,118 @@ typedef enum { REG_DISCONNECT_WRITE, } vfd_reg_type_t; - -typedef struct { +typedef struct +{ vfd_reg_type_t type; uint16_t addr; uint16_t value; uint8_t fails; } vfd_reg_t; - #define P(H, L) ((H) << 8 | (L)) - // NOTE, Modbus reg = AC Tech reg + 1 const vfd_reg_t ac_tech_regs[] PROGMEM = { - {REG_CONNECT_WRITE, 48, 19}, // Password unlock - {REG_CONNECT_WRITE, 1, 512}, // Manual mode - {REG_MAX_FREQ_READ, 62, 0}, // Max frequency - {REG_FREQ_SET, 40, 0}, // Frequency - {REG_STOP_WRITE, 1, 4}, // Stop drive - {REG_FWD_WRITE, 1, 128}, // Forward - {REG_FWD_WRITE, 1, 8}, // Start drive - {REG_REV_WRITE, 1, 64}, // Reverse - {REG_REV_WRITE, 1, 8}, // Start drive - {REG_FREQ_ACTECH_READ, 24, 0}, // Actual freq - {REG_DISCONNECT_WRITE, 1, 2}, // Lock controls and parameters - {REG_DISABLED}, + {REG_CONNECT_WRITE, 48, 19}, // Password unlock + {REG_CONNECT_WRITE, 1, 512}, // Manual mode + {REG_MAX_FREQ_READ, 62, 0}, // Max frequency + {REG_FREQ_SET, 40, 0}, // Frequency + {REG_STOP_WRITE, 1, 4}, // Stop drive + {REG_FWD_WRITE, 1, 128}, // Forward + {REG_FWD_WRITE, 1, 8}, // Start drive + {REG_REV_WRITE, 1, 64}, // Reverse + {REG_REV_WRITE, 1, 8}, // Start drive + {REG_FREQ_ACTECH_READ, 24, 0}, // Actual freq + {REG_DISCONNECT_WRITE, 1, 2}, // Lock controls and parameters + {REG_DISABLED}, }; - const vfd_reg_t nowforever_regs[] PROGMEM = { - {REG_MAX_FREQ_READ, 7, 0}, // Max frequency - {REG_FREQ_SET, 2305, 0}, // Frequency - {REG_STOP_WRITE, 2304, 0}, // Stop drive - {REG_FWD_WRITE, 2304, 1}, // Forward - {REG_REV_WRITE, 2304, 3}, // Reverse - {REG_FREQ_READ, 1282, 0}, // Output freq - {REG_STATUS_READ, 768, 0}, // Status - {REG_DISABLED}, + {REG_MAX_FREQ_READ, 7, 0}, // Max frequency + {REG_FREQ_SET, 2305, 0}, // Frequency + {REG_STOP_WRITE, 2304, 0}, // Stop drive + {REG_FWD_WRITE, 2304, 1}, // Forward + {REG_REV_WRITE, 2304, 3}, // Reverse + {REG_FREQ_READ, 1282, 0}, // Output freq + {REG_STATUS_READ, 768, 0}, // Status + {REG_DISABLED}, }; - const vfd_reg_t delta_vfd015m21a_regs[] PROGMEM = { - {REG_CONNECT_WRITE, 0x2002, 2}, // Reset fault - {REG_MAX_FREQ_READ, 3, 0}, // Max frequency - {REG_FREQ_SET, 0x2001, 0}, // Frequency - {REG_STOP_WRITE, 0x2000, 1}, // Stop drive - {REG_FWD_WRITE, 0x2000, 18}, // Forward - {REG_REV_WRITE, 0x2000, 34}, // Reverse - {REG_FREQ_READ, 0x2103, 0}, // Output freq - {REG_STATUS_READ, 0x2100, 0}, // Status - {REG_DISABLED}, + {REG_CONNECT_WRITE, 0x2002, 2}, // Reset fault + {REG_MAX_FREQ_READ, 3, 0}, // Max frequency + {REG_FREQ_SET, 0x2001, 0}, // Frequency + {REG_STOP_WRITE, 0x2000, 1}, // Stop drive + {REG_FWD_WRITE, 0x2000, 18}, // Forward + {REG_REV_WRITE, 0x2000, 34}, // Reverse + {REG_FREQ_READ, 0x2103, 0}, // Output freq + {REG_STATUS_READ, 0x2100, 0}, // Status + {REG_DISABLED}, }; - const vfd_reg_t yl600_regs[] PROGMEM = { - {REG_CONNECT_WRITE, 0x2000, 128}, // Reset all errors - {REG_MAX_FREQ_READ, 0x0004, 0}, // Max frequency - {REG_FREQ_SET, 0x2001, 0}, // Frequency - {REG_STOP_WRITE, 0x2000, 1}, // Stop drive - {REG_FWD_WRITE, 0x2000, 18}, // Forward - {REG_REV_WRITE, 0x2000, 34}, // Reverse - {REG_FREQ_READ, 0x200b, 0}, // Output freq - {REG_STATUS_READ, 0x2008, 0}, // Status - {REG_DISABLED}, + {REG_CONNECT_WRITE, 0x2000, 128}, // Reset all errors + {REG_MAX_FREQ_READ, 0x0004, 0}, // Max frequency + {REG_FREQ_SET, 0x2001, 0}, // Frequency + {REG_STOP_WRITE, 0x2000, 1}, // Stop drive + {REG_FWD_WRITE, 0x2000, 18}, // Forward + {REG_REV_WRITE, 0x2000, 34}, // Reverse + {REG_FREQ_READ, 0x200b, 0}, // Output freq + {REG_STATUS_READ, 0x2008, 0}, // Status + {REG_DISABLED}, }; - const vfd_reg_t fr_d700_regs[] PROGMEM = { - {REG_MAX_FREQ_READ, 1000, 0}, // Max frequency - {REG_FREQ_SET, 13, 0}, // Frequency - {REG_STOP_WRITE, 8, 1}, // Stop drive - {REG_FWD_WRITE, 8, 2}, // Forward - {REG_REV_WRITE, 8, 4}, // Reverse - {REG_FREQ_READ, 200, 0}, // Output freq - {REG_DISABLED}, + {REG_MAX_FREQ_READ, 1000, 0}, // Max frequency + {REG_FREQ_SET, 13, 0}, // Frequency + {REG_STOP_WRITE, 8, 1}, // Stop drive + {REG_FWD_WRITE, 8, 2}, // Forward + {REG_REV_WRITE, 8, 4}, // Reverse + {REG_FREQ_READ, 200, 0}, // Output freq + {REG_DISABLED}, }; - const vfd_reg_t sunfar_e300_regs[] PROGMEM = { - {REG_CONNECT_WRITE, 0x1001, 32}, // Reset all errors - {REG_MAX_FREQ_READ, 0xf004, 0}, // Max frequency F0.4 - {REG_FREQ_SET, 0x1002, 0}, // Frequency - {REG_STOP_WRITE, 0x1001, 3}, // Stop drive - {REG_FWD_WRITE, 0x1001, 1}, // Forward - {REG_REV_WRITE, 0x1001, 2}, // Reverse - {REG_FREQ_READ, 0xd000, 0}, // Output freq d.0 - {REG_STATUS_READ, 0x2000, 0}, // Status - {REG_DISABLED}, + {REG_CONNECT_WRITE, 0x1001, 32}, // Reset all errors + {REG_MAX_FREQ_READ, 0xf004, 0}, // Max frequency F0.4 + {REG_FREQ_SET, 0x1002, 0}, // Frequency + {REG_STOP_WRITE, 0x1001, 3}, // Stop drive + {REG_FWD_WRITE, 0x1001, 1}, // Forward + {REG_REV_WRITE, 0x1001, 2}, // Reverse + {REG_FREQ_READ, 0xd000, 0}, // Output freq d.0 + {REG_STATUS_READ, 0x2000, 0}, // Status + {REG_DISABLED}, }; - const vfd_reg_t omron_mx2_regs[] PROGMEM = { - {REG_CONNECT_WRITE, 0x1200, 3}, // A001 Frequency reference modbus - {REG_CONNECT_WRITE, 0x1201, 3}, // A002 Run command modbus - {REG_MAX_FREQ_FIXED, 0, 40000}, // TODO Want to use A004 max frequency - {REG_FREQ_SET, 0x0001, 0}, // F001 Frequency - {REG_STOP_WRITE, 0x1f00, 0}, // Stop drive - {REG_FWD_WRITE, 0x1f00, 2}, // Forward - {REG_REV_WRITE, 0x1f00, 6}, // Reverse - {REG_FREQ_READ, 0x1001, 0}, // D001 Output freq - {REG_STATUS_READ, 0x0004, 0}, // Status A - {REG_DISABLED}, + {REG_CONNECT_WRITE, 0x1200, 3}, // A001 Frequency reference modbus + {REG_CONNECT_WRITE, 0x1201, 3}, // A002 Run command modbus + {REG_MAX_FREQ_FIXED, 0, 40000}, // TODO Want to use A004 max frequency + {REG_FREQ_SET, 0x0001, 0}, // F001 Frequency + {REG_STOP_WRITE, 0x1f00, 0}, // Stop drive + {REG_FWD_WRITE, 0x1f00, 2}, // Forward + {REG_REV_WRITE, 0x1f00, 6}, // Reverse + {REG_FREQ_READ, 0x1001, 0}, // D001 Output freq + {REG_STATUS_READ, 0x0004, 0}, // Status A + {REG_DISABLED}, }; - const vfd_reg_t v70_regs[] PROGMEM = { - {REG_MAX_FREQ_READ, 0x0005, 0}, // Maximum operating frequency - {REG_FREQ_SET, 0x0201, 0}, // Set frequency in 0.1Hz - {REG_STOP_WRITE, 0x0200, 0}, // Stop - {REG_FWD_WRITE, 0x0200, 1}, // Run forward - {REG_REV_WRITE, 0x0200, 5}, // Run reverse - {REG_FREQ_READ, 0x0220, 0}, // Read operating frequency - {REG_STATUS_READ, 0x0210, 0}, // Read status - {REG_DISABLED}, + {REG_MAX_FREQ_READ, 0x0005, 0}, // Maximum operating frequency + {REG_FREQ_SET, 0x0201, 0}, // Set frequency in 0.1Hz + {REG_STOP_WRITE, 0x0200, 0}, // Stop + {REG_FWD_WRITE, 0x0200, 1}, // Run forward + {REG_REV_WRITE, 0x0200, 5}, // Run reverse + {REG_FREQ_READ, 0x0220, 0}, // Read operating frequency + {REG_STATUS_READ, 0x0210, 0}, // Read status + {REG_DISABLED}, }; -const vfd_reg_t em60_regs[] PROGMEM = { - {REG_MAX_FREQ_READ, 0x0007, 0}, // Read max frequency - {REG_FREQ_SCALED_SET, 0xa001, 10000}, // Set scaled frequency - {REG_FREQ_READ, 0x9000, 0}, // Read frequency - {REG_FWD_WRITE, 0xa000, 1}, // Run forward - {REG_REV_WRITE, 0xa000, 2}, // Run reverse - {REG_STOP_WRITE, 0xa000, 5}, // Stop - {REG_STATUS_READ, 0xb000, 0}, // Read status - {REG_DISABLED}, -}; - - static vfd_reg_t regs[VFDREG]; static vfd_reg_t custom_regs[VFDREG]; -static struct { +static struct +{ vfd_reg_type_t state; int8_t reg; uint8_t read_count; @@ -212,46 +191,52 @@ static struct { deinit_cb_t deinit_cb; } vfd; - -static void _disconnected() { +static void _disconnected() +{ modbus_deinit(); - if (vfd.deinit_cb) vfd.deinit_cb(); + if (vfd.deinit_cb) + vfd.deinit_cb(); vfd.deinit_cb = 0; } - -static bool _next_state() { - switch (vfd.state) { +static bool _next_state() +{ + switch (vfd.state) + { case REG_MAX_FREQ_FIXED: - if (!vfd.power) vfd.state = REG_STOP_WRITE; - else vfd.state = REG_FREQ_SET; - break; - - case REG_FREQ_SCALED_SET: - if (vfd.power < 0) vfd.state = REG_REV_WRITE; - else if (0 < vfd.power) vfd.state = REG_FWD_WRITE; - else vfd.state = REG_STOP_WRITE; + if (!vfd.power) + vfd.state = REG_STOP_WRITE; + else + vfd.state = REG_FREQ_SET; break; case REG_FREQ_SIGN_SET: - if (vfd.power < 0) vfd.state = REG_REV_WRITE; - else if (0 < vfd.power) vfd.state = REG_FWD_WRITE; - else vfd.state = REG_STOP_WRITE; + if (vfd.power < 0) + vfd.state = REG_REV_WRITE; + else if (0 < vfd.power) + vfd.state = REG_FWD_WRITE; + else + vfd.state = REG_STOP_WRITE; break; - case REG_STOP_WRITE: case REG_FWD_WRITE: case REG_REV_WRITE: + case REG_STOP_WRITE: + case REG_FWD_WRITE: + case REG_REV_WRITE: vfd.state = REG_FREQ_READ; break; case REG_STATUS_READ: - if (vfd.shutdown || estop_triggered()) vfd.state = REG_DISCONNECT_WRITE; + if (vfd.shutdown || estop_triggered()) + vfd.state = REG_DISCONNECT_WRITE; - else if (vfd.changed) { + else if (vfd.changed) + { // Update frequency and state vfd.changed = false; vfd.state = REG_MAX_FREQ_READ; - - } else { + } + else + { // Continue querying after delay vfd.state = REG_FREQ_READ; vfd.wait = rtc_get_time() + VFD_QUERY_DELAY; @@ -270,87 +255,113 @@ static bool _next_state() { return true; } - static bool _exec_command(); - -static void _next_reg() { - while (true) { +static void _next_reg() +{ + while (true) + { vfd.reg++; - if (vfd.reg == VFDREG) { + if (vfd.reg == VFDREG) + { vfd.reg = -1; vfd.read_count = 0; - if (!_next_state()) break; - - } else if (regs[vfd.reg].type == vfd.state && _exec_command()) break; + if (!_next_state()) + break; + } + else if (regs[vfd.reg].type == vfd.state && _exec_command()) + break; } } - -static void _connect() { +static void _connect() +{ vfd.state = REG_CONNECT_WRITE; vfd.reg = -1; _next_reg(); } - -static void _modbus_cb(bool ok, uint16_t addr, uint16_t value) { +static void _modbus_cb(bool ok, uint16_t addr, uint16_t value) +{ // Handle error - if (!ok) { - if (regs[vfd.reg].fails < 255) regs[vfd.reg].fails++; - if (vfd.shutdown || estop_triggered()) _disconnected(); - else _connect(); + if (!ok) + { + if (regs[vfd.reg].fails < 255) + regs[vfd.reg].fails++; + if (vfd.shutdown || estop_triggered()) + _disconnected(); + else + _connect(); return; } // Handle read result vfd.read_count++; - switch (regs[vfd.reg].type) { - case REG_MAX_FREQ_READ: vfd.max_freq = value; break; - case REG_FREQ_READ: vfd.actual_power = value / (float)vfd.max_freq; break; + switch (regs[vfd.reg].type) + { + case REG_MAX_FREQ_READ: + vfd.max_freq = value; + break; + case REG_FREQ_READ: + vfd.actual_power = value / (float)vfd.max_freq; + break; case REG_FREQ_SIGN_READ: vfd.actual_power = (int16_t)value / (float)vfd.max_freq; break; case REG_FREQ_ACTECH_READ: - if (vfd.read_count == 2) vfd.actual_power = value / (float)vfd.max_freq; - if (vfd.read_count < 6) return; + if (vfd.read_count == 2) + vfd.actual_power = value / (float)vfd.max_freq; + if (vfd.read_count < 6) + return; break; - case REG_STATUS_READ: vfd.status = value; break; + case REG_STATUS_READ: + vfd.status = value; + break; - default: break; + default: + break; } // Next _next_reg(); } - -static bool _use_multi_write() { - switch (spindle_get_type()) { - case SPINDLE_TYPE_CUSTOM: return vfd.user_multi_write; - case SPINDLE_TYPE_NOWFOREVER: return true; - default: return false; +static bool _use_multi_write() +{ + switch (spindle_get_type()) + { + case SPINDLE_TYPE_CUSTOM: + return vfd.user_multi_write; + case SPINDLE_TYPE_NOWFOREVER: + return true; + default: + return false; } } - -static bool _exec_command() { - if (vfd.wait) return true; +static bool _exec_command() +{ + if (vfd.wait) + return true; vfd_reg_t reg = regs[vfd.reg]; uint16_t words = 1; bool read = false; bool write = false; - switch (reg.type) { - case REG_DISABLED: break; + switch (reg.type) + { + case REG_DISABLED: + break; - case REG_MAX_FREQ_FIXED: vfd.max_freq = reg.value; break; + case REG_MAX_FREQ_FIXED: + vfd.max_freq = reg.value; + break; case REG_FREQ_SET: write = true; @@ -362,11 +373,6 @@ static bool _exec_command() { reg.value = vfd.power * vfd.max_freq; break; - case REG_FREQ_SCALED_SET: - write = true; - reg.value = fabs(vfd.power) * reg.value; - break; - case REG_CONNECT_WRITE: case REG_STOP_WRITE: case REG_FWD_WRITE: @@ -386,117 +392,138 @@ static bool _exec_command() { break; } - if (read) modbus_read(reg.addr, words, _modbus_cb); - else if (write) (_use_multi_write() ? modbus_multi_write : modbus_write) - (reg.addr, reg.value, _modbus_cb); - else return false; + if (read) + modbus_read(reg.addr, words, _modbus_cb); + else if (write) + (_use_multi_write() ? modbus_multi_write : modbus_write)(reg.addr, reg.value, _modbus_cb); + else + return false; return true; } - -static void _load(const vfd_reg_t *_regs) { +static void _load(const vfd_reg_t *_regs) +{ memset(®s, 0, sizeof(regs)); - for (int i = 0; i < VFDREG; i++) { + for (int i = 0; i < VFDREG; i++) + { regs[i].type = (vfd_reg_type_t)pgm_read_byte(&_regs[i].type); - if (!regs[i].type) break; + if (!regs[i].type) + break; regs[i].addr = pgm_read_word(&_regs[i].addr); regs[i].value = pgm_read_word(&_regs[i].value); } } - -void vfd_spindle_init() { +void vfd_spindle_init() +{ memset(&vfd, 0, sizeof(vfd)); - for (int i = 0; i < VFDREG; i++) regs[i].fails = 0; + for (int i = 0; i < VFDREG; i++) + regs[i].fails = 0; modbus_init(); - switch (spindle_get_type()) { - case SPINDLE_TYPE_CUSTOM: memcpy(regs, custom_regs, sizeof(regs)); break; - case SPINDLE_TYPE_AC_TECH: _load(ac_tech_regs); break; - case SPINDLE_TYPE_NOWFOREVER: _load(nowforever_regs); break; - case SPINDLE_TYPE_DELTA_VFD015M21A: _load(delta_vfd015m21a_regs); break; - case SPINDLE_TYPE_YL600: _load(yl600_regs); break; - case SPINDLE_TYPE_FR_D700: _load(fr_d700_regs); break; - case SPINDLE_TYPE_SUNFAR_E300: _load(sunfar_e300_regs); break; - case SPINDLE_TYPE_OMRON_MX2: _load(omron_mx2_regs); break; - case SPINDLE_TYPE_V70: _load(v70_regs); break; - case SPINDLE_TYPE_EM60: _load(em60_regs); break; - default: break; + switch (spindle_get_type()) + { + case SPINDLE_TYPE_CUSTOM: + memcpy(regs, custom_regs, sizeof(regs)); + break; + case SPINDLE_TYPE_AC_TECH: + _load(ac_tech_regs); + break; + case SPINDLE_TYPE_NOWFOREVER: + _load(nowforever_regs); + break; + case SPINDLE_TYPE_DELTA_VFD015M21A: + _load(delta_vfd015m21a_regs); + break; + case SPINDLE_TYPE_YL600: + _load(yl600_regs); + break; + case SPINDLE_TYPE_FR_D700: + _load(fr_d700_regs); + break; + case SPINDLE_TYPE_SUNFAR_E300: + _load(sunfar_e300_regs); + break; + case SPINDLE_TYPE_OMRON_MX2: + _load(omron_mx2_regs); + break; + case SPINDLE_TYPE_V70: + _load(v70_regs); + break; + default: + break; } _connect(); } - -void vfd_spindle_deinit(deinit_cb_t cb) { +void vfd_spindle_deinit(deinit_cb_t cb) +{ vfd.shutdown = true; vfd.deinit_cb = cb; } - -void vfd_spindle_set(float power) { +void vfd_spindle_set(float power) +{ if (vfd.power != power) - ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) + { vfd.power = power; vfd.changed = true; } } +float vfd_spindle_get() { return vfd.actual_power; } +uint16_t vfd_get_status() { return vfd.status; } -float vfd_spindle_get() {return vfd.actual_power;} -uint16_t vfd_get_status() {return vfd.status;} - - -void vfd_spindle_rtc_callback() { - if (!vfd.wait || !rtc_expired(vfd.wait)) return; +void vfd_spindle_rtc_callback() +{ + if (!vfd.wait || !rtc_expired(vfd.wait)) + return; vfd.wait = 0; _next_reg(); } - // Variable callbacks -uint16_t get_vfd_max_freq() {return vfd.max_freq;} -void set_vfd_max_freq(uint16_t max_freq) {vfd.max_freq = max_freq;} -bool get_vfd_multi_write() {return vfd.user_multi_write;} -void set_vfd_multi_write(bool value) {vfd.user_multi_write = value;} -uint8_t get_vfd_reg_type(int reg) {return regs[reg].type;} +uint16_t get_vfd_max_freq() { return vfd.max_freq; } +void set_vfd_max_freq(uint16_t max_freq) { vfd.max_freq = max_freq; } +bool get_vfd_multi_write() { return vfd.user_multi_write; } +void set_vfd_multi_write(bool value) { vfd.user_multi_write = value; } +uint8_t get_vfd_reg_type(int reg) { return regs[reg].type; } - -void set_vfd_reg_type(int reg, uint8_t type) { +void set_vfd_reg_type(int reg, uint8_t type) +{ custom_regs[reg].type = (vfd_reg_type_t)type; if (spindle_get_type() == SPINDLE_TYPE_CUSTOM) regs[reg].type = custom_regs[reg].type; vfd.changed = true; } +uint16_t get_vfd_reg_addr(int reg) { return regs[reg].addr; } -uint16_t get_vfd_reg_addr(int reg) {return regs[reg].addr;} - - -void set_vfd_reg_addr(int reg, uint16_t addr) { +void set_vfd_reg_addr(int reg, uint16_t addr) +{ custom_regs[reg].addr = addr; if (spindle_get_type() == SPINDLE_TYPE_CUSTOM) regs[reg].addr = custom_regs[reg].addr; vfd.changed = true; } +uint16_t get_vfd_reg_val(int reg) { return regs[reg].value; } -uint16_t get_vfd_reg_val(int reg) {return regs[reg].value;} - - -void set_vfd_reg_val(int reg, uint16_t value) { +void set_vfd_reg_val(int reg, uint16_t value) +{ custom_regs[reg].value = value; if (spindle_get_type() == SPINDLE_TYPE_CUSTOM) regs[reg].value = custom_regs[reg].value; vfd.changed = true; } +uint8_t get_vfd_reg_fails(int reg) { return regs[reg].fails; } -uint8_t get_vfd_reg_fails(int reg) {return regs[reg].fails;} - - -void set_vfd_reg_fails(int reg, uint8_t value) { +void set_vfd_reg_fails(int reg, uint8_t value) +{ regs[reg].fails = value; -} +} \ No newline at end of file diff --git a/src/js/modbus-reg.js b/src/js/modbus-reg.js index 2ce5e78..e6ba7a8 100644 --- a/src/js/modbus-reg.js +++ b/src/js/modbus-reg.js @@ -1,20 +1,20 @@ "use strict"; module.exports = { - replace: true, - template: "#modbus-reg-view-template", - props: [ "index", "model", "template", "enable" ], + replace: true, + template: "#modbus-reg-view-template", + props: ["index", "model", "template", "enable"], - computed: { - has_user_value: function() { - const type = this.model["reg-type"]; - return type.includes("write") || type.includes("fixed") || type.includes("scaled"); - } + computed: { + has_user_value: function () { + var type = this.model["reg-type"]; + return type.indexOf("write") != -1 || type.indexOf("fixed") != -1; }, + }, - methods: { - change: function() { - this.$dispatch("input-changed"); - } - } + methods: { + change: function () { + this.$dispatch("input-changed"); + }, + }, }; diff --git a/src/js/tool-view.js b/src/js/tool-view.js index b48c3fd..2e1add5 100644 --- a/src/js/tool-view.js +++ b/src/js/tool-view.js @@ -5,252 +5,261 @@ const modbus = require("./modbus.js"); const merge = require("lodash.merge"); module.exports = { - template: "#tool-view-template", - props: [ "config", "template", "state" ], + template: "#tool-view-template", + props: ["config", "template", "state"], - data: function() { - return { - address: 0, - value: 0, - toolList: [ - { - id: "disabled", - name: "Disabled", - }, - { - id: "router", - type: "PWM Spindle", - name: "Router (Makita, etc)", - }, - { - id: "laser", - type: "PWM Spindle", - name: "Laser (J Tech, etc)", - }, - { - id: "pwm", - name: "PWM Spindle", - }, - { - id: "unsupported-separator", - name: "Unsupported Tools", - disabled: true, - unsupported: true, - }, - { - id: "huanyang-vfd", - name: "Huanyang VFD", - unsupported: true, - }, - { - id: "custom-modbus-vfd", - name: "Custom Modbus VFD", - unsupported: true, - }, - { - id: "ac-tech-vfd", - name: "AC-Tech VFD", - unsupported: true, - }, - { - id: "nowforever-vfd", - name: "Nowforever VFD", - unsupported: true, - }, - { - id: "delta-vfd", - name: "Delta VFD015M21A (Beta)", - unsupported: true, - }, - { - id: "yl600-vfd", - name: "YL600, YL620, YL620-A VFD (Beta)", - unsupported: true, - }, - { - id: "fr-d700-vfd", - name: "FR-D700 (Beta)", - unsupported: true, - }, - { - id: "sunfar-e300-vfd", - name: "Sunfar E300 (Beta)", - unsupported: true, - }, - { - id: "omron-mx2-vfd", - name: "OMRON MX2", - unsupported: true, - }, - // { - // id: "EM60", - // name: "EM60", - // }, - ], - }; + data: function () { + return { + address: 0, + value: 0, + toolList: [ + { + id: "disabled", + name: "Disabled", + }, + { + id: "router", + type: "PWM Spindle", + name: "Router (Makita, etc)", + }, + { + id: "laser", + type: "PWM Spindle", + name: "Laser (J Tech, etc)", + }, + { + id: "pwm", + name: "PWM Spindle", + }, + { + id: "unsupported-separator", + name: "Unsupported Tools", + disabled: true, + unsupported: true, + }, + { + id: "huanyang-vfd", + name: "Huanyang VFD", + unsupported: true, + }, + { + id: "custom-modbus-vfd", + name: "Custom Modbus VFD", + unsupported: true, + }, + { + id: "ac-tech-vfd", + name: "AC-Tech VFD", + unsupported: true, + }, + { + id: "nowforever-vfd", + name: "Nowforever VFD", + unsupported: true, + }, + { + id: "delta-vfd", + name: "Delta VFD015M21A (Beta)", + unsupported: true, + }, + { + id: "yl600-vfd", + name: "YL600, YL620, YL620-A VFD (Beta)", + unsupported: true, + }, + { + id: "fr-d700-vfd", + name: "FR-D700 (Beta)", + unsupported: true, + }, + { + id: "sunfar-e300-vfd", + name: "Sunfar E300 (Beta)", + unsupported: true, + }, + { + id: "omron-mx2-vfd", + name: "OMRON MX2", + unsupported: true, + }, + ], + }; + }, + + components: { + "modbus-reg": require("./modbus-reg.js"), + }, + + watch: { + "state.mr": function () { + this.value = this.state.mr; + }, + }, + + events: { + "input-changed": function () { + this.$dispatch("config-changed"); + + return false; + }, + }, + + ready: function () { + this.value = this.state.mr; + }, + + computed: { + regs_tmpl: function () { + return this.template["modbus-spindle"].regs; }, - components: { - "modbus-reg": require("./modbus-reg.js") + tool_type: function () { + return this.config.tool["tool-type"].toUpperCase(); }, - watch: { - "state.mr": function() { - this.value = this.state.mr; - } + selected_tool: function () { + return this.config.tool["selected-tool"]; }, - events: { - "input-changed": function() { - this.$dispatch("config-changed"); - - return false; - }, + is_pwm_spindle: function () { + return this.selected_tool == "pwm"; }, - ready: function() { - this.value = this.state.mr; + is_modbus: function () { + switch (this.selected_tool) { + case "disabled": + case "laser": + case "router": + case "pwm": + return false; + + default: + return true; + } }, - computed: { - regs_tmpl: function() { - return this.template["modbus-spindle"].regs; - }, + modbus_status: function () { + return modbus.status_to_string(this.state.mx); + }, + }, - tool_type: function() { - return this.config.tool["tool-type"].toUpperCase(); - }, + methods: { + change_selected_tool: function () { + const selectedToolSettings = this.config["selected-tool-settings"] || {}; + const settings = selectedToolSettings[this.selected_tool] || {}; + this.config.tool = merge({}, this.config.tool, settings["tool"]); + this.config["pwm-spindle"] = merge( + {}, + this.config["pwm-spindle"], + settings["pwm-spindle"] + ); + this.config["modbus-spindle"] = merge( + {}, + this.config["modbus-spindle"], + settings["modbus-spindle"] + ); - selected_tool: function() { - return this.config.tool["selected-tool"]; - }, + const tool = this.toolList.find( + (tool) => tool.id == this.config.tool["selected-tool"] + ); + this.config.tool["tool-type"] = tool.type || tool.name; - is_pwm_spindle: function() { - return this.selected_tool == "pwm"; - }, - - is_modbus: function() { - switch (this.selected_tool) { - case "disabled": - case "laser": - case "router": - case "pwm": - return false; - - default: - return true; - } - }, - - modbus_status: function() { - return modbus.status_to_string(this.state.mx); - } + this.$dispatch("config-changed"); }, - methods: { - change_selected_tool: function() { - const selectedToolSettings = this.config["selected-tool-settings"] || {}; - const settings = selectedToolSettings[this.selected_tool] || {}; - this.config.tool = merge({}, this.config.tool, settings["tool"]); - this.config["pwm-spindle"] = merge({}, this.config["pwm-spindle"], settings["pwm-spindle"]); - this.config["modbus-spindle"] = merge({}, this.config["modbus-spindle"], settings["modbus-spindle"]); + show_tool_settings: function (key) { + switch (true) { + case key === "tool-type": + case key === "selected-tool": + return false; - const tool = this.toolList.find(tool => tool.id == this.config.tool["selected-tool"]); - this.config.tool["tool-type"] = tool.type || tool.name; + case this.selected_tool === "disabled": + return false; - this.$dispatch("config-changed"); - }, + case this.selected_tool === "laser": + case this.selected_tool === "router": + switch (key) { + case "tool-enable-mode": + return true; - show_tool_settings: function(key) { - switch (true) { - case key === "tool-type": - case key === "selected-tool": - return false; + default: + return false; + } - case this.selected_tool === "disabled": - return false; + default: + return true; + } + }, - case this.selected_tool === "laser": - case this.selected_tool === "router": - switch (key) { - case "tool-enable-mode": - return true; + get_reg_type: function (reg) { + return this.regs_tmpl.template["reg-type"].values[this.state[`${reg}vt`]]; + }, - default: - return false; - } + get_reg_addr: function (reg) { + return this.state[`${reg}va`]; + }, - default: - return true; - } - }, + get_reg_value: function (reg) { + return this.state[`${reg}vv`]; + }, - get_reg_type: function(reg) { - return this.regs_tmpl.template["reg-type"].values[this.state[`${reg}vt`]]; - }, + get_reg_fails: function (reg) { + const fails = this.state[`${reg}vr`]; + return fails == 255 ? "Max" : fails; + }, - get_reg_addr: function(reg) { - return this.state[`${reg}va`]; - }, + show_modbus_field: function (key) { + return ( + key != "regs" && + (key != "multi-write" || this.tool_type == "CUSTOM MODBUS VFD") + ); + }, - get_reg_value: function(reg) { - return this.state[`${reg}vv`]; - }, + read: function (e) { + e.preventDefault(); + api.put("modbus/read", { address: this.address }); + }, - get_reg_fails: function(reg) { - const fails = this.state[`${reg}vr`]; - return fails == 255 ? "Max" : fails; - }, + write: function (e) { + e.preventDefault(); + api.put("modbus/write", { address: this.address, value: this.value }); + }, - show_modbus_field: function(key) { - return key != "regs" && (key != "multi-write" || this.tool_type == "CUSTOM MODBUS VFD"); - }, + customize: function (e) { + e.preventDefault(); + this.config.tool["tool-type"] = "Custom Modbus VFD"; - read: function(e) { - e.preventDefault(); - api.put("modbus/read", { address: this.address }); - }, + const regs = this.config["modbus-spindle"].regs; + for (let i = 0; i < regs.length; i++) { + const reg = this.regs_tmpl.index[i]; + regs[i]["reg-type"] = this.get_reg_type(reg); + regs[i]["reg-addr"] = this.get_reg_addr(reg); + regs[i]["reg-value"] = this.get_reg_value(reg); + } - write: function(e) { - e.preventDefault(); - api.put("modbus/write", { address: this.address, value: this.value }); - }, + this.$dispatch("config-changed"); + }, - customize: function(e) { - e.preventDefault(); - this.config.tool["tool-type"] = "Custom Modbus VFD"; + clear: function (e) { + e.preventDefault(); + this.config.tool["tool-type"] = "Custom Modbus VFD"; - const regs = this.config["modbus-spindle"].regs; - for (let i = 0; i < regs.length; i++) { - const reg = this.regs_tmpl.index[i]; - regs[i]["reg-type"] = this.get_reg_type(reg); - regs[i]["reg-addr"] = this.get_reg_addr(reg); - regs[i]["reg-value"] = this.get_reg_value(reg); - } + const regs = this.config["modbus-spindle"].regs; + for (let i = 0; i < regs.length; i++) { + regs[i]["reg-type"] = "disabled"; + regs[i]["reg-addr"] = 0; + regs[i]["reg-value"] = 0; + } - this.$dispatch("config-changed"); - }, + this.$dispatch("config-changed"); + }, - clear: function(e) { - e.preventDefault(); - this.config.tool["tool-type"] = "Custom Modbus VFD"; - - const regs = this.config["modbus-spindle"].regs; - for (let i = 0; i < regs.length; i++) { - regs[i]["reg-type"] = "disabled"; - regs[i]["reg-addr"] = 0; - regs[i]["reg-value"] = 0; - } - - this.$dispatch("config-changed"); - }, - - reset_failures: function(e) { - e.preventDefault(); - const regs = this.config["modbus-spindle"].regs; - for (let reg = 0; reg < regs.length; reg++) { - this.$dispatch("send", `$${reg}vr=0`); - } - } - } + reset_failures: function (e) { + e.preventDefault(); + const regs = this.config["modbus-spindle"].regs; + for (let reg = 0; reg < regs.length; reg++) { + this.$dispatch("send", `$${reg}vr=0`); + } + }, + }, }; diff --git a/src/pug/templates/tool-view.pug b/src/pug/templates/tool-view.pug index d6d51f4..0745058 100644 --- a/src/pug/templates/tool-view.pug +++ b/src/pug/templates/tool-view.pug @@ -43,7 +43,7 @@ script#tool-view-template(type="text/x-template") label.units RPM fieldset.modbus-program( - v-if="is_modbus && tool_type != 'HUANYANG VFD' && tool_type != 'EM60'") + v-if="is_modbus && this.tool_type != 'HUANYANG VFD'") h2 Active Modbus Program p(v-if="$root.modified") | (Click #[tt(class="save") Save] to activate the selected @@ -379,65 +379,4 @@ script#tool-view-template(type="text/x-template") target="_blank") OMRON MX2 VFD manual | | and spindle type. The VFD must be rebooted after changing - | the above settings. - - - .notes(v-if="tool_type.startsWith('EM60')") - h2 Notes - p Set the following using the VFD's front panel. - table.modbus-regs.fixed-regs - tr - th Address - th Value - th Meaning - th Description - tr - td.reg-addr P0.0.03 - td.reg-value 2 - td Modbus - td Control mode - tr - td.reg-addr P0.0.04 - td.reg-value 9 - td Modbus - td Frequency source A - tr - td.reg-addr P0.1.00 - td.reg-value 0 - td Source A - td Frequency source - tr - td.reg-addr P4.1.00 - td.reg-value 3 - td 9600 BAUD - td Must match #[tt baud] above - tr - td.reg-addr P4.1.01 - td.reg-value 0 - td 8N2 - td Data format - tr - td.reg-addr P4.1.02 - td.reg-value 1 - td Bus id - td Must match #[tt bus-id] above - tr - td.reg-addr P4.1.03 - td.reg-value 2 - td No delay - td Communications response delay - tr - td.reg-addr P4.1.04 - td.reg-value 0 - td No timeout - td Communications timeout - tr - td.reg-addr P4.1.05 - td.reg-value 1 - td RTU - td Modbus format - p - | Other settings according to the - | - a(href="https://buildbotics.com/upload/vfd/em60.pdf", - target="_blank") EM60 VFD manual \ No newline at end of file + | the above settings. \ No newline at end of file diff --git a/src/resources/config-template.json b/src/resources/config-template.json index 5638244..907ce2b 100644 --- a/src/resources/config-template.json +++ b/src/resources/config-template.json @@ -270,8 +270,7 @@ "YL600, YL620, YL620-A VFD (Beta)", "FR-D700 (Beta)", "Sunfar E300 (Beta)", - "OMRON MX2", - "EM60" + "OMRON MX2" ], "default": "Disabled", "code": "st" @@ -365,7 +364,6 @@ "max-freq-fixed", "freq-set", "freq-signed-set", - "freq-scaled-set", "stop-write", "forward-write", "reverse-write", From 427343bdd5cfcaeb71ac84ac686f32b5acb7d84f Mon Sep 17 00:00:00 2001 From: saifullah-N Date: Sun, 29 Jan 2023 23:22:21 +0530 Subject: [PATCH 3/4] added .devcontainer and .vscode configurations --- .devcontainer/Dockerfile | 7 +++++ .devcontainer/devcontainer.json | 36 +++++++++++++++++++++++++ .devcontainer/install_tools.sh | 47 +++++++++++++++++++++++++++++++++ .vscode/settings.json | 31 ++++++++++++++++++++++ 4 files changed, 121 insertions(+) create mode 100644 .devcontainer/Dockerfile create mode 100644 .devcontainer/devcontainer.json create mode 100644 .devcontainer/install_tools.sh create mode 100644 .vscode/settings.json diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..f2f6d9b --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,7 @@ +# See here for image contents: https://github.com/microsoft/vscode-dev-containers/blob/v0.241.1/containers/debian/.devcontainer/base.Dockerfile + +# [Choice] Debian version (use bullseye on local arm64/Apple Silicon): bullseye, buster +ARG VARIANT=bullseye +FROM mcr.microsoft.com/vscode/devcontainers/base:${VARIANT} +COPY ./install_tools.sh /tmp/install_tools.sh +RUN /tmp/install_tools.sh diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..f5b5287 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,36 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at: +// https://github.com/microsoft/vscode-dev-containers/blob/v0.241.1/containers/debian +{ + "name": "Debian", + "build": { + "dockerfile": "Dockerfile", + // Update 'VARIANT' to pick an Debian version: bullseye, buster + // Use bullseye on local arm64/Apple Silicon. + "args": { + "VARIANT": "bullseye" + } + }, + "runArgs": [ + // The primary reason this is here is to enable loopback devices, + // which are used for mounting disk images during builds, etc. + "--privileged" + ], + // Use 'forwardPorts' to make a list of ports inside the container available locally. + // "forwardPorts": [], + // + // Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker. + // "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ], + "features": { + "sshd": "latest" + }, + "extensions": [ + "ms-azuretools.vscode-docker", + "dbaeumer.vscode-eslint", + "eamodio.gitlens", + "ms-vscode.makefile-tools", + "ms-python.python", + "svelte.svelte-vscode", + "redhat.vscode-yaml", + "ryu1kn.partial-diff" + ] +} \ No newline at end of file diff --git a/.devcontainer/install_tools.sh b/.devcontainer/install_tools.sh new file mode 100644 index 0000000..8ffc901 --- /dev/null +++ b/.devcontainer/install_tools.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env -S bash -e + +APT_PACKAGES=( + "build-essential" + "git" + "wget" + "binfmt-support" + "qemu" + "gcc-9" + "parted" + "udev" + "zerofree" + "gcc-avr" + "avr-libc" + "avrdude" + "python3" + "python3-pip" + "python3-tornado" + "inetutils-ping" + "curl" + "unzip" + "python3-setuptools" + "gcc-arm-linux-gnueabihf" + "bc" + "vim" + "locate" + "sudo" + "sshpass" +) + +apt-get update +apt-get upgrade -y + +apt-get install -y "${APT_PACKAGES[@]}" + +update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 9 + +/usr/bin/python3 -m pip install -U yapf + +curl -fsSL https://deb.nodesource.com/setup_18.x | bash - +apt-get install -y nodejs + +mkdir -p /root/.ssh +cat > /root/.ssh/config <<- END +Host onefinity + User bbmc +END diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..427acba --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,31 @@ +{ + "files.exclude": { + "**/.git": true, + "**/.svn": true, + "**/.hg": true, + "**/CVS": true, + "**/.DS_Store": true, + "**/Thumbs.db": true, + "**/node_modules": true, + "**/build": true, + "**/dist": true, + "**/rpi-share": true, + "**/rpi-root": true + }, + "search.exclude": { + "**/bower_components": true, + "**/*.code-search": true, + "**/node_modules": true, + "**/build": true, + "**/dist": true, + "**/rpi-share": true, + "**/rpi-root": true + }, + "explorer.excludeGitIgnore": true, + "git.ignoredRepositories": [ + "rpi-share/camotics", + "rpi-share/cbang" + ], + "git.autofetch": false, + "git.confirmSync": false +} \ No newline at end of file From aa3a359473ec4db6ca1511442105bcf3ce1168aa Mon Sep 17 00:00:00 2001 From: saifullah-N Date: Mon, 6 Feb 2023 12:13:41 +0530 Subject: [PATCH 4/4] Fix SSL certificate issue with mirror --- scripts/gplan-init-dev-img.sh | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/scripts/gplan-init-dev-img.sh b/scripts/gplan-init-dev-img.sh index cfa9d4e..e9ca447 100755 --- a/scripts/gplan-init-dev-img.sh +++ b/scripts/gplan-init-dev-img.sh @@ -3,9 +3,6 @@ export LC_ALL=C cd /mnt/host -# Update the system -apt-get update -#apt-get dist-upgrade -y - +apt -o "Acquire::https::Verify-Peer=false" update # Install packages -apt-get install -y scons build-essential libssl-dev python3-dev +apt -o "Acquire::https::Verify-Peer=false" install -y scons build-essential libssl-dev python3-dev