Mirrors_Framework/g2
1
0
Fork 0
mirror of https://github.com/synthetos/g2.git synced 2026-02-06 02:51:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Prep for on feedhold context switch; Minor change to buffer structure; Added designators to gQuintic pinouts

Browse Source
This commit is contained in:
Alden Hart
2017-01-09 11:21:14 -05:00
parent c6138819dd
commit d66cb8b16a
8 changed files with 229 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
g2core/board/gquintic/gquintic-b-pinout.h
View File

@@ -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"

27
g2core/canonical_machine.cpp
View File

@@ -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

4
g2core/canonical_machine.h
View File

@@ -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);

4
g2core/config_app.cpp
View File

@@ -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

2
g2core/g2core_info.h
View File

@@ -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

6
g2core/gpio.cpp
View File

@@ -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));
}

24
g2core/planner.cpp
View File

@@ -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

120
g2core/planner.h
View File

@@ -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);