Merge pull request #5 from keyme/homecounts

Improve support for encoders and home repeatability testing.

Author: ashelly

Makefile

@@ -30,7 +30,7 @@
 
 DEVICE     ?= atmega2560
 CLOCK      = 16000000
-PROGRAMMER ?= -c avrisp2 -P /dev/ttyUSB0 -v -v
+PROGRAMMER ?= -c avrisp2 -P /dev/ttyS0
 OBJECTS    = main.o motion_control.o gcode.o spindle_control.o coolant_control.o serial.o \
              protocol.o stepper.o eeprom.o settings.o planner.o nuts_bolts.o limits.o \
              print.o probe.o report.o system.o counters.o
@@ -41,7 +41,7 @@ FUSES      = -U hfuse:w:0xd2:m -U lfuse:w:0xff:m
 
 # Tune the lines below only if you know what you are doing:
 
-AVRDUDE = avrdude -v -v $(PROGRAMMER) -p $(DEVICE) -B 10 -F -D
+AVRDUDE = avrdude  $(PROGRAMMER) -p $(DEVICE) -B 10 -F
 COMPILE = avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DEVICE) -I. -ffunction-sections
 
 # symbolic targets:

counters.c

@@ -43,11 +43,12 @@ void counters_init()
 void  counters_reset(uint8_t axis)
 {
   counters.counts[axis]=0;
+  if (axis == Z_AXIS) { counters.idx=0; }
 }
 
 
 // Returns the counters pin state. Triggered = true.  and counters state monitor.
-uint16_t counters_get_count(uint8_t axis)
+count_t counters_get_count(uint8_t axis)
 {
   return counters.counts[axis];
 }
@@ -56,7 +57,7 @@ uint8_t counters_get_state(){
   return counters.state;
 }
 
-uint16_t counters_get_idx(){
+int16_t counters_get_idx(){
   return counters.idx;
 }
 
@@ -81,8 +82,8 @@ ISR(FDBK_INT_vect) {
       if (idx_on) {
         counters.idx += counters.dir;
         //rezero counter.
-        counters.counts[Z_AXIS]=(counters.counts[Z_AXIS]/DEFAULT_COUNTS_PER_IDX)*
-          DEFAULT_COUNTS_PER_IDX + counters.idx_offset;
+	//        counters.counts[Z_AXIS]=(counters.counts[Z_AXIS]/DEFAULT_COUNTS_PER_IDX)*
+	//          DEFAULT_COUNTS_PER_IDX + counters.idx_offset;
       }
   }
       /* moved to probe for debounce TODO: NEEDS TESTING*/

counters.h

@@ -21,10 +21,12 @@
 #ifndef counters_h
 #define counters_h 
 
+typedef int32_t count_t;
+
 typedef struct  counters {
-  int32_t counts[N_AXIS];
+  count_t counts[N_AXIS];
   int16_t idx; //encoder index counts
-  int16_t idx_offset; //encoder index counts
+  count_t idx_offset; //encoder index counts
   int8_t dir; //last known direction
   uint8_t state;
   uint8_t anew; //new a encode
@@ -40,9 +42,9 @@ void counters_init();
 uint8_t counters_get_state();
 
 // Returns counts for a given axis
-uint16_t counters_get_count(uint8_t axis);
+count_t counters_get_count(uint8_t axis);
 
-uint16_t counters_get_idx();
+int16_t counters_get_idx();
 
 
 void  counters_reset(uint8_t axis);

gcode.c

@@ -401,7 +401,7 @@ uint8_t gc_execute_line(char *line)
   // Check for valid line number N value.
   if (bit_istrue(value_words,bit(WORD_N))) {
     // Line number value cannot be less than zero (done) or greater than max line number.
-    if (gc_block.values.n > MAX_LINE_NUMBER) { FAIL(STATUS_GCODE_INVALID_LINE_NUMBER); } // [Exceeds max line number]
+    if (gc_block.values.n > LINENUMBER_MAX) { FAIL(STATUS_GCODE_INVALID_LINE_NUMBER); } // [Exceeds max line number]
   }
   // bit_false(value_words,bit(WORD_N)); // NOTE: Single-meaning value word. Set at end of error-checking.
 
@@ -872,8 +872,7 @@ uint8_t gc_execute_line(char *line)
   if (gc_block.non_modal_command == NON_MODAL_DWELL) { 
     linenumber_insert(gc_block.values.n); 
     mc_dwell(gc_block.values.p); 
-    sys.eol_flag = 1; //pop the number we just put in 
-    SYS_EXEC |= EXEC_STATUS_REPORT;
+    request_report_status(1); //pop the number we just put in 
   }
 
   // [11. Set active plane ]:

limits.c

@@ -28,7 +28,8 @@
 #include "limits.h"
 #include "report.h"
 
-#define HOMING_CYCLE_LINE_NUMBER MAX_LINE_NUMBER
+#define HOMING_ZERO_LINE_NUMBER (LINENUMBER_SPECIAL|0)
+#define HOMING_FINISHED_LINE_NUMBER (LINENUMBER_SPECIAL|1)
 
 #define HOMING_AXIS_SEARCH_SCALAR  1.1  // Axis search distance multiplier. Must be > 1.
 
@@ -49,11 +50,6 @@ void limits_init()
     LIMIT_PORT |= (LIMIT_MASK);  // Enable internal pull-up resistors. Normal high operation.
   }
 
-
-  /*  LIMIT_PCMSK &= ~LIMIT_MASK;  // prevent spurious interrupts while configuring
-  PCICR |= LIMIT_INT; // Enable Pin Change Interrupt on correct port.
-  */
-
   if (bit_istrue(settings.flags,BITFLAG_HARD_LIMIT_ENABLE)) {
     limits_enable(LIMIT_MASK & HARDSTOP_MASK,0);
   } else {
@@ -81,62 +77,23 @@ void limits_disable()
   limits.active = 0;
 }
 
-// This is the Limit Pin Change Interrupt, which handles the hard limit feature. A bouncing 
-// limit switch can cause a lot of problems, like false readings and multiple interrupt calls.
-// If a switch is triggered at all, something bad has happened and treat it as such, regardless
-// if a limit switch is being disengaged. It's impossible to reliably tell the state of a 
-// bouncing pin without a debouncing method. A simple software debouncing feature may be enabled 
-// through the config.h file, where an extra timer delays the limit pin read by several milli-
-// seconds to help with, not fix, bouncing switches.
-// NOTE: Do not attach an e-stop to the limit pins, because this interrupt is disabled during
-// homing cycles and will not respond correctly. Upon user request or need, there may be a
-// special pinout for an e-stop, but it is generally recommended to just directly connect
-// your e-stop switch to the Arduino reset pin, since it is the most correct way to do this.
-  // Ignore limit switches if already in an alarm state or in-process of executing an alarm.
-  // When in the alarm state, Grbl should have been reset or will force a reset, so any pending 
+
+// Limit checking moved to stepper ISR. 
+// limits_enable() sets limits.active and limits.expected flags.
+// stepper stops an axis whenever LIMIT_PIN&limits.active != limits.expected,
+//   in this case, it also sets limits.homenext to signal homing routine to continue.
+//   If not homing, it does a hard reset and sets the alarm.state
+//   (See `must_stop` section of ISR TIMER1_COMPA_vect)
+
+//  TODO: do we need special handling if already in an alarm state or in-process of executing an alarm.
+// Old comments said:
+  // Ignore limit switches When in the alarm state:
+  // Grbl should have been reset or will force a reset, so any pending 
   // moves in the planner and serial buffers are all cleared and newly sent blocks will be 
   // locked out until a homing cycle or a kill lock command. Allows the user to disable the hard
   // limit setting if their limits are constantly triggering after a reset and move their axes.
 
 
-void check_limit_pins()
-{
-  uint8_t invert_mask = (bit_istrue(settings.flags,BITFLAG_INVERT_LIMIT_PINS)) ? LIMIT_MASK : 0;
-  //sysflags.limit bits are set when limit is triggered
-  SYS_EXEC |= EXEC_LIMIT_REPORT;
-  sysflags.limits = (LIMIT_PIN ^ invert_mask );
-
-  if (sys.state & STATE_HOMING) {
-   //clear axislock bits when limit toggled.
-   sysflags.homing_axis_lock &=  (LIMIT_PIN>>LIMIT_BIT_SHIFT)^limit_approach;
-  }
-  else if (sysflags.limits & LIMIT_MASK) {
-    if (!(sys.state & STATE_ALARM)) { 
-      if (bit_isfalse(SYS_EXEC,EXEC_ALARM)) {
-        mc_reset(); // Initiate system kill.
-        SYS_EXEC |= (EXEC_ALARM | EXEC_CRIT_EVENT); // Indicate hard limit critical event
-      }
-    }
-  }
-}
-
-#ifndef ENABLE_SOFTWARE_DEBOUNCE
-ISR(LIMIT_INT_vect) // DEFAULT: Limit pin change interrupt process.
-{
-}
-#else // OPTIONAL: Software debounce limit pin routine.
-// Upon limit pin change, enable watchdog timer to create a short delay. 
-ISR(LIMIT_INT_vect) { 
-  if (!(WDTCSR & (1<<WDIE))) { WDTCSR |= (1<<WDIE); } 
-}
-ISR(WDT_vect) // Watchdog timer ISR
-{
-  WDTCSR &= ~(1<<WDIE); // Disable watchdog timer. 
-  check_limit_pins();
-}
-#endif
-
-
 // Homes the specified cycle axes, sets the machine position, and performs a pull-off motion after
 // completing. Homing is a special motion case, which involves rapid uncontrolled stops to locate
 // the trigger point of the limit switches. The rapid stops are handled by a system level axis lock 
@@ -154,50 +111,46 @@ void limits_go_home(uint8_t cycle_mask)
   uint8_t n_cycle = (2*N_HOMING_LOCATE_CYCLE+1);
   float target[N_AXIS];
 
+  uint8_t flipped = settings.homing_dir_mask>>X_DIRECTION_BIT;  //assumes keyme configuration.
+  //replace with an instance of `if (bitistrue(h_d_m,X_DIRECTION_BIT)) { flipped|=1<<X_AXIS;}` 
+  //for each axis if the bits line up differently
+
   // Determine travel distance to the furthest homing switch based on user max travel settings.
   float min_seek_rate = 1e9; //arbitrary maximum=1km/s, will be reduced by axis setting below
   float max_travel = 0;
+
   for (idx=0; idx<N_AXIS; idx++){
     if (bit_istrue(cycle_mask,bit(idx))) {
       max_travel = max(max_travel,settings.max_travel[idx]);
       homing_rate = min(homing_rate,settings.homing_seek_rate[idx]);
     }
   }
   max_travel *= HOMING_AXIS_SEARCH_SCALAR; // Ensure homing switches engaged by over-estimating max travel.
+  max_travel += settings.homing_pulloff;
   homing_rate = min_seek_rate;
-  
+
   plan_reset(); // Reset planner buffer to zero planner current position and to clear previous motions.
-  
+
   do {
-    
     // Set target location and rate for active axes.
+    // and reset homing axis locks based on cycle mask.  
+    uint8_t axislock = 0; 
     uint8_t n_active_axis = 0;
     for (idx=0; idx<N_AXIS; idx++) {
       if (bit_istrue(cycle_mask,bit(idx))) {
         n_active_axis++;
-        if (!approach) { target[idx] = max_travel; }
-        else { target[idx] = -max_travel; }
-      } else {
-        target[idx] = 0.0;
-      }
+        axislock |= (1<<(X_STEP_BIT+idx)); //assumes axes are in bit order.
+        if ((flipped&(1<<idx))^approach) { target[idx] = -max_travel; }
+        else {                             target[idx] = max_travel; }
+      } 
+      else {                               target[idx] = 0; 
+      } 
     }
-    if (bit_istrue(settings.homing_dir_mask,(1<<X_DIRECTION_BIT))) { target[X_AXIS] = -target[X_AXIS]; }
-    if (bit_istrue(settings.homing_dir_mask,(1<<Y_DIRECTION_BIT))) { target[Y_AXIS] = -target[Y_AXIS]; }
-    if (bit_istrue(settings.homing_dir_mask,(1<<Z_DIRECTION_BIT))) { target[Z_AXIS] = -target[Z_AXIS]; }
-    if (bit_istrue(settings.homing_dir_mask,(1<<C_DIRECTION_BIT))) { target[C_AXIS] = -target[Z_AXIS]; }
 
     homing_rate *= sqrt(n_active_axis); // [sqrt(N_AXIS)] Adjust so individual axes all move at homing rate.
+                                        // homing_rate is reset each time through this loop, so it doesn't keep increasing
 
-      // Reset homing axis locks based on cycle mask.
-    uint8_t axislock = 0;
-    if (bit_istrue(cycle_mask,bit(X_AXIS))) { axislock |= (1<<X_STEP_BIT); }
-    if (bit_istrue(cycle_mask,bit(Y_AXIS))) { axislock |= (1<<Y_STEP_BIT); }
-    if (bit_istrue(cycle_mask,bit(Z_AXIS))) { axislock |= (1<<Z_STEP_BIT); }
-    if (bit_istrue(cycle_mask,bit(C_AXIS))) { axislock |= (1<<C_STEP_BIT); }
-
-   // axis_lock bit is high if axis is homing, a 0 prevents it from being moved in stepper.
-    sysflags.homing_axis_lock = axislock;
-	 limit_approach = approach;  //limit_approach bits is high if approaching limit switch 
+    limit_approach = approach;  //limit_approach bits is high if approaching limit switch 
 
     // Perform homing cycle. Planner buffer should be empty, as required to initiate the homing cycle.
     #ifdef USE_LINE_NUMBERS
@@ -206,6 +159,7 @@ void limits_go_home(uint8_t cycle_mask)
       plan_buffer_line(target, homing_rate, false); // Bypass mc_line(). Directly plan homing motion.
     #endif
 
+	 // axislock bit is high if axis is homing, so we only enable checking on moving axes.
     limits_enable(axislock,~approach);  //expect 0 on approach (stop when 1). vice versa for pulloff
     limits.homenext =0;
 
@@ -224,7 +178,6 @@ void limits_go_home(uint8_t cycle_mask)
         protocol_execute_runtime();
         return;
       }
-
     } while (!limits.homenext);  //stepper isr sets this when limit is hit
 
     limits_disable();
@@ -240,6 +193,11 @@ void limits_go_home(uint8_t cycle_mask)
 
   } while (n_cycle-- > 0);
 
+  //force report of known position for compare to zero.
+  linenumber_insert(HOMING_ZERO_LINE_NUMBER);
+  request_report_status(1);
+  protocol_execute_runtime();
+
   // The active cycle axes should now be homed and machine limits have been located. By 
   // default, grbl defines machine space as all negative, as do most CNCs. Since limit switches
   // can be on either side of an axes, check and set axes machine zero appropriately. Also,
@@ -258,15 +216,15 @@ void limits_go_home(uint8_t cycle_mask)
         sys.position[idx] = -settings.homing_pulloff*settings.steps_per_mm[idx];
         target[idx] = 0;
       }
-      if (settings.homing_pulloff == 0.0) { SYS_EXEC|=EXEC_STATUS_REPORT; } //force report if we are not going to move
+      if (settings.homing_pulloff == 0.0) {SYS_EXEC|=EXEC_STATUS_REPORT; } //force report if we are not going to move  TODO TEST
     } else { // Non-active cycle axis. Set target to not move during pull-off.
       target[idx] = (float)sys.position[idx]/settings.steps_per_mm[idx];
     }
   }
   plan_sync_position(); // Sync planner position to current machine position for pull-off move.
 
   #ifdef USE_LINE_NUMBERS
-    plan_buffer_line(target, min_seek_rate, false, HOMING_CYCLE_LINE_NUMBER); // Bypass mc_line(). Directly plan motion.
+    plan_buffer_line(target, min_seek_rate, false, HOMING_FINISHED_LINE_NUMBER); // Bypass mc_line(). Directly plan motion.
   #else
     plan_buffer_line(target, min_seek_rate, false); // Bypass mc_line(). Directly plan motion.
   #endif

planner.c

@@ -27,7 +27,7 @@
 #include "protocol.h"
 #include "stepper.h"
 #include "settings.h"
-
+#include "report.h"
 
 #define SOME_LARGE_VALUE 1.0E+38 // Used by rapids and acceleration maximization calculations. Just needs
                                  // to be larger than any feasible (mm/min)^2 or mm/sec^2 value.
@@ -310,8 +310,7 @@ void plan_buffer_line(float *target, float feed_rate, uint8_t invert_feed_rate)
   if (block->step_event_count == 0) { 
     if (linenumber_insert(block->line_number|LINENUMBER_EMPTY_BLOCK) == 1) { 
       //was empty, so report immediately;
-      sys.eol_flag = 1;
-      SYS_EXEC |= EXEC_STATUS_REPORT;
+      request_report_status(1);
     }
     return;
   }
@@ -419,6 +418,9 @@ void plan_sync_position()
   }
 }
 
+float plan_get_position(uint8_t axis){ //in mm
+  return (float)pl.position[axis]/settings.steps_per_mm[axis];
+}
 
 // Re-initialize buffer plan with a partially completed block, assumed to exist at the buffer tail.
 // Called after a steppers have come to a complete stop for a feed hold and the cycle is stopped.

planner.h

@@ -98,4 +98,8 @@ void plan_cycle_reinitialize();
 // Returns the status of the block ring buffer. True, if buffer is full.
 uint8_t plan_check_full_buffer();
 
+//returns last planned pos for `axis` in mm
+float plan_get_position(uint8_t axis);
+
+
 #endif

probe.c

@@ -2,7 +2,7 @@
   probe.c - code pertaining to probing methods
   Part of Grbl
 
-  Copyright (c) 2014 Sungeun K. Jeon
+  Copyright (c) 2014 Sungeun K. Jeon, Adam Shelly
 
   Grbl is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

report.c

@@ -152,6 +152,7 @@ void report_grbl_help() {
                       "$X (kill alarm lock)\r\n"
                       "$H<x=single axis> (run homing cycle)\r\n"
                       "$E<x=clear axis> (report encoders)\r\n"
+                      "$Hx=axis (run homing cycle)\r\n"
                       "~ (cycle start)\r\n"
                       "! (feed hold)\r\n"
                       "? (current status)\r\n"

report.h

@@ -113,4 +113,7 @@ void report_build_info(char *line);
 
 // Prints current limit word
 void report_limit_pins();
+
+//called to trigger status report, with line number if eol set.
+#define request_report_status(eol) sys.eol_flag = (eol);SYS_EXEC|=EXEC_STATUS_REPORT
 #endif