ManuelW/grbl-LPC-CoreXY
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Sanguino compile patch

Browse Source 
@daapp : Sanguino compile serial USART path. Thanks!
This commit is contained in:
Sonny Jeon 2012-11-08 17:24:56 -07:00
parent 5e7a4b3ba8
commit baf137882b
2 changed files with 230 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
serial.c
View File

@ -91,7 +91,11 @@ void serial_write(uint8_t data) {
} }
// Data Register Empty Interrupt handler // Data Register Empty Interrupt handler
#ifdef __AVR_ATmega644P__
ISR(USART0_UDRE_vect)
#else
ISR(USART_UDRE_vect) ISR(USART_UDRE_vect)
#endif
{ {
// Temporary tx_buffer_tail (to optimize for volatile) // Temporary tx_buffer_tail (to optimize for volatile)
uint8_t tail = tx_buffer_tail; uint8_t tail = tx_buffer_tail;
@ -140,7 +144,11 @@ uint8_t serial_read()
} }
} }
#ifdef __AVR_ATmega644P__
ISR(USART0_RX_vect)
#else
ISR(USART_RX_vect) ISR(USART_RX_vect)
#endif
{ {
uint8_t data = UDR0; uint8_t data = UDR0;
uint8_t next_head; uint8_t next_head;

445
settings.c
View File

@ -1,223 +1,222 @@
/* /*
settings.c - eeprom configuration handling settings.c - eeprom configuration handling
Part of Grbl Part of Grbl
Copyright (c) 2009-2011 Simen Svale Skogsrud Copyright (c) 2009-2011 Simen Svale Skogsrud
Copyright (c) 2011-2012 Sungeun K. Jeon Copyright (c) 2011-2012 Sungeun K. Jeon
Grbl is free software: you can redistribute it and/or modify Grbl is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
Grbl is distributed in the hope that it will be useful, Grbl is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with Grbl. If not, see <http://www.gnu.org/licenses/>. along with Grbl. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <avr/io.h> #include <avr/io.h>
#include "protocol.h" #include "protocol.h"
#include "report.h" #include "report.h"
#include "stepper.h" #include "stepper.h"
#include "nuts_bolts.h" #include "nuts_bolts.h"
#include "settings.h" #include "settings.h"
#include "eeprom.h" #include "eeprom.h"
settings_t settings; settings_t settings;
// Version 4 outdated settings record // Version 4 outdated settings record
typedef struct { typedef struct {
float steps_per_mm[3]; float steps_per_mm[3];
uint8_t microsteps; uint8_t microsteps;
uint8_t pulse_microseconds; uint8_t pulse_microseconds;
float default_feed_rate; float default_feed_rate;
float default_seek_rate; float default_seek_rate;
uint8_t invert_mask; uint8_t invert_mask;
float mm_per_arc_segment; float mm_per_arc_segment;
float acceleration; float acceleration;
float junction_deviation; float junction_deviation;
} settings_v4_t; } settings_v4_t;
// Method to store startup lines into EEPROM // Method to store startup lines into EEPROM
void settings_store_startup_line(uint8_t n, char *line) void settings_store_startup_line(uint8_t n, char *line)
{ {
uint16_t addr = n*(LINE_BUFFER_SIZE+1)+EEPROM_ADDR_STARTUP_BLOCK; uint16_t addr = n*(LINE_BUFFER_SIZE+1)+EEPROM_ADDR_STARTUP_BLOCK;
memcpy_to_eeprom_with_checksum(addr,(char*)line, LINE_BUFFER_SIZE); memcpy_to_eeprom_with_checksum(addr,(char*)line, LINE_BUFFER_SIZE);
} }
// Method to store coord data parameters into EEPROM // Method to store coord data parameters into EEPROM
void settings_write_coord_data(uint8_t coord_select, float *coord_data) void settings_write_coord_data(uint8_t coord_select, float *coord_data)
{ {
uint16_t addr = coord_select*(sizeof(float)*N_AXIS+1) + EEPROM_ADDR_PARAMETERS; uint16_t addr = coord_select*(sizeof(float)*N_AXIS+1) + EEPROM_ADDR_PARAMETERS;
memcpy_to_eeprom_with_checksum(addr,(char*)coord_data, sizeof(float)*N_AXIS); memcpy_to_eeprom_with_checksum(addr,(char*)coord_data, sizeof(float)*N_AXIS);
} }
// Method to store Grbl global settings struct and version number into EEPROM // Method to store Grbl global settings struct and version number into EEPROM
void write_global_settings() void write_global_settings()
{ {
eeprom_put_char(0, SETTINGS_VERSION); eeprom_put_char(0, SETTINGS_VERSION);
memcpy_to_eeprom_with_checksum(EEPROM_ADDR_GLOBAL, (char*)&settings, sizeof(settings_t)); memcpy_to_eeprom_with_checksum(EEPROM_ADDR_GLOBAL, (char*)&settings, sizeof(settings_t));
} }
// Method to reset Grbl global settings back to defaults. // Method to reset Grbl global settings back to defaults.
void settings_reset(bool reset_all) { void settings_reset(bool reset_all) {
// Reset all settings or only the migration settings to the new version. // Reset all settings or only the migration settings to the new version.
if (reset_all) { if (reset_all) {
settings.steps_per_mm[X_AXIS] = DEFAULT_X_STEPS_PER_MM; settings.steps_per_mm[X_AXIS] = DEFAULT_X_STEPS_PER_MM;
settings.steps_per_mm[Y_AXIS] = DEFAULT_Y_STEPS_PER_MM; settings.steps_per_mm[Y_AXIS] = DEFAULT_Y_STEPS_PER_MM;
settings.steps_per_mm[Z_AXIS] = DEFAULT_Z_STEPS_PER_MM; settings.steps_per_mm[Z_AXIS] = DEFAULT_Z_STEPS_PER_MM;
settings.pulse_microseconds = DEFAULT_STEP_PULSE_MICROSECONDS; settings.pulse_microseconds = DEFAULT_STEP_PULSE_MICROSECONDS;
settings.default_feed_rate = DEFAULT_FEEDRATE; settings.default_feed_rate = DEFAULT_FEEDRATE;
settings.default_seek_rate = DEFAULT_RAPID_FEEDRATE; settings.default_seek_rate = DEFAULT_RAPID_FEEDRATE;
settings.acceleration = DEFAULT_ACCELERATION; settings.acceleration = DEFAULT_ACCELERATION;
settings.mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT; settings.mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT;
settings.invert_mask = DEFAULT_STEPPING_INVERT_MASK; settings.invert_mask = DEFAULT_STEPPING_INVERT_MASK;
settings.junction_deviation = DEFAULT_JUNCTION_DEVIATION; settings.junction_deviation = DEFAULT_JUNCTION_DEVIATION;
} }
// New settings since last version // New settings since last version
settings.flags = 0; settings.flags = 0;
if (DEFAULT_REPORT_INCHES) { settings.flags |= BITFLAG_REPORT_INCHES; } if (DEFAULT_REPORT_INCHES) { settings.flags |= BITFLAG_REPORT_INCHES; }
if (DEFAULT_AUTO_START) { settings.flags |= BITFLAG_AUTO_START; } if (DEFAULT_AUTO_START) { settings.flags |= BITFLAG_AUTO_START; }
if (DEFAULT_INVERT_ST_ENABLE) { settings.flags |= BITFLAG_INVERT_ST_ENABLE; } if (DEFAULT_INVERT_ST_ENABLE) { settings.flags |= BITFLAG_INVERT_ST_ENABLE; }
if (DEFAULT_HARD_LIMIT_ENABLE) { settings.flags |= BITFLAG_HARD_LIMIT_ENABLE; } if (DEFAULT_HARD_LIMIT_ENABLE) { settings.flags |= BITFLAG_HARD_LIMIT_ENABLE; }
if (DEFAULT_HOMING_ENABLE) { settings.flags |= BITFLAG_HOMING_ENABLE; } if (DEFAULT_HOMING_ENABLE) { settings.flags |= BITFLAG_HOMING_ENABLE; }
settings.homing_dir_mask = DEFAULT_HOMING_DIR_MASK; settings.homing_dir_mask = DEFAULT_HOMING_DIR_MASK;
settings.homing_feed_rate = DEFAULT_HOMING_FEEDRATE; settings.homing_feed_rate = DEFAULT_HOMING_FEEDRATE;
settings.homing_seek_rate = DEFAULT_HOMING_RAPID_FEEDRATE; settings.homing_seek_rate = DEFAULT_HOMING_RAPID_FEEDRATE;
settings.homing_debounce_delay = DEFAULT_HOMING_DEBOUNCE_DELAY; settings.homing_debounce_delay = DEFAULT_HOMING_DEBOUNCE_DELAY;
settings.homing_pulloff = DEFAULT_HOMING_PULLOFF; settings.homing_pulloff = DEFAULT_HOMING_PULLOFF;
settings.stepper_idle_lock_time = DEFAULT_STEPPER_IDLE_LOCK_TIME; settings.stepper_idle_lock_time = DEFAULT_STEPPER_IDLE_LOCK_TIME;
settings.decimal_places = DEFAULT_DECIMAL_PLACES; settings.decimal_places = DEFAULT_DECIMAL_PLACES;
settings.n_arc_correction = DEFAULT_N_ARC_CORRECTION; settings.n_arc_correction = DEFAULT_N_ARC_CORRECTION;
write_global_settings(); write_global_settings();
} }
// Reads startup line from EEPROM. Updated pointed line string data. // Reads startup line from EEPROM. Updated pointed line string data.
uint8_t settings_read_startup_line(uint8_t n, char *line) uint8_t settings_read_startup_line(uint8_t n, char *line)
{ {
uint16_t addr = n*(LINE_BUFFER_SIZE+1)+EEPROM_ADDR_STARTUP_BLOCK; uint16_t addr = n*(LINE_BUFFER_SIZE+1)+EEPROM_ADDR_STARTUP_BLOCK;
if (!(memcpy_from_eeprom_with_checksum((char*)line, addr, LINE_BUFFER_SIZE))) { if (!(memcpy_from_eeprom_with_checksum((char*)line, addr, LINE_BUFFER_SIZE))) {
// Reset line with default value // Reset line with default value
// TODO: Need to come up with a method to do this. line[0] = 0;
line[0] = 0; settings_store_startup_line(n, line);
settings_store_startup_line(n, line); return(false);
return(false); } else {
} else { return(true);
return(true); }
} }
}
// Read selected coordinate data from EEPROM. Updates pointed coord_data value.
// Read selected coordinate data from EEPROM. Updates pointed coord_data value. uint8_t settings_read_coord_data(uint8_t coord_select, float *coord_data)
uint8_t settings_read_coord_data(uint8_t coord_select, float *coord_data) {
{ uint16_t addr = coord_select*(sizeof(float)*N_AXIS+1) + EEPROM_ADDR_PARAMETERS;
uint16_t addr = coord_select*(sizeof(float)*N_AXIS+1) + EEPROM_ADDR_PARAMETERS; if (!(memcpy_from_eeprom_with_checksum((char*)coord_data, addr, sizeof(float)*N_AXIS))) {
if (!(memcpy_from_eeprom_with_checksum((char*)coord_data, addr, sizeof(float)*N_AXIS))) { // Reset with default zero vector
// Reset with default zero vector clear_vector_float(coord_data);
clear_vector_float(coord_data); settings_write_coord_data(coord_select,coord_data);
settings_write_coord_data(coord_select,coord_data); return(false);
return(false); } else {
} else { return(true);
return(true); }
} }
}
// Reads Grbl global settings struct from EEPROM.
// Reads Grbl global settings struct from EEPROM. uint8_t read_global_settings() {
uint8_t read_global_settings() { // Check version-byte of eeprom
// Check version-byte of eeprom uint8_t version = eeprom_get_char(0);
uint8_t version = eeprom_get_char(0);
if (version == SETTINGS_VERSION) {
if (version == SETTINGS_VERSION) { // Read settings-record and check checksum
// Read settings-record and check checksum if (!(memcpy_from_eeprom_with_checksum((char*)&settings, EEPROM_ADDR_GLOBAL, sizeof(settings_t)))) {
if (!(memcpy_from_eeprom_with_checksum((char*)&settings, EEPROM_ADDR_GLOBAL, sizeof(settings_t)))) { return(false);
return(false); }
} } else {
} else { if (version <= 4) {
if (version <= 4) { // Migrate from settings version 4 to current version.
// Migrate from settings version 4 to current version. if (!(memcpy_from_eeprom_with_checksum((char*)&settings, 1, sizeof(settings_v4_t)))) {
if (!(memcpy_from_eeprom_with_checksum((char*)&settings, 1, sizeof(settings_v4_t)))) { return(false);
return(false); }
} settings_reset(false); // Old settings ok. Write new settings only.
settings_reset(false); // Old settings ok. Write new settings only. } else {
} else { return(false);
return(false); }
} }
} return(true);
return(true); }
}
// A helper method to set settings from command line
// A helper method to set settings from command line uint8_t settings_store_global_setting(int parameter, float value) {
uint8_t settings_store_global_setting(int parameter, float value) { switch(parameter) {
switch(parameter) { case 0: case 1: case 2:
case 0: case 1: case 2: if (value <= 0.0) { return(STATUS_SETTING_VALUE_NEG); }
if (value <= 0.0) { return(STATUS_SETTING_VALUE_NEG); } settings.steps_per_mm[parameter] = value; break;
settings.steps_per_mm[parameter] = value; break; case 3:
case 3: if (value < 3) { return(STATUS_SETTING_STEP_PULSE_MIN); }
if (value < 3) { return(STATUS_SETTING_STEP_PULSE_MIN); } settings.pulse_microseconds = round(value); break;
settings.pulse_microseconds = round(value); break; case 4: settings.default_feed_rate = value; break;
case 4: settings.default_feed_rate = value; break; case 5: settings.default_seek_rate = value; break;
case 5: settings.default_seek_rate = value; break; case 6: settings.invert_mask = trunc(value); break;
case 6: settings.invert_mask = trunc(value); break; case 7: settings.stepper_idle_lock_time = round(value); break;
case 7: settings.stepper_idle_lock_time = round(value); break; case 8: settings.acceleration = value*60*60; break; // Convert to mm/min^2 for grbl internal use.
case 8: settings.acceleration = value*60*60; break; // Convert to mm/min^2 for grbl internal use. case 9: settings.junction_deviation = fabs(value); break;
case 9: settings.junction_deviation = fabs(value); break; case 10: settings.mm_per_arc_segment = value; break;
case 10: settings.mm_per_arc_segment = value; break; case 11: settings.n_arc_correction = round(value); break;
case 11: settings.n_arc_correction = round(value); break; case 12: settings.decimal_places = round(value); break;
case 12: settings.decimal_places = round(value); break; case 13:
case 13: if (value) { settings.flags |= BITFLAG_REPORT_INCHES; }
if (value) { settings.flags |= BITFLAG_REPORT_INCHES; } else { settings.flags &= ~BITFLAG_REPORT_INCHES; }
else { settings.flags &= ~BITFLAG_REPORT_INCHES; } break;
break; case 14: // Reboot to ensure change
case 14: // Reboot to ensure change if (value) { settings.flags |= BITFLAG_AUTO_START; }
if (value) { settings.flags |= BITFLAG_AUTO_START; } else { settings.flags &= ~BITFLAG_AUTO_START; }
else { settings.flags &= ~BITFLAG_AUTO_START; } break;
break; case 15: // Reboot to ensure change
case 15: // Reboot to ensure change if (value) { settings.flags |= BITFLAG_INVERT_ST_ENABLE; }
if (value) { settings.flags |= BITFLAG_INVERT_ST_ENABLE; } else { settings.flags &= ~BITFLAG_INVERT_ST_ENABLE; }
else { settings.flags &= ~BITFLAG_INVERT_ST_ENABLE; } break;
break; case 16: // Reboot to ensure change
case 16: // Reboot to ensure change if (value) { settings.flags |= BITFLAG_HARD_LIMIT_ENABLE; }
if (value) { settings.flags |= BITFLAG_HARD_LIMIT_ENABLE; } else { settings.flags &= ~BITFLAG_HARD_LIMIT_ENABLE; }
else { settings.flags &= ~BITFLAG_HARD_LIMIT_ENABLE; } break;
break; case 17:
case 17: if (value) {
if (value) { settings.flags |= BITFLAG_HOMING_ENABLE;
settings.flags |= BITFLAG_HOMING_ENABLE; sys.state = STATE_ALARM;
sys.state = STATE_ALARM; report_feedback_message(MESSAGE_HOMING_ALARM);
report_feedback_message(MESSAGE_HOMING_ALARM); } else { settings.flags &= ~BITFLAG_HOMING_ENABLE; }
} else { settings.flags &= ~BITFLAG_HOMING_ENABLE; } break;
break; case 18: settings.homing_dir_mask = trunc(value); break;
case 18: settings.homing_dir_mask = trunc(value); break; case 19: settings.homing_feed_rate = value; break;
case 19: settings.homing_feed_rate = value; break; case 20: settings.homing_seek_rate = value; break;
case 20: settings.homing_seek_rate = value; break; case 21: settings.homing_debounce_delay = round(value); break;
case 21: settings.homing_debounce_delay = round(value); break; case 22: settings.homing_pulloff = value; break;
case 22: settings.homing_pulloff = value; break; default:
default: return(STATUS_INVALID_STATEMENT);
return(STATUS_INVALID_STATEMENT); }
} write_global_settings();
write_global_settings(); return(STATUS_OK);
return(STATUS_OK); }
}
// Initialize the config subsystem
// Initialize the config subsystem void settings_init() {
void settings_init() { if(!read_global_settings()) {
if(!read_global_settings()) { report_status_message(STATUS_SETTING_READ_FAIL);
report_status_message(STATUS_SETTING_READ_FAIL); settings_reset(true);
settings_reset(true); report_grbl_settings();
report_grbl_settings(); }
} // Read all parameter data into a dummy variable. If error, reset to zero, otherwise do nothing.
// Read all parameter data into a dummy variable. If error, reset to zero, otherwise do nothing. float coord_data[N_AXIS];
float coord_data[N_AXIS]; uint8_t i;
uint8_t i; for (i=0; i<=SETTING_INDEX_NCOORD; i++) {
for (i=0; i<=SETTING_INDEX_NCOORD; i++) { if (!settings_read_coord_data(i, coord_data)) {
if (!settings_read_coord_data(i, coord_data)) { report_status_message(STATUS_SETTING_READ_FAIL);
report_status_message(STATUS_SETTING_READ_FAIL); }
} }
} // NOTE: Startup lines are handled and called by main.c at the end of initialization.
// NOTE: Startup lines are handled and called by protocol_init(). }
}