Merge branch 'Marlin_v1' of https://github.com/ErikZalm/Marlin into Marlin_v1

Marlin/Configuration.h

@@ -170,6 +170,7 @@ const bool Y_ENDSTOPS_INVERTING = true; // set to true to invert the logic of th
 const bool Z_ENDSTOPS_INVERTING = true; // set to true to invert the logic of the endstops. 
 // For optos H21LOB set to true, for Mendel-Parts newer optos TCST2103 set to false
 
+//#define ENDSTOPS_ONLY_FOR_HOMING // If defined the endstops will only be used for homing
 
 // For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1
 #define X_ENABLE_ON 0
@@ -279,8 +280,8 @@ const bool Z_ENDSTOPS_INVERTING = true; // set to true to invert the logic of th
 #ifdef ADVANCE
   #define EXTRUDER_ADVANCE_K .3
 
-  #define D_FILAMENT 1.7
+  #define D_FILAMENT 2.85
-  #define STEPS_MM_E 65
+  #define STEPS_MM_E 836
   #define EXTRUTION_AREA (0.25 * D_FILAMENT * D_FILAMENT * 3.14159)
   #define STEPS_PER_CUBIC_MM_E (axis_steps_per_unit[E_AXIS]/ EXTRUTION_AREA)
 

Marlin/Marlin.pde

@@ -529,6 +529,8 @@ FORCE_INLINE void process_commands()
       saved_feedmultiply = feedmultiply;
       feedmultiply = 100;
       
+      enable_endstops(true);
+      
       for(int8_t i=0; i < NUM_AXIS; i++) {
         destination[i] = current_position[i];
       }
@@ -564,6 +566,9 @@ FORCE_INLINE void process_commands()
         HOMEAXIS(Z);
 	current_position[2]=code_value()+add_homeing[2];
       }       
+      #ifdef ENDSTOPS_ONLY_FOR_HOMING
+        enable_endstops(false);
+      #endif
       
       feedrate = saved_feedrate;
       feedmultiply = saved_feedmultiply;

Marlin/planner.cpp

@@ -200,7 +200,6 @@ void calculate_trapezoid_for_block(block_t *block, float entry_factor, float exi
   
  // block->accelerate_until = accelerate_steps;
  // block->decelerate_after = accelerate_steps+plateau_steps;
-  
   CRITICAL_SECTION_START;  // Fill variables used by the stepper in a critical section
   if(block->busy == false) { // Don't update variables if block is busy.
     block->accelerate_until = accelerate_steps;
@@ -484,7 +483,7 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa
   // Bail if this is a zero-length block
   if (block->step_event_count <=dropsegments) { return; };
 
-  // Compute direction bits for this block
+  // Compute direction bits for this block 
   block->direction_bits = 0;
   if (target[X_AXIS] < position[X_AXIS]) { block->direction_bits |= (1<<X_AXIS); }
   if (target[Y_AXIS] < position[Y_AXIS]) { block->direction_bits |= (1<<Y_AXIS); }
@@ -725,7 +724,7 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa
     else {
       long acc_dist = estimate_acceleration_distance(0, block->nominal_rate, block->acceleration_st);
       float advance = (STEPS_PER_CUBIC_MM_E * EXTRUDER_ADVANCE_K) * 
-        (current_speed[E_AXIS] * current_speed[E_AXIS] * EXTRUTION_AREA * EXTRUTION_AREA / 3600.0)*65536;
+        (current_speed[E_AXIS] * current_speed[E_AXIS] * EXTRUTION_AREA * EXTRUTION_AREA)*256;
       block->advance = advance;
       if(acc_dist == 0) {
         block->advance_rate = 0;
@@ -734,6 +733,13 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa
         block->advance_rate = advance / (float)acc_dist;
       }
     }
+    /*
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPGM("advance :");
+    SERIAL_ECHO(block->advance/256.0);
+    SERIAL_ECHOPGM("advance rate :");
+    SERIAL_ECHOLN(block->advance_rate/256.0);
+    */
   #endif // ADVANCE
 
 

Marlin/stepper.cpp

@@ -56,9 +56,9 @@ static long counter_x,       // Counter variables for the bresenham line tracer
 volatile static unsigned long step_events_completed; // The number of step events executed in the current block
 #ifdef ADVANCE
   static long advance_rate, advance, final_advance = 0;
-  static short old_advance = 0;
+  static long old_advance = 0;
 #endif
-static short e_steps;
+static long e_steps;
 static unsigned char busy = false; // TRUE when SIG_OUTPUT_COMPARE1A is being serviced. Used to avoid retriggering that handler.
 static long acceleration_time, deceleration_time;
 //static unsigned long accelerate_until, decelerate_after, acceleration_rate, initial_rate, final_rate, nominal_rate;
@@ -79,13 +79,20 @@ static bool old_y_max_endstop=false;
 static bool old_z_min_endstop=false;
 static bool old_z_max_endstop=false;
 
+static bool check_endstops = true;
+
 volatile long count_position[NUM_AXIS] = { 0, 0, 0, 0};
 volatile char count_direction[NUM_AXIS] = { 1, 1, 1, 1};
 
 //===========================================================================
 //=============================functions         ============================
 //===========================================================================
-  
+
+#ifdef ENDSTOPS_ONLY_FOR_HOMING
+  #define CHECK_ENDSTOPS  if(check_endstops)
+#else
+  #define CHECK_ENDSTOPS
+#endif
 
 // intRes = intIn1 * intIn2 >> 16
 // uses:
@@ -191,6 +198,11 @@ void endstops_hit_on_purpose()
   endstop_z_hit=false;
 }
 
+void enable_endstops(bool check)
+{
+  check_endstops = check;
+}
+
 //         __________________________
 //        /|                        |\     _________________         ^
 //       / |                        | \   /|               |\        |
@@ -254,6 +266,9 @@ FORCE_INLINE void trapezoid_generator_reset() {
   #ifdef ADVANCE
     advance = current_block->initial_advance;
     final_advance = current_block->final_advance;
+    // Do E steps + advance steps
+    e_steps += ((advance >>8) - old_advance);
+    old_advance = advance >>8;  
   #endif
   deceleration_time = 0;
   // step_rate to timer interval
@@ -261,6 +276,17 @@ FORCE_INLINE void trapezoid_generator_reset() {
   acceleration_time = calc_timer(acc_step_rate);
   OCR1A = acceleration_time;
   OCR1A_nominal = calc_timer(current_block->nominal_rate);
+  
+//    SERIAL_ECHO_START;
+//    SERIAL_ECHOPGM("advance :");
+//    SERIAL_ECHO(current_block->advance/256.0);
+//    SERIAL_ECHOPGM("advance rate :");
+//    SERIAL_ECHO(current_block->advance_rate/256.0);
+//    SERIAL_ECHOPGM("initial advance :");
+//  SERIAL_ECHO(current_block->initial_advance/256.0);
+//    SERIAL_ECHOPGM("final advance :");
+//    SERIAL_ECHOLN(current_block->final_advance/256.0);
+    
 }
 
 // "The Stepper Driver Interrupt" - This timer interrupt is the workhorse.  
@@ -295,82 +321,100 @@ ISR(TIMER1_COMPA_vect)
     if ((out_bits & (1<<X_AXIS)) != 0) {   // -direction
       WRITE(X_DIR_PIN, INVERT_X_DIR);
       count_direction[X_AXIS]=-1;
-      #if X_MIN_PIN > -1
+      CHECK_ENDSTOPS
-        bool x_min_endstop=(READ(X_MIN_PIN) != X_ENDSTOPS_INVERTING);
+      {
-        if(x_min_endstop && old_x_min_endstop && (current_block->steps_x > 0)) {
+        #if X_MIN_PIN > -1
-          endstops_trigsteps[X_AXIS] = count_position[X_AXIS];
+          bool x_min_endstop=(READ(X_MIN_PIN) != X_ENDSTOPS_INVERTING);
-          endstop_x_hit=true;
+          if(x_min_endstop && old_x_min_endstop && (current_block->steps_x > 0)) {
-          step_events_completed = current_block->step_event_count;
+            endstops_trigsteps[X_AXIS] = count_position[X_AXIS];
-        }
+            endstop_x_hit=true;
-        old_x_min_endstop = x_min_endstop;
+            step_events_completed = current_block->step_event_count;
-      #endif
+          }
+          old_x_min_endstop = x_min_endstop;
+        #endif
+      }
     }
     else { // +direction 
       WRITE(X_DIR_PIN,!INVERT_X_DIR);
       count_direction[X_AXIS]=1;
-      #if X_MAX_PIN > -1
+      CHECK_ENDSTOPS 
-        bool x_max_endstop=(READ(X_MAX_PIN) != X_ENDSTOPS_INVERTING);
+      {
-        if(x_max_endstop && old_x_max_endstop && (current_block->steps_x > 0)){
+        #if X_MAX_PIN > -1
-          endstops_trigsteps[X_AXIS] = count_position[X_AXIS];
+          bool x_max_endstop=(READ(X_MAX_PIN) != X_ENDSTOPS_INVERTING);
-          endstop_x_hit=true;
+          if(x_max_endstop && old_x_max_endstop && (current_block->steps_x > 0)){
-          step_events_completed = current_block->step_event_count;
+            endstops_trigsteps[X_AXIS] = count_position[X_AXIS];
-        }
+            endstop_x_hit=true;
-        old_x_max_endstop = x_max_endstop;
+            step_events_completed = current_block->step_event_count;
-      #endif
+          }
+          old_x_max_endstop = x_max_endstop;
+        #endif
+      }
     }
 
     if ((out_bits & (1<<Y_AXIS)) != 0) {   // -direction
       WRITE(Y_DIR_PIN,INVERT_Y_DIR);
       count_direction[Y_AXIS]=-1;
-      #if Y_MIN_PIN > -1
+      CHECK_ENDSTOPS
-        bool y_min_endstop=(READ(Y_MIN_PIN) != Y_ENDSTOPS_INVERTING);
+      {
-        if(y_min_endstop && old_y_min_endstop && (current_block->steps_y > 0)) {
+        #if Y_MIN_PIN > -1
-          endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS];
+          bool y_min_endstop=(READ(Y_MIN_PIN) != Y_ENDSTOPS_INVERTING);
-          endstop_y_hit=true;
+          if(y_min_endstop && old_y_min_endstop && (current_block->steps_y > 0)) {
-          step_events_completed = current_block->step_event_count;
+            endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS];
-        }
+            endstop_y_hit=true;
-        old_y_min_endstop = y_min_endstop;
+            step_events_completed = current_block->step_event_count;
-      #endif
+          }
+          old_y_min_endstop = y_min_endstop;
+        #endif
+      }
     }
     else { // +direction
     WRITE(Y_DIR_PIN,!INVERT_Y_DIR);
       count_direction[Y_AXIS]=1;
-      #if Y_MAX_PIN > -1
+      CHECK_ENDSTOPS
-        bool y_max_endstop=(READ(Y_MAX_PIN) != Y_ENDSTOPS_INVERTING);
+      {
-        if(y_max_endstop && old_y_max_endstop && (current_block->steps_y > 0)){
+        #if Y_MAX_PIN > -1
-          endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS];
+          bool y_max_endstop=(READ(Y_MAX_PIN) != Y_ENDSTOPS_INVERTING);
-          endstop_y_hit=true;
+          if(y_max_endstop && old_y_max_endstop && (current_block->steps_y > 0)){
-          step_events_completed = current_block->step_event_count;
+            endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS];
-        }
+            endstop_y_hit=true;
-        old_y_max_endstop = y_max_endstop;
+            step_events_completed = current_block->step_event_count;
-      #endif
+          }
+          old_y_max_endstop = y_max_endstop;
+        #endif
+      }
     }
 
     if ((out_bits & (1<<Z_AXIS)) != 0) {   // -direction
       WRITE(Z_DIR_PIN,INVERT_Z_DIR);
       count_direction[Z_AXIS]=-1;
-      #if Z_MIN_PIN > -1
+      CHECK_ENDSTOPS
-        bool z_min_endstop=(READ(Z_MIN_PIN) != Z_ENDSTOPS_INVERTING);
+      {
-        if(z_min_endstop && old_z_min_endstop && (current_block->steps_z > 0)) {
+        #if Z_MIN_PIN > -1
-          endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS];
+          bool z_min_endstop=(READ(Z_MIN_PIN) != Z_ENDSTOPS_INVERTING);
-          endstop_z_hit=true;
+          if(z_min_endstop && old_z_min_endstop && (current_block->steps_z > 0)) {
-          step_events_completed = current_block->step_event_count;
+            endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS];
-        }
+            endstop_z_hit=true;
-        old_z_min_endstop = z_min_endstop;
+            step_events_completed = current_block->step_event_count;
-      #endif
+          }
+          old_z_min_endstop = z_min_endstop;
+        #endif
+      }
     }
     else { // +direction
       WRITE(Z_DIR_PIN,!INVERT_Z_DIR);
-        count_direction[Z_AXIS]=1;
+      count_direction[Z_AXIS]=1;
-      #if Z_MAX_PIN > -1
+      CHECK_ENDSTOPS
-        bool z_max_endstop=(READ(Z_MAX_PIN) != Z_ENDSTOPS_INVERTING);
+      {
-        if(z_max_endstop && old_z_max_endstop && (current_block->steps_z > 0)) {
+        #if Z_MAX_PIN > -1
-          endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS];
+          bool z_max_endstop=(READ(Z_MAX_PIN) != Z_ENDSTOPS_INVERTING);
-          endstop_z_hit=true;
+          if(z_max_endstop && old_z_max_endstop && (current_block->steps_z > 0)) {
-          step_events_completed = current_block->step_event_count;
+            endstops_trigsteps[Z_AXIS] = count_position[Z_AXIS];
-        }
+            endstop_z_hit=true;
-        old_z_max_endstop = z_max_endstop;
+            step_events_completed = current_block->step_event_count;
-      #endif
+          }
+          old_z_max_endstop = z_max_endstop;
+        #endif
+      }
     }
 
     #ifndef ADVANCE
@@ -383,6 +427,9 @@ ISR(TIMER1_COMPA_vect)
         count_direction[E_AXIS]=-1;
       }
     #endif //!ADVANCE
+    
+
+    
     for(int8_t i=0; i < step_loops; i++) { // Take multiple steps per interrupt (For high speed moves) 
       MSerial.checkRx(); // Check for serial chars. 
       
@@ -391,19 +438,12 @@ ISR(TIMER1_COMPA_vect)
       if (counter_e > 0) {
         counter_e -= current_block->step_event_count;
         if ((out_bits & (1<<E_AXIS)) != 0) { // - direction
-          CRITICAL_SECTION_START;
           e_steps--;
-          CRITICAL_SECTION_END;
         }
         else {
-          CRITICAL_SECTION_START;
           e_steps++;
-          CRITICAL_SECTION_END;
         }
       }    
-      // Do E steps + advance steps
-      e_steps += ((advance >> 16) - old_advance);
-      old_advance = advance >> 16;  
       #endif //ADVANCE
       
       counter_x += current_block->steps_x;
@@ -462,6 +502,11 @@ ISR(TIMER1_COMPA_vect)
         for(int8_t i=0; i < step_loops; i++) {
           advance += advance_rate;
         }
+        //if(advance > current_block->advance) advance = current_block->advance;
+        // Do E steps + advance steps
+        e_steps += ((advance >>8) - old_advance);
+        old_advance = advance >>8;  
+        
       #endif
     } 
     else if (step_events_completed > (unsigned long int)current_block->decelerate_after) {   
@@ -486,8 +531,10 @@ ISR(TIMER1_COMPA_vect)
         for(int8_t i=0; i < step_loops; i++) {
           advance -= advance_rate;
         }
-        if(advance < final_advance)
+        if(advance < final_advance) advance = final_advance;
-          advance = final_advance;
+        // Do E steps + advance steps
+        e_steps += ((advance >>8) - old_advance);
+        old_advance = advance >>8;  
       #endif //ADVANCE
     }
     else {
@@ -508,7 +555,7 @@ ISR(TIMER1_COMPA_vect)
   // Timer 0 is shared with millies
   ISR(TIMER0_COMPA_vect)
   {
-    old_OCR0A += 25; // ~10kHz interrupt
+    old_OCR0A += 52; // ~10kHz interrupt (250000 / 26 = 9615kHz)
     OCR0A = old_OCR0A;
     // Set E direction (Depends on E direction + advance)
     for(unsigned char i=0; i<4;) {
@@ -520,7 +567,7 @@ ISR(TIMER1_COMPA_vect)
         e_steps++;
         WRITE(E_STEP_PIN, HIGH);
       } 
-      if (e_steps > 0) {
+      else if (e_steps > 0) {
         WRITE(E_DIR_PIN,!INVERT_E_DIR);
         e_steps--;
         WRITE(E_STEP_PIN, HIGH);
@@ -649,6 +696,13 @@ void st_init()
     e_steps = 0;
     TIMSK0 |= (1<<OCIE0A);
   #endif //ADVANCE
+  
+  #ifdef ENDSTOPS_ONLY_FOR_HOMING
+    enable_endstops(false);
+  #else
+    enable_endstops(true);
+  #endif
+  
   sei();
 }
 

Marlin/stepper.h

@@ -44,6 +44,8 @@ void st_wake_up();
 void checkHitEndstops(); //call from somwhere to create an serial error message with the locations the endstops where hit, in case they were triggered
 void endstops_hit_on_purpose(); //avoid creation of the message, i.e. after homeing and before a routine call of checkHitEndstops();
 
+void enable_endstops(bool check); // Enable/disable endstop checking
+
 void checkStepperErrors(); //Print errors detected by the stepper
 
 void finishAndDisableSteppers();