setting up new branch

Author: triffid

mendel/calc.pl

@@ -0,0 +1,86 @@
+#!/usr/bin/perl
+
+my ($ss, $es, $f, $dn, $dt, $a, $n0, $nn, $np, $c0, $cn, $cp, $n, $c, $t, $tp, $v, $vp);
+my ($c0_exact, $cn_exact, $v_exact, $t_exact, $vp_exact, $tp_exact);
+my ($n_pre);
+
+$ss = 300;
+$es = 400;
+$f = 16000000;
+$dn = 50000;
+
+$ssq = $ss * $ss;
+$esq = $es * $es;
+$dsq = ($esq - $ssq);
+
+# $a = $dsq / ($dn << 1);
+
+#$n0 = int(($ss * $ss) / (2 * $a));
+#$nn = int(($es * $es) / (2 * $a));
+# $n0 = int($ssq * $dn / $dsq);
+# $nn = int($esq * $dn / $dsq);
+
+$c0 = int($f / $ss);
+# $c0_exact = $f * sqrt(2 / abs($a));
+
+
+# $dt = ($es - $ss) / $a;
+
+# printf "A:\t%d-%d/%g: %d\n", $es, $ss, $dt, $a;
+# printf "N:\t%d-%d %d:%d\n", $n0, $nn, $nn - $n0, $dn, $a;
+# printf "C:\t%d\t%g\n", $c0, $c0_exact * (sqrt(abs($n0) + 1) - sqrt(abs($n0)));
+# $n = $np = $n0;
+$c = $cp = int($f / $ss);
+$end_c = int($f / $es);
+$t = $tp = $t_exact = 0;
+# $v = $vp = $ss;
+
+$n_pre = int(4 * $ssq * $dn / $dsq) | 1;
+
+# $cn_exact = $c0_exact * (sqrt(abs($n0) + 1) - sqrt(abs($n0)));
+# $v_exact = $vp_exact = $f / $cn_exact;
+
+printf "\tt:i\t\t\tdt\tn\tV\t\ta\n";
+for (0..$dn) {
+	# approximation
+	# $c = int($c * 1000) / 1000;
+	printf "Approx:\t%8.6f:%i\t%10d\t%d\t%12.3f\t%12.3f\n", $t, $_, $c, ($n_pre / 4) - 1, $f / $c, ($t > 0)?($v - $ss) / ($t):0;
+
+# 	$tp = $t;
+# 	$cp = $c;
+# 	$np = $n;
+# 	$vp = $v;
+
+	$t += $c / $f;
+	if (
+		(($n_pre > 0) && ($c > $end_c)) ||
+		(($n_pre < 0) && ($c < $end_c))
+		) {
+		$c = int($c - ((2 * $c) / $n_pre));
+		$n_pre += 4;
+	}
+# 	$v = $f / $c;
+
+	# exact
+# 	printf "Exact:\t%8.6f:%i\t%10.3f\t%i\t%12.3f\t%12.3f\n\n", $t_exact, $_, $cn_exact, $n, $v_exact, ($t_exact > 0)?($v_exact - $ss) / ($t_exact):0
+# 		if ($_ % 10 == 0);
+#
+# 	$vp_exact = $v_exact;
+# 	$tp_exact = $t_exact;
+#
+# 	$t_exact += $cn_exact / $f;
+# 	$cn_exact = $c0_exact * (sqrt(abs($n) + 1) - sqrt(abs($n)));
+# 	$v_exact = $f / $cn_exact;
+
+	# loop increment
+# 	if ($nn > $n0) {
+# 		$n++;
+		$n_pre += 4;
+# 	}
+# 	else {
+# 		$n--;
+# 		$n_pre -= 4;
+# 	}
+}
+
+printf "dt:%8.3f\tv:%8.3f\n", int(($f / $es) + 0.5), $f / int(($f / $es) + 0.5);

mendel/dda.c

@@ -126,7 +126,7 @@ void dda_create(DDA *dda, TARGET *target) {
 
 	// initialise DDA to a known state
 	dda->live = 0;
-	dda->total_steps = 0;
+// 	dda->total_steps = 0;
 	dda->waitfor_temp = 0;
 
 	if (debug_flags & DEBUG_DDA)
@@ -162,7 +162,7 @@ void dda_create(DDA *dda, TARGET *target) {
 		serial_writestr_P(PSTR("] ["));
 	}
 
-	if (dda->x_delta > dda->total_steps)
+// 	if (dda->x_delta > dda->total_steps)
 		dda->total_steps = dda->x_delta;
 	if (dda->y_delta > dda->total_steps)
 		dda->total_steps = dda->y_delta;
@@ -449,7 +449,7 @@ void dda_step(DDA *dda) {
 		// else we are already at target speed
 	}
 
-	if (step_option & DID_STEP) {
+	if (step_option) {
 		// we stepped, reset timeout
 		steptimeout = 0;
 

mendel/dda_queue.c

@@ -1,10 +1,12 @@
 #include	"dda_queue.h"
 
 #include	<string.h>
+#include	<avr/interrupt.h>
 
 #include	"timer.h"
 #include	"serial.h"
 #include	"sermsg.h"
+#include	"temp.h"
 
 uint8_t	mb_head = 0;
 uint8_t	mb_tail = 0;
@@ -18,6 +20,41 @@ uint8_t queue_empty() {
 	return ((mb_tail == mb_head) && (movebuffer[mb_tail].live == 0))?255:0;
 }
 
+void queue_step() {
+	disableTimerInterrupt();
+
+	// do our next step
+	// NOTE: dda_step makes this interrupt interruptible after steps have been sent but before new speed is calculated.
+	if (movebuffer[mb_tail].live) {
+		if (movebuffer[mb_tail].waitfor_temp) {
+			if (temp_achieved()) {
+				movebuffer[mb_tail].live = movebuffer[mb_tail].waitfor_temp = 0;
+				serial_writestr_P(PSTR("Temp achieved\n"));
+			}
+
+			#if STEP_INTERRUPT_INTERRUPTIBLE
+				sei();
+			#endif
+		}
+		else {
+			dda_step(&(movebuffer[mb_tail]));
+		}
+	}
+
+// 	serial_writechar('!');
+
+	// fall directly into dda_start instead of waiting for another step
+	if (movebuffer[mb_tail].live == 0)
+		next_move();
+
+	#if STEP_INTERRUPT_INTERRUPTIBLE
+		cli();
+	#endif
+	// check queue, if empty we don't need to interrupt again until re-enabled in dda_create
+	if (queue_empty() == 0)
+		enableTimerInterrupt();
+}
+
 void enqueue(TARGET *t) {
 	// don't call this function when the queue is full, but just in case, wait for a move to complete and free up the space for the passed target
 	while (queue_full())
@@ -47,10 +84,11 @@ void enqueue_temp_wait() {
 	while (queue_full())
 		delay(WAITING_DELAY);
 
-	uint8_t h = mb_head;
-	h++;
-	if (h == MOVEBUFFER_SIZE)
-		h = 0;
+	uint8_t h = mb_head + 1;
+// 	h++;
+// 	if (h == MOVEBUFFER_SIZE)
+// 		h = 0;
+	h &= (MOVEBUFFER_SIZE - 1);
 
 	// wait for temp flag
 	movebuffer[h].waitfor_temp = 1;
@@ -76,16 +114,13 @@ void enqueue_temp_wait() {
 }
 
 void next_move() {
-	if (queue_empty()) {
-// 		memcpy(&startpoint, &current_position, sizeof(TARGET));
-		startpoint.E = current_position.E = 0;
-	}
-	else {
+	if (queue_empty() == 0) {
 		// next item
-		uint8_t t = mb_tail;
-		t++;
-		if (t == MOVEBUFFER_SIZE)
-			t = 0;
+		uint8_t t = mb_tail + 1;
+// 		t++;
+// 		if (t == MOVEBUFFER_SIZE)
+// 			t = 0;
+		t &= (MOVEBUFFER_SIZE - 1);
 		dda_start(&movebuffer[t]);
 		mb_tail = t;
 	}

mendel/dda_queue.h

@@ -20,6 +20,9 @@ extern DDA movebuffer[MOVEBUFFER_SIZE];
 uint8_t queue_full(void);
 uint8_t queue_empty(void);
 
+// take one step
+void queue_step(void);
+
 // add a new target to the queue
 void enqueue(TARGET *t);