josh
/
Teacup_Firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

time to save again, DDA doesn't like negative moves at the moment

This commit is contained in:
Michael Moon 2010-01-24 11:32:11 +11:00
parent bde8ab776d
commit 6fb725a813
7 changed files with 63 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
mendel/dda.c
View File

@ -74,13 +74,10 @@ void next_move() {
*/
// courtesy of http://www.oroboro.com/rafael/docserv.php/index/programming/article/distance
uint32_t approx_distance( int32_t dx, int32_t dy )
uint32_t approx_distance( uint32_t dx, uint32_t dy )
{
uint32_t min, max, approx;
if ( dx < 0 ) dx = -dx;
if ( dy < 0 ) dy = -dy;
if ( dx < dy )
{
min = dx;
@ -99,14 +96,10 @@ uint32_t approx_distance( int32_t dx, int32_t dy )
}
// courtesy of http://www.oroboro.com/rafael/docserv.php/index/programming/article/distance
uint32_t approx_distance_3( int32_t dx, int32_t dy, int32_t dz )
uint32_t approx_distance_3( uint32_t dx, uint32_t dy, uint32_t dz )
{
uint32_t min, med, max, approx;
if ( dx < 0 ) dx = -dx;
if ( dy < 0 ) dy = -dy;
if ( dz < 0 ) dz = -dz;
if ( dx < dy )
{
min = dy;
@ -116,12 +109,12 @@ uint32_t approx_distance_3( int32_t dx, int32_t dy, int32_t dz )
med = dy;
}
if ( dz < (int32_t)min )
if ( dz < min )
{
max = med;
med = min;
min = dz;
} else if ( dz < (int32_t)med ) {
} else if ( dz < med ) {
max = med;
med = dz;
} else {
@ -139,8 +132,8 @@ uint32_t approx_distance_3( int32_t dx, int32_t dy, int32_t dz )
uint32_t abs32(int32_t v) {
if (v < 0)
return -v;
return v;
return (uint32_t) (-v);
return (uint32_t) (v);
}
/*
@ -150,6 +143,8 @@ uint32_t abs32(int32_t v) {
void dda_create(TARGET *target, DDA *dda) {
uint32_t distance;
serial_writestr_P("\n{DDA_CREATE: [");
// we end at the passed target
memcpy(&(dda->endpoint), target, sizeof(TARGET));
@ -159,6 +154,12 @@ void dda_create(TARGET *target, DDA *dda) {
dda->e_delta = abs32(dda->endpoint.E - startpoint.E);
dda->f_delta = abs32(dda->endpoint.F - startpoint.F);
serwrite_uint32(dda->x_delta); serial_writechar(',');
serwrite_uint32(dda->y_delta); serial_writechar(',');
serwrite_uint32(dda->z_delta); serial_writechar(',');
serwrite_uint32(dda->e_delta); serial_writechar(',');
serwrite_uint32(dda->f_delta); serial_writestr_P("] [");
// since it's unusual to combine X, Y and Z changes in a single move on reprap, check if we can use simpler approximations before trying the full 3d approximation.
if (dda->z_delta == 0)
distance = approx_distance(dda->x_delta, dda->y_delta);
@ -181,12 +182,10 @@ void dda_create(TARGET *target, DDA *dda) {
if (dda->e_delta > dda->total_steps)
dda->total_steps = dda->e_delta;
if (dda->total_steps == 0) {
if (dda->total_steps == 0)
dda->nullmove = 1;
// copy F in case we're doing a null move speed change
startpoint.F = dda->endpoint.F;
current_position.F = dda->endpoint.F;
}
serwrite_uint32(dda->total_steps); serial_writechar(',');
if (dda->f_delta > dda->total_steps) {
dda->f_scale = dda->f_delta / dda->total_steps;
@ -202,6 +201,8 @@ void dda_create(TARGET *target, DDA *dda) {
dda->f_scale = 1;
}
serwrite_uint32(dda->total_steps); serial_writechar(',');
dda->x_direction = (dda->endpoint.X >= startpoint.X)?1:0;
dda->y_direction = (dda->endpoint.Y >= startpoint.Y)?1:0;
dda->z_direction = (dda->endpoint.Z >= startpoint.Z)?1:0;
@ -217,6 +218,8 @@ void dda_create(TARGET *target, DDA *dda) {
// mm.us per step.min / mm per min (F) = us per step
dda->move_duration = distance * 60000000 / dda->total_steps;
serwrite_uint32(dda->move_duration); serial_writestr_P("] }\n");
// next dda starts where we finish
memcpy(&startpoint, target, sizeof(TARGET));
@ -284,6 +287,7 @@ void dda_step(DDA *dda) {
#define E_CAN_STEP 8
#define F_CAN_STEP 16
#define REAL_MOVE 32
#define F_REAL_STEP 64
WRITE(SCK, 1);
@ -376,10 +380,14 @@ void dda_step(DDA *dda) {
if (current_position.F < dda->endpoint.F)
current_position.F = dda->endpoint.F;
}
step_option |= F_REAL_STEP;
}
}
serial_writechar('[');
serwrite_hex8(step_option);
serial_writechar(':');
serwrite_uint16(dda->f_scale);
serial_writechar(',');
serwrite_int32(current_position.F);
@ -394,12 +402,12 @@ void dda_step(DDA *dda) {
// turn off step outputs, hopefully they've been on long enough by now to register with the drivers
unstep();
// we have stepped and now need to wait
if (step_option & REAL_MOVE)
// we have stepped in speed and now need to recalculate our delay
if ((step_option & REAL_MOVE) && (step_option & F_REAL_STEP))
setTimer(dda->move_duration / current_position.F);
// if we could step, we're still running
dda->live = (step_option & (X_CAN_STEP | Y_CAN_STEP | Z_CAN_STEP | E_CAN_STEP | F_CAN_STEP));
dda->live = (step_option & (X_CAN_STEP | Y_CAN_STEP | Z_CAN_STEP | E_CAN_STEP | F_CAN_STEP))?1:0;
WRITE(SCK, 0);
}

4
mendel/dda.h
View File

@ -55,8 +55,8 @@ uint8_t queue_empty(void);
void enqueue(TARGET *t);
void next_move(void);
uint32_t approx_distance( int32_t dx, int32_t dy );
uint32_t approx_distance_3( int32_t dx, int32_t dy, int32_t dz );
uint32_t approx_distance( uint32_t dx, uint32_t dy );
uint32_t approx_distance_3( uint32_t dx, uint32_t dy, uint32_t dz );
void dda_create(TARGET *target, DDA *dda);
void dda_start(DDA *dda);

4
mendel/gcode.c
View File

@ -235,11 +235,11 @@ void scan_char(uint8_t c) {
// save options
option_bitfield = next_target.option;
option_bitfield &= ~OPTION_COMMENT;
// option_bitfield &= ~OPTION_COMMENT;
// reset variables
last_field = 0;
next_target.seen_X = next_target.seen_Y = next_target.seen_Z = next_target.seen_E = next_target.seen_F = next_target.seen_S = next_target.seen_P = 0;
last_field = 0;
read_digit.sign = 0;
read_digit.mantissa = 0;
read_digit.exponent = 0;

8
mendel/machine.h
View File

@ -11,16 +11,16 @@
axis calculations, adjust as necessary
*/
#define XY_STEPS_PER_REV 3200
#define XY_COG_CIRCUMFERENCE (4.77 * 16)
#define XY_STEPS_PER_REV 1600.0
#define XY_COG_CIRCUMFERENCE (4.77 * 16.0)
#define EXTRUDER_STEPS_PER_REV 3200
#define EXTRUDER_SHAFT_RADIUS 5
#define EXTRUDER_INLET_DIAMETER 3
#define EXTRUDER_NOZZLE_DIAMETER 0.8
#define STEPS_PER_MM_X (XY_STEPS_PER_REV * XY_COG_CIRCUMFERENCE)
#define STEPS_PER_MM_Y (XY_STEPS_PER_REV * XY_COG_CIRCUMFERENCE)
#define STEPS_PER_MM_X ((XY_STEPS_PER_REV / XY_COG_CIRCUMFERENCE) + 0.5)
#define STEPS_PER_MM_Y ((XY_STEPS_PER_REV / XY_COG_CIRCUMFERENCE) + 0.5)
#define STEPS_PER_MM_Z (200L)
#define STEPS_PER_MM_E (EXTRUDER_STEPS_PER_REV * EXTRUDER_SHAFT_RADIUS * PI * EXTRUDER_INLET_DIAMETER / EXTRUDER_NOZZLE_DIAMETER)

46
mendel/sermsg.c
View File

@ -2,31 +2,27 @@
#include "serial.h"
// void serwrite_uint8(uint8_t v) {
// serwrite_uint32(v);
// }
//
// void serwrite_int8(int8_t v) {
// if (v < 0) {
// serial_writechar('-');
// v = -v;
// }
//
// serwrite_uint32(v);
// }
//
// void serwrite_uint16(uint16_t v) {
// serwrite_uint32(v);
// }
//
// void serwrite_int16(int16_t v) {
// if (v < 0) {
// serial_writechar('-');
// v = -v;
// }
//
// serwrite_uint32(v);
// }
void serwrite_hex4(uint8_t v) {
if (v < 10)
serial_writechar('0' + v);
else
serial_writechar('A' + v);
}
void serwrite_hex8(uint8_t v) {
serwrite_hex4(v >> 4);
serwrite_hex4(v & 0x0F);
}
void serwrite_hex16(uint16_t v) {
serwrite_hex8(v >> 8);
serwrite_hex8(v & 0xFF);
}
void serwrite_hex32(uint32_t v) {
serwrite_hex8(v >> 16);
serwrite_hex8(v & 0xFFFF);
}
void serwrite_uint32(uint32_t v) {
uint8_t t = 0;

9
mendel/sermsg.h
View File

@ -3,11 +3,10 @@
#include <stdint.h>
// void serwrite_uint8(uint8_t v);
// void serwrite_int8(int8_t v);
//
// void serwrite_uint16(uint16_t v);
// void serwrite_int16(int16_t v);
void serwrite_hex4(uint8_t v);
void serwrite_hex8(uint8_t v);
void serwrite_hex16(uint16_t v);
void serwrite_hex32(uint32_t v);
#define serwrite_uint8(v) serwrite_uint32(v)
#define serwrite_int8(v) serwrite_int32(v)

1
mendel/timer.c
View File

@ -8,6 +8,7 @@
ISR(TIMER1_COMPA_vect) {
if(movebuffer[mb_tail].live) {
// this interrupt can be interruptible
// TODO: remove when not debugging
disableTimerInterrupt();
sei();