bissen21/Marlin_Firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases 4 Wiki Activity

Move L64XX index_to_axis to progmem (#16697)

Browse Source
This commit is contained in:
Scott Lahteine
2020-01-30 03:24:23 -06:00
committed by GitHub
parent 99b6a132bc
commit 50889c0f94
12 changed files with 539 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
Marlin/src/libs/L64XX/L64XX_Marlin.cpp
View File

@ -39,39 +39,40 @@ L64XX_Marlin L64xxManager;
void echo_yes_no(const bool yes) { serialprintPGM(yes ? PSTR(" YES") : PSTR(" NO ")); }
char L64XX_Marlin::index_to_axis[MAX_L64XX][3] = { "X ", "Y ", "Z ", "X2", "Y2", "Z2", "Z3", "Z4", "E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7" };
static const char str_X[] PROGMEM = "X ", str_Y[] PROGMEM = "Y ", str_Z[] PROGMEM = "Z ",
str_X2[] PROGMEM = "X2", str_Y2[] PROGMEM = "Y2",
str_Z2[] PROGMEM = "Z2", str_Z3[] PROGMEM = "Z3", str_Z4[] PROGMEM = "Z4",
str_E0[] PROGMEM = "E0", str_E1[] PROGMEM = "E1",
str_E2[] PROGMEM = "E2", str_E3[] PROGMEM = "E3",
str_E4[] PROGMEM = "E4", str_E5[] PROGMEM = "E5",
str_E6[] PROGMEM = "E6", str_E7[] PROGMEM = "E7"
;
PGM_P const L64XX_Marlin::index_to_axis[] PROGMEM = {
str_X, str_Y, str_Z, str_X2, str_Y2, str_Z2, str_Z3, str_Z4,
str_E0, str_E1, str_E2, str_E3, str_E4, str_E5, str_E6, str_E7
};
#define DEBUG_OUT ENABLED(L6470_CHITCHAT)
#include "../../core/debug_out.h"
uint8_t L64XX_Marlin::dir_commands[MAX_L64XX]; // array to hold direction command for each driver
uint8_t L64XX_Marlin::index_to_dir[MAX_L64XX] = { (INVERT_X_DIR), // 0 X
(INVERT_Y_DIR), // 1 Y
(INVERT_Z_DIR), // 2 Z
#if ENABLED(X_DUAL_STEPPER_DRIVERS) // 3 X2
(INVERT_X_DIR) ^ (INVERT_X2_VS_X_DIR),
#else
(INVERT_X_DIR),
#endif
#if ENABLED(Y_DUAL_STEPPER_DRIVERS) // 4 Y2
(INVERT_Y_DIR) ^ (INVERT_Y2_VS_Y_DIR),
#else
(INVERT_Y_DIR),
#endif
(INVERT_Z_DIR), // 5 Z2
(INVERT_Z_DIR), // 6 Z3
(INVERT_Z_DIR), // 7 Z4
const uint8_t L64XX_Marlin::index_to_dir[MAX_L64XX] = {
INVERT_X_DIR, INVERT_Y_DIR, INVERT_Z_DIR
, (INVERT_X_DIR) // X2
#if ENABLED(X_DUAL_STEPPER_DRIVERS)
^ (INVERT_X2_VS_X_DIR)
#endif
, (INVERT_Y_DIR) // Y2
#if ENABLED(Y_DUAL_STEPPER_DRIVERS)
^ (INVERT_Y2_VS_Y_DIR)
#endif
, INVERT_Z_DIR, INVERT_Z_DIR, INVERT_Z_DIR // Z2,Z3,Z4
(INVERT_E0_DIR), // 8 E0
(INVERT_E1_DIR), // 9 E1
(INVERT_E2_DIR), // 10 E2
(INVERT_E3_DIR), // 11 E3
(INVERT_E4_DIR), // 12 E4
(INVERT_E5_DIR), // 13 E5
(INVERT_E6_DIR), // 14 E6
(INVERT_E7_DIR) // 15 E7
};
, INVERT_E0_DIR, INVERT_E1_DIR, INVERT_E2_DIR, INVERT_E3_DIR
, INVERT_E4_DIR, INVERT_E5_DIR, INVERT_E6_DIR, INVERT_E7_DIR
};
volatile uint8_t L64XX_Marlin::spi_abort = false;
uint8_t L64XX_Marlin::spi_active = false;
@ -379,35 +380,27 @@ uint8_t L64XX_Marlin::get_user_input(uint8_t &driver_count, L64XX_axis_t axis_in
found_displacement = true;
displacement = _displacement;
uint8_t axis_offset = parser.byteval('J');
axis_mon[0][0] = axis_codes[i]; // axis ASCII value (target character)
axis_mon[0][0] = axis_codes[i]; // Axis first character, one of XYZE
const bool single_or_e = axis_offset >= 2 || axis_mon[0][0] == 'E',
one_or_more = !single_or_e && axis_offset == 0;
uint8_t driver_count_local = 0; // Can't use "driver_count" directly as a subscript because it's passed by reference
if (axis_offset >= 2 || axis_mon[0][0] == 'E') { // Single axis, E0, or E1
axis_mon[0][1] = axis_offset + '0';
for (j = 0; j < MAX_L64XX; j++) { // See how many drivers on this axis
const char * const str = index_to_axis[j];
if (axis_mon[0][0] == str[0]) {
char * const mon = axis_mon[driver_count_local];
mon[0] = str[0];
mon[1] = str[1];
mon[2] = str[2]; // append end of string
axis_index[driver_count_local] = (L64XX_axis_t)j; // set axis index
if (single_or_e) // Single axis, E0, or E1
axis_mon[0][1] = axis_offset + '0'; // Index given by 'J' parameter
if (single_or_e || one_or_more) {
for (j = 0; j < MAX_L64XX; j++) { // Count up the drivers on this axis
PGM_P str = (PGM_P)pgm_read_ptr(&index_to_axis[j]); // Get a PGM_P from progmem
const char c = pgm_read_byte(str); // Get a char from progmem
if (axis_mon[0][0] == c) { // For each stepper on this axis...
char *mon = axis_mon[driver_count_local];
*mon++ = c; // Copy the 3 letter axis name
*mon++ = pgm_read_byte(&str[1]); // to the axis_mon array
*mon = pgm_read_byte(&str[2]);
axis_index[driver_count_local] = (L64XX_axis_t)j; // And store the L64XX axis index
driver_count_local++;
}
}
}
else if (axis_offset == 0) { // One or more axes
for (j = 0; j < MAX_L64XX; j++) { // See how many drivers on this axis
const char * const str = index_to_axis[j];
if (axis_mon[0][0] == str[0]) {
char * const mon = axis_mon[driver_count_local];
mon[0] = str[0];
mon[1] = str[1];
mon[2] = str[2]; // append end of string
axis_index[driver_count_local] = (L64XX_axis_t)j; // set axis index
driver_count_local++;
}
}
driver_count = driver_count_local;
if (one_or_more) driver_count = driver_count_local;
}
break; // only take first axis found
}
@ -494,8 +487,8 @@ uint8_t L64XX_Marlin::get_user_input(uint8_t &driver_count, L64XX_axis_t axis_in
for (uint8_t k = 0; k < driver_count; k++) {
uint8_t not_found = true;
for (j = 1; j <= L64XX::chain[0]; j++) {
const char * const ind_axis = index_to_axis[L64XX::chain[j]];
if (ind_axis[0] == axis_mon[k][0] && ind_axis[1] == axis_mon[k][1]) { // See if a L6470 driver
PGM_P const str = (PGM_P)pgm_read_ptr(&index_to_axis[L64XX::chain[j]]);
if (pgm_read_byte(&str[0]) == axis_mon[k][0] && pgm_read_byte(&str[1]) == axis_mon[k][1]) { // See if a L6470 driver
not_found = false;
break;
}
@ -724,7 +717,8 @@ void L64XX_Marlin::say_axis(const L64XX_axis_t axis, const uint8_t label/*=true*
};
void L64XX_Marlin::append_stepper_err(char* &p, const uint8_t stepper_index, const char * const err/*=nullptr*/) {
p += sprintf_P(p, PSTR("Stepper %c%c "), index_to_axis[stepper_index][0], index_to_axis[stepper_index][1]);
PGM_P const str = (PGM_P)pgm_read_ptr(&index_to_axis[stepper_index]);
p += sprintf_P(p, PSTR("Stepper %c%c "), pgm_read_byte(&str[0]), pgm_read_byte(&str[1]));
if (err) p += sprintf_P(p, err);
}

6
Marlin/src/libs/L64XX/L64XX_Marlin.h
View File

@ -39,9 +39,10 @@ enum L64XX_axis_t : uint8_t { X, Y, Z, X2, Y2, Z2, Z3, Z4, E0, E1, E2, E3, E4, E
class L64XX_Marlin : public L64XXHelper {
public:
static char index_to_axis[MAX_L64XX][3];
static PGM_P const index_to_axis[MAX_L64XX];
static const uint8_t index_to_dir[MAX_L64XX];
static uint8_t index_to_dir[MAX_L64XX];
static uint8_t dir_commands[MAX_L64XX];
// Flags to guarantee graceful switch if stepper interrupts L6470 SPI transfer
@ -69,7 +70,6 @@ public:
static void transfer(uint8_t L6470_buf[], const uint8_t length);
//static char* index_to_axis(const uint8_t index);
static void say_axis(const L64XX_axis_t axis, const uint8_t label=true);
#if ENABLED(L6470_CHITCHAT)
static void error_status_decode(