Allow the engine to use dynamic acceleration settings to get better time estimates.

src/fffProcessor.h

@@ -108,6 +108,7 @@ private:
         gcode.setSwitchExtruderCode(config.preSwitchExtruderCode, config.postSwitchExtruderCode);
         gcode.setFlavor(config.gcodeFlavor);
         gcode.setRetractionSettings(config.retractionAmount, config.retractionSpeed, config.retractionAmountExtruderSwitch, config.minimalExtrusionBeforeRetraction, config.retractionZHop, config.retractionAmountPrime);
+        gcode.applyAccelerationSettings(config);
     }
 
     bool prepareModel(SliceDataStorage& storage, const std::vector<std::string> &files)
@@ -344,6 +345,8 @@ private:
                 gcode.writeComment("TIME:<__TIME__>");
                 gcode.writeComment("MATERIAL:<FILAMENT>");
                 gcode.writeComment("MATERIAL2:<FILAMEN2>");
+                gcode.writeComment("NOZZLE_DIAMETER:%f", float(config.nozzleSize) / 1000);
+                gcode.writeComment("NOZZLE_DIAMETER2:%f", float(config.nozzleSize) / 1000);
             }
             gcode.writeCode(config.startCode.c_str());
             if (gcode.getFlavor() == GCODE_FLAVOR_BFB)

src/gcodeExport.cpp

@@ -85,6 +85,7 @@ void GCodeExport::setFlavor(int flavor)
         for(int n=0; n<MAX_EXTRUDERS; n++)
             extruderCharacter[n] = 'E';
 }
+
 int GCodeExport::getFlavor()
 {
     return this->flavor;
@@ -119,6 +120,11 @@ void GCodeExport::setRetractionSettings(int retractionAmount, int retractionSpee
     this->retractionZHop = zHop;
 }
 
+void GCodeExport::applyAccelerationSettings(ConfigSettings& config)
+{
+    estimateCalculator.applyAccelerationSettings(config);
+}
+
 void GCodeExport::setZ(int z)
 {
     this->zPos = z;

src/gcodeExport.h

@@ -64,6 +64,8 @@ public:
     
     void setRetractionSettings(int retractionAmount, int retractionSpeed, int extruderSwitchRetraction, int minimalExtrusionBeforeRetraction, int zHop, int retractionAmountPrime);
     
+    void applyAccelerationSettings(ConfigSettings& config);
+    
     void setZ(int z);
     
     Point getPositionXY();

src/settings.cpp

@@ -18,6 +18,7 @@ ConfigSettings *ConfigSettings::config = NULL;
 ConfigSettings::ConfigSettings()
 {
     config = this;
+    SETTING(nozzleSize, 400);
     SETTING(layerThickness, 100);
     SETTING(initialLayerThickness, 300);
     SETTING(filamentDiameter, 2890);
@@ -151,6 +152,17 @@ ConfigSettings::ConfigSettings()
         "G28 X0 Y0                      ;move X/Y to min endstops, so the head is out of the way\n"
         "M84                         ;steppers off\n"
         "G90                         ;absolute positioning\n";
+
+
+    //Time estimate settings
+    SETTING(acceleration, 3000 * 1000);
+    SETTING(max_acceleration[0], 9000 * 1000);
+    SETTING(max_acceleration[1], 9000 * 1000);
+    SETTING(max_acceleration[2], 100 * 1000);
+    SETTING(max_acceleration[3], 10000 * 1000);
+    SETTING(max_xy_jerk, 20.0 * 1000);
+    SETTING(max_z_jerk, 0.4 * 1000);
+    SETTING(max_e_jerk, 5.0 * 1000);
 }
 
 #undef STRINGIFY

src/settings.h

@@ -126,6 +126,7 @@ private:
     std::vector<_ConfigSettingIndex> _index;
 public:
     static ConfigSettings *config; // allow access to config settings from everywhere
+    int nozzleSize;
     int layerThickness;
     int initialLayerThickness;
     int filamentDiameter;
@@ -218,6 +219,13 @@ public:
     std::string endCode;
     std::string preSwitchExtruderCode;
     std::string postSwitchExtruderCode;
+    
+    //Time estimate settings
+    int acceleration;
+    int max_acceleration[4];
+    int max_xy_jerk;
+    int max_z_jerk;
+    int max_e_jerk;
 
     ConfigSettings();
     bool setSetting(const char* key, const char* value);

src/timeEstimate.cpp

@@ -6,16 +6,26 @@
 
 #define MINIMUM_PLANNER_SPEED 0.05// (mm/sec)
 
-const double max_feedrate[TimeEstimateCalculator::NUM_AXIS] = {600, 600, 40, 25};
-const double minimumfeedrate = 0.01;
-const double acceleration = 3000;
-const double max_acceleration[TimeEstimateCalculator::NUM_AXIS] = {9000,9000,100,10000};
-const double max_xy_jerk = 20.0;
-const double max_z_jerk = 0.4;
-const double max_e_jerk = 5.0;
+static double max_feedrate[TimeEstimateCalculator::NUM_AXIS] = {600, 600, 40, 25};
+static double minimumfeedrate = 0.01;
+static double acceleration = 3000;
+static double max_acceleration[TimeEstimateCalculator::NUM_AXIS] = {9000,9000,100,10000};
+static double max_xy_jerk = 20.0;
+static double max_z_jerk = 0.4;
+static double max_e_jerk = 5.0;
 
 template<typename T> const T square(const T& a) { return a * a; }
 
+void TimeEstimateCalculator::applyAccelerationSettings(ConfigSettings& config)
+{
+    acceleration = float(config.acceleration) / 1000.0;
+    for(unsigned int n=0; n<TimeEstimateCalculator::NUM_AXIS; n++)
+        max_acceleration[n] = float(config.max_acceleration[n]) / 1000.0;
+    max_xy_jerk = float(config.max_xy_jerk) / 1000.0;
+    max_z_jerk = float(config.max_z_jerk) / 1000.0;
+    max_e_jerk = float(config.max_e_jerk) / 1000.0;
+}
+
 void TimeEstimateCalculator::setPosition(Position newPos)
 {
     currentPosition = newPos;

src/timeEstimate.h

@@ -1,6 +1,7 @@
 #ifndef TIME_ESTIMATE_H
 #define TIME_ESTIMATE_H
 
+#include "settings.h"
 #include <stdint.h>
 #include <vector>
 
@@ -58,6 +59,8 @@ private:
 
     std::vector<Block> blocks;
 public:
+    void applyAccelerationSettings(ConfigSettings& config);
+
     void setPosition(Position newPos);
     void plan(Position newPos, double feedRate);
     void reset();