Limit pin internal pull-resistors enabled. Re-wrote read_double() function. Correctly changed all 'double's to 'float's.

- Limit pin internal pull-resistors now enabled. Normal high operation.
This will be the standard going forward.

- Updated all of the 'double' variable types to 'float' to reflect what
happens when compiled for the Arduino. Also done for compatibility
reasons to @jgeisler0303 's Grbl simulator code.

- G-code parser will now ignore 'E' exponent values, since they are
reserved g-code characters for some machines. Thanks @csdexter!

- The read_double() function was re-written and optimized for use in
Grbl. The strtod() avr lib was removed.

gcode.c

@@ -77,8 +77,8 @@ typedef struct {
   uint8_t program_flow;            // {M0, M1, M2, M30}
   int8_t spindle_direction;        // 1 = CW, -1 = CCW, 0 = Stop {M3, M4, M5}
   uint8_t coolant_mode;            // 0 = Disable, 1 = Flood Enable {M8, M9}
-  double feed_rate, seek_rate;     // Millimeters/second
-  double position[3];              // Where the interpreter considers the tool to be at this point in the code
+  float feed_rate, seek_rate;     // Millimeters/second
+  float position[3];              // Where the interpreter considers the tool to be at this point in the code
   uint8_t tool;
   uint16_t spindle_speed;          // RPM/100
   uint8_t plane_axis_0, 
@@ -89,7 +89,7 @@ static parser_state_t gc;
 
 #define FAIL(status) gc.status_code = status;
 
-static int next_statement(char *letter, double *double_ptr, char *line, uint8_t *char_counter);
+static int next_statement(char *letter, float *float_ptr, char *line, uint8_t *char_counter);
 
 static void select_plane(uint8_t axis_0, uint8_t axis_1, uint8_t axis_2) 
 {
@@ -120,7 +120,7 @@ void gc_clear_position()
   clear_vector(gc.position);
 }
 
-static float to_millimeters(double value) 
+static float to_millimeters(float value) 
 {
   return(gc.inches_mode ? (value * MM_PER_INCH) : value);
 }
@@ -133,17 +133,17 @@ uint8_t gc_execute_line(char *line)
 {
   uint8_t char_counter = 0;  
   char letter;
-  double value;
+  float value;
   int int_value;
   
   uint16_t modal_group_words = 0;  // Bitflag variable to track and check modal group words in block
   uint8_t axis_words = 0;          // Bitflag to track which XYZ(ABC) parameters exist in block
 
-  double inverse_feed_rate = -1; // negative inverse_feed_rate means no inverse_feed_rate specified
+  float inverse_feed_rate = -1; // negative inverse_feed_rate means no inverse_feed_rate specified
   uint8_t absolute_override = false; // true(1) = absolute motion for this block only {G53}
   uint8_t non_modal_action = NON_MODAL_NONE; // Tracks the actions of modal group 0 (non-modal)
   
-  double target[3], offset[3];  
+  float target[3], offset[3];  
   clear_vector(target); // XYZ(ABC) axes parameters.
   clear_vector(offset); // IJK Arc offsets are incremental. Value of zero indicates no change.
     
@@ -248,11 +248,12 @@ uint8_t gc_execute_line(char *line)
   /* Pass 2: Parameters. All units converted according to current block commands. Position 
      parameters are converted and flagged to indicate a change. These can have multiple connotations
      for different commands. Each will be converted to their proper value upon execution. */
-  double p = 0, r = 0;
+  float p = 0, r = 0;
   uint8_t l = 0;
   char_counter = 0;
   while(next_statement(&letter, &value, line, &char_counter)) {
     switch(letter) {
+      case 'G': case 'M': break; // Ignore command statements
       case 'F': 
         if (value <= 0) { FAIL(STATUS_INVALID_COMMAND); } // Must be greater than zero
         if (gc.inverse_feed_rate_mode) {
@@ -276,6 +277,7 @@ uint8_t gc_execute_line(char *line)
       case 'X': target[X_AXIS] = to_millimeters(value); bit_true(axis_words,bit(X_AXIS)); break;
       case 'Y': target[Y_AXIS] = to_millimeters(value); bit_true(axis_words,bit(Y_AXIS)); break;
       case 'Z': target[Z_AXIS] = to_millimeters(value); bit_true(axis_words,bit(Z_AXIS)); break;
+      default: FAIL(STATUS_UNSUPPORTED_STATEMENT);
     }
   }
   
@@ -342,7 +344,6 @@ uint8_t gc_execute_line(char *line)
         mc_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], settings.default_seek_rate, false);
       }
       mc_go_home(); 
-//      clear_vector(gc.position); // Assumes home is at [0,0,0]
       axis_words = 0; // Axis words used. Lock out from motion modes by clearing flags.
       break;      
     case NON_MODAL_SET_COORDINATE_OFFSET:
@@ -473,11 +474,11 @@ uint8_t gc_execute_line(char *line)
             */
             
             // Calculate the change in position along each selected axis
-            double x = target[gc.plane_axis_0]-gc.position[gc.plane_axis_0];
-            double y = target[gc.plane_axis_1]-gc.position[gc.plane_axis_1];
+            float x = target[gc.plane_axis_0]-gc.position[gc.plane_axis_0];
+            float y = target[gc.plane_axis_1]-gc.position[gc.plane_axis_1];
             
             clear_vector(offset);
-            double h_x2_div_d = -sqrt(4 * r*r - x*x - y*y)/hypot(x,y); // == -(h * 2 / d)
+            float h_x2_div_d = -sqrt(4 * r*r - x*x - y*y)/hypot(x,y); // == -(h * 2 / d)
             // If r is smaller than d, the arc is now traversing the complex plane beyond the reach of any
             // real CNC, and thus - for practical reasons - we will terminate promptly:
             if(isnan(h_x2_div_d)) { FAIL(STATUS_FLOATING_POINT_ERROR); return(gc.status_code); }
@@ -535,7 +536,7 @@ uint8_t gc_execute_line(char *line)
     // As far as the parser is concerned, the position is now == target. In reality the
     // motion control system might still be processing the action and the real tool position
     // in any intermediate location.
-    memcpy(gc.position, target, sizeof(double)*3); // gc.position[] = target[];
+    memcpy(gc.position, target, sizeof(float)*3); // gc.position[] = target[];
   }
   
   // M0,M1,M2,M30: Perform non-running program flow actions. During a program pause, the buffer may 
@@ -556,7 +557,7 @@ uint8_t gc_execute_line(char *line)
 // Parses the next statement and leaves the counter on the first character following
 // the statement. Returns 1 if there was a statements, 0 if end of string was reached
 // or there was an error (check state.status_code).
-static int next_statement(char *letter, double *double_ptr, char *line, uint8_t *char_counter) 
+static int next_statement(char *letter, float *float_ptr, char *line, uint8_t *char_counter) 
 {
   if (line[*char_counter] == 0) {
     return(0); // No more statements
@@ -568,7 +569,7 @@ static int next_statement(char *letter, double *double_ptr, char *line, uint8_t
     return(0);
   }
   (*char_counter)++;
-  if (!read_double(line, char_counter, double_ptr)) {
+  if (!read_float(line, char_counter, float_ptr)) {
     FAIL(STATUS_BAD_NUMBER_FORMAT); 
     return(0);
   };