Updated Repetier version
This commit is contained in:
parent
d46229bf4b
commit
a0bb6d8315
73 changed files with 23884 additions and 15089 deletions
|
@ -63,6 +63,9 @@ WiFiServer server(port);
|
|||
|
||||
|
||||
void setup() {
|
||||
// Set wifi mode to client
|
||||
WiFi.mode(WIFI_STA);
|
||||
|
||||
// Initialize Serial connection
|
||||
Serial.begin(115200);
|
||||
delay(10);
|
||||
|
@ -73,8 +76,6 @@ void setup() {
|
|||
pinMode(bluePin, OUTPUT);
|
||||
|
||||
// Connect to WiFi network
|
||||
Serial.println();
|
||||
Serial.println();
|
||||
Serial.print("Connecting to ");
|
||||
Serial.println(ssid);
|
||||
WiFi.begin(ssid, password);
|
||||
|
|
635
Repetier/BedLeveling.cpp
Normal file
635
Repetier/BedLeveling.cpp
Normal file
|
@ -0,0 +1,635 @@
|
|||
|
||||
/*
|
||||
More and more printers now have automatic bed leveling using an ever increasing variety of methods.
|
||||
This makes the leveling routine one of the most complex parts of the firmware and there is not one
|
||||
way to level but hundreds of combinations.
|
||||
|
||||
First you should decide on the correction method. Once we know how our bed is tilted we want to
|
||||
remove that. This correction is defined by BED_CORRECTION_METHOD and allows the following values:
|
||||
BED_CORRECTION_METHOD 0
|
||||
Use a rotation matrix. This will make z axis go up/down while moving in x/y direction to compensate
|
||||
the tilt. For multiple extruders make sure the height match the tilt of the bed or one will scratch.
|
||||
|
||||
BED_CORRECTION_METHOD 1
|
||||
Motorized correction. This method needs a bed that is fixed on 3 points from which 2 have a motor
|
||||
to change the height. The positions are defined by
|
||||
BED_MOTOR_1_X, BED_MOTOR_1_Y, BED_MOTOR_2_X, BED_MOTOR_2_Y, BED_MOTOR_3_X, BED_MOTOR_3_Y
|
||||
Motor 2 and 3 are the one driven by motor driver 0 and 1. These can be extra motors like Felix Pro 1
|
||||
uses them or a system with 3 z axis where motors can be controlled individually like the Sparkcube
|
||||
does.
|
||||
|
||||
Next we have to distinguish several methods of z probing sensors. Each have their own advantages and
|
||||
disadvantages. First the z probe has a position when activated and that position is defined by
|
||||
#define Z_PROBE_X_OFFSET 0
|
||||
#define Z_PROBE_Y_OFFSET 0
|
||||
This is needed since we need to know where we measure the height when the z probe triggers. When
|
||||
probing is activated you will see a move to make probe go over current extruder position. The
|
||||
position can be changed in eeprom later on.
|
||||
|
||||
Some probes need to be activated/deactivated so we can use them. This is defined in the scripts
|
||||
#define Z_PROBE_START_SCRIPT ""
|
||||
#define Z_PROBE_FINISHED_SCRIPT ""
|
||||
|
||||
Now when we probe we want to know the distance of the extruder to the bed. This is defined by
|
||||
#define Z_PROBE_HEIGHT 4
|
||||
The 4 means that when we trigger the distance of the nozzle tip is 4mm. If your switch tends
|
||||
to return different points you might repeat a measured point and use the average height:
|
||||
#define Z_PROBE_SWITCHING_DISTANCE 1
|
||||
#define Z_PROBE_REPETITIONS 5
|
||||
Switching distance is the z raise needed to turn back a signal reliably to off. Inductive sensors
|
||||
need only a bit while mechanical switches may require a bit more.
|
||||
|
||||
Next thing to consider is the force for switching. Some beds use a cantilever design and pushing on
|
||||
the outside easily bends the bed. If your sensor needs some force to trigger you add the error of
|
||||
bending. For this reason you might add a bending correction. Currently you define
|
||||
#define BENDING_CORRECTION_A 0
|
||||
#define BENDING_CORRECTION_B 0
|
||||
#define BENDING_CORRECTION_C 0
|
||||
which are the deflections at the 3 z probe points. For all other possible measurements these values
|
||||
get interpolated. You can modify the values later on in eeprom. For force less sensors set them to 0.
|
||||
|
||||
Next thing is endstop handling. Without bed leveling you normally home to minimum position for x,y and z.
|
||||
With bed leveling this is not that easy any more. Since we do bed leveling we already assume the bed is
|
||||
not leveled for x/y moves. So without correction we would hit the bed for different x/y positions at
|
||||
different heights. As a result we have no real minimum position. That makes a z min endstop quite useless.
|
||||
There is an exception to this. If your nozzle triggers z min or if a inductive sensor would trigger at a given
|
||||
position we could use that signal. With nozzle triggers you need to be careful as a drop of filament
|
||||
would change the height. The other problem is that while homing the auto leveling is not used. So
|
||||
the only position would be if the z min sensor is directly over the 0,0 coordinate which is the rotation point
|
||||
if we have matrix based correction. For motor based correction this will work everywhere correctly.
|
||||
|
||||
So the only useful position for a z endstop is z max position. Apart from not having the bed tilt problem it
|
||||
also allows homing with a full bed so you can continue an aborted print with some gcode tweaking. With z max
|
||||
homing we adjust the error by simply changing the max. z height. One thing you need to remember is setting
|
||||
#define ENDSTOP_Z_BACK_ON_HOME 4
|
||||
so we release the z max endstop. This is very important if we move xy at z max. Auto leveling might want to
|
||||
increase z and the endstop might prevent it causing wrong position and a head crash if we later go down.
|
||||
The value should be larger then the maximum expected tilt.
|
||||
|
||||
Now it is time to define how we measure the bed rotation. Here again we have several methods to choose.
|
||||
All methods need at least 3 points to define the bed rotation correctly. The quality we get comes
|
||||
from the selection of the right points and method.
|
||||
|
||||
BED_LEVELING_METHOD 0
|
||||
This method measures at the 3 probe points and creates a plane through these points. If you have
|
||||
a really planar bed this gives the optimum result. The 3 points must not be in one line and have
|
||||
a long distance to increase numerical stability.
|
||||
|
||||
BED_LEVELING_METHOD 1
|
||||
This measures a grid. Probe point 1 is the origin and points 2 and 3 span a grid. We measure
|
||||
BED_LEVELING_GRID_SIZE points in each direction and compute a regression plane through all
|
||||
points. This gives a good overall plane if you have small bumps measuring inaccuracies.
|
||||
|
||||
BED_LEVELING_METHOD 2
|
||||
Bending correcting 4 point measurement. This is for cantilevered beds that have the rotation axis
|
||||
not at the side but inside the bed. Here we can assume no bending on the axis and a symmetric
|
||||
bending to both sides of the axis. So probe points 2 and 3 build the symmetric axis and
|
||||
point 1 is mirrored to 1m across the axis. Using the symmetry we then remove the bending
|
||||
from 1 and use that as plane.
|
||||
|
||||
By now the leveling process is finished. All errors that remain are measuring errors and bumps on
|
||||
the bed it self. For deltas you can enable distortion correction to follow the bumps.
|
||||
|
||||
*/
|
||||
|
||||
#include "Repetier.h"
|
||||
|
||||
#ifndef BED_LEVELING_METHOD
|
||||
#define BED_LEVELING_METHOD 0
|
||||
#endif
|
||||
|
||||
#ifndef BED_CORRECTION_METHOD
|
||||
#define BED_CORRECTION_METHOD 0
|
||||
#endif
|
||||
|
||||
#ifndef BED_LEVELING_GRID_SIZE
|
||||
#define BED_LEVELING_GRID_SIZE 5
|
||||
#endif
|
||||
|
||||
#ifndef BED_LEVELING_REPETITIONS
|
||||
#define BED_LEVELING_REPETITIONS 1
|
||||
#endif
|
||||
|
||||
#if FEATURE_AUTOLEVEL && FEATURE_Z_PROBE
|
||||
|
||||
class Plane {
|
||||
public:
|
||||
// f(x, y) = ax + by + c
|
||||
float a,b,c;
|
||||
float z(float x,float y) {
|
||||
return a * x + y * b + c;
|
||||
}
|
||||
};
|
||||
class PlaneBuilder {
|
||||
float sum_xx,sum_xy,sum_yy,sum_x,sum_y,sum_xz,sum_yz,sum_z,n;
|
||||
public:
|
||||
void reset() {
|
||||
sum_xx = sum_xy = sum_yy = sum_x = sum_y = sum_xz = sum_yz = sum_z = n = 0;
|
||||
}
|
||||
void addPoint(float x,float y,float z) {
|
||||
n++;
|
||||
sum_xx += x * x;
|
||||
sum_xy += x * y;
|
||||
sum_yy += y * y;
|
||||
sum_x += x;
|
||||
sum_y += y;
|
||||
sum_xz += x * z;
|
||||
sum_yz += y * z;
|
||||
sum_z += z;
|
||||
}
|
||||
void createPlane(Plane &plane) {
|
||||
float det = (sum_x*(sum_xy*sum_y-sum_x*sum_yy)+sum_xx*(n*sum_yy-sum_y*sum_y)+sum_xy*(sum_x*sum_y-n*sum_xy));
|
||||
plane.a = ((sum_xy*sum_y-sum_x*sum_yy)*sum_z+(sum_x*sum_y-n*sum_xy)*sum_yz+sum_xz*(n*sum_yy-sum_y*sum_y)) /det;
|
||||
plane.b = ((sum_x*sum_xy-sum_xx*sum_y)*sum_z+(n*sum_xx-sum_x*sum_x)*sum_yz+sum_xz*(sum_x*sum_y-n*sum_xy)) /det;
|
||||
plane.c = ((sum_xx*sum_yy-sum_xy*sum_xy)*sum_z+(sum_x*sum_xy-sum_xx*sum_y)*sum_yz+sum_xz*(sum_xy*sum_y-sum_x*sum_yy))/det;
|
||||
Com::printF(PSTR("plane: a = "),plane.a,4);
|
||||
Com::printF(PSTR(" b = "),plane.b,4);
|
||||
Com::printFLN(PSTR(" c = "),plane.c,4);
|
||||
}
|
||||
};
|
||||
|
||||
bool measureAutolevelPlane(Plane &plane) {
|
||||
PlaneBuilder builder;
|
||||
builder.reset();
|
||||
#if BED_LEVELING_METHOD == 0 // 3 point
|
||||
float h;
|
||||
Printer::moveTo(EEPROM::zProbeX1(),EEPROM::zProbeY1(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h = Printer::runZProbe(false,false);
|
||||
if(h < -1)
|
||||
return false;
|
||||
builder.addPoint(EEPROM::zProbeX1(),EEPROM::zProbeY1(),h);
|
||||
Printer::moveTo(EEPROM::zProbeX2(),EEPROM::zProbeY2(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h = Printer::runZProbe(false,false);
|
||||
if(h < -1)
|
||||
return false;
|
||||
builder.addPoint(EEPROM::zProbeX2(),EEPROM::zProbeY2(),h);
|
||||
Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h = Printer::runZProbe(false,false);
|
||||
if(h < -1)
|
||||
return false;
|
||||
builder.addPoint(EEPROM::zProbeX3(),EEPROM::zProbeY3(),h);
|
||||
#elif BED_LEVELING_METHOD == 1 // linear regression
|
||||
float delta = 1.0/(BED_LEVELING_GRID_SIZE - 1);
|
||||
float ox = EEPROM::zProbeX1();
|
||||
float oy = EEPROM::zProbeY1();
|
||||
float ax = delta * (EEPROM::zProbeX2() - EEPROM::zProbeX1());
|
||||
float ay = delta * (EEPROM::zProbeY2() - EEPROM::zProbeY1());
|
||||
float bx = delta * (EEPROM::zProbeX3() - EEPROM::zProbeX1());
|
||||
float by = delta * (EEPROM::zProbeY3() - EEPROM::zProbeY1());
|
||||
for(int ix = 0; ix < BED_LEVELING_GRID_SIZE; ix++) {
|
||||
for(int iy = 0; iy < BED_LEVELING_GRID_SIZE; iy++) {
|
||||
float px = ox + static_cast<float>(ix) * ax + static_cast<float>(iy) * bx;
|
||||
float py = oy + static_cast<float>(ix) * ay + static_cast<float>(iy) * by;
|
||||
Printer::moveTo(px,py,IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
float h = Printer::runZProbe(false,false);
|
||||
if(h < -1)
|
||||
return false;
|
||||
builder.addPoint(px,py,h);
|
||||
}
|
||||
}
|
||||
#elif BED_LEVELING_METHOD == 2 // 4 point symmetric
|
||||
float h1,h2,h3,h4;
|
||||
float apx = EEPROM::zProbeX1() - EEPROM::zProbeX2();
|
||||
float apy = EEPROM::zProbeY1() - EEPROM::zProbeY2();
|
||||
float abx = EEPROM::zProbeX3() - EEPROM::zProbeX2();
|
||||
float aby = EEPROM::zProbeY3() - EEPROM::zProbeY2();
|
||||
float ab2 = abx * abx + aby * aby;
|
||||
float abap = apx * abx + apy * aby;
|
||||
float t = abap / ab2;
|
||||
float xx = EEPROM::zProbeX2() + t * abx;
|
||||
float xy = EEPROM::zProbeY2() + t * aby;
|
||||
float x1Mirror = EEPROM::zProbeX1() + 2.0 * (xx - EEPROM::zProbeX1());
|
||||
float y1Mirror = EEPROM::zProbeY1() + 2.0 * (xy - EEPROM::zProbeY1());
|
||||
Printer::moveTo(EEPROM::zProbeX1(),EEPROM::zProbeY1(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h1 = Printer::runZProbe(false,false);
|
||||
if(h1 < -1)
|
||||
return false;
|
||||
Printer::moveTo(EEPROM::zProbeX2(),EEPROM::zProbeY2(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h2 = Printer::runZProbe(false,false);
|
||||
if(h2 < -1)
|
||||
return false;
|
||||
Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h3 = Printer::runZProbe(false,false);
|
||||
if(h3 < -1)
|
||||
return false;
|
||||
Printer::moveTo(x1Mirror,y1Mirror,IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h4 = Printer::runZProbe(false,false);
|
||||
if(h4 < -1)
|
||||
return false;
|
||||
t = h2 + (h3-h2) * t; // theoretical height for crossing point for symmetric axis
|
||||
h1 = t - (h4-h1) * 0.5; // remove bending part
|
||||
builder.addPoint(EEPROM::zProbeX1(),EEPROM::zProbeY1(),h1);
|
||||
builder.addPoint(EEPROM::zProbeX2(),EEPROM::zProbeY2(),h2);
|
||||
builder.addPoint(EEPROM::zProbeX3(),EEPROM::zProbeY3(),h3);
|
||||
#else
|
||||
#error Unknown bed leveling method
|
||||
#endif
|
||||
builder.createPlane(plane);
|
||||
return true;
|
||||
}
|
||||
|
||||
void correctAutolevel(GCode *code,Plane &plane) {
|
||||
#if BED_CORRECTION_METHOD == 0 // rotation matrix
|
||||
Printer::buildTransformationMatrix(plane.z(EEPROM::zProbeX1(),EEPROM::zProbeY1()),plane.z(EEPROM::zProbeX2(),EEPROM::zProbeY2()),plane.z(EEPROM::zProbeX3(),EEPROM::zProbeY3()));
|
||||
#elif BED_CORRECTION_METHOD == 1 // motorized correction
|
||||
#if !defined(NUM_MOTOR_DRIVERS) || NUM_MOTOR_DRIVERS < 2
|
||||
#error You need to define 2 motors for motorized bed correction
|
||||
#endif
|
||||
Commands::waitUntilEndOfAllMoves(); // move steppers might be leveling steppers as well !
|
||||
float h1 = plane.z(BED_MOTOR_1_X,BED_MOTOR_1_Y);
|
||||
float h2 = plane.z(BED_MOTOR_2_X,BED_MOTOR_2_Y);
|
||||
float h3 = plane.z(BED_MOTOR_3_X,BED_MOTOR_3_Y);
|
||||
// h1 is reference heights, h2 => motor 0, h3 => motor 1
|
||||
h2 -= h1;
|
||||
h3 -= h1;
|
||||
MotorDriverInterface *motor2 = getMotorDriver(0);
|
||||
MotorDriverInterface *motor3 = getMotorDriver(1);
|
||||
motor2->setCurrentAs(0);
|
||||
motor3->setCurrentAs(0);
|
||||
motor2->gotoPosition(h2);
|
||||
motor3->gotoPosition(h3);
|
||||
motor2->disable();
|
||||
motor3->disable(); // now bed is even
|
||||
Printer::currentPositionSteps[Z_AXIS] = h1 * Printer::axisStepsPerMM[Z_AXIS];
|
||||
#else
|
||||
#error Unknown bed correction method set
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
Implementation of the G32 command
|
||||
G32 S<0..2> - Autolevel print bed. S = 1 measure zLength, S = 2 Measure and store new zLength
|
||||
S = 0 : Do not update length - use this if you have not homed before or you mess up zlength!
|
||||
S = 1 : Measure zLength so homing works
|
||||
S = 2 : Like s = 1 plus store results in EEPROM for next connection.
|
||||
*/
|
||||
void runBedLeveling(GCode *com) {
|
||||
float h1,h2,h3,hc,oldFeedrate = Printer::feedrate;
|
||||
int s = com->hasS() ? com->S : -1;
|
||||
#if DISTORTION_CORRECTION
|
||||
bool distEnabled = Printer::distortion.isEnabled();
|
||||
Printer::distortion.disable(false); // if level has changed, distortion is also invalid
|
||||
#endif
|
||||
Printer::setAutolevelActive(false); // iterate
|
||||
Printer::resetTransformationMatrix(true); // in case we switch from matrix to motorized!
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
// It is not possible to go to the edges at the top, also users try
|
||||
// it often and wonder why the coordinate system is then wrong.
|
||||
// For that reason we ensure a correct behavior by code.
|
||||
Printer::homeAxis(true, true, true);
|
||||
Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
|
||||
#endif
|
||||
Printer::startProbing(true);
|
||||
//GCode::executeFString(Com::tZProbeStartScript);
|
||||
Printer::coordinateOffset[X_AXIS] = Printer::coordinateOffset[Y_AXIS] = Printer::coordinateOffset[Z_AXIS] = 0;
|
||||
Plane plane;
|
||||
#if BED_CORRECTION_METHOD == 1
|
||||
for(int r = 0; r < BED_LEVELING_REPETITIONS; r++) {
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
if(r > 0) {
|
||||
Printer::finishProbing();
|
||||
Printer::homeAxis(true, true, true);
|
||||
Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
|
||||
Printer::startProbing(true);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
if(!measureAutolevelPlane(plane)) {
|
||||
Com::printErrorFLN(PSTR("Probing had returned errors - autoleveling canceled."));
|
||||
return;
|
||||
}
|
||||
correctAutolevel(com,plane);
|
||||
|
||||
// Leveling is finished now update own positions and store leveling data if needed
|
||||
float currentZ = plane.z((float)Printer::currentPositionSteps[X_AXIS] * Printer::invAxisStepsPerMM[X_AXIS],(float)Printer::currentPositionSteps[Y_AXIS] * Printer::invAxisStepsPerMM[Y_AXIS]);
|
||||
Com::printF(PSTR("CurrentZ:"),currentZ);Com::printFLN(PSTR(" atZ:"),Printer::currentPosition[Z_AXIS]);
|
||||
// With max z endstop we adjust zlength so after next homing we have also a calibrated printer
|
||||
Printer::zMin = 0;
|
||||
#if MAX_HARDWARE_ENDSTOP_Z
|
||||
float xRot,yRot,zRot;
|
||||
#if BED_CORRECTION_METHOD != 1
|
||||
Printer::transformFromPrinter(Printer::currentPosition[X_AXIS],Printer::currentPosition[Y_AXIS],Printer::currentPosition[Z_AXIS],xRot,yRot,zRot);
|
||||
Com::printFLN(PSTR("Z after rotation:"),zRot);
|
||||
#else
|
||||
zRot = Printer::currentPosition[Z_AXIS];
|
||||
#endif
|
||||
// With max z endstop we adjust zlength so after next homing we have also a calibrated printer
|
||||
if(s != 0) {
|
||||
Printer::zLength += currentZ - zRot;
|
||||
Com::printFLN(Com::tZProbePrinterHeight, Printer::zLength);
|
||||
}
|
||||
#endif
|
||||
Printer::currentPositionSteps[Z_AXIS] = currentZ * Printer::axisStepsPerMM[Z_AXIS];
|
||||
Printer::updateCurrentPosition(true);
|
||||
#if BED_CORRECTION_METHOD == 1
|
||||
if(fabs(plane.a) < 0.00025 && fabsf(plane.b) < 0.00025 )
|
||||
break; // we reached achievable precision so we can stop
|
||||
}
|
||||
#endif
|
||||
Printer::updateDerivedParameter();
|
||||
Printer::finishProbing();
|
||||
#if BED_CORRECTION_METHOD != 1
|
||||
Printer::setAutolevelActive(true); // only for software correction or we can spare the comp. time
|
||||
#endif
|
||||
if(s >= 2) {
|
||||
EEPROM::storeDataIntoEEPROM();
|
||||
}
|
||||
Printer::updateCurrentPosition(true);
|
||||
Commands::printCurrentPosition(PSTR("G32 "));
|
||||
#if DISTORTION_CORRECTION
|
||||
if(distEnabled)
|
||||
Printer::distortion.enable(false); // if level has changed, distortion is also invalid
|
||||
#endif
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
Printer::homeAxis(true, true, true); // shifting z makes positioning invalid, need to recalibrate
|
||||
#endif
|
||||
Printer::feedrate = oldFeedrate;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void Printer::setAutolevelActive(bool on)
|
||||
{
|
||||
#if FEATURE_AUTOLEVEL
|
||||
if(on == isAutolevelActive()) return;
|
||||
flag0 = (on ? flag0 | PRINTER_FLAG0_AUTOLEVEL_ACTIVE : flag0 & ~PRINTER_FLAG0_AUTOLEVEL_ACTIVE);
|
||||
if(on)
|
||||
Com::printInfoFLN(Com::tAutolevelEnabled);
|
||||
else
|
||||
Com::printInfoFLN(Com::tAutolevelDisabled);
|
||||
updateCurrentPosition(false);
|
||||
#endif // FEATURE_AUTOLEVEL
|
||||
}
|
||||
#if MAX_HARDWARE_ENDSTOP_Z
|
||||
float Printer::runZMaxProbe()
|
||||
{
|
||||
#if NONLINEAR_SYSTEM
|
||||
long startZ = realDeltaPositionSteps[Z_AXIS] = currentDeltaPositionSteps[Z_AXIS]; // update real
|
||||
#endif
|
||||
Commands::waitUntilEndOfAllMoves();
|
||||
long probeDepth = 2*(Printer::zMaxSteps-Printer::zMinSteps);
|
||||
stepsRemainingAtZHit = -1;
|
||||
setZProbingActive(true);
|
||||
PrintLine::moveRelativeDistanceInSteps(0,0,probeDepth,0,EEPROM::zProbeSpeed(),true,true);
|
||||
if(stepsRemainingAtZHit < 0)
|
||||
{
|
||||
Com::printErrorFLN(Com::tZProbeFailed);
|
||||
return -1;
|
||||
}
|
||||
setZProbingActive(false);
|
||||
currentPositionSteps[Z_AXIS] -= stepsRemainingAtZHit;
|
||||
#if NONLINEAR_SYSTEM
|
||||
probeDepth -= (realDeltaPositionSteps[Z_AXIS] - startZ);
|
||||
#else
|
||||
probeDepth -= stepsRemainingAtZHit;
|
||||
#endif
|
||||
float distance = (float)probeDepth * invAxisStepsPerMM[Z_AXIS];
|
||||
Com::printF(Com::tZProbeMax,distance);
|
||||
Com::printF(Com::tSpaceXColon,realXPosition());
|
||||
Com::printFLN(Com::tSpaceYColon,realYPosition());
|
||||
PrintLine::moveRelativeDistanceInSteps(0,0,-probeDepth,0,EEPROM::zProbeSpeed(),true,true);
|
||||
return distance;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if FEATURE_Z_PROBE
|
||||
void Printer::startProbing(bool runScript) {
|
||||
float oldOffX = Printer::offsetX;
|
||||
float oldOffY = Printer::offsetY;
|
||||
float oldOffZ = Printer::offsetZ;
|
||||
if(runScript)
|
||||
GCode::executeFString(Com::tZProbeStartScript);
|
||||
float maxStartHeight = EEPROM::zProbeBedDistance() + (EEPROM::zProbeHeight() > 0 ? EEPROM::zProbeHeight() : 0) + 0.1;
|
||||
if(currentPosition[Z_AXIS] > maxStartHeight) {
|
||||
moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, maxStartHeight, IGNORE_COORDINATE, homingFeedrate[Z_AXIS]);
|
||||
}
|
||||
Printer::offsetX = -EEPROM::zProbeXOffset();
|
||||
Printer::offsetY = -EEPROM::zProbeYOffset();
|
||||
Printer::offsetZ = 0; // we correct this with probe height
|
||||
PrintLine::moveRelativeDistanceInSteps((Printer::offsetX - oldOffX) * Printer::axisStepsPerMM[X_AXIS],
|
||||
(Printer::offsetY - oldOffY) * Printer::axisStepsPerMM[Y_AXIS],
|
||||
0, 0, EEPROM::zProbeXYSpeed(), true, ALWAYS_CHECK_ENDSTOPS);
|
||||
}
|
||||
|
||||
void Printer::finishProbing() {
|
||||
float oldOffX = Printer::offsetX;
|
||||
float oldOffY = Printer::offsetY;
|
||||
float oldOffZ = Printer::offsetZ;
|
||||
GCode::executeFString(Com::tZProbeEndScript);
|
||||
if(Extruder::current)
|
||||
{
|
||||
Printer::offsetX = -Extruder::current->xOffset * Printer::invAxisStepsPerMM[X_AXIS];
|
||||
Printer::offsetY = -Extruder::current->yOffset * Printer::invAxisStepsPerMM[Y_AXIS];
|
||||
Printer::offsetZ = -Extruder::current->zOffset * Printer::invAxisStepsPerMM[Z_AXIS];
|
||||
}
|
||||
PrintLine::moveRelativeDistanceInSteps((Printer::offsetX - oldOffX) * Printer::axisStepsPerMM[X_AXIS],
|
||||
(Printer::offsetY - oldOffY) * Printer::axisStepsPerMM[Y_AXIS],
|
||||
(Printer::offsetZ - oldOffZ) * Printer::axisStepsPerMM[Z_AXIS], 0, EEPROM::zProbeXYSpeed(), true, ALWAYS_CHECK_ENDSTOPS);
|
||||
}
|
||||
|
||||
/*
|
||||
This is the most important function for bed leveling. It does
|
||||
1. Run probe start script if first = true and runStartScript = true
|
||||
2. Position zProbe at current position if first = true. If we are more then maxStartHeight away from bed we also go down to that distance.
|
||||
3. Measure the the steps until probe hits the bed.
|
||||
4. Undo positioning to z probe and run finish script if last = true.
|
||||
|
||||
Now we compute the nozzle height as follows:
|
||||
a) Compute average height from repeated measurements
|
||||
b) Add zProbeHeight to correct difference between triggering point and nozzle height above bed
|
||||
c) If Z_PROBE_Z_OFFSET_MODE == 1 we add zProbeZOffset() that is coating thickness if we measure below coating with indictive sensor.
|
||||
d) Add distortion correction.
|
||||
e) Add bending correction
|
||||
|
||||
Then we return the measured and corrected z distance.
|
||||
*/
|
||||
float Printer::runZProbe(bool first,bool last,uint8_t repeat,bool runStartScript)
|
||||
{
|
||||
float oldOffX = Printer::offsetX;
|
||||
float oldOffY = Printer::offsetY;
|
||||
float oldOffZ = Printer::offsetZ;
|
||||
if(first)
|
||||
startProbing(runStartScript);
|
||||
Commands::waitUntilEndOfAllMoves();
|
||||
int32_t sum = 0, probeDepth;
|
||||
int32_t shortMove = static_cast<int32_t>((float)Z_PROBE_SWITCHING_DISTANCE * axisStepsPerMM[Z_AXIS]); // distance to go up for repeated moves
|
||||
int32_t lastCorrection = currentPositionSteps[Z_AXIS]; // starting position
|
||||
#if NONLINEAR_SYSTEM
|
||||
realDeltaPositionSteps[Z_AXIS] = currentDeltaPositionSteps[Z_AXIS]; // update real
|
||||
#endif
|
||||
//int32_t updateZ = 0;
|
||||
waitForZProbeStart();
|
||||
for(int8_t r = 0; r < repeat; r++)
|
||||
{
|
||||
probeDepth = 2 * (Printer::zMaxSteps - Printer::zMinSteps); // probe should always hit within this distance
|
||||
stepsRemainingAtZHit = -1; // Marker that we did not hit z probe
|
||||
//int32_t offx = axisStepsPerMM[X_AXIS] * EEPROM::zProbeXOffset();
|
||||
//int32_t offy = axisStepsPerMM[Y_AXIS] * EEPROM::zProbeYOffset();
|
||||
//PrintLine::moveRelativeDistanceInSteps(-offx,-offy,0,0,EEPROM::zProbeXYSpeed(),true,true);
|
||||
setZProbingActive(true);
|
||||
PrintLine::moveRelativeDistanceInSteps(0, 0, -probeDepth, 0, EEPROM::zProbeSpeed(), true, true);
|
||||
if(stepsRemainingAtZHit < 0)
|
||||
{
|
||||
Com::printErrorFLN(Com::tZProbeFailed);
|
||||
return -1;
|
||||
}
|
||||
setZProbingActive(false);
|
||||
#if NONLINEAR_SYSTEM
|
||||
stepsRemainingAtZHit = realDeltaPositionSteps[C_TOWER] - currentDeltaPositionSteps[C_TOWER]; // nonlinear moves may split z so stepsRemainingAtZHit is only what is left from last segment not total move. This corrects the problem.
|
||||
#endif
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
currentDeltaPositionSteps[A_TOWER] += stepsRemainingAtZHit; // Update difference
|
||||
currentDeltaPositionSteps[B_TOWER] += stepsRemainingAtZHit;
|
||||
currentDeltaPositionSteps[C_TOWER] += stepsRemainingAtZHit;
|
||||
#endif
|
||||
currentPositionSteps[Z_AXIS] += stepsRemainingAtZHit; // now current position is correct
|
||||
sum += lastCorrection - currentPositionSteps[Z_AXIS];
|
||||
if(r + 1 < repeat) // go only shortest possible move up for repetitions
|
||||
PrintLine::moveRelativeDistanceInSteps(0, 0, shortMove, 0, EEPROM::zProbeSpeed(), true, false);
|
||||
}
|
||||
float distance = static_cast<float>(sum) * invAxisStepsPerMM[Z_AXIS] / static_cast<float>(repeat) + EEPROM::zProbeHeight();
|
||||
#if Z_PROBE_Z_OFFSET_MODE == 1
|
||||
distance += EEPROM::zProbeZOffset(); // We measured including coating, so we need to add coating thickness!
|
||||
#endif
|
||||
#if DISTORTION_CORRECTION
|
||||
float zCorr = 0;
|
||||
if(Printer::distortion.isEnabled()) {
|
||||
zCorr = distortion.correct(currentPositionSteps[X_AXIS] + EEPROM::zProbeXOffset() * axisStepsPerMM[X_AXIS],currentPositionSteps[Y_AXIS]
|
||||
+ EEPROM::zProbeYOffset() * axisStepsPerMM[Y_AXIS],0) * invAxisStepsPerMM[Z_AXIS];
|
||||
distance += zCorr;
|
||||
}
|
||||
#endif
|
||||
distance += bendingCorrectionAt(currentPosition[X_AXIS], currentPosition[Y_AXIS]);
|
||||
Com::printF(Com::tZProbe, distance);
|
||||
Com::printF(Com::tSpaceXColon, realXPosition());
|
||||
#if DISTORTION_CORRECTION
|
||||
if(Printer::distortion.isEnabled()) {
|
||||
Com::printF(Com::tSpaceYColon, realYPosition());
|
||||
Com::printFLN(PSTR(" zCorr:"), zCorr);
|
||||
} else {
|
||||
Com::printFLN(Com::tSpaceYColon, realYPosition());
|
||||
}
|
||||
#else
|
||||
Com::printFLN(Com::tSpaceYColon, realYPosition());
|
||||
#endif
|
||||
// Go back to start position
|
||||
PrintLine::moveRelativeDistanceInSteps(0, 0, lastCorrection - currentPositionSteps[Z_AXIS], 0, EEPROM::zProbeSpeed(), true, false);
|
||||
//PrintLine::moveRelativeDistanceInSteps(offx,offy,0,0,EEPROM::zProbeXYSpeed(),true,true);
|
||||
if(last)
|
||||
finishProbing();
|
||||
return distance;
|
||||
}
|
||||
|
||||
float Printer::bendingCorrectionAt(float x, float y) {
|
||||
RVector3 p0(EEPROM::zProbeX1(),EEPROM::zProbeY1(),EEPROM::bendingCorrectionA());
|
||||
RVector3 p1(EEPROM::zProbeX2(),EEPROM::zProbeY2(),EEPROM::bendingCorrectionB());
|
||||
RVector3 p2(EEPROM::zProbeX3(),EEPROM::zProbeY3(),EEPROM::bendingCorrectionC());
|
||||
RVector3 a = p1-p0,b = p2 - p0;
|
||||
RVector3 n = a.cross(b);
|
||||
RVector3 l0(x,y,0);
|
||||
return ((p0 - l0).scalar(n)) / n.z;
|
||||
}
|
||||
|
||||
void Printer::waitForZProbeStart()
|
||||
{
|
||||
#if Z_PROBE_WAIT_BEFORE_TEST
|
||||
Endstops::update();
|
||||
Endstops::update(); // double test to get right signal. Needed for crosstalk protection.
|
||||
if(Endstops::zProbe()) return;
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
uid.setStatusP(Com::tHitZProbe);
|
||||
uid.refreshPage();
|
||||
#endif
|
||||
#ifdef DEBUG_PRINT
|
||||
debugWaitLoop = 3;
|
||||
#endif
|
||||
while(!Endstops::zProbe())
|
||||
{
|
||||
defaultLoopActions();
|
||||
Endstops::update();
|
||||
Endstops::update(); // double test to get right signal. Needed for crosstalk protection.
|
||||
}
|
||||
#ifdef DEBUG_PRINT
|
||||
debugWaitLoop = 4;
|
||||
#endif
|
||||
HAL::delayMilliseconds(30);
|
||||
while(Endstops::zProbe())
|
||||
{
|
||||
defaultLoopActions();
|
||||
Endstops::update();
|
||||
Endstops::update(); // double test to get right signal. Needed for crosstalk protection.
|
||||
}
|
||||
HAL::delayMilliseconds(30);
|
||||
UI_CLEAR_STATUS;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if FEATURE_AUTOLEVEL
|
||||
void Printer::transformToPrinter(float x,float y,float z,float &transX,float &transY,float &transZ)
|
||||
{
|
||||
#if FEATURE_AXISCOMP
|
||||
// Axis compensation:
|
||||
x = x + y * EEPROM::axisCompTanXY() + z * EEPROM::axisCompTanXZ();
|
||||
y = y + z * EEPROM::axisCompTanYZ();
|
||||
#endif
|
||||
transX = x * autolevelTransformation[0] + y * autolevelTransformation[3] + z * autolevelTransformation[6];
|
||||
transY = x * autolevelTransformation[1] + y * autolevelTransformation[4] + z * autolevelTransformation[7];
|
||||
transZ = x * autolevelTransformation[2] + y * autolevelTransformation[5] + z * autolevelTransformation[8];
|
||||
}
|
||||
|
||||
void Printer::transformFromPrinter(float x,float y,float z,float &transX,float &transY,float &transZ)
|
||||
{
|
||||
transX = x * autolevelTransformation[0] + y * autolevelTransformation[1] + z * autolevelTransformation[2];
|
||||
transY = x * autolevelTransformation[3] + y * autolevelTransformation[4] + z * autolevelTransformation[5];
|
||||
transZ = x * autolevelTransformation[6] + y * autolevelTransformation[7] + z * autolevelTransformation[8];
|
||||
#if FEATURE_AXISCOMP
|
||||
// Axis compensation:
|
||||
transY = transY - transZ * EEPROM::axisCompTanYZ();
|
||||
transX = transX - transY * EEPROM::axisCompTanXY() - transZ * EEPROM::axisCompTanXZ();
|
||||
#endif
|
||||
}
|
||||
|
||||
void Printer::resetTransformationMatrix(bool silent)
|
||||
{
|
||||
autolevelTransformation[0] = autolevelTransformation[4] = autolevelTransformation[8] = 1;
|
||||
autolevelTransformation[1] = autolevelTransformation[2] = autolevelTransformation[3] =
|
||||
autolevelTransformation[5] = autolevelTransformation[6] = autolevelTransformation[7] = 0;
|
||||
if(!silent)
|
||||
Com::printInfoFLN(Com::tAutolevelReset);
|
||||
}
|
||||
|
||||
void Printer::buildTransformationMatrix(float h1,float h2,float h3)
|
||||
{
|
||||
float ax = EEPROM::zProbeX2()-EEPROM::zProbeX1();
|
||||
float ay = EEPROM::zProbeY2()-EEPROM::zProbeY1();
|
||||
float az = h1-h2;
|
||||
float bx = EEPROM::zProbeX3()-EEPROM::zProbeX1();
|
||||
float by = EEPROM::zProbeY3()-EEPROM::zProbeY1();
|
||||
float bz = h1-h3;
|
||||
// First z direction
|
||||
autolevelTransformation[6] = ay * bz - az * by;
|
||||
autolevelTransformation[7] = az * bx - ax * bz;
|
||||
autolevelTransformation[8] = ax * by - ay * bx;
|
||||
float len = sqrt(autolevelTransformation[6] * autolevelTransformation[6] + autolevelTransformation[7] * autolevelTransformation[7] + autolevelTransformation[8] * autolevelTransformation[8]);
|
||||
if(autolevelTransformation[8] < 0) len = -len;
|
||||
autolevelTransformation[6] /= len;
|
||||
autolevelTransformation[7] /= len;
|
||||
autolevelTransformation[8] /= len;
|
||||
autolevelTransformation[3] = 0;
|
||||
autolevelTransformation[4] = autolevelTransformation[8];
|
||||
autolevelTransformation[5] = -autolevelTransformation[7];
|
||||
// cross(y,z)
|
||||
autolevelTransformation[0] = autolevelTransformation[4] * autolevelTransformation[8] - autolevelTransformation[5] * autolevelTransformation[7];
|
||||
autolevelTransformation[1] = autolevelTransformation[5] * autolevelTransformation[6];// - autolevelTransformation[3] * autolevelTransformation[8];
|
||||
autolevelTransformation[2] = /*autolevelTransformation[3] * autolevelTransformation[7]*/ - autolevelTransformation[4] * autolevelTransformation[6];
|
||||
len = sqrt(autolevelTransformation[0] * autolevelTransformation[0] + autolevelTransformation[1] * autolevelTransformation[1] + autolevelTransformation[2] * autolevelTransformation[2]);
|
||||
autolevelTransformation[0] /= len;
|
||||
autolevelTransformation[1] /= len;
|
||||
autolevelTransformation[2] /= len;
|
||||
len = sqrt(autolevelTransformation[4] * autolevelTransformation[4] + autolevelTransformation[5] * autolevelTransformation[5]);
|
||||
autolevelTransformation[4] /= len;
|
||||
autolevelTransformation[5] /= len;
|
||||
Com::printArrayFLN(Com::tTransformationMatrix,autolevelTransformation, 9, 6);
|
||||
}
|
||||
#endif
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
#include "Repetier.h"
|
||||
|
||||
const uint8_t sensitive_pins[] PROGMEM = SENSITIVE_PINS; // Sensitive pin list for M42
|
||||
const int8_t sensitive_pins[] PROGMEM = SENSITIVE_PINS; // Sensitive pin list for M42
|
||||
int Commands::lowestRAMValue = MAX_RAM;
|
||||
int Commands::lowestRAMValueSend = MAX_RAM;
|
||||
|
||||
|
@ -161,6 +161,7 @@ void Commands::printCurrentPosition(FSTRINGPARAM(s))
|
|||
|
||||
void Commands::printTemperatures(bool showRaw)
|
||||
{
|
||||
#if NUM_EXTRUDER > 0
|
||||
float temp = Extruder::current->tempControl.currentTemperatureC;
|
||||
#if HEATED_BED_SENSOR_TYPE == 0
|
||||
Com::printF(Com::tTColon,temp);
|
||||
|
@ -198,8 +199,15 @@ void Commands::printTemperatures(bool showRaw)
|
|||
Com::printF(Com::tColon,(1023 << (2 - ANALOG_REDUCE_BITS)) - extruder[i].tempControl.currentTemperature);
|
||||
}
|
||||
}
|
||||
#elif NUM_EXTRUDER == 1
|
||||
if(showRaw)
|
||||
{
|
||||
Com::printF(Com::tSpaceRaw,(int)0);
|
||||
Com::printF(Com::tColon,(1023 << (2 - ANALOG_REDUCE_BITS)) - extruder[0].tempControl.currentTemperature);
|
||||
}
|
||||
#endif
|
||||
Com::println();
|
||||
#endif
|
||||
}
|
||||
void Commands::changeFeedrateMultiply(int factor)
|
||||
{
|
||||
|
@ -222,27 +230,39 @@ void Commands::changeFlowrateMultiply(int factor)
|
|||
Com::printFLN(Com::tFlowMultiply, factor);
|
||||
}
|
||||
|
||||
#if FEATURE_FAN_CONTROL
|
||||
uint8_t fanKickstart;
|
||||
void Commands::setFanSpeed(int speed,bool wait)
|
||||
#endif
|
||||
#if FEATURE_FAN2_CONTROL
|
||||
uint8_t fan2Kickstart;
|
||||
#endif
|
||||
|
||||
void Commands::setFanSpeed(int speed, bool immediately)
|
||||
{
|
||||
#if FAN_PIN>-1 && FEATURE_FAN_CONTROL
|
||||
#if FAN_PIN >- 1 && FEATURE_FAN_CONTROL
|
||||
if(Printer::fanSpeed == speed)
|
||||
return;
|
||||
speed = constrain(speed,0,255);
|
||||
Printer::setMenuMode(MENU_MODE_FAN_RUNNING,speed != 0);
|
||||
if(wait)
|
||||
Commands::waitUntilEndOfAllMoves(); // use only if neededthis to change the speed exactly at that point, but it may cause blobs if you do!
|
||||
if(speed != pwm_pos[NUM_EXTRUDER + 2])
|
||||
{
|
||||
Com::printFLN(Com::tFanspeed,speed); // send only new values to break update loops!
|
||||
#if FAN_KICKSTART_TIME
|
||||
if(fanKickstart == 0 && speed > pwm_pos[NUM_EXTRUDER + 2] && speed < 85)
|
||||
Printer::fanSpeed = speed;
|
||||
if(PrintLine::linesCount == 0 || immediately) {
|
||||
if(Printer::mode == PRINTER_MODE_FFF)
|
||||
{
|
||||
if(pwm_pos[NUM_EXTRUDER + 2]) fanKickstart = FAN_KICKSTART_TIME/100;
|
||||
else fanKickstart = FAN_KICKSTART_TIME/25;
|
||||
for(fast8_t i = 0; i < PRINTLINE_CACHE_SIZE; i++)
|
||||
PrintLine::lines[i].secondSpeed = speed; // fill all printline buffers with new fan speed value
|
||||
}
|
||||
Printer::setFanSpeedDirectly(speed);
|
||||
}
|
||||
Com::printFLN(Com::tFanspeed,speed); // send only new values to break update loops!
|
||||
#endif
|
||||
}
|
||||
pwm_pos[NUM_EXTRUDER + 2] = speed;
|
||||
#endif
|
||||
}
|
||||
void Commands::setFan2Speed(int speed)
|
||||
{
|
||||
#if FAN2_PIN >- 1 && FEATURE_FAN2_CONTROL
|
||||
speed = constrain(speed,0,255);
|
||||
Printer::setFan2SpeedDirectly(speed);
|
||||
Com::printFLN(Com::tFan2speed,speed); // send only new values to break update loops!
|
||||
#endif
|
||||
}
|
||||
|
||||
void Commands::reportPrinterUsage()
|
||||
|
@ -252,9 +272,10 @@ void Commands::reportPrinterUsage()
|
|||
Com::printF(Com::tPrintedFilament, dist, 2);
|
||||
Com::printF(Com::tSpacem);
|
||||
bool alloff = true;
|
||||
#if NUM_EXTRUDER > 0
|
||||
for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
|
||||
if(tempController[i]->targetTemperatureC > 15) alloff = false;
|
||||
|
||||
#endif
|
||||
int32_t seconds = (alloff ? 0 : (HAL::timeInMilliseconds() - Printer::msecondsPrinting) / 1000) + HAL::eprGetInt32(EPR_PRINTING_TIME);
|
||||
int32_t tmp = seconds / 86400;
|
||||
seconds -= tmp * 86400;
|
||||
|
@ -860,7 +881,7 @@ void Commands::processArc(GCode *com)
|
|||
return;
|
||||
}
|
||||
// Invert the sign of h_x2_div_d if the circle is counter clockwise (see sketch below)
|
||||
if (com->G==3)
|
||||
if (com->G == 3)
|
||||
{
|
||||
h_x2_div_d = -h_x2_div_d;
|
||||
}
|
||||
|
@ -892,8 +913,8 @@ void Commands::processArc(GCode *com)
|
|||
r = -r; // Finished with r. Set to positive for mc_arc
|
||||
}
|
||||
// Complete the operation by calculating the actual center of the arc
|
||||
offset[0] = 0.5*(x-(y*h_x2_div_d));
|
||||
offset[1] = 0.5*(y+(x*h_x2_div_d));
|
||||
offset[0] = 0.5 * (x - (y * h_x2_div_d));
|
||||
offset[1] = 0.5 * (y + (x * h_x2_div_d));
|
||||
|
||||
}
|
||||
else // Offset mode specific computations
|
||||
|
@ -906,7 +927,7 @@ void Commands::processArc(GCode *com)
|
|||
PrintLine::arc(position, target, offset, r, isclockwise);
|
||||
}
|
||||
#endif
|
||||
|
||||
extern void runBedLeveling(GCode *com);
|
||||
/**
|
||||
\brief Execute the G command stored in com.
|
||||
*/
|
||||
|
@ -917,6 +938,13 @@ void Commands::processGCode(GCode *com)
|
|||
{
|
||||
case 0: // G0 -> G1
|
||||
case 1: // G1
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
{ // disable laser for G0 moves
|
||||
bool laserOn = LaserDriver::laserOn;
|
||||
if(com->G == 0 && Printer::mode == PRINTER_MODE_LASER) {
|
||||
LaserDriver::laserOn = false;
|
||||
}
|
||||
#endif // defined
|
||||
if(com->hasS()) Printer::setNoDestinationCheck(com->S != 0);
|
||||
if(Printer::setDestinationStepsFromGCode(com)) // For X Y Z E F
|
||||
#if NONLINEAR_SYSTEM
|
||||
|
@ -941,18 +969,33 @@ void Commands::processGCode(GCode *com)
|
|||
int lc = (int)PrintLine::linesCount;
|
||||
int lp = (int)PrintLine::linesPos;
|
||||
int wp = (int)PrintLine::linesWritePos;
|
||||
int n = (wp-lp);
|
||||
int n = (wp - lp);
|
||||
if(n < 0) n += PRINTLINE_CACHE_SIZE;
|
||||
noInts.unprotect();
|
||||
if(n != lc)
|
||||
Com::printFLN(PSTR("Buffer corrupted"));
|
||||
}
|
||||
#endif
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
LaserDriver::laserOn = laserOn;
|
||||
}
|
||||
#endif // defined
|
||||
break;
|
||||
#if ARC_SUPPORT
|
||||
case 2: // CW Arc
|
||||
case 3: // CCW Arc MOTION_MODE_CW_ARC: case MOTION_MODE_CCW_ARC:
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
{ // disable laser for G0 moves
|
||||
bool laserOn = LaserDriver::laserOn;
|
||||
if(com->G == 0 && Printer::mode == PRINTER_MODE_LASER) {
|
||||
LaserDriver::laserOn = false;
|
||||
}
|
||||
#endif // defined
|
||||
processArc(com);
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
LaserDriver::laserOn = laserOn;
|
||||
}
|
||||
#endif // defined
|
||||
break;
|
||||
#endif
|
||||
case 4: // G4 dwell
|
||||
|
@ -1034,7 +1077,7 @@ void Commands::processGCode(GCode *com)
|
|||
Printer::homeAxis(true,true,true);
|
||||
#else
|
||||
Printer::currentPositionSteps[Z_AXIS] = sum * Printer::axisStepsPerMM[Z_AXIS];
|
||||
Printer::zLength = Printer::runZMaxProbe() + sum-ENDSTOP_Z_BACK_ON_HOME;
|
||||
Printer::zLength = Printer::runZMaxProbe() + sum - ENDSTOP_Z_BACK_ON_HOME;
|
||||
#endif
|
||||
Com::printInfoFLN(Com::tZProbeZReset);
|
||||
Com::printFLN(Com::tZProbePrinterHeight,Printer::zLength);
|
||||
|
@ -1074,7 +1117,10 @@ void Commands::processGCode(GCode *com)
|
|||
break;
|
||||
#if FEATURE_AUTOLEVEL
|
||||
case 32: // G32 Auto-Bed leveling
|
||||
runBedLeveling(com);
|
||||
#if 0
|
||||
{
|
||||
|
||||
#if DISTORTION_CORRECTION
|
||||
Printer::distortion.disable(true); // if level has changed, distortion is also invalid
|
||||
#endif
|
||||
|
@ -1082,7 +1128,7 @@ void Commands::processGCode(GCode *com)
|
|||
#if DRIVE_SYSTEM == DELTA
|
||||
// It is not possible to go to the edges at the top, also users try
|
||||
// it often and wonder why the coordinate system is then wrong.
|
||||
// For that reason we ensure a correct behaviour by code.
|
||||
// For that reason we ensure a correct behavior by code.
|
||||
Printer::homeAxis(true, true, true);
|
||||
Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
|
||||
#endif
|
||||
|
@ -1099,18 +1145,6 @@ void Commands::processGCode(GCode *com)
|
|||
Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
|
||||
h3 = Printer::runZProbe(false,true);
|
||||
if(h3 < -1) break;
|
||||
// Zprobe with force feedback may bed bed differently for different points.
|
||||
// these settings allow correction of the bending distance so leveling is correct afterwards.
|
||||
// Values are normally negative with bending amount on trigger.
|
||||
#ifdef ZPROBE_1_BENDING_CORRECTION
|
||||
h1 += ZPROBE_1_BENDING_CORRECTION;
|
||||
#endif
|
||||
#ifdef ZPROBE_2_BENDING_CORRECTION
|
||||
h2 += ZPROBE_2_BENDING_CORRECTION;
|
||||
#endif
|
||||
#ifdef ZPROBE_3_BENDING_CORRECTION
|
||||
h3 += ZPROBE_3_BENDING_CORRECTION;
|
||||
#endif
|
||||
#if defined(MOTORIZED_BED_LEVELING) && defined(NUM_MOTOR_DRIVERS) && NUM_MOTOR_DRIVERS >= 2
|
||||
// h1 is reference heights, h2 => motor 0, h3 => motor 1
|
||||
h2 -= h1;
|
||||
|
@ -1179,8 +1213,29 @@ void Commands::processGCode(GCode *com)
|
|||
#endif
|
||||
Printer::feedrate = oldFeedrate;
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
#endif
|
||||
#endif
|
||||
#if DISTORTION_CORRECTION
|
||||
case 33: {
|
||||
if(com->hasL()) { // G33 L0 - List distortion matrix
|
||||
Printer::distortion.showMatrix();
|
||||
} else if(com->hasR()) { // G33 R0 - Reset distortion matrix
|
||||
Printer::distortion.resetCorrection();
|
||||
} else if(com->hasX() || com->hasY() || com->hasZ()) { // G33 X<xpos> Y<ypos> Z<zCorrection> - Set correction for nearest point
|
||||
if(com->hasX() && com->hasY() && com->hasZ()) {
|
||||
Printer::distortion.set(com->X, com->Y, com->Z);
|
||||
} else {
|
||||
Com::printErrorFLN(PSTR("You need to define X, Y and Z to set a point!"));
|
||||
}
|
||||
} else { // G33
|
||||
float oldFeedrate = Printer::feedrate;
|
||||
Printer::measureDistortion();
|
||||
Printer::feedrate = oldFeedrate;
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 90: // G90
|
||||
Printer::relativeCoordinateMode = false;
|
||||
|
@ -1345,6 +1400,7 @@ void Commands::processGCode(GCode *com)
|
|||
EEPROM::setDeltaTowerZOffsetSteps(offz);
|
||||
}
|
||||
#endif
|
||||
PrintLine::moveRelativeDistanceInSteps(0, 0, -5*Printer::axisStepsPerMM[Z_AXIS], 0, Printer::homingFeedrate[Z_AXIS], true, true);
|
||||
Printer::homeAxis(true,true,true);
|
||||
}
|
||||
break;
|
||||
|
@ -1364,17 +1420,18 @@ void Commands::processGCode(GCode *com)
|
|||
// similar to comment above, this will get a different answer from any different starting point
|
||||
// so it is unclear how this is helpful. It must start at a well defined point.
|
||||
Printer::deltaMoveToTopEndstops(Printer::homingFeedrate[Z_AXIS]);
|
||||
int32_t offx = HOME_DISTANCE_STEPS-Printer::stepsRemainingAtXHit;
|
||||
int32_t offy = HOME_DISTANCE_STEPS-Printer::stepsRemainingAtYHit;
|
||||
int32_t offz = HOME_DISTANCE_STEPS-Printer::stepsRemainingAtZHit;
|
||||
int32_t offx = HOME_DISTANCE_STEPS - Printer::stepsRemainingAtXHit;
|
||||
int32_t offy = HOME_DISTANCE_STEPS - Printer::stepsRemainingAtYHit;
|
||||
int32_t offz = HOME_DISTANCE_STEPS - Printer::stepsRemainingAtZHit;
|
||||
Com::printFLN(Com::tTower1,offx);
|
||||
Com::printFLN(Com::tTower2,offy);
|
||||
Com::printFLN(Com::tTower3,offz);
|
||||
Printer::setAutolevelActive(oldAuto);
|
||||
PrintLine::moveRelativeDistanceInSteps(0, 0, Printer::axisStepsPerMM[Z_AXIS] * -ENDSTOP_Z_BACK_MOVE, 0, Printer::homingFeedrate[Z_AXIS] / ENDSTOP_X_RETEST_REDUCTION_FACTOR, true, false);
|
||||
Printer::homeAxis(true,true,true);
|
||||
}
|
||||
break;
|
||||
case 134: // G134
|
||||
case 135: // G135
|
||||
Com::printF(PSTR("CompDelta:"),Printer::currentDeltaPositionSteps[A_TOWER]);
|
||||
Com::printF(Com::tComma,Printer::currentDeltaPositionSteps[B_TOWER]);
|
||||
Com::printFLN(Com::tComma,Printer::currentDeltaPositionSteps[C_TOWER]);
|
||||
|
@ -1389,6 +1446,31 @@ void Commands::processGCode(GCode *com)
|
|||
break;
|
||||
|
||||
#endif // DRIVE_SYSTEM
|
||||
#if FEATURE_Z_PROBE
|
||||
case 134: // - G134 Px Sx Zx - Calibrate nozzle height difference (need z probe in nozzle!) Px = reference extruder, Sx = only measure extrude x against reference, Zx = add to measured z distance for Sx for correction.
|
||||
{
|
||||
float z = com->hasZ() ? com->Z : 0;
|
||||
int p = com->hasP() ? com->P : 0;
|
||||
int s = com->hasS() ? com->S : -1;
|
||||
extruder[p].zOffset = 0;
|
||||
Extruder::selectExtruderById(p);
|
||||
float refHeight = Printer::runZProbe(true,false,true);
|
||||
for(int i = 0;i < NUM_EXTRUDER;i++) {
|
||||
if(i == p) continue;
|
||||
if(s >= 0 && i != s) continue;
|
||||
extruder[i].zOffset = 0;
|
||||
Extruder::selectExtruderById(i);
|
||||
float height = Printer::runZProbe(false,false);
|
||||
extruder[i].zOffset = (height - refHeight + z)*Printer::axisStepsPerMM[Z_AXIS];
|
||||
}
|
||||
Extruder::selectExtruderById(p);
|
||||
Printer::runZProbe(false,true);
|
||||
#if EEPROM_MODE != 0
|
||||
EEPROM::storeDataIntoEEPROM(0);
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
#if defined(NUM_MOTOR_DRIVERS) && NUM_MOTOR_DRIVERS > 0
|
||||
case 201:
|
||||
commandG201(*com);
|
||||
|
@ -1417,13 +1499,56 @@ void Commands::processGCode(GCode *com)
|
|||
*/
|
||||
void Commands::processMCode(GCode *com)
|
||||
{
|
||||
uint32_t codenum; //throw away variable
|
||||
switch( com->M )
|
||||
{
|
||||
|
||||
case 3: // Spindle/laser on
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
if(Printer::mode == PRINTER_MODE_LASER) {
|
||||
if(com->hasS())
|
||||
LaserDriver::intensity = constrain(com->S,0,255);
|
||||
LaserDriver::laserOn = true;
|
||||
Com::printFLN(PSTR("LaserOn:"),(int)LaserDriver::intensity);
|
||||
}
|
||||
#endif // defined
|
||||
#if defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
if(Printer::mode == PRINTER_MODE_CNC) {
|
||||
waitUntilEndOfAllMoves();
|
||||
CNCDriver::spindleOnCW(com->hasS() ? com->S : 0);
|
||||
}
|
||||
#endif // defined
|
||||
break;
|
||||
case 4: // Spindle CCW
|
||||
#if defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
if(Printer::mode == PRINTER_MODE_CNC) {
|
||||
waitUntilEndOfAllMoves();
|
||||
CNCDriver::spindleOnCCW(com->hasS() ? com->S : 0);
|
||||
}
|
||||
#endif // defined
|
||||
break;
|
||||
case 5: // Spindle/laser off
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
if(Printer::mode == PRINTER_MODE_LASER) {
|
||||
LaserDriver::laserOn = false;
|
||||
}
|
||||
#endif // defined
|
||||
#if defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
if(Printer::mode == PRINTER_MODE_CNC) {
|
||||
waitUntilEndOfAllMoves();
|
||||
CNCDriver::spindleOff();
|
||||
}
|
||||
#endif // defined
|
||||
break;
|
||||
#if SDSUPPORT
|
||||
case 20: // M20 - list SD card
|
||||
#if JSON_OUTPUT
|
||||
if (com->hasString() && com->text[1] == '2') { // " S2 P/folder"
|
||||
if (com->text[3] == 'P') {
|
||||
sd.lsJSON(com->text + 4);
|
||||
}
|
||||
} else sd.ls();
|
||||
#else
|
||||
sd.ls();
|
||||
#endif
|
||||
break;
|
||||
case 21: // M21 - init SD card
|
||||
sd.mount();
|
||||
|
@ -1473,6 +1598,13 @@ void Commands::processMCode(GCode *com)
|
|||
sd.makeDirectory(com->text);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
#if JSON_OUTPUT && SDSUPPORT
|
||||
case 36: // M36 JSON File Info
|
||||
if (com->hasString()) {
|
||||
sd.JSONFileInfo(com->text);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 42: //M42 -Change pin status via gcode
|
||||
if (com->hasP())
|
||||
|
@ -1687,9 +1819,10 @@ void Commands::processMCode(GCode *com)
|
|||
previousMillisCmd = HAL::timeInMilliseconds();
|
||||
break;
|
||||
case 190: // M190 - Wait bed for heater to reach target.
|
||||
{
|
||||
#if HAVE_HEATED_BED
|
||||
if(Printer::debugDryrun()) break;
|
||||
UI_STATUS_UPD(UI_TEXT_HEATING_BED);
|
||||
UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_HEATING_BED_ID));
|
||||
Commands::waitUntilEndOfAllMoves();
|
||||
#if HAVE_HEATED_BED
|
||||
if (com->hasS()) Extruder::setHeatedBedTemperature(com->S,com->hasF() && com->F > 0);
|
||||
|
@ -1697,6 +1830,7 @@ void Commands::processMCode(GCode *com)
|
|||
if(abs(heatedBedController.currentTemperatureC - heatedBedController.targetTemperatureC) < SKIP_M190_IF_WITHIN) break;
|
||||
#endif
|
||||
EVENT_WAITING_HEATER(-1);
|
||||
uint32_t codenum; //throw away variable
|
||||
codenum = HAL::timeInMilliseconds();
|
||||
while(heatedBedController.currentTemperatureC + 0.5 < heatedBedController.targetTemperatureC && heatedBedController.targetTemperatureC > 25.0)
|
||||
{
|
||||
|
@ -1712,7 +1846,9 @@ void Commands::processMCode(GCode *com)
|
|||
#endif
|
||||
UI_CLEAR_STATUS;
|
||||
previousMillisCmd = HAL::timeInMilliseconds();
|
||||
}
|
||||
break;
|
||||
#if NUM_TEMPERATURE_LOOPS > 0
|
||||
case 116: // Wait for temperatures to reach target temperature
|
||||
for(fast8_t h = 0; h < NUM_TEMPERATURE_LOOPS; h++)
|
||||
{
|
||||
|
@ -1721,42 +1857,48 @@ void Commands::processMCode(GCode *com)
|
|||
EVENT_HEATING_FINISHED(h < NUM_EXTRUDER ? h : -1);
|
||||
}
|
||||
break;
|
||||
|
||||
#endif
|
||||
#if FAN_PIN>-1 && FEATURE_FAN_CONTROL
|
||||
case 106: // M106 Fan On
|
||||
if(!(Printer::flag2 & PRINTER_FLAG2_IGNORE_M106_COMMAND))
|
||||
{
|
||||
setFanSpeed(com->hasS() ? com->S : 255, com->hasP());
|
||||
if(com->hasP() && com->P == 1)
|
||||
setFan2Speed(com->hasS() ? com->S : 255);
|
||||
else
|
||||
setFanSpeed(com->hasS() ? com->S : 255);
|
||||
}
|
||||
break;
|
||||
case 107: // M107 Fan Off
|
||||
setFanSpeed(0, com->hasP());
|
||||
if(com->hasP() && com->P == 1)
|
||||
setFan2Speed(0);
|
||||
else
|
||||
setFanSpeed(0);
|
||||
break;
|
||||
#endif
|
||||
case 111: // M111 enable/disable run time debug flags
|
||||
if(com->hasS()) Printer::debugLevel = com->S;
|
||||
if(com->hasS()) Printer::setDebugLevel(static_cast<uint8_t>(com->S));
|
||||
if(com->hasP())
|
||||
{
|
||||
if (com->P > 0) Printer::debugLevel |= com->P;
|
||||
else Printer::debugLevel &= ~(-com->P);
|
||||
if (com->P > 0) Printer::debugSet(static_cast<uint8_t>(com->P));
|
||||
else Printer::debugReset(static_cast<uint8_t>(-com->P));
|
||||
}
|
||||
if(Printer::debugDryrun()) // simulate movements without printing
|
||||
{
|
||||
Extruder::setTemperatureForExtruder(0, 0);
|
||||
#if NUM_EXTRUDER>1
|
||||
#if NUM_EXTRUDER > 1
|
||||
for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
|
||||
Extruder::setTemperatureForExtruder(0, i);
|
||||
#else
|
||||
Extruder::setTemperatureForExtruder(0, 0);
|
||||
#endif
|
||||
#if HEATED_BED_TYPE!=0
|
||||
target_bed_raw = 0;
|
||||
#if HAVE_HEATED_BED != 0
|
||||
Extruder::setHeatedBedTemperature(0,false);
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
case 115: // M115
|
||||
Com::printFLN(Com::tFirmware);
|
||||
reportPrinterUsage();
|
||||
Printer::reportPrinterMode();
|
||||
break;
|
||||
case 114: // M114
|
||||
printCurrentPosition(PSTR("M114 "));
|
||||
|
@ -1783,6 +1925,7 @@ void Commands::processMCode(GCode *com)
|
|||
case 163: // M163 S<extruderNum> P<weight> - Set weight for this mixing extruder drive
|
||||
if(com->hasS() && com->hasP() && com->S < NUM_EXTRUDER && com->S >= 0)
|
||||
Extruder::setMixingWeight(com->S, com->P);
|
||||
Extruder::recomputeMixingExtruderSteps();
|
||||
break;
|
||||
case 164: /// M164 S<virtNum> P<0 = dont store eeprom,1 = store to eeprom> - Store weights as virtual extruder S
|
||||
if(!com->hasS() || com->S < 0 || com->S >= VIRTUAL_EXTRUDER) break; // ignore illigal values
|
||||
|
@ -1847,8 +1990,8 @@ void Commands::processMCode(GCode *com)
|
|||
TemperatureController *temp = &Extruder::current->tempControl;
|
||||
if(com->hasS())
|
||||
{
|
||||
if(com->S<0) break;
|
||||
if(com->S<NUM_EXTRUDER) temp = &extruder[com->S].tempControl;
|
||||
if(com->S < 0) break;
|
||||
if(com->S < NUM_EXTRUDER) temp = &extruder[com->S].tempControl;
|
||||
#if HAVE_HEATED_BED
|
||||
else temp = &heatedBedController;
|
||||
#else
|
||||
|
@ -1894,6 +2037,22 @@ void Commands::processMCode(GCode *com)
|
|||
case 221: // M221 S<Extrusion flow multiplier in percent>
|
||||
changeFlowrateMultiply(com->getS(100));
|
||||
break;
|
||||
case 228: // M228 P<pin> S<state 0/1> - Wait for pin getting state S
|
||||
if(!com->hasS() || !com->hasP())
|
||||
break;
|
||||
{
|
||||
bool comp = com->S;
|
||||
if(com->hasX()) {
|
||||
if(com->X == 0)
|
||||
HAL::pinMode(com->S,INPUT);
|
||||
else
|
||||
HAL::pinMode(com->S,INPUT_PULLUP);
|
||||
}
|
||||
do {
|
||||
Commands::checkForPeriodicalActions(true);
|
||||
} while(HAL::digitalRead(com->P) != comp);
|
||||
}
|
||||
break;
|
||||
#if USE_ADVANCE
|
||||
case 223: // M223 Extruder interrupt test
|
||||
if(com->hasS())
|
||||
|
@ -1909,10 +2068,10 @@ void Commands::processMCode(GCode *com)
|
|||
#endif
|
||||
Com::printFLN(Com::tCommaSpeedEqual,maxadvspeed);
|
||||
#if ENABLE_QUADRATIC_ADVANCE
|
||||
maxadv=0;
|
||||
maxadv = 0;
|
||||
#endif
|
||||
maxadv2=0;
|
||||
maxadvspeed=0;
|
||||
maxadv2 = 0;
|
||||
maxadvspeed = 0;
|
||||
break;
|
||||
#endif
|
||||
#if USE_ADVANCE
|
||||
|
@ -2088,6 +2247,38 @@ void Commands::processMCode(GCode *com)
|
|||
case 402: // M402 Go to stored position
|
||||
Printer::GoToMemoryPosition(com->hasX(),com->hasY(),com->hasZ(),com->hasE(),(com->hasF() ? com->F : Printer::feedrate));
|
||||
break;
|
||||
#if JSON_OUTPUT
|
||||
case 408:
|
||||
Printer::showJSONStatus(com->hasS() ? static_cast<int>(com->S) : 0);
|
||||
break;
|
||||
#endif
|
||||
case 450:
|
||||
Printer::reportPrinterMode();
|
||||
break;
|
||||
case 451:
|
||||
Printer::mode = PRINTER_MODE_FFF;
|
||||
Printer::reportPrinterMode();
|
||||
break;
|
||||
case 452:
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
Printer::mode = PRINTER_MODE_LASER;
|
||||
#endif
|
||||
Printer::reportPrinterMode();
|
||||
break;
|
||||
case 453:
|
||||
#if defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
Printer::mode = PRINTER_MODE_CNC;
|
||||
#endif
|
||||
Printer::reportPrinterMode();
|
||||
break;
|
||||
#if FAN_THERMO_PIN > -1
|
||||
case 460: // M460 X<minTemp> Y<maxTemp> : Set temperature range for thermo controlled fan
|
||||
if(com->hasX())
|
||||
Printer::thermoMinTemp = com->X;
|
||||
if(com->hasY())
|
||||
Printer::thermoMaxTemp = com->Y;
|
||||
break;
|
||||
#endif
|
||||
case 500: // M500
|
||||
{
|
||||
#if EEPROM_MODE != 0
|
||||
|
@ -2251,6 +2442,31 @@ void Commands::processMCode(GCode *com)
|
|||
dacCommitEeprom();
|
||||
#endif
|
||||
break;
|
||||
#if 0 && UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
// some debuggingcommands normally disabled
|
||||
case 888:
|
||||
Com::printFLN(PSTR("Selected language:"),(int)Com::selectedLanguage);
|
||||
Com::printF(PSTR("Translation:"));
|
||||
Com::printFLN(Com::translatedF(0));
|
||||
break;
|
||||
case 889:
|
||||
uid.showLanguageSelectionWizard();
|
||||
break;
|
||||
case 890:
|
||||
{
|
||||
if(com->hasX() && com->hasY()) {
|
||||
float c = Printer::bendingCorrectionAt(com->X,com->Y);
|
||||
Com::printF(PSTR("Bending at ("),com->X);
|
||||
Com::printF(PSTR(","),com->Y);
|
||||
Com::printFLN(PSTR(") = "),c);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 891:
|
||||
if(com->hasS())
|
||||
EEPROM::setVersion(com->S);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
if(!EVENT_UNHANDLED_M_CODE(com) && Printer::debugErrors())
|
||||
{
|
||||
|
@ -2291,6 +2507,14 @@ void Commands::executeGCode(GCode *com)
|
|||
com->printCommand();
|
||||
}
|
||||
}
|
||||
#ifdef DEBUG_DRYRUN_ERROR
|
||||
if(Printer::debugDryrun()) {
|
||||
Com::printFLN("Dryrun was enabled");
|
||||
com->printCommand();
|
||||
Printer::debugReset(8);
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void Commands::emergencyStop()
|
||||
|
@ -2303,7 +2527,7 @@ void Commands::emergencyStop()
|
|||
Extruder::manageTemperatures();
|
||||
for(uint8_t i = 0; i < NUM_EXTRUDER + 3; i++)
|
||||
pwm_pos[i] = 0;
|
||||
#if EXT0_HEATER_PIN > -1
|
||||
#if EXT0_HEATER_PIN > -1 && NUM_EXTRUDER > 0
|
||||
WRITE(EXT0_HEATER_PIN,HEATER_PINS_INVERTED);
|
||||
#endif
|
||||
#if defined(EXT1_HEATER_PIN) && EXT1_HEATER_PIN > -1 && NUM_EXTRUDER > 1
|
||||
|
@ -2324,10 +2548,10 @@ void Commands::emergencyStop()
|
|||
#if FAN_PIN > -1 && FEATURE_FAN_CONTROL
|
||||
WRITE(FAN_PIN, 0);
|
||||
#endif
|
||||
#if HEATED_BED_HEATER_PIN > -1
|
||||
#if HAVE_HEATED_BED && HEATED_BED_HEATER_PIN > -1
|
||||
WRITE(HEATED_BED_HEATER_PIN, HEATER_PINS_INVERTED);
|
||||
#endif
|
||||
UI_STATUS_UPD(UI_TEXT_KILLED);
|
||||
UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_KILLED_ID));
|
||||
HAL::delayMilliseconds(200);
|
||||
InterruptProtectedBlock noInts;
|
||||
while(1) {}
|
||||
|
@ -2349,5 +2573,3 @@ void Commands::writeLowestFreeRAM()
|
|||
Com::printFLN(Com::tFreeRAM, lowestRAMValue);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -37,7 +37,8 @@ public:
|
|||
static void waitUntilEndOfAllBuffers();
|
||||
static void printCurrentPosition(FSTRINGPARAM(s));
|
||||
static void printTemperatures(bool showRaw = false);
|
||||
static void setFanSpeed(int speed,bool wait); /// Set fan speed 0..255
|
||||
static void setFanSpeed(int speed, bool immediately = false); /// Set fan speed 0..255
|
||||
static void setFan2Speed(int speed); /// Set fan speed 0..255
|
||||
static void changeFeedrateMultiply(int factorInPercent);
|
||||
static void changeFlowrateMultiply(int factorInPercent);
|
||||
static void reportPrinterUsage();
|
||||
|
@ -50,5 +51,3 @@ private:
|
|||
};
|
||||
|
||||
#endif // COMMANDS_H_INCLUDED
|
||||
|
||||
|
||||
|
|
|
@ -21,15 +21,23 @@
|
|||
|
||||
#include "Repetier.h"
|
||||
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
uint8_t Com::selectedLanguage;
|
||||
#endif
|
||||
|
||||
#ifndef MACHINE_TYPE
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Delta EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
|
||||
#define MACHINE_TYPE "Delta"
|
||||
#elif DRIVE_SYSTEM == CARTESIAN
|
||||
#define MACHINE_TYPE "Mendel"
|
||||
#else
|
||||
#if DRIVE_SYSTEM == CARTESIAN
|
||||
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
|
||||
#else
|
||||
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Core_XY EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
|
||||
#define MACHINE_TYPE "Core_XY"
|
||||
#endif
|
||||
#endif
|
||||
#ifndef FIRMWARE_URL
|
||||
#define FIRMWARE_URL "https://github.com/repetier/Repetier-Firmware/"
|
||||
#endif // FIRMWARE_URL
|
||||
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:" FIRMWARE_URL " PROTOCOL_VERSION:1.0 MACHINE_TYPE:" MACHINE_TYPE " EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
|
||||
FSTRINGVALUE(Com::tDebug,"Debug:")
|
||||
FSTRINGVALUE(Com::tOk,"ok")
|
||||
FSTRINGVALUE(Com::tNewline,"\r\n")
|
||||
|
@ -83,9 +91,23 @@ FSTRINGVALUE(Com::tSpaceRaw," RAW")
|
|||
FSTRINGVALUE(Com::tColon,":")
|
||||
FSTRINGVALUE(Com::tSlash,"/")
|
||||
FSTRINGVALUE(Com::tSpaceSlash," /")
|
||||
#if JSON_OUTPUT
|
||||
FSTRINGVALUE(Com::tJSONDir,"{\"dir\":\"")
|
||||
FSTRINGVALUE(Com::tJSONFiles,"\",\"files\":[")
|
||||
FSTRINGVALUE(Com::tJSONArrayEnd,"]}")
|
||||
FSTRINGVALUE(Com::tJSONErrorStart,"{\"err\":\"")
|
||||
FSTRINGVALUE(Com::tJSONErrorEnd,"\"}")
|
||||
FSTRINGVALUE(Com::tJSONFileInfoStart, "{\"err\":0,\"size\":");
|
||||
FSTRINGVALUE(Com::tJSONFileInfoHeight, ",\"height\":");
|
||||
FSTRINGVALUE(Com::tJSONFileInfoLayerHeight, ",\"layerHeight\":");
|
||||
FSTRINGVALUE(Com::tJSONFileInfoFilament, ",\"filament\":[");
|
||||
FSTRINGVALUE(Com::tJSONFileInfoGeneratedBy, "],\"generatedBy\":\"");
|
||||
FSTRINGVALUE(Com::tJSONFileInfoName, ",\"fileName\":\"");
|
||||
#endif // JSON_OUTPUT
|
||||
FSTRINGVALUE(Com::tSpeedMultiply,"SpeedMultiply:")
|
||||
FSTRINGVALUE(Com::tFlowMultiply,"FlowMultiply:")
|
||||
FSTRINGVALUE(Com::tFanspeed,"Fanspeed:")
|
||||
FSTRINGVALUE(Com::tFan2speed,"Fanspeed2:")
|
||||
FSTRINGVALUE(Com::tPrintedFilament,"Printed filament:")
|
||||
FSTRINGVALUE(Com::tPrintingTime,"Printing time:")
|
||||
FSTRINGVALUE(Com::tSpacem,"m ")
|
||||
|
@ -122,7 +144,6 @@ FSTRINGVALUE(Com::tEEPROMUpdated,"EEPROM updated")
|
|||
|
||||
FSTRINGVALUE(Com::tLinearLColon,"linear L:")
|
||||
FSTRINGVALUE(Com::tQuadraticKColon," quadratic K:")
|
||||
FSTRINGVALUE(Com::tExtruderJam, UI_TEXT_EXTRUDER_JAM)
|
||||
FSTRINGVALUE(Com::tFilamentSlipping,"Filament slipping")
|
||||
FSTRINGVALUE(Com::tPauseCommunication,"// action:pause")
|
||||
FSTRINGVALUE(Com::tContinueCommunication,"// action:resume")
|
||||
|
@ -235,6 +256,7 @@ FSTRINGVALUE(Com::tWait,WAITING_IDENTIFIER)
|
|||
#if EEPROM_MODE == 0
|
||||
FSTRINGVALUE(Com::tNoEEPROMSupport,"No EEPROM support compiled.\r\n")
|
||||
#else
|
||||
FSTRINGVALUE(Com::tZProbeOffsetZ, "Coating thickness [mm]")
|
||||
#if FEATURE_Z_PROBE
|
||||
FSTRINGVALUE(Com::tZProbeHeight,"Z-probe height [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeBedDitance,"Max. z-probe - bed dist. [mm]")
|
||||
|
@ -242,12 +264,15 @@ FSTRINGVALUE(Com::tZProbeOffsetX,"Z-probe offset x [mm]")
|
|||
FSTRINGVALUE(Com::tZProbeOffsetY,"Z-probe offset y [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeSpeed,"Z-probe speed [mm/s]")
|
||||
FSTRINGVALUE(Com::tZProbeSpeedXY,"Z-probe x-y-speed [mm/s]")
|
||||
FSTRINGVALUE(Com::tZProbeX1,"Z-probe X1")
|
||||
FSTRINGVALUE(Com::tZProbeY1,"Z-probe Y1")
|
||||
FSTRINGVALUE(Com::tZProbeX2,"Z-probe X2")
|
||||
FSTRINGVALUE(Com::tZProbeY2,"Z-probe Y2")
|
||||
FSTRINGVALUE(Com::tZProbeX3,"Z-probe X3")
|
||||
FSTRINGVALUE(Com::tZProbeY3,"Z-probe Y3")
|
||||
FSTRINGVALUE(Com::tZProbeX1,"Z-probe X1 [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeY1,"Z-probe Y1 [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeX2,"Z-probe X2 [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeY2,"Z-probe Y2 [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeX3,"Z-probe X3 [mm]")
|
||||
FSTRINGVALUE(Com::tZProbeY3,"Z-probe Y3 [mm]")
|
||||
FSTRINGVALUE(Com::zZProbeBendingCorA,"Z-probe bending correction A [mm]")
|
||||
FSTRINGVALUE(Com::zZProbeBendingCorB,"Z-probe bending correction B [mm]")
|
||||
FSTRINGVALUE(Com::zZProbeBendingCorC,"Z-probe bending correction C [mm]")
|
||||
#endif
|
||||
#if FEATURE_AXISCOMP
|
||||
FSTRINGVALUE(Com::tAxisCompTanXY,"tanXY Axis Compensation")
|
||||
|
@ -267,6 +292,7 @@ FSTRINGVALUE(Com::tEPR1,"EPR:1 ")
|
|||
FSTRINGVALUE(Com::tEPR2,"EPR:2 ")
|
||||
FSTRINGVALUE(Com::tEPR3,"EPR:3 ")
|
||||
FSTRINGVALUE(Com::tEPRBaudrate,"Baudrate")
|
||||
FSTRINGVALUE(Com::tLanguage,"Language")
|
||||
FSTRINGVALUE(Com::tEPRFilamentPrinted,"Filament printed [m]")
|
||||
FSTRINGVALUE(Com::tEPRPrinterActive,"Printer active [s]")
|
||||
FSTRINGVALUE(Com::tEPRMaxInactiveTime,"Max. inactive time [ms,0=off]")
|
||||
|
@ -281,6 +307,7 @@ FSTRINGVALUE(Com::tEPRXBacklash,"X backlash [mm]")
|
|||
FSTRINGVALUE(Com::tEPRYBacklash,"Y backlash [mm]")
|
||||
FSTRINGVALUE(Com::tEPRZBacklash,"Z backlash [mm]")
|
||||
FSTRINGVALUE(Com::tEPRMaxJerk,"Max. jerk [mm/s]")
|
||||
FSTRINGVALUE(Com::tEPRAccelerationFactorAtTop,"Acceleration factor at top [%,100=like bottom]")
|
||||
#if DRIVE_SYSTEM==DELTA
|
||||
FSTRINGVALUE(Com::tEPRZAcceleration,"Acceleration [mm/s^2]")
|
||||
FSTRINGVALUE(Com::tEPRZTravelAcceleration,"Travel acceleration [mm/s^2]")
|
||||
|
@ -357,8 +384,8 @@ FSTRINGVALUE(Com::tEPRAdvanceL,"advance L [0=off]")
|
|||
|
||||
#endif
|
||||
#if SDSUPPORT
|
||||
FSTRINGVALUE(Com::tSDRemoved,UI_TEXT_SD_REMOVED)
|
||||
FSTRINGVALUE(Com::tSDInserted,UI_TEXT_SD_INSERTED)
|
||||
//FSTRINGVALUE(Com::tSDRemoved,UI_TEXT_SD_REMOVED)
|
||||
//FSTRINGVALUE(Com::tSDInserted,UI_TEXT_SD_INSERTED)
|
||||
FSTRINGVALUE(Com::tSDInitFail,"SD init fail")
|
||||
FSTRINGVALUE(Com::tErrorWritingToFile,"error writing to file")
|
||||
FSTRINGVALUE(Com::tBeginFileList,"Begin file list")
|
||||
|
@ -401,6 +428,12 @@ FSTRINGVALUE(Com::tExtrDot,"Extr.")
|
|||
FSTRINGVALUE(Com::tMCPEpromSettings, "MCP4728 DAC EEPROM Settings:")
|
||||
FSTRINGVALUE(Com::tMCPCurrentSettings,"MCP4728 DAC Current Settings:")
|
||||
#endif
|
||||
FSTRINGVALUE(Com::tPrinterModeFFF,"PrinterMode:FFF")
|
||||
FSTRINGVALUE(Com::tPrinterModeLaser,"PrinterMode:Laser")
|
||||
FSTRINGVALUE(Com::tPrinterModeCNC,"PrinterMode:CNC")
|
||||
#ifdef STARTUP_GCODE
|
||||
FSTRINGVALUE(Com::tStartupGCode,STARTUP_GCODE)
|
||||
#endif
|
||||
|
||||
void Com::config(FSTRINGPARAM(text)) {
|
||||
printF(tConfig);
|
||||
|
@ -590,4 +623,3 @@ void Com::printFloat(float number, uint8_t digits)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -67,6 +67,19 @@ FSTRINGVAR(tFreeRAM)
|
|||
FSTRINGVAR(tXColon)
|
||||
FSTRINGVAR(tSlash)
|
||||
FSTRINGVAR(tSpaceSlash)
|
||||
#if JSON_OUTPUT
|
||||
FSTRINGVAR(tJSONDir)
|
||||
FSTRINGVAR(tJSONFiles)
|
||||
FSTRINGVAR(tJSONArrayEnd)
|
||||
FSTRINGVAR(tJSONErrorStart)
|
||||
FSTRINGVAR(tJSONErrorEnd)
|
||||
FSTRINGVAR(tJSONFileInfoStart)
|
||||
FSTRINGVAR(tJSONFileInfoHeight)
|
||||
FSTRINGVAR(tJSONFileInfoLayerHeight)
|
||||
FSTRINGVAR(tJSONFileInfoFilament)
|
||||
FSTRINGVAR(tJSONFileInfoGeneratedBy)
|
||||
FSTRINGVAR(tJSONFileInfoName)
|
||||
#endif
|
||||
FSTRINGVAR(tSpaceXColon)
|
||||
FSTRINGVAR(tSpaceYColon)
|
||||
FSTRINGVAR(tSpaceZColon)
|
||||
|
@ -82,6 +95,7 @@ FSTRINGVAR(tColon)
|
|||
FSTRINGVAR(tSpeedMultiply)
|
||||
FSTRINGVAR(tFlowMultiply)
|
||||
FSTRINGVAR(tFanspeed)
|
||||
FSTRINGVAR(tFan2speed)
|
||||
FSTRINGVAR(tPrintedFilament)
|
||||
FSTRINGVAR(tPrintingTime)
|
||||
FSTRINGVAR(tSpacem)
|
||||
|
@ -117,7 +131,6 @@ FSTRINGVAR(tCommaSpeedEqual)
|
|||
FSTRINGVAR(tLinearLColon)
|
||||
FSTRINGVAR(tQuadraticKColon)
|
||||
FSTRINGVAR(tEEPROMUpdated)
|
||||
FSTRINGVAR(tExtruderJam)
|
||||
FSTRINGVAR(tFilamentSlipping)
|
||||
FSTRINGVAR(tPauseCommunication)
|
||||
FSTRINGVAR(tContinueCommunication)
|
||||
|
@ -236,6 +249,7 @@ FSTRINGVAR(tWait)
|
|||
#if EEPROM_MODE==0
|
||||
FSTRINGVAR(tNoEEPROMSupport)
|
||||
#else
|
||||
FSTRINGVAR(tZProbeOffsetZ)
|
||||
#if FEATURE_Z_PROBE
|
||||
FSTRINGVAR(tZProbeHeight)
|
||||
FSTRINGVAR(tZProbeOffsetX)
|
||||
|
@ -248,6 +262,9 @@ FSTRINGVAR(tZProbeX2)
|
|||
FSTRINGVAR(tZProbeY2)
|
||||
FSTRINGVAR(tZProbeX3)
|
||||
FSTRINGVAR(tZProbeY3)
|
||||
FSTRINGVAR(zZProbeBendingCorA)
|
||||
FSTRINGVAR(zZProbeBendingCorB)
|
||||
FSTRINGVAR(zZProbeBendingCorC)
|
||||
#endif
|
||||
#if FEATURE_AUTOLEVEL
|
||||
FSTRINGVAR(tAutolevelActive)
|
||||
|
@ -265,6 +282,7 @@ FSTRINGVAR(tEPR0)
|
|||
FSTRINGVAR(tEPR1)
|
||||
FSTRINGVAR(tEPR2)
|
||||
FSTRINGVAR(tEPR3)
|
||||
FSTRINGVAR(tLanguage)
|
||||
FSTRINGVAR(tEPRBaudrate)
|
||||
FSTRINGVAR(tEPRFilamentPrinted)
|
||||
FSTRINGVAR(tEPRPrinterActive)
|
||||
|
@ -282,10 +300,11 @@ FSTRINGVAR(tEPRYBacklash)
|
|||
FSTRINGVAR(tEPRZBacklash)
|
||||
FSTRINGVAR(tEPRZAcceleration)
|
||||
FSTRINGVAR(tEPRZTravelAcceleration)
|
||||
FSTRINGVAR(tEPRAccelerationFactorAtTop)
|
||||
FSTRINGVAR(tEPRZStepsPerMM)
|
||||
FSTRINGVAR(tEPRZMaxFeedrate)
|
||||
FSTRINGVAR(tEPRZHomingFeedrate)
|
||||
#if DRIVE_SYSTEM!=DELTA
|
||||
#if DRIVE_SYSTEM != DELTA
|
||||
FSTRINGVAR(tEPRMaxZJerk)
|
||||
FSTRINGVAR(tEPRXStepsPerMM)
|
||||
FSTRINGVAR(tEPRYStepsPerMM)
|
||||
|
@ -342,8 +361,8 @@ FSTRINGVAR(tEPRAdvanceK)
|
|||
FSTRINGVAR(tEPRAdvanceL)
|
||||
#endif
|
||||
#if SDSUPPORT
|
||||
FSTRINGVAR(tSDRemoved)
|
||||
FSTRINGVAR(tSDInserted)
|
||||
//FSTRINGVAR(tSDRemoved)
|
||||
//FSTRINGVAR(tSDInserted)
|
||||
FSTRINGVAR(tSDInitFail)
|
||||
FSTRINGVAR(tErrorWritingToFile)
|
||||
FSTRINGVAR(tBeginFileList)
|
||||
|
@ -386,6 +405,12 @@ FSTRINGVAR(tExtrDot)
|
|||
FSTRINGVAR(tMCPEpromSettings)
|
||||
FSTRINGVAR(tMCPCurrentSettings)
|
||||
#endif
|
||||
FSTRINGVAR(tPrinterModeFFF)
|
||||
FSTRINGVAR(tPrinterModeLaser)
|
||||
FSTRINGVAR(tPrinterModeCNC)
|
||||
#ifdef STARTUP_GCODE
|
||||
FSTRINGVAR(tStartupGCode)
|
||||
#endif
|
||||
|
||||
static void config(FSTRINGPARAM(text));
|
||||
static void config(FSTRINGPARAM(text),int value);
|
||||
|
@ -422,6 +447,11 @@ static inline void print(char c) {HAL::serialWriteByte(c);}
|
|||
static void printFloat(float number, uint8_t digits);
|
||||
static inline void print(float number) {printFloat(number, 6);}
|
||||
static inline void println() {HAL::serialWriteByte('\r');HAL::serialWriteByte('\n');}
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
static const char* translatedF(int textId);
|
||||
static void selectLanguage(fast8_t lang);
|
||||
static uint8_t selectedLanguage;
|
||||
#endif
|
||||
protected:
|
||||
private:
|
||||
};
|
||||
|
@ -444,5 +474,3 @@ static inline void println() {HAL::serialWriteByte('\r');HAL::serialWriteByte('\
|
|||
#endif
|
||||
|
||||
#endif // COMMUNICATION_H
|
||||
|
||||
|
||||
|
|
|
@ -43,8 +43,17 @@
|
|||
// ################## EDIT THESE SETTINGS MANUALLY ################
|
||||
// ################ END MANUAL SETTINGS ##########################
|
||||
|
||||
#undef FAN_PIN
|
||||
#define FAN_PIN -1
|
||||
#undef FAN_BOARD_PIN
|
||||
#define FAN_BOARD_PIN -1
|
||||
#define FAN_THERMO_PIN -1
|
||||
#define FAN_THERMO_MIN_PWM 128
|
||||
#define FAN_THERMO_MAX_PWM 255
|
||||
#define FAN_THERMO_MIN_TEMP 45
|
||||
#define FAN_THERMO_MAX_TEMP 60
|
||||
#define FAN_THERMO_THERMISTOR_PIN -1
|
||||
#define FAN_THERMO_THERMISTOR_TYPE 1
|
||||
|
||||
//#define EXTERNALSERIAL use Arduino serial library instead of build in. Requires more ram, has only 63 byte input buffer.
|
||||
// Uncomment the following line if you are using arduino compatible firmware made for Arduino version earlier then 1.0
|
||||
|
@ -77,7 +86,7 @@
|
|||
#define EXT0_STEP_PIN ORIG_E0_STEP_PIN
|
||||
#define EXT0_DIR_PIN ORIG_E0_DIR_PIN
|
||||
#define EXT0_INVERSE 0
|
||||
#define EXT0_ENABLE_PIN E0_ENABLE_PIN
|
||||
#define EXT0_ENABLE_PIN ORIG_E0_ENABLE_PIN
|
||||
#define EXT0_ENABLE_ON 0
|
||||
#define EXT0_MAX_FEEDRATE 50
|
||||
#define EXT0_MAX_START_FEEDRATE 20
|
||||
|
@ -112,7 +121,7 @@
|
|||
#define EXT1_STEP_PIN ORIG_E1_STEP_PIN
|
||||
#define EXT1_DIR_PIN ORIG_E1_DIR_PIN
|
||||
#define EXT1_INVERSE 0
|
||||
#define EXT1_ENABLE_PIN E1_ENABLE_PIN
|
||||
#define EXT1_ENABLE_PIN ORIG_E1_ENABLE_PIN
|
||||
#define EXT1_ENABLE_ON 0
|
||||
#define EXT1_MAX_FEEDRATE 50
|
||||
#define EXT1_MAX_START_FEEDRATE 20
|
||||
|
@ -198,11 +207,60 @@
|
|||
#define MIN_DEFECT_TEMPERATURE -10
|
||||
#define MAX_DEFECT_TEMPERATURE 290
|
||||
|
||||
// ##########################################################################################
|
||||
// ## Laser configuration ##
|
||||
// ##########################################################################################
|
||||
|
||||
/*
|
||||
If the firmware is in laser mode, it can control a laser output to cut or engrave materials.
|
||||
Please use this feature only if you know about safety and required protection. Lasers are
|
||||
dangerous and can hurt or make you blind!!!
|
||||
|
||||
The default laser driver only supports laser on and off. Here you control the eíntensity with
|
||||
your feedrate. For exchangeable diode lasers this is normally enough. If you need more control
|
||||
you can set the intensity in a range 0-255 with a custom extension to the driver. See driver.h
|
||||
and comments on how to extend the functions non invasive with our event system.
|
||||
|
||||
If you have a laser - powder system you will like your E override. If moves contain a
|
||||
increasing extruder position it will laser that move. With this trick you can
|
||||
use existing fdm slicers to laser the output. Laser width is extrusion width.
|
||||
|
||||
Other tools may use M3 and M5 to enable/disable laser. Here G1/G2/G3 moves have laser enabled
|
||||
and G0 moves have it disables.
|
||||
|
||||
In any case, laser only enables while moving. At the end of a move it gets
|
||||
automatically disabled.
|
||||
*/
|
||||
|
||||
#define SUPPORT_LASER 0
|
||||
#define LASER_PIN -1
|
||||
#define LASER_ON_HIGH 1
|
||||
|
||||
// ## CNC configuration ##
|
||||
|
||||
/*
|
||||
If the firmware is in CNC mode, it can control a mill with M3/M4/M5. It works
|
||||
similar to laser mode, but mill keeps enabled during G0 moves and it allows
|
||||
setting rpm (only with event extension that supports this) and milling direction.
|
||||
It also can add a delay to wait for spindle to run on full speed.
|
||||
*/
|
||||
|
||||
#define SUPPORT_CNC 0
|
||||
#define CNC_WAIT_ON_ENABLE 300
|
||||
#define CNC_WAIT_ON_DISABLE 0
|
||||
#define CNC_ENABLE_PIN -1
|
||||
#define CNC_ENABLE_WITH 1
|
||||
#define CNC_DIRECTION_PIN -1
|
||||
#define CNC_DIRECTION_CW 1
|
||||
|
||||
|
||||
#define DEFAULT_PRINTER_MODE 0
|
||||
|
||||
// ################ Endstop configuration #####################
|
||||
|
||||
#define ENDSTOP_PULLUP_X_MIN true
|
||||
#define ENDSTOP_X_MIN_INVERTING true
|
||||
#define MIN_HARDWARE_ENDSTOP_X true
|
||||
#define ENDSTOP_X_MIN_INVERTING false
|
||||
#define MIN_HARDWARE_ENDSTOP_X false
|
||||
#define ENDSTOP_PULLUP_Y_MIN true
|
||||
#define ENDSTOP_Y_MIN_INVERTING true
|
||||
#define MIN_HARDWARE_ENDSTOP_Y true
|
||||
|
@ -210,8 +268,8 @@
|
|||
#define ENDSTOP_Z_MIN_INVERTING false
|
||||
#define MIN_HARDWARE_ENDSTOP_Z false
|
||||
#define ENDSTOP_PULLUP_X_MAX true
|
||||
#define ENDSTOP_X_MAX_INVERTING false
|
||||
#define MAX_HARDWARE_ENDSTOP_X false
|
||||
#define ENDSTOP_X_MAX_INVERTING true
|
||||
#define MAX_HARDWARE_ENDSTOP_X true
|
||||
#define ENDSTOP_PULLUP_Y_MAX true
|
||||
#define ENDSTOP_Y_MAX_INVERTING false
|
||||
#define MAX_HARDWARE_ENDSTOP_Y false
|
||||
|
@ -220,10 +278,10 @@
|
|||
#define MAX_HARDWARE_ENDSTOP_Z true
|
||||
#define max_software_endstop_r true
|
||||
|
||||
#define min_software_endstop_x false
|
||||
#define min_software_endstop_x true
|
||||
#define min_software_endstop_y false
|
||||
#define min_software_endstop_z true
|
||||
#define max_software_endstop_x true
|
||||
#define max_software_endstop_x false
|
||||
#define max_software_endstop_y true
|
||||
#define max_software_endstop_z false
|
||||
#define ENDSTOP_X_BACK_MOVE 5
|
||||
|
@ -232,7 +290,7 @@
|
|||
#define ENDSTOP_X_RETEST_REDUCTION_FACTOR 3
|
||||
#define ENDSTOP_Y_RETEST_REDUCTION_FACTOR 3
|
||||
#define ENDSTOP_Z_RETEST_REDUCTION_FACTOR 3
|
||||
#define ENDSTOP_X_BACK_ON_HOME 1
|
||||
#define ENDSTOP_X_BACK_ON_HOME 10
|
||||
#define ENDSTOP_Y_BACK_ON_HOME 1
|
||||
#define ENDSTOP_Z_BACK_ON_HOME 0
|
||||
#define ALWAYS_CHECK_ENDSTOPS 0
|
||||
|
@ -249,23 +307,27 @@
|
|||
#define INVERT_X_DIR 0
|
||||
#define INVERT_Y_DIR 0
|
||||
#define INVERT_Z_DIR 0
|
||||
#define X_HOME_DIR -1
|
||||
#define X_HOME_DIR 1
|
||||
#define Y_HOME_DIR -1
|
||||
#define Z_HOME_DIR 1
|
||||
#define X_MAX_LENGTH 200
|
||||
#define Y_MAX_LENGTH 180
|
||||
#define Z_MAX_LENGTH 135
|
||||
#define X_MAX_LENGTH 155
|
||||
#define Y_MAX_LENGTH 155
|
||||
#define Z_MAX_LENGTH 145
|
||||
#define X_MIN_POS 0
|
||||
#define Y_MIN_POS 0
|
||||
#define Z_MIN_POS 0
|
||||
#define DISTORTION_CORRECTION 0
|
||||
#define DISTORTION_CORRECTION_POINTS 5
|
||||
#define DISTORTION_CORRECTION_POINTS 3
|
||||
#define DISTORTION_CORRECTION_R 100
|
||||
#define DISTORTION_PERMANENT 1
|
||||
#define DISTORTION_PERMANENT 0
|
||||
#define DISTORTION_UPDATE_FREQUENCY 15
|
||||
#define DISTORTION_START_DEGRADE 0.5
|
||||
#define DISTORTION_END_HEIGHT 1
|
||||
#define DISTORTION_EXTRAPOLATE_CORNERS 0
|
||||
#define DISTORTION_XMIN 0
|
||||
#define DISTORTION_YMIN 0
|
||||
#define DISTORTION_XMAX 155
|
||||
#define DISTORTION_YMAX 155
|
||||
|
||||
// ##########################################################################################
|
||||
// ## Movement settings ##
|
||||
|
@ -312,6 +374,8 @@
|
|||
#define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_X 1000
|
||||
#define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_Y 1000
|
||||
#define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_Z 500
|
||||
#define INTERPOLATE_ACCELERATION_WITH_Z 0
|
||||
#define ACCELERATION_FACTOR_TOP 100
|
||||
#define MAX_JERK 20
|
||||
#define MAX_ZJERK 0.3
|
||||
#define PRINTLINE_CACHE_SIZE 16
|
||||
|
@ -320,15 +384,19 @@
|
|||
#define FEATURE_TWO_XSTEPPER 0
|
||||
#define X2_STEP_PIN ORIG_E1_STEP_PIN
|
||||
#define X2_DIR_PIN ORIG_E1_DIR_PIN
|
||||
#define X2_ENABLE_PIN E1_ENABLE_PIN
|
||||
#define X2_ENABLE_PIN ORIG_E1_ENABLE_PIN
|
||||
#define FEATURE_TWO_YSTEPPER 0
|
||||
#define Y2_STEP_PIN ORIG_E1_STEP_PIN
|
||||
#define Y2_DIR_PIN ORIG_E1_DIR_PIN
|
||||
#define Y2_ENABLE_PIN E1_ENABLE_PIN
|
||||
#define Y2_ENABLE_PIN ORIG_E1_ENABLE_PIN
|
||||
#define FEATURE_TWO_ZSTEPPER 0
|
||||
#define Z2_STEP_PIN ORIG_E1_STEP_PIN
|
||||
#define Z2_DIR_PIN ORIG_E1_DIR_PIN
|
||||
#define Z2_ENABLE_PIN E1_ENABLE_PIN
|
||||
#define Z2_ENABLE_PIN ORIG_E1_ENABLE_PIN
|
||||
#define FEATURE_THREE_ZSTEPPER 0
|
||||
#define Z3_STEP_PIN ORIG_E2_STEP_PIN
|
||||
#define Z3_DIR_PIN ORIG_E2_DIR_PIN
|
||||
#define Z3_ENABLE_PIN ORIG_E2_ENABLE_PIN
|
||||
#define FEATURE_DITTO_PRINTING 0
|
||||
#define USE_ADVANCE 0
|
||||
#define ENABLE_QUADRATIC_ADVANCE 0
|
||||
|
@ -343,8 +411,10 @@
|
|||
#define ACK_WITH_LINENUMBER 1
|
||||
#define WAITING_IDENTIFIER "wait"
|
||||
#define ECHO_ON_EXECUTE 1
|
||||
#define EEPROM_MODE 0
|
||||
#define EEPROM_MODE 2
|
||||
#undef PS_ON_PIN
|
||||
#define PS_ON_PIN ORIG_PS_ON_PIN
|
||||
#define JSON_OUTPUT 0
|
||||
|
||||
/* ======== Servos =======
|
||||
Control the servos with
|
||||
|
@ -379,20 +449,33 @@ WARNING: Servos can draw a considerable amount of current. Make sure your system
|
|||
#define Z_PROBE_X_OFFSET 6.4
|
||||
#define Z_PROBE_Y_OFFSET 0
|
||||
#define Z_PROBE_WAIT_BEFORE_TEST 0
|
||||
#define Z_PROBE_SPEED 8
|
||||
#define Z_PROBE_SPEED 100
|
||||
#define Z_PROBE_XY_SPEED 150
|
||||
#define Z_PROBE_SWITCHING_DISTANCE 1
|
||||
#define Z_PROBE_REPETITIONS 1
|
||||
#define Z_PROBE_HEIGHT 7.4
|
||||
#define Z_PROBE_HEIGHT 6.9
|
||||
#define Z_PROBE_START_SCRIPT ""
|
||||
#define Z_PROBE_FINISHED_SCRIPT ""
|
||||
#define FEATURE_AUTOLEVEL 1
|
||||
#define Z_PROBE_X1 20
|
||||
#define Z_PROBE_Y1 20
|
||||
#define Z_PROBE_X2 160
|
||||
#define Z_PROBE_Y2 20
|
||||
#define Z_PROBE_X3 100
|
||||
#define Z_PROBE_Y3 160
|
||||
#define Z_PROBE_X1 5
|
||||
#define Z_PROBE_Y1 5
|
||||
#define Z_PROBE_X2 150
|
||||
#define Z_PROBE_Y2 5
|
||||
#define Z_PROBE_X3 150
|
||||
#define Z_PROBE_Y3 150
|
||||
#define BED_LEVELING_METHOD 0
|
||||
#define BED_CORRECTION_METHOD 0
|
||||
#define BED_LEVELING_GRID_SIZE 5
|
||||
#define BED_LEVELING_REPETITIONS 5
|
||||
#define BED_MOTOR_1_X 0
|
||||
#define BED_MOTOR_1_Y 0
|
||||
#define BED_MOTOR_2_X 200
|
||||
#define BED_MOTOR_2_Y 0
|
||||
#define BED_MOTOR_3_X 100
|
||||
#define BED_MOTOR_3_Y 200
|
||||
#define BENDING_CORRECTION_A 0
|
||||
#define BENDING_CORRECTION_B 0
|
||||
#define BENDING_CORRECTION_C 0
|
||||
#define FEATURE_AXISCOMP 0
|
||||
#define AXISCOMP_TANXY 0
|
||||
#define AXISCOMP_TANYZ 0
|
||||
|
@ -400,6 +483,7 @@ WARNING: Servos can draw a considerable amount of current. Make sure your system
|
|||
|
||||
#ifndef SDSUPPORT // Some boards have sd support on board. These define the values already in pins.h
|
||||
#define SDSUPPORT 0
|
||||
#undef SDCARDDETECT
|
||||
#define SDCARDDETECT -1
|
||||
#define SDCARDDETECTINVERTED 0
|
||||
#endif
|
||||
|
@ -410,8 +494,19 @@ WARNING: Servos can draw a considerable amount of current. Make sure your system
|
|||
#define FEATURE_MEMORY_POSITION 0
|
||||
#define FEATURE_CHECKSUM_FORCED 0
|
||||
#define FEATURE_FAN_CONTROL 0
|
||||
#define FEATURE_FAN2_CONTROL 0
|
||||
#define FEATURE_CONTROLLER 0
|
||||
#define UI_LANGUAGE 0
|
||||
#define LANGUAGE_EN_ACTIVE 1
|
||||
#define LANGUAGE_DE_ACTIVE 1
|
||||
#define LANGUAGE_NL_ACTIVE 1
|
||||
#define LANGUAGE_PT_ACTIVE 1
|
||||
#define LANGUAGE_IT_ACTIVE 1
|
||||
#define LANGUAGE_ES_ACTIVE 1
|
||||
#define LANGUAGE_SE_ACTIVE 1
|
||||
#define LANGUAGE_FR_ACTIVE 1
|
||||
#define LANGUAGE_CZ_ACTIVE 1
|
||||
#define LANGUAGE_PL_ACTIVE 1
|
||||
#define LANGUAGE_TR_ACTIVE 1
|
||||
#define UI_PRINTER_NAME "RepRap"
|
||||
#define UI_PRINTER_COMPANY "Home made"
|
||||
#define UI_PAGES_DURATION 4000
|
||||
|
@ -471,7 +566,7 @@ Values must be in range 1..255
|
|||
"zStepsPerMM": 200,
|
||||
"xInvert": 0,
|
||||
"xInvertEnable": 0,
|
||||
"eepromMode": 0,
|
||||
"eepromMode": 2,
|
||||
"yInvert": 0,
|
||||
"yInvertEnable": 0,
|
||||
"zInvert": 0,
|
||||
|
@ -515,7 +610,7 @@ Values must be in range 1..255
|
|||
"name": "Extruder 0",
|
||||
"step": "ORIG_E0_STEP_PIN",
|
||||
"dir": "ORIG_E0_DIR_PIN",
|
||||
"enable": "E0_ENABLE_PIN"
|
||||
"enable": "ORIG_E0_ENABLE_PIN"
|
||||
},
|
||||
"advanceBacklashSteps": 0,
|
||||
"decoupleTestPeriod": 12,
|
||||
|
@ -560,7 +655,7 @@ Values must be in range 1..255
|
|||
"name": "Extruder 1",
|
||||
"step": "ORIG_E1_STEP_PIN",
|
||||
"dir": "ORIG_E1_DIR_PIN",
|
||||
"enable": "E1_ENABLE_PIN"
|
||||
"enable": "ORIG_E1_ENABLE_PIN"
|
||||
},
|
||||
"advanceBacklashSteps": 0,
|
||||
"decoupleTestPeriod": 12,
|
||||
|
@ -570,10 +665,10 @@ Values must be in range 1..255
|
|||
],
|
||||
"uiLanguage": 0,
|
||||
"uiController": 0,
|
||||
"xMinEndstop": 1,
|
||||
"xMinEndstop": 0,
|
||||
"yMinEndstop": 1,
|
||||
"zMinEndstop": 0,
|
||||
"xMaxEndstop": 0,
|
||||
"xMaxEndstop": 1,
|
||||
"yMaxEndstop": 0,
|
||||
"zMaxEndstop": 1,
|
||||
"motherboard": 33,
|
||||
|
@ -617,18 +712,18 @@ Values must be in range 1..255
|
|||
"xMinPos": 0,
|
||||
"yMinPos": 0,
|
||||
"zMinPos": 0,
|
||||
"xLength": 200,
|
||||
"yLength": 180,
|
||||
"zLength": 135,
|
||||
"xLength": 155,
|
||||
"yLength": 155,
|
||||
"zLength": 145,
|
||||
"alwaysCheckEndstops": "0",
|
||||
"disableX": "0",
|
||||
"disableY": "0",
|
||||
"disableZ": "0",
|
||||
"disableE": "0",
|
||||
"xHomeDir": "-1",
|
||||
"xHomeDir": "1",
|
||||
"yHomeDir": "-1",
|
||||
"zHomeDir": "1",
|
||||
"xEndstopBack": 1,
|
||||
"xEndstopBack": 10,
|
||||
"yEndstopBack": 1,
|
||||
"zEndstopBack": 0,
|
||||
"deltaSegmentsPerSecondPrint": 180,
|
||||
|
@ -673,21 +768,28 @@ Values must be in range 1..255
|
|||
"name": "Extruder 1",
|
||||
"step": "ORIG_E1_STEP_PIN",
|
||||
"dir": "ORIG_E1_DIR_PIN",
|
||||
"enable": "E1_ENABLE_PIN"
|
||||
"enable": "ORIG_E1_ENABLE_PIN"
|
||||
},
|
||||
"mirrorY": 0,
|
||||
"mirrorYMotor": {
|
||||
"name": "Extruder 1",
|
||||
"step": "ORIG_E1_STEP_PIN",
|
||||
"dir": "ORIG_E1_DIR_PIN",
|
||||
"enable": "E1_ENABLE_PIN"
|
||||
"enable": "ORIG_E1_ENABLE_PIN"
|
||||
},
|
||||
"mirrorZ": 0,
|
||||
"mirrorZMotor": {
|
||||
"name": "Extruder 1",
|
||||
"step": "ORIG_E1_STEP_PIN",
|
||||
"dir": "ORIG_E1_DIR_PIN",
|
||||
"enable": "E1_ENABLE_PIN"
|
||||
"enable": "ORIG_E1_ENABLE_PIN"
|
||||
},
|
||||
"mirrorZ3": "0",
|
||||
"mirrorZ3Motor": {
|
||||
"name": "Extruder 2",
|
||||
"step": "ORIG_E2_STEP_PIN",
|
||||
"dir": "ORIG_E2_DIR_PIN",
|
||||
"enable": "ORIG_E2_ENABLE_PIN"
|
||||
},
|
||||
"dittoPrinting": "0",
|
||||
"featureServos": "0",
|
||||
|
@ -766,17 +868,20 @@ Values must be in range 1..255
|
|||
"userTable0": {
|
||||
"r1": 0,
|
||||
"r2": 4700,
|
||||
"temps": []
|
||||
"temps": [],
|
||||
"numEntries": 0
|
||||
},
|
||||
"userTable1": {
|
||||
"r1": 0,
|
||||
"r2": 4700,
|
||||
"temps": []
|
||||
"temps": [],
|
||||
"numEntries": 0
|
||||
},
|
||||
"userTable2": {
|
||||
"r1": 0,
|
||||
"r2": 4700,
|
||||
"temps": []
|
||||
"temps": [],
|
||||
"numEntries": 0
|
||||
},
|
||||
"tempHysteresis": 0,
|
||||
"pidControlRange": 20,
|
||||
|
@ -792,6 +897,15 @@ Values must be in range 1..255
|
|||
"sdExtendedDir": "1",
|
||||
"featureFanControl": "0",
|
||||
"fanPin": -1,
|
||||
"featureFan2Control": "0",
|
||||
"fan2Pin": "ORIG_FAN2_PIN",
|
||||
"fanThermoPin": -1,
|
||||
"fanThermoMinPWM": 128,
|
||||
"fanThermoMaxPWM": 255,
|
||||
"fanThermoMinTemp": 45,
|
||||
"fanThermoMaxTemp": 60,
|
||||
"fanThermoThermistorPin": -1,
|
||||
"fanThermoThermistorType": 1,
|
||||
"scalePidToMax": 0,
|
||||
"zProbePin": "ORIG_Z_MIN_PIN",
|
||||
"zProbeBedDistance": 10,
|
||||
|
@ -800,18 +914,18 @@ Values must be in range 1..255
|
|||
"zProbeXOffset": 6.4,
|
||||
"zProbeYOffset": 0,
|
||||
"zProbeWaitBeforeTest": "0",
|
||||
"zProbeSpeed": 8,
|
||||
"zProbeSpeed": 100,
|
||||
"zProbeXYSpeed": 150,
|
||||
"zProbeHeight": 7.4,
|
||||
"zProbeHeight": 6.9,
|
||||
"zProbeStartScript": "",
|
||||
"zProbeFinishedScript": "",
|
||||
"featureAutolevel": "1",
|
||||
"zProbeX1": 20,
|
||||
"zProbeY1": 20,
|
||||
"zProbeX2": 160,
|
||||
"zProbeY2": 20,
|
||||
"zProbeX3": 100,
|
||||
"zProbeY3": 160,
|
||||
"zProbeX1": 5,
|
||||
"zProbeY1": 5,
|
||||
"zProbeX2": 150,
|
||||
"zProbeY2": 5,
|
||||
"zProbeX3": 150,
|
||||
"zProbeY3": 150,
|
||||
"zProbeSwitchingDistance": 1,
|
||||
"zProbeRepetitions": 1,
|
||||
"sdSupport": "0",
|
||||
|
@ -849,13 +963,17 @@ Values must be in range 1..255
|
|||
"pauseStartCommands": "",
|
||||
"pauseEndCommands": "",
|
||||
"distortionCorrection": "0",
|
||||
"distortionCorrectionPoints": 5,
|
||||
"distortionCorrectionPoints": 3,
|
||||
"distortionCorrectionR": 100,
|
||||
"distortionPermanent": "1",
|
||||
"distortionPermanent": "0",
|
||||
"distortionUpdateFrequency": 15,
|
||||
"distortionStartDegrade": 0.5,
|
||||
"distortionEndDegrade": 1,
|
||||
"distortionExtrapolateCorners": "0",
|
||||
"distortionXMin": 0,
|
||||
"distortionXMax": 155,
|
||||
"distortionYMin": 0,
|
||||
"distortionYMax": 155,
|
||||
"sdRunOnStop": "",
|
||||
"sdStopHeaterMotorsOnStop": "1",
|
||||
"featureRetraction": "0",
|
||||
|
@ -966,6 +1084,46 @@ Values must be in range 1..255
|
|||
"zProbeZOffsetMode": 0,
|
||||
"zProbeZOffset": 0,
|
||||
"uiBedCoating": "1",
|
||||
"langEN": "1",
|
||||
"langDE": "1",
|
||||
"langNL": "1",
|
||||
"langPT": "1",
|
||||
"langIT": "1",
|
||||
"langES": "1",
|
||||
"langSE": "1",
|
||||
"langFR": "1",
|
||||
"langCZ": "1",
|
||||
"langPL": "1",
|
||||
"langTR": "1",
|
||||
"interpolateAccelerationWithZ": 0,
|
||||
"accelerationFactorTop": 100,
|
||||
"bendingCorrectionA": 0,
|
||||
"bendingCorrectionB": 0,
|
||||
"bendingCorrectionC": 0,
|
||||
"preventZDisableOnStepperTimeout": "0",
|
||||
"supportLaser": "0",
|
||||
"laserPin": -1,
|
||||
"laserOnHigh": "1",
|
||||
"defaultPrinterMode": 0,
|
||||
"supportCNC": "0",
|
||||
"cncWaitOnEnable": 300,
|
||||
"cncWaitOnDisable": 0,
|
||||
"cncEnablePin": -1,
|
||||
"cncEnableWith": "1",
|
||||
"cncDirectionPin": -1,
|
||||
"cncDirectionCW": "1",
|
||||
"startupGCode": "",
|
||||
"jsonOutput": "0",
|
||||
"bedLevelingMethod": 0,
|
||||
"bedCorrectionMethod": 0,
|
||||
"bedLevelingGridSize": 5,
|
||||
"bedLevelingRepetitions": 5,
|
||||
"bedMotor1X": 0,
|
||||
"bedMotor1Y": 0,
|
||||
"bedMotor2X": 200,
|
||||
"bedMotor2Y": 0,
|
||||
"bedMotor3X": 100,
|
||||
"bedMotor3Y": 200,
|
||||
"hasMAX6675": false,
|
||||
"hasMAX31855": false,
|
||||
"hasGeneric1": false,
|
||||
|
@ -975,7 +1133,7 @@ Values must be in range 1..255
|
|||
"hasUser1": false,
|
||||
"hasUser2": false,
|
||||
"numExtruder": 2,
|
||||
"version": 92.4,
|
||||
"version": 92.8,
|
||||
"primaryPortName": ""
|
||||
}
|
||||
========== End configuration string ==========
|
||||
|
|
|
@ -18,7 +18,8 @@ MOTOR_DRIVER_5(motorDriver5);
|
|||
MOTOR_DRIVER_6(motorDriver6);
|
||||
#endif
|
||||
|
||||
MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] = {
|
||||
MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] =
|
||||
{
|
||||
&motorDriver1
|
||||
#if NUM_MOTOR_DRIVERS > 1
|
||||
, &motorDriver2
|
||||
|
@ -37,14 +38,16 @@ MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] = {
|
|||
#endif
|
||||
};
|
||||
|
||||
MotorDriverInterface *getMotorDriver(int idx) {
|
||||
MotorDriverInterface *getMotorDriver(int idx)
|
||||
{
|
||||
return motorDrivers[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
Run motor P until it is at position X
|
||||
*/
|
||||
void commandG201(GCode &code) {
|
||||
void commandG201(GCode &code)
|
||||
{
|
||||
int id = 0;
|
||||
if(code.hasP())
|
||||
id = code.P;
|
||||
|
@ -55,7 +58,8 @@ void commandG201(GCode &code) {
|
|||
}
|
||||
|
||||
//G202 P<motorId> X<setpos> - Mark current position as X
|
||||
void commandG202(GCode &code) {
|
||||
void commandG202(GCode &code)
|
||||
{
|
||||
int id = 0;
|
||||
if(code.hasP())
|
||||
id = code.P;
|
||||
|
@ -65,7 +69,8 @@ void commandG202(GCode &code) {
|
|||
motorDrivers[id]->setCurrentAs(code.X);
|
||||
}
|
||||
//G203 P<motorId> - Report current motor position
|
||||
void commandG203(GCode &code) {
|
||||
void commandG203(GCode &code)
|
||||
{
|
||||
int id = 0;
|
||||
if(code.hasP())
|
||||
id = code.P;
|
||||
|
@ -75,7 +80,8 @@ void commandG203(GCode &code) {
|
|||
Com::printFLN(PSTR("Pos:"),motorDrivers[id]->getPosition());
|
||||
}
|
||||
//G204 P<motorId> S<0/1> - Enable/disable motor
|
||||
void commandG204(GCode &code) {
|
||||
void commandG204(GCode &code)
|
||||
{
|
||||
int id = 0;
|
||||
if(code.hasP())
|
||||
id = code.P;
|
||||
|
@ -88,15 +94,122 @@ void commandG204(GCode &code) {
|
|||
motorDrivers[id]->disable();
|
||||
}
|
||||
|
||||
void disableAllMotorDrivers() {
|
||||
void disableAllMotorDrivers()
|
||||
{
|
||||
for(int i = 0; i < NUM_MOTOR_DRIVERS; i++)
|
||||
motorDrivers[i]->disable();
|
||||
}
|
||||
void initializeAllMotorDrivers() {
|
||||
void initializeAllMotorDrivers()
|
||||
{
|
||||
for(int i = 0; i < NUM_MOTOR_DRIVERS; i++)
|
||||
motorDrivers[i]->initialize();
|
||||
}
|
||||
|
||||
#endif // NUM_MOTOR_DRIVERS
|
||||
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
uint8_t LaserDriver::intensity = 255; // Intensity to use for next move queued if we want lasers. This is NOT the current value!
|
||||
bool LaserDriver::laserOn = false;
|
||||
void LaserDriver::initialize()
|
||||
{
|
||||
if(EVENT_INITALIZE_LASER)
|
||||
{
|
||||
#if LASER_PIN > -1
|
||||
SET_OUTPUT(LASER_PIN);
|
||||
#endif
|
||||
}
|
||||
changeIntensity(0);
|
||||
}
|
||||
void LaserDriver::changeIntensity(uint8_t newIntensity)
|
||||
{
|
||||
if(EVENT_SET_LASER(newIntensity))
|
||||
{
|
||||
// Default implementation
|
||||
#if LASER_PIN > -1
|
||||
WRITE(LASER_PIN,(LASER_ON_HIGH ? newIntensity > 199 : newIntensity < 200));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif // SUPPORT_LASER
|
||||
|
||||
#if defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
/**
|
||||
The CNC driver differs a bit from laser driver. Here only M3,M4,M5 have an influence on the spindle.
|
||||
The motor also keeps running for G0 moves. M3 and M4 wait for old moves to be finished and then enables
|
||||
the motor. It then waits CNC_WAIT_ON_ENABLE milliseconds for the spindle to reach target speed.
|
||||
*/
|
||||
|
||||
int8_t CNCDriver::direction = 0;
|
||||
/** Initialize cnc pins. EVENT_INITALIZE_CNC should return false to prevent default initalization.*/
|
||||
void CNCDriver::initialize()
|
||||
{
|
||||
if(EVENT_INITALIZE_CNC)
|
||||
{
|
||||
#if CNC_ENABLE_PIN > -1
|
||||
SET_OUTPUT(CNC_ENABLE_PIN);
|
||||
WRITE(CNC_ENABLE_PIN,!CNC_ENABLE_WITH);
|
||||
#endif
|
||||
#if CNC_DIRECTION_PIN > -1
|
||||
SET_OUTPUT(CNC_DIRECTION_PIN);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
/** Turns off spindle. For event override implement
|
||||
EVENT_SPINDLE_OFF
|
||||
returning false.
|
||||
*/
|
||||
void CNCDriver::spindleOff()
|
||||
{
|
||||
if(direction == 0) return; // already off
|
||||
if(EVENT_SPINDLE_OFF)
|
||||
{
|
||||
#if CNC_ENABLE_PIN > -1
|
||||
WRITE(CNC_ENABLE_PIN,!CNC_ENABLE_WITH);
|
||||
#endif
|
||||
}
|
||||
HAL::delayMilliseconds(CNC_WAIT_ON_DISABLE);
|
||||
direction = 0;
|
||||
}
|
||||
/** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
|
||||
CNC_DIRECTION_PIN is not -1 it sets direction to CNC_DIRECTION_CW. rpm is ignored.
|
||||
To override with event system, return false for the event
|
||||
EVENT_SPINDLE_CW(rpm)
|
||||
*/
|
||||
void CNCDriver::spindleOnCW(int32_t rpm)
|
||||
{
|
||||
if(direction == 1)
|
||||
return;
|
||||
spindleOff();
|
||||
direction = 1;
|
||||
if(EVENT_SPINDLE_CW(rpm)) {
|
||||
#if CNC_DIRECTION_PIN > -1
|
||||
WRITE(CNC_DIRECTION_PIN, CNC_DIRECTION_CW);
|
||||
#endif
|
||||
#if CNC_ENABLE_PIN > -1
|
||||
WRITE(CNC_ENABLE_PIN, CNC_ENABLE_WITH);
|
||||
#endif
|
||||
}
|
||||
HAL::delayMilliseconds(CNC_WAIT_ON_ENABLE);
|
||||
}
|
||||
/** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
|
||||
CNC_DIRECTION_PIN is not -1 it sets direction to !CNC_DIRECTION_CW. rpm is ignored.
|
||||
To override with event system, return false for the event
|
||||
EVENT_SPINDLE_CCW(rpm)
|
||||
*/
|
||||
void CNCDriver::spindleOnCCW(int32_t rpm)
|
||||
{
|
||||
if(direction == -1)
|
||||
return;
|
||||
spindleOff();
|
||||
direction = -1;
|
||||
if(EVENT_SPINDLE_CW(rpm)) {
|
||||
#if CNC_DIRECTION_PIN > -1
|
||||
WRITE(CNC_DIRECTION_PIN, !CNC_DIRECTION_CW);
|
||||
#endif
|
||||
#if CNC_ENABLE_PIN > -1
|
||||
WRITE(CNC_ENABLE_PIN, CNC_ENABLE_WITH);
|
||||
#endif
|
||||
}
|
||||
HAL::delayMilliseconds(CNC_WAIT_ON_ENABLE);
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -101,6 +101,53 @@ extern MotorDriverInterface *getMotorDriver(int idx);
|
|||
extern void initializeAllMotorDrivers();
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
/**
|
||||
With laser support you can exchange a extruder by a laser. A laser gets controlled by a digital pin.
|
||||
By default all intensities > 200 are always on, and lower values are always off. You can overwrite
|
||||
this with a programmed event EVENT_SET_LASER(intensity) that return false to signal the default
|
||||
implementation that it has set it's value already.
|
||||
EVENT_INITALIZE_LASER should return false to prevent default initialization.
|
||||
*/
|
||||
class LaserDriver {
|
||||
public:
|
||||
static uint8_t intensity; // Intensity to use for next move queued. This is NOT the current value!
|
||||
static bool laserOn; // Enabled by M3?
|
||||
static void initialize();
|
||||
static void changeIntensity(uint8_t newIntensity);
|
||||
};
|
||||
#endif
|
||||
|
||||
#if defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
/**
|
||||
The CNC driver differs a bit from laser driver. Here only M3,M4,M5 have an influence on the spindle.
|
||||
The motor also keeps running for G0 moves. M3 and M4 wait for old moves to be finished and then enables
|
||||
the motor. It then waits CNC_WAIT_ON_ENABLE milliseconds for the spindle to reach target speed.
|
||||
*/
|
||||
class CNCDriver {
|
||||
public:
|
||||
static int8_t direction;
|
||||
/** Initialize cnc pins. EVENT_INITALIZE_CNC should return false to prevent default initalization.*/
|
||||
static void initialize();
|
||||
/** Turns off spindle. For event override implement
|
||||
EVENT_SPINDLE_OFF
|
||||
returning false.
|
||||
*/
|
||||
static void spindleOff();
|
||||
/** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
|
||||
CNC_DIRECTION_PIN is not -1 it sets direction to CNC_DIRECTION_CW. rpm is ignored.
|
||||
To override with event system, return false for the event
|
||||
EVENT_SPINDLE_CW(rpm)
|
||||
*/
|
||||
static void spindleOnCW(int32_t rpm);
|
||||
/** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
|
||||
CNC_DIRECTION_PIN is not -1 it sets direction to !CNC_DIRECTION_CW. rpm is ignored.
|
||||
To override with event system, return false for the event
|
||||
EVENT_SPINDLE_CCW(rpm)
|
||||
*/
|
||||
static void spindleOnCCW(int32_t rpm);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif // DRIVERS_H_INCLUDED
|
||||
|
||||
|
||||
|
|
|
@ -232,7 +232,7 @@ void EEPROM::restoreEEPROMSettingsFromConfiguration()
|
|||
e->advanceL = EXT3_ADVANCE_L;
|
||||
#endif
|
||||
#endif // NUM_EXTRUDER > 3
|
||||
#if NUM_EXTRUDER>4
|
||||
#if NUM_EXTRUDER > 4
|
||||
e = &extruder[4];
|
||||
e->stepsPerMM = EXT4_STEPS_PER_MM;
|
||||
e->maxFeedrate = EXT4_MAX_FEEDRATE;
|
||||
|
@ -262,7 +262,7 @@ void EEPROM::restoreEEPROMSettingsFromConfiguration()
|
|||
e->advanceL = EXT4_ADVANCE_L;
|
||||
#endif
|
||||
#endif // NUM_EXTRUDER > 4
|
||||
#if NUM_EXTRUDER>5
|
||||
#if NUM_EXTRUDER > 5
|
||||
e = &extruder[5];
|
||||
e->stepsPerMM = EXT5_STEPS_PER_MM;
|
||||
e->maxFeedrate = EXT5_MAX_FEEDRATE;
|
||||
|
@ -385,6 +385,9 @@ void EEPROM::storeDataIntoEEPROM(uint8_t corrupted)
|
|||
HAL::eprSetByte(EPR_AUTOLEVEL_ACTIVE,Printer::isAutolevelActive());
|
||||
for(uint8_t i = 0; i < 9; i++)
|
||||
HAL::eprSetFloat(EPR_AUTOLEVEL_MATRIX + (((int)i) << 2),Printer::autolevelTransformation[i]);
|
||||
#endif
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
HAL::eprSetByte(EPR_SELECTED_LANGUAGE,Com::selectedLanguage);
|
||||
#endif
|
||||
// now the extruder
|
||||
for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
|
||||
|
@ -453,6 +456,7 @@ void EEPROM::initalizeUncached()
|
|||
HAL::eprSetFloat(EPR_Z_PROBE_XY_SPEED,Z_PROBE_XY_SPEED);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_X_OFFSET,Z_PROBE_X_OFFSET);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_Y_OFFSET,Z_PROBE_Y_OFFSET);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_Z_OFFSET,Z_PROBE_Z_OFFSET);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_X1,Z_PROBE_X1);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_Y1,Z_PROBE_Y1);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_X2,Z_PROBE_X2);
|
||||
|
@ -463,6 +467,7 @@ void EEPROM::initalizeUncached()
|
|||
HAL::eprSetFloat(EPR_AXISCOMP_TANYZ,AXISCOMP_TANYZ);
|
||||
HAL::eprSetFloat(EPR_AXISCOMP_TANXZ,AXISCOMP_TANXZ);
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_BED_DISTANCE,Z_PROBE_BED_DISTANCE);
|
||||
Printer::zBedOffset = HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
HAL::eprSetFloat(EPR_DELTA_DIAGONAL_ROD_LENGTH,DELTA_DIAGONAL_ROD);
|
||||
HAL::eprSetFloat(EPR_DELTA_HORIZONTAL_RADIUS,ROD_RADIUS);
|
||||
|
@ -495,6 +500,10 @@ void EEPROM::initalizeUncached()
|
|||
HAL::eprSetFloat(EPR_RETRACTION_UNDO_EXTRA_LONG_LENGTH,RETRACTION_UNDO_EXTRA_LONG_LENGTH);
|
||||
HAL::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED);
|
||||
HAL::eprSetByte(EPR_AUTORETRACT_ENABLED,AUTORETRACT_ENABLED);
|
||||
HAL::eprSetFloat(EPR_BENDING_CORRECTION_A,BENDING_CORRECTION_A);
|
||||
HAL::eprSetFloat(EPR_BENDING_CORRECTION_B,BENDING_CORRECTION_B);
|
||||
HAL::eprSetFloat(EPR_BENDING_CORRECTION_C,BENDING_CORRECTION_C);
|
||||
HAL::eprSetFloat(EPR_ACCELERATION_FACTOR_TOP,Z_ACCELERATION_TOP);
|
||||
|
||||
}
|
||||
|
||||
|
@ -502,6 +511,7 @@ void EEPROM::readDataFromEEPROM(bool includeExtruder)
|
|||
{
|
||||
#if EEPROM_MODE != 0
|
||||
uint8_t version = HAL::eprGetByte(EPR_VERSION); // This is the saved version. Don't copy data not set in older versions!
|
||||
//Com::printFLN(PSTR("Detected EEPROM version:"),(int)version);
|
||||
baudrate = HAL::eprGetInt32(EPR_BAUDRATE);
|
||||
maxInactiveTime = HAL::eprGetInt32(EPR_MAX_INACTIVE_TIME);
|
||||
stepperInactiveTime = HAL::eprGetInt32(EPR_STEPPER_INACTIVE_TIME);
|
||||
|
@ -705,6 +715,21 @@ void EEPROM::readDataFromEEPROM(bool includeExtruder)
|
|||
HAL::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED);
|
||||
HAL::eprSetByte(EPR_AUTORETRACT_ENABLED,AUTORETRACT_ENABLED);
|
||||
}
|
||||
if(version < 14) {
|
||||
HAL::eprSetFloat(EPR_Z_PROBE_Z_OFFSET,Z_PROBE_Z_OFFSET);
|
||||
}
|
||||
if(version < 15) {
|
||||
HAL::eprSetByte(EPR_SELECTED_LANGUAGE, 254); // activate selector on startup
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
Com::selectedLanguage = 254;
|
||||
#endif
|
||||
}
|
||||
if(version < 16) {
|
||||
HAL::eprSetFloat(EPR_BENDING_CORRECTION_A,BENDING_CORRECTION_A);
|
||||
HAL::eprSetFloat(EPR_BENDING_CORRECTION_B,BENDING_CORRECTION_B);
|
||||
HAL::eprSetFloat(EPR_BENDING_CORRECTION_C,BENDING_CORRECTION_C);
|
||||
HAL::eprSetFloat(EPR_ACCELERATION_FACTOR_TOP,ACCELERATION_FACTOR_TOP);
|
||||
}
|
||||
/* if (version<8) {
|
||||
#if DRIVE_SYSTEM==DELTA
|
||||
// Prior to verion 8, the cartesian max was stored in the zmax
|
||||
|
@ -723,6 +748,10 @@ void EEPROM::readDataFromEEPROM(bool includeExtruder)
|
|||
|
||||
storeDataIntoEEPROM(false); // Store new fields for changed version
|
||||
}
|
||||
Printer::zBedOffset = HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
Com::selectLanguage(HAL::eprGetByte(EPR_SELECTED_LANGUAGE));
|
||||
#endif
|
||||
Printer::updateDerivedParameter();
|
||||
Extruder::initHeatedBed();
|
||||
#endif
|
||||
|
@ -733,7 +762,7 @@ void EEPROM::initBaudrate()
|
|||
// Invariant - baudrate is intitalized with or without eeprom!
|
||||
baudrate = BAUDRATE;
|
||||
#if EEPROM_MODE != 0
|
||||
if(HAL::eprGetByte(EPR_MAGIC_BYTE)==EEPROM_MODE)
|
||||
if(HAL::eprGetByte(EPR_MAGIC_BYTE) == EEPROM_MODE)
|
||||
{
|
||||
baudrate = HAL::eprGetInt32(EPR_BAUDRATE);
|
||||
}
|
||||
|
@ -762,7 +791,7 @@ void EEPROM::init()
|
|||
if(newcheck != HAL::eprGetByte(EPR_INTEGRITY_BYTE))
|
||||
HAL::eprSetByte(EPR_INTEGRITY_BYTE,newcheck);
|
||||
}
|
||||
Com::printFLN(PSTR("EEprom baud rate restored from configuration."));
|
||||
Com::printFLN(PSTR("EEPROM baud rate restored from configuration."));
|
||||
Com::printFLN(PSTR("RECOMPILE WITH USE_CONFIGURATION_BAUD_RATE == 0 to alter baud rate via EEPROM"));
|
||||
}
|
||||
}
|
||||
|
@ -805,6 +834,7 @@ With
|
|||
void EEPROM::writeSettings()
|
||||
{
|
||||
#if EEPROM_MODE != 0
|
||||
writeByte(EPR_SELECTED_LANGUAGE,Com::tLanguage);
|
||||
writeLong(EPR_BAUDRATE, Com::tEPRBaudrate);
|
||||
writeFloat(EPR_PRINTING_DISTANCE, Com::tEPRFilamentPrinted);
|
||||
writeLong(EPR_PRINTING_TIME, Com::tEPRPrinterActive);
|
||||
|
@ -852,6 +882,9 @@ void EEPROM::writeSettings()
|
|||
#if DRIVE_SYSTEM == DELTA
|
||||
writeFloat(EPR_Z_MAX_ACCEL, Com::tEPRZAcceleration);
|
||||
writeFloat(EPR_Z_MAX_TRAVEL_ACCEL, Com::tEPRZTravelAcceleration);
|
||||
#if defined(INTERPOLATE_ACCELERATION_WITH_Z) && INTERPOLATE_ACCELERATION_WITH_Z != 0
|
||||
writeFloat(EPR_ACCELERATION_FACTOR_TOP, Com::tEPRAccelerationFactorAtTop);
|
||||
#endif
|
||||
writeFloat(EPR_DELTA_DIAGONAL_ROD_LENGTH, Com::tEPRDiagonalRodLength);
|
||||
writeFloat(EPR_DELTA_HORIZONTAL_RADIUS, Com::tEPRHorizontalRadius);
|
||||
writeFloat(EPR_DELTA_MAX_RADIUS, Com::tEPRDeltaMaxRadius);
|
||||
|
@ -876,8 +909,12 @@ void EEPROM::writeSettings()
|
|||
writeFloat(EPR_X_MAX_TRAVEL_ACCEL, Com::tEPRXTravelAcceleration);
|
||||
writeFloat(EPR_Y_MAX_TRAVEL_ACCEL, Com::tEPRYTravelAcceleration);
|
||||
writeFloat(EPR_Z_MAX_TRAVEL_ACCEL, Com::tEPRZTravelAcceleration);
|
||||
#if defined(INTERPOLATE_ACCELERATION_WITH_Z) && INTERPOLATE_ACCELERATION_WITH_Z != 0
|
||||
writeFloat(EPR_ACCELERATION_FACTOR_TOP, Com::tEPRAccelerationFactorAtTop);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
writeFloat(EPR_Z_PROBE_Z_OFFSET, Com::tZProbeOffsetZ);
|
||||
#if FEATURE_Z_PROBE
|
||||
writeFloat(EPR_Z_PROBE_HEIGHT, Com::tZProbeHeight);
|
||||
writeFloat(EPR_Z_PROBE_BED_DISTANCE, Com::tZProbeBedDitance);
|
||||
|
@ -891,6 +928,9 @@ void EEPROM::writeSettings()
|
|||
writeFloat(EPR_Z_PROBE_Y2, Com::tZProbeY2);
|
||||
writeFloat(EPR_Z_PROBE_X3, Com::tZProbeX3);
|
||||
writeFloat(EPR_Z_PROBE_Y3, Com::tZProbeY3);
|
||||
writeFloat(EPR_BENDING_CORRECTION_A, Com::zZProbeBendingCorA);
|
||||
writeFloat(EPR_BENDING_CORRECTION_B, Com::zZProbeBendingCorB);
|
||||
writeFloat(EPR_BENDING_CORRECTION_C, Com::zZProbeBendingCorC);
|
||||
#endif
|
||||
#if FEATURE_AUTOLEVEL
|
||||
writeByte(EPR_AUTOLEVEL_ACTIVE, Com::tAutolevelActive);
|
||||
|
@ -1092,5 +1132,3 @@ void EEPROM::setZCorrection(int32_t c,int index)
|
|||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -20,7 +20,7 @@
|
|||
#define _EEPROM_H
|
||||
|
||||
// Id to distinguish version changes
|
||||
#define EEPROM_PROTOCOL_VERSION 13
|
||||
#define EEPROM_PROTOCOL_VERSION 16
|
||||
|
||||
/** Where to start with our datablock in memory. Can be moved if you
|
||||
have problems with other modules using the eeprom */
|
||||
|
@ -112,15 +112,21 @@ have problems with other modules using the eeprom */
|
|||
#define EPR_AXISCOMP_TANYZ 980
|
||||
#define EPR_AXISCOMP_TANXZ 984
|
||||
|
||||
#define EPR_DISTORTION_CORRECTION_ENABLED 988
|
||||
#define EPR_RETRACTION_LENGTH 992
|
||||
#define EPR_RETRACTION_LONG_LENGTH 996
|
||||
#define EPR_RETRACTION_SPEED 1000
|
||||
#define EPR_RETRACTION_Z_LIFT 1004
|
||||
#define EPR_RETRACTION_UNDO_EXTRA_LENGTH 1008
|
||||
#define EPR_DISTORTION_CORRECTION_ENABLED 988
|
||||
#define EPR_RETRACTION_LENGTH 992
|
||||
#define EPR_RETRACTION_LONG_LENGTH 996
|
||||
#define EPR_RETRACTION_SPEED 1000
|
||||
#define EPR_RETRACTION_Z_LIFT 1004
|
||||
#define EPR_RETRACTION_UNDO_EXTRA_LENGTH 1008
|
||||
#define EPR_RETRACTION_UNDO_EXTRA_LONG_LENGTH 1012
|
||||
#define EPR_RETRACTION_UNDO_SPEED 1016
|
||||
#define EPR_AUTORETRACT_ENABLED 1020
|
||||
#define EPR_RETRACTION_UNDO_SPEED 1016
|
||||
#define EPR_AUTORETRACT_ENABLED 1020
|
||||
#define EPR_Z_PROBE_Z_OFFSET 1024
|
||||
#define EPR_SELECTED_LANGUAGE 1028
|
||||
#define EPR_ACCELERATION_FACTOR_TOP 1032
|
||||
#define EPR_BENDING_CORRECTION_A 1036
|
||||
#define EPR_BENDING_CORRECTION_B 1040
|
||||
#define EPR_BENDING_CORRECTION_C 1044
|
||||
|
||||
#if EEPROM_MODE != 0
|
||||
#define EEPROM_FLOAT(x) HAL::eprGetFloat(EPR_##x)
|
||||
|
@ -128,9 +134,9 @@ have problems with other modules using the eeprom */
|
|||
#define EEPROM_BYTE(x) HAL::eprGetByte(EPR_##x)
|
||||
#define EEPROM_SET_BYTE(x,val) HAL::eprSetByte(EPR_##x,val)
|
||||
#else
|
||||
#define EEPROM_FLOAT(x) (x)
|
||||
#define EEPROM_INT32(x) (x)
|
||||
#define EEPROM_BYTE(x) (x)
|
||||
#define EEPROM_FLOAT(x) (float)(x)
|
||||
#define EEPROM_INT32(x) (int32_t)(x)
|
||||
#define EEPROM_BYTE(x) (uint8_t)(x)
|
||||
#define EEPROM_SET_BYTE(x,val)
|
||||
#endif
|
||||
|
||||
|
@ -189,7 +195,26 @@ public:
|
|||
static void writeSettings();
|
||||
static void update(GCode *com);
|
||||
static void updatePrinterUsage();
|
||||
|
||||
static inline void setVersion(uint8_t v) {
|
||||
#if EEPROM_MODE != 0
|
||||
HAL::eprSetByte(EPR_VERSION,v);
|
||||
HAL::eprSetByte(EPR_INTEGRITY_BYTE,computeChecksum());
|
||||
#endif
|
||||
}
|
||||
static inline uint8_t getStoredLanguage() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetByte(EPR_SELECTED_LANGUAGE);
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
static inline float zProbeZOffset() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
|
||||
#else
|
||||
return Z_PROBE_Z_OFFSET;
|
||||
#endif
|
||||
}
|
||||
static inline float zProbeSpeed() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetFloat(EPR_Z_PROBE_SPEED);
|
||||
|
@ -516,7 +541,34 @@ static inline void setTowerZFloor(float newZ) {
|
|||
return 0;
|
||||
#endif
|
||||
}
|
||||
static inline float bendingCorrectionA() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetFloat(EPR_BENDING_CORRECTION_A);
|
||||
#else
|
||||
return BENDING_CORRECTION_A;
|
||||
#endif
|
||||
}
|
||||
static inline float bendingCorrectionB() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetFloat(EPR_BENDING_CORRECTION_B);
|
||||
#else
|
||||
return BENDING_CORRECTION_B;
|
||||
#endif
|
||||
}
|
||||
static inline float bendingCorrectionC() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetFloat(EPR_BENDING_CORRECTION_C);
|
||||
#else
|
||||
return BENDING_CORRECTION_C;
|
||||
#endif
|
||||
}
|
||||
static inline float accelarationFactorTop() {
|
||||
#if EEPROM_MODE != 0
|
||||
return HAL::eprGetFloat(EPR_ACCELERATION_FACTOR_TOP);
|
||||
#else
|
||||
return ACCELERATION_FACTOR_TOP;
|
||||
#endif
|
||||
}
|
||||
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
@ -50,6 +50,21 @@ Each of the following events describe the parameter and when it is called.
|
|||
// Gets called if a nextPrevius actions gets executed.
|
||||
#define EVENT_START_NEXTPREVIOUS(action,increment) {}
|
||||
|
||||
// Called to initalize laser pins. Return false to prevent default initalization.
|
||||
#define EVENT_INITALIZE_LASER true
|
||||
// Set laser to intensity level 0 = off, 255 = full. Return false if you have overridden the setting routine.
|
||||
// with true the default solution will set it as digital value.
|
||||
#define EVENT_SET_LASER(intensity) true
|
||||
|
||||
// Called to initalize cnc pins. Return false to prevent default initalization.
|
||||
#define EVENT_INITALIZE_CNC true
|
||||
// Turn off spindle
|
||||
#define EVENT_SPINDLE_OFF true
|
||||
// Turn spindle clockwise
|
||||
#define EVENT_SPINDLE_CW(rpm) true
|
||||
// Turn spindle counter clockwise
|
||||
#define EVENT_SPINDLE_CCW(rpm) true
|
||||
|
||||
// Allow adding new G and M codes. To implement it create a function
|
||||
// bool eventUnhandledGCode(GCode *com)
|
||||
// that returns true if it handled the code, otherwise false.
|
||||
|
@ -67,5 +82,3 @@ Each of the following events describe the parameter and when it is called.
|
|||
#define EVENT_INITIALIZE {}
|
||||
|
||||
#endif // EVENTS_H_INCLUDED
|
||||
|
||||
|
||||
|
|
|
@ -66,11 +66,35 @@ void Extruder::manageTemperatures()
|
|||
HAL::pingWatchdog();
|
||||
#endif // FEATURE_WATCHDOG
|
||||
uint8_t errorDetected = 0;
|
||||
#ifdef RED_BLUE_STATUS_LEDS
|
||||
bool hot = false;
|
||||
#endif
|
||||
bool newDefectFound = false;
|
||||
millis_t time = HAL::timeInMilliseconds(); // compare time for decouple tests
|
||||
#if NUM_TEMPERATURE_LOOPS > 0
|
||||
for(uint8_t controller = 0; controller < NUM_TEMPERATURE_LOOPS; controller++)
|
||||
{
|
||||
TemperatureController *act = tempController[controller];
|
||||
// Get Temperature
|
||||
act->updateCurrentTemperature();
|
||||
#if FAN_THERMO_PIN > -1
|
||||
// Special case thermistor controlled fan
|
||||
if(act == &thermoController) {
|
||||
if(act->currentTemperatureC < Printer::thermoMinTemp)
|
||||
pwm_pos[PWM_FAN_THERMO] = 0;
|
||||
else if(act->currentTemperatureC > Printer::thermoMaxTemp)
|
||||
pwm_pos[PWM_FAN_THERMO] = FAN_THERMO_MAX_PWM;
|
||||
else {
|
||||
// Interpolate target speed
|
||||
float out = FAN_THERMO_MIN_PWM + (FAN_THERMO_MAX_PWM-FAN_THERMO_MIN_PWM) * (act->currentTemperatureC - Printer::thermoMinTemp) / (Printer::thermoMaxTemp - Printer::thermoMinTemp);
|
||||
if(out > 255)
|
||||
pwm_pos[PWM_FAN_THERMO] = FAN_THERMO_MAX_PWM;
|
||||
else
|
||||
pwm_pos[PWM_FAN_THERMO] = static_cast<uint8_t>(out);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
// Handle automatic cooling of extruders
|
||||
if(controller < NUM_EXTRUDER)
|
||||
{
|
||||
|
@ -87,25 +111,22 @@ void Extruder::manageTemperatures()
|
|||
}
|
||||
}
|
||||
#if SHARED_COOLER_BOARD_EXT
|
||||
if(pwm_pos[NUM_EXTRUDER + 1]) enable = true;
|
||||
if(pwm_pos[PWM_BOARD_FAN]) enable = true;
|
||||
#endif
|
||||
extruder[0].coolerPWM = (enable ? extruder[0].coolerSpeed : 0);
|
||||
}
|
||||
} // controller == 0
|
||||
#else
|
||||
if(act->currentTemperatureC < EXTRUDER_FAN_COOL_TEMP && act->targetTemperatureC < EXTRUDER_FAN_COOL_TEMP)
|
||||
extruder[controller].coolerPWM = 0;
|
||||
else
|
||||
extruder[controller].coolerPWM = extruder[controller].coolerSpeed;
|
||||
#endif // NUM_EXTRUDER
|
||||
}
|
||||
} // extruder controller
|
||||
// do skip temperature control while auto tuning is in progress
|
||||
if(controller == autotuneIndex) continue;
|
||||
#if MIXING_EXTRUDER
|
||||
if(controller > 0 && controller < NUM_EXTRUDER) continue; // Mixing extruder only test for ext 0
|
||||
#endif
|
||||
|
||||
// Get Temperature
|
||||
act->updateCurrentTemperature();
|
||||
#endif // MIXING_EXTRUDER
|
||||
|
||||
|
||||
// Check for obvious sensor errors
|
||||
|
@ -119,14 +140,36 @@ void Extruder::manageTemperatures()
|
|||
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDEFECT;
|
||||
if(!Printer::isAnyTempsensorDefect())
|
||||
{
|
||||
newDefectFound = true;
|
||||
Printer::setAnyTempsensorDefect();
|
||||
reportTempsensorError();
|
||||
}
|
||||
EVENT_HEATER_DEFECT(controller);
|
||||
}
|
||||
}
|
||||
#if HAVE_HEATED_BED
|
||||
else if(controller == NUM_EXTRUDER && Extruder::getHeatedBedTemperature() > HEATED_BED_MAX_TEMP + 5) {
|
||||
errorDetected = 1;
|
||||
if(extruderTempErrors < 10) // Ignore short temporary failures
|
||||
extruderTempErrors++;
|
||||
else
|
||||
{
|
||||
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDEFECT;
|
||||
Com::printErrorFLN(PSTR("Heated bed exceeded max temperature!"));
|
||||
if(!Printer::isAnyTempsensorDefect())
|
||||
{
|
||||
newDefectFound = true;
|
||||
Printer::setAnyTempsensorDefect();
|
||||
reportTempsensorError();
|
||||
}
|
||||
EVENT_HEATER_DEFECT(controller);
|
||||
}
|
||||
}
|
||||
#endif // HAVE_HEATED_BED
|
||||
#ifdef RED_BLUE_STATUS_LEDS
|
||||
if(act->currentTemperatureC > 50)
|
||||
hot = true;
|
||||
#endif // RED_BLUE_STATUS_LEDS
|
||||
if(Printer::isAnyTempsensorDefect()) continue;
|
||||
uint8_t on = act->currentTemperatureC >= act->targetTemperatureC ? LOW : HIGH;
|
||||
// Make a sound if alarm was set on reaching target temperature
|
||||
|
@ -137,7 +180,7 @@ void Extruder::manageTemperatures()
|
|||
}
|
||||
|
||||
// Run test if heater and sensor are decoupled
|
||||
bool decoupleTestRequired = act->decoupleTestPeriod > 0 && (time - act->lastDecoupleTest) > act->decoupleTestPeriod; // time enough for temperature change?
|
||||
bool decoupleTestRequired = !errorDetected && act->decoupleTestPeriod > 0 && (time - act->lastDecoupleTest) > act->decoupleTestPeriod; // time enough for temperature change?
|
||||
if(decoupleTestRequired && act->isDecoupleFullOrHold() && Printer::isPowerOn()) // Only test when powered
|
||||
{
|
||||
if(act->isDecoupleFull()) // Phase 1: Heating fully until target range is reached
|
||||
|
@ -149,7 +192,12 @@ void Extruder::manageTemperatures()
|
|||
if(extruderTempErrors > 10) // Ignore short temporary failures
|
||||
{
|
||||
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED;
|
||||
Printer::setAnyTempsensorDefect();
|
||||
|
||||
if(!Printer::isAnyTempsensorDefect())
|
||||
{
|
||||
Printer::setAnyTempsensorDefect();
|
||||
newDefectFound = true;
|
||||
}
|
||||
UI_ERROR_P(Com::tHeaterDecoupled);
|
||||
Com::printErrorFLN(Com::tHeaterDecoupledWarning);
|
||||
Com::printF(PSTR("Error:Temp. raised to slow. Rise = "),act->currentTemperatureC - act->lastDecoupleTemp);
|
||||
|
@ -173,7 +221,11 @@ void Extruder::manageTemperatures()
|
|||
if(extruderTempErrors > 10) // Ignore short temporary failures
|
||||
{
|
||||
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED;
|
||||
Printer::setAnyTempsensorDefect();
|
||||
if(!Printer::isAnyTempsensorDefect())
|
||||
{
|
||||
Printer::setAnyTempsensorDefect();
|
||||
newDefectFound = true;
|
||||
}
|
||||
UI_ERROR_P(Com::tHeaterDecoupled);
|
||||
Com::printErrorFLN(Com::tHeaterDecoupledWarning);
|
||||
Com::printF(PSTR("Error:Could not hold temperature "),act->lastDecoupleTemp);
|
||||
|
@ -218,7 +270,7 @@ void Extruder::manageTemperatures()
|
|||
pidTerm += dgain;
|
||||
#if SCALE_PID_TO_MAX == 1
|
||||
pidTerm = (pidTerm * act->pidMax) * 0.0039215;
|
||||
#endif
|
||||
#endif // SCALE_PID_TO_MAX
|
||||
output = constrain((int)pidTerm, 0, act->pidMax);
|
||||
}
|
||||
else if(act->heatManager == HTR_DEADTIME) // dead-time control
|
||||
|
@ -229,7 +281,7 @@ void Extruder::manageTemperatures()
|
|||
output = (act->currentTemperatureC + act->tempIState * act->deadTime > act->targetTemperatureC ? 0 : act->pidDriveMax);
|
||||
}
|
||||
else // bang bang and slow bang bang
|
||||
#endif
|
||||
#endif // TEMP_PID
|
||||
if(act->heatManager == HTR_SLOWBANG) // Bang-bang with reduced change frequency to save relais life
|
||||
{
|
||||
if (time - act->lastTemperatureUpdate > HEATED_BED_SET_INTERVAL)
|
||||
|
@ -251,19 +303,22 @@ void Extruder::manageTemperatures()
|
|||
#ifdef MAXTEMP
|
||||
if(act->currentTemperatureC > MAXTEMP) // Force heater off if MAXTEMP is exceeded
|
||||
output = 0;
|
||||
#endif
|
||||
#endif // MAXTEMP
|
||||
pwm_pos[act->pwmIndex] = output; // set pwm signal
|
||||
#if LED_PIN > -1
|
||||
if(act == &Extruder::current->tempControl)
|
||||
WRITE(LED_PIN,on);
|
||||
#endif
|
||||
#endif // LED_PIN
|
||||
} // for controller
|
||||
|
||||
#ifdef RED_BLUE_STATUS_LEDS
|
||||
if(Printer::isAnyTempsensorDefect()) {
|
||||
if(Printer::isAnyTempsensorDefect())
|
||||
{
|
||||
WRITE(BLUE_STATUS_LED,HIGH);
|
||||
WRITE(RED_STATUS_LED,HIGH);
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
WRITE(BLUE_STATUS_LED,!hot);
|
||||
WRITE(RED_STATUS_LED,hot);
|
||||
}
|
||||
|
@ -271,14 +326,12 @@ void Extruder::manageTemperatures()
|
|||
|
||||
if(errorDetected == 0 && extruderTempErrors > 0)
|
||||
extruderTempErrors--;
|
||||
if(Printer::isAnyTempsensorDefect()
|
||||
#if HAVE_HEATED_BED
|
||||
|| Extruder::getHeatedBedTemperature() > HEATED_BED_MAX_TEMP + 5
|
||||
#endif
|
||||
)
|
||||
if(newDefectFound)
|
||||
{
|
||||
Com::printFLN(PSTR("Disabling all heaters due to detected sensor defect."));
|
||||
for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
|
||||
{
|
||||
tempController[i]->targetTemperatureC = 0;
|
||||
pwm_pos[tempController[i]->pwmIndex] = 0;
|
||||
}
|
||||
#if defined(KILL_IF_SENSOR_DEFECT) && KILL_IF_SENSOR_DEFECT > 0
|
||||
|
@ -286,12 +339,13 @@ void Extruder::manageTemperatures()
|
|||
{
|
||||
#if SDSUPPORT
|
||||
sd.stopPrint();
|
||||
#endif
|
||||
#endif // SDSUPPORT
|
||||
Printer::kill(0);
|
||||
}
|
||||
#endif
|
||||
Printer::debugLevel |= 8; // Go into dry mode
|
||||
}
|
||||
#endif // KILL_IF_SENSOR_DEFECT
|
||||
Printer::debugSet(8); // Go into dry mode
|
||||
} // any sensor defect
|
||||
#endif // NUM_TEMPERATURE_LOOPS
|
||||
|
||||
}
|
||||
|
||||
|
@ -509,7 +563,7 @@ void TemperatureController::updateTempControlVars()
|
|||
|
||||
/** \brief Select extruder ext_num.
|
||||
|
||||
This function changes and initalizes a new extruder. This is also called, after the eeprom values are changed.
|
||||
This function changes and initializes a new extruder. This is also called, after the eeprom values are changed.
|
||||
*/
|
||||
void Extruder::selectExtruderById(uint8_t extruderId)
|
||||
{
|
||||
|
@ -520,10 +574,14 @@ void Extruder::selectExtruderById(uint8_t extruderId)
|
|||
activeMixingExtruder = extruderId;
|
||||
for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
|
||||
Extruder::setMixingWeight(i, extruder[i].virtualWeights[extruderId]);
|
||||
Com::printFLN(PSTR("SelectExtruder:"),static_cast<int>(extruderId));
|
||||
extruderId = 0;
|
||||
#endif
|
||||
if(extruderId >= NUM_EXTRUDER)
|
||||
extruderId = 0;
|
||||
#if !MIXING_EXTRUDER
|
||||
Com::printFLN(PSTR("SelectExtruder:"),static_cast<int>(extruderId));
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 1 && MIXING_EXTRUDER == 0
|
||||
bool executeSelect = false;
|
||||
if(extruderId != Extruder::current->id)
|
||||
|
@ -536,19 +594,23 @@ void Extruder::selectExtruderById(uint8_t extruderId)
|
|||
Extruder::current->extrudePosition = Printer::currentPositionSteps[E_AXIS];
|
||||
Extruder::current = &extruder[extruderId];
|
||||
#ifdef SEPERATE_EXTRUDER_POSITIONS
|
||||
// Use seperate extruder positions only if beeing told. Slic3r e.g. creates a continuous extruder position increment
|
||||
// Use separate extruder positions only if being told. Slic3r e.g. creates a continuous extruder position increment
|
||||
Printer::currentPositionSteps[E_AXIS] = Extruder::current->extrudePosition;
|
||||
#endif
|
||||
Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS];
|
||||
Printer::axisStepsPerMM[E_AXIS] = Extruder::current->stepsPerMM;
|
||||
Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS];
|
||||
#if MIXING_EXTRUDER
|
||||
recomputeMixingExtruderSteps();
|
||||
#else
|
||||
Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS];
|
||||
Printer::axisStepsPerMM[E_AXIS] = Extruder::current->stepsPerMM;
|
||||
Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS];
|
||||
#endif
|
||||
Printer::maxFeedrate[E_AXIS] = Extruder::current->maxFeedrate;
|
||||
// max_start_speed_units_per_second[E_AXIS] = Extruder::current->maxStartFeedrate;
|
||||
Printer::maxAccelerationMMPerSquareSecond[E_AXIS] = Printer::maxTravelAccelerationMMPerSquareSecond[E_AXIS] = Extruder::current->maxAcceleration;
|
||||
Printer::maxTravelAccelerationStepsPerSquareSecond[E_AXIS] =
|
||||
Printer::maxPrintAccelerationStepsPerSquareSecond[E_AXIS] = Printer::maxAccelerationMMPerSquareSecond[E_AXIS] * Printer::axisStepsPerMM[E_AXIS];
|
||||
#if USE_ADVANCE
|
||||
Printer::maxExtruderSpeed = (uint8_t)floor(HAL::maxExtruderTimerFrequency() / (Extruder::current->maxFeedrate*Extruder::current->stepsPerMM));
|
||||
Printer::maxExtruderSpeed = (ufast8_t)floor(HAL::maxExtruderTimerFrequency() / (Extruder::current->maxFeedrate * Extruder::current->stepsPerMM));
|
||||
#if CPU_ARCH == ARCH_ARM
|
||||
if(Printer::maxExtruderSpeed > 40) Printer::maxExtruderSpeed = 40;
|
||||
#else
|
||||
|
@ -581,9 +643,25 @@ void Extruder::selectExtruderById(uint8_t extruderId)
|
|||
#endif
|
||||
#endif
|
||||
}
|
||||
#if MIXING_EXTRUDER
|
||||
void Extruder::recomputeMixingExtruderSteps() {
|
||||
int32_t sum_w = 0;
|
||||
float sum = 0;
|
||||
for(fast8_t i = 0; i < NUM_EXTRUDER; i++) {
|
||||
sum_w += extruder[i].mixingW;
|
||||
sum += extruder[i].stepsPerMM * extruder[i].mixingW;
|
||||
}
|
||||
sum /= sum_w;
|
||||
Printer::currentPositionSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS] * sum / Printer::axisStepsPerMM[E_AXIS]; // reposition according resolution change
|
||||
Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS];
|
||||
Printer::axisStepsPerMM[E_AXIS] = sum;
|
||||
Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS];
|
||||
}
|
||||
#endif
|
||||
|
||||
void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t extr, bool beep, bool wait)
|
||||
{
|
||||
#if NUM_EXTRUDER > 0
|
||||
#if MIXING_EXTRUDER
|
||||
extr = 0; // map any virtual extruder number to 0
|
||||
#endif // MIXING_EXTRUDER
|
||||
|
@ -609,12 +687,14 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
|
|||
{
|
||||
TemperatureController *tc2 = tempController[1];
|
||||
tc2->setTargetTemperature(temperatureInCelsius);
|
||||
tc2->updateTempControlVars();
|
||||
if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[1].coolerPWM = extruder[1].coolerSpeed;
|
||||
#if NUM_EXTRUDER > 2
|
||||
if(Extruder::dittoMode > 1 && extr == 0)
|
||||
{
|
||||
TemperatureController *tc2 = tempController[2];
|
||||
tc2->setTargetTemperature(temperatureInCelsius);
|
||||
tc2->updateTempControlVars();
|
||||
if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[2].coolerPWM = extruder[2].coolerSpeed;
|
||||
}
|
||||
#endif
|
||||
|
@ -623,6 +703,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
|
|||
{
|
||||
TemperatureController *tc2 = tempController[3];
|
||||
tc2->setTargetTemperature(temperatureInCelsius);
|
||||
tc2->updateTempControlVars();
|
||||
if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[3].coolerPWM = extruder[3].coolerSpeed;
|
||||
}
|
||||
#endif
|
||||
|
@ -635,7 +716,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
|
|||
)
|
||||
{
|
||||
Extruder *actExtruder = &extruder[extr];
|
||||
UI_STATUS_UPD(UI_TEXT_HEATING_EXTRUDER);
|
||||
UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_HEATING_EXTRUDER_ID));
|
||||
EVENT_WAITING_HEATER(actExtruder->id);
|
||||
bool dirRising = actExtruder->tempControl.targetTemperature > actExtruder->tempControl.currentTemperature;
|
||||
millis_t printedTime = HAL::timeInMilliseconds();
|
||||
|
@ -696,6 +777,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
|
|||
Printer::filamentPrinted = 0; // new print, new counter
|
||||
Printer::flag2 &= ~PRINTER_FLAG2_RESET_FILAMENT_USAGE;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void Extruder::setHeatedBedTemperature(float temperatureInCelsius,bool beep)
|
||||
|
@ -708,9 +790,9 @@ void Extruder::setHeatedBedTemperature(float temperatureInCelsius,bool beep)
|
|||
if(beep && temperatureInCelsius>30) heatedBedController.setAlarm(true);
|
||||
Com::printFLN(Com::tTargetBedColon,heatedBedController.targetTemperatureC,0);
|
||||
if(temperatureInCelsius > 15)
|
||||
pwm_pos[NUM_EXTRUDER + 1] = 255; // turn on the mainboard cooling fan
|
||||
pwm_pos[PWM_BOARD_FAN] = 255; // turn on the mainboard cooling fan
|
||||
else if(Printer::areAllSteppersDisabled())
|
||||
pwm_pos[NUM_EXTRUDER + 1] = 0; // turn off the mainboard cooling fan only if steppers disabled
|
||||
pwm_pos[PWM_BOARD_FAN] = 0; // turn off the mainboard cooling fan only if steppers disabled
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -738,6 +820,45 @@ void Extruder::setMixingWeight(uint8_t extr,int weight)
|
|||
}
|
||||
void Extruder::step()
|
||||
{
|
||||
if(PrintLine::cur != NULL && PrintLine::cur->isAllEMotors()) {
|
||||
#if NUM_EXTRUDER > 0
|
||||
WRITE(EXT0_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(0)
|
||||
#endif
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 1
|
||||
WRITE(EXT1_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(1)
|
||||
#endif
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 2
|
||||
WRITE(EXT2_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(2)
|
||||
#endif
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 3
|
||||
WRITE(EXT3_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(3)
|
||||
#endif
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 4
|
||||
WRITE(EXT4_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(4)
|
||||
#endif
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 5
|
||||
WRITE(EXT5_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(5)
|
||||
#endif
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
uint8_t best = 255,i;
|
||||
int bestError;
|
||||
if(mixingDir)
|
||||
|
@ -775,7 +896,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 0
|
||||
if(best == 0)
|
||||
{
|
||||
WRITE(EXT0_STEP_PIN, HIGH);
|
||||
WRITE(EXT0_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(0)
|
||||
#endif
|
||||
|
@ -784,7 +905,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 1
|
||||
if(best == 1)
|
||||
{
|
||||
WRITE(EXT1_STEP_PIN, HIGH);
|
||||
WRITE(EXT1_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(1)
|
||||
#endif
|
||||
|
@ -793,7 +914,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 2
|
||||
if(best == 2)
|
||||
{
|
||||
WRITE(EXT2_STEP_PIN, HIGH);
|
||||
WRITE(EXT2_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(2)
|
||||
#endif
|
||||
|
@ -802,7 +923,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 3
|
||||
if(best == 3)
|
||||
{
|
||||
WRITE(EXT3_STEP_PIN, HIGH);
|
||||
WRITE(EXT3_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(3)
|
||||
#endif
|
||||
|
@ -811,7 +932,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 4
|
||||
if(best == 4)
|
||||
{
|
||||
WRITE(EXT4_STEP_PIN, HIGH);
|
||||
WRITE(EXT4_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(4)
|
||||
#endif
|
||||
|
@ -820,7 +941,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 5
|
||||
if(best == 5)
|
||||
{
|
||||
WRITE(EXT5_STEP_PIN, HIGH);
|
||||
WRITE(EXT5_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(5)
|
||||
#endif
|
||||
|
@ -831,22 +952,22 @@ void Extruder::step()
|
|||
void Extruder::unstep()
|
||||
{
|
||||
#if NUM_EXTRUDER > 0
|
||||
WRITE(EXT0_STEP_PIN, LOW);
|
||||
WRITE(EXT0_STEP_PIN, !START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 1
|
||||
WRITE(EXT1_STEP_PIN, LOW);
|
||||
WRITE(EXT1_STEP_PIN, !START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 2
|
||||
WRITE(EXT2_STEP_PIN, LOW);
|
||||
WRITE(EXT2_STEP_PIN, !START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 3
|
||||
WRITE(EXT3_STEP_PIN, LOW);
|
||||
WRITE(EXT3_STEP_PIN, !START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 4
|
||||
WRITE(EXT4_STEP_PIN, LOW);
|
||||
WRITE(EXT4_STEP_PIN, !START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 5
|
||||
WRITE(EXT5_STEP_PIN, LOW);
|
||||
WRITE(EXT5_STEP_PIN, !START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -925,7 +1046,7 @@ Call this function only, if interrupts are disabled.
|
|||
void Extruder::step()
|
||||
{
|
||||
#if NUM_EXTRUDER == 1
|
||||
WRITE(EXT0_STEP_PIN, HIGH);
|
||||
WRITE(EXT0_STEP_PIN, START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(0)
|
||||
#endif
|
||||
|
@ -934,21 +1055,21 @@ void Extruder::step()
|
|||
{
|
||||
case 0:
|
||||
#if NUM_EXTRUDER > 0
|
||||
WRITE(EXT0_STEP_PIN,HIGH);
|
||||
WRITE(EXT0_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(0)
|
||||
#endif
|
||||
#if FEATURE_DITTO_PRINTING
|
||||
if(Extruder::dittoMode)
|
||||
{
|
||||
WRITE(EXT1_STEP_PIN,HIGH);
|
||||
WRITE(EXT1_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(1)
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 2
|
||||
if(Extruder::dittoMode > 1)
|
||||
{
|
||||
WRITE(EXT2_STEP_PIN,HIGH);
|
||||
WRITE(EXT2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(2)
|
||||
#endif
|
||||
|
@ -957,7 +1078,7 @@ void Extruder::step()
|
|||
#if NUM_EXTRUDER > 3
|
||||
if(Extruder::dittoMode > 2)
|
||||
{
|
||||
WRITE(EXT3_STEP_PIN,HIGH);
|
||||
WRITE(EXT3_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(3)
|
||||
#endif
|
||||
|
@ -969,7 +1090,7 @@ void Extruder::step()
|
|||
break;
|
||||
#if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1
|
||||
case 1:
|
||||
WRITE(EXT1_STEP_PIN,HIGH);
|
||||
WRITE(EXT1_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(1)
|
||||
#endif
|
||||
|
@ -977,7 +1098,7 @@ void Extruder::step()
|
|||
#endif
|
||||
#if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2
|
||||
case 2:
|
||||
WRITE(EXT2_STEP_PIN,HIGH);
|
||||
WRITE(EXT2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(2)
|
||||
#endif
|
||||
|
@ -985,7 +1106,7 @@ void Extruder::step()
|
|||
#endif
|
||||
#if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3
|
||||
case 3:
|
||||
WRITE(EXT3_STEP_PIN,HIGH);
|
||||
WRITE(EXT3_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(3)
|
||||
#endif
|
||||
|
@ -993,7 +1114,7 @@ void Extruder::step()
|
|||
#endif
|
||||
#if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4
|
||||
case 4:
|
||||
WRITE(EXT4_STEP_PIN,HIGH);
|
||||
WRITE(EXT4_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(4)
|
||||
#endif
|
||||
|
@ -1001,7 +1122,7 @@ void Extruder::step()
|
|||
#endif
|
||||
#if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5
|
||||
case 5:
|
||||
WRITE(EXT5_STEP_PIN,HIGH);
|
||||
WRITE(EXT5_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
|
||||
TEST_EXTRUDER_JAM(5)
|
||||
#endif
|
||||
|
@ -1019,27 +1140,27 @@ Call this function only, if interrupts are disabled.
|
|||
void Extruder::unstep()
|
||||
{
|
||||
#if NUM_EXTRUDER == 1
|
||||
WRITE(EXT0_STEP_PIN,LOW);
|
||||
WRITE(EXT0_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#else
|
||||
switch(Extruder::current->id)
|
||||
{
|
||||
case 0:
|
||||
#if NUM_EXTRUDER > 0
|
||||
WRITE(EXT0_STEP_PIN,LOW);
|
||||
WRITE(EXT0_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#if FEATURE_DITTO_PRINTING
|
||||
if(Extruder::dittoMode)
|
||||
{
|
||||
WRITE(EXT1_STEP_PIN,LOW);
|
||||
WRITE(EXT1_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#if NUM_EXTRUDER > 2
|
||||
if(Extruder::dittoMode > 1)
|
||||
{
|
||||
WRITE(EXT2_STEP_PIN,LOW);
|
||||
WRITE(EXT2_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
}
|
||||
#endif
|
||||
#if NUM_EXTRUDER > 3
|
||||
if(Extruder::dittoMode > 2)
|
||||
{
|
||||
WRITE(EXT3_STEP_PIN,LOW);
|
||||
WRITE(EXT3_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
}
|
||||
#endif // NUM_EXTRUDER > 3
|
||||
}
|
||||
|
@ -1048,27 +1169,27 @@ void Extruder::unstep()
|
|||
break;
|
||||
#if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1
|
||||
case 1:
|
||||
WRITE(EXT1_STEP_PIN,LOW);
|
||||
WRITE(EXT1_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2
|
||||
case 2:
|
||||
WRITE(EXT2_STEP_PIN,LOW);
|
||||
WRITE(EXT2_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3
|
||||
case 3:
|
||||
WRITE(EXT3_STEP_PIN,LOW);
|
||||
WRITE(EXT3_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4
|
||||
case 4:
|
||||
WRITE(EXT4_STEP_PIN,LOW);
|
||||
WRITE(EXT4_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5
|
||||
case 5:
|
||||
WRITE(EXT5_STEP_PIN,LOW);
|
||||
WRITE(EXT5_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
@ -1283,7 +1404,7 @@ const short temptable_4[NUMTEMPS_4][2] PROGMEM =
|
|||
{478*4, 46*8},{531*4, 41*8},{584*4, 35*8},{637*4, 30*8},{690*4, 25*8},{743*4, 20*8},{796*4, 14*8},{849*4, 7*8},{902*4, 0*8},
|
||||
{955*4, -11*8},{1008*4, -35*8}
|
||||
};
|
||||
|
||||
// ATC 104GT
|
||||
#define NUMTEMPS_8 34
|
||||
const short temptable_8[NUMTEMPS_8][2] PROGMEM =
|
||||
{
|
||||
|
@ -1325,6 +1446,12 @@ const short temptable_12[NUMTEMPS_12][2] PROGMEM =
|
|||
{351*4, 140*8},{386*4, 134*8},{421*4, 128*8},{456*4, 122*8},{491*4, 117*8},{526*4, 112*8},{561*4, 107*8},{596*4, 102*8},{631*4, 97*8},{666*4, 91*8},
|
||||
{701*4, 86*8},{736*4, 81*8},{771*4, 76*8},{806*4, 70*8},{841*4, 63*8},{876*4, 56*8},{911*4, 48*8},{946*4, 38*8},{981*4, 23*8},{1005*4, 5*8},{1016*4, 0*8}
|
||||
};
|
||||
#define NUMTEMPS_13 19
|
||||
const short temptable_13[NUMTEMPS_13][2] PROGMEM =
|
||||
{
|
||||
{0,0},{908,8},{942,10*8},{982,20*8},{1015,8*30},{1048,8*40},{1080,8*50},{1113,8*60},{1146,8*70},{1178,8*80},{1211,8*90},{1276,8*110},{1318,8*120}
|
||||
,{1670,8*230},{2455,8*500},{3445,8*900},{3666,8*1000},{3871,8*1100},{4095,8*2000}
|
||||
};
|
||||
#if NUM_TEMPS_USERTHERMISTOR0 > 0
|
||||
const short temptable_5[NUM_TEMPS_USERTHERMISTOR0][2] PROGMEM = USER_THERMISTORTABLE0 ;
|
||||
#endif
|
||||
|
@ -1334,7 +1461,7 @@ const short temptable_6[NUM_TEMPS_USERTHERMISTOR1][2] PROGMEM = USER_THERMISTORT
|
|||
#if NUM_TEMPS_USERTHERMISTOR2 > 0
|
||||
const short temptable_7[NUM_TEMPS_USERTHERMISTOR2][2] PROGMEM = USER_THERMISTORTABLE2 ;
|
||||
#endif
|
||||
const short * const temptables[12] PROGMEM = {(short int *)&temptable_1[0][0],(short int *)&temptable_2[0][0],(short int *)&temptable_3[0][0],(short int *)&temptable_4[0][0]
|
||||
const short * const temptables[13] PROGMEM = {(short int *)&temptable_1[0][0],(short int *)&temptable_2[0][0],(short int *)&temptable_3[0][0],(short int *)&temptable_4[0][0]
|
||||
#if NUM_TEMPS_USERTHERMISTOR0 > 0
|
||||
,(short int *)&temptable_5[0][0]
|
||||
#else
|
||||
|
@ -1355,9 +1482,10 @@ const short * const temptables[12] PROGMEM = {(short int *)&temptable_1[0][0],(s
|
|||
,(short int *)&temptable_10[0][0]
|
||||
,(short int *)&temptable_11[0][0]
|
||||
,(short int *)&temptable_12[0][0]
|
||||
,(short int *)&temptable_13[0][0]
|
||||
};
|
||||
const uint8_t temptables_num[12] PROGMEM = {NUMTEMPS_1,NUMTEMPS_2,NUMTEMPS_3,NUMTEMPS_4,NUM_TEMPS_USERTHERMISTOR0,NUM_TEMPS_USERTHERMISTOR1,NUM_TEMPS_USERTHERMISTOR2,NUMTEMPS_8,
|
||||
NUMTEMPS_9,NUMTEMPS_10,NUMTEMPS_11,NUMTEMPS_12
|
||||
const uint8_t temptables_num[13] PROGMEM = {NUMTEMPS_1,NUMTEMPS_2,NUMTEMPS_3,NUMTEMPS_4,NUM_TEMPS_USERTHERMISTOR0,NUM_TEMPS_USERTHERMISTOR1,NUM_TEMPS_USERTHERMISTOR2,NUMTEMPS_8,
|
||||
NUMTEMPS_9,NUMTEMPS_10,NUMTEMPS_11,NUMTEMPS_12,NUMTEMPS_13
|
||||
};
|
||||
|
||||
|
||||
|
@ -1370,7 +1498,7 @@ void TemperatureController::updateCurrentTemperature()
|
|||
case 0:
|
||||
currentTemperature = 25;
|
||||
break;
|
||||
#if ANALOG_INPUTS>0
|
||||
#if ANALOG_INPUTS > 0
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
|
@ -1388,12 +1516,13 @@ void TemperatureController::updateCurrentTemperature()
|
|||
case 99:
|
||||
currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS)); // Convert to 10 bit result
|
||||
break;
|
||||
case 13: // PT100 E3D
|
||||
case 50: // User defined PTC table
|
||||
case 51:
|
||||
case 52:
|
||||
case 60: // HEATER_USES_AD8495 (Delivers 5mV/degC)
|
||||
case 61: // HEATER_USES_AD8495 (Delivers 5mV/degC) 1.25v offset
|
||||
case 100: // AD595
|
||||
case 100: // AD595 / AD597
|
||||
currentTemperature = (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS));
|
||||
break;
|
||||
#endif
|
||||
|
@ -1431,14 +1560,14 @@ void TemperatureController::updateCurrentTemperature()
|
|||
case 12:
|
||||
{
|
||||
type--;
|
||||
uint8_t num = pgm_read_byte(&temptables_num[type])<<1;
|
||||
uint8_t i=2;
|
||||
const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
|
||||
short oldraw = pgm_read_word(&temptable[0]);
|
||||
short oldtemp = pgm_read_word(&temptable[1]);
|
||||
short newraw,newtemp;
|
||||
currentTemperature = (1023<<(2-ANALOG_REDUCE_BITS))-currentTemperature;
|
||||
while(i<num)
|
||||
uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
|
||||
uint8_t i = 2;
|
||||
const int16_t *temptable = (const int16_t *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
|
||||
int16_t oldraw = pgm_read_word(&temptable[0]);
|
||||
int16_t oldtemp = pgm_read_word(&temptable[1]);
|
||||
int16_t newraw,newtemp = 0;
|
||||
currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - currentTemperature;
|
||||
while(i < num)
|
||||
{
|
||||
newraw = pgm_read_word(&temptable[i++]);
|
||||
newtemp = pgm_read_word(&temptable[i++]);
|
||||
|
@ -1446,7 +1575,7 @@ void TemperatureController::updateCurrentTemperature()
|
|||
{
|
||||
//OUT_P_I("RC O:",oldtemp);OUT_P_I_LN(" OR:",oldraw);
|
||||
//OUT_P_I("RC N:",newtemp);OUT_P_I_LN(" NR:",newraw);
|
||||
currentTemperatureC = TEMP_INT_TO_FLOAT(oldtemp + (float)(currentTemperature-oldraw)*(float)(newtemp-oldtemp)/(newraw-oldraw));
|
||||
currentTemperatureC = TEMP_INT_TO_FLOAT(oldtemp + (float)(currentTemperature-oldraw)*(float)(newtemp - oldtemp) / (newraw - oldraw));
|
||||
return;
|
||||
}
|
||||
oldtemp = newtemp;
|
||||
|
@ -1456,18 +1585,22 @@ void TemperatureController::updateCurrentTemperature()
|
|||
currentTemperatureC = TEMP_INT_TO_FLOAT(newtemp);
|
||||
}
|
||||
break;
|
||||
case 13:
|
||||
case 50: // User defined PTC thermistor
|
||||
case 51:
|
||||
case 52:
|
||||
{
|
||||
type-=46;
|
||||
uint8_t num = pgm_read_byte(&temptables_num[type])<<1;
|
||||
uint8_t i=2;
|
||||
const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
|
||||
short oldraw = pgm_read_word(&temptable[0]);
|
||||
short oldtemp = pgm_read_word(&temptable[1]);
|
||||
short newraw,newtemp;
|
||||
while(i<num)
|
||||
if(type > 49)
|
||||
type -= 46;
|
||||
else
|
||||
type--;
|
||||
uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
|
||||
uint8_t i = 2;
|
||||
const int16_t *temptable = (const int16_t *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
|
||||
int16_t oldraw = pgm_read_word(&temptable[0]);
|
||||
int16_t oldtemp = pgm_read_word(&temptable[1]);
|
||||
int16_t newraw,newtemp = 0;
|
||||
while(i < num)
|
||||
{
|
||||
newraw = pgm_read_word(&temptable[i++]);
|
||||
newtemp = pgm_read_word(&temptable[i++]);
|
||||
|
@ -1497,12 +1630,16 @@ void TemperatureController::updateCurrentTemperature()
|
|||
currentTemperatureC = ((float)currentTemperature * 660.0f / (1024 << (2 - ANALOG_REDUCE_BITS))) - 250.0f;
|
||||
#endif
|
||||
break;
|
||||
case 100: // AD595
|
||||
case 100: // AD595 / AD597 10mV/°C
|
||||
//return (int)((long)raw_temp * 500/(1024<<(2-ANALOG_REDUCE_BITS)));
|
||||
#if CPU_ARCH == ARCH_AVR
|
||||
currentTemperatureC = ((float)currentTemperature * 500.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
|
||||
#else
|
||||
#if FEATURE_CONTROLLER == CONTROLLER_LCD_MP_PHARAOH_DUE
|
||||
currentTemperatureC = ((float)currentTemperature * 500.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
|
||||
#else
|
||||
currentTemperatureC = ((float)currentTemperature * 330.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
|
||||
#endif
|
||||
#endif
|
||||
break;
|
||||
#ifdef SUPPORT_MAX6675
|
||||
|
@ -1607,24 +1744,28 @@ void TemperatureController::setTargetTemperature(float target)
|
|||
targetTemperature = (1023<<(2-ANALOG_REDUCE_BITS))-newraw;
|
||||
break;
|
||||
}
|
||||
case 13: // PT100 E3D
|
||||
case 50: // user defined PTC thermistor
|
||||
case 51:
|
||||
case 52:
|
||||
{
|
||||
type -= 46;
|
||||
if(type > 49)
|
||||
type -= 46;
|
||||
else
|
||||
type--;
|
||||
uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
|
||||
uint8_t i = 2;
|
||||
const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word(&temptables[type]);
|
||||
short oldraw = pgm_read_word(&temptable[0]);
|
||||
short oldtemp = pgm_read_word(&temptable[1]);
|
||||
short newraw = 0,newtemp;
|
||||
while(i<num)
|
||||
while(i < num)
|
||||
{
|
||||
newraw = pgm_read_word(&temptable[i++]);
|
||||
newtemp = pgm_read_word(&temptable[i++]);
|
||||
if (newtemp > temp)
|
||||
{
|
||||
targetTemperature = oldraw + (int32_t)(oldtemp-temp) * (int32_t)(oldraw-newraw) / (oldtemp-newtemp);
|
||||
targetTemperature = oldraw + (int32_t)(oldtemp - temp) * (int32_t)(oldraw - newraw) / (oldtemp-newtemp);
|
||||
return;
|
||||
}
|
||||
oldtemp = newtemp;
|
||||
|
@ -1695,13 +1836,15 @@ void TemperatureController::setTargetTemperature(float target)
|
|||
uint8_t autotuneIndex = 255;
|
||||
void Extruder::disableAllHeater()
|
||||
{
|
||||
for(uint8_t i=0; i<NUM_TEMPERATURE_LOOPS; i++)
|
||||
#if NUM_TEMPERATURE_LOOPS > 0
|
||||
for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
|
||||
{
|
||||
TemperatureController *c = tempController[i];
|
||||
c->targetTemperature = 0;
|
||||
c->targetTemperatureC = 0;
|
||||
pwm_pos[c->pwmIndex] = 0;
|
||||
}
|
||||
#endif
|
||||
autotuneIndex = 255;
|
||||
}
|
||||
|
||||
|
@ -1863,6 +2006,7 @@ void writeMonitor()
|
|||
|
||||
bool reportTempsensorError()
|
||||
{
|
||||
#if NUM_TEMPERATURE_LOOPS > 0
|
||||
if(!Printer::isAnyTempsensorDefect()) return false;
|
||||
for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
|
||||
{
|
||||
|
@ -1876,19 +2020,28 @@ bool reportTempsensorError()
|
|||
}
|
||||
Com::printErrorFLN(Com::tDryModeUntilRestart);
|
||||
return true;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef SUPPORT_MAX6675
|
||||
|
||||
int16_t read_max6675(uint8_t ss_pin)
|
||||
{
|
||||
int16_t max6675_temp = 0;
|
||||
HAL::spiInit(2);
|
||||
HAL::digitalWrite(ss_pin, 0); // enable TT_MAX6675
|
||||
HAL::delayMicroseconds(1); // ensure 100ns delay - a bit extra is fine
|
||||
max6675_temp = HAL::spiReceive(0);
|
||||
max6675_temp <<= 8;
|
||||
max6675_temp |= HAL::spiReceive(0);
|
||||
HAL::digitalWrite(ss_pin, 1); // disable TT_MAX6675
|
||||
static millis_t last_max6675_read = 0;
|
||||
static int16_t max6675_temp = 0;
|
||||
if (HAL::timeInMilliseconds() - last_max6675_read > 230)
|
||||
{
|
||||
HAL::spiInit(2);
|
||||
HAL::digitalWrite(ss_pin, 0); // enable TT_MAX6675
|
||||
HAL::delayMicroseconds(1); // ensure 100ns delay - a bit extra is fine
|
||||
max6675_temp = HAL::spiReceive(0);
|
||||
max6675_temp <<= 8;
|
||||
max6675_temp |= HAL::spiReceive(0);
|
||||
HAL::digitalWrite(ss_pin, 1); // disable TT_MAX6675
|
||||
last_max6675_read = HAL::timeInMilliseconds();
|
||||
}
|
||||
return max6675_temp & 4 ? 2000 : max6675_temp >> 3; // thermocouple open?
|
||||
}
|
||||
#endif
|
||||
|
@ -1934,7 +2087,13 @@ void Extruder::retractDistance(float dist)
|
|||
int32_t distance = static_cast<int32_t>(dist * stepsPerMM / Printer::extrusionFactor);
|
||||
int32_t oldEPos = Printer::currentPositionSteps[E_AXIS];
|
||||
float speed = distance > 0 ? EEPROM_FLOAT(RETRACTION_SPEED) : EEPROM_FLOAT(RETRACTION_UNDO_SPEED);
|
||||
#if MIXING_EXTRUDER
|
||||
Printer::setAllEMotors(true);
|
||||
#endif
|
||||
PrintLine::moveRelativeDistanceInSteps(0, 0, 0, -distance, RMath::max(speed, 1.f), false, false);
|
||||
#if MIXING_EXTRUDER
|
||||
Printer::setAllEMotors(false);
|
||||
#endif
|
||||
Printer::currentPositionSteps[E_AXIS] = oldEPos; // restore previous extruder position
|
||||
Printer::feedrate = oldFeedrate;
|
||||
}
|
||||
|
@ -1943,26 +2102,27 @@ void Extruder::retract(bool isRetract,bool isLong)
|
|||
{
|
||||
float oldFeedrate = Printer::feedrate;
|
||||
float distance = (isLong ? EEPROM_FLOAT( RETRACTION_LONG_LENGTH) : EEPROM_FLOAT(RETRACTION_LENGTH));
|
||||
int32_t zlift = static_cast<int32_t>(EEPROM_FLOAT(RETRACTION_Z_LIFT) * Printer::axisStepsPerMM[Z_AXIS]);
|
||||
int32_t oldZPos = Printer::currentPositionSteps[Z_AXIS];
|
||||
float oldZPosF = Printer::currentPosition[Z_AXIS];
|
||||
float zLiftF = EEPROM_FLOAT(RETRACTION_Z_LIFT);
|
||||
int32_t zlift = static_cast<int32_t>(zLiftF * Printer::axisStepsPerMM[Z_AXIS]);
|
||||
if(isRetract && !isRetracted())
|
||||
{
|
||||
retractDistance(distance);
|
||||
setRetracted(true);
|
||||
if(zlift > 0)
|
||||
if(zlift > 0) {
|
||||
PrintLine::moveRelativeDistanceInStepsReal(0,0,zlift,0,Printer::maxFeedrate[Z_AXIS], false);
|
||||
Printer::coordinateOffset[Z_AXIS] -= zLiftF;
|
||||
}
|
||||
}
|
||||
else if(!isRetract && isRetracted())
|
||||
{
|
||||
distance += (isLong ? EEPROM_FLOAT(RETRACTION_UNDO_EXTRA_LONG_LENGTH) : EEPROM_FLOAT(RETRACTION_UNDO_EXTRA_LENGTH) );
|
||||
if(zlift > 0)
|
||||
if(zlift > 0) {
|
||||
PrintLine::moveRelativeDistanceInStepsReal(0,0,-zlift,0,Printer::maxFeedrate[Z_AXIS], false);
|
||||
Printer::coordinateOffset[Z_AXIS] += zLiftF;
|
||||
}
|
||||
retractDistance(-distance);
|
||||
setRetracted(false);
|
||||
}
|
||||
Printer::currentPositionSteps[Z_AXIS] = oldZPos; // z lift should have no visible impact
|
||||
Printer::currentPosition[Z_AXIS] = oldZPosF;
|
||||
Printer::feedrate = oldFeedrate;
|
||||
}
|
||||
#endif
|
||||
|
@ -2165,45 +2325,55 @@ Extruder extruder[NUM_EXTRUDER] =
|
|||
#endif // NUM_EXTRUDER
|
||||
|
||||
#if HAVE_HEATED_BED
|
||||
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER+1
|
||||
TemperatureController heatedBedController = {NUM_EXTRUDER,HEATED_BED_SENSOR_TYPE,BED_SENSOR_INDEX,0,0,0,0,0,HEATED_BED_HEAT_MANAGER
|
||||
TemperatureController heatedBedController = {PWM_HEATED_BED,HEATED_BED_SENSOR_TYPE,BED_SENSOR_INDEX,0,0,0,0,0,HEATED_BED_HEAT_MANAGER
|
||||
#if TEMP_PID
|
||||
,0,HEATED_BED_PID_INTEGRAL_DRIVE_MAX,HEATED_BED_PID_INTEGRAL_DRIVE_MIN,HEATED_BED_PID_PGAIN_OR_DEAD_TIME,HEATED_BED_PID_IGAIN,HEATED_BED_PID_DGAIN,HEATED_BED_PID_MAX,0,0,0,{0,0,0,0}
|
||||
#endif
|
||||
,0,0,0,HEATED_BED_DECOUPLE_TEST_PERIOD
|
||||
};
|
||||
#else
|
||||
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER
|
||||
,0,0,0,HEATED_BED_DECOUPLE_TEST_PERIOD};
|
||||
#endif
|
||||
|
||||
#if FAN_THERMO_PIN > -1
|
||||
TemperatureController thermoController = {PWM_FAN_THERMO,FAN_THERMO_THERMISTOR_TYPE,THERMO_ANALOG_INDEX,0,0,0,0,0,0
|
||||
#if TEMP_PID
|
||||
,0,255,0,10,1,1,255,0,0,0,{0,0,0,0}
|
||||
#endif
|
||||
,0,0,0,0};
|
||||
#endif
|
||||
|
||||
#if NUM_TEMPERATURE_LOOPS > 0
|
||||
TemperatureController *tempController[NUM_TEMPERATURE_LOOPS] =
|
||||
{
|
||||
#if NUM_EXTRUDER>0
|
||||
#if NUM_EXTRUDER > 0
|
||||
&extruder[0].tempControl
|
||||
#endif
|
||||
#if NUM_EXTRUDER>1
|
||||
#if NUM_EXTRUDER > 1
|
||||
,&extruder[1].tempControl
|
||||
#endif
|
||||
#if NUM_EXTRUDER>2
|
||||
#if NUM_EXTRUDER > 2
|
||||
,&extruder[2].tempControl
|
||||
#endif
|
||||
#if NUM_EXTRUDER>3
|
||||
#if NUM_EXTRUDER > 3
|
||||
,&extruder[3].tempControl
|
||||
#endif
|
||||
#if NUM_EXTRUDER>4
|
||||
#if NUM_EXTRUDER > 4
|
||||
,&extruder[4].tempControl
|
||||
#endif
|
||||
#if NUM_EXTRUDER>5
|
||||
#if NUM_EXTRUDER > 5
|
||||
,&extruder[5].tempControl
|
||||
#endif
|
||||
#if HAVE_HEATED_BED
|
||||
#if NUM_EXTRUDER==0
|
||||
#if NUM_EXTRUDER == 0
|
||||
&heatedBedController
|
||||
#else
|
||||
,&heatedBedController
|
||||
#endif
|
||||
#endif
|
||||
#if FAN_THERMO_PIN > -1
|
||||
#if NUM_EXTRUDER == 0 && !HAVE_HEATED_BED
|
||||
&thermoController
|
||||
#else
|
||||
,&thermoController
|
||||
#endif
|
||||
#endif // FAN_THERMO_PIN
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
@ -148,6 +148,7 @@ class Extruder;
|
|||
extern Extruder extruder[];
|
||||
|
||||
#if EXTRUDER_JAM_CONTROL
|
||||
#if JAM_METHOD == 1
|
||||
#define _TEST_EXTRUDER_JAM(x,pin) {\
|
||||
uint8_t sig = READ(pin);extruder[x].jamStepsSinceLastSignal += extruder[x].jamLastDir;\
|
||||
if(extruder[x].jamLastSignal != sig && abs(extruder[x].jamStepsSinceLastSignal - extruder[x].jamLastChangeAt) > JAM_MIN_STEPS) {\
|
||||
|
@ -156,10 +157,23 @@ extern Extruder extruder[];
|
|||
} else if(abs(extruder[x].jamStepsSinceLastSignal) > JAM_ERROR_STEPS && !Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) \
|
||||
extruder[x].tempControl.setJammed(true);\
|
||||
}
|
||||
#define RESET_EXTRUDER_JAM(x,dir) extruder[x].jamLastDir = dir ? 1 : -1;
|
||||
#elif JAM_METHOD == 2
|
||||
#define _TEST_EXTRUDER_JAM(x,pin) {\
|
||||
uint8_t sig = READ(pin);\
|
||||
if(sig){extruder[x].tempControl.setJammed(true);} else if(!Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) {extruder[x].resetJamSteps();}}
|
||||
#define RESET_EXTRUDER_JAM(x,dir)
|
||||
#elif JAM_METHOD == 3
|
||||
#define _TEST_EXTRUDER_JAM(x,pin) {\
|
||||
uint8_t sig = !READ(pin);\
|
||||
if(sig){extruder[x].tempControl.setJammed(true);} else if(!Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) {extruder[x].resetJamSteps();}}
|
||||
#define RESET_EXTRUDER_JAM(x,dir)
|
||||
#else
|
||||
#error Unknown value for JAM_METHOD
|
||||
#endif
|
||||
#define ___TEST_EXTRUDER_JAM(x,y) _TEST_EXTRUDER_JAM(x,y)
|
||||
#define __TEST_EXTRUDER_JAM(x) ___TEST_EXTRUDER_JAM(x,EXT ## x ## _JAM_PIN)
|
||||
#define TEST_EXTRUDER_JAM(x) __TEST_EXTRUDER_JAM(x)
|
||||
#define RESET_EXTRUDER_JAM(x,dir) extruder[x].jamLastDir = dir ? 1 : -1;
|
||||
#else
|
||||
#define TEST_EXTRUDER_JAM(x)
|
||||
#define RESET_EXTRUDER_JAM(x,dir)
|
||||
|
@ -184,6 +198,7 @@ public:
|
|||
static int mixingS; ///< Sum of all weights
|
||||
static uint8_t mixingDir; ///< Direction flag
|
||||
static uint8_t activeMixingExtruder;
|
||||
static void recomputeMixingExtruderSteps();
|
||||
#endif
|
||||
uint8_t id;
|
||||
int32_t xOffset;
|
||||
|
@ -274,19 +289,27 @@ public:
|
|||
};
|
||||
|
||||
#if HAVE_HEATED_BED
|
||||
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER+1
|
||||
#define HEATED_BED_INDEX NUM_EXTRUDER
|
||||
extern TemperatureController heatedBedController;
|
||||
#else
|
||||
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER
|
||||
#define HEATED_BED_INDEX NUM_EXTRUDER-1
|
||||
#endif
|
||||
#if FAN_THERMO_PIN > -1
|
||||
#define THERMO_CONTROLLER_INDEX HEATED_BED_INDEX+1
|
||||
extern TemperatureController thermoController;
|
||||
#else
|
||||
#define THERMO_CONTROLLER_INDEX HEATED_BED_INDEX
|
||||
#endif
|
||||
#define NUM_TEMPERATURE_LOOPS THERMO_CONTROLLER_INDEX+1
|
||||
|
||||
#define TEMP_INT_TO_FLOAT(temp) ((float)(temp)/(float)(1<<CELSIUS_EXTRA_BITS))
|
||||
#define TEMP_FLOAT_TO_INT(temp) ((int)((temp)*(1<<CELSIUS_EXTRA_BITS)))
|
||||
|
||||
//extern Extruder *Extruder::current;
|
||||
#if NUM_TEMPERATURE_LOOPS > 0
|
||||
extern TemperatureController *tempController[NUM_TEMPERATURE_LOOPS];
|
||||
#endif
|
||||
extern uint8_t autotuneIndex;
|
||||
|
||||
|
||||
#endif // EXTRUDER_H_INCLUDED
|
||||
|
||||
|
||||
|
|
|
@ -416,5 +416,3 @@ static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir) {
|
|||
return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
|
||||
}
|
||||
#endif // FatStructs_h
|
||||
|
||||
|
||||
|
|
|
@ -6,7 +6,9 @@ uint8 osAnalogInputCounter[ANALOG_INPUTS];
|
|||
uint osAnalogInputBuildup[ANALOG_INPUTS];
|
||||
uint8 osAnalogInputPos = 0; // Current sampling position
|
||||
#endif
|
||||
|
||||
#if FEATURE_WATCHDOG
|
||||
bool HAL::wdPinged = false;
|
||||
#endif
|
||||
//extern "C" void __cxa_pure_virtual() { }
|
||||
|
||||
HAL::HAL()
|
||||
|
@ -318,8 +320,8 @@ void HAL::analogStart()
|
|||
//ADCSRA |= _BV(ADSC); // start ADC-conversion
|
||||
while (ADCSRA & _BV(ADSC) ) {} // wait for conversion
|
||||
/* ADCW must be read once, otherwise the next result is wrong. */
|
||||
uint dummyADCResult;
|
||||
dummyADCResult = ADCW;
|
||||
//uint dummyADCResult;
|
||||
//dummyADCResult = ADCW;
|
||||
// Enable interrupt driven conversion loop
|
||||
uint8_t channel = pgm_read_byte(&osAnalogInputChannels[osAnalogInputPos]);
|
||||
#if defined(ADCSRB) && defined(MUX5)
|
||||
|
@ -782,8 +784,8 @@ ISR(PWM_TIMER_VECTOR)
|
|||
{
|
||||
static uint8_t pwm_count_cooler = 0;
|
||||
static uint8_t pwm_count_heater = 0;
|
||||
static uint8_t pwm_pos_set[NUM_EXTRUDER + 3];
|
||||
#if NUM_EXTRUDER > 0
|
||||
static uint8_t pwm_pos_set[NUM_PWM];
|
||||
#if NUM_EXTRUDER > 0 && ((defined(EXT0_HEATER_PIN) && EXT0_HEATER_PIN > -1 && EXT0_EXTRUDER_COOLER_PIN > -1) || (NUM_EXTRUDER > 1 && EXT1_EXTRUDER_COOLER_PIN > -1 && EXT1_EXTRUDER_COOLER_PIN != EXT0_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 2 && EXT2_EXTRUDER_COOLER_PIN > -1 && EXT2_EXTRUDER_COOLER_PIN != EXT2_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 3 && EXT3_EXTRUDER_COOLER_PIN > -1 && EXT3_EXTRUDER_COOLER_PIN != EXT3_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 4 && EXT4_EXTRUDER_COOLER_PIN > -1 && EXT4_EXTRUDER_COOLER_PIN != EXT4_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 5 && EXT5_EXTRUDER_COOLER_PIN > -1 && EXT5_EXTRUDER_COOLER_PIN != EXT5_EXTRUDER_COOLER_PIN))
|
||||
static uint8_t pwm_cooler_pos_set[NUM_EXTRUDER];
|
||||
#endif
|
||||
PWM_OCR += 64;
|
||||
|
@ -842,10 +844,16 @@ ISR(PWM_TIMER_VECTOR)
|
|||
#endif
|
||||
#endif
|
||||
#if FAN_BOARD_PIN > -1 && SHARED_COOLER_BOARD_EXT == 0
|
||||
if((pwm_pos_set[NUM_EXTRUDER + 1] = (pwm_pos[NUM_EXTRUDER + 1] & COOLER_PWM_MASK)) > 0) WRITE(FAN_BOARD_PIN,1);
|
||||
if((pwm_pos_set[PWM_BOARD_FAN] = (pwm_pos[PWM_BOARD_FAN] & COOLER_PWM_MASK)) > 0) WRITE(FAN_BOARD_PIN,1);
|
||||
#endif
|
||||
#if FAN_PIN > -1 && FEATURE_FAN_CONTROL
|
||||
if((pwm_pos_set[NUM_EXTRUDER + 2] = (pwm_pos[NUM_EXTRUDER + 2] & COOLER_PWM_MASK)) > 0) WRITE(FAN_PIN,1);
|
||||
if((pwm_pos_set[PWM_FAN1] = (pwm_pos[PWM_FAN1] & COOLER_PWM_MASK)) > 0) WRITE(FAN_PIN,1);
|
||||
#endif
|
||||
#if FAN2_PIN > -1 && FEATURE_FAN2_CONTROL
|
||||
if((pwm_pos_set[PWM_FAN2] = (pwm_pos[PWM_FAN2] & COOLER_PWM_MASK)) > 0) WRITE(FAN2_PIN,1);
|
||||
#endif
|
||||
#if defined(FAN_THERMO_PIN) && FAN_THERMO_PIN > -1
|
||||
if((pwm_pos_set[PWM_FAN_THERMO] = (pwm_pos[PWM_FAN_THERMO] & COOLER_PWM_MASK)) > 0) WRITE(FAN_THERMO_PIN,1);
|
||||
#endif
|
||||
}
|
||||
#if defined(EXT0_HEATER_PIN) && EXT0_HEATER_PIN > -1
|
||||
|
@ -934,21 +942,38 @@ ISR(PWM_TIMER_VECTOR)
|
|||
#endif
|
||||
#if FAN_BOARD_PIN > -1 && SHARED_COOLER_BOARD_EXT == 0
|
||||
#if PDM_FOR_COOLER
|
||||
pulseDensityModulate(FAN_BOARD_PIN, pwm_pos[NUM_EXTRUDER + 1], pwm_pos_set[NUM_EXTRUDER + 1], false);
|
||||
pulseDensityModulate(FAN_BOARD_PIN, pwm_pos[PWM_BOARD_FAN], pwm_pos_set[PWM_BOARD_FAN], false);
|
||||
#else
|
||||
if(pwm_pos_set[NUM_EXTRUDER + 1] == pwm_count_cooler && pwm_pos_set[NUM_EXTRUDER + 1] != COOLER_PWM_MASK) WRITE(FAN_BOARD_PIN,0);
|
||||
if(pwm_pos_set[PWM_BOARD_FAN] == pwm_count_cooler && pwm_pos_set[NUM_EXTRUDER + 1] != COOLER_PWM_MASK) WRITE(FAN_BOARD_PIN,0);
|
||||
#endif
|
||||
#endif
|
||||
#if FAN_PIN > -1 && FEATURE_FAN_CONTROL
|
||||
if(fanKickstart == 0)
|
||||
{
|
||||
#if PDM_FOR_COOLER
|
||||
pulseDensityModulate(FAN_PIN, pwm_pos[NUM_EXTRUDER + 2], pwm_pos_set[NUM_EXTRUDER + 2], false);
|
||||
pulseDensityModulate(FAN_PIN, pwm_pos[PWM_FAN1], pwm_pos_set[PWM_FAN1], false);
|
||||
#else
|
||||
if(pwm_pos_set[NUM_EXTRUDER + 2] == pwm_count_cooler && pwm_pos_set[NUM_EXTRUDER + 2] != COOLER_PWM_MASK) WRITE(FAN_PIN,0);
|
||||
if(pwm_pos_set[PWM_FAN1] == pwm_count_cooler && pwm_pos_set[PWM_FAN1] != COOLER_PWM_MASK) WRITE(FAN_PIN,0);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#if FAN2_PIN > -1 && FEATURE_FAN2_CONTROL
|
||||
if(fan2Kickstart == 0)
|
||||
{
|
||||
#if PDM_FOR_COOLER
|
||||
pulseDensityModulate(FAN2_PIN, pwm_pos[PWM_FAN2], pwm_pos_set[PWM_FAN2], false);
|
||||
#else
|
||||
if(pwm_pos_set[PWM_FAN2] == pwm_count_cooler && pwm_pos_set[PWM_FAN2] != COOLER_PWM_MASK) WRITE(FAN2_PIN,0);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#if defined(FAN_THERMO_PIN) && FAN_THERMO_PIN > -1
|
||||
#if PDM_FOR_COOLER
|
||||
pulseDensityModulate(FAN_THERMO_PIN, pwm_pos[PWM_FAN_THERMO], pwm_pos_set[PWM_FAN_THERMO], false);
|
||||
#else
|
||||
if(pwm_pos_set[PWM_FAN_THERMO] == pwm_count_cooler && pwm_pos_set[PWM_FAN_THERMO] != COOLER_PWM_MASK) WRITE(FAN_THERMO_PIN,0);
|
||||
#endif
|
||||
#endif
|
||||
#if HEATED_BED_HEATER_PIN > -1 && HAVE_HEATED_BED
|
||||
#if PDM_FOR_EXTRUDER
|
||||
pulseDensityModulate(HEATED_BED_HEATER_PIN, pwm_pos[NUM_EXTRUDER], pwm_pos_set[NUM_EXTRUDER], HEATER_PINS_INVERTED);
|
||||
|
@ -957,12 +982,17 @@ ISR(PWM_TIMER_VECTOR)
|
|||
#endif
|
||||
#endif
|
||||
HAL::allowInterrupts();
|
||||
counterPeriodical++; // Appxoimate a 100ms timer
|
||||
counterPeriodical++; // Approximate a 100ms timer
|
||||
if(counterPeriodical >= (int)(F_CPU/40960))
|
||||
{
|
||||
counterPeriodical = 0;
|
||||
executePeriodical = 1;
|
||||
if(fanKickstart) fanKickstart--;
|
||||
#if FEATURE_FAN_CONTROL
|
||||
if (fanKickstart) fanKickstart--;
|
||||
#endif
|
||||
#if FEATURE_FAN2_CONTROL
|
||||
if (fan2Kickstart) fan2Kickstart--;
|
||||
#endif
|
||||
}
|
||||
// read analog values
|
||||
#if ANALOG_INPUTS > 0
|
||||
|
@ -1002,6 +1032,12 @@ ISR(PWM_TIMER_VECTOR)
|
|||
UI_FAST; // Short timed user interface action
|
||||
pwm_count_cooler += COOLER_PWM_STEP;
|
||||
pwm_count_heater += HEATER_PWM_STEP;
|
||||
#if FEATURE_WATCHDOG
|
||||
if(HAL::wdPinged) {
|
||||
wdt_reset();
|
||||
HAL::wdPinged = false;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#if USE_ADVANCE
|
||||
|
||||
|
@ -1160,8 +1196,6 @@ ISR(USART_UDRE_vect)
|
|||
{
|
||||
// There is more data in the output buffer. Send the next byte
|
||||
uint8_t c = tx_buffer.buffer[tx_buffer.tail];
|
||||
tx_buffer.tail = (tx_buffer.tail + 1) & SERIAL_TX_BUFFER_MASK;
|
||||
|
||||
#if defined(UDR0)
|
||||
UDR0 = c;
|
||||
#elif defined(UDR)
|
||||
|
@ -1169,6 +1203,7 @@ ISR(USART_UDRE_vect)
|
|||
#else
|
||||
#error UDR not defined
|
||||
#endif
|
||||
tx_buffer.tail = (tx_buffer.tail + 1) & SERIAL_TX_BUFFER_MASK;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
@ -1360,7 +1395,7 @@ int RFHardwareSerial::available(void)
|
|||
}
|
||||
int RFHardwareSerial::outputUnused(void)
|
||||
{
|
||||
return SERIAL_TX_BUFFER_SIZE-(unsigned int)((SERIAL_TX_BUFFER_SIZE + _tx_buffer->head - _tx_buffer->tail) & SERIAL_TX_BUFFER_MASK);
|
||||
return SERIAL_TX_BUFFER_SIZE - (unsigned int)((SERIAL_TX_BUFFER_SIZE + _tx_buffer->head - _tx_buffer->tail) & SERIAL_TX_BUFFER_MASK);
|
||||
}
|
||||
|
||||
int RFHardwareSerial::peek(void)
|
||||
|
@ -1403,9 +1438,9 @@ RFHardwareSerial::write(uint8_t c)
|
|||
|
||||
// If the output buffer is full, there's nothing for it other than to
|
||||
// wait for the interrupt handler to empty it a bit
|
||||
while (i == _tx_buffer->tail) ;
|
||||
while (i == _tx_buffer->tail) {}
|
||||
#if defined(BLUETOOTH_SERIAL) && BLUETOOTH_SERIAL > 0
|
||||
while (i == txx_buffer_tail) ;
|
||||
while (i == txx_buffer_tail) {}
|
||||
#endif
|
||||
_tx_buffer->buffer[_tx_buffer->head] = c;
|
||||
_tx_buffer->head = i;
|
||||
|
@ -1433,5 +1468,3 @@ RFHardwareSerial RFSerial(&rx_buffer, &tx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UC
|
|||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -70,7 +70,9 @@ All known arduino boards use 64. This value is needed for the extruder timing. *
|
|||
#endif
|
||||
#include <inttypes.h>
|
||||
#include "Print.h"
|
||||
|
||||
#ifdef EXTERNALSERIAL
|
||||
#define SERIAL_RX_BUFFER_SIZE 128
|
||||
#endif
|
||||
#if defined(ARDUINO) && ARDUINO >= 100
|
||||
#include "Arduino.h"
|
||||
#else
|
||||
|
@ -132,7 +134,7 @@ public:
|
|||
#define I2C_WRITE 0
|
||||
|
||||
#if NONLINEAR_SYSTEM
|
||||
// Maximum speed with 100% inerrupt utilization is 27000 hz at 16MHz cpu
|
||||
// Maximum speed with 100% interrupt utilization is 27000 hz at 16MHz cpu
|
||||
// leave some margin for all the extra transformations. So we keep inside clean timings.
|
||||
#define LIMIT_INTERVAL ((F_CPU/30000)+1)
|
||||
#else
|
||||
|
@ -175,8 +177,15 @@ typedef uint8_t ufast8_t;
|
|||
|
||||
#define SERIAL_BUFFER_SIZE 128
|
||||
#define SERIAL_BUFFER_MASK 127
|
||||
#undef SERIAL_TX_BUFFER_SIZE
|
||||
#undef SERIAL_TX_BUFFER_MASK
|
||||
#ifdef BIG_OUTPUT_BUFFER
|
||||
#define SERIAL_TX_BUFFER_SIZE 128
|
||||
#define SERIAL_TX_BUFFER_MASK 127
|
||||
#else
|
||||
#define SERIAL_TX_BUFFER_SIZE 64
|
||||
#define SERIAL_TX_BUFFER_MASK 63
|
||||
#endif
|
||||
|
||||
struct ring_buffer
|
||||
{
|
||||
|
@ -253,6 +262,9 @@ extern RFHardwareSerial RFSerial;
|
|||
class HAL
|
||||
{
|
||||
public:
|
||||
#if FEATURE_WATCHDOG
|
||||
static bool wdPinged;
|
||||
#endif
|
||||
HAL();
|
||||
virtual ~HAL();
|
||||
static inline void hwSetup(void)
|
||||
|
@ -601,7 +613,7 @@ public:
|
|||
SET_OUTPUT(SDSSORIG);
|
||||
#endif
|
||||
// set SS high - may be chip select for another SPI device
|
||||
#if SET_SPI_SS_HIGH
|
||||
#if defined(SET_SPI_SS_HIGH) && SET_SPI_SS_HIGH
|
||||
WRITE(SDSS, HIGH);
|
||||
#endif // SET_SPI_SS_HIGH
|
||||
#endif
|
||||
|
@ -711,7 +723,7 @@ public:
|
|||
inline static void pingWatchdog()
|
||||
{
|
||||
#if FEATURE_WATCHDOG
|
||||
wdt_reset();
|
||||
wdPinged = true;
|
||||
#endif
|
||||
};
|
||||
inline static float maxExtruderTimerFrequency()
|
||||
|
@ -756,5 +768,3 @@ private:
|
|||
#define PWM_OCIE OCIE0B
|
||||
//#endif
|
||||
#endif // HAL_H
|
||||
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -94,6 +94,7 @@ union wizardVar
|
|||
#define PRINTER_FLAG2_DEBUG_JAM 16
|
||||
#define PRINTER_FLAG2_JAMCONTROL_DISABLED 32
|
||||
#define PRINTER_FLAG2_HOMING 64
|
||||
#define PRINTER_FLAG2_ALL_E_MOTORS 128 // Set all e motors flag
|
||||
|
||||
// List of possible interrupt events (1-255 allowed)
|
||||
#define PRINTER_INTERRUPT_EVENT_JAM_DETECTED 1
|
||||
|
@ -106,7 +107,7 @@ union wizardVar
|
|||
// define an integer number of steps more than large enough to get to endstop from anywhere
|
||||
#define HOME_DISTANCE_STEPS (Printer::zMaxSteps-Printer::zMinSteps+1000)
|
||||
#define HOME_DISTANCE_MM (HOME_DISTANCE_STEPS * invAxisStepsPerMM[Z_AXIS])
|
||||
// Some dfines to make clearer reading, as we overload these cartesion memory locations for delta
|
||||
// Some defines to make clearer reading, as we overload these cartesian memory locations for delta
|
||||
#define towerAMaxSteps Printer::xMaxSteps
|
||||
#define towerBMaxSteps Printer::yMaxSteps
|
||||
#define towerCMaxSteps Printer::zMaxSteps
|
||||
|
@ -126,18 +127,27 @@ public:
|
|||
int32_t correct(int32_t x, int32_t y, int32_t z) const;
|
||||
void updateDerived();
|
||||
void reportStatus();
|
||||
bool isEnabled() {return enabled;}
|
||||
int32_t zMaxSteps() {return zEnd;}
|
||||
void set(float x,float y,float z);
|
||||
void showMatrix();
|
||||
void resetCorrection();
|
||||
private:
|
||||
INLINE int matrixIndex(fast8_t x, fast8_t y) const;
|
||||
INLINE int32_t getMatrix(int index) const;
|
||||
INLINE void setMatrix(int32_t val, int index);
|
||||
int matrixIndex(fast8_t x, fast8_t y) const;
|
||||
int32_t getMatrix(int index) const;
|
||||
void setMatrix(int32_t val, int index);
|
||||
bool isCorner(fast8_t i, fast8_t j) const;
|
||||
INLINE int32_t extrapolatePoint(fast8_t x1, fast8_t y1, fast8_t x2, fast8_t y2) const;
|
||||
void extrapolateCorner(fast8_t x, fast8_t y, fast8_t dx, fast8_t dy);
|
||||
void extrapolateCorners();
|
||||
void resetCorrection();
|
||||
// attributes
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
int32_t step;
|
||||
int32_t radiusCorrectionSteps;
|
||||
#else
|
||||
int32_t xCorrectionSteps,xOffsetSteps;
|
||||
int32_t yCorrectionSteps,yOffsetSteps;
|
||||
#endif
|
||||
int32_t zStart,zEnd;
|
||||
#if !DISTORTION_PERMANENT
|
||||
int32_t matrix[DISTORTION_CORRECTION_POINTS * DISTORTION_CORRECTION_POINTS];
|
||||
|
@ -167,9 +177,11 @@ private:
|
|||
class Endstops {
|
||||
static flag8_t lastState;
|
||||
static flag8_t lastRead;
|
||||
static flag8_t accumulator;
|
||||
#ifdef EXTENDED_ENDSTOPS
|
||||
static flag8_t lastState2;
|
||||
static flag8_t lastRead2;
|
||||
static flag8_t accumulator2;
|
||||
#endif
|
||||
public:
|
||||
static void update();
|
||||
|
@ -177,6 +189,18 @@ public:
|
|||
static INLINE bool anyXYZMax() {
|
||||
return (lastState & (ENDSTOP_X_MAX_ID|ENDSTOP_Z_MAX_ID|ENDSTOP_Z_MAX_ID)) != 0;
|
||||
}
|
||||
static INLINE void resetAccumulator() {
|
||||
accumulator = 0;
|
||||
#ifdef EXTENDED_ENDSTOPS
|
||||
accumulator2 = 0;
|
||||
#endif
|
||||
}
|
||||
static INLINE void fillFromAccumulator() {
|
||||
lastState = accumulator;
|
||||
#ifdef EXTENDED_ENDSTOPS
|
||||
lastState2 = accumulator2;
|
||||
#endif
|
||||
}
|
||||
static INLINE bool xMin() {
|
||||
#if (X_MIN_PIN > -1) && MIN_HARDWARE_ENDSTOP_X
|
||||
return (lastState & ENDSTOP_X_MIN_ID) != 0;
|
||||
|
@ -235,12 +259,25 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
#ifndef DEFAULT_PRINTER_MODE
|
||||
#if NUM_EXTRUDER > 0
|
||||
#define DEFAULT_PRINTER_MODE PRINTER_MODE_FFF
|
||||
#elif defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
#define DEFAULT_PRINTER_MODE PRINTER_MODE_LASER
|
||||
#elif defined(SUPPORT_CNC) && SUPPORT_CNC
|
||||
#define DEFAULT_PRINTER_MODE PRINTER_MODE_CNC
|
||||
#else
|
||||
#error No supported printer mode compiled
|
||||
#endif
|
||||
#endif
|
||||
|
||||
class Printer
|
||||
{
|
||||
static uint8_t debugLevel;
|
||||
public:
|
||||
#if USE_ADVANCE
|
||||
static volatile int extruderStepsNeeded; ///< This many extruder steps are still needed, <0 = reverse steps needed.
|
||||
static uint8_t maxExtruderSpeed; ///< Timer delay for end extruder speed
|
||||
static ufast8_t maxExtruderSpeed; ///< Timer delay for end extruder speed
|
||||
//static uint8_t extruderAccelerateDelay; ///< delay between 2 speec increases
|
||||
static int advanceStepsSet;
|
||||
#if ENABLE_QUADRATIC_ADVANCE
|
||||
|
@ -260,11 +297,12 @@ public:
|
|||
static uint8_t relativeExtruderCoordinateMode; ///< Determines Absolute or Relative E Codes while in Absolute Coordinates mode. E is always relative in Relative Coordinates mode.
|
||||
|
||||
static uint8_t unitIsInches;
|
||||
|
||||
static uint8_t debugLevel;
|
||||
static uint8_t mode;
|
||||
static uint8_t fanSpeed; // Last fan speed set with M106/M107
|
||||
static float zBedOffset;
|
||||
static uint8_t flag0,flag1; // 1 = stepper disabled, 2 = use external extruder interrupt, 4 = temp Sensor defect, 8 = homed
|
||||
static uint8_t flag2;
|
||||
static uint8_t stepsPerTimerCall;
|
||||
static fast8_t stepsPerTimerCall;
|
||||
static uint32_t interval; ///< Last step duration in ticks.
|
||||
static uint32_t timer; ///< used for acceleration/deceleration timing
|
||||
static uint32_t stepNumber; ///< Step number in current move.
|
||||
|
@ -293,15 +331,17 @@ public:
|
|||
static int16_t travelMovesPerSecond;
|
||||
static int16_t printMovesPerSecond;
|
||||
static float radius0;
|
||||
#else
|
||||
static int32_t zCorrectionStepsIncluded;
|
||||
#endif
|
||||
#if FEATURE_Z_PROBE || MAX_HARDWARE_ENDSTOP_Z || NONLINEAR_SYSTEM
|
||||
static int32_t stepsRemainingAtZHit;
|
||||
#endif
|
||||
#if DRIVE_SYSTEM==DELTA
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
static int32_t stepsRemainingAtXHit;
|
||||
static int32_t stepsRemainingAtYHit;
|
||||
#endif
|
||||
#if SOFTWARE_LEVELING
|
||||
#ifdef SOFTWARE_LEVELING
|
||||
static int32_t levelingP1[3];
|
||||
static int32_t levelingP2[3];
|
||||
static int32_t levelingP3[3];
|
||||
|
@ -309,7 +349,11 @@ public:
|
|||
#if FEATURE_AUTOLEVEL
|
||||
static float autolevelTransformation[9]; ///< Transformation matrix
|
||||
#endif
|
||||
static int8_t zBabystepsMissing;
|
||||
#if FAN_THERMO_PIN > -1
|
||||
static float thermoMinTemp;
|
||||
static float thermoMaxTemp;
|
||||
#endif
|
||||
static int16_t zBabystepsMissing;
|
||||
static float minimumSpeed; ///< lowest allowed speed to keep integration error small
|
||||
static float minimumZSpeed; ///< lowest allowed speed to keep integration error small
|
||||
static int32_t xMaxSteps; ///< For software endstops, limit of move in positive direction.
|
||||
|
@ -343,9 +387,6 @@ public:
|
|||
static float backlashY;
|
||||
static float backlashZ;
|
||||
static uint8_t backlashDir;
|
||||
#endif
|
||||
#ifdef DEBUG_STEPCOUNT
|
||||
static long totalStepsRemaining;
|
||||
#endif
|
||||
static float memoryX;
|
||||
static float memoryY;
|
||||
|
@ -372,7 +413,7 @@ public:
|
|||
if(highPriority || interruptEvent == 0)
|
||||
interruptEvent = evt;
|
||||
}
|
||||
|
||||
static void reportPrinterMode();
|
||||
static INLINE void setMenuMode(uint8_t mode,bool on)
|
||||
{
|
||||
if(on)
|
||||
|
@ -383,54 +424,63 @@ public:
|
|||
|
||||
static INLINE bool isMenuMode(uint8_t mode)
|
||||
{
|
||||
return (menuMode & mode)==mode;
|
||||
return (menuMode & mode) == mode;
|
||||
}
|
||||
|
||||
static void setDebugLevel(uint8_t newLevel);
|
||||
static void toggleEcho();
|
||||
static void toggleInfo();
|
||||
static void toggleErrors();
|
||||
static void toggleDryRun();
|
||||
static void toggleCommunication();
|
||||
static void toggleNoMoves();
|
||||
static INLINE uint8_t getDebugLevel() {return debugLevel;}
|
||||
static INLINE bool debugEcho()
|
||||
{
|
||||
return ((debugLevel & 1)!=0);
|
||||
return ((debugLevel & 1) != 0);
|
||||
}
|
||||
|
||||
static INLINE bool debugInfo()
|
||||
{
|
||||
return ((debugLevel & 2)!=0);
|
||||
return ((debugLevel & 2) != 0);
|
||||
}
|
||||
|
||||
static INLINE bool debugErrors()
|
||||
{
|
||||
return ((debugLevel & 4)!=0);
|
||||
return ((debugLevel & 4) != 0);
|
||||
}
|
||||
|
||||
static INLINE bool debugDryrun()
|
||||
{
|
||||
return ((debugLevel & 8)!=0);
|
||||
return ((debugLevel & 8) != 0);
|
||||
}
|
||||
|
||||
static INLINE bool debugCommunication()
|
||||
{
|
||||
return ((debugLevel & 16)!=0);
|
||||
return ((debugLevel & 16) != 0);
|
||||
}
|
||||
|
||||
static INLINE bool debugNoMoves()
|
||||
{
|
||||
return ((debugLevel & 32)!=0);
|
||||
return ((debugLevel & 32) != 0);
|
||||
}
|
||||
|
||||
static INLINE bool debugFlag(unsigned long flags)
|
||||
static INLINE bool debugFlag(uint8_t flags)
|
||||
{
|
||||
return (debugLevel & flags);
|
||||
}
|
||||
|
||||
static INLINE void debugSet(unsigned long flags)
|
||||
static INLINE void debugSet(uint8_t flags)
|
||||
{
|
||||
debugLevel |= flags;
|
||||
setDebugLevel(debugLevel | flags);
|
||||
}
|
||||
|
||||
static INLINE void debugReset(unsigned long flags)
|
||||
static INLINE void debugReset(uint8_t flags)
|
||||
{
|
||||
debugLevel &= ~flags;
|
||||
setDebugLevel(debugLevel & ~flags);
|
||||
}
|
||||
|
||||
/** Sets the pwm for the fan speed. Gets called by motion control ot Commands::setFanSpeed. */
|
||||
static void setFanSpeedDirectly(uint8_t speed);
|
||||
static void setFan2SpeedDirectly(uint8_t speed);
|
||||
/** \brief Disable stepper motor for x direction. */
|
||||
static INLINE void disableXStepper()
|
||||
{
|
||||
|
@ -460,6 +510,9 @@ public:
|
|||
#endif
|
||||
#if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
|
||||
WRITE(Z2_ENABLE_PIN, !Z_ENABLE_ON);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER && (Z3_ENABLE_PIN > -1)
|
||||
WRITE(Z3_ENABLE_PIN, !Z_ENABLE_ON);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -492,6 +545,9 @@ public:
|
|||
#endif
|
||||
#if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
|
||||
WRITE(Z2_ENABLE_PIN, Z_ENABLE_ON);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER && (Z3_ENABLE_PIN > -1)
|
||||
WRITE(Z3_ENABLE_PIN, Z_ENABLE_ON);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -537,6 +593,9 @@ public:
|
|||
WRITE(Z_DIR_PIN, !INVERT_Z_DIR);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_DIR_PIN, !INVERT_Z_DIR);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER
|
||||
WRITE(Z3_DIR_PIN, !INVERT_Z_DIR);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
|
@ -544,6 +603,9 @@ public:
|
|||
WRITE(Z_DIR_PIN, INVERT_Z_DIR);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_DIR_PIN, INVERT_Z_DIR);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER
|
||||
WRITE(Z3_DIR_PIN, INVERT_Z_DIR);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
@ -697,6 +759,15 @@ public:
|
|||
{
|
||||
flag2 = (b ? flag2 | PRINTER_FLAG2_HOMING : flag2 & ~PRINTER_FLAG2_HOMING);
|
||||
}
|
||||
static INLINE uint8_t isAllEMotors()
|
||||
{
|
||||
return flag2 & PRINTER_FLAG2_ALL_E_MOTORS;
|
||||
}
|
||||
|
||||
static INLINE void setAllEMotors(uint8_t b)
|
||||
{
|
||||
flag2 = (b ? flag2 | PRINTER_FLAG2_ALL_E_MOTORS : flag2 & ~PRINTER_FLAG2_ALL_E_MOTORS);
|
||||
}
|
||||
|
||||
static INLINE uint8_t isDebugJam()
|
||||
{
|
||||
|
@ -744,8 +815,8 @@ public:
|
|||
static INLINE void unsetAllSteppersDisabled()
|
||||
{
|
||||
flag0 &= ~PRINTER_FLAG0_STEPPER_DISABLED;
|
||||
#if FAN_BOARD_PIN>-1
|
||||
pwm_pos[NUM_EXTRUDER + 1] = 255;
|
||||
#if FAN_BOARD_PIN > -1
|
||||
pwm_pos[PWM_BOARD_FAN] = 255;
|
||||
#endif // FAN_BOARD_PIN
|
||||
}
|
||||
static INLINE bool isAnyTempsensorDefect()
|
||||
|
@ -786,33 +857,33 @@ public:
|
|||
#if (GANTRY)
|
||||
if(motorX <= -2)
|
||||
{
|
||||
WRITE(X_STEP_PIN,HIGH);
|
||||
WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,HIGH);
|
||||
WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorX += 2;
|
||||
}
|
||||
else if(motorX >= 2)
|
||||
{
|
||||
WRITE(X_STEP_PIN,HIGH);
|
||||
WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,HIGH);
|
||||
WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorX -= 2;
|
||||
}
|
||||
if(motorYorZ <= -2)
|
||||
{
|
||||
WRITE(Y_STEP_PIN,HIGH);
|
||||
WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_YSTEPPER
|
||||
WRITE(Y2_STEP_PIN,HIGH);
|
||||
WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorYorZ += 2;
|
||||
}
|
||||
else if(motorYorZ >= 2)
|
||||
{
|
||||
WRITE(Y_STEP_PIN,HIGH);
|
||||
WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_YSTEPPER
|
||||
WRITE(Y2_STEP_PIN,HIGH);
|
||||
WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorYorZ -= 2;
|
||||
}
|
||||
|
@ -823,53 +894,86 @@ public:
|
|||
#if (GANTRY)
|
||||
if(motorX <= -2)
|
||||
{
|
||||
WRITE(X_STEP_PIN,HIGH);
|
||||
WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,HIGH);
|
||||
WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorX += 2;
|
||||
}
|
||||
else if(motorX >= 2)
|
||||
{
|
||||
WRITE(X_STEP_PIN,HIGH);
|
||||
WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,HIGH);
|
||||
WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorX -= 2;
|
||||
}
|
||||
if(motorYorZ <= -2)
|
||||
{
|
||||
//ANALYZER_ON(ANALYZER_CH3); // I dont think i can use these as they are for the y - possible bug area though
|
||||
WRITE(Z_STEP_PIN,HIGH);
|
||||
WRITE(Z_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_STEP_PIN,HIGH);
|
||||
WRITE(Z2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER
|
||||
WRITE(Z3_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorYorZ += 2;
|
||||
}
|
||||
else if(motorYorZ >= 2)
|
||||
{
|
||||
//ANALYZER_ON(ANALYZER_CH3); // I dont think i can use these as they are for the y - possible bug area though
|
||||
WRITE(Z_STEP_PIN,HIGH);
|
||||
WRITE(Z_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_STEP_PIN,HIGH);
|
||||
WRITE(Z2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER
|
||||
WRITE(Z3_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
motorYorZ -= 2;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
static INLINE void startXStep()
|
||||
{
|
||||
WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
}
|
||||
static INLINE void startYStep()
|
||||
{
|
||||
WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_YSTEPPER
|
||||
WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
}
|
||||
static INLINE void startZStep()
|
||||
{
|
||||
WRITE(Z_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER
|
||||
WRITE(Z3_STEP_PIN,START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
}
|
||||
static INLINE void endXYZSteps()
|
||||
{
|
||||
WRITE(X_STEP_PIN,LOW);
|
||||
WRITE(X_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,LOW);
|
||||
WRITE(X2_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
WRITE(Y_STEP_PIN,LOW);
|
||||
WRITE(Y_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_YSTEPPER
|
||||
WRITE(Y2_STEP_PIN,LOW);
|
||||
WRITE(Y2_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
WRITE(Z_STEP_PIN,LOW);
|
||||
WRITE(Z_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_STEP_PIN,LOW);
|
||||
WRITE(Z2_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
#if FEATURE_THREE_ZSTEPPER
|
||||
WRITE(Z3_STEP_PIN,!START_STEP_WITH_HIGH);
|
||||
#endif
|
||||
}
|
||||
static INLINE speed_t updateStepsPerTimerCall(speed_t vbase)
|
||||
|
@ -956,13 +1060,17 @@ public:
|
|||
static void defaultLoopActions();
|
||||
static uint8_t setDestinationStepsFromGCode(GCode *com);
|
||||
static uint8_t moveTo(float x,float y,float z,float e,float f);
|
||||
static uint8_t moveToReal(float x,float y,float z,float e,float f);
|
||||
static uint8_t moveToReal(float x,float y,float z,float e,float f,bool pathOptimize = true);
|
||||
static void homeAxis(bool xaxis,bool yaxis,bool zaxis); /// Home axis
|
||||
static void setOrigin(float xOff,float yOff,float zOff);
|
||||
static bool isPositionAllowed(float x,float y,float z);
|
||||
static INLINE int getFanSpeed()
|
||||
{
|
||||
return (int)pwm_pos[NUM_EXTRUDER + 2];
|
||||
return (int)pwm_pos[PWM_FAN1];
|
||||
}
|
||||
static INLINE int getFan2Speed()
|
||||
{
|
||||
return (int)pwm_pos[PWM_FAN2];
|
||||
}
|
||||
#if NONLINEAR_SYSTEM
|
||||
static INLINE void setDeltaPositions(long xaxis, long yaxis, long zaxis)
|
||||
|
@ -977,8 +1085,11 @@ public:
|
|||
static float runZMaxProbe();
|
||||
#endif
|
||||
#if FEATURE_Z_PROBE
|
||||
static void startProbing(bool runScript);
|
||||
static void finishProbing();
|
||||
static float runZProbe(bool first,bool last,uint8_t repeat = Z_PROBE_REPETITIONS,bool runStartScript = true);
|
||||
static void waitForZProbeStart();
|
||||
static float bendingCorrectionAt(float x,float y);
|
||||
#endif
|
||||
// Moved outside FEATURE_Z_PROBE to allow auto-level functional test on
|
||||
// system without Z-probe
|
||||
|
@ -1011,6 +1122,9 @@ public:
|
|||
static void showConfiguration();
|
||||
static void setCaseLight(bool on);
|
||||
static void reportCaseLightStatus();
|
||||
#if JSON_OUTPUT
|
||||
static void showJSONStatus(int type);
|
||||
#endif
|
||||
private:
|
||||
static void homeXAxis();
|
||||
static void homeYAxis();
|
||||
|
@ -1018,5 +1132,3 @@ private:
|
|||
};
|
||||
|
||||
#endif // PRINTER_H_INCLUDED
|
||||
|
||||
|
||||
|
|
|
@ -1,875 +0,0 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
|
||||
<CodeBlocks_project_file>
|
||||
<FileVersion major="1" minor="6" />
|
||||
<Project>
|
||||
<Option title="Repetier" />
|
||||
<Option pch_mode="2" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Option virtualFolders="libraries\;" />
|
||||
<Build>
|
||||
<Target title="Simulator - Debug">
|
||||
<Option output="bin/Release/Repetier_sim.exe" prefix_auto="1" extension_auto="0" />
|
||||
<Option object_output="obj/Debug/" />
|
||||
<Option type="1" />
|
||||
<Option compiler="GCC" />
|
||||
<Compiler>
|
||||
<Add option="-g" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-DARDUSIM" />
|
||||
<Add option="-D__AVR_ATmega2560__" />
|
||||
<Add option="-x c++" />
|
||||
<Add directory="$(ARDUINO_DIR)/arduino/cores" />
|
||||
<Add directory="$(ARDUINO_DIR)/arduino/variants/standard" />
|
||||
<Add directory="$(ARDUINO_DIR)/include" />
|
||||
</Compiler>
|
||||
<Environment>
|
||||
<Variable name="ARDUINO_DIR" value="$(APP_PATH)\ardusim" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Simulator - Release">
|
||||
<Option output="bin/Release/Repetier_sim.exe" prefix_auto="1" extension_auto="0" />
|
||||
<Option object_output="obj/Release/" />
|
||||
<Option type="1" />
|
||||
<Option compiler="GCC" />
|
||||
<Compiler>
|
||||
<Add option="-Os" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-DARDUSIM" />
|
||||
<Add option="-D__AVR_ATmega2560__" />
|
||||
<Add option="-x c++" />
|
||||
<Add directory="$(ARDUINO_DIR)/arduino/cores" />
|
||||
<Add directory="$(ARDUINO_DIR)/arduino/variants/standard" />
|
||||
<Add directory="$(ARDUINO_DIR)/include" />
|
||||
</Compiler>
|
||||
<Environment>
|
||||
<Variable name="ARDUINO_DIR" value="$(APP_PATH)\ardusim" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Uno">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Uno" />
|
||||
<Variable name="BOARD_ID" value="uno" />
|
||||
<Variable name="MCU" value="atmega328p" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="115200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Leonardo">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega32U4__" />
|
||||
<Add option="-DUSB_VID=0x2341" />
|
||||
<Add option="-DUSB_PID=0x8036" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/leonardo" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Leonardo" />
|
||||
<Variable name="BOARD_ID" value="leonardo" />
|
||||
<Variable name="MCU" value="atmega32u4" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Esplora">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega32U4__" />
|
||||
<Add option="-DUSB_VID=0x2341" />
|
||||
<Add option="-DUSB_PID=0x8037" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/leonardo" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Esplora" />
|
||||
<Variable name="BOARD_ID" value="esplora" />
|
||||
<Variable name="MCU" value="atmega32u4" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Micro">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega32U4__" />
|
||||
<Add option="-DUSB_VID=0x2341" />
|
||||
<Add option="-DUSB_PID=0x803C" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/micro" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Micro" />
|
||||
<Variable name="BOARD_ID" value="micro" />
|
||||
<Variable name="MCU" value="atmega32u4" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Duemilanove (328)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Duemilanove (328)" />
|
||||
<Variable name="BOARD_ID" value="duemilanove328" />
|
||||
<Variable name="MCU" value="atmega328p" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Duemilanove (168)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega168__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Duemilanove (168)" />
|
||||
<Variable name="BOARD_ID" value="duemilanove168" />
|
||||
<Variable name="MCU" value="atmega168" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="19200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Nano (328)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Nano (328)" />
|
||||
<Variable name="BOARD_ID" value="nano328" />
|
||||
<Variable name="MCU" value="atmega328p" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Nano (168)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega168__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Nano (168)" />
|
||||
<Variable name="BOARD_ID" value="nano168" />
|
||||
<Variable name="MCU" value="atmega168" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="19200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Mini (328)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Mini (328)" />
|
||||
<Variable name="BOARD_ID" value="mini328" />
|
||||
<Variable name="MCU" value="atmega328p" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Mini (168)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega168__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Mini (168)" />
|
||||
<Variable name="BOARD_ID" value="mini168" />
|
||||
<Variable name="MCU" value="atmega168" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="19200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Pro Mini (328)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Pro Mini (328)" />
|
||||
<Variable name="BOARD_ID" value="promini328" />
|
||||
<Variable name="MCU" value="atmega328p" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Pro Mini (168)">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega168__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Pro Mini (168)" />
|
||||
<Variable name="BOARD_ID" value="promini168" />
|
||||
<Variable name="MCU" value="atmega168" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="19200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Mega 2560/ADK">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-Os" />
|
||||
<Add option="-W" />
|
||||
<Add option="-Wall" />
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega2560__" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/mega" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries/U8glib" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Mega 2560\ADK" />
|
||||
<Variable name="BOARD_ID" value="mega2560" />
|
||||
<Variable name="MCU" value="atmega2560" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Mega 1280">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega1280__" />
|
||||
<Add option="-O2" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/mega" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Mega 1280" />
|
||||
<Variable name="BOARD_ID" value="mega1280" />
|
||||
<Variable name="MCU" value="atmega1280" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="57600" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Arduino Mega 8">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Arduino Mega 8" />
|
||||
<Variable name="BOARD_ID" value="mega8" />
|
||||
<Variable name="MCU" value="atmega8" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="19200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
<Target title="Microduino Core+">
|
||||
<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
|
||||
<Option type="1" />
|
||||
<Option compiler="avrgcc" />
|
||||
<Compiler>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-DF_CPU=16000000L" />
|
||||
<Add option="-D__AVR_ATmega328P__" />
|
||||
<Add option="-Os" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
|
||||
<Add directory="$(ARDUINO_DIR)/libraries" />
|
||||
<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/plus" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add option="-mmcu=$(MCU)" />
|
||||
<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
|
||||
</Linker>
|
||||
<ExtraCommands>
|
||||
<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
|
||||
<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
|
||||
<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
|
||||
<Add after='cmd /c "avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss"' />
|
||||
</ExtraCommands>
|
||||
<Environment>
|
||||
<Variable name="BOARD" value="Microduino Core+" />
|
||||
<Variable name="BOARD_ID" value="uduino644p" />
|
||||
<Variable name="MCU" value="atmega644p" />
|
||||
<Variable name="UPLOAD_BAUDRATE" value="115200" />
|
||||
<Variable name="UPLOAD_PORT" value="" />
|
||||
</Environment>
|
||||
</Target>
|
||||
</Build>
|
||||
<Compiler>
|
||||
<Add option="-w" />
|
||||
<Add directory="." />
|
||||
</Compiler>
|
||||
<Unit filename="Commands.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="Commands.h" />
|
||||
<Unit filename="Communication.cpp" />
|
||||
<Unit filename="Communication.h" />
|
||||
<Unit filename="Configuration.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="Eeprom.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="Eeprom.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="Extruder.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="Extruder.h" />
|
||||
<Unit filename="FatStructs.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="HAL.cpp" />
|
||||
<Unit filename="HAL.h" />
|
||||
<Unit filename="Printer.cpp" />
|
||||
<Unit filename="Printer.h" />
|
||||
<Unit filename="Repetier.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="Repetier.ino">
|
||||
<Option compile="1" />
|
||||
<Option link="1" />
|
||||
<Option compiler="avrgcc" use="1" buildCommand="$compiler $options -x c++ $includes -c $file -o $object" />
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="SDCard.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="SdFat.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="SdFat.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="cores/CDC.cpp" />
|
||||
<Unit filename="cores/IPAddress.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="cores/Print.cpp" />
|
||||
<Unit filename="cores/Stream.cpp" />
|
||||
<Unit filename="cores/Tone.cpp" />
|
||||
<Unit filename="cores/USBCore.cpp" />
|
||||
<Unit filename="cores/WInterrupts.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="cores/WMath.cpp" />
|
||||
<Unit filename="cores/WString.cpp" />
|
||||
<Unit filename="cores/main.cpp" />
|
||||
<Unit filename="cores/new.cpp" />
|
||||
<Unit filename="cores/wiring.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="cores/wiring_analog.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="cores/wiring_digital.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="cores/wiring_pulse.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="cores/wiring_shift.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="fastio.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="gcode.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="gcode.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/EEPROM.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/Ethernet.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/Firmata.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/LiquidCrystal.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/MultiLCD.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
<Option target="Arduino Uno" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Micro" />
|
||||
<Option target="Arduino Duemilanove (328)" />
|
||||
<Option target="Arduino Duemilanove (168)" />
|
||||
<Option target="Arduino Nano (328)" />
|
||||
<Option target="Arduino Nano (168)" />
|
||||
<Option target="Arduino Mini (328)" />
|
||||
<Option target="Arduino Mini (168)" />
|
||||
<Option target="Arduino Pro Mini (328)" />
|
||||
<Option target="Arduino Pro Mini (168)" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
<Option target="Microduino Core+" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/OBD.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/SD.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/SPI.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/Servo.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/Stepper.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/TinyGPS.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/U8gui.h">
|
||||
<Option virtualFolder="libraries/" />
|
||||
<Option target="<{~None~}>" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/WiFi.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/Wire.cpp">
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="libraries/twi.c">
|
||||
<Option compilerVar="CC" />
|
||||
<Option compile="0" />
|
||||
<Option link="0" />
|
||||
</Unit>
|
||||
<Unit filename="motion.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="motion.h">
|
||||
<Option target="<{~None~}>" />
|
||||
</Unit>
|
||||
<Unit filename="pins.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="u8glib_ex.h" />
|
||||
<Unit filename="ui.cpp">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="ui.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="uiconfig.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="uilang.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Unit filename="uimenu.h">
|
||||
<Option target="Simulator - Debug" />
|
||||
<Option target="Simulator - Release" />
|
||||
<Option target="Arduino Leonardo" />
|
||||
<Option target="Arduino Esplora" />
|
||||
<Option target="Arduino Mega 2560/ADK" />
|
||||
<Option target="Arduino Mega 1280" />
|
||||
<Option target="Arduino Mega 8" />
|
||||
</Unit>
|
||||
<Extensions>
|
||||
<code_completion />
|
||||
<debugger />
|
||||
</Extensions>
|
||||
</Project>
|
||||
</CodeBlocks_project_file>
|
File diff suppressed because it is too large
Load diff
|
@ -23,15 +23,16 @@
|
|||
#define _REPETIER_H
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#define REPETIER_VERSION "0.92.3"
|
||||
#include <stdint.h>
|
||||
#define REPETIER_VERSION "0.92.8"
|
||||
|
||||
// ##########################################################################################
|
||||
// ## Debug configuration ##
|
||||
// ##########################################################################################
|
||||
// These are run time sqitchable debug flags
|
||||
enum debugFlags {DEB_ECHO = 0x1, DEB_INFO = 0x2, DEB_ERROR = 0x4,DEB_DRYRUN = 0x8,
|
||||
DEB_COMMUNICATION = 0x10, DEB_NOMOVES = 0x20, DEB_DEBUG = 0x40};
|
||||
DEB_COMMUNICATION = 0x10, DEB_NOMOVES = 0x20, DEB_DEBUG = 0x40
|
||||
};
|
||||
|
||||
/** Uncomment, to see detailed data for every move. Only for debugging purposes! */
|
||||
//#define DEBUG_QUEUE_MOVE
|
||||
|
@ -62,6 +63,8 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
//#define DEBUG_SEGMENT_LENGTH
|
||||
// Find the maximum real jerk during a print
|
||||
//#define DEBUG_REAL_JERK
|
||||
// Debug reason for not mounting a sd card
|
||||
//#define DEBUG_SD_ERROR
|
||||
// Uncomment the following line to enable debugging. You can better control debugging below the following line
|
||||
//#define DEBUG
|
||||
|
||||
|
@ -150,6 +153,8 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define CONTROLLER_SPARKLCD 19
|
||||
#define CONTROLLER_BAM_DICE_DUE 20
|
||||
#define CONTROLLER_VIKI2 21
|
||||
#define CONTROLLER_LCD_MP_PHARAOH_DUE 22
|
||||
#define CONTROLLER_SPARKLCD_ADAPTER 23
|
||||
#define CONTROLLER_FELIX_DUE 405
|
||||
|
||||
//direction flags
|
||||
|
@ -175,8 +180,26 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
// add pid control
|
||||
#define TEMP_PID 1
|
||||
|
||||
#define PRINTER_MODE_FFF 0
|
||||
#define PRINTER_MODE_LASER 1
|
||||
#define PRINTER_MODE_CNC 2
|
||||
// we can not prevent this as some configs need a parameter and others not
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
|
||||
#include "Configuration.h"
|
||||
|
||||
inline void memcopy2(void *dest,void *source) {
|
||||
*((int16_t*)dest) = *((int16_t*)source);
|
||||
}
|
||||
inline void memcopy4(void *dest,void *source) {
|
||||
*((int32_t*)dest) = *((int32_t*)source);
|
||||
}
|
||||
|
||||
#ifndef JSON_OUTPUT
|
||||
#define JSON_OUTPUT 0
|
||||
#endif
|
||||
|
||||
#if FEATURE_Z_PROBE && Z_PROBE_PIN < 0
|
||||
#error You need to define Z_PROBE_PIN to use z probe!
|
||||
#endif
|
||||
|
@ -230,10 +253,12 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define SPEED_MAX_MILLIS 60
|
||||
#define SPEED_MAGNIFICATION 100.0f
|
||||
|
||||
#define SOFTWARE_LEVELING (FEATURE_SOFTWARE_LEVELING && (DRIVE_SYSTEM==DELTA))
|
||||
#define SOFTWARE_LEVELING (defined(FEATURE_SOFTWARE_LEVELING) && (DRIVE_SYSTEM==DELTA))
|
||||
/** \brief Horizontal distance bridged by the diagonal push rod when the end effector is in the center. It is pretty close to 50% of the push rod length (250 mm).
|
||||
*/
|
||||
#ifndef ROD_RADIUS
|
||||
#define ROD_RADIUS (PRINTER_RADIUS-END_EFFECTOR_HORIZONTAL_OFFSET-CARRIAGE_HORIZONTAL_OFFSET)
|
||||
#endif
|
||||
|
||||
#ifndef UI_SPEEDDEPENDENT_POSITIONING
|
||||
#define UI_SPEEDDEPENDENT_POSITIONING true
|
||||
|
@ -276,16 +301,28 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define SHARED_COOLER 0
|
||||
#endif
|
||||
|
||||
#ifndef START_STEP_WITH_HIGH
|
||||
#define START_STEP_WITH_HIGH 1
|
||||
#endif
|
||||
|
||||
#if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE == 101
|
||||
#define SUPPORT_MAX6675
|
||||
#endif
|
||||
|
||||
#if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE == 102
|
||||
#define SUPPORT_MAX31855
|
||||
#endif
|
||||
|
||||
// Test for shared coolers between extruders and mainboard
|
||||
#if EXT0_EXTRUDER_COOLER_PIN > -1 && EXT0_EXTRUDER_COOLER_PIN == FAN_BOARD_PIN
|
||||
#define SHARED_COOLER_BOARD_EXT 1
|
||||
#define SHARED_COOLER_BOARD_EXT 1
|
||||
#else
|
||||
#define SHARED_COOLER_BOARD_EXT 0
|
||||
#define SHARED_COOLER_BOARD_EXT 0
|
||||
#endif
|
||||
|
||||
#if defined(UI_SERVO_CONTROL) && UI_SERVO_CONTROL > FEATURE_SERVO
|
||||
#undef UI_SERVO_CONTROL
|
||||
#define UI_SERVO_CONTROL FEATURE_SERVO
|
||||
#undef UI_SERVO_CONTROL
|
||||
#define UI_SERVO_CONTROL FEATURE_SERVO
|
||||
#endif
|
||||
|
||||
#if (defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1) || (defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1) || (defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1) || (defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1) || (defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1) || (defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1)
|
||||
|
@ -293,6 +330,9 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#else
|
||||
#define EXTRUDER_JAM_CONTROL 0
|
||||
#endif
|
||||
#ifndef JAM_METHOD
|
||||
#define JAM_METHOD 1
|
||||
#endif
|
||||
|
||||
#if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE < 101
|
||||
#define EXT0_ANALOG_INPUTS 1
|
||||
|
@ -306,7 +346,7 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define EXT0_ANALOG_CHANNEL
|
||||
#endif
|
||||
|
||||
#if NUM_EXTRUDER>1 && EXT1_TEMPSENSOR_TYPE<101
|
||||
#if NUM_EXTRUDER > 1 && EXT1_TEMPSENSOR_TYPE < 101
|
||||
#define EXT1_ANALOG_INPUTS 1
|
||||
#define EXT1_SENSOR_INDEX EXT0_ANALOG_INPUTS
|
||||
#define EXT1_ANALOG_CHANNEL ACCOMMA0 EXT1_TEMPSENSOR_PIN
|
||||
|
@ -318,7 +358,7 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define EXT1_ANALOG_CHANNEL
|
||||
#endif
|
||||
|
||||
#if NUM_EXTRUDER>2 && EXT2_TEMPSENSOR_TYPE<101
|
||||
#if NUM_EXTRUDER > 2 && EXT2_TEMPSENSOR_TYPE<101
|
||||
#define EXT2_ANALOG_INPUTS 1
|
||||
#define EXT2_SENSOR_INDEX EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS
|
||||
#define EXT2_ANALOG_CHANNEL ACCOMMA1 EXT2_TEMPSENSOR_PIN
|
||||
|
@ -354,7 +394,7 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define EXT4_ANALOG_CHANNEL
|
||||
#endif
|
||||
|
||||
#if NUM_EXTRUDER>5 && EXT5_TEMPSENSOR_TYPE<101
|
||||
#if NUM_EXTRUDER > 5 && EXT5_TEMPSENSOR_TYPE<101
|
||||
#define EXT5_ANALOG_INPUTS 1
|
||||
#define EXT5_SENSOR_INDEX EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS
|
||||
#define EXT5_ANALOG_CHANNEL ACCOMMA4 EXT5_TEMPSENSOR_PIN
|
||||
|
@ -370,12 +410,22 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define BED_ANALOG_INPUTS 1
|
||||
#define BED_SENSOR_INDEX EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS
|
||||
#define BED_ANALOG_CHANNEL ACCOMMA5 HEATED_BED_SENSOR_PIN
|
||||
#undef KOMMA
|
||||
#define KOMMA ,
|
||||
#undef BEKOMMA
|
||||
#define BED_KOMMA ,
|
||||
#else
|
||||
#define BED_ANALOG_INPUTS 0
|
||||
#define BED_SENSOR_INDEX HEATED_BED_SENSOR_PIN
|
||||
#define BED_ANALOG_CHANNEL
|
||||
#define BED_KOMMA ACCOMMA5
|
||||
#endif
|
||||
|
||||
#if FAN_THERMO_THERMISTOR_PIN > -1 && FAN_THERMO_PIN > -1
|
||||
#define THERMO_ANALOG_INPUTS 1
|
||||
#define THERMO_ANALOG_INDEX EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS+BED_ANALOG_INPUTS
|
||||
#define THERMO_ANALOG_CHANNEL BED_KOMMA FAN_THERMO_THERMISTOR_PIN
|
||||
#else
|
||||
#define THERMO_ANALOG_INPUTS 0
|
||||
#define THERMO_ANALOG_CHANNEL
|
||||
#endif
|
||||
|
||||
#ifndef DEBUG_FREE_MEMORY
|
||||
|
@ -385,10 +435,10 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#endif
|
||||
|
||||
/** \brief number of analog input signals. Normally 1 for each temperature sensor */
|
||||
#define ANALOG_INPUTS (EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS+BED_ANALOG_INPUTS)
|
||||
#if ANALOG_INPUTS>0
|
||||
#define ANALOG_INPUTS (EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS+BED_ANALOG_INPUTS+THERMO_ANALOG_INPUTS)
|
||||
#if ANALOG_INPUTS > 0
|
||||
/** Channels are the MUX-part of ADMUX register */
|
||||
#define ANALOG_INPUT_CHANNELS {EXT0_ANALOG_CHANNEL EXT1_ANALOG_CHANNEL EXT2_ANALOG_CHANNEL EXT3_ANALOG_CHANNEL EXT4_ANALOG_CHANNEL EXT5_ANALOG_CHANNEL BED_ANALOG_CHANNEL}
|
||||
#define ANALOG_INPUT_CHANNELS {EXT0_ANALOG_CHANNEL EXT1_ANALOG_CHANNEL EXT2_ANALOG_CHANNEL EXT3_ANALOG_CHANNEL EXT4_ANALOG_CHANNEL EXT5_ANALOG_CHANNEL BED_ANALOG_CHANNEL THERMO_ANALOG_CHANNEL}
|
||||
#endif
|
||||
|
||||
#define MENU_MODE_SD_MOUNTED 1
|
||||
|
@ -399,6 +449,22 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#define MENU_MODE_FULL_PID 32
|
||||
#define MENU_MODE_DEADTIME 64
|
||||
|
||||
#ifndef BENDING_CORRECTION_A
|
||||
#define BENDING_CORRECTION_A 0
|
||||
#endif
|
||||
|
||||
#ifndef BENDING_CORRECTION_B
|
||||
#define BENDING_CORRECTION_B 0
|
||||
#endif
|
||||
|
||||
#ifndef BENDING_CORRECTION_C
|
||||
#define BENDING_CORRECTION_C 0
|
||||
#endif
|
||||
|
||||
#ifndef Z_ACCELERATION_TOP
|
||||
#define Z_ACCELERATION_TOP 0
|
||||
#endif
|
||||
|
||||
#include "HAL.h"
|
||||
#include "gcode.h"
|
||||
#define MAX_VFAT_ENTRIES (2)
|
||||
|
@ -411,9 +477,9 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
|
||||
|
||||
#if UI_DISPLAY_TYPE != DISPLAY_U8G
|
||||
#if (defined(USER_KEY1_PIN) && (USER_KEY1_PIN==UI_DISPLAY_D5_PIN || USER_KEY1_PIN==UI_DISPLAY_D6_PIN || USER_KEY1_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY2_PIN) && (USER_KEY2_PIN==UI_DISPLAY_D5_PIN || USER_KEY2_PIN==UI_DISPLAY_D6_PIN || USER_KEY2_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY3_PIN) && (USER_KEY3_PIN==UI_DISPLAY_D5_PIN || USER_KEY3_PIN==UI_DISPLAY_D6_PIN || USER_KEY3_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY4_PIN) && (USER_KEY4_PIN==UI_DISPLAY_D5_PIN || USER_KEY4_PIN==UI_DISPLAY_D6_PIN || USER_KEY4_PIN==UI_DISPLAY_D7_PIN))
|
||||
#error "You cannot use DISPLAY_D5_PIN, DISPLAY_D6_PIN or DISPLAY_D7_PIN for "User Keys" with character LCD display"
|
||||
#endif
|
||||
#if (defined(USER_KEY1_PIN) && (USER_KEY1_PIN==UI_DISPLAY_D5_PIN || USER_KEY1_PIN==UI_DISPLAY_D6_PIN || USER_KEY1_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY2_PIN) && (USER_KEY2_PIN==UI_DISPLAY_D5_PIN || USER_KEY2_PIN==UI_DISPLAY_D6_PIN || USER_KEY2_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY3_PIN) && (USER_KEY3_PIN==UI_DISPLAY_D5_PIN || USER_KEY3_PIN==UI_DISPLAY_D6_PIN || USER_KEY3_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY4_PIN) && (USER_KEY4_PIN==UI_DISPLAY_D5_PIN || USER_KEY4_PIN==UI_DISPLAY_D6_PIN || USER_KEY4_PIN==UI_DISPLAY_D7_PIN))
|
||||
#error You cannot use DISPLAY_D5_PIN, DISPLAY_D6_PIN or DISPLAY_D7_PIN for "User Keys" with character LCD display
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
@ -442,65 +508,271 @@ usage or for seraching for memory induced errors. Switch it off for production,
|
|||
#undef min
|
||||
#undef max
|
||||
|
||||
class RMath {
|
||||
class RMath
|
||||
{
|
||||
public:
|
||||
static inline float min(float a,float b) {
|
||||
if(a<b) return a;
|
||||
static inline float min(float a,float b)
|
||||
{
|
||||
if(a < b) return a;
|
||||
return b;
|
||||
}
|
||||
static inline float max(float a,float b) {
|
||||
if(a<b) return b;
|
||||
static inline float max(float a,float b)
|
||||
{
|
||||
if(a < b) return b;
|
||||
return a;
|
||||
}
|
||||
static inline int32_t min(int32_t a,int32_t b) {
|
||||
if(a<b) return a;
|
||||
static inline int32_t min(int32_t a,int32_t b)
|
||||
{
|
||||
if(a < b) return a;
|
||||
return b;
|
||||
}
|
||||
static inline int32_t min(int32_t a,int32_t b, int32_t c) {
|
||||
if(a<b) return a<c ? a : c;
|
||||
return b<c ? b : c;
|
||||
static inline int32_t min(int32_t a,int32_t b, int32_t c)
|
||||
{
|
||||
if(a < b) return a < c ? a : c;
|
||||
return b<c ? b : c;
|
||||
}
|
||||
static inline float min(float a,float b, float c) {
|
||||
if(a<b) return a<c ? a : c;
|
||||
return b<c ? b : c;
|
||||
static inline float min(float a,float b, float c)
|
||||
{
|
||||
if(a < b) return a < c ? a : c;
|
||||
return b < c ? b : c;
|
||||
}
|
||||
static inline int32_t max(int32_t a,int32_t b) {
|
||||
if(a<b) return b;
|
||||
static inline int32_t max(int32_t a,int32_t b)
|
||||
{
|
||||
if(a < b) return b;
|
||||
return a;
|
||||
}
|
||||
static inline int min(int a,int b) {
|
||||
if(a<b) return a;
|
||||
static inline int min(int a,int b)
|
||||
{
|
||||
if(a < b) return a;
|
||||
return b;
|
||||
}
|
||||
static inline uint16_t min(uint16_t a,uint16_t b) {
|
||||
if(a<b) return a;
|
||||
static inline uint16_t min(uint16_t a,uint16_t b)
|
||||
{
|
||||
if(a < b) return a;
|
||||
return b;
|
||||
}
|
||||
static inline int16_t max(int16_t a,int16_t b) {
|
||||
if(a<b) return b;
|
||||
static inline int16_t max(int16_t a,int16_t b)
|
||||
{
|
||||
if(a < b) return b;
|
||||
return a;
|
||||
}
|
||||
static inline uint16_t max(uint16_t a,uint16_t b) {
|
||||
if(a<b) return b;
|
||||
static inline uint16_t max(uint16_t a,uint16_t b)
|
||||
{
|
||||
if(a < b) return b;
|
||||
return a;
|
||||
}
|
||||
static inline unsigned long absLong(long a) {return a >= 0 ? a : -a;}
|
||||
static inline int32_t sqr(int32_t a) {return a*a;}
|
||||
static inline uint32_t sqr(uint32_t a) {return a*a;}
|
||||
static inline unsigned long absLong(long a)
|
||||
{
|
||||
return a >= 0 ? a : -a;
|
||||
}
|
||||
static inline int32_t sqr(int32_t a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
static inline uint32_t sqr(uint32_t a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
#ifdef SUPPORT_64_BIT_MATH
|
||||
static inline int64_t sqr(int64_t a) {return a*a;}
|
||||
static inline uint64_t sqr(uint64_t a) {return a*a;}
|
||||
static inline int64_t sqr(int64_t a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
static inline uint64_t sqr(uint64_t a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline float sqr(float a) {return a*a;}
|
||||
static inline float sqr(float a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
};
|
||||
|
||||
class RVector3
|
||||
{
|
||||
public:
|
||||
float x, y, z;
|
||||
RVector3(float _x = 0,float _y = 0,float _z = 0):x(_x),y(_y),z(_z) {};
|
||||
RVector3(const RVector3 &a):x(a.x),y(a.y),z(a.z) {};
|
||||
|
||||
|
||||
/* const float &operator[](std::size_t idx) const
|
||||
{
|
||||
if(idx == 0) return x;
|
||||
if(idx == 1) return y;
|
||||
return z;
|
||||
};
|
||||
|
||||
float &operator[](std::size_t idx)
|
||||
{
|
||||
switch(idx) {
|
||||
case 0: return x;
|
||||
case 1: return y;
|
||||
case 2: return z;
|
||||
}
|
||||
return 0;
|
||||
};*/
|
||||
|
||||
inline bool operator==(const RVector3 &rhs)
|
||||
{
|
||||
return x==rhs.x && y==rhs.y && z==rhs.z;
|
||||
}
|
||||
inline bool operator!=(const RVector3 &rhs)
|
||||
{
|
||||
return !(*this==rhs);
|
||||
}
|
||||
inline RVector3& operator=(const RVector3 &rhs)
|
||||
{
|
||||
if(this!=&rhs)
|
||||
{
|
||||
x = rhs.x;
|
||||
y = rhs.y;
|
||||
z = rhs.z;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline RVector3& operator+=(const RVector3 &rhs)
|
||||
{
|
||||
x += rhs.x;
|
||||
y += rhs.y;
|
||||
z += rhs.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline RVector3& operator-=(const RVector3 &rhs)
|
||||
{
|
||||
x -= rhs.x;
|
||||
y -= rhs.y;
|
||||
z -= rhs.z;
|
||||
return *this;
|
||||
}
|
||||
inline RVector3 operator-() const
|
||||
{
|
||||
return RVector3(-x,-y,-z);
|
||||
}
|
||||
|
||||
inline float length() const
|
||||
{
|
||||
return sqrt(x * x + y * y + z * z);
|
||||
}
|
||||
|
||||
inline float lengthSquared() const
|
||||
{
|
||||
return (x*x+y*y+z*z);
|
||||
}
|
||||
|
||||
inline RVector3 cross(const RVector3 &b) const
|
||||
{
|
||||
return RVector3(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);
|
||||
}
|
||||
inline float scalar(const RVector3 &b) const
|
||||
{
|
||||
return (x*b.x+y*b.y+z*b.z);
|
||||
}
|
||||
inline RVector3 scale(float factor) const
|
||||
{
|
||||
return RVector3(x*factor,y*factor,z*factor);
|
||||
}
|
||||
inline void scaleIntern(float factor)
|
||||
{
|
||||
x*=factor;
|
||||
y*=factor;
|
||||
z*=factor;
|
||||
}
|
||||
inline void setMinimum(const RVector3 &b)
|
||||
{
|
||||
x = RMath::min(x,b.x);
|
||||
y = RMath::min(y,b.y);
|
||||
z = RMath::min(z,b.z);
|
||||
}
|
||||
inline void setMaximum(const RVector3 &b)
|
||||
{
|
||||
x = RMath::max(x,b.x);
|
||||
y = RMath::max(y,b.y);
|
||||
z = RMath::max(z,b.z);
|
||||
}
|
||||
inline float distance(const RVector3 &b) const
|
||||
{
|
||||
float dx = b.x-x,dy = b.y-y, dz = b.z-z;
|
||||
return (sqrt(dx*dx+dy*dy+dz*dz));
|
||||
}
|
||||
inline float angle(RVector3 &direction)
|
||||
{
|
||||
return static_cast<float>(acos(scalar(direction)/(length()*direction.length())));
|
||||
}
|
||||
|
||||
inline RVector3 normalize() const
|
||||
{
|
||||
float len = length();
|
||||
if(len != 0) len = static_cast<float>(1.0/len);
|
||||
return RVector3(x*len,y*len,z*len);
|
||||
}
|
||||
|
||||
inline RVector3 interpolatePosition(const RVector3 &b, float pos) const
|
||||
{
|
||||
float pos2 = 1.0f - pos;
|
||||
return RVector3(x * pos2 + b.x * pos, y * pos2 + b.y * pos, z * pos2 + b.z * pos);
|
||||
}
|
||||
|
||||
inline RVector3 interpolateDirection(const RVector3 &b,float pos) const
|
||||
{
|
||||
//float pos2 = 1.0f - pos;
|
||||
|
||||
float dot = scalar(b);
|
||||
if (dot > 0.9995 || dot < -0.9995)
|
||||
return interpolatePosition(b,pos); // cases cause trouble, use linear interpolation here
|
||||
|
||||
float theta = acos(dot) * pos; // interpolated position
|
||||
float st = sin(theta);
|
||||
RVector3 t(b);
|
||||
t -= scale(dot);
|
||||
float lengthSq = t.lengthSquared();
|
||||
float dl = st * ((lengthSq < 0.0001f) ? 1.0f : 1.0f / sqrt(lengthSq));
|
||||
t.scaleIntern(dl);
|
||||
t += scale(cos(theta));
|
||||
return t.normalize();
|
||||
}
|
||||
};
|
||||
inline RVector3 operator+(RVector3 lhs, const RVector3& rhs) // first arg by value, second by const ref
|
||||
{
|
||||
lhs.x += rhs.x;
|
||||
lhs.y += rhs.y;
|
||||
lhs.z += rhs.z;
|
||||
return lhs;
|
||||
}
|
||||
|
||||
inline RVector3 operator-(RVector3 lhs, const RVector3& rhs) // first arg by value, second by const ref
|
||||
{
|
||||
lhs.x -= rhs.x;
|
||||
lhs.y -= rhs.y;
|
||||
lhs.z -= rhs.z;
|
||||
return lhs;
|
||||
}
|
||||
|
||||
inline RVector3 operator*(const RVector3 &lhs,float rhs) {
|
||||
return lhs.scale(rhs);
|
||||
}
|
||||
|
||||
inline RVector3 operator*(float lhs,const RVector3 &rhs) {
|
||||
return rhs.scale(lhs);
|
||||
}
|
||||
extern const uint8 osAnalogInputChannels[] PROGMEM;
|
||||
//extern uint8 osAnalogInputCounter[ANALOG_INPUTS];
|
||||
//extern uint osAnalogInputBuildup[ANALOG_INPUTS];
|
||||
//extern uint8 osAnalogInputPos; // Current sampling position
|
||||
#if ANALOG_INPUTS > 0
|
||||
extern volatile uint osAnalogInputValues[ANALOG_INPUTS];
|
||||
extern uint8_t pwm_pos[NUM_EXTRUDER+3]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
|
||||
#endif
|
||||
#define PWM_HEATED_BED NUM_EXTRUDER
|
||||
#define PWM_BOARD_FAN PWM_HEATED_BED+1
|
||||
#define PWM_FAN1 PWM_BOARD_FAN+1
|
||||
#define PWM_FAN2 PWM_FAN1+1
|
||||
#define PWM_FAN_THERMO PWM_FAN2+1
|
||||
#define NUM_PWM PWM_FAN_THERMO+1
|
||||
extern uint8_t pwm_pos[NUM_PWM]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
|
||||
#if USE_ADVANCE
|
||||
#if ENABLE_QUADRATIC_ADVANCE
|
||||
extern int maxadv;
|
||||
|
@ -542,10 +814,6 @@ extern void microstepInit();
|
|||
#include "Printer.h"
|
||||
#include "motion.h"
|
||||
extern long baudrate;
|
||||
#if OS_ANALOG_INPUTS>0
|
||||
// Get last result for pin x
|
||||
extern volatile uint osAnalogInputValues[OS_ANALOG_INPUTS];
|
||||
#endif
|
||||
|
||||
#include "HAL.h"
|
||||
|
||||
|
@ -554,8 +822,12 @@ extern unsigned int counterPeriodical;
|
|||
extern volatile uint8_t executePeriodical;
|
||||
extern uint8_t counter250ms;
|
||||
extern void writeMonitor();
|
||||
#if FEATURE_FAN_CONTROL
|
||||
extern uint8_t fanKickstart;
|
||||
|
||||
#endif
|
||||
#if FEATURE_FAN2_CONTROL
|
||||
extern uint8_t fan2Kickstart;
|
||||
#endif
|
||||
|
||||
#if SDSUPPORT
|
||||
extern char tempLongFilename[LONG_FILENAME_LENGTH+1];
|
||||
|
@ -564,51 +836,65 @@ extern char fullName[LONG_FILENAME_LENGTH*SD_MAX_FOLDER_DEPTH+SD_MAX_FOLDER_DEPT
|
|||
#include "SdFat.h"
|
||||
|
||||
enum LsAction {LS_SerialPrint,LS_Count,LS_GetFilename};
|
||||
class SDCard {
|
||||
class SDCard
|
||||
{
|
||||
public:
|
||||
SdFat fat;
|
||||
//Sd2Card card; // ~14 Byte
|
||||
//SdVolume volume;
|
||||
//SdFile root;
|
||||
//SdFile dir[SD_MAX_FOLDER_DEPTH+1];
|
||||
SdFile file;
|
||||
uint32_t filesize;
|
||||
uint32_t sdpos;
|
||||
//char fullName[13*SD_MAX_FOLDER_DEPTH+13]; // Fill name
|
||||
char *shortname; // Pointer to start of filename itself
|
||||
char *pathend; // File to char where pathname in fullname ends
|
||||
uint8_t sdmode; // true if we are printing from sd card, 2 = stop accepting new commands
|
||||
bool sdactive;
|
||||
//int16_t n;
|
||||
bool savetosd;
|
||||
SdBaseFile parentFound;
|
||||
SdFat fat;
|
||||
//Sd2Card card; // ~14 Byte
|
||||
//SdVolume volume;
|
||||
//SdFile root;
|
||||
//SdFile dir[SD_MAX_FOLDER_DEPTH+1];
|
||||
SdFile file;
|
||||
#if JSON_OUTPUT
|
||||
GCodeFileInfo fileInfo;
|
||||
#endif
|
||||
uint32_t filesize;
|
||||
uint32_t sdpos;
|
||||
//char fullName[13*SD_MAX_FOLDER_DEPTH+13]; // Fill name
|
||||
char *shortname; // Pointer to start of filename itself
|
||||
char *pathend; // File to char where pathname in fullname ends
|
||||
uint8_t sdmode; // true if we are printing from sd card, 2 = stop accepting new commands
|
||||
bool sdactive;
|
||||
//int16_t n;
|
||||
bool savetosd;
|
||||
SdBaseFile parentFound;
|
||||
|
||||
SDCard();
|
||||
void initsd();
|
||||
void writeCommand(GCode *code);
|
||||
bool selectFile(const char *filename,bool silent=false);
|
||||
void mount();
|
||||
void unmount();
|
||||
void startPrint();
|
||||
void pausePrint(bool intern = false);
|
||||
void continuePrint(bool intern = false);
|
||||
void stopPrint();
|
||||
inline void setIndex(uint32_t newpos) { if(!sdactive) return; sdpos = newpos;file.seekSet(sdpos);}
|
||||
void printStatus();
|
||||
void ls();
|
||||
void startWrite(char *filename);
|
||||
void deleteFile(char *filename);
|
||||
void finishWrite();
|
||||
char *createFilename(char *buffer,const dir_t &p);
|
||||
void makeDirectory(char *filename);
|
||||
bool showFilename(const uint8_t *name);
|
||||
void automount();
|
||||
SDCard();
|
||||
void initsd();
|
||||
void writeCommand(GCode *code);
|
||||
bool selectFile(const char *filename,bool silent=false);
|
||||
void mount();
|
||||
void unmount();
|
||||
void startPrint();
|
||||
void pausePrint(bool intern = false);
|
||||
void continuePrint(bool intern = false);
|
||||
void stopPrint();
|
||||
inline void setIndex(uint32_t newpos)
|
||||
{
|
||||
if(!sdactive) return;
|
||||
sdpos = newpos;
|
||||
file.seekSet(sdpos);
|
||||
}
|
||||
void printStatus();
|
||||
void ls();
|
||||
#if JSON_OUTPUT
|
||||
void lsJSON(const char *filename);
|
||||
void JSONFileInfo(const char *filename);
|
||||
static void printEscapeChars(const char *s);
|
||||
#endif
|
||||
void startWrite(char *filename);
|
||||
void deleteFile(char *filename);
|
||||
void finishWrite();
|
||||
char *createFilename(char *buffer,const dir_t &p);
|
||||
void makeDirectory(char *filename);
|
||||
bool showFilename(const uint8_t *name);
|
||||
void automount();
|
||||
#ifdef GLENN_DEBUG
|
||||
void writeToFile();
|
||||
void writeToFile();
|
||||
#endif
|
||||
private:
|
||||
uint8_t lsRecursive(SdBaseFile *parent,uint8_t level,char *findFilename);
|
||||
// SdFile *getDirectory(char* name);
|
||||
uint8_t lsRecursive(SdBaseFile *parent,uint8_t level,char *findFilename);
|
||||
// SdFile *getDirectory(char* name);
|
||||
};
|
||||
|
||||
extern SDCard sd;
|
||||
|
@ -652,5 +938,3 @@ extern int debugWaitLoop;
|
|||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
@ -39,7 +39,7 @@ Implemented Codes
|
|||
- G0 -> G1
|
||||
- G1 - Coordinated Movement X Y Z E, S1 disables boundary check, S0 enables it
|
||||
- G4 - Dwell S<seconds> or P<milliseconds>
|
||||
- G10 S<1 = long retract, 0 = short retract = default> retracts filament accoridng to stored setting
|
||||
- G10 S<1 = long retract, 0 = short retract = default> retracts filament according to stored setting
|
||||
- G11 S<1 = long retract, 0 = short retract = default> = Undo retraction according to stored setting
|
||||
- G20 - Units for G0/G1 are inches.
|
||||
- G21 - Units for G0/G1 are mm.
|
||||
|
@ -47,19 +47,21 @@ Implemented Codes
|
|||
- G29 S<0..2> - Z-Probe at the 3 defined probe points. S = 1 measure avg. zHeight, S = 2 store avg zHeight
|
||||
- G30 P<0..3> - Single z-probe at current position P = 1 first measurement, P = 2 Last measurement P = 0 or 3 first and last measurement
|
||||
- G31 - Write signal of probe sensor
|
||||
- G32 S<0..2> P<0..1> - Autolevel print bed. S = 1 measure zLength, S = 2 Measue and store new zLength
|
||||
- G32 S<0..2> P<0..1> - Autolevel print bed. S = 1 measure zLength, S = 2 Measure and store new zLength
|
||||
- G90 - Use absolute coordinates
|
||||
- G91 - Use relative coordinates
|
||||
- G92 - Set current position to cordinates given
|
||||
- G92 - Set current position to coordinates given
|
||||
- G131 - set extruder offset position to 0 - needed for calibration with G132
|
||||
- G132 - calibrate endstop positions. Call this, after calling G131 and after centering the extruder holder.
|
||||
- G133 - measure steps until max endstops for deltas. Can be used to detect lost steps within tolerances of endstops.
|
||||
- G134 Px Sx Zx - Calibrate nozzle height difference (need z probe in nozzle!) Px = reference extruder, Sx = only measure extrude x against reference, Zx = add to measured z distance for Sx for correction.
|
||||
|
||||
RepRap M Codes
|
||||
|
||||
- M104 - Set extruder target temp
|
||||
- M105 - Read current temp
|
||||
- M106 - Fan on
|
||||
- M107 - Fan off
|
||||
- M106 S<speed> P<fan> - Fan on speed = 0..255, P = 0 or 1, 0 is default and can be omitted
|
||||
- M107 P<fan> - Fan off, P = 0 or 1, 0 is default and can be omitted
|
||||
- M109 - Wait for extruder current temp to reach target temp.
|
||||
- M114 - Display current position
|
||||
|
||||
|
@ -109,6 +111,7 @@ Custom M Codes
|
|||
- M209 S<0/1> - Enable/disable autoretraction
|
||||
- M220 S<Feedrate multiplier in percent> - Increase/decrease given feedrate
|
||||
- M221 S<Extrusion flow multiplier in percent> - Increase/decrease given flow rate
|
||||
- M228 P<pin> S<state 0/1> - Wait for pin getting state S. Add X0 to init as input without pullup and X1 for input with pullup.
|
||||
- M231 S<OPS_MODE> X<Min_Distance> Y<Retract> Z<Backlash> F<ReatrctMove> - Set OPS parameter
|
||||
- M232 - Read and reset max. advance values
|
||||
- M233 X<AdvanceK> Y<AdvanceL> - Set temporary advance K-value to X and linear term advanceL to Y
|
||||
|
@ -129,6 +132,11 @@ Custom M Codes
|
|||
- M400 - Wait until move buffers empty.
|
||||
- M401 - Store x, y and z position.
|
||||
- M402 - Go to stored position. If X, Y or Z is specified, only these coordinates are used. F changes feedrate fo rthat move.
|
||||
- M450 - Reports printer mode
|
||||
- M451 - Set printer mode to FFF
|
||||
- M452 - Set printer mode to laser
|
||||
- M453 - Set printer mode to CNC
|
||||
- M460 X<minTemp> Y<maxTemp> : Set temperature range for thermistor controlled fan
|
||||
- M500 Store settings to EEPROM
|
||||
- M501 Load settings from EEPROM
|
||||
- M502 Reset settings to the one in configuration.h. Does not store values in EEPROM!
|
||||
|
@ -163,5 +171,3 @@ void loop()
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -1,213 +0,0 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
|
||||
<CodeBlocks_layout_file>
|
||||
<ActiveTarget name="Arduino Mega 2560/ADK" />
|
||||
<File name="fastio.h" open="0" top="0" tabpos="25" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="2263" topLine="59" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="gcode.cpp" open="1" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="21260" topLine="603" />
|
||||
</Cursor>
|
||||
<Folding>
|
||||
<Collapse line="231" />
|
||||
<Collapse line="239" />
|
||||
</Folding>
|
||||
</File>
|
||||
<File name="gcode.h" open="1" top="0" tabpos="16" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="1228" topLine="15" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="libraries\EEPROM.cpp" open="0" top="0" tabpos="29" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="libraries\Ethernet.cpp" open="0" top="0" tabpos="28" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Printer.cpp" open="1" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="2659" topLine="26" />
|
||||
</Cursor>
|
||||
<Folding>
|
||||
<Collapse line="179" />
|
||||
<Collapse line="1059" />
|
||||
</Folding>
|
||||
</File>
|
||||
<File name="Printer.h" open="1" top="0" tabpos="15" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="7168" topLine="126" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Repetier.h" open="1" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="2489" topLine="27" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Repetier.ino" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="1912" topLine="37" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="libraries\OBD.cpp" open="0" top="0" tabpos="33" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="SDCard.cpp" open="0" top="0" tabpos="10" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="2466" topLine="71" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="SdFat.cpp" open="0" top="0" tabpos="23" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="86777" topLine="3013" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="libraries\SPI.cpp" open="0" top="0" tabpos="37" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="20" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Communication.h" open="1" top="0" tabpos="17" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="10270" topLine="346" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="SdFat.h" open="0" top="0" tabpos="24" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="29389" topLine="772" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="libraries\Servo.cpp" open="0" top="0" tabpos="34" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Configuration.h" open="1" top="0" tabpos="18" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="7460" topLine="217" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="motion.cpp" open="1" top="1" tabpos="12" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="26758" topLine="645" />
|
||||
</Cursor>
|
||||
<Folding>
|
||||
<Collapse line="891" />
|
||||
<Collapse line="912" />
|
||||
<Collapse line="938" />
|
||||
<Collapse line="1397" />
|
||||
</Folding>
|
||||
</File>
|
||||
<File name="libraries\Stepper.cpp" open="0" top="0" tabpos="36" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Eeprom.cpp" open="1" top="0" tabpos="19" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="26476" topLine="616" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="motion.h" open="1" top="0" tabpos="13" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="18497" topLine="629" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Eeprom.h" open="1" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="pins.h" open="1" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="32601" topLine="1166" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="cores\Print.cpp" open="0" top="0" tabpos="26" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Extruder.cpp" open="1" top="0" tabpos="11" split="0" active="1" splitpos="838" zoom_1="-1" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="34982" topLine="885" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="u8glib_ex.h" open="0" top="0" tabpos="11" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="11774" topLine="315" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="cores\Stream.cpp" open="0" top="0" tabpos="27" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="0" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Extruder.h" open="0" top="0" tabpos="16" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="1209" topLine="13" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="ui.cpp" open="1" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="89117" topLine="2763" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="FatStructs.h" open="0" top="0" tabpos="24" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="952" topLine="0" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="ui.h" open="1" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="24207" topLine="12" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="HAL.cpp" open="1" top="0" tabpos="20" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="12287" topLine="267" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="uiconfig.h" open="0" top="0" tabpos="23" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="2235" topLine="48" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="HAL.h" open="1" top="0" tabpos="21" split="0" active="1" splitpos="0" zoom_1="1" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="7282" topLine="212" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="uilang.h" open="0" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="9398" topLine="202" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Commands.cpp" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="-2" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="56856" topLine="1491" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="uimenu.h" open="1" top="0" tabpos="10" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="13785" topLine="361" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Commands.h" open="0" top="0" tabpos="19" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="1295" topLine="10" />
|
||||
</Cursor>
|
||||
</File>
|
||||
<File name="Communication.cpp" open="1" top="0" tabpos="14" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
|
||||
<Cursor>
|
||||
<Cursor1 position="19721" topLine="459" />
|
||||
</Cursor>
|
||||
</File>
|
||||
</CodeBlocks_layout_file>
|
|
@ -41,25 +41,26 @@ void SDCard::automount()
|
|||
#if SDCARDDETECT > -1
|
||||
if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED)
|
||||
{
|
||||
if(sdactive) // Card removed
|
||||
if(sdactive || sdmode == 100) // Card removed
|
||||
{
|
||||
Com::printFLN(PSTR("SD card removed"));
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
uid.executeAction(UI_ACTION_TOP_MENU, true);
|
||||
#endif
|
||||
unmount();
|
||||
UI_STATUS(UI_TEXT_SD_REMOVED);
|
||||
UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_SD_REMOVED_ID));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!sdactive)
|
||||
if(!sdactive && sdmode != 100)
|
||||
{
|
||||
UI_STATUS(UI_TEXT_SD_INSERTED);
|
||||
Com::printFLN(PSTR("SD card inserted")); // Not translateable or host will not understand signal
|
||||
initsd();
|
||||
UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_SD_INSERTED_ID));
|
||||
mount();
|
||||
if(sdmode != 100) // send message only if we have success
|
||||
Com::printFLN(PSTR("SD card inserted")); // Not translatable or host will not understand signal
|
||||
#if UI_DISPLAY_TYPE != NO_DISPLAY
|
||||
if(sdactive) {
|
||||
if(sdactive && !uid.isWizardActive()) { // Wizards have priority
|
||||
Printer::setAutomount(true);
|
||||
uid.executeAction(UI_ACTION_SD_PRINT + UI_ACTION_TOPMENU, true);
|
||||
}
|
||||
|
@ -77,11 +78,13 @@ void SDCard::initsd()
|
|||
if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED)
|
||||
return;
|
||||
#endif
|
||||
HAL::delayMilliseconds(50); // wait for stabilization of contacts, bootup ...
|
||||
/*if(dir[0].isOpen())
|
||||
dir[0].close();*/
|
||||
if(!fat.begin(SDSS, SPI_FULL_SPEED))
|
||||
{
|
||||
Com::printFLN(Com::tSDInitFail);
|
||||
sdmode = 100; // prevent automount loop!
|
||||
return;
|
||||
}
|
||||
sdactive = true;
|
||||
|
@ -176,27 +179,31 @@ void SDCard::stopPrint()
|
|||
|
||||
void SDCard::writeCommand(GCode *code)
|
||||
{
|
||||
unsigned int sum1=0,sum2=0; // for fletcher-16 checksum
|
||||
unsigned int sum1 = 0, sum2 = 0; // for fletcher-16 checksum
|
||||
uint8_t buf[100];
|
||||
uint8_t p=2;
|
||||
uint8_t p = 2;
|
||||
file.writeError = false;
|
||||
int params = 128 | (code->params & ~1);
|
||||
*(int*)buf = params;
|
||||
uint16_t params = 128 | (code->params & ~1);
|
||||
memcopy2(buf,¶ms);
|
||||
//*(int*)buf = params;
|
||||
if(code->isV2()) // Read G,M as 16 bit value
|
||||
{
|
||||
*(int*)&buf[p] = code->params2;
|
||||
p+=2;
|
||||
memcopy2(&buf[p],&code->params2);
|
||||
//*(int*)&buf[p] = code->params2;
|
||||
p += 2;
|
||||
if(code->hasString())
|
||||
buf[p++] = strlen(code->text);
|
||||
if(code->hasM())
|
||||
{
|
||||
*(int*)&buf[p] = code->M;
|
||||
p+=2;
|
||||
memcopy2(&buf[p],&code->M);
|
||||
//*(int*)&buf[p] = code->M;
|
||||
p += 2;
|
||||
}
|
||||
if(code->hasG())
|
||||
{
|
||||
*(int*)&buf[p]= code->G;
|
||||
p+=2;
|
||||
memcopy2(&buf[p],&code->G);
|
||||
//*(int*)&buf[p]= code->G;
|
||||
p += 2;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
@ -212,28 +219,33 @@ void SDCard::writeCommand(GCode *code)
|
|||
}
|
||||
if(code->hasX())
|
||||
{
|
||||
*(float*)&buf[p] = code->X;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->X);
|
||||
//*(float*)&buf[p] = code->X;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasY())
|
||||
{
|
||||
*(float*)&buf[p] = code->Y;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->Y);
|
||||
//*(float*)&buf[p] = code->Y;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasZ())
|
||||
{
|
||||
*(float*)&buf[p] = code->Z;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->Z);
|
||||
//*(float*)&buf[p] = code->Z;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasE())
|
||||
{
|
||||
*(float*)&buf[p] = code->E;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->E);
|
||||
//*(float*)&buf[p] = code->E;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasF())
|
||||
{
|
||||
*(float*)&buf[p] = code->F;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->F);
|
||||
//*(float*)&buf[p] = code->F;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasT())
|
||||
{
|
||||
|
@ -241,23 +253,81 @@ void SDCard::writeCommand(GCode *code)
|
|||
}
|
||||
if(code->hasS())
|
||||
{
|
||||
*(long int*)&buf[p] = code->S;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->S);
|
||||
//*(int32_t*)&buf[p] = code->S;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasP())
|
||||
{
|
||||
*(long int*)&buf[p] = code->P;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->P);
|
||||
//*(int32_t*)&buf[p] = code->P;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasI())
|
||||
{
|
||||
*(float*)&buf[p] = code->I;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->I);
|
||||
//*(float*)&buf[p] = code->I;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasJ())
|
||||
{
|
||||
*(float*)&buf[p] = code->J;
|
||||
p+=4;
|
||||
memcopy4(&buf[p],&code->J);
|
||||
//*(float*)&buf[p] = code->J;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasR())
|
||||
{
|
||||
memcopy4(&buf[p],&code->R);
|
||||
//*(float*)&buf[p] = code->R;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasD())
|
||||
{
|
||||
memcopy4(&buf[p],&code->D);
|
||||
//*(float*)&buf[p] = code->D;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasC())
|
||||
{
|
||||
memcopy4(&buf[p],&code->C);
|
||||
//*(float*)&buf[p] = code->C;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasH())
|
||||
{
|
||||
memcopy4(&buf[p],&code->H);
|
||||
//*(float*)&buf[p] = code->H;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasA())
|
||||
{
|
||||
memcopy4(&buf[p],&code->A);
|
||||
//*(float*)&buf[p] = code->A;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasB())
|
||||
{
|
||||
memcopy4(&buf[p],&code->B);
|
||||
//*(float*)&buf[p] = code->B;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasK())
|
||||
{
|
||||
memcopy4(&buf[p],&code->K);
|
||||
//*(float*)&buf[p] = code->K;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasL())
|
||||
{
|
||||
memcopy4(&buf[p],&code->L);
|
||||
//*(float*)&buf[p] = code->L;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasO())
|
||||
{
|
||||
memcopy4(&buf[p],&code->O);
|
||||
//*(float*)&buf[p] = code->O;
|
||||
p += 4;
|
||||
}
|
||||
if(code->hasString()) // read 16 uint8_t into string
|
||||
{
|
||||
|
@ -269,7 +339,7 @@ void SDCard::writeCommand(GCode *code)
|
|||
}
|
||||
else
|
||||
{
|
||||
for(uint8_t i=0; i<16; ++i) buf[p++] = *sp++;
|
||||
for(uint8_t i = 0; i < 16; ++i) buf[p++] = *sp++;
|
||||
}
|
||||
}
|
||||
uint8_t *ptr = buf;
|
||||
|
@ -281,14 +351,19 @@ void SDCard::writeCommand(GCode *code)
|
|||
do
|
||||
{
|
||||
sum1 += *ptr++;
|
||||
if(sum1>=255) sum1-=255;
|
||||
if(sum1 >= 255) sum1 -= 255;
|
||||
sum2 += sum1;
|
||||
if(sum2>=255) sum2-=255;
|
||||
if(sum2 >= 255) sum2 -= 255;
|
||||
}
|
||||
while (--tlen);
|
||||
}
|
||||
buf[p++] = sum1;
|
||||
buf[p++] = sum2;
|
||||
// Debug
|
||||
/*Com::printF(PSTR("Buf: "));
|
||||
for(int i=0;i<p;i++)
|
||||
Com::printF(PSTR(" "),(int)buf[i]);
|
||||
Com::println();*/
|
||||
if(params == 128)
|
||||
{
|
||||
Com::printErrorFLN(Com::tAPIDFinished);
|
||||
|
@ -352,11 +427,97 @@ void SDCard::ls()
|
|||
Com::printFLN(Com::tEndFileList);
|
||||
}
|
||||
|
||||
#if JSON_OUTPUT
|
||||
void SDCard::lsJSON(const char *filename)
|
||||
{
|
||||
SdBaseFile dir;
|
||||
fat.chdir();
|
||||
if (*filename == 0) {
|
||||
dir.openRoot(fat.vol());
|
||||
} else {
|
||||
if (!dir.open(fat.vwd(), filename, O_READ) || !dir.isDir()) {
|
||||
Com::printF(Com::tJSONErrorStart);
|
||||
Com::printF(Com::tFileOpenFailed);
|
||||
Com::printFLN(Com::tJSONErrorEnd);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
Com::printF(Com::tJSONDir);
|
||||
SDCard::printEscapeChars(filename);
|
||||
Com::printF(Com::tJSONFiles);
|
||||
dir.lsJSON();
|
||||
Com::printFLN(Com::tJSONArrayEnd);
|
||||
}
|
||||
|
||||
void SDCard::printEscapeChars(const char *s) {
|
||||
for (unsigned int i = 0; i < strlen(s); ++i) {
|
||||
switch (s[i]) {
|
||||
case '"':
|
||||
case '/':
|
||||
case '\b':
|
||||
case '\f':
|
||||
case '\n':
|
||||
case '\r':
|
||||
case '\t':
|
||||
case '\\':
|
||||
Com::print('\\');
|
||||
break;
|
||||
}
|
||||
Com::print(s[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void SDCard::JSONFileInfo(const char* filename) {
|
||||
SdBaseFile targetFile;
|
||||
GCodeFileInfo *info,tmpInfo;
|
||||
if (strlen(filename) == 0) {
|
||||
targetFile = file;
|
||||
info = &fileInfo;
|
||||
} else {
|
||||
if (!targetFile.open(fat.vwd(), filename, O_READ) || targetFile.isDir()) {
|
||||
Com::printF(Com::tJSONErrorStart);
|
||||
Com::printF(Com::tFileOpenFailed);
|
||||
Com::printFLN(Com::tJSONErrorEnd);
|
||||
return;
|
||||
}
|
||||
info = &tmpInfo;
|
||||
info->init(targetFile);
|
||||
}
|
||||
if (!targetFile.isOpen()) {
|
||||
Com::printF(Com::tJSONErrorStart);
|
||||
Com::printF(Com::tNotSDPrinting);
|
||||
Com::printFLN(Com::tJSONErrorEnd);
|
||||
return;
|
||||
}
|
||||
|
||||
// {"err":0,"size":457574,"height":4.00,"layerHeight":0.25,"filament":[6556.3],"generatedBy":"Slic3r 1.1.7 on 2014-11-09 at 17:11:32"}
|
||||
Com::printF(Com::tJSONFileInfoStart);
|
||||
Com::print(info->fileSize);
|
||||
Com::printF(Com::tJSONFileInfoHeight);
|
||||
Com::print(info->objectHeight);
|
||||
Com::printF(Com::tJSONFileInfoLayerHeight);
|
||||
Com::print(info->layerHeight);
|
||||
Com::printF(Com::tJSONFileInfoFilament);
|
||||
Com::print(info->filamentNeeded);
|
||||
Com::printF(Com::tJSONFileInfoGeneratedBy);
|
||||
Com::print(info->generatedBy);
|
||||
Com::print('"');
|
||||
if (strlen(filename) == 0) {
|
||||
Com::printF(Com::tJSONFileInfoName);
|
||||
file.printName();
|
||||
Com::print('"');
|
||||
}
|
||||
Com::print('}');
|
||||
Com::println();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
bool SDCard::selectFile(const char *filename, bool silent)
|
||||
{
|
||||
SdBaseFile parent;
|
||||
const char *oldP = filename;
|
||||
boolean bFound;
|
||||
|
||||
if(!sdactive) return false;
|
||||
sdmode = 0;
|
||||
|
@ -376,6 +537,9 @@ bool SDCard::selectFile(const char *filename, bool silent)
|
|||
Com::printF(Com::tFileOpened, oldP);
|
||||
Com::printFLN(Com::tSpaceSizeColon,file.fileSize());
|
||||
}
|
||||
#if JSON_OUTPUT
|
||||
fileInfo.init(file);
|
||||
#endif
|
||||
sdpos = 0;
|
||||
filesize = file.fileSize();
|
||||
Com::printFLN(Com::tFileSelected);
|
||||
|
@ -414,7 +578,7 @@ void SDCard::startWrite(char *filename)
|
|||
}
|
||||
else
|
||||
{
|
||||
UI_STATUS(UI_TEXT_UPLOADING);
|
||||
UI_STATUS_F(Com::translatedF(UI_TEXT_UPLOADING_ID));
|
||||
savetosd = true;
|
||||
Com::printFLN(Com::tWritingToFile,filename);
|
||||
}
|
||||
|
@ -480,5 +644,3 @@ void SDCard::writeToFile()
|
|||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -32,11 +32,6 @@ extern int8_t RFstrnicmp(const char* s1, const char* s2, size_t n);
|
|||
|
||||
//#define GLENN_DEBUG
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------
|
||||
static void pstrPrint(FSTRINGPARAM(str)) {
|
||||
Com::printF(str);
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
static void pstrPrintln(FSTRINGPARAM(str)) {
|
||||
Com::printFLN(str);
|
||||
|
@ -652,11 +647,12 @@ void SdBaseFile::ls(uint8_t flags) {
|
|||
ls(flags, 0);
|
||||
}
|
||||
|
||||
uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound)
|
||||
uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound, bool isJson)
|
||||
{
|
||||
dir_t *p = NULL;
|
||||
uint8_t cnt=0;
|
||||
char *oldpathend = pathend;
|
||||
//uint8_t cnt=0;
|
||||
//char *oldpathend = pathend;
|
||||
bool firstFile = true;
|
||||
|
||||
parent->rewind();
|
||||
|
||||
|
@ -665,21 +661,29 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
|
|||
HAL::pingWatchdog();
|
||||
if (! (DIR_IS_FILE(p) || DIR_IS_SUBDIR(p))) continue;
|
||||
if (strcmp(tempLongFilename, "..") == 0) continue;
|
||||
if( DIR_IS_SUBDIR(p))
|
||||
{
|
||||
if(level>=SD_MAX_FOLDER_DEPTH) continue; // can't go deeper
|
||||
if(level<SD_MAX_FOLDER_DEPTH)
|
||||
{
|
||||
if (findFilename == NULL)
|
||||
{
|
||||
if(level)
|
||||
{
|
||||
Com::print(fullName);
|
||||
Com::printF(Com::tSlash);
|
||||
}
|
||||
Com::print(tempLongFilename);
|
||||
Com::printFLN(Com::tSlash); //End with / to mark it as directory entry, so we can see empty directories.
|
||||
if (tempLongFilename[0] == '.') continue; // MAC CRAP
|
||||
if (DIR_IS_SUBDIR(p)) {
|
||||
if (level >= SD_MAX_FOLDER_DEPTH) continue; // can't go deeper
|
||||
if (level < SD_MAX_FOLDER_DEPTH && findFilename == NULL) {
|
||||
if (level && !isJson) {
|
||||
Com::print(fullName);
|
||||
Com::printF(Com::tSlash);
|
||||
}
|
||||
#if JSON_OUTPUT
|
||||
if (isJson) {
|
||||
if (!firstFile) Com::print(',');
|
||||
Com::print('"');Com::print('*');
|
||||
SDCard::printEscapeChars(tempLongFilename);
|
||||
Com::print('"');
|
||||
firstFile = false;
|
||||
} else {
|
||||
Com::print(tempLongFilename);
|
||||
Com::printFLN(Com::tSlash); // End with / to mark it as directory entry, so we can see empty directories.
|
||||
}
|
||||
#else
|
||||
Com::print(tempLongFilename);
|
||||
Com::printFLN(Com::tSlash); // End with / to mark it as directory entry, so we can see empty directories.
|
||||
#endif
|
||||
}
|
||||
SdBaseFile next;
|
||||
char *tmp;
|
||||
|
@ -689,11 +693,11 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
|
|||
strcat(fullName, tempLongFilename);
|
||||
uint16_t index = (parent->curPosition()-31) >> 5;
|
||||
|
||||
if(next.open(parent, index, O_READ))
|
||||
{
|
||||
if (next.lsRecursive(&next,level+1, findFilename, pParentFound))
|
||||
if(!isJson && next.open(parent, index, O_READ))
|
||||
{
|
||||
if (next.lsRecursive(&next,level+1, findFilename, pParentFound,false))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
parent->seekSet(32 * (index + 1));
|
||||
if ((tmp = strrchr(fullName, '/'))!= NULL)
|
||||
*tmp = 0;
|
||||
|
@ -721,16 +725,27 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
|
|||
}
|
||||
else
|
||||
{
|
||||
if(level)
|
||||
if(level && !isJson)
|
||||
{
|
||||
Com::print(fullName);
|
||||
Com::printF(Com::tSlash);
|
||||
}
|
||||
Com::print(tempLongFilename);
|
||||
#if SD_EXTENDED_DIR
|
||||
Com::printF(Com::tSpace,(long)p->fileSize);
|
||||
#if JSON_OUTPUT
|
||||
if (isJson) {
|
||||
if (!firstFile) Com::printF(Com::tComma);
|
||||
Com::print('"');
|
||||
SDCard::printEscapeChars(tempLongFilename);
|
||||
Com::print('"');
|
||||
firstFile = false;
|
||||
} else
|
||||
#endif
|
||||
Com::println();
|
||||
{
|
||||
Com::print(tempLongFilename);
|
||||
#if SD_EXTENDED_DIR
|
||||
Com::printF(Com::tSpace, (long) p->fileSize);
|
||||
#endif
|
||||
Com::println();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -754,20 +769,30 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
|
|||
* list to indicate subdirectory level.
|
||||
*/
|
||||
void SdBaseFile::ls(uint8_t flags, uint8_t indent) {
|
||||
SdBaseFile parent;
|
||||
|
||||
rewind();
|
||||
SdBaseFile parent;
|
||||
rewind();
|
||||
*fullName = 0;
|
||||
pathend = fullName;
|
||||
parent = *this;
|
||||
lsRecursive(&parent, 0, NULL, NULL);
|
||||
pathend = fullName;
|
||||
parent = *this;
|
||||
lsRecursive(&parent, 0, NULL, NULL, false);
|
||||
}
|
||||
|
||||
#if JSON_OUTPUT
|
||||
void SdBaseFile::lsJSON() {
|
||||
SdBaseFile parent;
|
||||
rewind();
|
||||
*fullName = 0;
|
||||
parent = *this;
|
||||
lsRecursive(&parent, 0, NULL, NULL, true);
|
||||
}
|
||||
#endif
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// saves 32 bytes on stack for ls recursion
|
||||
// return 0 - EOF, 1 - normal file, or 2 - directory
|
||||
int8_t SdBaseFile::lsPrintNext(uint8_t flags, uint8_t indent) {
|
||||
dir_t dir;
|
||||
uint8_t w = 0;
|
||||
//uint8_t w = 0;
|
||||
while (1) {
|
||||
if (read(&dir, sizeof(dir)) != sizeof(dir)) return 0;
|
||||
if (dir.name[0] == DIR_NAME_FREE) return 0;
|
||||
|
@ -876,8 +901,6 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
|
|||
{
|
||||
return mkdir(&newParent, dname);
|
||||
}
|
||||
|
||||
fail:
|
||||
return false;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
@ -886,13 +909,13 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
|
|||
|
||||
if (!parent->isDir()) {
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
return false;
|
||||
}
|
||||
|
||||
// create a normal file
|
||||
if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR, true)) {
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
return false;
|
||||
}
|
||||
|
||||
// make entry for '.'
|
||||
|
@ -908,7 +931,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
|
|||
for (uint8_t i = 1; i < 11; i++) d.name[i] = ' ';
|
||||
|
||||
if (write(&d, sizeof(dir_t)) < 0)
|
||||
goto fail;
|
||||
return false;
|
||||
sync();
|
||||
|
||||
// make entry for '..'
|
||||
|
@ -921,18 +944,16 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
|
|||
d.firstClusterHigh = parent->firstCluster_ >> 16;
|
||||
}
|
||||
if (write(&d, sizeof(dir_t)) < 0)
|
||||
goto fail;
|
||||
return false;
|
||||
sync();
|
||||
memset(&d, 0, sizeof(dir_t));
|
||||
if (write(&d, sizeof(dir_t)) < 0)
|
||||
goto fail;
|
||||
return false;
|
||||
sync();
|
||||
// fileSize_ = 0;
|
||||
type_ = FAT_FILE_TYPE_SUBDIR;
|
||||
flags_ |= F_FILE_DIR_DIRTY;
|
||||
return true;
|
||||
fail:
|
||||
return false;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
/** Open a file in the current working directory.
|
||||
|
@ -1005,10 +1026,10 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
|
|||
SdBaseFile *newParent, boolean bMakeDirs) {
|
||||
SdBaseFile dir1, dir2;
|
||||
SdBaseFile *parent = dirFile;
|
||||
dir_t *pEntry;
|
||||
//dir_t *pEntry;
|
||||
SdBaseFile *sub = &dir1;
|
||||
char *p;
|
||||
boolean bFound;
|
||||
//boolean bFound;
|
||||
|
||||
#ifdef GLENN_DEBUG
|
||||
Commands::checkFreeMemory();
|
||||
|
@ -1052,7 +1073,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
|
|||
Commands::checkFreeMemory();
|
||||
Commands::writeLowestFreeRAM();
|
||||
#endif
|
||||
bFound = false;
|
||||
//bFound = false;
|
||||
if (!sub->open(parent, dname, O_READ, false))
|
||||
{
|
||||
if (!bMakeDirs)
|
||||
|
@ -1093,7 +1114,6 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const char* path, uint8_t oflag)
|
|||
return open(&parent, dname, oflag, false);
|
||||
}
|
||||
|
||||
fail:
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -1113,11 +1133,11 @@ uint8_t SdBaseFile::lfn_checksum(const unsigned char *pFCBName)
|
|||
bool SdBaseFile::open(SdBaseFile* dirFile,const uint8_t *dname, uint8_t oflag, bool bDir) {
|
||||
bool emptyFound = false;
|
||||
uint8_t index = 0;
|
||||
dir_t tempDir, *p;
|
||||
dir_t tempDir, *p = NULL;
|
||||
const char *tempPtr;
|
||||
char newName[SHORT_FILENAME_LENGTH+2];
|
||||
boolean bShortName = false;
|
||||
int8_t cVFATNeeded = -1, wIndex, cVFATFoundCur;
|
||||
int8_t cVFATNeeded = -1, cVFATFoundCur;
|
||||
uint32_t wIndexPos = 0;
|
||||
uint8_t cbFilename;
|
||||
char *Filename = (char *)dname;
|
||||
|
@ -1570,6 +1590,9 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
|
|||
bool SdBaseFile::openRoot(SdVolume* vol) {
|
||||
// error if file is already open
|
||||
if (isOpen()) {
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("Root already open"));
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -1587,6 +1610,10 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
|
|||
}
|
||||
} else {
|
||||
// volume is not initialized, invalid, or FAT12 without support
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorF(PSTR("volume is not initialized, invalid, or FAT12 without support, type:"));
|
||||
Com::print((int)vol->fatType());Com::println();
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -1603,6 +1630,9 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
|
|||
return true;
|
||||
|
||||
fail:
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("SD open root dir failed"));
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
@ -2055,7 +2085,7 @@ dir_t *SdBaseFile::getLongFilename(dir_t *dir, char *longFilename, int8_t cVFATN
|
|||
|
||||
bool SdBaseFile::findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound, uint32_t *pwIndexPos)
|
||||
{
|
||||
int16_t n;
|
||||
//int16_t n; // unused
|
||||
int8_t cVFATFound = 0;
|
||||
// if not a directory file or miss-positioned return an error
|
||||
if (!isDir()) return -1;
|
||||
|
@ -2081,7 +2111,7 @@ bool SdBaseFile::findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound,
|
|||
{
|
||||
if (DIR_IS_LONG_NAME(dir))
|
||||
{
|
||||
vfat_t *VFAT = (vfat_t*)dir;
|
||||
//vfat_t *VFAT = (vfat_t*)dir; // unused
|
||||
cVFATFound++;
|
||||
}
|
||||
else
|
||||
|
@ -3202,7 +3232,7 @@ uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
|
|||
|
||||
#if USE_SD_CRC
|
||||
// form message
|
||||
uint8_t d[6] = {cmd | 0X40, pa[3], pa[2], pa[1], pa[0]};
|
||||
uint8_t d[6] = {static_cast<uint8_t>(cmd | static_cast<uint8_t>(0X40)), pa[3], pa[2], pa[1], pa[0]};
|
||||
|
||||
// add crc
|
||||
d[5] = CRC7(d, 5);
|
||||
|
@ -3415,6 +3445,9 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
|
|||
|
||||
fail:
|
||||
chipSelectHigh();
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("SD card initalization failed"));
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
@ -3469,7 +3502,7 @@ bool Sd2Card::readData(uint8_t* dst, size_t count) {
|
|||
goto fail;
|
||||
}
|
||||
// transfer data
|
||||
if (status_ = spiRec(dst, count)) {
|
||||
if ((status_ = spiRec(dst, count))) {
|
||||
error(SD_CARD_ERROR_SPI_DMA);
|
||||
goto fail;
|
||||
}
|
||||
|
@ -4224,7 +4257,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
cacheStatus_ = 0; // cacheSync() will write block if true
|
||||
cacheBlockNumber_ = 0XFFFFFFFF;
|
||||
cacheFatOffset_ = 0;
|
||||
#if USE_SERARATEFAT_CACHE
|
||||
#if defined(USE_SERARATEFAT_CACHE) && USE_SERARATEFAT_CACHE
|
||||
cacheFatStatus_ = 0; // cacheSync() will write block if true
|
||||
cacheFatBlockNumber_ = 0XFFFFFFFF;
|
||||
#endif // USE_SERARATEFAT_CACHE
|
||||
|
@ -4232,11 +4265,17 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
// if part > 0 assume mbr volume with partition table
|
||||
if (part) {
|
||||
if (part > 4) {
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("volume init: illegal part"));
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
|
||||
if (!pc) {
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("volume init: cache fetch failed"));
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -4245,6 +4284,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
p->totalSectors < 100 ||
|
||||
p->firstSector == 0) {
|
||||
// not a valid partition
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("volume init: invalid partition"));
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -4252,6 +4294,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
}
|
||||
pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
|
||||
if (!pc) {
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("volume init: cache fetch failed"));
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -4261,6 +4306,13 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
fbs->reservedSectorCount == 0 ||
|
||||
fbs->sectorsPerCluster == 0) {
|
||||
// not valid FAT volume
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("volume init: not a valid FAT volume"));
|
||||
Com::printFLN(PSTR("BytesPerSector:"),fbs->bytesPerSector);
|
||||
Com::printFLN(PSTR("fatCount:"),fbs->fatCount);
|
||||
Com::printFLN(PSTR("reservedSectorCount:"),fbs->reservedSectorCount);
|
||||
Com::printFLN(PSTR("sectorsPerCluster:"),fbs->sectorsPerCluster);
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -4303,6 +4355,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
if (clusterCount_ < 4085) {
|
||||
fatType_ = 12;
|
||||
if (!FAT12_SUPPORT) {
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("volume init: No FAT 12 support"));
|
||||
#endif
|
||||
DBG_FAIL_MACRO;
|
||||
goto fail;
|
||||
}
|
||||
|
@ -4315,6 +4370,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|||
return true;
|
||||
|
||||
fail:
|
||||
#if defined(DEBUG_SD_ERROR)
|
||||
Com::printErrorFLN(PSTR("SD volume open failed"));
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
// =============== SdFile.cpp ====================
|
||||
|
@ -4434,5 +4492,3 @@ void SdFatUtil::SerialPrintln_P(FSTRINGPARAM(str)) {
|
|||
|
||||
#endif // SDSUPPORT
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -2057,7 +2057,7 @@ class SdBaseFile {
|
|||
dir_t* readDirCacheSpecial();
|
||||
dir_t *getLongFilename(dir_t *dir, char *longFilename, int8_t cVFATNeeded, uint32_t *pwIndexPos);
|
||||
bool findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound, uint32_t *pwIndexPos);
|
||||
uint8_t lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound);
|
||||
uint8_t lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound, bool isJson);
|
||||
|
||||
bool setDirSize();
|
||||
//------------------------------------------------------------------------------
|
||||
|
@ -2208,6 +2208,9 @@ class SdBaseFile {
|
|||
static bool remove(SdBaseFile& dirFile, const char* path) // NOLINT
|
||||
__attribute__((error("use remove(&dirFile, path)")));
|
||||
#endif // ALLOW_DEPRECATED_FUNCTIONS
|
||||
#if JSON_OUTPUT
|
||||
void lsJSON();
|
||||
#endif
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
/**
|
||||
|
@ -2321,5 +2324,3 @@ class SdFat {
|
|||
SdBaseFile vwd_;
|
||||
};
|
||||
#endif // SdFat_h
|
||||
|
||||
|
||||
|
|
|
@ -1,3 +0,0 @@
|
|||
/* Stub for CDC.cpp */
|
||||
|
||||
#include <CDC.cpp>
|
|
@ -1,3 +0,0 @@
|
|||
/* Stub for HardwareSerial.cpp */
|
||||
|
||||
#include <HardwareSerial.cpp>
|
|
@ -1,3 +0,0 @@
|
|||
/* Stub for IPAddress.cpp */
|
||||
|
||||
#include <IPAddress.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <Print.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <Stream.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <Tone.cpp>
|
|
@ -1,2 +0,0 @@
|
|||
#include <HID.cpp>
|
||||
#include <USBCore.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <WInterrupts.c>
|
|
@ -1 +0,0 @@
|
|||
#include <WMath.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <WString.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <main.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <new.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <wiring.c>
|
|
@ -1 +0,0 @@
|
|||
#include <wiring_analog.c>
|
|
@ -1 +0,0 @@
|
|||
#include <wiring_digital.c>
|
|
@ -1 +0,0 @@
|
|||
#include <wiring_pulse.c>
|
|
@ -1 +0,0 @@
|
|||
#include <wiring_shift.c>
|
|
@ -3735,5 +3735,3 @@ pins
|
|||
|
||||
#endif /* _ARDUINO_H */
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -224,7 +224,7 @@ void GCode::checkAndPushCommand()
|
|||
}
|
||||
pushCommand();
|
||||
#ifdef DEBUG_COM_ERRORS
|
||||
if(M == 667)
|
||||
if(hasM() && M == 667)
|
||||
return; // omit ok
|
||||
#endif
|
||||
#if ACK_WITH_LINENUMBER
|
||||
|
@ -428,7 +428,7 @@ void GCode::readFromSerial()
|
|||
}
|
||||
}
|
||||
#if SDSUPPORT
|
||||
if(sd.sdmode == 0 || commandsReceivingWritePosition != 0) // not reading or incoming serial command
|
||||
if(sd.sdmode == 0 || sd.sdmode >= 100 || commandsReceivingWritePosition != 0) // not reading or incoming serial command
|
||||
return;
|
||||
while( sd.filesize > sd.sdpos && commandsReceivingWritePosition < MAX_CMD_SIZE) // consume data until no data or buffer full
|
||||
{
|
||||
|
@ -520,7 +520,7 @@ void GCode::readFromSerial()
|
|||
bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
|
||||
{
|
||||
internalCommand = !fromSerial;
|
||||
unsigned int sum1 = 0,sum2 = 0; // for fletcher-16 checksum
|
||||
unsigned int sum1 = 0, sum2 = 0; // for fletcher-16 checksum
|
||||
// first do fletcher-16 checksum tests see
|
||||
// http://en.wikipedia.org/wiki/Fletcher's_checksum
|
||||
uint8_t *p = buffer;
|
||||
|
@ -549,13 +549,13 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
|
|||
return false;
|
||||
}
|
||||
p = buffer;
|
||||
params = *(unsigned int *)p;
|
||||
params = *(uint16_t *)p;
|
||||
p += 2;
|
||||
uint8_t textlen = 16;
|
||||
if(isV2())
|
||||
{
|
||||
params2 = *(unsigned int *)p;
|
||||
p+=2;
|
||||
params2 = *(uint16_t *)p;
|
||||
p += 2;
|
||||
if(hasString())
|
||||
textlen = *p++;
|
||||
}
|
||||
|
@ -563,16 +563,16 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
|
|||
if(params & 1)
|
||||
{
|
||||
actLineNumber = N = *(uint16_t *)p;
|
||||
p+=2;
|
||||
p += 2;
|
||||
}
|
||||
if(isV2()) // Read G,M as 16 bit value
|
||||
{
|
||||
if(params & 2)
|
||||
if(hasM())
|
||||
{
|
||||
M = *(uint16_t *)p;
|
||||
p += 2;
|
||||
}
|
||||
if(params & 4)
|
||||
if(hasG())
|
||||
{
|
||||
G = *(uint16_t *)p;
|
||||
p += 2;
|
||||
|
@ -580,51 +580,51 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
|
|||
}
|
||||
else
|
||||
{
|
||||
if(params & 2)
|
||||
if(hasM())
|
||||
{
|
||||
M = *p++;
|
||||
}
|
||||
if(params & 4)
|
||||
if(hasG())
|
||||
{
|
||||
G = *p++;
|
||||
}
|
||||
}
|
||||
//if(code->params & 8) {memcpy(&code->X,p,4);p+=4;}
|
||||
if(params & 8)
|
||||
if(hasX())
|
||||
{
|
||||
X = *(float *)p;
|
||||
p += 4;
|
||||
}
|
||||
if(params & 16)
|
||||
if(hasY())
|
||||
{
|
||||
Y = *(float *)p;
|
||||
p += 4;
|
||||
}
|
||||
if(params & 32)
|
||||
if(hasZ())
|
||||
{
|
||||
Z = *(float *)p;
|
||||
p += 4;
|
||||
}
|
||||
if(params & 64)
|
||||
if(hasE())
|
||||
{
|
||||
E = *(float *)p;
|
||||
p += 4;
|
||||
}
|
||||
if(params & 256)
|
||||
if(hasF())
|
||||
{
|
||||
F = *(float *)p;
|
||||
p += 4;
|
||||
}
|
||||
if(params & 512)
|
||||
if(hasT())
|
||||
{
|
||||
T = *p++;
|
||||
}
|
||||
if(params & 1024)
|
||||
if(hasS())
|
||||
{
|
||||
S = *(int32_t*)p;
|
||||
p += 4;
|
||||
}
|
||||
if(params & 2048)
|
||||
if(hasP())
|
||||
{
|
||||
P = *(int32_t*)p;
|
||||
p += 4;
|
||||
|
@ -688,7 +688,7 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
|
|||
{
|
||||
text = (char*)p;
|
||||
text[textlen] = 0; // Terminate string overwriting checksum
|
||||
waitUntilAllCommandsAreParsed=true; // Don't destroy string until executed
|
||||
waitUntilAllCommandsAreParsed = true; // Don't destroy string until executed
|
||||
}
|
||||
formatErrors = 0;
|
||||
return true;
|
||||
|
@ -706,6 +706,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
|
|||
char c;
|
||||
while ( (c = *(pos++)) )
|
||||
{
|
||||
if(c == '(' || c == '%') break; // alternative comment or program block
|
||||
switch(c)
|
||||
{
|
||||
case 'N':
|
||||
|
@ -728,10 +729,10 @@ bool GCode::parseAscii(char *line,bool fromSerial)
|
|||
case 'm':
|
||||
{
|
||||
M = parseLongValue(pos) & 0xffff;
|
||||
params |=2;
|
||||
params |= 2;
|
||||
if(M > 255) params |= 4096;
|
||||
// handle non standard text arguments that some M codes have
|
||||
if (M == 23 || M == 28 || M == 29 || M == 30 || M == 32 || M == 117)
|
||||
if (M == 20 || M == 23 || M == 28 || M == 29 || M == 30 || M == 32 || M == 36 || M == 117)
|
||||
{
|
||||
// after M command we got a filename or text
|
||||
char digit;
|
||||
|
@ -749,7 +750,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
|
|||
text = pos;
|
||||
while (*pos)
|
||||
{
|
||||
if((M != 117 && *pos==' ') || *pos=='*') break;
|
||||
if((M != 117 && M != 20 && *pos==' ') || *pos=='*') break;
|
||||
pos++; // find a space as file name end
|
||||
}
|
||||
*pos = 0; // truncate filename by erasing space with nul, also skips checksum
|
||||
|
@ -846,11 +847,67 @@ bool GCode::parseAscii(char *line,bool fromSerial)
|
|||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'C':
|
||||
case 'c':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 16;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'H':
|
||||
case 'h':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 32;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'A':
|
||||
case 'a':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 64;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'B':
|
||||
case 'b':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 128;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'K':
|
||||
case 'k':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 256;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'L':
|
||||
case 'l':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 512;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case 'O':
|
||||
case 'o':
|
||||
{
|
||||
D = parseFloatValue(pos);
|
||||
params2 |= 1024;
|
||||
params |= 4096; // Needs V2 for saving
|
||||
break;
|
||||
}
|
||||
case '*' : //checksum
|
||||
{
|
||||
uint8_t checksum_given = parseLongValue(pos);
|
||||
uint8_t checksum = 0;
|
||||
while(line != (pos-1)) checksum ^= *line++;
|
||||
while(line != (pos - 1)) checksum ^= *line++;
|
||||
#if FEATURE_CHECKSUM_FORCED
|
||||
Printer::flag0 |= PRINTER_FLAG0_FORCE_CHECKSUM;
|
||||
#endif
|
||||
|
@ -869,12 +926,12 @@ bool GCode::parseAscii(char *line,bool fromSerial)
|
|||
}// end switch
|
||||
}// end while
|
||||
|
||||
if(hasFormatError() || (params & 518)==0) // Must contain G, M or T command and parameter need to have variables!
|
||||
if(hasFormatError() || (params & 518) == 0) // Must contain G, M or T command and parameter need to have variables!
|
||||
{
|
||||
formatErrors++;
|
||||
if(Printer::debugErrors())
|
||||
Com::printErrorFLN(Com::tFormatError);
|
||||
if(formatErrors<3) return false;
|
||||
if(formatErrors < 3) return false;
|
||||
}
|
||||
else formatErrors = 0;
|
||||
return true;
|
||||
|
@ -885,7 +942,7 @@ void GCode::printCommand()
|
|||
{
|
||||
if(hasN()) {
|
||||
Com::print('N');
|
||||
Com::print((long)N);
|
||||
Com::print((int32_t)N);
|
||||
Com::print(' ');
|
||||
}
|
||||
if(hasM())
|
||||
|
@ -953,4 +1010,192 @@ void GCode::printCommand()
|
|||
Com::println();
|
||||
}
|
||||
|
||||
#if JSON_OUTPUT
|
||||
|
||||
// --------------------------------------------------------------- //
|
||||
// Code that gets gcode information is adapted from RepRapFirmware //
|
||||
// Originally licenced under GPL //
|
||||
// Authors: reprappro, dc42, dcnewman, others //
|
||||
// Source: https://github.com/dcnewman/RepRapFirmware //
|
||||
// Copy date: 15 Nov 2015 //
|
||||
// --------------------------------------------------------------- //
|
||||
|
||||
void GCodeFileInfo::init(SdBaseFile &file) {
|
||||
this->fileSize = file.fileSize();
|
||||
this->filamentNeeded = 0.0;
|
||||
this->objectHeight = 0.0;
|
||||
this->layerHeight = 0.0;
|
||||
if (!file.isOpen()) return;
|
||||
bool genByFound = false, layerHeightFound = false, filamentNeedFound = false;
|
||||
#if CPU_ARCH==ARCH_AVR
|
||||
#define GCI_BUF_SIZE 120
|
||||
#else
|
||||
#define GCI_BUF_SIZE 1024
|
||||
#endif
|
||||
// READ 4KB FROM THE BEGINNING
|
||||
char buf[GCI_BUF_SIZE];
|
||||
for (int i = 0; i < 4096; i += GCI_BUF_SIZE-50) {
|
||||
if(!file.seekSet(i)) break;
|
||||
file.read(buf, GCI_BUF_SIZE);
|
||||
if (!genByFound && findGeneratedBy(buf, this->generatedBy)) genByFound = true;
|
||||
if (!layerHeightFound && findLayerHeight(buf, this->layerHeight)) layerHeightFound = true;
|
||||
if (!filamentNeedFound && findFilamentNeed(buf, this->filamentNeeded)) filamentNeedFound = true;
|
||||
if(genByFound && layerHeightFound && filamentNeedFound) goto get_objectHeight;
|
||||
}
|
||||
|
||||
// READ 4KB FROM END
|
||||
for (int i = 0; i < 4096; i += GCI_BUF_SIZE-50) {
|
||||
if(!file.seekEnd(-4096 + i)) break;
|
||||
file.read(buf, GCI_BUF_SIZE);
|
||||
if (!genByFound && findGeneratedBy(buf, this->generatedBy)) genByFound = true;
|
||||
if (!layerHeightFound && findLayerHeight(buf, this->layerHeight)) layerHeightFound = true;
|
||||
if (!filamentNeedFound && findFilamentNeed(buf, this->filamentNeeded)) filamentNeedFound = true;
|
||||
if(genByFound && layerHeightFound && filamentNeedFound) goto get_objectHeight;
|
||||
}
|
||||
|
||||
get_objectHeight:
|
||||
// MOVE FROM END UP IN 1KB BLOCKS UP TO 30KB
|
||||
for (int i = GCI_BUF_SIZE; i < 30000; i += GCI_BUF_SIZE-50) {
|
||||
if(!file.seekEnd(-i)) break;
|
||||
file.read(buf, GCI_BUF_SIZE);
|
||||
if (findTotalHeight(buf, this->objectHeight)) break;
|
||||
}
|
||||
file.seekSet(0);
|
||||
}
|
||||
|
||||
bool GCodeFileInfo::findGeneratedBy(char *buf, char *genBy) {
|
||||
// Slic3r & S3D
|
||||
const char* generatedByString = PSTR("generated by ");
|
||||
char* pos = strstr_P(buf, generatedByString);
|
||||
if (pos) {
|
||||
pos += strlen_P(generatedByString);
|
||||
size_t i = 0;
|
||||
while (i < GENBY_SIZE - 1 && *pos >= ' ') {
|
||||
char c = *pos++;
|
||||
if (c == '"' || c == '\\') {
|
||||
// Need to escape the quote-mark for JSON
|
||||
if (i > GENBY_SIZE - 3) break;
|
||||
genBy[i++] = '\\';
|
||||
}
|
||||
genBy[i++] = c;
|
||||
}
|
||||
genBy[i] = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
// CURA
|
||||
const char* slicedAtString = PSTR(";Sliced at: ");
|
||||
pos = strstr_P(buf, slicedAtString);
|
||||
if (pos) {
|
||||
strcpy_P(genBy, PSTR("Cura"));
|
||||
return true;
|
||||
}
|
||||
|
||||
// UNKNOWN
|
||||
strcpy_P(genBy, PSTR("Unknown"));
|
||||
return false;
|
||||
}
|
||||
|
||||
bool GCodeFileInfo::findLayerHeight(char *buf, float &layerHeight) {
|
||||
// SLIC3R
|
||||
layerHeight = 0;
|
||||
const char* layerHeightSlic3r = PSTR("; layer_height ");
|
||||
char *pos = strstr_P(buf, layerHeightSlic3r);
|
||||
if (pos) {
|
||||
pos += strlen_P(layerHeightSlic3r);
|
||||
while (*pos == ' ' || *pos == 't' || *pos == '=' || *pos == ':') {
|
||||
++pos;
|
||||
}
|
||||
layerHeight = strtod(pos, NULL);
|
||||
return true;
|
||||
}
|
||||
|
||||
// CURA
|
||||
const char* layerHeightCura = PSTR("Layer height: ");
|
||||
pos = strstr_P(buf, layerHeightCura);
|
||||
if (pos) {
|
||||
pos += strlen_P(layerHeightCura);
|
||||
while (*pos == ' ' || *pos == 't' || *pos == '=' || *pos == ':') {
|
||||
++pos;
|
||||
}
|
||||
layerHeight = strtod(pos, NULL);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool GCodeFileInfo::findFilamentNeed(char *buf, float &filament) {
|
||||
const char* filamentUsedStr = PSTR("filament used");
|
||||
const char* pos = strstr_P(buf, filamentUsedStr);
|
||||
filament = 0;
|
||||
if (pos != NULL) {
|
||||
pos += strlen_P(filamentUsedStr);
|
||||
while (*pos == ' ' || *pos == 't' || *pos == '=' || *pos == ':') {
|
||||
++pos; // this allows for " = " from default slic3r comment and ": " from default Cura comment
|
||||
}
|
||||
if (isDigit(*pos)) {
|
||||
char *q;
|
||||
filament += strtod(pos, &q);
|
||||
if (*q == 'm' && *(q + 1) != 'm') {
|
||||
filament *= 1000.0; // Cura outputs filament used in metres not mm
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool GCodeFileInfo::findTotalHeight(char *buf, float &height) {
|
||||
int len = 1024;
|
||||
bool inComment, inRelativeMode = false;
|
||||
unsigned int zPos;
|
||||
for (int i = len - 5; i > 0; i--) {
|
||||
if (inRelativeMode) {
|
||||
inRelativeMode = !(buf[i] == 'G' && buf[i + 1] == '9' && buf[i + 2] == '1' && buf[i + 3] <= ' ');
|
||||
} else if (buf[i] == 'G') {
|
||||
// Ignore G0/G1 codes if absolute mode was switched back using G90 (typical for Cura files)
|
||||
if (buf[i + 1] == '9' && buf[i + 2] == '0' && buf[i + 3] <= ' ') {
|
||||
inRelativeMode = true;
|
||||
} else if ((buf[i + 1] == '0' || buf[i + 1] == '1') && buf[i + 2] == ' ') {
|
||||
// Look for last "G0/G1 ... Z#HEIGHT#" command as generated by common slicers
|
||||
// Looks like we found a controlled move, however it could be in a comment, especially when using slic3r 1.1.1
|
||||
inComment = false;
|
||||
size_t j = i;
|
||||
while (j != 0) {
|
||||
--j;
|
||||
char c = buf[j];
|
||||
if (c == '\n' || c == '\r') break;
|
||||
if (c == ';') {
|
||||
// It is in a comment, so give up on this one
|
||||
inComment = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (inComment) continue;
|
||||
|
||||
// Find 'Z' position and grab that value
|
||||
zPos = 0;
|
||||
for (int j = i + 3; j < len - 2; j++) {
|
||||
char c = buf[j];
|
||||
if (c < ' ') {
|
||||
// Skip all whitespaces...
|
||||
while (j < len - 2 && c <= ' ') {
|
||||
c = buf[++j];
|
||||
}
|
||||
// ...to make sure ";End" doesn't follow G0 .. Z#HEIGHT#
|
||||
if (zPos != 0) {
|
||||
//debugPrintf("Found at offset %u text: %.100s\n", zPos, &buf[zPos + 1]);
|
||||
height = strtod(&buf[zPos + 1], NULL);
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
} else if (c == ';') break;
|
||||
else if (c == 'Z') zPos = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
#endif // JSON_OUTPUT
|
||||
|
|
|
@ -19,22 +19,23 @@
|
|||
#define _GCODE_H
|
||||
|
||||
#define MAX_CMD_SIZE 96
|
||||
#define ARRAY_SIZE(_x) (sizeof(_x)/sizeof(_x[0]))
|
||||
class SDCard;
|
||||
class GCode // 52 uint8_ts per command needed
|
||||
{
|
||||
unsigned int params;
|
||||
unsigned int params2;
|
||||
uint16_t params;
|
||||
uint16_t params2;
|
||||
public:
|
||||
unsigned int N; // Line number
|
||||
unsigned int M;
|
||||
unsigned int G;
|
||||
uint16_t N; // Line number
|
||||
uint16_t M;
|
||||
uint16_t G;
|
||||
float X;
|
||||
float Y;
|
||||
float Z;
|
||||
float E;
|
||||
float F;
|
||||
long S;
|
||||
long P;
|
||||
int32_t S;
|
||||
int32_t P;
|
||||
float I;
|
||||
float J;
|
||||
float R;
|
||||
|
@ -191,6 +192,7 @@ private:
|
|||
inline float parseFloatValue(char *s)
|
||||
{
|
||||
char *endPtr;
|
||||
while(*s == 32) s++; // skip spaces
|
||||
float f = (strtod(s, &endPtr));
|
||||
if(s == endPtr) f=0.0; // treat empty string "x " as "x0"
|
||||
return f;
|
||||
|
@ -198,6 +200,7 @@ private:
|
|||
inline long parseLongValue(char *s)
|
||||
{
|
||||
char *endPtr;
|
||||
while(*s == 32) s++; // skip spaces
|
||||
long l = (strtol(s, &endPtr, 10));
|
||||
if(s == endPtr) l=0; // treat empty string argument "p " as "p0"
|
||||
return l;
|
||||
|
@ -221,8 +224,26 @@ private:
|
|||
static uint8_t formatErrors; ///< Number of sequential format errors
|
||||
};
|
||||
|
||||
#if JSON_OUTPUT
|
||||
#include "SdFat.h"
|
||||
// Struct to hold Gcode file information 32 bytes
|
||||
#define GENBY_SIZE 16
|
||||
class GCodeFileInfo {
|
||||
public:
|
||||
void init(SdBaseFile &file);
|
||||
|
||||
unsigned long fileSize;
|
||||
float objectHeight;
|
||||
float layerHeight;
|
||||
float filamentNeeded;
|
||||
char generatedBy[GENBY_SIZE];
|
||||
|
||||
bool findGeneratedBy(char *buf, char *genBy);
|
||||
bool findLayerHeight(char *buf, float &layerHeight);
|
||||
bool findFilamentNeed(char *buf, float &filament);
|
||||
bool findTotalHeight(char *buf, float &objectHeight);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -1 +0,0 @@
|
|||
#include <EEPROM.cpp>
|
|
@ -1,8 +0,0 @@
|
|||
#include <w5100.cpp>
|
||||
#include <socket.cpp>
|
||||
#include <Dns.cpp>
|
||||
#include <Dhcp.cpp>
|
||||
#include <Ethernet.cpp>
|
||||
#include <EthernetClient.cpp>
|
||||
#include <EthernetServer.cpp>
|
||||
#include <EthernetUdp.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <Firmata.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <LiquidCrystal.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <OBD.cpp>
|
|
@ -1,5 +0,0 @@
|
|||
#include <SD.cpp>
|
||||
#include <Sd2Card.cpp>
|
||||
#include <SdFile.cpp>
|
||||
#include <SdVolume.cpp>
|
||||
#include <File.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <SPI.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <Servo.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <SoftwareSerial.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <Stepper.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <TinyGPS.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <U8glib.cpp>
|
|
@ -1,7 +0,0 @@
|
|||
#include <server_drv.cpp>
|
||||
#include <socket.cpp>
|
||||
#include <spi_drv.cpp>
|
||||
#include <wifi_drv.cpp>
|
||||
#include <WiFi.cpp>
|
||||
#include <WiFiClient.cpp>
|
||||
#include <WiFiServer.cpp>
|
|
@ -1,2 +0,0 @@
|
|||
#include <twi.c>
|
||||
#include <Wire.cpp>
|
|
@ -1 +0,0 @@
|
|||
#include <twi.c>
|
|
@ -3,6 +3,7 @@
|
|||
// http://en.radzio.dxp.pl/bitmap_converter/
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifndef CUSTOM_LOGO
|
||||
#define LOGO_WIDTH 60
|
||||
#define LOGO_HEIGHT 64
|
||||
|
||||
|
@ -39,41 +40,7 @@ const unsigned char logo[] PROGMEM = { //AVR-GCC, WinAVR
|
|||
0x00, 0x07, 0xFF, 0xFF, 0xF8, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFC, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x03, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0xF8, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
/*
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
|
||||
0xFF, 0xFF, 0xF7, 0x83, 0xC1, 0xF0, 0x1E, 0x0F, 0xFF, 0xFF, 0x7C, 0x0F, 0x07, 0xC0, 0x78, 0x0F,
|
||||
0xFF, 0xFD, 0xE0, 0x00, 0x00, 0x01, 0xE0, 0x3F, 0xFF, 0xDF, 0x80, 0x00, 0x00, 0x07, 0xC0, 0x7F,
|
||||
0xFE, 0x3F, 0xFF, 0xFF, 0xFF, 0xDF, 0x01, 0xFF, 0xF8, 0x00, 0x00, 0x0B, 0xFF, 0xFC, 0x03, 0xFF,
|
||||
0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
|
||||
0xF0, 0x50, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF1, 0xFF, 0xFF, 0xFF, 0xD0, 0x00, 0x7F, 0x7F,
|
||||
0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x7E, 0x7F, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xFC, 0x7F,
|
||||
0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF8, 0x3F, 0xF1, 0xEF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0x3F,
|
||||
0xF9, 0xE0, 0x00, 0x0F, 0xFF, 0xF0, 0xE0, 0x3F, 0xF1, 0xE0, 0x00, 0x00, 0xFF, 0xF8, 0xE0, 0x3F,
|
||||
0xF9, 0xE0, 0x00, 0x00, 0x3F, 0xF0, 0xE3, 0x3F, 0xF1, 0xE0, 0x00, 0x00, 0x1F, 0xF8, 0xE3, 0x7F,
|
||||
0xF9, 0xE0, 0x00, 0x00, 0x0F, 0xF0, 0xE7, 0x3F, 0xF1, 0xE0, 0x00, 0x00, 0x0F, 0xF8, 0xE7, 0x7F,
|
||||
0xF9, 0xE0, 0x08, 0x00, 0x0F, 0xF0, 0xE7, 0x7F, 0xF1, 0xE0, 0x0F, 0xE0, 0x07, 0xF8, 0xE7, 0x7F,
|
||||
0xF9, 0xE0, 0x0F, 0xE0, 0x07, 0xF0, 0xE7, 0x7F, 0xF1, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0xE6, 0x7F,
|
||||
0xF9, 0xE0, 0x0F, 0xF0, 0x07, 0xF0, 0xE0, 0x7F, 0xF9, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0xE0, 0xFF,
|
||||
0xF9, 0xE0, 0x0F, 0xE0, 0x07, 0xF0, 0xE0, 0xFF, 0xF9, 0xE0, 0x00, 0x00, 0x07, 0xF8, 0xE1, 0xFF,
|
||||
0xF9, 0xE0, 0x00, 0x00, 0x0F, 0xF0, 0xE3, 0xFF, 0xF9, 0xE0, 0x00, 0x00, 0x0F, 0xF8, 0xE3, 0xFF,
|
||||
0xF9, 0xE0, 0x00, 0x00, 0x1F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x00, 0x00, 0x3F, 0xF8, 0xE7, 0xFF,
|
||||
0xF9, 0xE0, 0x00, 0x01, 0xFF, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0C, 0x01, 0xFF, 0xF8, 0xE7, 0xFF,
|
||||
0xF9, 0xE0, 0x0E, 0x00, 0x7F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0x00, 0x7F, 0xF8, 0xE7, 0xFF,
|
||||
0xF9, 0xE0, 0x0F, 0x00, 0x3F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0x80, 0x1F, 0xF8, 0xE7, 0xFF,
|
||||
0xF9, 0xE0, 0x0F, 0x80, 0x1F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0xC0, 0x0F, 0xF8, 0xE7, 0xFF,
|
||||
0xF9, 0xE0, 0x0F, 0xC0, 0x0F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0xE0, 0x07, 0xF8, 0xEF, 0xFF,
|
||||
0xF9, 0xF0, 0x0F, 0xE0, 0x07, 0xF8, 0xEF, 0xFF, 0xF9, 0xE0, 0x0F, 0xF0, 0x03, 0xF8, 0xFF, 0xFF,
|
||||
0xF9, 0xF0, 0x0F, 0xF0, 0x03, 0xF8, 0xFF, 0xFF, 0xF9, 0xFE, 0x0F, 0xF8, 0x03, 0xF8, 0xFF, 0xFF,
|
||||
0xF9, 0xFF, 0xFF, 0xF8, 0x01, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0x81, 0xF8, 0xFF, 0xFF,
|
||||
0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0x7F, 0xFF, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF,
|
||||
0xF8, 0x00, 0xFF, 0xFF, 0xFF, 0xF8, 0xDF, 0xFF, 0xF8, 0x00, 0x00, 0xFF, 0xFF, 0xF8, 0x7F, 0xFF,
|
||||
0xFF, 0x40, 0x00, 0x00, 0xFF, 0xF0, 0x3F, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x7F, 0xFF,
|
||||
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x80, 0x00, 0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x40, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xAF, 0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF
|
||||
*/
|
||||
};
|
||||
|
||||
|
||||
|
||||
#else
|
||||
LOGO_BITMAP
|
||||
#endif
|
||||
|
|
|
@ -65,8 +65,8 @@
|
|||
|
||||
//Inactivity shutdown variables
|
||||
millis_t previousMillisCmd = 0;
|
||||
millis_t maxInactiveTime = MAX_INACTIVE_TIME*1000L;
|
||||
millis_t stepperInactiveTime = STEPPER_INACTIVE_TIME*1000L;
|
||||
millis_t maxInactiveTime = MAX_INACTIVE_TIME * 1000L;
|
||||
millis_t stepperInactiveTime = STEPPER_INACTIVE_TIME * 1000L;
|
||||
long baudrate = BAUDRATE; ///< Communication speed rate.
|
||||
#if USE_ADVANCE
|
||||
#if ENABLE_QUADRATIC_ADVANCE
|
||||
|
@ -75,11 +75,11 @@ int maxadv = 0;
|
|||
int maxadv2 = 0;
|
||||
float maxadvspeed = 0;
|
||||
#endif
|
||||
uint8_t pwm_pos[NUM_EXTRUDER+3]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
|
||||
uint8_t pwm_pos[NUM_PWM]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
|
||||
volatile int waitRelax = 0; // Delay filament relax at the end of print, could be a simple timeout
|
||||
|
||||
PrintLine PrintLine::lines[PRINTLINE_CACHE_SIZE]; ///< Cache for print moves.
|
||||
PrintLine *PrintLine::cur = 0; ///< Current printing line
|
||||
PrintLine *PrintLine::cur = NULL; ///< Current printing line
|
||||
#if CPU_ARCH == ARCH_ARM
|
||||
volatile bool PrintLine::nlFlag = false;
|
||||
#endif
|
||||
|
@ -90,7 +90,7 @@ ufast8_t PrintLine::linesPos = 0; ///< Position for executing li
|
|||
/**
|
||||
Move printer the given number of steps. Puts the move into the queue. Used by e.g. homing commands.
|
||||
*/
|
||||
void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd, bool checkEndstop)
|
||||
void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd, bool checkEndstop,bool pathOptimize)
|
||||
{
|
||||
#if NUM_EXTRUDER > 0
|
||||
if(Printer::debugDryrun() || (MIN_EXTRUDER_TEMP > 30 && Extruder::current->tempControl.currentTemperatureC < MIN_EXTRUDER_TEMP && !Printer::isColdExtrusionAllowed()))
|
||||
|
@ -103,12 +103,12 @@ void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int
|
|||
Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS] + e;
|
||||
Printer::feedrate = feedrate;
|
||||
#if NONLINEAR_SYSTEM
|
||||
if (!queueDeltaMove(checkEndstop, false, false))
|
||||
if (!queueDeltaMove(checkEndstop, pathOptimize, false))
|
||||
{
|
||||
Com::printWarningFLN(PSTR("moveRelativeDistanceInSteps / queueDeltaMove returns error"));
|
||||
}
|
||||
#else
|
||||
queueCartesianMove(checkEndstop, false);
|
||||
queueCartesianMove(checkEndstop, pathOptimize);
|
||||
#endif
|
||||
Printer::feedrate = savedFeedrate;
|
||||
Printer::updateCurrentPosition(false);
|
||||
|
@ -117,7 +117,7 @@ void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int
|
|||
previousMillisCmd = HAL::timeInMilliseconds();
|
||||
}
|
||||
|
||||
void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd)
|
||||
void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd,bool pathOptimize)
|
||||
{
|
||||
Printer::lastCmdPos[X_AXIS] += x * Printer::invAxisStepsPerMM[X_AXIS];
|
||||
Printer::lastCmdPos[Y_AXIS] += y * Printer::invAxisStepsPerMM[Y_AXIS];
|
||||
|
@ -131,7 +131,7 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
|
|||
e = 0; // should not be allowed for current temperature
|
||||
#endif
|
||||
Printer::moveToReal(Printer::lastCmdPos[X_AXIS], Printer::lastCmdPos[Y_AXIS], Printer::lastCmdPos[Z_AXIS],
|
||||
(Printer::currentPositionSteps[E_AXIS] + e) * Printer::invAxisStepsPerMM[E_AXIS],feedrate);
|
||||
(Printer::currentPositionSteps[E_AXIS] + e) * Printer::invAxisStepsPerMM[E_AXIS],feedrate,pathOptimize);
|
||||
Printer::updateCurrentPosition();
|
||||
if(waitEnd)
|
||||
Commands::waitUntilEndOfAllMoves();
|
||||
|
@ -139,6 +139,130 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
|
|||
}
|
||||
|
||||
#if !NONLINEAR_SYSTEM
|
||||
#if DISTORTION_CORRECTION
|
||||
/* Special version which adds distortion correction to z. Gets called from queueCartesianMove if needed. */
|
||||
void PrintLine::queueCartesianSegmentTo(uint8_t check_endstops, uint8_t pathOptimize) {
|
||||
|
||||
// Correct the bumps
|
||||
Printer::zCorrectionStepsIncluded = Printer::distortion.correct(Printer::destinationSteps[X_AXIS],Printer::destinationSteps[Y_AXIS],Printer::destinationSteps[Z_AXIS]);
|
||||
Printer::destinationSteps[Z_AXIS] += Printer::zCorrectionStepsIncluded;
|
||||
#if DEBUG_DISTORTION
|
||||
Com::printF(PSTR("zCorr:"),Printer::zCorrectionStepsIncluded*Printer::invAxisStepsPerMM[Z_AXIS],3);
|
||||
Com::printF(PSTR(" atX:"),Printer::destinationSteps[0]*Printer::invAxisStepsPerMM[X_AXIS]);
|
||||
Com::printFLN(PSTR(" atY:"),Printer::destinationSteps[1]*Printer::invAxisStepsPerMM[Y_AXIS]);
|
||||
#endif
|
||||
PrintLine::waitForXFreeLines(1);
|
||||
uint8_t newPath = PrintLine::insertWaitMovesIfNeeded(pathOptimize, 0);
|
||||
PrintLine *p = PrintLine::getNextWriteLine();
|
||||
|
||||
float axis_diff[E_AXIS_ARRAY]; // Axis movement in mm
|
||||
p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
|
||||
#if MIXING_EXTRUDER
|
||||
if(Printer::isAllEMotors()) {
|
||||
p->flags |= FLAG_ALL_E_MOTORS;
|
||||
}
|
||||
#endif
|
||||
p->joinFlags = 0;
|
||||
if(!pathOptimize) p->setEndSpeedFixed(true);
|
||||
p->dir = 0;
|
||||
Printer::constrainDestinationCoords();
|
||||
//Find direction
|
||||
Printer::zCorrectionStepsIncluded = 0;
|
||||
for(uint8_t axis = 0; axis < 4; axis++)
|
||||
{
|
||||
p->delta[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
|
||||
p->secondSpeed = Printer::fanSpeed;
|
||||
if(axis == E_AXIS)
|
||||
{
|
||||
if(Printer::mode == PRINTER_MODE_FFF)
|
||||
{
|
||||
Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor);
|
||||
p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
|
||||
Printer::extrudeMultiplyError -= p->delta[E_AXIS];
|
||||
Printer::filamentPrinted += p->delta[E_AXIS] * Printer::invAxisStepsPerMM[axis];
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER)
|
||||
{
|
||||
p->secondSpeed = ((p->delta[X_AXIS] != 0 || p->delta[Y_AXIS] != 0) && (LaserDriver::laserOn || p->delta[E_AXIS] != 0) ? LaserDriver::intensity : 0);
|
||||
p->delta[E_AXIS] = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
if(p->delta[axis] >= 0)
|
||||
p->setPositiveDirectionForAxis(axis);
|
||||
else
|
||||
p->delta[axis] = -p->delta[axis];
|
||||
axis_diff[axis] = p->delta[axis] * Printer::invAxisStepsPerMM[axis];
|
||||
if(p->delta[axis]) p->setMoveOfAxis(axis);
|
||||
Printer::currentPositionSteps[axis] = Printer::destinationSteps[axis];
|
||||
}
|
||||
if(p->isNoMove())
|
||||
{
|
||||
if(newPath) // need to delete dummy elements, otherwise commands can get locked.
|
||||
PrintLine::resetPathPlanner();
|
||||
return; // No steps included
|
||||
}
|
||||
float xydist2;
|
||||
#if ENABLE_BACKLASH_COMPENSATION
|
||||
if((p->isXYZMove()) && ((p->dir & XYZ_DIRPOS)^(Printer::backlashDir & XYZ_DIRPOS)) & (Printer::backlashDir >> 3)) // We need to compensate backlash, add a move
|
||||
{
|
||||
PrintLine::waitForXFreeLines(2);
|
||||
uint8_t wpos2 = PrintLine::linesWritePos + 1;
|
||||
if(wpos2 >= PRINTLINE_CACHE_SIZE) wpos2 = 0;
|
||||
PrintLine *p2 = &PrintLine::lines[wpos2];
|
||||
memcpy(p2,p,sizeof(PrintLine)); // Move current data to p2
|
||||
uint8_t changed = (p->dir & XYZ_DIRPOS)^(Printer::backlashDir & XYZ_DIRPOS);
|
||||
float back_diff[4]; // Axis movement in mm
|
||||
back_diff[E_AXIS] = 0;
|
||||
back_diff[X_AXIS] = (changed & 1 ? (p->isXPositiveMove() ? Printer::backlashX : -Printer::backlashX) : 0);
|
||||
back_diff[Y_AXIS] = (changed & 2 ? (p->isYPositiveMove() ? Printer::backlashY : -Printer::backlashY) : 0);
|
||||
back_diff[Z_AXIS] = (changed & 4 ? (p->isZPositiveMove() ? Printer::backlashZ : -Printer::backlashZ) : 0);
|
||||
p->dir &= XYZ_DIRPOS; // x,y and z are already correct
|
||||
for(uint8_t i = 0; i < 4; i++)
|
||||
{
|
||||
float f = back_diff[i]*Printer::axisStepsPerMM[i];
|
||||
p->delta[i] = abs((long)f);
|
||||
if(p->delta[i]) p->dir |= XSTEP << i;
|
||||
}
|
||||
//Define variables that are needed for the Bresenham algorithm. Please note that Z is not currently included in the Bresenham algorithm.
|
||||
if(p->delta[Y_AXIS] > p->delta[X_AXIS] && p->delta[Y_AXIS] > p->delta[Z_AXIS]) p->primaryAxis = Y_AXIS;
|
||||
else if (p->delta[X_AXIS] > p->delta[Z_AXIS] ) p->primaryAxis = X_AXIS;
|
||||
else p->primaryAxis = Z_AXIS;
|
||||
p->stepsRemaining = p->delta[p->primaryAxis];
|
||||
//Feedrate calc based on XYZ travel distance
|
||||
xydist2 = back_diff[X_AXIS] * back_diff[X_AXIS] + back_diff[Y_AXIS] * back_diff[Y_AXIS];
|
||||
if(p->isZMove())
|
||||
p->distance = sqrt(xydist2 + back_diff[Z_AXIS] * back_diff[Z_AXIS]);
|
||||
else
|
||||
p->distance = sqrt(xydist2);
|
||||
// 56 seems to be xstep|ystep|e_posdir which just seems odd
|
||||
Printer::backlashDir = (Printer::backlashDir & 56) | (p2->dir & XYZ_DIRPOS);
|
||||
p->calculateMove(back_diff,pathOptimize);
|
||||
p = p2; // use saved instance for the real move
|
||||
}
|
||||
#endif
|
||||
|
||||
//Define variables that are needed for the Bresenham algorithm. Please note that Z is not currently included in the Bresenham algorithm.
|
||||
if(p->delta[Y_AXIS] > p->delta[X_AXIS] && p->delta[Y_AXIS] > p->delta[Z_AXIS] && p->delta[Y_AXIS] > p->delta[E_AXIS]) p->primaryAxis = Y_AXIS;
|
||||
else if (p->delta[X_AXIS] > p->delta[Z_AXIS] && p->delta[X_AXIS] > p->delta[E_AXIS]) p->primaryAxis = X_AXIS;
|
||||
else if (p->delta[Z_AXIS] > p->delta[E_AXIS]) p->primaryAxis = Z_AXIS;
|
||||
else p->primaryAxis = E_AXIS;
|
||||
p->stepsRemaining = p->delta[p->primaryAxis];
|
||||
if(p->isXYZMove())
|
||||
{
|
||||
xydist2 = axis_diff[X_AXIS] * axis_diff[X_AXIS] + axis_diff[Y_AXIS] * axis_diff[Y_AXIS];
|
||||
if(p->isZMove())
|
||||
p->distance = RMath::max((float)sqrt(xydist2 + axis_diff[Z_AXIS] * axis_diff[Z_AXIS]),fabs(axis_diff[E_AXIS]));
|
||||
else
|
||||
p->distance = RMath::max((float)sqrt(xydist2),fabs(axis_diff[E_AXIS]));
|
||||
}
|
||||
else
|
||||
p->distance = fabs(axis_diff[E_AXIS]);
|
||||
p->calculateMove(axis_diff,pathOptimize);
|
||||
|
||||
}
|
||||
#endif
|
||||
/**
|
||||
Put a move to the current destination coordinates into the movement cache.
|
||||
If the cache is full, the method will wait, until a place gets free. During
|
||||
|
@ -148,27 +272,74 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
|
|||
void PrintLine::queueCartesianMove(uint8_t check_endstops, uint8_t pathOptimize)
|
||||
{
|
||||
Printer::unsetAllSteppersDisabled();
|
||||
#if DISTORTION_CORRECTION
|
||||
if(Printer::distortion.isEnabled() && Printer::destinationSteps[Z_AXIS] < Printer::distortion.zMaxSteps() && Printer::isZProbingActive() == false && !Printer::isHoming()) {
|
||||
// we are inside correction height so we split all moves in lines of max. 10 mm and add them
|
||||
// including a z correction
|
||||
int32_t deltas[E_AXIS_ARRAY],start[E_AXIS_ARRAY];
|
||||
for(fast8_t i = 0;i < E_AXIS_ARRAY;i++) {
|
||||
deltas[i] = Printer::destinationSteps[i] - Printer::currentPositionSteps[i];
|
||||
start[i] = Printer::currentPositionSteps[i];
|
||||
}
|
||||
float dx = Printer::invAxisStepsPerMM[X_AXIS] * deltas[X_AXIS];
|
||||
float dy = Printer::invAxisStepsPerMM[Y_AXIS] * deltas[Y_AXIS];
|
||||
float len = dx * dx + dy * dy;
|
||||
if(len < 100) { // no splitting required
|
||||
queueCartesianSegmentTo(check_endstops, pathOptimize);
|
||||
return;
|
||||
}
|
||||
// we need to split longer lines to follow bed curvature
|
||||
len = sqrt(len);
|
||||
int segments = (static_cast<int>(len) + 9) / 10;
|
||||
#if DEBUG_DISTORTION
|
||||
Com::printF(PSTR("Split line len:"),len);Com::printFLN(PSTR(" segments:"),segments);
|
||||
#endif
|
||||
for(int i = 1; i <= segments; i++) {
|
||||
for(fast8_t j = 0; j < E_AXIS_ARRAY; j++) {
|
||||
Printer::destinationSteps[j] = start[j] + (i * deltas[j]) / segments;
|
||||
}
|
||||
queueCartesianSegmentTo(check_endstops, pathOptimize);
|
||||
}
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
waitForXFreeLines(1);
|
||||
uint8_t newPath = insertWaitMovesIfNeeded(pathOptimize, 0);
|
||||
PrintLine *p = getNextWriteLine();
|
||||
|
||||
float axis_diff[E_AXIS_ARRAY]; // Axis movement in mm
|
||||
if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS;
|
||||
else p->flags = 0;
|
||||
p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
|
||||
#if MIXING_EXTRUDER
|
||||
if(Printer::isAllEMotors()) {
|
||||
p->flags |= FLAG_ALL_E_MOTORS;
|
||||
}
|
||||
#endif
|
||||
p->joinFlags = 0;
|
||||
if(!pathOptimize) p->setEndSpeedFixed(true);
|
||||
p->dir = 0;
|
||||
Printer::constrainDestinationCoords();
|
||||
//Find direction
|
||||
Printer::zCorrectionStepsIncluded = 0;
|
||||
for(uint8_t axis = 0; axis < 4; axis++)
|
||||
{
|
||||
p->delta[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
|
||||
p->secondSpeed = Printer::fanSpeed;
|
||||
if(axis == E_AXIS)
|
||||
{
|
||||
Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor);
|
||||
p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
|
||||
Printer::extrudeMultiplyError -= p->delta[E_AXIS];
|
||||
Printer::filamentPrinted += p->delta[E_AXIS] * Printer::invAxisStepsPerMM[axis];
|
||||
if(Printer::mode == PRINTER_MODE_FFF)
|
||||
{
|
||||
Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor);
|
||||
p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
|
||||
Printer::extrudeMultiplyError -= p->delta[E_AXIS];
|
||||
Printer::filamentPrinted += p->delta[E_AXIS] * Printer::invAxisStepsPerMM[axis];
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER)
|
||||
{
|
||||
p->secondSpeed = ((p->delta[X_AXIS] != 0 || p->delta[Y_AXIS] != 0) && (LaserDriver::laserOn || p->delta[E_AXIS] != 0) ? LaserDriver::intensity : 0);
|
||||
p->delta[E_AXIS] = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
if(p->delta[axis] >= 0)
|
||||
p->setPositiveDirectionForAxis(axis);
|
||||
|
@ -252,17 +423,18 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
|
|||
long axisInterval[E_AXIS_ARRAY];
|
||||
#endif
|
||||
float timeForMove = (float)(F_CPU)*distance / (isXOrYMove() ? RMath::max(Printer::minimumSpeed, Printer::feedrate) : Printer::feedrate); // time is in ticks
|
||||
bool critical = Printer::isZProbingActive();
|
||||
//bool critical = Printer::isZProbingActive();
|
||||
if(linesCount < MOVE_CACHE_LOW && timeForMove < LOW_TICKS_PER_MOVE) // Limit speed to keep cache full.
|
||||
{
|
||||
//OUT_P_I("L:",lines_count);
|
||||
//Com::printF(PSTR("L:"),(int)linesCount);
|
||||
//Com::printF(PSTR(" Old "),timeForMove);
|
||||
timeForMove += (3 * (LOW_TICKS_PER_MOVE - timeForMove)) / (linesCount + 1); // Increase time if queue gets empty. Add more time if queue gets smaller.
|
||||
//OUT_P_F_LN("Slow ",time_for_move);
|
||||
critical = true;
|
||||
//Com::printFLN(PSTR("Slow "),timeForMove);
|
||||
//critical = true;
|
||||
}
|
||||
timeInTicks = timeForMove;
|
||||
UI_MEDIUM; // do check encoder
|
||||
// Compute the solwest allowed interval (ticks/step), so maximum feedrate is not violated
|
||||
// Compute the slowest allowed interval (ticks/step), so maximum feedrate is not violated
|
||||
long limitInterval = timeForMove / stepsRemaining; // until not violated by other constraints it is your target speed
|
||||
if(isXMove())
|
||||
{
|
||||
|
@ -304,7 +476,7 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
|
|||
limitInterval = RMath::max(axisInterval[VIRTUAL_AXIS], limitInterval);
|
||||
#endif
|
||||
|
||||
fullInterval = limitInterval = limitInterval>LIMIT_INTERVAL ? limitInterval : LIMIT_INTERVAL; // This is our target speed
|
||||
fullInterval = limitInterval = limitInterval > LIMIT_INTERVAL ? limitInterval : LIMIT_INTERVAL; // This is our target speed
|
||||
// new time at full speed = limitInterval*p->stepsRemaining [ticks]
|
||||
timeForMove = (float)limitInterval * (float)stepsRemaining; // for large z-distance this overflows with long computation
|
||||
float inv_time_s = (float)F_CPU / timeForMove;
|
||||
|
@ -345,14 +517,32 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
|
|||
// slowest time to accelerate from v0 to limitInterval determines used acceleration
|
||||
// t = (v_end-v_start)/a
|
||||
float slowest_axis_plateau_time_repro = 1e15; // repro to reduce division Unit: 1/s
|
||||
unsigned long *accel = (isEPositiveMove() ? Printer::maxPrintAccelerationStepsPerSquareSecond : Printer::maxTravelAccelerationStepsPerSquareSecond);
|
||||
|
||||
uint32_t *accel = (isEPositiveMove() ? Printer::maxPrintAccelerationStepsPerSquareSecond : Printer::maxTravelAccelerationStepsPerSquareSecond);
|
||||
#if defined(INTERPOLATE_ACCELERATION_WITH_Z) && INTERPOLATE_ACCELERATION_WITH_Z != 0
|
||||
uint32_t newAccel[4];
|
||||
float accelFac = 100.0 + (EEPROM::accelarationFactorTop() - 100.0) * Printer::currentPosition[Z_AXIS] / Printer::zLength;
|
||||
#if INTERPOLATE_ACCELERATION_WITH_Z == 1 || INTERPOLATE_ACCELERATION_WITH_Z == 3
|
||||
newAccel[X_AXIS] = static_cast<int32_t>(accel[X_AXIS] * accelFac) / 100;
|
||||
newAccel[Y_AXIS] = static_cast<int32_t>(accel[Y_AXIS] * accelFac) / 100;
|
||||
#else
|
||||
newAccel[X_AXIS] = accel[X_AXIS];
|
||||
newAccel[Y_AXIS] = accel[Y_AXIS];
|
||||
#endif
|
||||
#if INTERPOLATE_ACCELERATION_WITH_Z == 2 || INTERPOLATE_ACCELERATION_WITH_Z == 3
|
||||
newAccel[Z_AXIS] = static_cast<int32_t>(accel[Z_AXIS] * accelFac) / 100;
|
||||
#else
|
||||
newAccel[Z_AXIS] = accel[Z_AXIS];
|
||||
#endif
|
||||
newAccel[E_AXIS] = accel[E_AXIS];
|
||||
accel = newAccel;
|
||||
#endif
|
||||
for(uint8_t i = 0; i < 4 ; i++)
|
||||
{
|
||||
if(isMoveOfAxis(i))
|
||||
// v = a * t => t = v/a = F_CPU/(c*a) => 1/t = c*a/F_CPU
|
||||
slowest_axis_plateau_time_repro = RMath::min(slowest_axis_plateau_time_repro, (float)axisInterval[i] * (float)accel[i]); // steps/s^2 * step/tick Ticks/s^2
|
||||
}
|
||||
|
||||
// Errors for delta move are initialized in timer (except extruder)
|
||||
#if !NONLINEAR_SYSTEM
|
||||
error[X_AXIS] = error[Y_AXIS] = error[Z_AXIS] = delta[primaryAxis] >> 1;
|
||||
|
@ -482,7 +672,7 @@ void PrintLine::updateTrapezoids()
|
|||
// now first points to last segment before the end speed is fixed
|
||||
// so start speed is also fixed.
|
||||
|
||||
if(first == linesWritePos) // Nothing to plan, only new element presend
|
||||
if(first == linesWritePos) // Nothing to plan, only new element present
|
||||
{
|
||||
act->block(); // Prevent steppe rinterrupt from using this
|
||||
noInts.unprotect();
|
||||
|
@ -521,7 +711,9 @@ void PrintLine::updateTrapezoids()
|
|||
act->updateStepsParameter();
|
||||
firstLine->unblock();
|
||||
return;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
computeMaxJunctionSpeed(previous, act); // Set maximum junction speed if we have a real move before
|
||||
}
|
||||
// Increase speed if possible neglecting current speed
|
||||
|
@ -554,20 +746,20 @@ Jerk = (1-cos(alpha))*min(v1,v2)
|
|||
This sets jerk to 0 on zero angle change.
|
||||
|
||||
Old New
|
||||
0<EFBFBD><EFBFBD>: 0 0
|
||||
30<EFBFBD><EFBFBD>: 51,8 13.4
|
||||
45<EFBFBD><EFBFBD>: 76.53 29.3
|
||||
90<EFBFBD><EFBFBD>: 141 100
|
||||
180<EFBFBD><EFBFBD>: 200 200
|
||||
0°: 0 0
|
||||
30°: 51,8 13.4
|
||||
45°: 76.53 29.3
|
||||
90°: 141 100
|
||||
180°: 200 200
|
||||
|
||||
|
||||
von 100 auf 200
|
||||
Old New(min) New(max)
|
||||
0<EFBFBD><EFBFBD>: 100 0 0
|
||||
30<EFBFBD><EFBFBD>: 123,9 13.4 26.8
|
||||
45<EFBFBD><EFBFBD>: 147.3 29.3 58.6
|
||||
90<EFBFBD><EFBFBD>: 223 100 200
|
||||
180<EFBFBD><EFBFBD>: 300 200 400
|
||||
0°: 100 0 0
|
||||
30°: 123,9 13.4 26.8
|
||||
45°: 147.3 29.3 58.6
|
||||
90°: 223 100 200
|
||||
180°: 300 200 400
|
||||
|
||||
*/
|
||||
inline void PrintLine::computeMaxJunctionSpeed(PrintLine *previous, PrintLine *current)
|
||||
|
@ -833,10 +1025,13 @@ inline float PrintLine::safeSpeed()
|
|||
if(isZMove())
|
||||
{
|
||||
float mz = Printer::maxZJerk * 0.5;
|
||||
if(isXOrYMove()) {
|
||||
if(fabs(speedZ) > mz)
|
||||
safe = RMath::min(safe,mz * fullSpeed / fabs(speedZ));
|
||||
} else {
|
||||
if(isXOrYMove())
|
||||
{
|
||||
if(fabs(speedZ) > mz)
|
||||
safe = RMath::min(safe,mz * fullSpeed / fabs(speedZ));
|
||||
}
|
||||
else
|
||||
{
|
||||
safe = mz;
|
||||
}
|
||||
}
|
||||
|
@ -864,8 +1059,9 @@ processing.
|
|||
*/
|
||||
uint8_t PrintLine::insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExtraLines)
|
||||
{
|
||||
if(linesCount == 0 && waitRelax == 0 && pathOptimize) // First line after some time - warmup needed
|
||||
if(linesCount == 0 && waitRelax == 0 && pathOptimize) // First line after some time - warm up needed
|
||||
{
|
||||
//return 0;
|
||||
#if NONLINEAR_SYSTEM
|
||||
uint8_t w = 3;
|
||||
#else
|
||||
|
@ -879,12 +1075,13 @@ uint8_t PrintLine::insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExt
|
|||
p->dir = 0;
|
||||
p->setWaitForXLinesFilled(w + waitExtraLines);
|
||||
#if NONLINEAR_SYSTEM
|
||||
p->setWaitTicks(50000);
|
||||
p->setWaitTicks(300000);
|
||||
#else
|
||||
p->setWaitTicks(25000);
|
||||
p->setWaitTicks(100000);
|
||||
#endif // NONLINEAR_SYSTEM
|
||||
pushLine();
|
||||
}
|
||||
//Com::printFLN(PSTR("InsertWait"));
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
|
@ -1020,7 +1217,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
|
|||
+ zSteps);
|
||||
else
|
||||
return 0;
|
||||
if (deltaPosSteps[A_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0;
|
||||
if (deltaPosSteps[A_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
|
||||
|
||||
temp = Printer::deltaBPosYSteps - cartesianPosSteps[Y_AXIS];
|
||||
opt = Printer::deltaDiagonalStepsSquaredB.f - temp * temp;
|
||||
|
@ -1030,7 +1227,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
|
|||
+ zSteps);
|
||||
else
|
||||
return 0;
|
||||
if (deltaPosSteps[B_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0;
|
||||
if (deltaPosSteps[B_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
|
||||
|
||||
temp = Printer::deltaCPosYSteps - cartesianPosSteps[Y_AXIS];
|
||||
opt = Printer::deltaDiagonalStepsSquaredC.f - temp * temp;
|
||||
|
@ -1040,7 +1237,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
|
|||
+ zSteps);
|
||||
else
|
||||
return 0;
|
||||
if (deltaPosSteps[C_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0;
|
||||
if (deltaPosSteps[C_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
|
||||
|
||||
return 1;
|
||||
#endif
|
||||
|
@ -1213,6 +1410,7 @@ void DeltaSegment::checkEndstops(PrintLine *cur,bool checkall)
|
|||
{
|
||||
if(Printer::isZProbingActive())
|
||||
{
|
||||
Endstops::update();
|
||||
#if FEATURE_Z_PROBE
|
||||
if(isZNegativeMove() && Endstops::zProbe())
|
||||
{
|
||||
|
@ -1241,6 +1439,8 @@ void DeltaSegment::checkEndstops(PrintLine *cur,bool checkall)
|
|||
}
|
||||
if(checkall)
|
||||
{
|
||||
if(!Printer::isZProbingActive())
|
||||
Endstops::update(); // do not test twice
|
||||
if(isXPositiveMove() && Endstops::xMax())
|
||||
{
|
||||
#if DRIVE_SYSTEM == DELTA
|
||||
|
@ -1469,6 +1669,11 @@ inline void PrintLine::queueEMove(int32_t extrudeDiff,uint8_t check_endstops,uin
|
|||
float axisDiff[5]; // Axis movement in mm
|
||||
if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS;
|
||||
else p->flags = 0;
|
||||
#if MIXING_EXTRUDER
|
||||
if(Printer::isAllEMotors()) {
|
||||
p->flags |= FLAG_ALL_E_MOTORS;
|
||||
}
|
||||
#endif
|
||||
p->joinFlags = 0;
|
||||
if(!pathOptimize) p->setEndSpeedFixed(true);
|
||||
//Find direction
|
||||
|
@ -1510,17 +1715,28 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
|
|||
//if (softEndstop && Printer::destinationSteps[Z_AXIS] < 0) Printer::destinationSteps[Z_AXIS] = 0; // now constrained at entry level including cylinder test
|
||||
int32_t difference[E_AXIS_ARRAY];
|
||||
float axis_diff[VIRTUAL_AXIS_ARRAY]; // Axis movement in mm. Virtual axis in 4;
|
||||
uint8_t secondSpeed = Printer::fanSpeed;
|
||||
for(fast8_t axis = 0; axis < E_AXIS_ARRAY; axis++)
|
||||
{
|
||||
difference[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
|
||||
if(axis == E_AXIS)
|
||||
{
|
||||
Printer::extrudeMultiplyError += (static_cast<float>(difference[E_AXIS]) * Printer::extrusionFactor);
|
||||
difference[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
|
||||
Printer::extrudeMultiplyError -= difference[E_AXIS];
|
||||
axis_diff[E_AXIS] = difference[E_AXIS] * Printer::invAxisStepsPerMM[E_AXIS];
|
||||
Printer::filamentPrinted += axis_diff[E_AXIS];
|
||||
axis_diff[E_AXIS] = fabs(axis_diff[E_AXIS]);
|
||||
if(Printer::mode == PRINTER_MODE_FFF)
|
||||
{
|
||||
Printer::extrudeMultiplyError += (static_cast<float>(difference[E_AXIS]) * Printer::extrusionFactor);
|
||||
difference[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
|
||||
Printer::extrudeMultiplyError -= difference[E_AXIS];
|
||||
axis_diff[E_AXIS] = difference[E_AXIS] * Printer::invAxisStepsPerMM[E_AXIS];
|
||||
Printer::filamentPrinted += axis_diff[E_AXIS];
|
||||
axis_diff[E_AXIS] = fabs(axis_diff[E_AXIS]);
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER)
|
||||
{
|
||||
secondSpeed = ((axis_diff[X_AXIS] != 0 || axis_diff[Y_AXIS] != 0) && (LaserDriver::laserOn || axis_diff[E_AXIS] != 0) ? LaserDriver::intensity : 0);
|
||||
axis_diff[E_AXIS] = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
axis_diff[axis] = fabs(difference[axis] * Printer::invAxisStepsPerMM[axis]);
|
||||
|
@ -1598,7 +1814,7 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
|
|||
waitForXFreeLines(1);
|
||||
|
||||
// Insert dummy moves if necessary
|
||||
// Nead to leave at least one slot open for the first split move
|
||||
// Need to leave at least one slot open for the first split move
|
||||
insertWaitMovesIfNeeded(pathOptimize, RMath::min(PRINTLINE_CACHE_SIZE - 4, numLines));
|
||||
uint32_t oldEDestination = Printer::destinationSteps[E_AXIS]; // flow and volumetric extrusion changed virtual target
|
||||
Printer::currentPositionSteps[E_AXIS] = 0;
|
||||
|
@ -1632,6 +1848,7 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
|
|||
}
|
||||
|
||||
p->joinFlags = 0;
|
||||
p->secondSpeed = secondSpeed;
|
||||
p->moveID = lastMoveID;
|
||||
|
||||
// Only set fixed on last segment
|
||||
|
@ -1639,6 +1856,11 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
|
|||
p->setEndSpeedFixed(true);
|
||||
|
||||
p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
|
||||
#if MIXING_EXTRUDER
|
||||
if(Printer::isAllEMotors()) {
|
||||
p->flags |= FLAG_ALL_E_MOTORS;
|
||||
}
|
||||
#endif
|
||||
p->numDeltaSegments = segmentsPerLine;
|
||||
|
||||
uint16_t maxDeltaStep = p->calculateDeltaSubSegments(softEndstop);
|
||||
|
@ -1703,7 +1925,7 @@ void PrintLine::arc(float *position, float *target, float *offset, float radius,
|
|||
// plan_set_acceleration_manager_enabled(false); // disable acceleration management for the duration of the arc
|
||||
float center_axis0 = position[X_AXIS] + offset[X_AXIS];
|
||||
float center_axis1 = position[Y_AXIS] + offset[Y_AXIS];
|
||||
float linear_travel = 0; //target[axis_linear] - position[axis_linear];
|
||||
//float linear_travel = 0; //target[axis_linear] - position[axis_linear];
|
||||
float extruder_travel = (Printer::destinationSteps[E_AXIS] - Printer::currentPositionSteps[E_AXIS]) * Printer::invAxisStepsPerMM[E_AXIS];
|
||||
float r_axis0 = -offset[0]; // Radius vector from center to current location
|
||||
float r_axis1 = -offset[1];
|
||||
|
@ -1716,7 +1938,7 @@ void PrintLine::arc(float *position, float *target, float *offset, float radius,
|
|||
*/
|
||||
// CCW angle between position and target from circle center. Only one atan2() trig computation required.
|
||||
float angular_travel = atan2(r_axis0 * rt_axis1 - r_axis1 * rt_axis0, r_axis0 * rt_axis0 + r_axis1 * rt_axis1);
|
||||
if (angular_travel < 0)
|
||||
if ((!isclockwise && angular_travel <= 0.00001) || (isclockwise && angular_travel < -0.000001))
|
||||
{
|
||||
angular_travel += 2.0f * M_PI;
|
||||
}
|
||||
|
@ -1875,7 +2097,7 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
//HAL::forbidInterrupts();
|
||||
//deltaSegmentCount -= cur->numDeltaSegments; // should always be zero
|
||||
removeCurrentLineForbidInterrupt();
|
||||
if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
|
||||
if(linesCount == 0) UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
|
||||
return 1000;
|
||||
}
|
||||
#endif
|
||||
|
@ -1901,7 +2123,7 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
if(Printer::isZProbingActive() && Printer::stepsRemainingAtZHit >= 0)
|
||||
{
|
||||
removeCurrentLineForbidInterrupt();
|
||||
if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
|
||||
if(linesCount == 0) UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
|
||||
return 1000;
|
||||
}
|
||||
#endif
|
||||
|
@ -1958,6 +2180,15 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
Printer::advanceExecuted = cur->advanceStart;
|
||||
#endif
|
||||
cur->updateAdvanceSteps(cur->vStart, 0, false);
|
||||
#endif
|
||||
if(Printer::mode == PRINTER_MODE_FFF) {
|
||||
Printer::setFanSpeedDirectly(cur->secondSpeed);
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER)
|
||||
{
|
||||
LaserDriver::changeIntensity(cur->secondSpeed);
|
||||
}
|
||||
#endif
|
||||
return Printer::interval; // Wait an other 50% from last step to make the 100% full
|
||||
} // End cur=0
|
||||
|
@ -1965,7 +2196,6 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
|
||||
if(curd != NULL)
|
||||
{
|
||||
Endstops::update();
|
||||
curd->checkEndstops(cur,(cur->isCheckEndstops()));
|
||||
}
|
||||
int maxLoops = (Printer::stepsPerTimerCall <= cur->stepsRemaining ? Printer::stepsPerTimerCall : cur->stepsRemaining);
|
||||
|
@ -2035,6 +2265,15 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
{
|
||||
if (cur->numDeltaSegments)
|
||||
{
|
||||
if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing/* && curd
|
||||
&& (curd->dir & XYZ_STEP) == XYZ_STEP*/)
|
||||
{
|
||||
// execute a extra babystep
|
||||
//Printer::insertStepperHighDelay();
|
||||
//Printer::endXYZSteps();
|
||||
//HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY + 1);
|
||||
Printer::zBabystep();
|
||||
}
|
||||
// Get the next delta segment
|
||||
curd = &cur->segments[--cur->numDeltaSegments];
|
||||
|
||||
|
@ -2053,48 +2292,6 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
HAL::delayMicroseconds(DIRECTION_DELAY);
|
||||
#endif
|
||||
|
||||
if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing && curd
|
||||
&& (curd->dir & XYZ_STEP) == XYZ_STEP)
|
||||
{
|
||||
// execute a extra babystep
|
||||
Printer::insertStepperHighDelay();
|
||||
Printer::endXYZSteps();
|
||||
HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY + 1);
|
||||
|
||||
if(Printer::zBabystepsMissing > 0)
|
||||
{
|
||||
if(curd->dir & X_DIRPOS)
|
||||
cur->startXStep();
|
||||
else
|
||||
cur->error[X_AXIS] += curd_errupd;
|
||||
if(curd->dir & Y_DIRPOS)
|
||||
cur->startYStep();
|
||||
else
|
||||
cur->error[Y_AXIS] += curd_errupd;
|
||||
if(curd->dir & Z_DIRPOS)
|
||||
cur->startZStep();
|
||||
else
|
||||
cur->error[Z_AXIS] += curd_errupd;
|
||||
Printer::zBabystepsMissing--;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(curd->dir & X_DIRPOS)
|
||||
cur->error[X_AXIS] += curd_errupd;
|
||||
else
|
||||
cur->startXStep();
|
||||
if(curd->dir & Y_DIRPOS)
|
||||
cur->error[Y_AXIS] += curd_errupd;
|
||||
else
|
||||
cur->startYStep();
|
||||
if(curd->dir & Z_DIRPOS)
|
||||
cur->error[Z_AXIS] += curd_errupd;
|
||||
else
|
||||
cur->startZStep();
|
||||
Printer::zBabystepsMissing++;
|
||||
}
|
||||
HAL::delayMicroseconds(1);
|
||||
}
|
||||
}
|
||||
else
|
||||
curd = 0;// Release the last segment
|
||||
|
@ -2196,7 +2393,18 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
|
|||
//deltaSegmentCount -= cur->numDeltaSegments; // should always be zero
|
||||
removeCurrentLineForbidInterrupt();
|
||||
Printer::disableAllowedStepper();
|
||||
if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
|
||||
if(linesCount == 0) {
|
||||
UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
|
||||
if(Printer::mode == PRINTER_MODE_FFF) {
|
||||
Printer::setFanSpeedDirectly(Printer::fanSpeed);
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER) // Last move disables laser for safety!
|
||||
{
|
||||
LaserDriver::changeIntensity(0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
Printer::interval >>= 1; // 50% of time to next call to do cur=0
|
||||
DEBUG_MEMORY;
|
||||
} // Do even
|
||||
|
@ -2342,16 +2550,26 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
|
|||
Printer::advanceExecuted = cur->advanceStart;
|
||||
#endif
|
||||
cur->updateAdvanceSteps(cur->vStart, 0, false);
|
||||
#endif
|
||||
if(Printer::mode == PRINTER_MODE_FFF) {
|
||||
Printer::setFanSpeedDirectly(cur->secondSpeed);
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER)
|
||||
{
|
||||
LaserDriver::changeIntensity(cur->secondSpeed);
|
||||
}
|
||||
#endif
|
||||
return Printer::interval; // Wait an other 50% from last step to make the 100% full
|
||||
} // End cur=0
|
||||
Endstops::update();
|
||||
cur->checkEndstops();
|
||||
fast8_t max_loops = RMath::min((int32_t)Printer::stepsPerTimerCall,cur->stepsRemaining);
|
||||
fast8_t max_loops = Printer::stepsPerTimerCall;
|
||||
if(cur->stepsRemaining < max_loops)
|
||||
max_loops = cur->stepsRemaining;
|
||||
for(fast8_t loop = 0; loop < max_loops; loop++)
|
||||
{
|
||||
#if STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY > 0
|
||||
if(loop > 0)
|
||||
if(loop)
|
||||
HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY);
|
||||
#endif
|
||||
if((cur->error[E_AXIS] -= cur->delta[E_AXIS]) < 0)
|
||||
|
@ -2369,19 +2587,25 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
|
|||
Extruder::step();
|
||||
cur->error[E_AXIS] += cur_errupd;
|
||||
}
|
||||
#if CPU_ARCH == ARCH_AVR
|
||||
if(cur->isXMove())
|
||||
#endif
|
||||
if((cur->error[X_AXIS] -= cur->delta[X_AXIS]) < 0)
|
||||
{
|
||||
cur->startXStep();
|
||||
cur->error[X_AXIS] += cur_errupd;
|
||||
}
|
||||
#if CPU_ARCH == ARCH_AVR
|
||||
if(cur->isYMove())
|
||||
#endif
|
||||
if((cur->error[Y_AXIS] -= cur->delta[Y_AXIS]) < 0)
|
||||
{
|
||||
cur->startYStep();
|
||||
cur->error[Y_AXIS] += cur_errupd;
|
||||
}
|
||||
#if CPU_ARCH == ARCH_AVR
|
||||
if(cur->isZMove())
|
||||
#endif
|
||||
if((cur->error[Z_AXIS] -= cur->delta[Z_AXIS]) < 0)
|
||||
{
|
||||
cur->startZStep();
|
||||
|
@ -2401,7 +2625,8 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
|
|||
#if USE_ADVANCE
|
||||
if(!Printer::isAdvanceActivated()) // Use interrupt for movement
|
||||
#endif
|
||||
Extruder::unstep();
|
||||
cur->stepsRemaining--;
|
||||
Extruder::unstep();
|
||||
Printer::endXYZSteps();
|
||||
} // for loop
|
||||
HAL::allowInterrupts(); // Allow interrupts for other types, timer1 is still disabled
|
||||
|
@ -2464,7 +2689,6 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
|
|||
Printer::stepsPerTimerCall = 1;
|
||||
Printer::interval = cur->fullInterval; // without RAMPS always use full speed
|
||||
#endif // RAMP_ACCELERATION
|
||||
cur->stepsRemaining -= max_loops;
|
||||
long interval = Printer::interval;
|
||||
if(cur->stepsRemaining <= 0 || cur->isNoMove()) // line finished
|
||||
{
|
||||
|
@ -2477,16 +2701,27 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
|
|||
#endif
|
||||
removeCurrentLineForbidInterrupt();
|
||||
Printer::disableAllowedStepper();
|
||||
if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
|
||||
if(linesCount == 0)
|
||||
{
|
||||
UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
|
||||
if(Printer::mode == PRINTER_MODE_FFF) {
|
||||
Printer::setFanSpeedDirectly(Printer::fanSpeed);
|
||||
}
|
||||
#if defined(SUPPORT_LASER) && SUPPORT_LASER
|
||||
else if(Printer::mode == PRINTER_MODE_LASER) // Last move disables laser for safety!
|
||||
{
|
||||
LaserDriver::changeIntensity(0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
interval = Printer::interval = interval >> 1; // 50% of time to next call to do cur=0
|
||||
DEBUG_MEMORY;
|
||||
} // Do even
|
||||
if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing)
|
||||
{
|
||||
HAL::forbidInterrupts();
|
||||
Printer::zBabystep();
|
||||
}
|
||||
return interval;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
@ -28,10 +28,10 @@
|
|||
#define FLAG_WARMUP 1
|
||||
#define FLAG_NOMINAL 2
|
||||
#define FLAG_DECELERATING 4
|
||||
#define FLAG_ACCELERATION_ENABLED 8
|
||||
#define FLAG_ACCELERATION_ENABLED 8 // unused
|
||||
#define FLAG_CHECK_ENDSTOPS 16
|
||||
#define FLAG_SKIP_ACCELERATING 32
|
||||
#define FLAG_SKIP_DEACCELERATING 64
|
||||
#define FLAG_ALL_E_MOTORS 32 // For mixed extruder move all motors instead of selected motor
|
||||
#define FLAG_SKIP_DEACCELERATING 64 // unused
|
||||
#define FLAG_BLOCKED 128
|
||||
|
||||
/** Are the step parameter computed */
|
||||
|
@ -174,10 +174,11 @@ public:
|
|||
static ufast8_t linesWritePos; // Position where we write the next cached line move
|
||||
ufast8_t joinFlags;
|
||||
volatile ufast8_t flags;
|
||||
uint8_t secondSpeed; // for laser intensity or fan control
|
||||
private:
|
||||
fast8_t primaryAxis;
|
||||
int32_t timeInTicks;
|
||||
ufast8_t dir; ///< Direction of movement. 1 = X+, 2 = Y+, 4= Z+, values can be combined.
|
||||
int32_t timeInTicks;
|
||||
int32_t delta[E_AXIS_ARRAY]; ///< Steps we want to move.
|
||||
int32_t error[E_AXIS_ARRAY]; ///< Error calculation for Bresenham algorithm
|
||||
float speedX; ///< Speed in x direction at fullInterval in mm/s
|
||||
|
@ -282,6 +283,9 @@ public:
|
|||
{
|
||||
return flags & FLAG_BLOCKED;
|
||||
}
|
||||
inline bool isAllEMotors() {
|
||||
return flags & FLAG_ALL_E_MOTORS;
|
||||
}
|
||||
inline bool isCheckEndstops()
|
||||
{
|
||||
return flags & FLAG_CHECK_ENDSTOPS;
|
||||
|
@ -298,6 +302,7 @@ public:
|
|||
{
|
||||
if(isCheckEndstops())
|
||||
{
|
||||
Endstops::update();
|
||||
if(isXNegativeMove() && Endstops::xMin())
|
||||
setXMoveFinished();
|
||||
else if(isXPositiveMove() && Endstops::xMax())
|
||||
|
@ -327,10 +332,13 @@ public:
|
|||
}
|
||||
}
|
||||
#if FEATURE_Z_PROBE
|
||||
else if(Printer::isZProbingActive() && isZNegativeMove() && Endstops::zProbe())
|
||||
{
|
||||
setZMoveFinished();
|
||||
Printer::stepsRemainingAtZHit = stepsRemaining;
|
||||
else if(Printer::isZProbingActive() && isZNegativeMove()) {
|
||||
Endstops::update();
|
||||
if(Endstops::zProbe())
|
||||
{
|
||||
setZMoveFinished();
|
||||
Printer::stepsRemainingAtZHit = stepsRemaining;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
@ -488,7 +496,7 @@ public:
|
|||
#endif
|
||||
#endif
|
||||
}
|
||||
inline bool moveDecelerating()
|
||||
INLINE bool moveDecelerating()
|
||||
{
|
||||
if(stepsRemaining <= decelSteps)
|
||||
{
|
||||
|
@ -501,17 +509,14 @@ public:
|
|||
}
|
||||
else return false;
|
||||
}
|
||||
inline bool moveAccelerating()
|
||||
INLINE bool moveAccelerating()
|
||||
{
|
||||
return Printer::stepNumber <= accelSteps;
|
||||
}
|
||||
inline void startXStep()
|
||||
INLINE void startXStep()
|
||||
{
|
||||
#if !(GANTRY)
|
||||
WRITE(X_STEP_PIN,HIGH);
|
||||
#if FEATURE_TWO_XSTEPPER
|
||||
WRITE(X2_STEP_PIN,HIGH);
|
||||
#endif
|
||||
Printer::startXStep();
|
||||
#else
|
||||
#if DRIVE_SYSTEM == XY_GANTRY || DRIVE_SYSTEM == XZ_GANTRY
|
||||
if(isXPositiveMove())
|
||||
|
@ -541,15 +546,11 @@ public:
|
|||
#ifdef DEBUG_STEPCOUNT
|
||||
totalStepsRemaining--;
|
||||
#endif
|
||||
|
||||
}
|
||||
inline void startYStep()
|
||||
INLINE void startYStep()
|
||||
{
|
||||
#if !(GANTRY) || DRIVE_SYSTEM == ZX_GANTRY || DRIVE_SYSTEM == XZ_GANTRY
|
||||
WRITE(Y_STEP_PIN,HIGH);
|
||||
#if FEATURE_TWO_YSTEPPER
|
||||
WRITE(Y2_STEP_PIN,HIGH);
|
||||
#endif
|
||||
Printer::startYStep();
|
||||
#else
|
||||
#if DRIVE_SYSTEM == XY_GANTRY
|
||||
if(isYPositiveMove())
|
||||
|
@ -579,17 +580,15 @@ public:
|
|||
#ifdef DEBUG_STEPCOUNT
|
||||
totalStepsRemaining--;
|
||||
#endif
|
||||
|
||||
}
|
||||
inline void startZStep()
|
||||
INLINE void startZStep()
|
||||
{
|
||||
#if !(GANTRY) || DRIVE_SYSTEM == YX_GANTRY || DRIVE_SYSTEM == XY_GANTRY
|
||||
WRITE(Z_STEP_PIN,HIGH);
|
||||
#if FEATURE_TWO_ZSTEPPER
|
||||
WRITE(Z2_STEP_PIN,HIGH);
|
||||
#endif
|
||||
Printer::startZStep();
|
||||
#else
|
||||
#if DRIVE_SYSTEM == XZ_GANTRY
|
||||
if(isYPositiveMove())
|
||||
if(isZPositiveMove())
|
||||
{
|
||||
Printer::motorX++;
|
||||
Printer::motorYorZ--;
|
||||
|
@ -601,7 +600,7 @@ public:
|
|||
}
|
||||
#endif
|
||||
#if DRIVE_SYSTEM == ZX_GANTRY
|
||||
if(isYPositiveMove())
|
||||
if(isZPositiveMove())
|
||||
{
|
||||
Printer::motorX++;
|
||||
Printer::motorYorZ++;
|
||||
|
@ -612,26 +611,29 @@ public:
|
|||
Printer::motorYorZ--;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#ifdef DEBUG_STEPCOUNT
|
||||
totalStepsRemaining--;
|
||||
#endif
|
||||
}
|
||||
void updateStepsParameter();
|
||||
inline float safeSpeed();
|
||||
float safeSpeed();
|
||||
void calculateMove(float axis_diff[],uint8_t pathOptimize);
|
||||
void logLine();
|
||||
inline long getWaitTicks()
|
||||
INLINE long getWaitTicks()
|
||||
{
|
||||
return timeInTicks;
|
||||
}
|
||||
inline void setWaitTicks(long wait)
|
||||
INLINE void setWaitTicks(long wait)
|
||||
{
|
||||
timeInTicks = wait;
|
||||
}
|
||||
|
||||
static inline bool hasLines()
|
||||
static INLINE bool hasLines()
|
||||
{
|
||||
return linesCount;
|
||||
}
|
||||
static inline void setCurrentLine()
|
||||
static INLINE void setCurrentLine()
|
||||
{
|
||||
cur = &lines[linesPos];
|
||||
#if CPU_ARCH==ARCH_ARM
|
||||
|
@ -639,7 +641,7 @@ public:
|
|||
#endif
|
||||
}
|
||||
// Only called from within interrupts
|
||||
static inline void removeCurrentLineForbidInterrupt()
|
||||
static INLINE void removeCurrentLineForbidInterrupt()
|
||||
{
|
||||
linesPos++;
|
||||
if(linesPos >= PRINTLINE_CACHE_SIZE) linesPos = 0;
|
||||
|
@ -652,7 +654,7 @@ public:
|
|||
if(!linesCount)
|
||||
Printer::setMenuMode(MENU_MODE_PRINTING, false);
|
||||
}
|
||||
static inline void pushLine()
|
||||
static INLINE void pushLine()
|
||||
{
|
||||
linesWritePos++;
|
||||
if(linesWritePos >= PRINTLINE_CACHE_SIZE) linesWritePos = 0;
|
||||
|
@ -676,17 +678,22 @@ public:
|
|||
static inline void backwardPlanner(ufast8_t p,ufast8_t last);
|
||||
static void updateTrapezoids();
|
||||
static uint8_t insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExtraLines);
|
||||
#if NONLINEAR_SYSTEM == 0
|
||||
static void queueCartesianMove(uint8_t check_endstops,uint8_t pathOptimize);
|
||||
static void moveRelativeDistanceInSteps(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd,bool check_endstop);
|
||||
static void moveRelativeDistanceInStepsReal(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd);
|
||||
#if DISTORTION_CORRECTION
|
||||
static void queueCartesianSegmentTo(uint8_t check_endstops, uint8_t pathOptimize);
|
||||
#endif
|
||||
#endif
|
||||
static void moveRelativeDistanceInSteps(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd,bool check_endstop,bool pathOptimize = true);
|
||||
static void moveRelativeDistanceInStepsReal(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd,bool pathOptimize = true);
|
||||
#if ARC_SUPPORT
|
||||
static void arc(float *position, float *target, float *offset, float radius, uint8_t isclockwise);
|
||||
#endif
|
||||
static inline void previousPlannerIndex(ufast8_t &p)
|
||||
static INLINE void previousPlannerIndex(ufast8_t &p)
|
||||
{
|
||||
p = (p ? p - 1 : PRINTLINE_CACHE_SIZE - 1);
|
||||
}
|
||||
static inline void nextPlannerIndex(ufast8_t& p)
|
||||
static INLINE void nextPlannerIndex(ufast8_t& p)
|
||||
{
|
||||
p = (p == PRINTLINE_CACHE_SIZE - 1 ? 0 : p + 1);
|
||||
}
|
||||
|
@ -706,5 +713,3 @@ public:
|
|||
|
||||
|
||||
#endif // MOTION_H_INCLUDED
|
||||
|
||||
|
||||
|
|
891
Repetier/pins.h
891
Repetier/pins.h
File diff suppressed because it is too large
Load diff
|
@ -116,6 +116,11 @@ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
*/
|
||||
|
||||
// these warnings appear and are no problem.
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
|
||||
// ============= u8g.h ====================
|
||||
|
||||
/*
|
||||
|
@ -156,6 +161,7 @@ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#ifndef _U8G_H
|
||||
#define _U8G_H
|
||||
|
||||
|
||||
/* uncomment the following line to support displays larger than 240x240 */
|
||||
//#define U8G_16BIT 1
|
||||
|
||||
|
@ -854,6 +860,7 @@ defined(__18CXX) || defined(__PIC32MX)
|
|||
#define U8G_SPI_CLK_CYCLE_50NS 1
|
||||
#define U8G_SPI_CLK_CYCLE_300NS 2
|
||||
#define U8G_SPI_CLK_CYCLE_400NS 3
|
||||
#define U8G_SPI_CLK_CYCLE_500NS 4
|
||||
#define U8G_SPI_CLK_CYCLE_NONE 255
|
||||
|
||||
uint8_t u8g_InitCom(u8g_t *u8g, u8g_dev_t *dev, uint8_t clk_cycle_time);
|
||||
|
@ -6832,8 +6839,8 @@ static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) U8G_NOINLINE;
|
||||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
|
||||
{
|
||||
uint8_t cnt = 8;
|
||||
/*
|
||||
uint8_t cnt = 8;
|
||||
uint8_t bitData = u8g_bitData;
|
||||
uint8_t bitNotData = u8g_bitNotData;
|
||||
uint8_t bitClock = u8g_bitClock;
|
||||
|
@ -6864,7 +6871,7 @@ static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
|
|||
U8G_ATOMIC_START();
|
||||
#ifdef UI_SPI_MOSI
|
||||
|
||||
for( cnt=0; cnt<8; cnt++ )
|
||||
for(uint8_t cnt=0; cnt<8; cnt++ )
|
||||
{
|
||||
WRITE(UI_SPI_SCK, LOW);
|
||||
WRITE(UI_SPI_MOSI, val&0x80);
|
||||
|
@ -6982,8 +6989,6 @@ static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
|
|||
|
||||
static void u8g_com_arduino_st7920_write_byte_seq(uint8_t rs, uint8_t *ptr, uint8_t len)
|
||||
{
|
||||
uint8_t i;
|
||||
|
||||
if ( rs == 0 )
|
||||
{
|
||||
/* command */
|
||||
|
@ -7010,8 +7015,6 @@ static void u8g_com_arduino_st7920_write_byte_seq(uint8_t rs, uint8_t *ptr, uint
|
|||
|
||||
static void u8g_com_arduino_st7920_write_byte(uint8_t rs, uint8_t val)
|
||||
{
|
||||
uint8_t i;
|
||||
|
||||
if ( rs == 0 )
|
||||
{
|
||||
/* command */
|
||||
|
@ -9774,7 +9777,11 @@ uint8_t u8g_dev_st7565_nhd_c12864_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
|
|||
switch(msg)
|
||||
{
|
||||
case U8G_DEV_MSG_INIT:
|
||||
#if defined(__SAM3X8E__)
|
||||
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_400NS);
|
||||
#else
|
||||
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_400NS);
|
||||
#endif
|
||||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_init_seq);
|
||||
break;
|
||||
case U8G_DEV_MSG_STOP:
|
||||
|
@ -10211,6 +10218,10 @@ uint8_t u8g_com_arduino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
|
|||
{
|
||||
SPI0->SPI_CSR[0] = SPI_CSR_SCBR(34) | 1;
|
||||
}
|
||||
else if ( arg_val <= U8G_SPI_CLK_CYCLE_500NS )
|
||||
{
|
||||
SPI0->SPI_CSR[0] = SPI_CSR_SCBR(42) | 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
SPI0->SPI_CSR[0] = SPI_CSR_SCBR(84) | 1;
|
||||
|
@ -10699,5 +10710,4 @@ uint8_t u8g_dev_rot270_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
|
|
476
Repetier/ui.cpp
476
Repetier/ui.cpp
File diff suppressed because it is too large
Load diff
641
Repetier/ui.h
641
Repetier/ui.h
File diff suppressed because it is too large
Load diff
|
@ -378,7 +378,7 @@ void uiInitKeys() {
|
|||
// UI_KEYS_INIT_MATRIX(32,47,45,43,41,39,37,35);
|
||||
#endif
|
||||
}
|
||||
void uiCheckKeys(int &action) {
|
||||
void uiCheckKeys(uint16_t &action) {
|
||||
#if UI_HAS_KEYS!=0
|
||||
|
||||
//UI_KEYS_CLICKENCODER_LOW_REV(33,31); // click encoder on pins 47 and 45. Phase is connected with gnd for signals.
|
||||
|
@ -402,7 +402,7 @@ inline void uiCheckSlowEncoder() {
|
|||
HAL::i2cWrite(0x12); // GIOA
|
||||
HAL::i2cStop();
|
||||
HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ);
|
||||
unsigned int keymask = HAL::i2cReadAck();
|
||||
uint16_t keymask = HAL::i2cReadAck();
|
||||
keymask = keymask + (HAL::i2cReadNak()<<8);
|
||||
#endif
|
||||
HAL::i2cStop();
|
||||
|
@ -410,7 +410,7 @@ inline void uiCheckSlowEncoder() {
|
|||
UI_KEYS_I2C_CLICKENCODER_LOW_REV(_BV(2),_BV(0)); // click encoder on pins 0 and 2. Phase is connected with gnd for signals.
|
||||
#endif
|
||||
}
|
||||
void uiCheckSlowKeys(int &action) {
|
||||
void uiCheckSlowKeys(uint16_t &action) {
|
||||
#if defined(UI_HAS_I2C_KEYS) && UI_HAS_KEYS!=0
|
||||
#if UI_DISPLAY_I2C_CHIPTYPE==0
|
||||
HAL::i2cStartWait(UI_I2C_KEY_ADDRESS+I2C_READ);
|
||||
|
@ -421,7 +421,7 @@ void uiCheckSlowKeys(int &action) {
|
|||
HAL::i2cWrite(0x12); // GPIOA
|
||||
HAL::i2cStop();
|
||||
HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ);
|
||||
unsigned int keymask = HAL::i2cReadAck();
|
||||
uint16_t keymask = HAL::i2cReadAck();
|
||||
keymask = keymask + (HAL::i2cReadNak()<<8);
|
||||
#endif
|
||||
HAL::i2cStop();
|
||||
|
@ -451,5 +451,3 @@ void uiCheckSlowKeys(int &action) {
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
6065
Repetier/uilang.cpp
Normal file
6065
Repetier/uilang.cpp
Normal file
File diff suppressed because it is too large
Load diff
5245
Repetier/uilang.h
5245
Repetier/uilang.h
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue