Pin state reporting of all pins. Flash optimization.

- New pin state realtime reporting feature. Instead of `Lim:000` for
limit state reports, the new feature shows `Pin:000|0|0000`, or
something similar. The `|` delimited fields indicate xyz limits, probe,
and control pin states, where 0 is always not triggered, and 1 is
triggered. Invert masks ARE accounted for.
  Each field may be enabled or disabled via the `$10` status report
setting. The probe and control pin flags are bits 5 and 6, respectively.

- Remove the now deprecated `REPORT_CONTROL_PIN_STATE` option in
config.h

- The old limit pin reports `Lim:000` may be re-enabled by commenting
out `REPORT_ALL_PIN_STATES` in config.h.

- Incremented the version letter (v1.0c) to indicate the change in
reporting style.

- Replaced all bit_true_atomic and bit_false_atomic macros with
function calls. This saved a couple hundred bytes of flash.

Author: chamnit

README.md

@@ -31,9 +31,11 @@ Grbl includes full acceleration management with look ahead. That means the contr
 
 ***
 
-##Update Summary for v1.0b
+##Update Summary for v1.0c
 - **IMPORTANT:** Your EEPROM will be wiped and restored with new settings. This is due to the addition of two new spindle speed '$' settings.
 
+- Altered limit pin status reports from `Lim:000` to `Pin:000|0|0000`, where the `|` delimiters separate the new probe state and control pin states. Each new field may be disabled by the `$10` Grbl setting. NOTE: Commenting `REPORT_ALL_PIN_STATES` in config.h reverts to old `Lim:` reports, if needed.
+
 - New safety door parking motion as a compile-option. Grbl will retract, disable the spindle/coolant, and park near Z max. When resumed, it will perform these task in reverse order and continue the program. Highly configurable. See config.h for details.
 
 - New '$' Grbl settings for max and min spindle rpm. Allows for tweaking the PWM output to more closely match true spindle rpm. When max rpm is set to zero or less than min rpm, the PWM pin D11 will act like a simple enable on/off output.

doc/log/commit_log_v1.0b.txt

@@ -1,3 +1,39 @@
+----------------
+Date: 2015-09-30
+Author: Sonny Jeon
+Subject: Bug fixes.
+
+- G38.x was not printing correctly in the $G g-code state reports. Now
+fixed.
+
+- When investigating the above issue, it was noticed that G38.x
+wouldn’t show at all, but instead a G0 would be printed. This was
+unlike the v0.9j master build. It turned out volatile variables do not
+like to be defined inside a C struct. These are undefined on how to be
+handled. Once pulled out, all weird issues went away.
+
+- Also changed two ‘sizeof()’ statements in the mc_probe() and
+probe_state_monitor() functions to be more robust later on.
+
+- Updated the commit logs to individual files for each minor release.
+Forgot to update the generating script to account for this.
+
+
+----------------
+Date: 2015-09-30
+Author: Sonny Jeon
+Subject: Minor bug fixes.
+
+- G38.x was not printing correctly in the $G g-code state reports. Now
+fixed.
+
+- Potential bug regarding volatile variables inside a struct. It has
+never been a problem in v0.9, but ran into this during v1.0
+development. Just to be safe, the fixes are applied here.
+
+- Updated pre-built firmwares with these two bug fixes.
+
+
 ----------------
 Date: 2015-09-24
 Author: Sonny Jeon

grbl/config.h

@@ -164,11 +164,12 @@
 // uncomment the config option USE_SPINDLE_DIR_AS_ENABLE_PIN below.
 // #define INVERT_SPINDLE_ENABLE_PIN // Default disabled. Uncomment to enable.
 
-// Enable control pin states feedback in status reports. The data is presented as simple binary of
-// the control pin port (0 (low) or 1(high)), masked to show only the input pins. Non-control pins on the 
-// port will always show a 0 value. See cpu_map.h for the pin bitmap. As with the limit pin reporting,
-// we do not recommend keeping this option enabled. Try to only use this for setting up a new CNC.
-// #define REPORT_CONTROL_PIN_STATE // Default disabled. Uncomment to enable.
+// Enable all pin states feedback in status reports. Configurable with Grbl settings to print only
+// the desired data, which is presented as simple binary reading of each pin as (0 (low) or 1(high)).
+// The fields are printed in a particular order and settings groups are separated by '|' characters. 
+// NOTE: This option is here for backward compatibility of the old style of pin state reports, i.e. 
+// `Lim:000`. This new `Pin:` report will be the standard going forward.
+#define REPORT_ALL_PIN_STATES // Default enabled. Comment to disable.
 
 // When Grbl powers-cycles or is hard reset with the Arduino reset button, Grbl boots up with no ALARM
 // by default. This is to make it as simple as possible for new users to start using Grbl. When homing

grbl/gcode.c

@@ -1044,7 +1044,7 @@ uint8_t gc_execute_line(char *line)
     protocol_buffer_synchronize(); // Sync and finish all remaining buffered motions before moving on.
     if (gc_state.modal.program_flow == PROGRAM_FLOW_PAUSED) {
       if (sys.state != STATE_CHECK_MODE) {
-        bit_true_atomic(sys_rt_exec_state, EXEC_FEED_HOLD); // Use feed hold for program pause.
+        system_set_exec_state_flag(EXEC_FEED_HOLD); // Use feed hold for program pause.
         protocol_execute_realtime(); // Execute suspend.
       }
     } else { // == PROGRAM_FLOW_COMPLETED

grbl/grbl.h

@@ -22,8 +22,8 @@
 #define grbl_h
 
 // Grbl versioning system
-#define GRBL_VERSION "1.0b"
-#define GRBL_VERSION_BUILD "20150930"
+#define GRBL_VERSION "1.0c"
+#define GRBL_VERSION_BUILD "20151109"
 
 // Define standard libraries used by Grbl.
 #include <avr/io.h>

grbl/limits.c

@@ -106,11 +106,11 @@ uint8_t limits_get_state()
           // Check limit pin state. 
           if (limits_get_state()) {
             mc_reset(); // Initiate system kill.
-            bit_true_atomic(sys_rt_exec_alarm, (EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate hard limit critical event
+            system_set_exec_alarm_flag((EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate hard limit critical event
           }
         #else
           mc_reset(); // Initiate system kill.
-          bit_true_atomic(sys_rt_exec_alarm, (EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate hard limit critical event
+          system_set_exec_alarm_flag((EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate hard limit critical event
         #endif
       }
     }
@@ -126,7 +126,7 @@ uint8_t limits_get_state()
         // Check limit pin state. 
         if (limits_get_state()) {
           mc_reset(); // Initiate system kill.
-          bit_true_atomic(sys_rt_exec_alarm, (EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate hard limit critical event
+          system_set_exec_alarm_flag((EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate hard limit critical event
         }
       }  
     }
@@ -235,7 +235,7 @@ void limits_go_home(uint8_t cycle_mask)
           return;
         } else {
           // Pull-off motion complete. Disable CYCLE_STOP from executing.
-          bit_false_atomic(sys_rt_exec_state,EXEC_CYCLE_STOP);
+          system_clear_exec_state_flag(EXEC_CYCLE_STOP);
           break;
         } 
       }
@@ -335,15 +335,15 @@ void limits_soft_check(float *target)
       // workspace volume so just come to a controlled stop so position is not lost. When complete
       // enter alarm mode.
       if (sys.state == STATE_CYCLE) {
-        bit_true_atomic(sys_rt_exec_state, EXEC_FEED_HOLD);
+        system_set_exec_state_flag(EXEC_FEED_HOLD);
         do {
           protocol_execute_realtime();
           if (sys.abort) { return; }
         } while ( sys.state != STATE_IDLE );
       }
 
       mc_reset(); // Issue system reset and ensure spindle and coolant are shutdown.
-      bit_true_atomic(sys_rt_exec_alarm, (EXEC_ALARM_SOFT_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate soft limit critical event
+      system_set_exec_alarm_flag((EXEC_ALARM_SOFT_LIMIT|EXEC_CRITICAL_EVENT)); // Indicate soft limit critical event
       protocol_execute_realtime(); // Execute to enter critical event loop and system abort
       return;
     }

grbl/motion_control.c

@@ -220,7 +220,7 @@ void mc_homing_cycle()
   #ifdef LIMITS_TWO_SWITCHES_ON_AXES  
     if (limits_get_state()) { 
       mc_reset(); // Issue system reset and ensure spindle and coolant are shutdown.
-      bit_true_atomic(sys_rt_exec_alarm, (EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT));
+      system_set_exec_alarm_flag((EXEC_ALARM_HARD_LIMIT|EXEC_CRITICAL_EVENT));
       return;
     }
   #endif
@@ -276,7 +276,7 @@ void mc_homing_cycle()
   // After syncing, check if probe is already triggered. If so, halt and issue alarm.
   // NOTE: This probe initialization error applies to all probing cycles.
   if ( probe_get_state() ) { // Check probe pin state.
-    bit_true_atomic(sys_rt_exec_alarm, EXEC_ALARM_PROBE_FAIL);
+    system_set_exec_alarm_flag(EXEC_ALARM_PROBE_FAIL);
     protocol_execute_realtime();
   }
   if (sys.abort) { return; } // Return if system reset has been issued.
@@ -292,7 +292,7 @@ void mc_homing_cycle()
   sys_probe_state = PROBE_ACTIVE;
 
   // Perform probing cycle. Wait here until probe is triggered or motion completes.
-  bit_true_atomic(sys_rt_exec_state, EXEC_CYCLE_START);
+  system_set_exec_state_flag(EXEC_CYCLE_START);
   do {
     protocol_execute_realtime(); 
     if (sys.abort) { return; } // Check for system abort
@@ -303,7 +303,7 @@ void mc_homing_cycle()
   // Set state variables and error out, if the probe failed and cycle with error is enabled.
   if (sys_probe_state == PROBE_ACTIVE) {
     if (is_no_error) { memcpy(sys.probe_position, sys.position, sizeof(sys.position)); }
-    else { bit_true_atomic(sys_rt_exec_alarm, EXEC_ALARM_PROBE_FAIL); }
+    else { system_set_exec_alarm_flag(EXEC_ALARM_PROBE_FAIL); }
   } else { 
     sys.probe_succeeded = true; // Indicate to system the probing cycle completed successfully.
   }
@@ -366,7 +366,7 @@ void mc_reset()
 {
   // Only this function can set the system reset. Helps prevent multiple kill calls.
   if (bit_isfalse(sys_rt_exec_state, EXEC_RESET)) {
-    bit_true_atomic(sys_rt_exec_state, EXEC_RESET);
+    system_set_exec_state_flag(EXEC_RESET);
 
     // Kill spindle and coolant.   
     spindle_stop();
@@ -378,8 +378,8 @@ void mc_reset()
     // violated, by which, all bets are off.
     if ((sys.state & (STATE_CYCLE | STATE_HOMING)) || 
     		(sys.step_control & (STEP_CONTROL_EXECUTE_HOLD | STEP_CONTROL_EXECUTE_PARK))) {
-      if (sys.state == STATE_HOMING) { bit_true_atomic(sys_rt_exec_alarm, EXEC_ALARM_HOMING_FAIL); }
-      else { bit_true_atomic(sys_rt_exec_alarm, EXEC_ALARM_ABORT_CYCLE); }
+      if (sys.state == STATE_HOMING) { system_set_exec_alarm_flag(EXEC_ALARM_HOMING_FAIL); }
+      else { system_set_exec_alarm_flag(EXEC_ALARM_ABORT_CYCLE); }
       st_go_idle(); // Force kill steppers. Position has likely been lost.
     }
   }

grbl/nuts_bolts.h

@@ -56,9 +56,6 @@
 
 // Bit field and masking macros
 #define bit(n) (1 << n) 
-#define bit_true_atomic(x,mask) {uint8_t sreg = SREG; cli(); (x) |= (mask); SREG = sreg; }
-#define bit_false_atomic(x,mask) {uint8_t sreg = SREG; cli(); (x) &= ~(mask); SREG = sreg; }
-#define bit_toggle_atomic(x,mask) {uint8_t sreg = SREG; cli(); (x) ^= (mask); SREG = sreg; }
 #define bit_true(x,mask) (x) |= (mask)
 #define bit_false(x,mask) (x) &= ~(mask)
 #define bit_istrue(x,mask) ((x & mask) != 0)

grbl/probe.c

@@ -34,7 +34,7 @@ void probe_init()
   #else
     PROBE_PORT |= PROBE_MASK;    // Enable internal pull-up resistors. Normal high operation.
   #endif
-  // probe_configure_invert_mask(false); // Initialize invert mask. Not required. Updated when in-use.
+  probe_configure_invert_mask(false); // Initialize invert mask. Re-updated during use.
 }
 
 

grbl/protocol.c

@@ -190,7 +190,7 @@ void protocol_buffer_synchronize()
 // when one of these conditions exist respectively: There are no more blocks sent (i.e. streaming 
 // is finished, single commands), a command that needs to wait for the motions in the buffer to 
 // execute calls a buffer sync, or the planner buffer is full and ready to go.
-void protocol_auto_cycle_start() { bit_true_atomic(sys_rt_exec_state, EXEC_CYCLE_START); } 
+void protocol_auto_cycle_start() { system_set_exec_state_flag(EXEC_CYCLE_START); } 
 
 
 // This function is the general interface to Grbl's real-time command execution system. It is called
@@ -237,7 +237,7 @@ void protocol_exec_rt_system()
     // Halt everything upon a critical event flag. Currently hard and soft limits flag this.
     if (rt_exec & EXEC_CRITICAL_EVENT) {
       report_feedback_message(MESSAGE_CRITICAL_EVENT);
-      bit_false_atomic(sys_rt_exec_state,EXEC_RESET); // Disable any existing reset
+      system_clear_exec_state_flag(EXEC_RESET); // Disable any existing reset
       do {       
         // Block everything, except reset and status reports, until user issues reset or power 
         // cycles. Hard limits typically occur while unattended or not paying attention. Gives 
@@ -248,12 +248,12 @@ void protocol_exec_rt_system()
 // TODO: Allow status reports during a critical alarm. Still need to think about implications of this.
         // if (sys_rt_exec_state & EXEC_STATUS_REPORT) { 
         //   report_realtime_status();
-        //   bit_false_atomic(sys_rt_exec_state,EXEC_STATUS_REPORT); 
+        //   system_clear_exec_state_flag(EXEC_STATUS_REPORT); 
         // }
 
       } while (bit_isfalse(sys_rt_exec_state,EXEC_RESET));
     }
-    bit_false_atomic(sys_rt_exec_alarm,0xFF); // Clear all alarm flags
+    system_clear_exec_alarm_flag(0xFF); // Clear all alarm flags
   }
 
   rt_exec = sys_rt_exec_state; // Copy volatile sys_rt_exec_state.
@@ -268,7 +268,7 @@ void protocol_exec_rt_system()
     // Execute and serial print status
     if (rt_exec & EXEC_STATUS_REPORT) { 
       report_realtime_status();
-      bit_false_atomic(sys_rt_exec_state,EXEC_STATUS_REPORT);
+      system_clear_exec_state_flag(EXEC_STATUS_REPORT);
     }
 
     // NOTE: The math involved to calculate the hold should be low enough for most, if not all, 
@@ -340,7 +340,7 @@ void protocol_exec_rt_system()
 
       }
 
-      bit_false_atomic(sys_rt_exec_state,(EXEC_MOTION_CANCEL | EXEC_FEED_HOLD | EXEC_SAFETY_DOOR));      
+      system_clear_exec_state_flag((EXEC_MOTION_CANCEL | EXEC_FEED_HOLD | EXEC_SAFETY_DOOR));      
     }
 
     // Execute a cycle start by starting the stepper interrupt to begin executing the blocks in queue.
@@ -380,7 +380,7 @@ void protocol_exec_rt_system()
           }
         }
       }    
-      bit_false_atomic(sys_rt_exec_state,EXEC_CYCLE_START);
+      system_clear_exec_state_flag(EXEC_CYCLE_START);
     }
 
     if (rt_exec & EXEC_CYCLE_STOP) {
@@ -399,7 +399,7 @@ void protocol_exec_rt_system()
         sys.suspend = SUSPEND_DISABLE;
         sys.state = STATE_IDLE;
       }  
-      bit_false_atomic(sys_rt_exec_state,EXEC_CYCLE_STOP);
+      system_clear_exec_state_flag(EXEC_CYCLE_STOP);
     }
   }
 
@@ -544,7 +544,7 @@ static void protocol_exec_rt_suspend()
 
           if (bit_isfalse(sys.suspend,SUSPEND_RESTART_RETRACT)) {
             sys.suspend |= SUSPEND_RESTORE_COMPLETE;
-            bit_true_atomic(sys_rt_exec_state,EXEC_CYCLE_START); // Set to resume program.
+            system_set_exec_state_flag(EXEC_CYCLE_START); // Set to resume program.
           }
         }