diff --git a/g2core/board/gquintic/gquintic-b-pinout.h b/g2core/board/gquintic/gquintic-b-pinout.h index e0f9280e..3cbc5736 100644 --- a/g2core/board/gquintic/gquintic-b-pinout.h +++ b/g2core/board/gquintic/gquintic-b-pinout.h @@ -3,8 +3,8 @@ * For: /board/gQuintic * This file is part of the g2core project * - * Copyright (c) 2016 Robert Giseburt - * Copyright (c) 2016 Alden S. Hart Jr. + * Copyright (c) 2016 - 2017 Robert Giseburt + * Copyright (c) 2016 - 2017 Alden S. Hart Jr. * * This file is part of the Motate Library. * @@ -117,99 +117,94 @@ namespace Motate { -// Unused: -// -// -// -// -// +// All DO and DI and ADC board pinouts are for gQuintic Rev B +// Designators agree with silkscreen on board -_MAKE_MOTATE_PIN(kLED_RGBWPixelPinNumber, 'A', 0); // -_MAKE_MOTATE_PIN(kOutput1_PinNumber, 'A', 1); // -_MAKE_MOTATE_PIN(kOutput2_PinNumber, 'A', 2); // -_MAKE_MOTATE_PIN(kI2C1_SDAPinNumber, 'A', 3); // -_MAKE_MOTATE_PIN(kI2C1_SCLPinNumber, 'A', 4); // -_MAKE_MOTATE_PIN(kOutput11_PinNumber, 'A', 5); // -_MAKE_MOTATE_PIN(kExternalClock1_PinNumber, 'A', 6); // CPU_CLK -_MAKE_MOTATE_PIN(kOutput7_PinNumber, 'A', 7); // -_MAKE_MOTATE_PIN(kSerial_RTSPinNumber, 'A', 8); // -_MAKE_MOTATE_PIN(kSerial_RXPinNumber, 'A', 9); // -_MAKE_MOTATE_PIN(kSerial_TXPinNumber, 'A', 10); // -_MAKE_MOTATE_PIN(kSocket2_EnablePinNumber, 'A', 11); // -_MAKE_MOTATE_PIN(kOutput6_PinNumber, 'A', 12); // -_MAKE_MOTATE_PIN(kOutput8_PinNumber, 'A', 13); // -_MAKE_MOTATE_PIN(kSocket1_StepPinNumber, 'A', 14); // -_MAKE_MOTATE_PIN(kOutput3_PinNumber, 'A', 15); // -_MAKE_MOTATE_PIN(kOutput4_PinNumber, 'A', 16); // -_MAKE_MOTATE_PIN(kADC3_PinNumber, 'A', 17); // -_MAKE_MOTATE_PIN(kADC2_PinNumber, 'A', 18); // -_MAKE_MOTATE_PIN(kADC1_PinNumber, 'A', 19); // -_MAKE_MOTATE_PIN(kADC0_PinNumber, 'A', 20); // -_MAKE_MOTATE_PIN(kSerial_CTSPinNumber, 'A', 21); // -_MAKE_MOTATE_PIN(kSocket1_EnablePinNumber, 'A', 22); // -_MAKE_MOTATE_PIN(kOutput10_PinNumber, 'A', 23); // -_MAKE_MOTATE_PIN(kSocket3_EnablePinNumber, 'A', 24); // -_MAKE_MOTATE_PIN(kSocket2_DirPinNumber, 'A', 25); // -_MAKE_MOTATE_PIN(kOutput5_PinNumber, 'A', 26); // On Timer 2! -_MAKE_MOTATE_PIN(kSocket3_StepPinNumber, 'A', 27); // On Timer 2! -_MAKE_MOTATE_PIN(kUnassigned1, 'A', 28); // DIAG1 -_MAKE_MOTATE_PIN(kUnassigned2, 'A', 29); // -_MAKE_MOTATE_PIN(kInput1_PinNumber, 'A', 30); // -_MAKE_MOTATE_PIN(kInput4_PinNumber, 'A', 31); // +_MAKE_MOTATE_PIN(kLED_RGBWPixelPinNumber, 'A', 0); // DO12 +_MAKE_MOTATE_PIN(kOutput1_PinNumber, 'A', 1); // DO1 +_MAKE_MOTATE_PIN(kOutput2_PinNumber, 'A', 2); // DO2 +_MAKE_MOTATE_PIN(kI2C1_SDAPinNumber, 'A', 3); // SDA +_MAKE_MOTATE_PIN(kI2C1_SCLPinNumber, 'A', 4); // SCK +_MAKE_MOTATE_PIN(kOutput11_PinNumber, 'A', 5); // DO11 +_MAKE_MOTATE_PIN(kExternalClock1_PinNumber, 'A',6); // CPU_CLK (internal signal, not brought out) +_MAKE_MOTATE_PIN(kOutput7_PinNumber, 'A', 7); // DO7 +_MAKE_MOTATE_PIN(kSerial_RTSPinNumber, 'A', 8); // RTS +_MAKE_MOTATE_PIN(kSerial_RXPinNumber, 'A', 9); // RX +_MAKE_MOTATE_PIN(kSerial_TXPinNumber, 'A', 10); // TX +_MAKE_MOTATE_PIN(kSocket2_EnablePinNumber, 'A',11); // M2 ENAB +_MAKE_MOTATE_PIN(kOutput6_PinNumber, 'A', 12); // DO6 +_MAKE_MOTATE_PIN(kOutput8_PinNumber, 'A', 13); // DO8 +_MAKE_MOTATE_PIN(kSocket1_StepPinNumber, 'A', 14); // M1 Step +_MAKE_MOTATE_PIN(kOutput3_PinNumber, 'A', 15); // DO3 +_MAKE_MOTATE_PIN(kOutput4_PinNumber, 'A', 16); // DO4 +_MAKE_MOTATE_PIN(kADC3_PinNumber, 'A', 17); // ADC4 +_MAKE_MOTATE_PIN(kADC2_PinNumber, 'A', 18); // ADC3 +_MAKE_MOTATE_PIN(kADC1_PinNumber, 'A', 19); // ADC2 +_MAKE_MOTATE_PIN(kADC0_PinNumber, 'A', 20); // ADC1 +_MAKE_MOTATE_PIN(kSerial_CTSPinNumber, 'A', 21); // CTS +_MAKE_MOTATE_PIN(kSocket1_EnablePinNumber, 'A',22); // M1 ENAB +_MAKE_MOTATE_PIN(kOutput10_PinNumber, 'A', 23); // DO10 +_MAKE_MOTATE_PIN(kSocket3_EnablePinNumber, 'A',24); // M3 ENAB +_MAKE_MOTATE_PIN(kSocket2_DirPinNumber, 'A', 25); // M2 DIR +_MAKE_MOTATE_PIN(kOutput5_PinNumber, 'A', 26); // DO5 (On Timer 2!) +_MAKE_MOTATE_PIN(kSocket3_StepPinNumber, 'A', 27); // M3 DIR (On Timer 2!) +_MAKE_MOTATE_PIN(kUnassigned1, 'A', 28); // DIAG1 (internal signal) +_MAKE_MOTATE_PIN(kUnassigned2, 'A', 29); // (not present on S70) +_MAKE_MOTATE_PIN(kInput1_PinNumber, 'A', 30); // DI1 +_MAKE_MOTATE_PIN(kInput4_PinNumber, 'A', 31); // DI4 -_MAKE_MOTATE_PIN(kInput12_PinNumber, 'B', 0); // -_MAKE_MOTATE_PIN(kInput11_PinNumber, 'B', 1); // -_MAKE_MOTATE_PIN(kSocket1_SPISlaveSelectPinNumber, 'B', 2); // -_MAKE_MOTATE_PIN(kOutputSAFE_PinNumber, 'B', 3); // -//_MAKE_MOTATE_PIN( , 'B', 4); // TDI -//_MAKE_MOTATE_PIN( , 'B', 5); // TRACESDO -//_MAKE_MOTATE_PIN( , 'B', 6); // SWDIO -//_MAKE_MOTATE_PIN( , 'B', 7); // SWDCLK -//_MAKE_MOTATE_PIN( , 'B', 8); // XOUT -//_MAKE_MOTATE_PIN( , 'B', 9); // XIN -//_MAKE_MOTATE_PIN( , 'B', 10); // USB_D- -//_MAKE_MOTATE_PIN( , 'B', 11); // USB_D+ -//_MAKE_MOTATE_PIN( , 'B', 12); // ERASE -_MAKE_MOTATE_PIN(kLED_USBRXPinNumber, 'B', 13); // LED_1 (Heartbeat) - PWM2 -_MAKE_MOTATE_PIN(kSocket4_SPISlaveSelectPinNumber, 'B', 14); // NOT CONNECTED +_MAKE_MOTATE_PIN(kInput12_PinNumber, 'B', 0); // DI12 +_MAKE_MOTATE_PIN(kInput11_PinNumber, 'B', 1); // DI11 +_MAKE_MOTATE_PIN(kSocket1_SPISlaveSelectPinNumber,'B',2); // SPI Slave select 0 (multiplexed) +_MAKE_MOTATE_PIN(kOutputSAFE_PinNumber, 'B', 3); // SAFI (SAFE pulses) +//_MAKE_MOTATE_PIN( , 'B', 4); // TDI +//_MAKE_MOTATE_PIN( , 'B', 5); // TRACESDO +//_MAKE_MOTATE_PIN( , 'B', 6); // SWDIO +//_MAKE_MOTATE_PIN( , 'B', 7); // SWDCLK +//_MAKE_MOTATE_PIN( , 'B', 8); // XOUT +//_MAKE_MOTATE_PIN( , 'B', 9); // XIN +//_MAKE_MOTATE_PIN( , 'B', 10); // USB_D- +//_MAKE_MOTATE_PIN( , 'B', 11); // USB_D+ +//_MAKE_MOTATE_PIN( , 'B', 12); // ERASE +_MAKE_MOTATE_PIN(kLED_USBRXPinNumber, 'B', 13); // LED_1 (Heartbeat) - PWM2 +_MAKE_MOTATE_PIN(kSocket4_SPISlaveSelectPinNumber, 'B', 14); // not connected - -//_MAKE_MOTATE_PIN( , 'D', 0); // USB_VBUS -_MAKE_MOTATE_PIN(kInput9_PinNumber, 'D', 1); // -_MAKE_MOTATE_PIN(kInput10_PinNumber, 'D', 2); // -_MAKE_MOTATE_PIN(kInput8_PinNumber, 'D', 3); // -_MAKE_MOTATE_PIN(kInput7_PinNumber, 'D', 4); // -_MAKE_MOTATE_PIN(kInput6_PinNumber, 'D', 5); // -_MAKE_MOTATE_PIN(kInput5_PinNumber, 'D', 6); // -_MAKE_MOTATE_PIN(kInput3_PinNumber, 'D', 7); // -_MAKE_MOTATE_PIN(kInput2_PinNumber, 'D', 8); // ] -_MAKE_MOTATE_PIN(kUnassigned3, 'D', 9); // DIAG0 -_MAKE_MOTATE_PIN(kUnassigned4, 'D', 10); // -_MAKE_MOTATE_PIN(kSocket5_StepPinNumber, 'D', 11); // -_MAKE_MOTATE_PIN(kSocket3_SPISlaveSelectPinNumber, 'D', 12); // -_MAKE_MOTATE_PIN(kSocket5_DirPinNumber, 'D', 13); // -_MAKE_MOTATE_PIN(kSocket5_EnablePinNumber, 'D', 14); // -_MAKE_MOTATE_PIN(kUnassigned5, 'D', 15); // -_MAKE_MOTATE_PIN(kSocket4_StepPinNumber, 'D', 16); // -_MAKE_MOTATE_PIN(kSocket4_DirPinNumber, 'D', 17); // -_MAKE_MOTATE_PIN(kSocket3_DirPinNumber, 'D', 18); // -_MAKE_MOTATE_PIN(kUnassigned6, 'D', 19); // -_MAKE_MOTATE_PIN(kSPI0_MISOPinNumber, 'D', 20); // -_MAKE_MOTATE_PIN(kSPI0_MOSIPinNumber, 'D', 21); // -_MAKE_MOTATE_PIN(kSPI0_SCKPinNumber, 'D', 22); // -_MAKE_MOTATE_PIN(kUnassigned7, 'D', 23); // -_MAKE_MOTATE_PIN(kSocket2_StepPinNumber, 'D', 24); // -_MAKE_MOTATE_PIN(kSocket2_SPISlaveSelectPinNumber, 'D', 25); // -_MAKE_MOTATE_PIN(kOutput9_PinNumber, 'D', 26); // -_MAKE_MOTATE_PIN(kSocket1_DirPinNumber, 'D', 27); // -_MAKE_MOTATE_PIN(kSocket4_EnablePinNumber, 'D', 28); // -_MAKE_MOTATE_PIN(kUnassigned8, 'D', 29); // -_MAKE_MOTATE_PIN(kUnassigned9, 'D', 30); // INTERRUPT_OUT -_MAKE_MOTATE_PIN(kUnassigned10, 'D', 31); // +//_MAKE_MOTATE_PIN( ,' D', 0); // USB_VBUS +_MAKE_MOTATE_PIN(kInput9_PinNumber, 'D', 1); // DI9 +_MAKE_MOTATE_PIN(kInput10_PinNumber,'D', 2); // DI10 +_MAKE_MOTATE_PIN(kInput8_PinNumber, 'D', 3); // DI8 +_MAKE_MOTATE_PIN(kInput7_PinNumber, 'D', 4); // DI7 +_MAKE_MOTATE_PIN(kInput6_PinNumber, 'D', 5); // DI6 +_MAKE_MOTATE_PIN(kInput5_PinNumber, 'D', 6); // DI5 +_MAKE_MOTATE_PIN(kInput3_PinNumber, 'D', 7); // DI3 +_MAKE_MOTATE_PIN(kInput2_PinNumber, 'D', 8); // DI2 +_MAKE_MOTATE_PIN(kUnassigned3, 'D', 9); // DIAG0 +_MAKE_MOTATE_PIN(kUnassigned4, 'D', 10); // not connected +_MAKE_MOTATE_PIN(kSocket5_StepPinNumber, 'D', 11); // M5 STEP +_MAKE_MOTATE_PIN(kSocket3_SPISlaveSelectPinNumber, 'D',12); // SPI Slave select 2 (multiplexed) +_MAKE_MOTATE_PIN(kSocket5_DirPinNumber, 'D', 13); // M5 DIR +_MAKE_MOTATE_PIN(kSocket5_EnablePinNumber, 'D',14); // M5 ENAB +_MAKE_MOTATE_PIN(kUnassigned5, 'D', 15); // not connected +_MAKE_MOTATE_PIN(kSocket4_StepPinNumber, 'D', 16); // M4 STEP +_MAKE_MOTATE_PIN(kSocket4_DirPinNumber, 'D', 17); // M4 DIR +_MAKE_MOTATE_PIN(kSocket3_DirPinNumber, 'D', 18); // M3 STEP +_MAKE_MOTATE_PIN(kUnassigned6, 'D', 19); // not connected +_MAKE_MOTATE_PIN(kSPI0_MISOPinNumber, 'D', 20); // MISO +_MAKE_MOTATE_PIN(kSPI0_MOSIPinNumber, 'D', 21); // MOSI +_MAKE_MOTATE_PIN(kSPI0_SCKPinNumber, 'D', 22); // CLK +_MAKE_MOTATE_PIN(kUnassigned7, 'D', 23); // not connected +_MAKE_MOTATE_PIN(kSocket2_StepPinNumber, 'D', 24); // M2 STEP +_MAKE_MOTATE_PIN(kSocket2_SPISlaveSelectPinNumber, 'D',25); // SPI Slave select 1 (multiplexed) +_MAKE_MOTATE_PIN(kOutput9_PinNumber, 'D', 26); // DO9 +_MAKE_MOTATE_PIN(kSocket1_DirPinNumber, 'D', 27); // M1 DIR +_MAKE_MOTATE_PIN(kSocket4_EnablePinNumber, 'D',28); // M4 ENAB +_MAKE_MOTATE_PIN(kUnassigned8, 'D', 29); // (not present on S70) +_MAKE_MOTATE_PIN(kUnassigned9, 'D', 30); // supposed to become INT (INTERRUPT_OUT) +_MAKE_MOTATE_PIN(kUnassigned10, 'D', 31); // not connected } // namespace Motate -// We then allow each chip-type to have it's onw function definitions +// We then allow each chip-type to have it's own function definitions // that will refer to these pin assignments. #include "motate_chip_pin_functions.h" diff --git a/g2core/canonical_machine.cpp b/g2core/canonical_machine.cpp index a0bee3a0..698b42c0 100644 --- a/g2core/canonical_machine.cpp +++ b/g2core/canonical_machine.cpp @@ -265,6 +265,33 @@ void cm_set_model_linenum(const uint32_t linenum) nv_add_object((const char *)"n"); // then add the line number to the nv list } +/* + * cm_switch() - switch canonical machine to a different machine + * cm_return() - return canoncial machine to origincal machine + */ +stat_t cm_switch(nvObj_t *nv) +{ +/* + if (nv->value < PRIMARY_Q) { + return (STAT_INPUT_LESS_THAN_MIN_VALUE); + } + if (nv->value < SECONDARY_Q) { + return (STAT_INPUT_EXCEEDS_MAX_VALUE); + } + mb.return_q = mb.active_q; + mb.active_q = (uint8_t)nv->value; +*/ + return (STAT_OK); +} + +stat_t cm_return(nvObj_t *nv) // if value == true return with offset corrections +{ +/* + mb.active_q = mb.return_q; +*/ + return (STAT_OK); +} + /*********************************************************************************** * COORDINATE SYSTEMS AND OFFSETS * Functions to get, set and report coordinate systems and work offsets diff --git a/g2core/canonical_machine.h b/g2core/canonical_machine.h index 12e5493d..90e0a3ca 100644 --- a/g2core/canonical_machine.h +++ b/g2core/canonical_machine.h @@ -222,7 +222,6 @@ typedef struct cmMachine { // struct to manage canonical machin // Coordinate systems and offsets float offset[COORDS+1][AXES]; // persistent coordinate offsets: absolute (G53) + G54,G55,G56,G57,G58,G59 float tl_offset[AXES]; // current tool length offset -// float tt_offset[TOOLS+1][AXES]; // persistent tool table offsets // Axis settings cfgAxis_t a[AXES]; @@ -300,6 +299,9 @@ cmHomingState cm_get_homing_state(void); cmProbeState cm_get_probe_state(void); uint8_t cm_get_jogging_state(void); +stat_t cm_switch(nvObj_t *nv); +stat_t cm_return(nvObj_t *nv); + void cm_set_motion_state(const cmMotionState motion_state); uint32_t cm_get_linenum(const GCodeState_t *gcode_state); diff --git a/g2core/config_app.cpp b/g2core/config_app.cpp index 18ee3a50..9bdfbaa9 100644 --- a/g2core/config_app.cpp +++ b/g2core/config_app.cpp @@ -905,8 +905,8 @@ const cfgItem_t cfgArray[] = { { "", "tram", _f0,0, cm_print_tram,cm_get_tram,cm_set_tram,(float *)&cs.null, 0 }, // SET to attempt setting rotation matrix from probes { "", "defa",_f0, 0, tx_print_nul, help_defa,set_defaults,(float *)&cs.null,0 }, // set/print defaults / help screen { "", "flash",_f0,0, tx_print_nul, help_flash,hw_flash, (float *)&cs.null,0 }, - { "", "switch",_f0,0, tx_print_nul, get_nul, mp_switch_q, (float *)&cs.null,0 }, - { "", "return",_f0,0, tx_print_nul, get_nul, mp_return_q, (float *)&cs.null,0 }, + { "", "switch",_f0,0, tx_print_nul, get_nul, cm_switch, (float *)&cs.null,0 }, + { "", "return",_f0,0, tx_print_nul, get_nul, cm_return, (float *)&cs.null,0 }, #ifdef __HELP_SCREENS { "", "help",_f0, 0, tx_print_nul, help_config, set_nul, (float *)&cs.null,0 }, // prints config help screen diff --git a/g2core/g2core_info.h b/g2core/g2core_info.h index c16606d5..cf2f1c18 100644 --- a/g2core/g2core_info.h +++ b/g2core/g2core_info.h @@ -21,7 +21,7 @@ #ifndef G2CORE_INFO_H_ONCE #define G2CORE_INFO_H_ONCE -#define G2CORE_FIRMWARE_BUILD 100.17 // Added tool offsets (PR #211) +#define G2CORE_FIRMWARE_BUILD 100.18 // This branch has been merged to edge 100.18 #define G2CORE_FIRMWARE_VERSION 0.99 #ifdef GIT_VERSION diff --git a/g2core/gpio.cpp b/g2core/gpio.cpp index 21ed1d96..03ae7043 100644 --- a/g2core/gpio.cpp +++ b/g2core/gpio.cpp @@ -2,8 +2,8 @@ * gpio.cpp - digital IO handling functions * This file is part of the g2core project * - * Copyright (c) 2015 - 2106 Alden S. Hart, Jr. - * Copyright (c) 2015 - 2016 Robert Giseburt + * Copyright (c) 2015 - 2107 Alden S. Hart, Jr. + * Copyright (c) 2015 - 2017 Robert Giseburt * * This file ("the software") is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2 as published by the @@ -481,10 +481,8 @@ static stat_t _output_set_helper(nvObj_t *nv, const int8_t lower_bound, const in return (STAT_OK); } - stat_t io_set_mo(nvObj_t *nv) // input type or disabled { -// return (_io_set_helper(nv, IO_MODE_DISABLED, IO_MODE_MAX)); return (_input_set_helper(nv, IO_ACTIVE_LOW, IO_MODE_MAX)); } diff --git a/g2core/planner.cpp b/g2core/planner.cpp index b2b2f602..e2f0b45e 100644 --- a/g2core/planner.cpp +++ b/g2core/planner.cpp @@ -2,8 +2,8 @@ * planner.cpp - Cartesian trajectory planning and motion execution * This file is part of the g2core project * - * Copyright (c) 2010 - 2016 Alden S. Hart, Jr. - * Copyright (c) 2012 - 2016 Rob Giseburt + * Copyright (c) 2010 - 2017 Alden S. Hart, Jr. + * Copyright (c) 2012 - 2017 Rob Giseburt * * This file ("the software") is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2 as published by the @@ -627,26 +627,6 @@ void mp_planner_time_accounting() UPDATE_MP_DIAGNOSTICS //+++++ } -/* - * mp_switch_q() - switch planner to different quue - * mp_return_q() - return from a planner queue switch - */ -stat_t mp_switch_q(nvObj_t *nv) -{ - if ((nv->value < PRIMARY_Q) || (nv->value < SECONDARY_Q)) { - return (STAT_INPUT_VALUE_RANGE_ERROR); - } - mb.return_q = mb.active_q; - mb.active_q = (uint8_t)nv->value; - return (STAT_OK); -} - -stat_t mp_return_q(nvObj_t *nv) // if value == true return with offset corrections -{ - mb.active_q = mb.return_q; - return (STAT_OK); -} - /**** PLANNER BUFFER PRIMITIVES ************************************************************ * * Planner buffers are used to queue and operate on Gcode blocks. Each buffer contains diff --git a/g2core/planner.h b/g2core/planner.h index dbac1cb1..e8b18e40 100644 --- a/g2core/planner.h +++ b/g2core/planner.h @@ -2,8 +2,8 @@ * planner.h - cartesian trajectory planning and motion execution * This file is part of the g2core project * - * Copyright (c) 2013 - 2016 Alden S. Hart, Jr. - * Copyright (c) 2013 - 2016 Robert Giseburt + * Copyright (c) 2013 - 2017 Alden S. Hart, Jr. + * Copyright (c) 2013 - 2017 Robert Giseburt * * This file ("the software") is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2 as published by the @@ -250,12 +250,12 @@ typedef enum { /*** Most of these factors are the result of a lot of tweaking. Change with caution.***/ #define PLANNER_BUFFER_POOL_SIZE ((uint8_t)48) // Suggest 12 min. Limit is 255 -#define SECONDARY_BUFFER_POOL_SIZE ((uint8_t)4) // Secondary planner queue for feedhold operations +#define SECONDARY_BUFFER_POOL_SIZE ((uint8_t)12) // Secondary planner queue for feedhold operations #define PLANNER_BUFFER_HEADROOM ((uint8_t)4) // Buffers to reserve in planner before processing new input line #define JERK_MULTIPLIER ((float)1000000) // DO NOT CHANGE - must always be 1 million -#define JUNCTION_INTEGRATION_MIN (0.05) // minimum allowable setting -#define JUNCTION_INTEGRATION_MAX (5.00) // maximum allowable setting +#define JUNCTION_INTEGRATION_MIN (0.05) // JT minimum allowable setting +#define JUNCTION_INTEGRATION_MAX (5.00) // JT maximum allowable setting #define MIN_SEGMENT_MS ((float)0.75) // minimum segment milliseconds #define NOM_SEGMENT_MS ((float)1.5) // nominal segment ms (at LEAST MIN_SEGMENT_MS * 2) @@ -293,6 +293,8 @@ typedef enum { #define Veq2_lo 1.0 #define VELOCITY_ROUGHLY_EQ(v0,v1) ( (v0 > Vthr2) ? fabs(v0-v1) < Veq2_hi : fabs(v0-v1) < Veq2_lo ) +/* Diagnostics */ + //#define ASCII_ART(s) xio_writeline(s) #define ASCII_ART(s) //#define UPDATE_BF_DIAGNOSTICS(bf) { bf->block_time_ms = bf->block_time*60000; bf->plannable_time_ms = bf->plannable_time*60000; } @@ -301,12 +303,12 @@ typedef enum { /* * Planner structures * - * You should be aware of the distinction between 'buffers' and 'blocks' + * Be aware of the distinction between 'buffers' and 'blocks' * Please refer to header comments in for important details on buffers and blocks * - plan_zoid.cpp / mp_calculate_ramps() * - plan_exec.cpp / mp_exec_aline() */ - +/* struct mpBuffer_to_clear { stat_t (*bf_func)(struct mpBuffer *bf); // callback to buffer exec function cm_exec_t cm_func; // callback to canonical machine execution function @@ -359,7 +361,7 @@ struct mpBuffer_to_clear { GCodeState_t gm; // Gcode model state - passed from model, used by planner and runtime - // cleasr the above structure + // clears the above structure void reset() { //memset((void *)(this), 0, sizeof(mpBuffer_to_clear)); // slower on the M3. Test for M7 @@ -402,13 +404,110 @@ struct mpBuffer_to_clear { gm.reset(); } }; +*/ -typedef struct mpBuffer : mpBuffer_to_clear { // See Planning Velocity Notes for variable usage +//typedef struct mpBuffer : mpBuffer_to_clear { // See Planning Velocity Notes for variable usage +typedef struct mpBuffer { // *** CAUTION *** These two pointers are not reset by _clear_buffer() struct mpBuffer *pv; // static pointer to previous buffer struct mpBuffer *nx; // static pointer to next buffer uint8_t buffer_number; //+++++ DIAGNOSTIC for easier debugging + + stat_t (*bf_func)(struct mpBuffer *bf); // callback to buffer exec function + cm_exec_t cm_func; // callback to canonical machine execution function + + //+++++ DIAGNOSTICS for easier debugging + uint32_t linenum; // mirror of bf->gm.linenum + int iterations; + float block_time_ms; + float plannable_time_ms; // time in planner + float plannable_length; // length in planner + uint8_t meet_iterations; // iterations needed in _get_meet_velocity + //+++++ to here + + bufferState buffer_state; // used to manage queuing/dequeuing + blockType block_type; // used to dispatch to run routine + blockState block_state; // move state machine sequence + blockHint hint; // hint the block for zoid and other planning operations. Must be accurate or NO_HINT + + // block parameters + float unit[AXES]; // unit vector for axis scaling & planning + bool axis_flags[AXES]; // set true for axes participating in the move & for command parameters + + bool plannable; // set true when this block can be used for planning + + float length; // total length of line or helix in mm + float block_time; // computed move time for entire block (move) + float override_factor; // feed rate or rapid override factor for this block ("override" is a reserved word) + + // *** SEE NOTES ON THESE VARIABLES, in aline() *** + // We removed all entry_* values. + // To get the entry_* values, look at pv->exit_* or mr.exit_* + float cruise_velocity; // cruise velocity requested & achieved + float exit_velocity; // exit velocity requested for the move + // is also the entry velocity of the *next* move + + float cruise_vset; // cruise velocity requested for move - prior to overrides + float cruise_vmax; // cruise max velocity adjusted for overrides + float exit_vmax; // max exit velocity possible for this move + // is also the maximum entry velocity of the next move + + float absolute_vmax; // fastest this block can move w/o exceeding constraints + float junction_vmax; // maximum the exit velocity can be to go through the junction + // between the NEXT BLOCK AND THIS ONE + + float jerk; // maximum linear jerk term for this move + float jerk_sq; // Jm^2 is used for planning (computed and cached) + float recip_jerk; // 1/Jm used for planning (computed and cached) + float sqrt_j; // sqrt(jM) used for planning (computed and cached) + float q_recip_2_sqrt_j; // (q/(2 sqrt(jM))) where q = (sqrt(10)/(3^(1/4))), used in length computations (computed and cached) + + GCodeState_t gm; // Gcode model state - passed from model, used by planner and runtime + + // clears the above structure + void reset() { + //memset((void *)(this), 0, sizeof(mpBuffer_to_clear)); // slower on the M3. Test for M7 + + bf_func = nullptr; + cm_func = nullptr; + + linenum = 0; + iterations = 0; + block_time_ms = 0; + plannable_time_ms = 0; + plannable_length = 0; + meet_iterations = 0; + + buffer_state = MP_BUFFER_EMPTY; + block_type = BLOCK_TYPE_NULL; + block_state = BLOCK_INACTIVE; + hint = NO_HINT; + + for (uint8_t i = 0; i< AXES; i++) { + unit[i] = 0; + axis_flags[i] = 0; + } + + plannable = false; + length = 0.0; + block_time = 0.0; + override_factor = 0.0; + cruise_velocity = 0.0; + exit_velocity = 0.0; + cruise_vset = 0.0; + cruise_vmax = 0.0; + exit_vmax = 0.0; + absolute_vmax = 0.0; + junction_vmax = 0.0; + jerk = 0.0; + jerk_sq = 0.0; + recip_jerk = 0.0; + sqrt_j = 0.0; + q_recip_2_sqrt_j = 0.0; + gm.reset(); + } + } mpBuf_t; typedef struct mpQueue { // a planner buffer queue @@ -566,9 +665,6 @@ void mp_start_feed_override(const float ramp_time, const float override); void mp_end_feed_override(const float ramp_time); void mp_planner_time_accounting(void); -stat_t mp_switch_q(nvObj_t *nv); -stat_t mp_return_q(nvObj_t *nv); - // planner buffer primitives void mp_init_buffers(void); mpBuf_t * mp_get_w(int8_t q);