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

general clean up after refactoring

Browse Source
This commit is contained in:
Simen Svale Skogsrud 2010-03-03 13:04:51 +01:00
parent 49ca861dc0
commit 7e152851cc
8 changed files with 18 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
config.h
View File

@ -21,7 +21,7 @@
#ifndef config_h
#define config_h
#define VERSION "0.0"
#define VERSION "0.5"
#define X_STEPS_PER_MM (94.488188976378*16)
#define Y_STEPS_PER_MM (94.488188976378*16)

2
main.c
View File

@ -39,8 +39,6 @@ int main(void)
gc_init(); // initialize gcode-parser
sp_init(); // initialize the serial protocol
st_start(); // start the stepper subsystem
DDRD |= (1<<3)|(1<<4)|(1<<5);
for(;;){

33
motion_control.c
View File

@ -40,27 +40,20 @@
#define ONE_MINUTE_OF_MICROSECONDS 60000000.0
volatile int8_t mode; // The current operation mode
int32_t position[3]; // The current position of the tool in absolute steps
uint8_t direction_bits; // The direction bits to be used with any upcoming step-instruction
void set_stepper_directions(int8_t *direction);
inline void step_steppers(uint8_t bits);
inline void step_axis(uint8_t axis);
void prepare_linear_motion(uint32_t x, uint32_t y, uint32_t z, float feed_rate, int invert_feed_rate);
void mc_init()
{
mode = MC_MODE_AT_REST;
clear_vector(position);
}
void mc_dwell(uint32_t milliseconds)
{
mode = MC_MODE_DWELL;
st_synchronize();
_delay_ms(milliseconds);
mode = MC_MODE_AT_REST;
st_buffer_line(0, 0, 0, milliseconds*1000);
}
// Execute linear motion in absolute millimeter coordinates. Feed rate given in millimeters/second
@ -128,30 +121,6 @@ void mc_arc(double theta, double angular_travel, double radius, double linear_tr
void mc_go_home()
{
mode = MC_MODE_HOME;
st_go_home();
st_synchronize();
clear_vector(position); // By definition this is location [0, 0, 0]
mode = MC_MODE_AT_REST;
}
int mc_status()
{
return(mode);
}
// Set the direction bits for the stepper motors according to the provided vector.
// direction is an array of three 8 bit integers representing the direction of
// each motor. The values should be negative (reverse), 0 or positive (forward).
void set_stepper_directions(int8_t *direction)
{
/* Sorry about this convoluted code! It uses the fact that bit 7 of each direction
int is set when the direction == -1, but is 0 when direction is forward. This
way we can generate the whole direction bit-mask without doing any comparisions
or branching. Fast and compact, yet practically unreadable. Sorry sorry sorry.
*/
direction_bits = (
((direction[X_AXIS]&0x80)>>(7-X_DIRECTION_BIT)) |
((direction[Y_AXIS]&0x80)>>(7-Y_DIRECTION_BIT)) |
((direction[Z_AXIS]&0x80)>>(7-Z_DIRECTION_BIT)));
}

43
serial_protocol.c
View File

@ -26,40 +26,13 @@
#include <math.h>
#include "nuts_bolts.h"
#define LINE_BUFFER_SIZE 128
#define LINE_BUFFER_SIZE 60
char line[LINE_BUFFER_SIZE];
uint8_t line_counter;
uint8_t char_counter;
void prompt() {
printString("ok\r\n");
line_counter = 0;
}
void print_result() {
double position[3];
int inches_mode;
uint8_t status_code;
uint32_t line_number;
int i; // loop variable
gc_get_status(position, &status_code, &inches_mode, &line_number);
printString("\r\n[ ");
for(i=X_AXIS; i<=Z_AXIS; i++) {
printInteger(trunc(position[i]*100));
printByte(' ');
}
printByte(']');
printByte('@');
printInteger(line_number);
printByte(':');
switch(status_code) {
case GCSTATUS_OK: printString("0 OK\r\n"); break;
case GCSTATUS_BAD_NUMBER_FORMAT: printString("1 Bad number format\r\n"); break;
case GCSTATUS_EXPECTED_COMMAND_LETTER: printString("2 Expected command letter\r\n"); break;
case GCSTATUS_UNSUPPORTED_STATEMENT: printString("3 Unsupported statement\r\n"); break;
case GCSTATUS_MOTION_CONTROL_ERROR: printString("4 Motion control error\r\n"); break;
case GCSTATUS_FLOATING_POINT_ERROR: printString("5 Floating point error\r\n"); break;
}
}
void sp_init()
@ -78,19 +51,15 @@ void sp_process()
while((c = serialRead()) != -1)
{
if((c == '\n')) { // Line is complete. Then execute!
line[line_counter] = 0;
// printString("->");
// printString(line);
// printString("<-\r\n");
line[char_counter] = 0;
gc_execute_line(line);
line_counter = 0;
char_counter = 0;
prompt();
} else if (c <= ' ') { // Throw away whitepace and control characters
} else if (c >= 'a' && c <= 'z') { // Upcase lowercase
line[line_counter++] = c-'a'+'A';
line[char_counter++] = c-'a'+'A';
} else {
line[line_counter++] = c;
line[char_counter++] = c;
}
}
}

2
serial_protocol.h
View File

@ -27,8 +27,6 @@
// Initialize the serial protocol
void sp_init();
// Called by motion control just before the motion starts
void sp_send_execution_marker();
// Read command lines from the serial port and execute them as they
// come in. Blocks until the serial buffer is emptied.
void sp_process();

88
stepper.c
View File

@ -33,7 +33,7 @@
#include "wiring_serial.h"
#define TICKS_PER_MICROSECOND (F_CPU/1000000)
#define LINE_BUFFER_SIZE 8
#define LINE_BUFFER_SIZE 10
struct Line {
uint32_t steps_x, steps_y, steps_z;
@ -52,15 +52,11 @@ struct Line *current_line;
volatile int32_t counter_x, counter_y, counter_z;
uint32_t iterations;
uint8_t stepper_mode = STEPPER_MODE_STOPPED;
void config_pace_timer(uint32_t microseconds);
void config_step_timer(uint32_t microseconds);
// Add a new linear movement to the buffer. steps_x, _y and _z is the signed, relative motion in
// steps. Microseconds specify how many microseconds the move should take to perform.
void st_buffer_line(int32_t steps_x, int32_t steps_y, int32_t steps_z, uint32_t microseconds) {
// Buffer nothing unless stepping subsystem is running
if (stepper_mode != STEPPER_MODE_RUNNING) { return; }
// Calculate the buffer head after we push this byte
int next_buffer_head = (line_buffer_head + 1) % LINE_BUFFER_SIZE;
// If the buffer is full: good! That means we are well ahead of the robot.
@ -108,7 +104,7 @@ SIGNAL(SIG_OUTPUT_COMPARE1A)
PORTD ^= (1<<5);
// Retrieve a new line and get ready to step it
current_line = &line_buffer[line_buffer_tail];
config_pace_timer(current_line->rate);
config_step_timer(current_line->rate);
counter_x = -(current_line->maximum_steps/2);
counter_y = counter_x;
counter_z = counter_x;
@ -182,24 +178,21 @@ void st_init()
TCCR2A = 0; // Normal operation
TCCR2B = (1<<CS21); // Full speed, 1/8 prescaler
TIMSK2 = 0; // All interrupts disabled
TIMSK2 |= (1<<TOIE2);
// set enable pin
STEPPERS_ENABLE_PORT |= 1<<STEPPERS_ENABLE_BIT;
sei();
// start off with a mellow pace
config_pace_timer(20000);
}
// Block until all buffered steps are executed
void st_synchronize()
{
if (stepper_mode == STEPPER_MODE_RUNNING) {
while(line_buffer_tail != line_buffer_head) { sleep_mode(); }
} else {
st_flush();
}
while(line_buffer_tail != line_buffer_head) { sleep_mode(); }
}
// Cancel all pending steps
// Cancel all buffered steps
void st_flush()
{
cli();
@ -208,42 +201,8 @@ void st_flush()
sei();
}
// Start the stepper subsystem
void st_start()
{
// Enable timer interrupts
TIMSK1 |= (1<<OCIE1A);
TIMSK2 |= (1<<TOIE2);
// set enable pin
STEPPERS_ENABLE_PORT |= 1<<STEPPERS_ENABLE_BIT;
stepper_mode = STEPPER_MODE_RUNNING;
}
// Execute all buffered steps, then stop the stepper subsystem
inline void st_stop()
{
// flush pending operations
st_synchronize();
// disable timer interrupts
TIMSK1 &= ~(1<<OCIE1A);
TIMSK2 &= ~(1<<TOIE2);
// reset enable pin
STEPPERS_ENABLE_PORT &= ~(1<<STEPPERS_ENABLE_BIT);
stepper_mode = STEPPER_MODE_STOPPED;
}
// Returns a bitmask with the stepper bit for the given axis set
uint8_t st_bit_for_stepper(int axis) {
switch(axis) {
case X_AXIS: return(1<<X_STEP_BIT);
case Y_AXIS: return(1<<Y_STEP_BIT);
case Z_AXIS: return(1<<Z_STEP_BIT);
}
return(0);
}
// Configures the prescaler and ceiling of timer 1 to produce the given pace as accurately as possible.
void config_pace_timer(uint32_t microseconds)
void config_step_timer(uint32_t microseconds)
{
uint32_t ticks = microseconds*TICKS_PER_MICROSECOND;
uint16_t ceiling;
@ -274,34 +233,7 @@ void config_pace_timer(uint32_t microseconds)
OCR1A = ceiling;
}
int check_limit_switches()
{
// Dual read as crude debounce
return((LIMIT_PORT & LIMIT_MASK) | (LIMIT_PORT & LIMIT_MASK));
}
int check_limit_switch(int axis)
{
uint8_t mask = 0;
switch (axis) {
case X_AXIS: mask = 1<<X_LIMIT_BIT; break;
case Y_AXIS: mask = 1<<Y_LIMIT_BIT; break;
case Z_AXIS: mask = 1<<Z_LIMIT_BIT; break;
}
return((LIMIT_PORT&mask) || (LIMIT_PORT&mask));
}
void st_go_home()
{
// Todo: Perform the homing cycle
}
// Convert from millimeters to step-counts along the designated axis
int32_t st_millimeters_to_steps(double millimeters, int axis) {
switch(axis) {
case X_AXIS: return(round(millimeters*X_STEPS_PER_MM));
case Y_AXIS: return(round(millimeters*Y_STEPS_PER_MM));
case Z_AXIS: return(round(millimeters*Z_STEPS_PER_MM));
}
return(0);
}

15
stepper.h
View File

@ -32,9 +32,6 @@
// Initialize and start the stepper motor subsystem
void st_init();
// Returns a bitmask with the stepper bit for the given axis set
uint8_t st_bit_for_stepper(int axis);
// Add a new linear movement to the buffer. steps_x, _y and _z is the signed, relative motion in
// steps. Microseconds specify how many microseconds the move should take to perform.
void st_buffer_line(int32_t steps_x, int32_t steps_y, int32_t steps_z, uint32_t rate);
@ -45,19 +42,7 @@ void st_synchronize();
// Cancel all pending steps
void st_flush();
// Start the stepper subsystem
void st_start();
// Execute all buffered steps, then stop the stepper subsystem
inline void st_stop();
// Execute the homing cycle
void st_go_home();
// Echo steps to serial port? (true/false)
void st_set_echo(int value);
// Convert from millimeters to step-counts along the designated axis
int32_t st_millimeters_to_steps(double millimeters, int axis);
#endif

13
todo.txt
View File

@ -1,19 +1,6 @@
* Use errno to detect fp-errors
* Optimize arc target detection code utilizing the primary axis of travel
* Arcs might be a step or two off because of FP gotchas. Must add a little nudge in the end there?
* Implement homing cycle in stepper.c
* Implement limit switch support in stepper.c (use port-triggered interrupts?)
* How on earth am I going to deal with arcs in setups that have different steps/mm on each axis? Must
support elipses?! Oh no.
* Eliminate need for x and y in step_arc_along_
* Tool table
* Tool length offsets
* Tool change M6
* Path Control Modes
* Spindle speed support
Bugs to fix:
This generates an infinite sequence of non-steppings
G01 X152.730364 Y331.534522
G03 X152.30001 Y331.959998 I-1.959917 J-1.552007