Updated Repetier version

This commit is contained in:
Nis Wechselberg 2016-01-15 20:42:10 +01:00
parent d46229bf4b
commit a0bb6d8315
73 changed files with 23884 additions and 15089 deletions

View file

@ -63,6 +63,9 @@ WiFiServer server(port);
void setup() { void setup() {
// Set wifi mode to client
WiFi.mode(WIFI_STA);
// Initialize Serial connection // Initialize Serial connection
Serial.begin(115200); Serial.begin(115200);
delay(10); delay(10);
@ -73,8 +76,6 @@ void setup() {
pinMode(bluePin, OUTPUT); pinMode(bluePin, OUTPUT);
// Connect to WiFi network // Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to "); Serial.print("Connecting to ");
Serial.println(ssid); Serial.println(ssid);
WiFi.begin(ssid, password); WiFi.begin(ssid, password);

635
Repetier/BedLeveling.cpp Normal file
View 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

View file

@ -21,7 +21,7 @@
#include "Repetier.h" #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::lowestRAMValue = MAX_RAM;
int Commands::lowestRAMValueSend = MAX_RAM; int Commands::lowestRAMValueSend = MAX_RAM;
@ -161,6 +161,7 @@ void Commands::printCurrentPosition(FSTRINGPARAM(s))
void Commands::printTemperatures(bool showRaw) void Commands::printTemperatures(bool showRaw)
{ {
#if NUM_EXTRUDER > 0
float temp = Extruder::current->tempControl.currentTemperatureC; float temp = Extruder::current->tempControl.currentTemperatureC;
#if HEATED_BED_SENSOR_TYPE == 0 #if HEATED_BED_SENSOR_TYPE == 0
Com::printF(Com::tTColon,temp); 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); 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 #endif
Com::println(); Com::println();
#endif
} }
void Commands::changeFeedrateMultiply(int factor) void Commands::changeFeedrateMultiply(int factor)
{ {
@ -222,26 +230,38 @@ void Commands::changeFlowrateMultiply(int factor)
Com::printFLN(Com::tFlowMultiply, factor); Com::printFLN(Com::tFlowMultiply, factor);
} }
#if FEATURE_FAN_CONTROL
uint8_t fanKickstart; 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); speed = constrain(speed,0,255);
Printer::setMenuMode(MENU_MODE_FAN_RUNNING,speed != 0); Printer::setMenuMode(MENU_MODE_FAN_RUNNING,speed != 0);
if(wait) Printer::fanSpeed = speed;
Commands::waitUntilEndOfAllMoves(); // use only if neededthis to change the speed exactly at that point, but it may cause blobs if you do! if(PrintLine::linesCount == 0 || immediately) {
if(speed != pwm_pos[NUM_EXTRUDER + 2]) if(Printer::mode == PRINTER_MODE_FFF)
{ {
Com::printFLN(Com::tFanspeed,speed); // send only new values to break update loops! for(fast8_t i = 0; i < PRINTLINE_CACHE_SIZE; i++)
#if FAN_KICKSTART_TIME PrintLine::lines[i].secondSpeed = speed; // fill all printline buffers with new fan speed value
if(fanKickstart == 0 && speed > pwm_pos[NUM_EXTRUDER + 2] && speed < 85)
{
if(pwm_pos[NUM_EXTRUDER + 2]) fanKickstart = FAN_KICKSTART_TIME/100;
else fanKickstart = FAN_KICKSTART_TIME/25;
} }
Printer::setFanSpeedDirectly(speed);
}
Com::printFLN(Com::tFanspeed,speed); // send only new values to break update loops!
#endif #endif
} }
pwm_pos[NUM_EXTRUDER + 2] = speed; 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 #endif
} }
@ -252,9 +272,10 @@ void Commands::reportPrinterUsage()
Com::printF(Com::tPrintedFilament, dist, 2); Com::printF(Com::tPrintedFilament, dist, 2);
Com::printF(Com::tSpacem); Com::printF(Com::tSpacem);
bool alloff = true; bool alloff = true;
#if NUM_EXTRUDER > 0
for(uint8_t i = 0; i < NUM_EXTRUDER; i++) for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
if(tempController[i]->targetTemperatureC > 15) alloff = false; 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 seconds = (alloff ? 0 : (HAL::timeInMilliseconds() - Printer::msecondsPrinting) / 1000) + HAL::eprGetInt32(EPR_PRINTING_TIME);
int32_t tmp = seconds / 86400; int32_t tmp = seconds / 86400;
seconds -= tmp * 86400; seconds -= tmp * 86400;
@ -906,7 +927,7 @@ void Commands::processArc(GCode *com)
PrintLine::arc(position, target, offset, r, isclockwise); PrintLine::arc(position, target, offset, r, isclockwise);
} }
#endif #endif
extern void runBedLeveling(GCode *com);
/** /**
\brief Execute the G command stored in com. \brief Execute the G command stored in com.
*/ */
@ -917,6 +938,13 @@ void Commands::processGCode(GCode *com)
{ {
case 0: // G0 -> G1 case 0: // G0 -> G1
case 1: // 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(com->hasS()) Printer::setNoDestinationCheck(com->S != 0);
if(Printer::setDestinationStepsFromGCode(com)) // For X Y Z E F if(Printer::setDestinationStepsFromGCode(com)) // For X Y Z E F
#if NONLINEAR_SYSTEM #if NONLINEAR_SYSTEM
@ -948,11 +976,26 @@ void Commands::processGCode(GCode *com)
Com::printFLN(PSTR("Buffer corrupted")); Com::printFLN(PSTR("Buffer corrupted"));
} }
#endif #endif
#if defined(SUPPORT_LASER) && SUPPORT_LASER
LaserDriver::laserOn = laserOn;
}
#endif // defined
break; break;
#if ARC_SUPPORT #if ARC_SUPPORT
case 2: // CW Arc case 2: // CW Arc
case 3: // CCW Arc MOTION_MODE_CW_ARC: case MOTION_MODE_CCW_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); processArc(com);
#if defined(SUPPORT_LASER) && SUPPORT_LASER
LaserDriver::laserOn = laserOn;
}
#endif // defined
break; break;
#endif #endif
case 4: // G4 dwell case 4: // G4 dwell
@ -1074,7 +1117,10 @@ void Commands::processGCode(GCode *com)
break; break;
#if FEATURE_AUTOLEVEL #if FEATURE_AUTOLEVEL
case 32: // G32 Auto-Bed leveling case 32: // G32 Auto-Bed leveling
runBedLeveling(com);
#if 0
{ {
#if DISTORTION_CORRECTION #if DISTORTION_CORRECTION
Printer::distortion.disable(true); // if level has changed, distortion is also invalid Printer::distortion.disable(true); // if level has changed, distortion is also invalid
#endif #endif
@ -1082,7 +1128,7 @@ void Commands::processGCode(GCode *com)
#if DRIVE_SYSTEM == DELTA #if DRIVE_SYSTEM == DELTA
// It is not possible to go to the edges at the top, also users try // 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. // 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::homeAxis(true, true, true);
Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]); Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
#endif #endif
@ -1099,18 +1145,6 @@ void Commands::processGCode(GCode *com)
Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed()); Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
h3 = Printer::runZProbe(false,true); h3 = Printer::runZProbe(false,true);
if(h3 < -1) break; 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 #if defined(MOTORIZED_BED_LEVELING) && defined(NUM_MOTOR_DRIVERS) && NUM_MOTOR_DRIVERS >= 2
// h1 is reference heights, h2 => motor 0, h3 => motor 1 // h1 is reference heights, h2 => motor 0, h3 => motor 1
h2 -= h1; h2 -= h1;
@ -1179,8 +1213,29 @@ void Commands::processGCode(GCode *com)
#endif #endif
Printer::feedrate = oldFeedrate; Printer::feedrate = oldFeedrate;
} }
#endif
break; break;
#endif #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 #endif
case 90: // G90 case 90: // G90
Printer::relativeCoordinateMode = false; Printer::relativeCoordinateMode = false;
@ -1345,6 +1400,7 @@ void Commands::processGCode(GCode *com)
EEPROM::setDeltaTowerZOffsetSteps(offz); EEPROM::setDeltaTowerZOffsetSteps(offz);
} }
#endif #endif
PrintLine::moveRelativeDistanceInSteps(0, 0, -5*Printer::axisStepsPerMM[Z_AXIS], 0, Printer::homingFeedrate[Z_AXIS], true, true);
Printer::homeAxis(true,true,true); Printer::homeAxis(true,true,true);
} }
break; break;
@ -1371,10 +1427,11 @@ void Commands::processGCode(GCode *com)
Com::printFLN(Com::tTower2,offy); Com::printFLN(Com::tTower2,offy);
Com::printFLN(Com::tTower3,offz); Com::printFLN(Com::tTower3,offz);
Printer::setAutolevelActive(oldAuto); 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); Printer::homeAxis(true,true,true);
} }
break; break;
case 134: // G134 case 135: // G135
Com::printF(PSTR("CompDelta:"),Printer::currentDeltaPositionSteps[A_TOWER]); Com::printF(PSTR("CompDelta:"),Printer::currentDeltaPositionSteps[A_TOWER]);
Com::printF(Com::tComma,Printer::currentDeltaPositionSteps[B_TOWER]); Com::printF(Com::tComma,Printer::currentDeltaPositionSteps[B_TOWER]);
Com::printFLN(Com::tComma,Printer::currentDeltaPositionSteps[C_TOWER]); Com::printFLN(Com::tComma,Printer::currentDeltaPositionSteps[C_TOWER]);
@ -1389,6 +1446,31 @@ void Commands::processGCode(GCode *com)
break; break;
#endif // DRIVE_SYSTEM #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 #if defined(NUM_MOTOR_DRIVERS) && NUM_MOTOR_DRIVERS > 0
case 201: case 201:
commandG201(*com); commandG201(*com);
@ -1417,13 +1499,56 @@ void Commands::processGCode(GCode *com)
*/ */
void Commands::processMCode(GCode *com) void Commands::processMCode(GCode *com)
{ {
uint32_t codenum; //throw away variable
switch( com->M ) 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 #if SDSUPPORT
case 20: // M20 - list SD card 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(); sd.ls();
#endif
break; break;
case 21: // M21 - init SD card case 21: // M21 - init SD card
sd.mount(); sd.mount();
@ -1473,6 +1598,13 @@ void Commands::processMCode(GCode *com)
sd.makeDirectory(com->text); sd.makeDirectory(com->text);
} }
break; break;
#endif
#if JSON_OUTPUT && SDSUPPORT
case 36: // M36 JSON File Info
if (com->hasString()) {
sd.JSONFileInfo(com->text);
}
break;
#endif #endif
case 42: //M42 -Change pin status via gcode case 42: //M42 -Change pin status via gcode
if (com->hasP()) if (com->hasP())
@ -1687,9 +1819,10 @@ void Commands::processMCode(GCode *com)
previousMillisCmd = HAL::timeInMilliseconds(); previousMillisCmd = HAL::timeInMilliseconds();
break; break;
case 190: // M190 - Wait bed for heater to reach target. case 190: // M190 - Wait bed for heater to reach target.
{
#if HAVE_HEATED_BED #if HAVE_HEATED_BED
if(Printer::debugDryrun()) break; if(Printer::debugDryrun()) break;
UI_STATUS_UPD(UI_TEXT_HEATING_BED); UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_HEATING_BED_ID));
Commands::waitUntilEndOfAllMoves(); Commands::waitUntilEndOfAllMoves();
#if HAVE_HEATED_BED #if HAVE_HEATED_BED
if (com->hasS()) Extruder::setHeatedBedTemperature(com->S,com->hasF() && com->F > 0); 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; if(abs(heatedBedController.currentTemperatureC - heatedBedController.targetTemperatureC) < SKIP_M190_IF_WITHIN) break;
#endif #endif
EVENT_WAITING_HEATER(-1); EVENT_WAITING_HEATER(-1);
uint32_t codenum; //throw away variable
codenum = HAL::timeInMilliseconds(); codenum = HAL::timeInMilliseconds();
while(heatedBedController.currentTemperatureC + 0.5 < heatedBedController.targetTemperatureC && heatedBedController.targetTemperatureC > 25.0) while(heatedBedController.currentTemperatureC + 0.5 < heatedBedController.targetTemperatureC && heatedBedController.targetTemperatureC > 25.0)
{ {
@ -1712,7 +1846,9 @@ void Commands::processMCode(GCode *com)
#endif #endif
UI_CLEAR_STATUS; UI_CLEAR_STATUS;
previousMillisCmd = HAL::timeInMilliseconds(); previousMillisCmd = HAL::timeInMilliseconds();
}
break; break;
#if NUM_TEMPERATURE_LOOPS > 0
case 116: // Wait for temperatures to reach target temperature case 116: // Wait for temperatures to reach target temperature
for(fast8_t h = 0; h < NUM_TEMPERATURE_LOOPS; h++) 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); EVENT_HEATING_FINISHED(h < NUM_EXTRUDER ? h : -1);
} }
break; break;
#endif
#if FAN_PIN>-1 && FEATURE_FAN_CONTROL #if FAN_PIN>-1 && FEATURE_FAN_CONTROL
case 106: // M106 Fan On case 106: // M106 Fan On
if(!(Printer::flag2 & PRINTER_FLAG2_IGNORE_M106_COMMAND)) 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; break;
case 107: // M107 Fan Off case 107: // M107 Fan Off
setFanSpeed(0, com->hasP()); if(com->hasP() && com->P == 1)
setFan2Speed(0);
else
setFanSpeed(0);
break; break;
#endif #endif
case 111: // M111 enable/disable run time debug flags 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->hasP())
{ {
if (com->P > 0) Printer::debugLevel |= com->P; if (com->P > 0) Printer::debugSet(static_cast<uint8_t>(com->P));
else Printer::debugLevel &= ~(-com->P); else Printer::debugReset(static_cast<uint8_t>(-com->P));
} }
if(Printer::debugDryrun()) // simulate movements without printing 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++) for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
Extruder::setTemperatureForExtruder(0, i); Extruder::setTemperatureForExtruder(0, i);
#else #else
Extruder::setTemperatureForExtruder(0, 0); Extruder::setTemperatureForExtruder(0, 0);
#endif #endif
#if HEATED_BED_TYPE!=0 #if HAVE_HEATED_BED != 0
target_bed_raw = 0; Extruder::setHeatedBedTemperature(0,false);
#endif #endif
} }
break; break;
case 115: // M115 case 115: // M115
Com::printFLN(Com::tFirmware); Com::printFLN(Com::tFirmware);
reportPrinterUsage(); reportPrinterUsage();
Printer::reportPrinterMode();
break; break;
case 114: // M114 case 114: // M114
printCurrentPosition(PSTR("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 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) if(com->hasS() && com->hasP() && com->S < NUM_EXTRUDER && com->S >= 0)
Extruder::setMixingWeight(com->S, com->P); Extruder::setMixingWeight(com->S, com->P);
Extruder::recomputeMixingExtruderSteps();
break; break;
case 164: /// M164 S<virtNum> P<0 = dont store eeprom,1 = store to eeprom> - Store weights as virtual extruder S 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 if(!com->hasS() || com->S < 0 || com->S >= VIRTUAL_EXTRUDER) break; // ignore illigal values
@ -1894,6 +2037,22 @@ void Commands::processMCode(GCode *com)
case 221: // M221 S<Extrusion flow multiplier in percent> case 221: // M221 S<Extrusion flow multiplier in percent>
changeFlowrateMultiply(com->getS(100)); changeFlowrateMultiply(com->getS(100));
break; 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 #if USE_ADVANCE
case 223: // M223 Extruder interrupt test case 223: // M223 Extruder interrupt test
if(com->hasS()) if(com->hasS())
@ -2088,6 +2247,38 @@ void Commands::processMCode(GCode *com)
case 402: // M402 Go to stored position case 402: // M402 Go to stored position
Printer::GoToMemoryPosition(com->hasX(),com->hasY(),com->hasZ(),com->hasE(),(com->hasF() ? com->F : Printer::feedrate)); Printer::GoToMemoryPosition(com->hasX(),com->hasY(),com->hasZ(),com->hasE(),(com->hasF() ? com->F : Printer::feedrate));
break; 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 case 500: // M500
{ {
#if EEPROM_MODE != 0 #if EEPROM_MODE != 0
@ -2251,6 +2442,31 @@ void Commands::processMCode(GCode *com)
dacCommitEeprom(); dacCommitEeprom();
#endif #endif
break; 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: default:
if(!EVENT_UNHANDLED_M_CODE(com) && Printer::debugErrors()) if(!EVENT_UNHANDLED_M_CODE(com) && Printer::debugErrors())
{ {
@ -2291,6 +2507,14 @@ void Commands::executeGCode(GCode *com)
com->printCommand(); com->printCommand();
} }
} }
#ifdef DEBUG_DRYRUN_ERROR
if(Printer::debugDryrun()) {
Com::printFLN("Dryrun was enabled");
com->printCommand();
Printer::debugReset(8);
}
#endif
} }
void Commands::emergencyStop() void Commands::emergencyStop()
@ -2303,7 +2527,7 @@ void Commands::emergencyStop()
Extruder::manageTemperatures(); Extruder::manageTemperatures();
for(uint8_t i = 0; i < NUM_EXTRUDER + 3; i++) for(uint8_t i = 0; i < NUM_EXTRUDER + 3; i++)
pwm_pos[i] = 0; pwm_pos[i] = 0;
#if EXT0_HEATER_PIN > -1 #if EXT0_HEATER_PIN > -1 && NUM_EXTRUDER > 0
WRITE(EXT0_HEATER_PIN,HEATER_PINS_INVERTED); WRITE(EXT0_HEATER_PIN,HEATER_PINS_INVERTED);
#endif #endif
#if defined(EXT1_HEATER_PIN) && EXT1_HEATER_PIN > -1 && NUM_EXTRUDER > 1 #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 #if FAN_PIN > -1 && FEATURE_FAN_CONTROL
WRITE(FAN_PIN, 0); WRITE(FAN_PIN, 0);
#endif #endif
#if HEATED_BED_HEATER_PIN > -1 #if HAVE_HEATED_BED && HEATED_BED_HEATER_PIN > -1
WRITE(HEATED_BED_HEATER_PIN, HEATER_PINS_INVERTED); WRITE(HEATED_BED_HEATER_PIN, HEATER_PINS_INVERTED);
#endif #endif
UI_STATUS_UPD(UI_TEXT_KILLED); UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_KILLED_ID));
HAL::delayMilliseconds(200); HAL::delayMilliseconds(200);
InterruptProtectedBlock noInts; InterruptProtectedBlock noInts;
while(1) {} while(1) {}
@ -2349,5 +2573,3 @@ void Commands::writeLowestFreeRAM()
Com::printFLN(Com::tFreeRAM, lowestRAMValue); Com::printFLN(Com::tFreeRAM, lowestRAMValue);
} }
} }

View file

@ -37,7 +37,8 @@ public:
static void waitUntilEndOfAllBuffers(); static void waitUntilEndOfAllBuffers();
static void printCurrentPosition(FSTRINGPARAM(s)); static void printCurrentPosition(FSTRINGPARAM(s));
static void printTemperatures(bool showRaw = false); 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 changeFeedrateMultiply(int factorInPercent);
static void changeFlowrateMultiply(int factorInPercent); static void changeFlowrateMultiply(int factorInPercent);
static void reportPrinterUsage(); static void reportPrinterUsage();
@ -50,5 +51,3 @@ private:
}; };
#endif // COMMANDS_H_INCLUDED #endif // COMMANDS_H_INCLUDED

View file

@ -21,15 +21,23 @@
#include "Repetier.h" #include "Repetier.h"
#if UI_DISPLAY_TYPE != NO_DISPLAY
uint8_t Com::selectedLanguage;
#endif
#ifndef MACHINE_TYPE
#if DRIVE_SYSTEM == DELTA #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 #else
#if DRIVE_SYSTEM == CARTESIAN #define MACHINE_TYPE "Core_XY"
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")
#endif #endif
#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::tDebug,"Debug:")
FSTRINGVALUE(Com::tOk,"ok") FSTRINGVALUE(Com::tOk,"ok")
FSTRINGVALUE(Com::tNewline,"\r\n") FSTRINGVALUE(Com::tNewline,"\r\n")
@ -83,9 +91,23 @@ FSTRINGVALUE(Com::tSpaceRaw," RAW")
FSTRINGVALUE(Com::tColon,":") FSTRINGVALUE(Com::tColon,":")
FSTRINGVALUE(Com::tSlash,"/") FSTRINGVALUE(Com::tSlash,"/")
FSTRINGVALUE(Com::tSpaceSlash," /") 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::tSpeedMultiply,"SpeedMultiply:")
FSTRINGVALUE(Com::tFlowMultiply,"FlowMultiply:") FSTRINGVALUE(Com::tFlowMultiply,"FlowMultiply:")
FSTRINGVALUE(Com::tFanspeed,"Fanspeed:") FSTRINGVALUE(Com::tFanspeed,"Fanspeed:")
FSTRINGVALUE(Com::tFan2speed,"Fanspeed2:")
FSTRINGVALUE(Com::tPrintedFilament,"Printed filament:") FSTRINGVALUE(Com::tPrintedFilament,"Printed filament:")
FSTRINGVALUE(Com::tPrintingTime,"Printing time:") FSTRINGVALUE(Com::tPrintingTime,"Printing time:")
FSTRINGVALUE(Com::tSpacem,"m ") FSTRINGVALUE(Com::tSpacem,"m ")
@ -122,7 +144,6 @@ FSTRINGVALUE(Com::tEEPROMUpdated,"EEPROM updated")
FSTRINGVALUE(Com::tLinearLColon,"linear L:") FSTRINGVALUE(Com::tLinearLColon,"linear L:")
FSTRINGVALUE(Com::tQuadraticKColon," quadratic K:") FSTRINGVALUE(Com::tQuadraticKColon," quadratic K:")
FSTRINGVALUE(Com::tExtruderJam, UI_TEXT_EXTRUDER_JAM)
FSTRINGVALUE(Com::tFilamentSlipping,"Filament slipping") FSTRINGVALUE(Com::tFilamentSlipping,"Filament slipping")
FSTRINGVALUE(Com::tPauseCommunication,"// action:pause") FSTRINGVALUE(Com::tPauseCommunication,"// action:pause")
FSTRINGVALUE(Com::tContinueCommunication,"// action:resume") FSTRINGVALUE(Com::tContinueCommunication,"// action:resume")
@ -235,6 +256,7 @@ FSTRINGVALUE(Com::tWait,WAITING_IDENTIFIER)
#if EEPROM_MODE == 0 #if EEPROM_MODE == 0
FSTRINGVALUE(Com::tNoEEPROMSupport,"No EEPROM support compiled.\r\n") FSTRINGVALUE(Com::tNoEEPROMSupport,"No EEPROM support compiled.\r\n")
#else #else
FSTRINGVALUE(Com::tZProbeOffsetZ, "Coating thickness [mm]")
#if FEATURE_Z_PROBE #if FEATURE_Z_PROBE
FSTRINGVALUE(Com::tZProbeHeight,"Z-probe height [mm]") FSTRINGVALUE(Com::tZProbeHeight,"Z-probe height [mm]")
FSTRINGVALUE(Com::tZProbeBedDitance,"Max. z-probe - bed dist. [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::tZProbeOffsetY,"Z-probe offset y [mm]")
FSTRINGVALUE(Com::tZProbeSpeed,"Z-probe speed [mm/s]") FSTRINGVALUE(Com::tZProbeSpeed,"Z-probe speed [mm/s]")
FSTRINGVALUE(Com::tZProbeSpeedXY,"Z-probe x-y-speed [mm/s]") FSTRINGVALUE(Com::tZProbeSpeedXY,"Z-probe x-y-speed [mm/s]")
FSTRINGVALUE(Com::tZProbeX1,"Z-probe X1") FSTRINGVALUE(Com::tZProbeX1,"Z-probe X1 [mm]")
FSTRINGVALUE(Com::tZProbeY1,"Z-probe Y1") FSTRINGVALUE(Com::tZProbeY1,"Z-probe Y1 [mm]")
FSTRINGVALUE(Com::tZProbeX2,"Z-probe X2") FSTRINGVALUE(Com::tZProbeX2,"Z-probe X2 [mm]")
FSTRINGVALUE(Com::tZProbeY2,"Z-probe Y2") FSTRINGVALUE(Com::tZProbeY2,"Z-probe Y2 [mm]")
FSTRINGVALUE(Com::tZProbeX3,"Z-probe X3") FSTRINGVALUE(Com::tZProbeX3,"Z-probe X3 [mm]")
FSTRINGVALUE(Com::tZProbeY3,"Z-probe Y3") 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 #endif
#if FEATURE_AXISCOMP #if FEATURE_AXISCOMP
FSTRINGVALUE(Com::tAxisCompTanXY,"tanXY Axis Compensation") FSTRINGVALUE(Com::tAxisCompTanXY,"tanXY Axis Compensation")
@ -267,6 +292,7 @@ FSTRINGVALUE(Com::tEPR1,"EPR:1 ")
FSTRINGVALUE(Com::tEPR2,"EPR:2 ") FSTRINGVALUE(Com::tEPR2,"EPR:2 ")
FSTRINGVALUE(Com::tEPR3,"EPR:3 ") FSTRINGVALUE(Com::tEPR3,"EPR:3 ")
FSTRINGVALUE(Com::tEPRBaudrate,"Baudrate") FSTRINGVALUE(Com::tEPRBaudrate,"Baudrate")
FSTRINGVALUE(Com::tLanguage,"Language")
FSTRINGVALUE(Com::tEPRFilamentPrinted,"Filament printed [m]") FSTRINGVALUE(Com::tEPRFilamentPrinted,"Filament printed [m]")
FSTRINGVALUE(Com::tEPRPrinterActive,"Printer active [s]") FSTRINGVALUE(Com::tEPRPrinterActive,"Printer active [s]")
FSTRINGVALUE(Com::tEPRMaxInactiveTime,"Max. inactive time [ms,0=off]") 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::tEPRYBacklash,"Y backlash [mm]")
FSTRINGVALUE(Com::tEPRZBacklash,"Z backlash [mm]") FSTRINGVALUE(Com::tEPRZBacklash,"Z backlash [mm]")
FSTRINGVALUE(Com::tEPRMaxJerk,"Max. jerk [mm/s]") FSTRINGVALUE(Com::tEPRMaxJerk,"Max. jerk [mm/s]")
FSTRINGVALUE(Com::tEPRAccelerationFactorAtTop,"Acceleration factor at top [%,100=like bottom]")
#if DRIVE_SYSTEM==DELTA #if DRIVE_SYSTEM==DELTA
FSTRINGVALUE(Com::tEPRZAcceleration,"Acceleration [mm/s^2]") FSTRINGVALUE(Com::tEPRZAcceleration,"Acceleration [mm/s^2]")
FSTRINGVALUE(Com::tEPRZTravelAcceleration,"Travel acceleration [mm/s^2]") FSTRINGVALUE(Com::tEPRZTravelAcceleration,"Travel acceleration [mm/s^2]")
@ -357,8 +384,8 @@ FSTRINGVALUE(Com::tEPRAdvanceL,"advance L [0=off]")
#endif #endif
#if SDSUPPORT #if SDSUPPORT
FSTRINGVALUE(Com::tSDRemoved,UI_TEXT_SD_REMOVED) //FSTRINGVALUE(Com::tSDRemoved,UI_TEXT_SD_REMOVED)
FSTRINGVALUE(Com::tSDInserted,UI_TEXT_SD_INSERTED) //FSTRINGVALUE(Com::tSDInserted,UI_TEXT_SD_INSERTED)
FSTRINGVALUE(Com::tSDInitFail,"SD init fail") FSTRINGVALUE(Com::tSDInitFail,"SD init fail")
FSTRINGVALUE(Com::tErrorWritingToFile,"error writing to file") FSTRINGVALUE(Com::tErrorWritingToFile,"error writing to file")
FSTRINGVALUE(Com::tBeginFileList,"Begin file list") FSTRINGVALUE(Com::tBeginFileList,"Begin file list")
@ -401,6 +428,12 @@ FSTRINGVALUE(Com::tExtrDot,"Extr.")
FSTRINGVALUE(Com::tMCPEpromSettings, "MCP4728 DAC EEPROM Settings:") FSTRINGVALUE(Com::tMCPEpromSettings, "MCP4728 DAC EEPROM Settings:")
FSTRINGVALUE(Com::tMCPCurrentSettings,"MCP4728 DAC Current Settings:") FSTRINGVALUE(Com::tMCPCurrentSettings,"MCP4728 DAC Current Settings:")
#endif #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)) { void Com::config(FSTRINGPARAM(text)) {
printF(tConfig); printF(tConfig);
@ -590,4 +623,3 @@ void Com::printFloat(float number, uint8_t digits)
} }
} }

View file

@ -67,6 +67,19 @@ FSTRINGVAR(tFreeRAM)
FSTRINGVAR(tXColon) FSTRINGVAR(tXColon)
FSTRINGVAR(tSlash) FSTRINGVAR(tSlash)
FSTRINGVAR(tSpaceSlash) 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(tSpaceXColon)
FSTRINGVAR(tSpaceYColon) FSTRINGVAR(tSpaceYColon)
FSTRINGVAR(tSpaceZColon) FSTRINGVAR(tSpaceZColon)
@ -82,6 +95,7 @@ FSTRINGVAR(tColon)
FSTRINGVAR(tSpeedMultiply) FSTRINGVAR(tSpeedMultiply)
FSTRINGVAR(tFlowMultiply) FSTRINGVAR(tFlowMultiply)
FSTRINGVAR(tFanspeed) FSTRINGVAR(tFanspeed)
FSTRINGVAR(tFan2speed)
FSTRINGVAR(tPrintedFilament) FSTRINGVAR(tPrintedFilament)
FSTRINGVAR(tPrintingTime) FSTRINGVAR(tPrintingTime)
FSTRINGVAR(tSpacem) FSTRINGVAR(tSpacem)
@ -117,7 +131,6 @@ FSTRINGVAR(tCommaSpeedEqual)
FSTRINGVAR(tLinearLColon) FSTRINGVAR(tLinearLColon)
FSTRINGVAR(tQuadraticKColon) FSTRINGVAR(tQuadraticKColon)
FSTRINGVAR(tEEPROMUpdated) FSTRINGVAR(tEEPROMUpdated)
FSTRINGVAR(tExtruderJam)
FSTRINGVAR(tFilamentSlipping) FSTRINGVAR(tFilamentSlipping)
FSTRINGVAR(tPauseCommunication) FSTRINGVAR(tPauseCommunication)
FSTRINGVAR(tContinueCommunication) FSTRINGVAR(tContinueCommunication)
@ -236,6 +249,7 @@ FSTRINGVAR(tWait)
#if EEPROM_MODE==0 #if EEPROM_MODE==0
FSTRINGVAR(tNoEEPROMSupport) FSTRINGVAR(tNoEEPROMSupport)
#else #else
FSTRINGVAR(tZProbeOffsetZ)
#if FEATURE_Z_PROBE #if FEATURE_Z_PROBE
FSTRINGVAR(tZProbeHeight) FSTRINGVAR(tZProbeHeight)
FSTRINGVAR(tZProbeOffsetX) FSTRINGVAR(tZProbeOffsetX)
@ -248,6 +262,9 @@ FSTRINGVAR(tZProbeX2)
FSTRINGVAR(tZProbeY2) FSTRINGVAR(tZProbeY2)
FSTRINGVAR(tZProbeX3) FSTRINGVAR(tZProbeX3)
FSTRINGVAR(tZProbeY3) FSTRINGVAR(tZProbeY3)
FSTRINGVAR(zZProbeBendingCorA)
FSTRINGVAR(zZProbeBendingCorB)
FSTRINGVAR(zZProbeBendingCorC)
#endif #endif
#if FEATURE_AUTOLEVEL #if FEATURE_AUTOLEVEL
FSTRINGVAR(tAutolevelActive) FSTRINGVAR(tAutolevelActive)
@ -265,6 +282,7 @@ FSTRINGVAR(tEPR0)
FSTRINGVAR(tEPR1) FSTRINGVAR(tEPR1)
FSTRINGVAR(tEPR2) FSTRINGVAR(tEPR2)
FSTRINGVAR(tEPR3) FSTRINGVAR(tEPR3)
FSTRINGVAR(tLanguage)
FSTRINGVAR(tEPRBaudrate) FSTRINGVAR(tEPRBaudrate)
FSTRINGVAR(tEPRFilamentPrinted) FSTRINGVAR(tEPRFilamentPrinted)
FSTRINGVAR(tEPRPrinterActive) FSTRINGVAR(tEPRPrinterActive)
@ -282,6 +300,7 @@ FSTRINGVAR(tEPRYBacklash)
FSTRINGVAR(tEPRZBacklash) FSTRINGVAR(tEPRZBacklash)
FSTRINGVAR(tEPRZAcceleration) FSTRINGVAR(tEPRZAcceleration)
FSTRINGVAR(tEPRZTravelAcceleration) FSTRINGVAR(tEPRZTravelAcceleration)
FSTRINGVAR(tEPRAccelerationFactorAtTop)
FSTRINGVAR(tEPRZStepsPerMM) FSTRINGVAR(tEPRZStepsPerMM)
FSTRINGVAR(tEPRZMaxFeedrate) FSTRINGVAR(tEPRZMaxFeedrate)
FSTRINGVAR(tEPRZHomingFeedrate) FSTRINGVAR(tEPRZHomingFeedrate)
@ -342,8 +361,8 @@ FSTRINGVAR(tEPRAdvanceK)
FSTRINGVAR(tEPRAdvanceL) FSTRINGVAR(tEPRAdvanceL)
#endif #endif
#if SDSUPPORT #if SDSUPPORT
FSTRINGVAR(tSDRemoved) //FSTRINGVAR(tSDRemoved)
FSTRINGVAR(tSDInserted) //FSTRINGVAR(tSDInserted)
FSTRINGVAR(tSDInitFail) FSTRINGVAR(tSDInitFail)
FSTRINGVAR(tErrorWritingToFile) FSTRINGVAR(tErrorWritingToFile)
FSTRINGVAR(tBeginFileList) FSTRINGVAR(tBeginFileList)
@ -386,6 +405,12 @@ FSTRINGVAR(tExtrDot)
FSTRINGVAR(tMCPEpromSettings) FSTRINGVAR(tMCPEpromSettings)
FSTRINGVAR(tMCPCurrentSettings) FSTRINGVAR(tMCPCurrentSettings)
#endif #endif
FSTRINGVAR(tPrinterModeFFF)
FSTRINGVAR(tPrinterModeLaser)
FSTRINGVAR(tPrinterModeCNC)
#ifdef STARTUP_GCODE
FSTRINGVAR(tStartupGCode)
#endif
static void config(FSTRINGPARAM(text)); static void config(FSTRINGPARAM(text));
static void config(FSTRINGPARAM(text),int value); 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 void printFloat(float number, uint8_t digits);
static inline void print(float number) {printFloat(number, 6);} static inline void print(float number) {printFloat(number, 6);}
static inline void println() {HAL::serialWriteByte('\r');HAL::serialWriteByte('\n');} 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: protected:
private: private:
}; };
@ -444,5 +474,3 @@ static inline void println() {HAL::serialWriteByte('\r');HAL::serialWriteByte('\
#endif #endif
#endif // COMMUNICATION_H #endif // COMMUNICATION_H

View file

@ -43,8 +43,17 @@
// ################## EDIT THESE SETTINGS MANUALLY ################ // ################## EDIT THESE SETTINGS MANUALLY ################
// ################ END MANUAL SETTINGS ########################## // ################ END MANUAL SETTINGS ##########################
#undef FAN_PIN
#define FAN_PIN -1 #define FAN_PIN -1
#undef FAN_BOARD_PIN
#define FAN_BOARD_PIN -1 #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. //#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 // 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_STEP_PIN ORIG_E0_STEP_PIN
#define EXT0_DIR_PIN ORIG_E0_DIR_PIN #define EXT0_DIR_PIN ORIG_E0_DIR_PIN
#define EXT0_INVERSE 0 #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_ENABLE_ON 0
#define EXT0_MAX_FEEDRATE 50 #define EXT0_MAX_FEEDRATE 50
#define EXT0_MAX_START_FEEDRATE 20 #define EXT0_MAX_START_FEEDRATE 20
@ -112,7 +121,7 @@
#define EXT1_STEP_PIN ORIG_E1_STEP_PIN #define EXT1_STEP_PIN ORIG_E1_STEP_PIN
#define EXT1_DIR_PIN ORIG_E1_DIR_PIN #define EXT1_DIR_PIN ORIG_E1_DIR_PIN
#define EXT1_INVERSE 0 #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_ENABLE_ON 0
#define EXT1_MAX_FEEDRATE 50 #define EXT1_MAX_FEEDRATE 50
#define EXT1_MAX_START_FEEDRATE 20 #define EXT1_MAX_START_FEEDRATE 20
@ -198,11 +207,60 @@
#define MIN_DEFECT_TEMPERATURE -10 #define MIN_DEFECT_TEMPERATURE -10
#define MAX_DEFECT_TEMPERATURE 290 #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 ##################### // ################ Endstop configuration #####################
#define ENDSTOP_PULLUP_X_MIN true #define ENDSTOP_PULLUP_X_MIN true
#define ENDSTOP_X_MIN_INVERTING true #define ENDSTOP_X_MIN_INVERTING false
#define MIN_HARDWARE_ENDSTOP_X true #define MIN_HARDWARE_ENDSTOP_X false
#define ENDSTOP_PULLUP_Y_MIN true #define ENDSTOP_PULLUP_Y_MIN true
#define ENDSTOP_Y_MIN_INVERTING true #define ENDSTOP_Y_MIN_INVERTING true
#define MIN_HARDWARE_ENDSTOP_Y true #define MIN_HARDWARE_ENDSTOP_Y true
@ -210,8 +268,8 @@
#define ENDSTOP_Z_MIN_INVERTING false #define ENDSTOP_Z_MIN_INVERTING false
#define MIN_HARDWARE_ENDSTOP_Z false #define MIN_HARDWARE_ENDSTOP_Z false
#define ENDSTOP_PULLUP_X_MAX true #define ENDSTOP_PULLUP_X_MAX true
#define ENDSTOP_X_MAX_INVERTING false #define ENDSTOP_X_MAX_INVERTING true
#define MAX_HARDWARE_ENDSTOP_X false #define MAX_HARDWARE_ENDSTOP_X true
#define ENDSTOP_PULLUP_Y_MAX true #define ENDSTOP_PULLUP_Y_MAX true
#define ENDSTOP_Y_MAX_INVERTING false #define ENDSTOP_Y_MAX_INVERTING false
#define MAX_HARDWARE_ENDSTOP_Y false #define MAX_HARDWARE_ENDSTOP_Y false
@ -220,10 +278,10 @@
#define MAX_HARDWARE_ENDSTOP_Z true #define MAX_HARDWARE_ENDSTOP_Z true
#define max_software_endstop_r 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_y false
#define min_software_endstop_z true #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_y true
#define max_software_endstop_z false #define max_software_endstop_z false
#define ENDSTOP_X_BACK_MOVE 5 #define ENDSTOP_X_BACK_MOVE 5
@ -232,7 +290,7 @@
#define ENDSTOP_X_RETEST_REDUCTION_FACTOR 3 #define ENDSTOP_X_RETEST_REDUCTION_FACTOR 3
#define ENDSTOP_Y_RETEST_REDUCTION_FACTOR 3 #define ENDSTOP_Y_RETEST_REDUCTION_FACTOR 3
#define ENDSTOP_Z_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_Y_BACK_ON_HOME 1
#define ENDSTOP_Z_BACK_ON_HOME 0 #define ENDSTOP_Z_BACK_ON_HOME 0
#define ALWAYS_CHECK_ENDSTOPS 0 #define ALWAYS_CHECK_ENDSTOPS 0
@ -249,23 +307,27 @@
#define INVERT_X_DIR 0 #define INVERT_X_DIR 0
#define INVERT_Y_DIR 0 #define INVERT_Y_DIR 0
#define INVERT_Z_DIR 0 #define INVERT_Z_DIR 0
#define X_HOME_DIR -1 #define X_HOME_DIR 1
#define Y_HOME_DIR -1 #define Y_HOME_DIR -1
#define Z_HOME_DIR 1 #define Z_HOME_DIR 1
#define X_MAX_LENGTH 200 #define X_MAX_LENGTH 155
#define Y_MAX_LENGTH 180 #define Y_MAX_LENGTH 155
#define Z_MAX_LENGTH 135 #define Z_MAX_LENGTH 145
#define X_MIN_POS 0 #define X_MIN_POS 0
#define Y_MIN_POS 0 #define Y_MIN_POS 0
#define Z_MIN_POS 0 #define Z_MIN_POS 0
#define DISTORTION_CORRECTION 0 #define DISTORTION_CORRECTION 0
#define DISTORTION_CORRECTION_POINTS 5 #define DISTORTION_CORRECTION_POINTS 3
#define DISTORTION_CORRECTION_R 100 #define DISTORTION_CORRECTION_R 100
#define DISTORTION_PERMANENT 1 #define DISTORTION_PERMANENT 0
#define DISTORTION_UPDATE_FREQUENCY 15 #define DISTORTION_UPDATE_FREQUENCY 15
#define DISTORTION_START_DEGRADE 0.5 #define DISTORTION_START_DEGRADE 0.5
#define DISTORTION_END_HEIGHT 1 #define DISTORTION_END_HEIGHT 1
#define DISTORTION_EXTRAPOLATE_CORNERS 0 #define DISTORTION_EXTRAPOLATE_CORNERS 0
#define DISTORTION_XMIN 0
#define DISTORTION_YMIN 0
#define DISTORTION_XMAX 155
#define DISTORTION_YMAX 155
// ########################################################################################## // ##########################################################################################
// ## Movement settings ## // ## Movement settings ##
@ -312,6 +374,8 @@
#define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_X 1000 #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_Y 1000
#define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_Z 500 #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_JERK 20
#define MAX_ZJERK 0.3 #define MAX_ZJERK 0.3
#define PRINTLINE_CACHE_SIZE 16 #define PRINTLINE_CACHE_SIZE 16
@ -320,15 +384,19 @@
#define FEATURE_TWO_XSTEPPER 0 #define FEATURE_TWO_XSTEPPER 0
#define X2_STEP_PIN ORIG_E1_STEP_PIN #define X2_STEP_PIN ORIG_E1_STEP_PIN
#define X2_DIR_PIN ORIG_E1_DIR_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 FEATURE_TWO_YSTEPPER 0
#define Y2_STEP_PIN ORIG_E1_STEP_PIN #define Y2_STEP_PIN ORIG_E1_STEP_PIN
#define Y2_DIR_PIN ORIG_E1_DIR_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 FEATURE_TWO_ZSTEPPER 0
#define Z2_STEP_PIN ORIG_E1_STEP_PIN #define Z2_STEP_PIN ORIG_E1_STEP_PIN
#define Z2_DIR_PIN ORIG_E1_DIR_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 FEATURE_DITTO_PRINTING 0
#define USE_ADVANCE 0 #define USE_ADVANCE 0
#define ENABLE_QUADRATIC_ADVANCE 0 #define ENABLE_QUADRATIC_ADVANCE 0
@ -343,8 +411,10 @@
#define ACK_WITH_LINENUMBER 1 #define ACK_WITH_LINENUMBER 1
#define WAITING_IDENTIFIER "wait" #define WAITING_IDENTIFIER "wait"
#define ECHO_ON_EXECUTE 1 #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 PS_ON_PIN ORIG_PS_ON_PIN
#define JSON_OUTPUT 0
/* ======== Servos ======= /* ======== Servos =======
Control the servos with 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_X_OFFSET 6.4
#define Z_PROBE_Y_OFFSET 0 #define Z_PROBE_Y_OFFSET 0
#define Z_PROBE_WAIT_BEFORE_TEST 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_XY_SPEED 150
#define Z_PROBE_SWITCHING_DISTANCE 1 #define Z_PROBE_SWITCHING_DISTANCE 1
#define Z_PROBE_REPETITIONS 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_START_SCRIPT ""
#define Z_PROBE_FINISHED_SCRIPT "" #define Z_PROBE_FINISHED_SCRIPT ""
#define FEATURE_AUTOLEVEL 1 #define FEATURE_AUTOLEVEL 1
#define Z_PROBE_X1 20 #define Z_PROBE_X1 5
#define Z_PROBE_Y1 20 #define Z_PROBE_Y1 5
#define Z_PROBE_X2 160 #define Z_PROBE_X2 150
#define Z_PROBE_Y2 20 #define Z_PROBE_Y2 5
#define Z_PROBE_X3 100 #define Z_PROBE_X3 150
#define Z_PROBE_Y3 160 #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 FEATURE_AXISCOMP 0
#define AXISCOMP_TANXY 0 #define AXISCOMP_TANXY 0
#define AXISCOMP_TANYZ 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 #ifndef SDSUPPORT // Some boards have sd support on board. These define the values already in pins.h
#define SDSUPPORT 0 #define SDSUPPORT 0
#undef SDCARDDETECT
#define SDCARDDETECT -1 #define SDCARDDETECT -1
#define SDCARDDETECTINVERTED 0 #define SDCARDDETECTINVERTED 0
#endif #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_MEMORY_POSITION 0
#define FEATURE_CHECKSUM_FORCED 0 #define FEATURE_CHECKSUM_FORCED 0
#define FEATURE_FAN_CONTROL 0 #define FEATURE_FAN_CONTROL 0
#define FEATURE_FAN2_CONTROL 0
#define FEATURE_CONTROLLER 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_NAME "RepRap"
#define UI_PRINTER_COMPANY "Home made" #define UI_PRINTER_COMPANY "Home made"
#define UI_PAGES_DURATION 4000 #define UI_PAGES_DURATION 4000
@ -471,7 +566,7 @@ Values must be in range 1..255
"zStepsPerMM": 200, "zStepsPerMM": 200,
"xInvert": 0, "xInvert": 0,
"xInvertEnable": 0, "xInvertEnable": 0,
"eepromMode": 0, "eepromMode": 2,
"yInvert": 0, "yInvert": 0,
"yInvertEnable": 0, "yInvertEnable": 0,
"zInvert": 0, "zInvert": 0,
@ -515,7 +610,7 @@ Values must be in range 1..255
"name": "Extruder 0", "name": "Extruder 0",
"step": "ORIG_E0_STEP_PIN", "step": "ORIG_E0_STEP_PIN",
"dir": "ORIG_E0_DIR_PIN", "dir": "ORIG_E0_DIR_PIN",
"enable": "E0_ENABLE_PIN" "enable": "ORIG_E0_ENABLE_PIN"
}, },
"advanceBacklashSteps": 0, "advanceBacklashSteps": 0,
"decoupleTestPeriod": 12, "decoupleTestPeriod": 12,
@ -560,7 +655,7 @@ Values must be in range 1..255
"name": "Extruder 1", "name": "Extruder 1",
"step": "ORIG_E1_STEP_PIN", "step": "ORIG_E1_STEP_PIN",
"dir": "ORIG_E1_DIR_PIN", "dir": "ORIG_E1_DIR_PIN",
"enable": "E1_ENABLE_PIN" "enable": "ORIG_E1_ENABLE_PIN"
}, },
"advanceBacklashSteps": 0, "advanceBacklashSteps": 0,
"decoupleTestPeriod": 12, "decoupleTestPeriod": 12,
@ -570,10 +665,10 @@ Values must be in range 1..255
], ],
"uiLanguage": 0, "uiLanguage": 0,
"uiController": 0, "uiController": 0,
"xMinEndstop": 1, "xMinEndstop": 0,
"yMinEndstop": 1, "yMinEndstop": 1,
"zMinEndstop": 0, "zMinEndstop": 0,
"xMaxEndstop": 0, "xMaxEndstop": 1,
"yMaxEndstop": 0, "yMaxEndstop": 0,
"zMaxEndstop": 1, "zMaxEndstop": 1,
"motherboard": 33, "motherboard": 33,
@ -617,18 +712,18 @@ Values must be in range 1..255
"xMinPos": 0, "xMinPos": 0,
"yMinPos": 0, "yMinPos": 0,
"zMinPos": 0, "zMinPos": 0,
"xLength": 200, "xLength": 155,
"yLength": 180, "yLength": 155,
"zLength": 135, "zLength": 145,
"alwaysCheckEndstops": "0", "alwaysCheckEndstops": "0",
"disableX": "0", "disableX": "0",
"disableY": "0", "disableY": "0",
"disableZ": "0", "disableZ": "0",
"disableE": "0", "disableE": "0",
"xHomeDir": "-1", "xHomeDir": "1",
"yHomeDir": "-1", "yHomeDir": "-1",
"zHomeDir": "1", "zHomeDir": "1",
"xEndstopBack": 1, "xEndstopBack": 10,
"yEndstopBack": 1, "yEndstopBack": 1,
"zEndstopBack": 0, "zEndstopBack": 0,
"deltaSegmentsPerSecondPrint": 180, "deltaSegmentsPerSecondPrint": 180,
@ -673,21 +768,28 @@ Values must be in range 1..255
"name": "Extruder 1", "name": "Extruder 1",
"step": "ORIG_E1_STEP_PIN", "step": "ORIG_E1_STEP_PIN",
"dir": "ORIG_E1_DIR_PIN", "dir": "ORIG_E1_DIR_PIN",
"enable": "E1_ENABLE_PIN" "enable": "ORIG_E1_ENABLE_PIN"
}, },
"mirrorY": 0, "mirrorY": 0,
"mirrorYMotor": { "mirrorYMotor": {
"name": "Extruder 1", "name": "Extruder 1",
"step": "ORIG_E1_STEP_PIN", "step": "ORIG_E1_STEP_PIN",
"dir": "ORIG_E1_DIR_PIN", "dir": "ORIG_E1_DIR_PIN",
"enable": "E1_ENABLE_PIN" "enable": "ORIG_E1_ENABLE_PIN"
}, },
"mirrorZ": 0, "mirrorZ": 0,
"mirrorZMotor": { "mirrorZMotor": {
"name": "Extruder 1", "name": "Extruder 1",
"step": "ORIG_E1_STEP_PIN", "step": "ORIG_E1_STEP_PIN",
"dir": "ORIG_E1_DIR_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", "dittoPrinting": "0",
"featureServos": "0", "featureServos": "0",
@ -766,17 +868,20 @@ Values must be in range 1..255
"userTable0": { "userTable0": {
"r1": 0, "r1": 0,
"r2": 4700, "r2": 4700,
"temps": [] "temps": [],
"numEntries": 0
}, },
"userTable1": { "userTable1": {
"r1": 0, "r1": 0,
"r2": 4700, "r2": 4700,
"temps": [] "temps": [],
"numEntries": 0
}, },
"userTable2": { "userTable2": {
"r1": 0, "r1": 0,
"r2": 4700, "r2": 4700,
"temps": [] "temps": [],
"numEntries": 0
}, },
"tempHysteresis": 0, "tempHysteresis": 0,
"pidControlRange": 20, "pidControlRange": 20,
@ -792,6 +897,15 @@ Values must be in range 1..255
"sdExtendedDir": "1", "sdExtendedDir": "1",
"featureFanControl": "0", "featureFanControl": "0",
"fanPin": -1, "fanPin": -1,
"featureFan2Control": "0",
"fan2Pin": "ORIG_FAN2_PIN",
"fanThermoPin": -1,
"fanThermoMinPWM": 128,
"fanThermoMaxPWM": 255,
"fanThermoMinTemp": 45,
"fanThermoMaxTemp": 60,
"fanThermoThermistorPin": -1,
"fanThermoThermistorType": 1,
"scalePidToMax": 0, "scalePidToMax": 0,
"zProbePin": "ORIG_Z_MIN_PIN", "zProbePin": "ORIG_Z_MIN_PIN",
"zProbeBedDistance": 10, "zProbeBedDistance": 10,
@ -800,18 +914,18 @@ Values must be in range 1..255
"zProbeXOffset": 6.4, "zProbeXOffset": 6.4,
"zProbeYOffset": 0, "zProbeYOffset": 0,
"zProbeWaitBeforeTest": "0", "zProbeWaitBeforeTest": "0",
"zProbeSpeed": 8, "zProbeSpeed": 100,
"zProbeXYSpeed": 150, "zProbeXYSpeed": 150,
"zProbeHeight": 7.4, "zProbeHeight": 6.9,
"zProbeStartScript": "", "zProbeStartScript": "",
"zProbeFinishedScript": "", "zProbeFinishedScript": "",
"featureAutolevel": "1", "featureAutolevel": "1",
"zProbeX1": 20, "zProbeX1": 5,
"zProbeY1": 20, "zProbeY1": 5,
"zProbeX2": 160, "zProbeX2": 150,
"zProbeY2": 20, "zProbeY2": 5,
"zProbeX3": 100, "zProbeX3": 150,
"zProbeY3": 160, "zProbeY3": 150,
"zProbeSwitchingDistance": 1, "zProbeSwitchingDistance": 1,
"zProbeRepetitions": 1, "zProbeRepetitions": 1,
"sdSupport": "0", "sdSupport": "0",
@ -849,13 +963,17 @@ Values must be in range 1..255
"pauseStartCommands": "", "pauseStartCommands": "",
"pauseEndCommands": "", "pauseEndCommands": "",
"distortionCorrection": "0", "distortionCorrection": "0",
"distortionCorrectionPoints": 5, "distortionCorrectionPoints": 3,
"distortionCorrectionR": 100, "distortionCorrectionR": 100,
"distortionPermanent": "1", "distortionPermanent": "0",
"distortionUpdateFrequency": 15, "distortionUpdateFrequency": 15,
"distortionStartDegrade": 0.5, "distortionStartDegrade": 0.5,
"distortionEndDegrade": 1, "distortionEndDegrade": 1,
"distortionExtrapolateCorners": "0", "distortionExtrapolateCorners": "0",
"distortionXMin": 0,
"distortionXMax": 155,
"distortionYMin": 0,
"distortionYMax": 155,
"sdRunOnStop": "", "sdRunOnStop": "",
"sdStopHeaterMotorsOnStop": "1", "sdStopHeaterMotorsOnStop": "1",
"featureRetraction": "0", "featureRetraction": "0",
@ -966,6 +1084,46 @@ Values must be in range 1..255
"zProbeZOffsetMode": 0, "zProbeZOffsetMode": 0,
"zProbeZOffset": 0, "zProbeZOffset": 0,
"uiBedCoating": "1", "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, "hasMAX6675": false,
"hasMAX31855": false, "hasMAX31855": false,
"hasGeneric1": false, "hasGeneric1": false,
@ -975,7 +1133,7 @@ Values must be in range 1..255
"hasUser1": false, "hasUser1": false,
"hasUser2": false, "hasUser2": false,
"numExtruder": 2, "numExtruder": 2,
"version": 92.4, "version": 92.8,
"primaryPortName": "" "primaryPortName": ""
} }
========== End configuration string ========== ========== End configuration string ==========

View file

@ -18,7 +18,8 @@ MOTOR_DRIVER_5(motorDriver5);
MOTOR_DRIVER_6(motorDriver6); MOTOR_DRIVER_6(motorDriver6);
#endif #endif
MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] = { MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] =
{
&motorDriver1 &motorDriver1
#if NUM_MOTOR_DRIVERS > 1 #if NUM_MOTOR_DRIVERS > 1
, &motorDriver2 , &motorDriver2
@ -37,14 +38,16 @@ MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] = {
#endif #endif
}; };
MotorDriverInterface *getMotorDriver(int idx) { MotorDriverInterface *getMotorDriver(int idx)
{
return motorDrivers[idx]; return motorDrivers[idx];
} }
/** /**
Run motor P until it is at position X Run motor P until it is at position X
*/ */
void commandG201(GCode &code) { void commandG201(GCode &code)
{
int id = 0; int id = 0;
if(code.hasP()) if(code.hasP())
id = code.P; id = code.P;
@ -55,7 +58,8 @@ void commandG201(GCode &code) {
} }
//G202 P<motorId> X<setpos> - Mark current position as X //G202 P<motorId> X<setpos> - Mark current position as X
void commandG202(GCode &code) { void commandG202(GCode &code)
{
int id = 0; int id = 0;
if(code.hasP()) if(code.hasP())
id = code.P; id = code.P;
@ -65,7 +69,8 @@ void commandG202(GCode &code) {
motorDrivers[id]->setCurrentAs(code.X); motorDrivers[id]->setCurrentAs(code.X);
} }
//G203 P<motorId> - Report current motor position //G203 P<motorId> - Report current motor position
void commandG203(GCode &code) { void commandG203(GCode &code)
{
int id = 0; int id = 0;
if(code.hasP()) if(code.hasP())
id = code.P; id = code.P;
@ -75,7 +80,8 @@ void commandG203(GCode &code) {
Com::printFLN(PSTR("Pos:"),motorDrivers[id]->getPosition()); Com::printFLN(PSTR("Pos:"),motorDrivers[id]->getPosition());
} }
//G204 P<motorId> S<0/1> - Enable/disable motor //G204 P<motorId> S<0/1> - Enable/disable motor
void commandG204(GCode &code) { void commandG204(GCode &code)
{
int id = 0; int id = 0;
if(code.hasP()) if(code.hasP())
id = code.P; id = code.P;
@ -88,15 +94,122 @@ void commandG204(GCode &code) {
motorDrivers[id]->disable(); motorDrivers[id]->disable();
} }
void disableAllMotorDrivers() { void disableAllMotorDrivers()
{
for(int i = 0; i < NUM_MOTOR_DRIVERS; i++) for(int i = 0; i < NUM_MOTOR_DRIVERS; i++)
motorDrivers[i]->disable(); motorDrivers[i]->disable();
} }
void initializeAllMotorDrivers() { void initializeAllMotorDrivers()
{
for(int i = 0; i < NUM_MOTOR_DRIVERS; i++) for(int i = 0; i < NUM_MOTOR_DRIVERS; i++)
motorDrivers[i]->initialize(); motorDrivers[i]->initialize();
} }
#endif // NUM_MOTOR_DRIVERS #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

View file

@ -101,6 +101,53 @@ extern MotorDriverInterface *getMotorDriver(int idx);
extern void initializeAllMotorDrivers(); extern void initializeAllMotorDrivers();
#endif #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 #endif // DRIVERS_H_INCLUDED

View file

@ -385,6 +385,9 @@ void EEPROM::storeDataIntoEEPROM(uint8_t corrupted)
HAL::eprSetByte(EPR_AUTOLEVEL_ACTIVE,Printer::isAutolevelActive()); HAL::eprSetByte(EPR_AUTOLEVEL_ACTIVE,Printer::isAutolevelActive());
for(uint8_t i = 0; i < 9; i++) for(uint8_t i = 0; i < 9; i++)
HAL::eprSetFloat(EPR_AUTOLEVEL_MATRIX + (((int)i) << 2),Printer::autolevelTransformation[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 #endif
// now the extruder // now the extruder
for(uint8_t i = 0; i < NUM_EXTRUDER; i++) 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_XY_SPEED,Z_PROBE_XY_SPEED);
HAL::eprSetFloat(EPR_Z_PROBE_X_OFFSET,Z_PROBE_X_OFFSET); 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_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_X1,Z_PROBE_X1);
HAL::eprSetFloat(EPR_Z_PROBE_Y1,Z_PROBE_Y1); HAL::eprSetFloat(EPR_Z_PROBE_Y1,Z_PROBE_Y1);
HAL::eprSetFloat(EPR_Z_PROBE_X2,Z_PROBE_X2); 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_TANYZ,AXISCOMP_TANYZ);
HAL::eprSetFloat(EPR_AXISCOMP_TANXZ,AXISCOMP_TANXZ); HAL::eprSetFloat(EPR_AXISCOMP_TANXZ,AXISCOMP_TANXZ);
HAL::eprSetFloat(EPR_Z_PROBE_BED_DISTANCE,Z_PROBE_BED_DISTANCE); HAL::eprSetFloat(EPR_Z_PROBE_BED_DISTANCE,Z_PROBE_BED_DISTANCE);
Printer::zBedOffset = HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
#if DRIVE_SYSTEM == DELTA #if DRIVE_SYSTEM == DELTA
HAL::eprSetFloat(EPR_DELTA_DIAGONAL_ROD_LENGTH,DELTA_DIAGONAL_ROD); HAL::eprSetFloat(EPR_DELTA_DIAGONAL_ROD_LENGTH,DELTA_DIAGONAL_ROD);
HAL::eprSetFloat(EPR_DELTA_HORIZONTAL_RADIUS,ROD_RADIUS); 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_EXTRA_LONG_LENGTH,RETRACTION_UNDO_EXTRA_LONG_LENGTH);
HAL::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED); HAL::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED);
HAL::eprSetByte(EPR_AUTORETRACT_ENABLED,AUTORETRACT_ENABLED); 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 #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! 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); baudrate = HAL::eprGetInt32(EPR_BAUDRATE);
maxInactiveTime = HAL::eprGetInt32(EPR_MAX_INACTIVE_TIME); maxInactiveTime = HAL::eprGetInt32(EPR_MAX_INACTIVE_TIME);
stepperInactiveTime = HAL::eprGetInt32(EPR_STEPPER_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::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED);
HAL::eprSetByte(EPR_AUTORETRACT_ENABLED,AUTORETRACT_ENABLED); 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 (version<8) {
#if DRIVE_SYSTEM==DELTA #if DRIVE_SYSTEM==DELTA
// Prior to verion 8, the cartesian max was stored in the zmax // 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 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(); Printer::updateDerivedParameter();
Extruder::initHeatedBed(); Extruder::initHeatedBed();
#endif #endif
@ -762,7 +791,7 @@ void EEPROM::init()
if(newcheck != HAL::eprGetByte(EPR_INTEGRITY_BYTE)) if(newcheck != HAL::eprGetByte(EPR_INTEGRITY_BYTE))
HAL::eprSetByte(EPR_INTEGRITY_BYTE,newcheck); 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")); Com::printFLN(PSTR("RECOMPILE WITH USE_CONFIGURATION_BAUD_RATE == 0 to alter baud rate via EEPROM"));
} }
} }
@ -805,6 +834,7 @@ With
void EEPROM::writeSettings() void EEPROM::writeSettings()
{ {
#if EEPROM_MODE != 0 #if EEPROM_MODE != 0
writeByte(EPR_SELECTED_LANGUAGE,Com::tLanguage);
writeLong(EPR_BAUDRATE, Com::tEPRBaudrate); writeLong(EPR_BAUDRATE, Com::tEPRBaudrate);
writeFloat(EPR_PRINTING_DISTANCE, Com::tEPRFilamentPrinted); writeFloat(EPR_PRINTING_DISTANCE, Com::tEPRFilamentPrinted);
writeLong(EPR_PRINTING_TIME, Com::tEPRPrinterActive); writeLong(EPR_PRINTING_TIME, Com::tEPRPrinterActive);
@ -852,6 +882,9 @@ void EEPROM::writeSettings()
#if DRIVE_SYSTEM == DELTA #if DRIVE_SYSTEM == DELTA
writeFloat(EPR_Z_MAX_ACCEL, Com::tEPRZAcceleration); writeFloat(EPR_Z_MAX_ACCEL, Com::tEPRZAcceleration);
writeFloat(EPR_Z_MAX_TRAVEL_ACCEL, Com::tEPRZTravelAcceleration); 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_DIAGONAL_ROD_LENGTH, Com::tEPRDiagonalRodLength);
writeFloat(EPR_DELTA_HORIZONTAL_RADIUS, Com::tEPRHorizontalRadius); writeFloat(EPR_DELTA_HORIZONTAL_RADIUS, Com::tEPRHorizontalRadius);
writeFloat(EPR_DELTA_MAX_RADIUS, Com::tEPRDeltaMaxRadius); writeFloat(EPR_DELTA_MAX_RADIUS, Com::tEPRDeltaMaxRadius);
@ -876,8 +909,12 @@ void EEPROM::writeSettings()
writeFloat(EPR_X_MAX_TRAVEL_ACCEL, Com::tEPRXTravelAcceleration); writeFloat(EPR_X_MAX_TRAVEL_ACCEL, Com::tEPRXTravelAcceleration);
writeFloat(EPR_Y_MAX_TRAVEL_ACCEL, Com::tEPRYTravelAcceleration); writeFloat(EPR_Y_MAX_TRAVEL_ACCEL, Com::tEPRYTravelAcceleration);
writeFloat(EPR_Z_MAX_TRAVEL_ACCEL, Com::tEPRZTravelAcceleration); 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 #endif
#endif
writeFloat(EPR_Z_PROBE_Z_OFFSET, Com::tZProbeOffsetZ);
#if FEATURE_Z_PROBE #if FEATURE_Z_PROBE
writeFloat(EPR_Z_PROBE_HEIGHT, Com::tZProbeHeight); writeFloat(EPR_Z_PROBE_HEIGHT, Com::tZProbeHeight);
writeFloat(EPR_Z_PROBE_BED_DISTANCE, Com::tZProbeBedDitance); 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_Y2, Com::tZProbeY2);
writeFloat(EPR_Z_PROBE_X3, Com::tZProbeX3); writeFloat(EPR_Z_PROBE_X3, Com::tZProbeX3);
writeFloat(EPR_Z_PROBE_Y3, Com::tZProbeY3); 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 #endif
#if FEATURE_AUTOLEVEL #if FEATURE_AUTOLEVEL
writeByte(EPR_AUTOLEVEL_ACTIVE, Com::tAutolevelActive); writeByte(EPR_AUTOLEVEL_ACTIVE, Com::tAutolevelActive);
@ -1092,5 +1132,3 @@ void EEPROM::setZCorrection(int32_t c,int index)
#endif #endif

View file

@ -20,7 +20,7 @@
#define _EEPROM_H #define _EEPROM_H
// Id to distinguish version changes // 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 /** Where to start with our datablock in memory. Can be moved if you
have problems with other modules using the eeprom */ have problems with other modules using the eeprom */
@ -121,6 +121,12 @@ have problems with other modules using the eeprom */
#define EPR_RETRACTION_UNDO_EXTRA_LONG_LENGTH 1012 #define EPR_RETRACTION_UNDO_EXTRA_LONG_LENGTH 1012
#define EPR_RETRACTION_UNDO_SPEED 1016 #define EPR_RETRACTION_UNDO_SPEED 1016
#define EPR_AUTORETRACT_ENABLED 1020 #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 #if EEPROM_MODE != 0
#define EEPROM_FLOAT(x) HAL::eprGetFloat(EPR_##x) #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_BYTE(x) HAL::eprGetByte(EPR_##x)
#define EEPROM_SET_BYTE(x,val) HAL::eprSetByte(EPR_##x,val) #define EEPROM_SET_BYTE(x,val) HAL::eprSetByte(EPR_##x,val)
#else #else
#define EEPROM_FLOAT(x) (x) #define EEPROM_FLOAT(x) (float)(x)
#define EEPROM_INT32(x) (x) #define EEPROM_INT32(x) (int32_t)(x)
#define EEPROM_BYTE(x) (x) #define EEPROM_BYTE(x) (uint8_t)(x)
#define EEPROM_SET_BYTE(x,val) #define EEPROM_SET_BYTE(x,val)
#endif #endif
@ -189,7 +195,26 @@ public:
static void writeSettings(); static void writeSettings();
static void update(GCode *com); static void update(GCode *com);
static void updatePrinterUsage(); 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() { static inline float zProbeSpeed() {
#if EEPROM_MODE != 0 #if EEPROM_MODE != 0
return HAL::eprGetFloat(EPR_Z_PROBE_SPEED); return HAL::eprGetFloat(EPR_Z_PROBE_SPEED);
@ -516,7 +541,34 @@ static inline void setTowerZFloor(float newZ) {
return 0; return 0;
#endif #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 #endif

View file

@ -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. // Gets called if a nextPrevius actions gets executed.
#define EVENT_START_NEXTPREVIOUS(action,increment) {} #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 // Allow adding new G and M codes. To implement it create a function
// bool eventUnhandledGCode(GCode *com) // bool eventUnhandledGCode(GCode *com)
// that returns true if it handled the code, otherwise false. // 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 {} #define EVENT_INITIALIZE {}
#endif // EVENTS_H_INCLUDED #endif // EVENTS_H_INCLUDED

View file

@ -66,11 +66,35 @@ void Extruder::manageTemperatures()
HAL::pingWatchdog(); HAL::pingWatchdog();
#endif // FEATURE_WATCHDOG #endif // FEATURE_WATCHDOG
uint8_t errorDetected = 0; uint8_t errorDetected = 0;
#ifdef RED_BLUE_STATUS_LEDS
bool hot = false; bool hot = false;
#endif
bool newDefectFound = false;
millis_t time = HAL::timeInMilliseconds(); // compare time for decouple tests 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++) for(uint8_t controller = 0; controller < NUM_TEMPERATURE_LOOPS; controller++)
{ {
TemperatureController *act = tempController[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 // Handle automatic cooling of extruders
if(controller < NUM_EXTRUDER) if(controller < NUM_EXTRUDER)
{ {
@ -87,25 +111,22 @@ void Extruder::manageTemperatures()
} }
} }
#if SHARED_COOLER_BOARD_EXT #if SHARED_COOLER_BOARD_EXT
if(pwm_pos[NUM_EXTRUDER + 1]) enable = true; if(pwm_pos[PWM_BOARD_FAN]) enable = true;
#endif #endif
extruder[0].coolerPWM = (enable ? extruder[0].coolerSpeed : 0); extruder[0].coolerPWM = (enable ? extruder[0].coolerSpeed : 0);
} } // controller == 0
#else #else
if(act->currentTemperatureC < EXTRUDER_FAN_COOL_TEMP && act->targetTemperatureC < EXTRUDER_FAN_COOL_TEMP) if(act->currentTemperatureC < EXTRUDER_FAN_COOL_TEMP && act->targetTemperatureC < EXTRUDER_FAN_COOL_TEMP)
extruder[controller].coolerPWM = 0; extruder[controller].coolerPWM = 0;
else else
extruder[controller].coolerPWM = extruder[controller].coolerSpeed; extruder[controller].coolerPWM = extruder[controller].coolerSpeed;
#endif // NUM_EXTRUDER #endif // NUM_EXTRUDER
} } // extruder controller
// do skip temperature control while auto tuning is in progress // do skip temperature control while auto tuning is in progress
if(controller == autotuneIndex) continue; if(controller == autotuneIndex) continue;
#if MIXING_EXTRUDER #if MIXING_EXTRUDER
if(controller > 0 && controller < NUM_EXTRUDER) continue; // Mixing extruder only test for ext 0 if(controller > 0 && controller < NUM_EXTRUDER) continue; // Mixing extruder only test for ext 0
#endif #endif // MIXING_EXTRUDER
// Get Temperature
act->updateCurrentTemperature();
// Check for obvious sensor errors // Check for obvious sensor errors
@ -119,14 +140,36 @@ void Extruder::manageTemperatures()
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDEFECT; act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDEFECT;
if(!Printer::isAnyTempsensorDefect()) if(!Printer::isAnyTempsensorDefect())
{ {
newDefectFound = true;
Printer::setAnyTempsensorDefect(); Printer::setAnyTempsensorDefect();
reportTempsensorError(); reportTempsensorError();
} }
EVENT_HEATER_DEFECT(controller); 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) if(act->currentTemperatureC > 50)
hot = true; hot = true;
#endif // RED_BLUE_STATUS_LEDS
if(Printer::isAnyTempsensorDefect()) continue; if(Printer::isAnyTempsensorDefect()) continue;
uint8_t on = act->currentTemperatureC >= act->targetTemperatureC ? LOW : HIGH; uint8_t on = act->currentTemperatureC >= act->targetTemperatureC ? LOW : HIGH;
// Make a sound if alarm was set on reaching target temperature // 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 // 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(decoupleTestRequired && act->isDecoupleFullOrHold() && Printer::isPowerOn()) // Only test when powered
{ {
if(act->isDecoupleFull()) // Phase 1: Heating fully until target range is reached 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 if(extruderTempErrors > 10) // Ignore short temporary failures
{ {
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED; act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED;
if(!Printer::isAnyTempsensorDefect())
{
Printer::setAnyTempsensorDefect(); Printer::setAnyTempsensorDefect();
newDefectFound = true;
}
UI_ERROR_P(Com::tHeaterDecoupled); UI_ERROR_P(Com::tHeaterDecoupled);
Com::printErrorFLN(Com::tHeaterDecoupledWarning); Com::printErrorFLN(Com::tHeaterDecoupledWarning);
Com::printF(PSTR("Error:Temp. raised to slow. Rise = "),act->currentTemperatureC - act->lastDecoupleTemp); 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 if(extruderTempErrors > 10) // Ignore short temporary failures
{ {
act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED; act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED;
if(!Printer::isAnyTempsensorDefect())
{
Printer::setAnyTempsensorDefect(); Printer::setAnyTempsensorDefect();
newDefectFound = true;
}
UI_ERROR_P(Com::tHeaterDecoupled); UI_ERROR_P(Com::tHeaterDecoupled);
Com::printErrorFLN(Com::tHeaterDecoupledWarning); Com::printErrorFLN(Com::tHeaterDecoupledWarning);
Com::printF(PSTR("Error:Could not hold temperature "),act->lastDecoupleTemp); Com::printF(PSTR("Error:Could not hold temperature "),act->lastDecoupleTemp);
@ -218,7 +270,7 @@ void Extruder::manageTemperatures()
pidTerm += dgain; pidTerm += dgain;
#if SCALE_PID_TO_MAX == 1 #if SCALE_PID_TO_MAX == 1
pidTerm = (pidTerm * act->pidMax) * 0.0039215; pidTerm = (pidTerm * act->pidMax) * 0.0039215;
#endif #endif // SCALE_PID_TO_MAX
output = constrain((int)pidTerm, 0, act->pidMax); output = constrain((int)pidTerm, 0, act->pidMax);
} }
else if(act->heatManager == HTR_DEADTIME) // dead-time control 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); output = (act->currentTemperatureC + act->tempIState * act->deadTime > act->targetTemperatureC ? 0 : act->pidDriveMax);
} }
else // bang bang and slow bang bang 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(act->heatManager == HTR_SLOWBANG) // Bang-bang with reduced change frequency to save relais life
{ {
if (time - act->lastTemperatureUpdate > HEATED_BED_SET_INTERVAL) if (time - act->lastTemperatureUpdate > HEATED_BED_SET_INTERVAL)
@ -251,19 +303,22 @@ void Extruder::manageTemperatures()
#ifdef MAXTEMP #ifdef MAXTEMP
if(act->currentTemperatureC > MAXTEMP) // Force heater off if MAXTEMP is exceeded if(act->currentTemperatureC > MAXTEMP) // Force heater off if MAXTEMP is exceeded
output = 0; output = 0;
#endif #endif // MAXTEMP
pwm_pos[act->pwmIndex] = output; // set pwm signal pwm_pos[act->pwmIndex] = output; // set pwm signal
#if LED_PIN > -1 #if LED_PIN > -1
if(act == &Extruder::current->tempControl) if(act == &Extruder::current->tempControl)
WRITE(LED_PIN,on); WRITE(LED_PIN,on);
#endif #endif // LED_PIN
} // for controller } // for controller
#ifdef RED_BLUE_STATUS_LEDS #ifdef RED_BLUE_STATUS_LEDS
if(Printer::isAnyTempsensorDefect()) { if(Printer::isAnyTempsensorDefect())
{
WRITE(BLUE_STATUS_LED,HIGH); WRITE(BLUE_STATUS_LED,HIGH);
WRITE(RED_STATUS_LED,HIGH); WRITE(RED_STATUS_LED,HIGH);
} else { }
else
{
WRITE(BLUE_STATUS_LED,!hot); WRITE(BLUE_STATUS_LED,!hot);
WRITE(RED_STATUS_LED,hot); WRITE(RED_STATUS_LED,hot);
} }
@ -271,14 +326,12 @@ void Extruder::manageTemperatures()
if(errorDetected == 0 && extruderTempErrors > 0) if(errorDetected == 0 && extruderTempErrors > 0)
extruderTempErrors--; extruderTempErrors--;
if(Printer::isAnyTempsensorDefect() if(newDefectFound)
#if HAVE_HEATED_BED
|| Extruder::getHeatedBedTemperature() > HEATED_BED_MAX_TEMP + 5
#endif
)
{ {
Com::printFLN(PSTR("Disabling all heaters due to detected sensor defect."));
for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++) for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
{ {
tempController[i]->targetTemperatureC = 0;
pwm_pos[tempController[i]->pwmIndex] = 0; pwm_pos[tempController[i]->pwmIndex] = 0;
} }
#if defined(KILL_IF_SENSOR_DEFECT) && KILL_IF_SENSOR_DEFECT > 0 #if defined(KILL_IF_SENSOR_DEFECT) && KILL_IF_SENSOR_DEFECT > 0
@ -286,12 +339,13 @@ void Extruder::manageTemperatures()
{ {
#if SDSUPPORT #if SDSUPPORT
sd.stopPrint(); sd.stopPrint();
#endif #endif // SDSUPPORT
Printer::kill(0); Printer::kill(0);
} }
#endif #endif // KILL_IF_SENSOR_DEFECT
Printer::debugLevel |= 8; // Go into dry mode 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. /** \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) void Extruder::selectExtruderById(uint8_t extruderId)
{ {
@ -520,10 +574,14 @@ void Extruder::selectExtruderById(uint8_t extruderId)
activeMixingExtruder = extruderId; activeMixingExtruder = extruderId;
for(uint8_t i = 0; i < NUM_EXTRUDER; i++) for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
Extruder::setMixingWeight(i, extruder[i].virtualWeights[extruderId]); Extruder::setMixingWeight(i, extruder[i].virtualWeights[extruderId]);
Com::printFLN(PSTR("SelectExtruder:"),static_cast<int>(extruderId));
extruderId = 0; extruderId = 0;
#endif #endif
if(extruderId >= NUM_EXTRUDER) if(extruderId >= NUM_EXTRUDER)
extruderId = 0; extruderId = 0;
#if !MIXING_EXTRUDER
Com::printFLN(PSTR("SelectExtruder:"),static_cast<int>(extruderId));
#endif
#if NUM_EXTRUDER > 1 && MIXING_EXTRUDER == 0 #if NUM_EXTRUDER > 1 && MIXING_EXTRUDER == 0
bool executeSelect = false; bool executeSelect = false;
if(extruderId != Extruder::current->id) if(extruderId != Extruder::current->id)
@ -536,19 +594,23 @@ void Extruder::selectExtruderById(uint8_t extruderId)
Extruder::current->extrudePosition = Printer::currentPositionSteps[E_AXIS]; Extruder::current->extrudePosition = Printer::currentPositionSteps[E_AXIS];
Extruder::current = &extruder[extruderId]; Extruder::current = &extruder[extruderId];
#ifdef SEPERATE_EXTRUDER_POSITIONS #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; Printer::currentPositionSteps[E_AXIS] = Extruder::current->extrudePosition;
#endif #endif
#if MIXING_EXTRUDER
recomputeMixingExtruderSteps();
#else
Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS]; Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS];
Printer::axisStepsPerMM[E_AXIS] = Extruder::current->stepsPerMM; Printer::axisStepsPerMM[E_AXIS] = Extruder::current->stepsPerMM;
Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS]; Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS];
#endif
Printer::maxFeedrate[E_AXIS] = Extruder::current->maxFeedrate; Printer::maxFeedrate[E_AXIS] = Extruder::current->maxFeedrate;
// max_start_speed_units_per_second[E_AXIS] = Extruder::current->maxStartFeedrate; // max_start_speed_units_per_second[E_AXIS] = Extruder::current->maxStartFeedrate;
Printer::maxAccelerationMMPerSquareSecond[E_AXIS] = Printer::maxTravelAccelerationMMPerSquareSecond[E_AXIS] = Extruder::current->maxAcceleration; Printer::maxAccelerationMMPerSquareSecond[E_AXIS] = Printer::maxTravelAccelerationMMPerSquareSecond[E_AXIS] = Extruder::current->maxAcceleration;
Printer::maxTravelAccelerationStepsPerSquareSecond[E_AXIS] = Printer::maxTravelAccelerationStepsPerSquareSecond[E_AXIS] =
Printer::maxPrintAccelerationStepsPerSquareSecond[E_AXIS] = Printer::maxAccelerationMMPerSquareSecond[E_AXIS] * Printer::axisStepsPerMM[E_AXIS]; Printer::maxPrintAccelerationStepsPerSquareSecond[E_AXIS] = Printer::maxAccelerationMMPerSquareSecond[E_AXIS] * Printer::axisStepsPerMM[E_AXIS];
#if USE_ADVANCE #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 CPU_ARCH == ARCH_ARM
if(Printer::maxExtruderSpeed > 40) Printer::maxExtruderSpeed = 40; if(Printer::maxExtruderSpeed > 40) Printer::maxExtruderSpeed = 40;
#else #else
@ -581,9 +643,25 @@ void Extruder::selectExtruderById(uint8_t extruderId)
#endif #endif
#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) void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t extr, bool beep, bool wait)
{ {
#if NUM_EXTRUDER > 0
#if MIXING_EXTRUDER #if MIXING_EXTRUDER
extr = 0; // map any virtual extruder number to 0 extr = 0; // map any virtual extruder number to 0
#endif // MIXING_EXTRUDER #endif // MIXING_EXTRUDER
@ -609,12 +687,14 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
{ {
TemperatureController *tc2 = tempController[1]; TemperatureController *tc2 = tempController[1];
tc2->setTargetTemperature(temperatureInCelsius); tc2->setTargetTemperature(temperatureInCelsius);
tc2->updateTempControlVars();
if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[1].coolerPWM = extruder[1].coolerSpeed; if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[1].coolerPWM = extruder[1].coolerSpeed;
#if NUM_EXTRUDER > 2 #if NUM_EXTRUDER > 2
if(Extruder::dittoMode > 1 && extr == 0) if(Extruder::dittoMode > 1 && extr == 0)
{ {
TemperatureController *tc2 = tempController[2]; TemperatureController *tc2 = tempController[2];
tc2->setTargetTemperature(temperatureInCelsius); tc2->setTargetTemperature(temperatureInCelsius);
tc2->updateTempControlVars();
if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[2].coolerPWM = extruder[2].coolerSpeed; if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[2].coolerPWM = extruder[2].coolerSpeed;
} }
#endif #endif
@ -623,6 +703,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
{ {
TemperatureController *tc2 = tempController[3]; TemperatureController *tc2 = tempController[3];
tc2->setTargetTemperature(temperatureInCelsius); tc2->setTargetTemperature(temperatureInCelsius);
tc2->updateTempControlVars();
if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[3].coolerPWM = extruder[3].coolerSpeed; if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[3].coolerPWM = extruder[3].coolerSpeed;
} }
#endif #endif
@ -635,7 +716,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
) )
{ {
Extruder *actExtruder = &extruder[extr]; 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); EVENT_WAITING_HEATER(actExtruder->id);
bool dirRising = actExtruder->tempControl.targetTemperature > actExtruder->tempControl.currentTemperature; bool dirRising = actExtruder->tempControl.targetTemperature > actExtruder->tempControl.currentTemperature;
millis_t printedTime = HAL::timeInMilliseconds(); 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::filamentPrinted = 0; // new print, new counter
Printer::flag2 &= ~PRINTER_FLAG2_RESET_FILAMENT_USAGE; Printer::flag2 &= ~PRINTER_FLAG2_RESET_FILAMENT_USAGE;
} }
#endif
} }
void Extruder::setHeatedBedTemperature(float temperatureInCelsius,bool beep) 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); if(beep && temperatureInCelsius>30) heatedBedController.setAlarm(true);
Com::printFLN(Com::tTargetBedColon,heatedBedController.targetTemperatureC,0); Com::printFLN(Com::tTargetBedColon,heatedBedController.targetTemperatureC,0);
if(temperatureInCelsius > 15) 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()) 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 #endif
} }
@ -738,6 +820,45 @@ void Extruder::setMixingWeight(uint8_t extr,int weight)
} }
void Extruder::step() 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; uint8_t best = 255,i;
int bestError; int bestError;
if(mixingDir) if(mixingDir)
@ -775,7 +896,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 0 #if NUM_EXTRUDER > 0
if(best == 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 #if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
TEST_EXTRUDER_JAM(0) TEST_EXTRUDER_JAM(0)
#endif #endif
@ -784,7 +905,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 1 #if NUM_EXTRUDER > 1
if(best == 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 #if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
TEST_EXTRUDER_JAM(1) TEST_EXTRUDER_JAM(1)
#endif #endif
@ -793,7 +914,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 2 #if NUM_EXTRUDER > 2
if(best == 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 #if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
TEST_EXTRUDER_JAM(2) TEST_EXTRUDER_JAM(2)
#endif #endif
@ -802,7 +923,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 3 #if NUM_EXTRUDER > 3
if(best == 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 #if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
TEST_EXTRUDER_JAM(3) TEST_EXTRUDER_JAM(3)
#endif #endif
@ -811,7 +932,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 4 #if NUM_EXTRUDER > 4
if(best == 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 #if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
TEST_EXTRUDER_JAM(4) TEST_EXTRUDER_JAM(4)
#endif #endif
@ -820,7 +941,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 5 #if NUM_EXTRUDER > 5
if(best == 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 #if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
TEST_EXTRUDER_JAM(5) TEST_EXTRUDER_JAM(5)
#endif #endif
@ -831,22 +952,22 @@ void Extruder::step()
void Extruder::unstep() void Extruder::unstep()
{ {
#if NUM_EXTRUDER > 0 #if NUM_EXTRUDER > 0
WRITE(EXT0_STEP_PIN, LOW); WRITE(EXT0_STEP_PIN, !START_STEP_WITH_HIGH);
#endif #endif
#if NUM_EXTRUDER > 1 #if NUM_EXTRUDER > 1
WRITE(EXT1_STEP_PIN, LOW); WRITE(EXT1_STEP_PIN, !START_STEP_WITH_HIGH);
#endif #endif
#if NUM_EXTRUDER > 2 #if NUM_EXTRUDER > 2
WRITE(EXT2_STEP_PIN, LOW); WRITE(EXT2_STEP_PIN, !START_STEP_WITH_HIGH);
#endif #endif
#if NUM_EXTRUDER > 3 #if NUM_EXTRUDER > 3
WRITE(EXT3_STEP_PIN, LOW); WRITE(EXT3_STEP_PIN, !START_STEP_WITH_HIGH);
#endif #endif
#if NUM_EXTRUDER > 4 #if NUM_EXTRUDER > 4
WRITE(EXT4_STEP_PIN, LOW); WRITE(EXT4_STEP_PIN, !START_STEP_WITH_HIGH);
#endif #endif
#if NUM_EXTRUDER > 5 #if NUM_EXTRUDER > 5
WRITE(EXT5_STEP_PIN, LOW); WRITE(EXT5_STEP_PIN, !START_STEP_WITH_HIGH);
#endif #endif
} }
@ -925,7 +1046,7 @@ Call this function only, if interrupts are disabled.
void Extruder::step() void Extruder::step()
{ {
#if NUM_EXTRUDER == 1 #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 #if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
TEST_EXTRUDER_JAM(0) TEST_EXTRUDER_JAM(0)
#endif #endif
@ -934,21 +1055,21 @@ void Extruder::step()
{ {
case 0: case 0:
#if NUM_EXTRUDER > 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 #if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
TEST_EXTRUDER_JAM(0) TEST_EXTRUDER_JAM(0)
#endif #endif
#if FEATURE_DITTO_PRINTING #if FEATURE_DITTO_PRINTING
if(Extruder::dittoMode) 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 #if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
TEST_EXTRUDER_JAM(1) TEST_EXTRUDER_JAM(1)
#endif #endif
#if NUM_EXTRUDER > 2 #if NUM_EXTRUDER > 2
if(Extruder::dittoMode > 1) 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 #if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
TEST_EXTRUDER_JAM(2) TEST_EXTRUDER_JAM(2)
#endif #endif
@ -957,7 +1078,7 @@ void Extruder::step()
#if NUM_EXTRUDER > 3 #if NUM_EXTRUDER > 3
if(Extruder::dittoMode > 2) 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 #if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
TEST_EXTRUDER_JAM(3) TEST_EXTRUDER_JAM(3)
#endif #endif
@ -969,7 +1090,7 @@ void Extruder::step()
break; break;
#if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1 #if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1
case 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 #if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
TEST_EXTRUDER_JAM(1) TEST_EXTRUDER_JAM(1)
#endif #endif
@ -977,7 +1098,7 @@ void Extruder::step()
#endif #endif
#if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2 #if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2
case 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 #if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
TEST_EXTRUDER_JAM(2) TEST_EXTRUDER_JAM(2)
#endif #endif
@ -985,7 +1106,7 @@ void Extruder::step()
#endif #endif
#if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3 #if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3
case 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 #if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
TEST_EXTRUDER_JAM(3) TEST_EXTRUDER_JAM(3)
#endif #endif
@ -993,7 +1114,7 @@ void Extruder::step()
#endif #endif
#if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4 #if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4
case 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 #if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
TEST_EXTRUDER_JAM(4) TEST_EXTRUDER_JAM(4)
#endif #endif
@ -1001,7 +1122,7 @@ void Extruder::step()
#endif #endif
#if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5 #if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5
case 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 #if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
TEST_EXTRUDER_JAM(5) TEST_EXTRUDER_JAM(5)
#endif #endif
@ -1019,27 +1140,27 @@ Call this function only, if interrupts are disabled.
void Extruder::unstep() void Extruder::unstep()
{ {
#if NUM_EXTRUDER == 1 #if NUM_EXTRUDER == 1
WRITE(EXT0_STEP_PIN,LOW); WRITE(EXT0_STEP_PIN,!START_STEP_WITH_HIGH);
#else #else
switch(Extruder::current->id) switch(Extruder::current->id)
{ {
case 0: case 0:
#if NUM_EXTRUDER > 0 #if NUM_EXTRUDER > 0
WRITE(EXT0_STEP_PIN,LOW); WRITE(EXT0_STEP_PIN,!START_STEP_WITH_HIGH);
#if FEATURE_DITTO_PRINTING #if FEATURE_DITTO_PRINTING
if(Extruder::dittoMode) if(Extruder::dittoMode)
{ {
WRITE(EXT1_STEP_PIN,LOW); WRITE(EXT1_STEP_PIN,!START_STEP_WITH_HIGH);
#if NUM_EXTRUDER > 2 #if NUM_EXTRUDER > 2
if(Extruder::dittoMode > 1) if(Extruder::dittoMode > 1)
{ {
WRITE(EXT2_STEP_PIN,LOW); WRITE(EXT2_STEP_PIN,!START_STEP_WITH_HIGH);
} }
#endif #endif
#if NUM_EXTRUDER > 3 #if NUM_EXTRUDER > 3
if(Extruder::dittoMode > 2) if(Extruder::dittoMode > 2)
{ {
WRITE(EXT3_STEP_PIN,LOW); WRITE(EXT3_STEP_PIN,!START_STEP_WITH_HIGH);
} }
#endif // NUM_EXTRUDER > 3 #endif // NUM_EXTRUDER > 3
} }
@ -1048,27 +1169,27 @@ void Extruder::unstep()
break; break;
#if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1 #if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1
case 1: case 1:
WRITE(EXT1_STEP_PIN,LOW); WRITE(EXT1_STEP_PIN,!START_STEP_WITH_HIGH);
break; break;
#endif #endif
#if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2 #if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2
case 2: case 2:
WRITE(EXT2_STEP_PIN,LOW); WRITE(EXT2_STEP_PIN,!START_STEP_WITH_HIGH);
break; break;
#endif #endif
#if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3 #if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3
case 3: case 3:
WRITE(EXT3_STEP_PIN,LOW); WRITE(EXT3_STEP_PIN,!START_STEP_WITH_HIGH);
break; break;
#endif #endif
#if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4 #if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4
case 4: case 4:
WRITE(EXT4_STEP_PIN,LOW); WRITE(EXT4_STEP_PIN,!START_STEP_WITH_HIGH);
break; break;
#endif #endif
#if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5 #if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5
case 5: case 5:
WRITE(EXT5_STEP_PIN,LOW); WRITE(EXT5_STEP_PIN,!START_STEP_WITH_HIGH);
break; break;
#endif #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}, {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} {955*4, -11*8},{1008*4, -35*8}
}; };
// ATC 104GT
#define NUMTEMPS_8 34 #define NUMTEMPS_8 34
const short temptable_8[NUMTEMPS_8][2] PROGMEM = 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}, {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} {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 #if NUM_TEMPS_USERTHERMISTOR0 > 0
const short temptable_5[NUM_TEMPS_USERTHERMISTOR0][2] PROGMEM = USER_THERMISTORTABLE0 ; const short temptable_5[NUM_TEMPS_USERTHERMISTOR0][2] PROGMEM = USER_THERMISTORTABLE0 ;
#endif #endif
@ -1334,7 +1461,7 @@ const short temptable_6[NUM_TEMPS_USERTHERMISTOR1][2] PROGMEM = USER_THERMISTORT
#if NUM_TEMPS_USERTHERMISTOR2 > 0 #if NUM_TEMPS_USERTHERMISTOR2 > 0
const short temptable_7[NUM_TEMPS_USERTHERMISTOR2][2] PROGMEM = USER_THERMISTORTABLE2 ; const short temptable_7[NUM_TEMPS_USERTHERMISTOR2][2] PROGMEM = USER_THERMISTORTABLE2 ;
#endif #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 #if NUM_TEMPS_USERTHERMISTOR0 > 0
,(short int *)&temptable_5[0][0] ,(short int *)&temptable_5[0][0]
#else #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_10[0][0]
,(short int *)&temptable_11[0][0] ,(short int *)&temptable_11[0][0]
,(short int *)&temptable_12[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, 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_9,NUMTEMPS_10,NUMTEMPS_11,NUMTEMPS_12,NUMTEMPS_13
}; };
@ -1388,12 +1516,13 @@ void TemperatureController::updateCurrentTemperature()
case 99: case 99:
currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS)); // Convert to 10 bit result currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS)); // Convert to 10 bit result
break; break;
case 13: // PT100 E3D
case 50: // User defined PTC table case 50: // User defined PTC table
case 51: case 51:
case 52: case 52:
case 60: // HEATER_USES_AD8495 (Delivers 5mV/degC) case 60: // HEATER_USES_AD8495 (Delivers 5mV/degC)
case 61: // HEATER_USES_AD8495 (Delivers 5mV/degC) 1.25v offset case 61: // HEATER_USES_AD8495 (Delivers 5mV/degC) 1.25v offset
case 100: // AD595 case 100: // AD595 / AD597
currentTemperature = (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS)); currentTemperature = (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS));
break; break;
#endif #endif
@ -1433,10 +1562,10 @@ void TemperatureController::updateCurrentTemperature()
type--; type--;
uint8_t num = pgm_read_byte(&temptables_num[type]) << 1; uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
uint8_t i = 2; uint8_t i = 2;
const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]); const int16_t *temptable = (const int16_t *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
short oldraw = pgm_read_word(&temptable[0]); int16_t oldraw = pgm_read_word(&temptable[0]);
short oldtemp = pgm_read_word(&temptable[1]); int16_t oldtemp = pgm_read_word(&temptable[1]);
short newraw,newtemp; int16_t newraw,newtemp = 0;
currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - currentTemperature; currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - currentTemperature;
while(i < num) while(i < num)
{ {
@ -1456,17 +1585,21 @@ void TemperatureController::updateCurrentTemperature()
currentTemperatureC = TEMP_INT_TO_FLOAT(newtemp); currentTemperatureC = TEMP_INT_TO_FLOAT(newtemp);
} }
break; break;
case 13:
case 50: // User defined PTC thermistor case 50: // User defined PTC thermistor
case 51: case 51:
case 52: case 52:
{ {
if(type > 49)
type -= 46; type -= 46;
else
type--;
uint8_t num = pgm_read_byte(&temptables_num[type]) << 1; uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
uint8_t i = 2; uint8_t i = 2;
const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]); const int16_t *temptable = (const int16_t *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
short oldraw = pgm_read_word(&temptable[0]); int16_t oldraw = pgm_read_word(&temptable[0]);
short oldtemp = pgm_read_word(&temptable[1]); int16_t oldtemp = pgm_read_word(&temptable[1]);
short newraw,newtemp; int16_t newraw,newtemp = 0;
while(i < num) while(i < num)
{ {
newraw = pgm_read_word(&temptable[i++]); newraw = pgm_read_word(&temptable[i++]);
@ -1497,12 +1630,16 @@ void TemperatureController::updateCurrentTemperature()
currentTemperatureC = ((float)currentTemperature * 660.0f / (1024 << (2 - ANALOG_REDUCE_BITS))) - 250.0f; currentTemperatureC = ((float)currentTemperature * 660.0f / (1024 << (2 - ANALOG_REDUCE_BITS))) - 250.0f;
#endif #endif
break; break;
case 100: // AD595 case 100: // AD595 / AD597 10mV/°C
//return (int)((long)raw_temp * 500/(1024<<(2-ANALOG_REDUCE_BITS))); //return (int)((long)raw_temp * 500/(1024<<(2-ANALOG_REDUCE_BITS)));
#if CPU_ARCH == ARCH_AVR #if CPU_ARCH == ARCH_AVR
currentTemperatureC = ((float)currentTemperature * 500.0f / (1024 << (2 - ANALOG_REDUCE_BITS))); 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 #else
currentTemperatureC = ((float)currentTemperature * 330.0f / (1024 << (2 - ANALOG_REDUCE_BITS))); currentTemperatureC = ((float)currentTemperature * 330.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
#endif
#endif #endif
break; break;
#ifdef SUPPORT_MAX6675 #ifdef SUPPORT_MAX6675
@ -1607,11 +1744,15 @@ void TemperatureController::setTargetTemperature(float target)
targetTemperature = (1023<<(2-ANALOG_REDUCE_BITS))-newraw; targetTemperature = (1023<<(2-ANALOG_REDUCE_BITS))-newraw;
break; break;
} }
case 13: // PT100 E3D
case 50: // user defined PTC thermistor case 50: // user defined PTC thermistor
case 51: case 51:
case 52: case 52:
{ {
if(type > 49)
type -= 46; type -= 46;
else
type--;
uint8_t num = pgm_read_byte(&temptables_num[type]) << 1; uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
uint8_t i = 2; uint8_t i = 2;
const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word(&temptables[type]); const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word(&temptables[type]);
@ -1695,6 +1836,7 @@ void TemperatureController::setTargetTemperature(float target)
uint8_t autotuneIndex = 255; uint8_t autotuneIndex = 255;
void Extruder::disableAllHeater() void Extruder::disableAllHeater()
{ {
#if NUM_TEMPERATURE_LOOPS > 0
for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++) for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
{ {
TemperatureController *c = tempController[i]; TemperatureController *c = tempController[i];
@ -1702,6 +1844,7 @@ void Extruder::disableAllHeater()
c->targetTemperatureC = 0; c->targetTemperatureC = 0;
pwm_pos[c->pwmIndex] = 0; pwm_pos[c->pwmIndex] = 0;
} }
#endif
autotuneIndex = 255; autotuneIndex = 255;
} }
@ -1863,6 +2006,7 @@ void writeMonitor()
bool reportTempsensorError() bool reportTempsensorError()
{ {
#if NUM_TEMPERATURE_LOOPS > 0
if(!Printer::isAnyTempsensorDefect()) return false; if(!Printer::isAnyTempsensorDefect()) return false;
for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++) for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
{ {
@ -1876,12 +2020,19 @@ bool reportTempsensorError()
} }
Com::printErrorFLN(Com::tDryModeUntilRestart); Com::printErrorFLN(Com::tDryModeUntilRestart);
return true; return true;
#else
return false;
#endif
} }
#ifdef SUPPORT_MAX6675 #ifdef SUPPORT_MAX6675
int16_t read_max6675(uint8_t ss_pin) int16_t read_max6675(uint8_t ss_pin)
{ {
int16_t max6675_temp = 0; static millis_t last_max6675_read = 0;
static int16_t max6675_temp = 0;
if (HAL::timeInMilliseconds() - last_max6675_read > 230)
{
HAL::spiInit(2); HAL::spiInit(2);
HAL::digitalWrite(ss_pin, 0); // enable TT_MAX6675 HAL::digitalWrite(ss_pin, 0); // enable TT_MAX6675
HAL::delayMicroseconds(1); // ensure 100ns delay - a bit extra is fine HAL::delayMicroseconds(1); // ensure 100ns delay - a bit extra is fine
@ -1889,6 +2040,8 @@ int16_t read_max6675(uint8_t ss_pin)
max6675_temp <<= 8; max6675_temp <<= 8;
max6675_temp |= HAL::spiReceive(0); max6675_temp |= HAL::spiReceive(0);
HAL::digitalWrite(ss_pin, 1); // disable TT_MAX6675 HAL::digitalWrite(ss_pin, 1); // disable TT_MAX6675
last_max6675_read = HAL::timeInMilliseconds();
}
return max6675_temp & 4 ? 2000 : max6675_temp >> 3; // thermocouple open? return max6675_temp & 4 ? 2000 : max6675_temp >> 3; // thermocouple open?
} }
#endif #endif
@ -1934,7 +2087,13 @@ void Extruder::retractDistance(float dist)
int32_t distance = static_cast<int32_t>(dist * stepsPerMM / Printer::extrusionFactor); int32_t distance = static_cast<int32_t>(dist * stepsPerMM / Printer::extrusionFactor);
int32_t oldEPos = Printer::currentPositionSteps[E_AXIS]; int32_t oldEPos = Printer::currentPositionSteps[E_AXIS];
float speed = distance > 0 ? EEPROM_FLOAT(RETRACTION_SPEED) : EEPROM_FLOAT(RETRACTION_UNDO_SPEED); 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); 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::currentPositionSteps[E_AXIS] = oldEPos; // restore previous extruder position
Printer::feedrate = oldFeedrate; Printer::feedrate = oldFeedrate;
} }
@ -1943,26 +2102,27 @@ void Extruder::retract(bool isRetract,bool isLong)
{ {
float oldFeedrate = Printer::feedrate; float oldFeedrate = Printer::feedrate;
float distance = (isLong ? EEPROM_FLOAT( RETRACTION_LONG_LENGTH) : EEPROM_FLOAT(RETRACTION_LENGTH)); 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]); float zLiftF = EEPROM_FLOAT(RETRACTION_Z_LIFT);
int32_t oldZPos = Printer::currentPositionSteps[Z_AXIS]; int32_t zlift = static_cast<int32_t>(zLiftF * Printer::axisStepsPerMM[Z_AXIS]);
float oldZPosF = Printer::currentPosition[Z_AXIS];
if(isRetract && !isRetracted()) if(isRetract && !isRetracted())
{ {
retractDistance(distance); retractDistance(distance);
setRetracted(true); setRetracted(true);
if(zlift > 0) if(zlift > 0) {
PrintLine::moveRelativeDistanceInStepsReal(0,0,zlift,0,Printer::maxFeedrate[Z_AXIS], false); PrintLine::moveRelativeDistanceInStepsReal(0,0,zlift,0,Printer::maxFeedrate[Z_AXIS], false);
Printer::coordinateOffset[Z_AXIS] -= zLiftF;
}
} }
else if(!isRetract && isRetracted()) else if(!isRetract && isRetracted())
{ {
distance += (isLong ? EEPROM_FLOAT(RETRACTION_UNDO_EXTRA_LONG_LENGTH) : EEPROM_FLOAT(RETRACTION_UNDO_EXTRA_LENGTH) ); 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); PrintLine::moveRelativeDistanceInStepsReal(0,0,-zlift,0,Printer::maxFeedrate[Z_AXIS], false);
Printer::coordinateOffset[Z_AXIS] += zLiftF;
}
retractDistance(-distance); retractDistance(-distance);
setRetracted(false); setRetracted(false);
} }
Printer::currentPositionSteps[Z_AXIS] = oldZPos; // z lift should have no visible impact
Printer::currentPosition[Z_AXIS] = oldZPosF;
Printer::feedrate = oldFeedrate; Printer::feedrate = oldFeedrate;
} }
#endif #endif
@ -2165,17 +2325,22 @@ Extruder extruder[NUM_EXTRUDER] =
#endif // NUM_EXTRUDER #endif // NUM_EXTRUDER
#if HAVE_HEATED_BED #if HAVE_HEATED_BED
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER+1 TemperatureController heatedBedController = {PWM_HEATED_BED,HEATED_BED_SENSOR_TYPE,BED_SENSOR_INDEX,0,0,0,0,0,HEATED_BED_HEAT_MANAGER
TemperatureController heatedBedController = {NUM_EXTRUDER,HEATED_BED_SENSOR_TYPE,BED_SENSOR_INDEX,0,0,0,0,0,HEATED_BED_HEAT_MANAGER
#if TEMP_PID #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} ,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 #endif
,0,0,0,HEATED_BED_DECOUPLE_TEST_PERIOD ,0,0,0,HEATED_BED_DECOUPLE_TEST_PERIOD};
};
#else
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER
#endif #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] = TemperatureController *tempController[NUM_TEMPERATURE_LOOPS] =
{ {
#if NUM_EXTRUDER > 0 #if NUM_EXTRUDER > 0
@ -2203,7 +2368,12 @@ TemperatureController *tempController[NUM_TEMPERATURE_LOOPS] =
,&heatedBedController ,&heatedBedController
#endif #endif
#endif #endif
#if FAN_THERMO_PIN > -1
#if NUM_EXTRUDER == 0 && !HAVE_HEATED_BED
&thermoController
#else
,&thermoController
#endif
#endif // FAN_THERMO_PIN
}; };
#endif

View file

@ -148,6 +148,7 @@ class Extruder;
extern Extruder extruder[]; extern Extruder extruder[];
#if EXTRUDER_JAM_CONTROL #if EXTRUDER_JAM_CONTROL
#if JAM_METHOD == 1
#define _TEST_EXTRUDER_JAM(x,pin) {\ #define _TEST_EXTRUDER_JAM(x,pin) {\
uint8_t sig = READ(pin);extruder[x].jamStepsSinceLastSignal += extruder[x].jamLastDir;\ 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) {\ 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()) \ } else if(abs(extruder[x].jamStepsSinceLastSignal) > JAM_ERROR_STEPS && !Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) \
extruder[x].tempControl.setJammed(true);\ 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,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,EXT ## x ## _JAM_PIN)
#define TEST_EXTRUDER_JAM(x) __TEST_EXTRUDER_JAM(x) #define TEST_EXTRUDER_JAM(x) __TEST_EXTRUDER_JAM(x)
#define RESET_EXTRUDER_JAM(x,dir) extruder[x].jamLastDir = dir ? 1 : -1;
#else #else
#define TEST_EXTRUDER_JAM(x) #define TEST_EXTRUDER_JAM(x)
#define RESET_EXTRUDER_JAM(x,dir) #define RESET_EXTRUDER_JAM(x,dir)
@ -184,6 +198,7 @@ public:
static int mixingS; ///< Sum of all weights static int mixingS; ///< Sum of all weights
static uint8_t mixingDir; ///< Direction flag static uint8_t mixingDir; ///< Direction flag
static uint8_t activeMixingExtruder; static uint8_t activeMixingExtruder;
static void recomputeMixingExtruderSteps();
#endif #endif
uint8_t id; uint8_t id;
int32_t xOffset; int32_t xOffset;
@ -274,19 +289,27 @@ public:
}; };
#if HAVE_HEATED_BED #if HAVE_HEATED_BED
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER+1 #define HEATED_BED_INDEX NUM_EXTRUDER
extern TemperatureController heatedBedController; extern TemperatureController heatedBedController;
#else #else
#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER #define HEATED_BED_INDEX NUM_EXTRUDER-1
#endif #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_INT_TO_FLOAT(temp) ((float)(temp)/(float)(1<<CELSIUS_EXTRA_BITS))
#define TEMP_FLOAT_TO_INT(temp) ((int)((temp)*(1<<CELSIUS_EXTRA_BITS))) #define TEMP_FLOAT_TO_INT(temp) ((int)((temp)*(1<<CELSIUS_EXTRA_BITS)))
//extern Extruder *Extruder::current; //extern Extruder *Extruder::current;
#if NUM_TEMPERATURE_LOOPS > 0
extern TemperatureController *tempController[NUM_TEMPERATURE_LOOPS]; extern TemperatureController *tempController[NUM_TEMPERATURE_LOOPS];
#endif
extern uint8_t autotuneIndex; extern uint8_t autotuneIndex;
#endif // EXTRUDER_H_INCLUDED #endif // EXTRUDER_H_INCLUDED

View file

@ -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; return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
} }
#endif // FatStructs_h #endif // FatStructs_h

View file

@ -6,7 +6,9 @@ uint8 osAnalogInputCounter[ANALOG_INPUTS];
uint osAnalogInputBuildup[ANALOG_INPUTS]; uint osAnalogInputBuildup[ANALOG_INPUTS];
uint8 osAnalogInputPos = 0; // Current sampling position uint8 osAnalogInputPos = 0; // Current sampling position
#endif #endif
#if FEATURE_WATCHDOG
bool HAL::wdPinged = false;
#endif
//extern "C" void __cxa_pure_virtual() { } //extern "C" void __cxa_pure_virtual() { }
HAL::HAL() HAL::HAL()
@ -318,8 +320,8 @@ void HAL::analogStart()
//ADCSRA |= _BV(ADSC); // start ADC-conversion //ADCSRA |= _BV(ADSC); // start ADC-conversion
while (ADCSRA & _BV(ADSC) ) {} // wait for conversion while (ADCSRA & _BV(ADSC) ) {} // wait for conversion
/* ADCW must be read once, otherwise the next result is wrong. */ /* ADCW must be read once, otherwise the next result is wrong. */
uint dummyADCResult; //uint dummyADCResult;
dummyADCResult = ADCW; //dummyADCResult = ADCW;
// Enable interrupt driven conversion loop // Enable interrupt driven conversion loop
uint8_t channel = pgm_read_byte(&osAnalogInputChannels[osAnalogInputPos]); uint8_t channel = pgm_read_byte(&osAnalogInputChannels[osAnalogInputPos]);
#if defined(ADCSRB) && defined(MUX5) #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_cooler = 0;
static uint8_t pwm_count_heater = 0; static uint8_t pwm_count_heater = 0;
static uint8_t pwm_pos_set[NUM_EXTRUDER + 3]; static uint8_t pwm_pos_set[NUM_PWM];
#if NUM_EXTRUDER > 0 #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]; static uint8_t pwm_cooler_pos_set[NUM_EXTRUDER];
#endif #endif
PWM_OCR += 64; PWM_OCR += 64;
@ -842,10 +844,16 @@ ISR(PWM_TIMER_VECTOR)
#endif #endif
#endif #endif
#if FAN_BOARD_PIN > -1 && SHARED_COOLER_BOARD_EXT == 0 #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 #endif
#if FAN_PIN > -1 && FEATURE_FAN_CONTROL #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 #endif
} }
#if defined(EXT0_HEATER_PIN) && EXT0_HEATER_PIN > -1 #if defined(EXT0_HEATER_PIN) && EXT0_HEATER_PIN > -1
@ -934,21 +942,38 @@ ISR(PWM_TIMER_VECTOR)
#endif #endif
#if FAN_BOARD_PIN > -1 && SHARED_COOLER_BOARD_EXT == 0 #if FAN_BOARD_PIN > -1 && SHARED_COOLER_BOARD_EXT == 0
#if PDM_FOR_COOLER #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 #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
#endif #endif
#if FAN_PIN > -1 && FEATURE_FAN_CONTROL #if FAN_PIN > -1 && FEATURE_FAN_CONTROL
if(fanKickstart == 0) if(fanKickstart == 0)
{ {
#if PDM_FOR_COOLER #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 #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
} }
#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 HEATED_BED_HEATER_PIN > -1 && HAVE_HEATED_BED
#if PDM_FOR_EXTRUDER #if PDM_FOR_EXTRUDER
pulseDensityModulate(HEATED_BED_HEATER_PIN, pwm_pos[NUM_EXTRUDER], pwm_pos_set[NUM_EXTRUDER], HEATER_PINS_INVERTED); 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
#endif #endif
HAL::allowInterrupts(); HAL::allowInterrupts();
counterPeriodical++; // Appxoimate a 100ms timer counterPeriodical++; // Approximate a 100ms timer
if(counterPeriodical >= (int)(F_CPU/40960)) if(counterPeriodical >= (int)(F_CPU/40960))
{ {
counterPeriodical = 0; counterPeriodical = 0;
executePeriodical = 1; executePeriodical = 1;
#if FEATURE_FAN_CONTROL
if (fanKickstart) fanKickstart--; if (fanKickstart) fanKickstart--;
#endif
#if FEATURE_FAN2_CONTROL
if (fan2Kickstart) fan2Kickstart--;
#endif
} }
// read analog values // read analog values
#if ANALOG_INPUTS > 0 #if ANALOG_INPUTS > 0
@ -1002,6 +1032,12 @@ ISR(PWM_TIMER_VECTOR)
UI_FAST; // Short timed user interface action UI_FAST; // Short timed user interface action
pwm_count_cooler += COOLER_PWM_STEP; pwm_count_cooler += COOLER_PWM_STEP;
pwm_count_heater += HEATER_PWM_STEP; pwm_count_heater += HEATER_PWM_STEP;
#if FEATURE_WATCHDOG
if(HAL::wdPinged) {
wdt_reset();
HAL::wdPinged = false;
}
#endif
} }
#if USE_ADVANCE #if USE_ADVANCE
@ -1160,8 +1196,6 @@ ISR(USART_UDRE_vect)
{ {
// There is more data in the output buffer. Send the next byte // There is more data in the output buffer. Send the next byte
uint8_t c = tx_buffer.buffer[tx_buffer.tail]; uint8_t c = tx_buffer.buffer[tx_buffer.tail];
tx_buffer.tail = (tx_buffer.tail + 1) & SERIAL_TX_BUFFER_MASK;
#if defined(UDR0) #if defined(UDR0)
UDR0 = c; UDR0 = c;
#elif defined(UDR) #elif defined(UDR)
@ -1169,6 +1203,7 @@ ISR(USART_UDRE_vect)
#else #else
#error UDR not defined #error UDR not defined
#endif #endif
tx_buffer.tail = (tx_buffer.tail + 1) & SERIAL_TX_BUFFER_MASK;
} }
} }
#endif #endif
@ -1403,9 +1438,9 @@ RFHardwareSerial::write(uint8_t c)
// If the output buffer is full, there's nothing for it other than to // If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit // 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 #if defined(BLUETOOTH_SERIAL) && BLUETOOTH_SERIAL > 0
while (i == txx_buffer_tail) ; while (i == txx_buffer_tail) {}
#endif #endif
_tx_buffer->buffer[_tx_buffer->head] = c; _tx_buffer->buffer[_tx_buffer->head] = c;
_tx_buffer->head = i; _tx_buffer->head = i;
@ -1433,5 +1468,3 @@ RFHardwareSerial RFSerial(&rx_buffer, &tx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UC
#endif #endif

View file

@ -70,7 +70,9 @@ All known arduino boards use 64. This value is needed for the extruder timing. *
#endif #endif
#include <inttypes.h> #include <inttypes.h>
#include "Print.h" #include "Print.h"
#ifdef EXTERNALSERIAL
#define SERIAL_RX_BUFFER_SIZE 128
#endif
#if defined(ARDUINO) && ARDUINO >= 100 #if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h" #include "Arduino.h"
#else #else
@ -132,7 +134,7 @@ public:
#define I2C_WRITE 0 #define I2C_WRITE 0
#if NONLINEAR_SYSTEM #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. // leave some margin for all the extra transformations. So we keep inside clean timings.
#define LIMIT_INTERVAL ((F_CPU/30000)+1) #define LIMIT_INTERVAL ((F_CPU/30000)+1)
#else #else
@ -175,8 +177,15 @@ typedef uint8_t ufast8_t;
#define SERIAL_BUFFER_SIZE 128 #define SERIAL_BUFFER_SIZE 128
#define SERIAL_BUFFER_MASK 127 #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_SIZE 64
#define SERIAL_TX_BUFFER_MASK 63 #define SERIAL_TX_BUFFER_MASK 63
#endif
struct ring_buffer struct ring_buffer
{ {
@ -253,6 +262,9 @@ extern RFHardwareSerial RFSerial;
class HAL class HAL
{ {
public: public:
#if FEATURE_WATCHDOG
static bool wdPinged;
#endif
HAL(); HAL();
virtual ~HAL(); virtual ~HAL();
static inline void hwSetup(void) static inline void hwSetup(void)
@ -601,7 +613,7 @@ public:
SET_OUTPUT(SDSSORIG); SET_OUTPUT(SDSSORIG);
#endif #endif
// set SS high - may be chip select for another SPI device // 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); WRITE(SDSS, HIGH);
#endif // SET_SPI_SS_HIGH #endif // SET_SPI_SS_HIGH
#endif #endif
@ -711,7 +723,7 @@ public:
inline static void pingWatchdog() inline static void pingWatchdog()
{ {
#if FEATURE_WATCHDOG #if FEATURE_WATCHDOG
wdt_reset(); wdPinged = true;
#endif #endif
}; };
inline static float maxExtruderTimerFrequency() inline static float maxExtruderTimerFrequency()
@ -756,5 +768,3 @@ private:
#define PWM_OCIE OCIE0B #define PWM_OCIE OCIE0B
//#endif //#endif
#endif // HAL_H #endif // HAL_H

File diff suppressed because it is too large Load diff

View file

@ -94,6 +94,7 @@ union wizardVar
#define PRINTER_FLAG2_DEBUG_JAM 16 #define PRINTER_FLAG2_DEBUG_JAM 16
#define PRINTER_FLAG2_JAMCONTROL_DISABLED 32 #define PRINTER_FLAG2_JAMCONTROL_DISABLED 32
#define PRINTER_FLAG2_HOMING 64 #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) // List of possible interrupt events (1-255 allowed)
#define PRINTER_INTERRUPT_EVENT_JAM_DETECTED 1 #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 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_STEPS (Printer::zMaxSteps-Printer::zMinSteps+1000)
#define HOME_DISTANCE_MM (HOME_DISTANCE_STEPS * invAxisStepsPerMM[Z_AXIS]) #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 towerAMaxSteps Printer::xMaxSteps
#define towerBMaxSteps Printer::yMaxSteps #define towerBMaxSteps Printer::yMaxSteps
#define towerCMaxSteps Printer::zMaxSteps #define towerCMaxSteps Printer::zMaxSteps
@ -126,18 +127,27 @@ public:
int32_t correct(int32_t x, int32_t y, int32_t z) const; int32_t correct(int32_t x, int32_t y, int32_t z) const;
void updateDerived(); void updateDerived();
void reportStatus(); void reportStatus();
bool isEnabled() {return enabled;}
int32_t zMaxSteps() {return zEnd;}
void set(float x,float y,float z);
void showMatrix();
void resetCorrection();
private: private:
INLINE int matrixIndex(fast8_t x, fast8_t y) const; int matrixIndex(fast8_t x, fast8_t y) const;
INLINE int32_t getMatrix(int index) const; int32_t getMatrix(int index) const;
INLINE void setMatrix(int32_t val, int index); void setMatrix(int32_t val, int index);
bool isCorner(fast8_t i, fast8_t j) const; 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; 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 extrapolateCorner(fast8_t x, fast8_t y, fast8_t dx, fast8_t dy);
void extrapolateCorners(); void extrapolateCorners();
void resetCorrection();
// attributes // attributes
#if DRIVE_SYSTEM == DELTA
int32_t step; int32_t step;
int32_t radiusCorrectionSteps; int32_t radiusCorrectionSteps;
#else
int32_t xCorrectionSteps,xOffsetSteps;
int32_t yCorrectionSteps,yOffsetSteps;
#endif
int32_t zStart,zEnd; int32_t zStart,zEnd;
#if !DISTORTION_PERMANENT #if !DISTORTION_PERMANENT
int32_t matrix[DISTORTION_CORRECTION_POINTS * DISTORTION_CORRECTION_POINTS]; int32_t matrix[DISTORTION_CORRECTION_POINTS * DISTORTION_CORRECTION_POINTS];
@ -167,9 +177,11 @@ private:
class Endstops { class Endstops {
static flag8_t lastState; static flag8_t lastState;
static flag8_t lastRead; static flag8_t lastRead;
static flag8_t accumulator;
#ifdef EXTENDED_ENDSTOPS #ifdef EXTENDED_ENDSTOPS
static flag8_t lastState2; static flag8_t lastState2;
static flag8_t lastRead2; static flag8_t lastRead2;
static flag8_t accumulator2;
#endif #endif
public: public:
static void update(); static void update();
@ -177,6 +189,18 @@ public:
static INLINE bool anyXYZMax() { static INLINE bool anyXYZMax() {
return (lastState & (ENDSTOP_X_MAX_ID|ENDSTOP_Z_MAX_ID|ENDSTOP_Z_MAX_ID)) != 0; 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() { static INLINE bool xMin() {
#if (X_MIN_PIN > -1) && MIN_HARDWARE_ENDSTOP_X #if (X_MIN_PIN > -1) && MIN_HARDWARE_ENDSTOP_X
return (lastState & ENDSTOP_X_MIN_ID) != 0; 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 class Printer
{ {
static uint8_t debugLevel;
public: public:
#if USE_ADVANCE #if USE_ADVANCE
static volatile int extruderStepsNeeded; ///< This many extruder steps are still needed, <0 = reverse steps needed. 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 uint8_t extruderAccelerateDelay; ///< delay between 2 speec increases
static int advanceStepsSet; static int advanceStepsSet;
#if ENABLE_QUADRATIC_ADVANCE #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 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 unitIsInches;
static uint8_t mode;
static uint8_t debugLevel; 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 flag0,flag1; // 1 = stepper disabled, 2 = use external extruder interrupt, 4 = temp Sensor defect, 8 = homed
static uint8_t flag2; static uint8_t flag2;
static uint8_t stepsPerTimerCall; static fast8_t stepsPerTimerCall;
static uint32_t interval; ///< Last step duration in ticks. static uint32_t interval; ///< Last step duration in ticks.
static uint32_t timer; ///< used for acceleration/deceleration timing static uint32_t timer; ///< used for acceleration/deceleration timing
static uint32_t stepNumber; ///< Step number in current move. static uint32_t stepNumber; ///< Step number in current move.
@ -293,6 +331,8 @@ public:
static int16_t travelMovesPerSecond; static int16_t travelMovesPerSecond;
static int16_t printMovesPerSecond; static int16_t printMovesPerSecond;
static float radius0; static float radius0;
#else
static int32_t zCorrectionStepsIncluded;
#endif #endif
#if FEATURE_Z_PROBE || MAX_HARDWARE_ENDSTOP_Z || NONLINEAR_SYSTEM #if FEATURE_Z_PROBE || MAX_HARDWARE_ENDSTOP_Z || NONLINEAR_SYSTEM
static int32_t stepsRemainingAtZHit; static int32_t stepsRemainingAtZHit;
@ -301,7 +341,7 @@ public:
static int32_t stepsRemainingAtXHit; static int32_t stepsRemainingAtXHit;
static int32_t stepsRemainingAtYHit; static int32_t stepsRemainingAtYHit;
#endif #endif
#if SOFTWARE_LEVELING #ifdef SOFTWARE_LEVELING
static int32_t levelingP1[3]; static int32_t levelingP1[3];
static int32_t levelingP2[3]; static int32_t levelingP2[3];
static int32_t levelingP3[3]; static int32_t levelingP3[3];
@ -309,7 +349,11 @@ public:
#if FEATURE_AUTOLEVEL #if FEATURE_AUTOLEVEL
static float autolevelTransformation[9]; ///< Transformation matrix static float autolevelTransformation[9]; ///< Transformation matrix
#endif #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 minimumSpeed; ///< lowest allowed speed to keep integration error small
static float minimumZSpeed; ///< 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. static int32_t xMaxSteps; ///< For software endstops, limit of move in positive direction.
@ -343,9 +387,6 @@ public:
static float backlashY; static float backlashY;
static float backlashZ; static float backlashZ;
static uint8_t backlashDir; static uint8_t backlashDir;
#endif
#ifdef DEBUG_STEPCOUNT
static long totalStepsRemaining;
#endif #endif
static float memoryX; static float memoryX;
static float memoryY; static float memoryY;
@ -372,7 +413,7 @@ public:
if(highPriority || interruptEvent == 0) if(highPriority || interruptEvent == 0)
interruptEvent = evt; interruptEvent = evt;
} }
static void reportPrinterMode();
static INLINE void setMenuMode(uint8_t mode,bool on) static INLINE void setMenuMode(uint8_t mode,bool on)
{ {
if(on) if(on)
@ -385,7 +426,14 @@ public:
{ {
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() static INLINE bool debugEcho()
{ {
return ((debugLevel & 1) != 0); return ((debugLevel & 1) != 0);
@ -416,21 +464,23 @@ public:
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); 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. */ /** \brief Disable stepper motor for x direction. */
static INLINE void disableXStepper() static INLINE void disableXStepper()
{ {
@ -460,6 +510,9 @@ public:
#endif #endif
#if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1) #if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
WRITE(Z2_ENABLE_PIN, !Z_ENABLE_ON); WRITE(Z2_ENABLE_PIN, !Z_ENABLE_ON);
#endif
#if FEATURE_THREE_ZSTEPPER && (Z3_ENABLE_PIN > -1)
WRITE(Z3_ENABLE_PIN, !Z_ENABLE_ON);
#endif #endif
} }
@ -492,6 +545,9 @@ public:
#endif #endif
#if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1) #if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
WRITE(Z2_ENABLE_PIN, Z_ENABLE_ON); WRITE(Z2_ENABLE_PIN, Z_ENABLE_ON);
#endif
#if FEATURE_THREE_ZSTEPPER && (Z3_ENABLE_PIN > -1)
WRITE(Z3_ENABLE_PIN, Z_ENABLE_ON);
#endif #endif
} }
@ -537,6 +593,9 @@ public:
WRITE(Z_DIR_PIN, !INVERT_Z_DIR); WRITE(Z_DIR_PIN, !INVERT_Z_DIR);
#if FEATURE_TWO_ZSTEPPER #if FEATURE_TWO_ZSTEPPER
WRITE(Z2_DIR_PIN, !INVERT_Z_DIR); WRITE(Z2_DIR_PIN, !INVERT_Z_DIR);
#endif
#if FEATURE_THREE_ZSTEPPER
WRITE(Z3_DIR_PIN, !INVERT_Z_DIR);
#endif #endif
} }
else else
@ -544,6 +603,9 @@ public:
WRITE(Z_DIR_PIN, INVERT_Z_DIR); WRITE(Z_DIR_PIN, INVERT_Z_DIR);
#if FEATURE_TWO_ZSTEPPER #if FEATURE_TWO_ZSTEPPER
WRITE(Z2_DIR_PIN, INVERT_Z_DIR); WRITE(Z2_DIR_PIN, INVERT_Z_DIR);
#endif
#if FEATURE_THREE_ZSTEPPER
WRITE(Z3_DIR_PIN, INVERT_Z_DIR);
#endif #endif
} }
} }
@ -697,6 +759,15 @@ public:
{ {
flag2 = (b ? flag2 | PRINTER_FLAG2_HOMING : flag2 & ~PRINTER_FLAG2_HOMING); 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() static INLINE uint8_t isDebugJam()
{ {
@ -745,7 +816,7 @@ public:
{ {
flag0 &= ~PRINTER_FLAG0_STEPPER_DISABLED; flag0 &= ~PRINTER_FLAG0_STEPPER_DISABLED;
#if FAN_BOARD_PIN > -1 #if FAN_BOARD_PIN > -1
pwm_pos[NUM_EXTRUDER + 1] = 255; pwm_pos[PWM_BOARD_FAN] = 255;
#endif // FAN_BOARD_PIN #endif // FAN_BOARD_PIN
} }
static INLINE bool isAnyTempsensorDefect() static INLINE bool isAnyTempsensorDefect()
@ -786,33 +857,33 @@ public:
#if (GANTRY) #if (GANTRY)
if(motorX <= -2) if(motorX <= -2)
{ {
WRITE(X_STEP_PIN,HIGH); WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
#if FEATURE_TWO_XSTEPPER #if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH); WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
#endif #endif
motorX += 2; motorX += 2;
} }
else if(motorX >= 2) else if(motorX >= 2)
{ {
WRITE(X_STEP_PIN,HIGH); WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
#if FEATURE_TWO_XSTEPPER #if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH); WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
#endif #endif
motorX -= 2; motorX -= 2;
} }
if(motorYorZ <= -2) if(motorYorZ <= -2)
{ {
WRITE(Y_STEP_PIN,HIGH); WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
#if FEATURE_TWO_YSTEPPER #if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,HIGH); WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
#endif #endif
motorYorZ += 2; motorYorZ += 2;
} }
else if(motorYorZ >= 2) else if(motorYorZ >= 2)
{ {
WRITE(Y_STEP_PIN,HIGH); WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
#if FEATURE_TWO_YSTEPPER #if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,HIGH); WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
#endif #endif
motorYorZ -= 2; motorYorZ -= 2;
} }
@ -823,53 +894,86 @@ public:
#if (GANTRY) #if (GANTRY)
if(motorX <= -2) if(motorX <= -2)
{ {
WRITE(X_STEP_PIN,HIGH); WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
#if FEATURE_TWO_XSTEPPER #if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH); WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
#endif #endif
motorX += 2; motorX += 2;
} }
else if(motorX >= 2) else if(motorX >= 2)
{ {
WRITE(X_STEP_PIN,HIGH); WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
#if FEATURE_TWO_XSTEPPER #if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH); WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
#endif #endif
motorX -= 2; motorX -= 2;
} }
if(motorYorZ <= -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 //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 #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 #endif
motorYorZ += 2; motorYorZ += 2;
} }
else if(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 //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 #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 #endif
motorYorZ -= 2; 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 #endif
} }
static INLINE void endXYZSteps() static INLINE void endXYZSteps()
{ {
WRITE(X_STEP_PIN,LOW); WRITE(X_STEP_PIN,!START_STEP_WITH_HIGH);
#if FEATURE_TWO_XSTEPPER #if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,LOW); WRITE(X2_STEP_PIN,!START_STEP_WITH_HIGH);
#endif #endif
WRITE(Y_STEP_PIN,LOW); WRITE(Y_STEP_PIN,!START_STEP_WITH_HIGH);
#if FEATURE_TWO_YSTEPPER #if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,LOW); WRITE(Y2_STEP_PIN,!START_STEP_WITH_HIGH);
#endif #endif
WRITE(Z_STEP_PIN,LOW); WRITE(Z_STEP_PIN,!START_STEP_WITH_HIGH);
#if FEATURE_TWO_ZSTEPPER #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 #endif
} }
static INLINE speed_t updateStepsPerTimerCall(speed_t vbase) static INLINE speed_t updateStepsPerTimerCall(speed_t vbase)
@ -956,13 +1060,17 @@ public:
static void defaultLoopActions(); static void defaultLoopActions();
static uint8_t setDestinationStepsFromGCode(GCode *com); static uint8_t setDestinationStepsFromGCode(GCode *com);
static uint8_t moveTo(float x,float y,float z,float e,float f); 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 homeAxis(bool xaxis,bool yaxis,bool zaxis); /// Home axis
static void setOrigin(float xOff,float yOff,float zOff); static void setOrigin(float xOff,float yOff,float zOff);
static bool isPositionAllowed(float x,float y,float z); static bool isPositionAllowed(float x,float y,float z);
static INLINE int getFanSpeed() 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 #if NONLINEAR_SYSTEM
static INLINE void setDeltaPositions(long xaxis, long yaxis, long zaxis) static INLINE void setDeltaPositions(long xaxis, long yaxis, long zaxis)
@ -977,8 +1085,11 @@ public:
static float runZMaxProbe(); static float runZMaxProbe();
#endif #endif
#if FEATURE_Z_PROBE #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 float runZProbe(bool first,bool last,uint8_t repeat = Z_PROBE_REPETITIONS,bool runStartScript = true);
static void waitForZProbeStart(); static void waitForZProbeStart();
static float bendingCorrectionAt(float x,float y);
#endif #endif
// Moved outside FEATURE_Z_PROBE to allow auto-level functional test on // Moved outside FEATURE_Z_PROBE to allow auto-level functional test on
// system without Z-probe // system without Z-probe
@ -1011,6 +1122,9 @@ public:
static void showConfiguration(); static void showConfiguration();
static void setCaseLight(bool on); static void setCaseLight(bool on);
static void reportCaseLightStatus(); static void reportCaseLightStatus();
#if JSON_OUTPUT
static void showJSONStatus(int type);
#endif
private: private:
static void homeXAxis(); static void homeXAxis();
static void homeYAxis(); static void homeYAxis();
@ -1018,5 +1132,3 @@ private:
}; };
#endif // PRINTER_H_INCLUDED #endif // PRINTER_H_INCLUDED

View file

@ -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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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 &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
</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="&lt;{~None~}&gt;" />
</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="&lt;{~None~}&gt;" />
</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

View file

@ -23,15 +23,16 @@
#define _REPETIER_H #define _REPETIER_H
#include <math.h> #include <math.h>
#include <stdint.h>
#define REPETIER_VERSION "0.92.3" #define REPETIER_VERSION "0.92.8"
// ########################################################################################## // ##########################################################################################
// ## Debug configuration ## // ## Debug configuration ##
// ########################################################################################## // ##########################################################################################
// These are run time sqitchable debug flags // These are run time sqitchable debug flags
enum debugFlags {DEB_ECHO = 0x1, DEB_INFO = 0x2, DEB_ERROR = 0x4,DEB_DRYRUN = 0x8, 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! */ /** Uncomment, to see detailed data for every move. Only for debugging purposes! */
//#define DEBUG_QUEUE_MOVE //#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 //#define DEBUG_SEGMENT_LENGTH
// Find the maximum real jerk during a print // Find the maximum real jerk during a print
//#define DEBUG_REAL_JERK //#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 // Uncomment the following line to enable debugging. You can better control debugging below the following line
//#define DEBUG //#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_SPARKLCD 19
#define CONTROLLER_BAM_DICE_DUE 20 #define CONTROLLER_BAM_DICE_DUE 20
#define CONTROLLER_VIKI2 21 #define CONTROLLER_VIKI2 21
#define CONTROLLER_LCD_MP_PHARAOH_DUE 22
#define CONTROLLER_SPARKLCD_ADAPTER 23
#define CONTROLLER_FELIX_DUE 405 #define CONTROLLER_FELIX_DUE 405
//direction flags //direction flags
@ -175,8 +180,26 @@ usage or for seraching for memory induced errors. Switch it off for production,
// add pid control // add pid control
#define TEMP_PID 1 #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" #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 #if FEATURE_Z_PROBE && Z_PROBE_PIN < 0
#error You need to define Z_PROBE_PIN to use z probe! #error You need to define Z_PROBE_PIN to use z probe!
#endif #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_MAX_MILLIS 60
#define SPEED_MAGNIFICATION 100.0f #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). /** \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) #define ROD_RADIUS (PRINTER_RADIUS-END_EFFECTOR_HORIZONTAL_OFFSET-CARRIAGE_HORIZONTAL_OFFSET)
#endif
#ifndef UI_SPEEDDEPENDENT_POSITIONING #ifndef UI_SPEEDDEPENDENT_POSITIONING
#define UI_SPEEDDEPENDENT_POSITIONING true #define UI_SPEEDDEPENDENT_POSITIONING true
@ -276,6 +301,18 @@ usage or for seraching for memory induced errors. Switch it off for production,
#define SHARED_COOLER 0 #define SHARED_COOLER 0
#endif #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 // Test for shared coolers between extruders and mainboard
#if EXT0_EXTRUDER_COOLER_PIN > -1 && EXT0_EXTRUDER_COOLER_PIN == FAN_BOARD_PIN #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
@ -293,6 +330,9 @@ usage or for seraching for memory induced errors. Switch it off for production,
#else #else
#define EXTRUDER_JAM_CONTROL 0 #define EXTRUDER_JAM_CONTROL 0
#endif #endif
#ifndef JAM_METHOD
#define JAM_METHOD 1
#endif
#if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE < 101 #if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE < 101
#define EXT0_ANALOG_INPUTS 1 #define EXT0_ANALOG_INPUTS 1
@ -370,12 +410,22 @@ usage or for seraching for memory induced errors. Switch it off for production,
#define BED_ANALOG_INPUTS 1 #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_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 #define BED_ANALOG_CHANNEL ACCOMMA5 HEATED_BED_SENSOR_PIN
#undef KOMMA #undef BEKOMMA
#define KOMMA , #define BED_KOMMA ,
#else #else
#define BED_ANALOG_INPUTS 0 #define BED_ANALOG_INPUTS 0
#define BED_SENSOR_INDEX HEATED_BED_SENSOR_PIN #define BED_SENSOR_INDEX HEATED_BED_SENSOR_PIN
#define BED_ANALOG_CHANNEL #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 #endif
#ifndef DEBUG_FREE_MEMORY #ifndef DEBUG_FREE_MEMORY
@ -385,10 +435,10 @@ usage or for seraching for memory induced errors. Switch it off for production,
#endif #endif
/** \brief number of analog input signals. Normally 1 for each temperature sensor */ /** \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) #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 #if ANALOG_INPUTS > 0
/** Channels are the MUX-part of ADMUX register */ /** 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 #endif
#define MENU_MODE_SD_MOUNTED 1 #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_FULL_PID 32
#define MENU_MODE_DEADTIME 64 #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 "HAL.h"
#include "gcode.h" #include "gcode.h"
#define MAX_VFAT_ENTRIES (2) #define MAX_VFAT_ENTRIES (2)
@ -412,7 +478,7 @@ usage or for seraching for memory induced errors. Switch it off for production,
#if UI_DISPLAY_TYPE != DISPLAY_U8G #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)) #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" #error You cannot use DISPLAY_D5_PIN, DISPLAY_D6_PIN or DISPLAY_D7_PIN for "User Keys" with character LCD display
#endif #endif
#endif #endif
@ -442,65 +508,271 @@ usage or for seraching for memory induced errors. Switch it off for production,
#undef min #undef min
#undef max #undef max
class RMath { class RMath
{
public: public:
static inline float min(float a,float b) { static inline float min(float a,float b)
{
if(a < b) return a; if(a < b) return a;
return b; return b;
} }
static inline float max(float a,float b) { static inline float max(float a,float b)
{
if(a < b) return b; if(a < b) return b;
return a; return a;
} }
static inline int32_t min(int32_t a,int32_t b) { static inline int32_t min(int32_t a,int32_t b)
{
if(a < b) return a; if(a < b) return a;
return b; return b;
} }
static inline int32_t min(int32_t a,int32_t b, int32_t c) { static inline int32_t min(int32_t a,int32_t b, int32_t c)
{
if(a < b) return a < c ? a : c; if(a < b) return a < c ? a : c;
return b<c ? b : c; return b<c ? b : c;
} }
static inline float min(float a,float b, float c) { static inline float min(float a,float b, float c)
{
if(a < b) return a < c ? a : c; if(a < b) return a < c ? a : c;
return b < c ? b : c; return b < c ? b : c;
} }
static inline int32_t max(int32_t a,int32_t b) { static inline int32_t max(int32_t a,int32_t b)
{
if(a < b) return b; if(a < b) return b;
return a; return a;
} }
static inline int min(int a,int b) { static inline int min(int a,int b)
{
if(a < b) return a; if(a < b) return a;
return b; return b;
} }
static inline uint16_t min(uint16_t a,uint16_t b) { static inline uint16_t min(uint16_t a,uint16_t b)
{
if(a < b) return a; if(a < b) return a;
return b; return b;
} }
static inline int16_t max(int16_t a,int16_t b) { static inline int16_t max(int16_t a,int16_t b)
{
if(a < b) return b; if(a < b) return b;
return a; return a;
} }
static inline uint16_t max(uint16_t a,uint16_t b) { static inline uint16_t max(uint16_t a,uint16_t b)
{
if(a < b) return b; if(a < b) return b;
return a; return a;
} }
static inline unsigned long absLong(long a) {return a >= 0 ? a : -a;} static inline unsigned long absLong(long a)
static inline int32_t sqr(int32_t a) {return a*a;} {
static inline uint32_t sqr(uint32_t a) {return a*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 #ifdef SUPPORT_64_BIT_MATH
static inline int64_t sqr(int64_t a) {return a*a;} static inline int64_t sqr(int64_t a)
static inline uint64_t sqr(uint64_t a) {return a*a;} {
return a*a;
}
static inline uint64_t sqr(uint64_t a)
{
return a*a;
}
#endif #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 const uint8 osAnalogInputChannels[] PROGMEM;
//extern uint8 osAnalogInputCounter[ANALOG_INPUTS]; //extern uint8 osAnalogInputCounter[ANALOG_INPUTS];
//extern uint osAnalogInputBuildup[ANALOG_INPUTS]; //extern uint osAnalogInputBuildup[ANALOG_INPUTS];
//extern uint8 osAnalogInputPos; // Current sampling position //extern uint8 osAnalogInputPos; // Current sampling position
#if ANALOG_INPUTS > 0
extern volatile uint osAnalogInputValues[ANALOG_INPUTS]; 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 USE_ADVANCE
#if ENABLE_QUADRATIC_ADVANCE #if ENABLE_QUADRATIC_ADVANCE
extern int maxadv; extern int maxadv;
@ -542,10 +814,6 @@ extern void microstepInit();
#include "Printer.h" #include "Printer.h"
#include "motion.h" #include "motion.h"
extern long baudrate; 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" #include "HAL.h"
@ -554,8 +822,12 @@ extern unsigned int counterPeriodical;
extern volatile uint8_t executePeriodical; extern volatile uint8_t executePeriodical;
extern uint8_t counter250ms; extern uint8_t counter250ms;
extern void writeMonitor(); extern void writeMonitor();
#if FEATURE_FAN_CONTROL
extern uint8_t fanKickstart; extern uint8_t fanKickstart;
#endif
#if FEATURE_FAN2_CONTROL
extern uint8_t fan2Kickstart;
#endif
#if SDSUPPORT #if SDSUPPORT
extern char tempLongFilename[LONG_FILENAME_LENGTH+1]; extern char tempLongFilename[LONG_FILENAME_LENGTH+1];
@ -564,7 +836,8 @@ extern char fullName[LONG_FILENAME_LENGTH*SD_MAX_FOLDER_DEPTH+SD_MAX_FOLDER_DEPT
#include "SdFat.h" #include "SdFat.h"
enum LsAction {LS_SerialPrint,LS_Count,LS_GetFilename}; enum LsAction {LS_SerialPrint,LS_Count,LS_GetFilename};
class SDCard { class SDCard
{
public: public:
SdFat fat; SdFat fat;
//Sd2Card card; // ~14 Byte //Sd2Card card; // ~14 Byte
@ -572,6 +845,9 @@ public:
//SdFile root; //SdFile root;
//SdFile dir[SD_MAX_FOLDER_DEPTH+1]; //SdFile dir[SD_MAX_FOLDER_DEPTH+1];
SdFile file; SdFile file;
#if JSON_OUTPUT
GCodeFileInfo fileInfo;
#endif
uint32_t filesize; uint32_t filesize;
uint32_t sdpos; uint32_t sdpos;
//char fullName[13*SD_MAX_FOLDER_DEPTH+13]; // Fill name //char fullName[13*SD_MAX_FOLDER_DEPTH+13]; // Fill name
@ -593,9 +869,19 @@ public:
void pausePrint(bool intern = false); void pausePrint(bool intern = false);
void continuePrint(bool intern = false); void continuePrint(bool intern = false);
void stopPrint(); void stopPrint();
inline void setIndex(uint32_t newpos) { if(!sdactive) return; sdpos = newpos;file.seekSet(sdpos);} inline void setIndex(uint32_t newpos)
{
if(!sdactive) return;
sdpos = newpos;
file.seekSet(sdpos);
}
void printStatus(); void printStatus();
void ls(); 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 startWrite(char *filename);
void deleteFile(char *filename); void deleteFile(char *filename);
void finishWrite(); void finishWrite();
@ -652,5 +938,3 @@ extern int debugWaitLoop;
#endif #endif
#endif #endif

View file

@ -39,7 +39,7 @@ Implemented Codes
- G0 -> G1 - G0 -> G1
- G1 - Coordinated Movement X Y Z E, S1 disables boundary check, S0 enables it - G1 - Coordinated Movement X Y Z E, S1 disables boundary check, S0 enables it
- G4 - Dwell S<seconds> or P<milliseconds> - 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 - G11 S<1 = long retract, 0 = short retract = default> = Undo retraction according to stored setting
- G20 - Units for G0/G1 are inches. - G20 - Units for G0/G1 are inches.
- G21 - Units for G0/G1 are mm. - 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 - 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 - 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 - 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 - G90 - Use absolute coordinates
- G91 - Use relative 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 - 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. - 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 RepRap M Codes
- M104 - Set extruder target temp - M104 - Set extruder target temp
- M105 - Read current temp - M105 - Read current temp
- M106 - Fan on - M106 S<speed> P<fan> - Fan on speed = 0..255, P = 0 or 1, 0 is default and can be omitted
- M107 - Fan off - 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. - M109 - Wait for extruder current temp to reach target temp.
- M114 - Display current position - M114 - Display current position
@ -109,6 +111,7 @@ Custom M Codes
- M209 S<0/1> - Enable/disable autoretraction - M209 S<0/1> - Enable/disable autoretraction
- M220 S<Feedrate multiplier in percent> - Increase/decrease given feedrate - M220 S<Feedrate multiplier in percent> - Increase/decrease given feedrate
- M221 S<Extrusion flow multiplier in percent> - Increase/decrease given flow rate - 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 - M231 S<OPS_MODE> X<Min_Distance> Y<Retract> Z<Backlash> F<ReatrctMove> - Set OPS parameter
- M232 - Read and reset max. advance values - 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 - 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. - M400 - Wait until move buffers empty.
- M401 - Store x, y and z position. - 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. - 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 - M500 Store settings to EEPROM
- M501 Load settings from EEPROM - M501 Load settings from EEPROM
- M502 Reset settings to the one in configuration.h. Does not store values in EEPROM! - M502 Reset settings to the one in configuration.h. Does not store values in EEPROM!
@ -163,5 +171,3 @@ void loop()

View file

@ -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>

View file

@ -41,25 +41,26 @@ void SDCard::automount()
#if SDCARDDETECT > -1 #if SDCARDDETECT > -1
if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED) if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED)
{ {
if(sdactive) // Card removed if(sdactive || sdmode == 100) // Card removed
{ {
Com::printFLN(PSTR("SD card removed")); Com::printFLN(PSTR("SD card removed"));
#if UI_DISPLAY_TYPE != NO_DISPLAY #if UI_DISPLAY_TYPE != NO_DISPLAY
uid.executeAction(UI_ACTION_TOP_MENU, true); uid.executeAction(UI_ACTION_TOP_MENU, true);
#endif #endif
unmount(); unmount();
UI_STATUS(UI_TEXT_SD_REMOVED); UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_SD_REMOVED_ID));
} }
} }
else else
{ {
if(!sdactive) if(!sdactive && sdmode != 100)
{ {
UI_STATUS(UI_TEXT_SD_INSERTED); UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_SD_INSERTED_ID));
Com::printFLN(PSTR("SD card inserted")); // Not translateable or host will not understand signal mount();
initsd(); 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 UI_DISPLAY_TYPE != NO_DISPLAY
if(sdactive) { if(sdactive && !uid.isWizardActive()) { // Wizards have priority
Printer::setAutomount(true); Printer::setAutomount(true);
uid.executeAction(UI_ACTION_SD_PRINT + UI_ACTION_TOPMENU, true); uid.executeAction(UI_ACTION_SD_PRINT + UI_ACTION_TOPMENU, true);
} }
@ -77,11 +78,13 @@ void SDCard::initsd()
if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED) if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED)
return; return;
#endif #endif
HAL::delayMilliseconds(50); // wait for stabilization of contacts, bootup ...
/*if(dir[0].isOpen()) /*if(dir[0].isOpen())
dir[0].close();*/ dir[0].close();*/
if(!fat.begin(SDSS, SPI_FULL_SPEED)) if(!fat.begin(SDSS, SPI_FULL_SPEED))
{ {
Com::printFLN(Com::tSDInitFail); Com::printFLN(Com::tSDInitFail);
sdmode = 100; // prevent automount loop!
return; return;
} }
sdactive = true; sdactive = true;
@ -180,22 +183,26 @@ void SDCard::writeCommand(GCode *code)
uint8_t buf[100]; uint8_t buf[100];
uint8_t p = 2; uint8_t p = 2;
file.writeError = false; file.writeError = false;
int params = 128 | (code->params & ~1); uint16_t params = 128 | (code->params & ~1);
*(int*)buf = params; memcopy2(buf,&params);
//*(int*)buf = params;
if(code->isV2()) // Read G,M as 16 bit value if(code->isV2()) // Read G,M as 16 bit value
{ {
*(int*)&buf[p] = code->params2; memcopy2(&buf[p],&code->params2);
//*(int*)&buf[p] = code->params2;
p += 2; p += 2;
if(code->hasString()) if(code->hasString())
buf[p++] = strlen(code->text); buf[p++] = strlen(code->text);
if(code->hasM()) if(code->hasM())
{ {
*(int*)&buf[p] = code->M; memcopy2(&buf[p],&code->M);
//*(int*)&buf[p] = code->M;
p += 2; p += 2;
} }
if(code->hasG()) if(code->hasG())
{ {
*(int*)&buf[p]= code->G; memcopy2(&buf[p],&code->G);
//*(int*)&buf[p]= code->G;
p += 2; p += 2;
} }
} }
@ -212,27 +219,32 @@ void SDCard::writeCommand(GCode *code)
} }
if(code->hasX()) if(code->hasX())
{ {
*(float*)&buf[p] = code->X; memcopy4(&buf[p],&code->X);
//*(float*)&buf[p] = code->X;
p += 4; p += 4;
} }
if(code->hasY()) if(code->hasY())
{ {
*(float*)&buf[p] = code->Y; memcopy4(&buf[p],&code->Y);
//*(float*)&buf[p] = code->Y;
p += 4; p += 4;
} }
if(code->hasZ()) if(code->hasZ())
{ {
*(float*)&buf[p] = code->Z; memcopy4(&buf[p],&code->Z);
//*(float*)&buf[p] = code->Z;
p += 4; p += 4;
} }
if(code->hasE()) if(code->hasE())
{ {
*(float*)&buf[p] = code->E; memcopy4(&buf[p],&code->E);
//*(float*)&buf[p] = code->E;
p += 4; p += 4;
} }
if(code->hasF()) if(code->hasF())
{ {
*(float*)&buf[p] = code->F; memcopy4(&buf[p],&code->F);
//*(float*)&buf[p] = code->F;
p += 4; p += 4;
} }
if(code->hasT()) if(code->hasT())
@ -241,22 +253,80 @@ void SDCard::writeCommand(GCode *code)
} }
if(code->hasS()) if(code->hasS())
{ {
*(long int*)&buf[p] = code->S; memcopy4(&buf[p],&code->S);
//*(int32_t*)&buf[p] = code->S;
p += 4; p += 4;
} }
if(code->hasP()) if(code->hasP())
{ {
*(long int*)&buf[p] = code->P; memcopy4(&buf[p],&code->P);
//*(int32_t*)&buf[p] = code->P;
p += 4; p += 4;
} }
if(code->hasI()) if(code->hasI())
{ {
*(float*)&buf[p] = code->I; memcopy4(&buf[p],&code->I);
//*(float*)&buf[p] = code->I;
p += 4; p += 4;
} }
if(code->hasJ()) if(code->hasJ())
{ {
*(float*)&buf[p] = code->J; 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; p += 4;
} }
if(code->hasString()) // read 16 uint8_t into string if(code->hasString()) // read 16 uint8_t into string
@ -289,6 +359,11 @@ void SDCard::writeCommand(GCode *code)
} }
buf[p++] = sum1; buf[p++] = sum1;
buf[p++] = sum2; 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) if(params == 128)
{ {
Com::printErrorFLN(Com::tAPIDFinished); Com::printErrorFLN(Com::tAPIDFinished);
@ -352,11 +427,97 @@ void SDCard::ls()
Com::printFLN(Com::tEndFileList); 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) bool SDCard::selectFile(const char *filename, bool silent)
{ {
SdBaseFile parent; SdBaseFile parent;
const char *oldP = filename; const char *oldP = filename;
boolean bFound;
if(!sdactive) return false; if(!sdactive) return false;
sdmode = 0; sdmode = 0;
@ -376,6 +537,9 @@ bool SDCard::selectFile(const char *filename, bool silent)
Com::printF(Com::tFileOpened, oldP); Com::printF(Com::tFileOpened, oldP);
Com::printFLN(Com::tSpaceSizeColon,file.fileSize()); Com::printFLN(Com::tSpaceSizeColon,file.fileSize());
} }
#if JSON_OUTPUT
fileInfo.init(file);
#endif
sdpos = 0; sdpos = 0;
filesize = file.fileSize(); filesize = file.fileSize();
Com::printFLN(Com::tFileSelected); Com::printFLN(Com::tFileSelected);
@ -414,7 +578,7 @@ void SDCard::startWrite(char *filename)
} }
else else
{ {
UI_STATUS(UI_TEXT_UPLOADING); UI_STATUS_F(Com::translatedF(UI_TEXT_UPLOADING_ID));
savetosd = true; savetosd = true;
Com::printFLN(Com::tWritingToFile,filename); Com::printFLN(Com::tWritingToFile,filename);
} }
@ -480,5 +644,3 @@ void SDCard::writeToFile()
#endif #endif

View file

@ -32,11 +32,6 @@ extern int8_t RFstrnicmp(const char* s1, const char* s2, size_t n);
//#define GLENN_DEBUG //#define GLENN_DEBUG
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
static void pstrPrint(FSTRINGPARAM(str)) {
Com::printF(str);
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static void pstrPrintln(FSTRINGPARAM(str)) { static void pstrPrintln(FSTRINGPARAM(str)) {
Com::printFLN(str); Com::printFLN(str);
@ -652,11 +647,12 @@ void SdBaseFile::ls(uint8_t flags) {
ls(flags, 0); 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; dir_t *p = NULL;
uint8_t cnt=0; //uint8_t cnt=0;
char *oldpathend = pathend; //char *oldpathend = pathend;
bool firstFile = true;
parent->rewind(); parent->rewind();
@ -665,21 +661,29 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
HAL::pingWatchdog(); HAL::pingWatchdog();
if (! (DIR_IS_FILE(p) || DIR_IS_SUBDIR(p))) continue; if (! (DIR_IS_FILE(p) || DIR_IS_SUBDIR(p))) continue;
if (strcmp(tempLongFilename, "..") == 0) continue; if (strcmp(tempLongFilename, "..") == 0) continue;
if( DIR_IS_SUBDIR(p)) 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) continue; // can't go deeper
if(level<SD_MAX_FOLDER_DEPTH) if (level < SD_MAX_FOLDER_DEPTH && findFilename == NULL) {
{ if (level && !isJson) {
if (findFilename == NULL)
{
if(level)
{
Com::print(fullName); Com::print(fullName);
Com::printF(Com::tSlash); 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::print(tempLongFilename);
Com::printFLN(Com::tSlash); // End with / to mark it as directory entry, so we can see empty directories. 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; SdBaseFile next;
char *tmp; char *tmp;
@ -689,9 +693,9 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
strcat(fullName, tempLongFilename); strcat(fullName, tempLongFilename);
uint16_t index = (parent->curPosition()-31) >> 5; uint16_t index = (parent->curPosition()-31) >> 5;
if(next.open(parent, index, O_READ)) if(!isJson && next.open(parent, index, O_READ))
{ {
if (next.lsRecursive(&next,level+1, findFilename, pParentFound)) if (next.lsRecursive(&next,level+1, findFilename, pParentFound,false))
return true; return true;
} }
parent->seekSet(32 * (index + 1)); parent->seekSet(32 * (index + 1));
@ -721,11 +725,21 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
} }
else else
{ {
if(level) if(level && !isJson)
{ {
Com::print(fullName); Com::print(fullName);
Com::printF(Com::tSlash); Com::printF(Com::tSlash);
} }
#if JSON_OUTPUT
if (isJson) {
if (!firstFile) Com::printF(Com::tComma);
Com::print('"');
SDCard::printEscapeChars(tempLongFilename);
Com::print('"');
firstFile = false;
} else
#endif
{
Com::print(tempLongFilename); Com::print(tempLongFilename);
#if SD_EXTENDED_DIR #if SD_EXTENDED_DIR
Com::printF(Com::tSpace, (long) p->fileSize); Com::printF(Com::tSpace, (long) p->fileSize);
@ -734,6 +748,7 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
} }
} }
} }
}
return false; return false;
} }
@ -755,19 +770,29 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
*/ */
void SdBaseFile::ls(uint8_t flags, uint8_t indent) { void SdBaseFile::ls(uint8_t flags, uint8_t indent) {
SdBaseFile parent; SdBaseFile parent;
rewind(); rewind();
*fullName = 0; *fullName = 0;
pathend = fullName; pathend = fullName;
parent = *this; parent = *this;
lsRecursive(&parent, 0, NULL, NULL); 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 // saves 32 bytes on stack for ls recursion
// return 0 - EOF, 1 - normal file, or 2 - directory // return 0 - EOF, 1 - normal file, or 2 - directory
int8_t SdBaseFile::lsPrintNext(uint8_t flags, uint8_t indent) { int8_t SdBaseFile::lsPrintNext(uint8_t flags, uint8_t indent) {
dir_t dir; dir_t dir;
uint8_t w = 0; //uint8_t w = 0;
while (1) { while (1) {
if (read(&dir, sizeof(dir)) != sizeof(dir)) return 0; if (read(&dir, sizeof(dir)) != sizeof(dir)) return 0;
if (dir.name[0] == DIR_NAME_FREE) 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); return mkdir(&newParent, dname);
} }
fail:
return false; return false;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -886,13 +909,13 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
if (!parent->isDir()) { if (!parent->isDir()) {
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; return false;
} }
// create a normal file // create a normal file
if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR, true)) { if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR, true)) {
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; return false;
} }
// make entry for '.' // 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] = ' '; for (uint8_t i = 1; i < 11; i++) d.name[i] = ' ';
if (write(&d, sizeof(dir_t)) < 0) if (write(&d, sizeof(dir_t)) < 0)
goto fail; return false;
sync(); sync();
// make entry for '..' // make entry for '..'
@ -921,18 +944,16 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
d.firstClusterHigh = parent->firstCluster_ >> 16; d.firstClusterHigh = parent->firstCluster_ >> 16;
} }
if (write(&d, sizeof(dir_t)) < 0) if (write(&d, sizeof(dir_t)) < 0)
goto fail; return false;
sync(); sync();
memset(&d, 0, sizeof(dir_t)); memset(&d, 0, sizeof(dir_t));
if (write(&d, sizeof(dir_t)) < 0) if (write(&d, sizeof(dir_t)) < 0)
goto fail; return false;
sync(); sync();
// fileSize_ = 0; // fileSize_ = 0;
type_ = FAT_FILE_TYPE_SUBDIR; type_ = FAT_FILE_TYPE_SUBDIR;
flags_ |= F_FILE_DIR_DIRTY; flags_ |= F_FILE_DIR_DIRTY;
return true; return true;
fail:
return false;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** Open a file in the current working directory. /** 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 *newParent, boolean bMakeDirs) {
SdBaseFile dir1, dir2; SdBaseFile dir1, dir2;
SdBaseFile *parent = dirFile; SdBaseFile *parent = dirFile;
dir_t *pEntry; //dir_t *pEntry;
SdBaseFile *sub = &dir1; SdBaseFile *sub = &dir1;
char *p; char *p;
boolean bFound; //boolean bFound;
#ifdef GLENN_DEBUG #ifdef GLENN_DEBUG
Commands::checkFreeMemory(); Commands::checkFreeMemory();
@ -1052,7 +1073,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
Commands::checkFreeMemory(); Commands::checkFreeMemory();
Commands::writeLowestFreeRAM(); Commands::writeLowestFreeRAM();
#endif #endif
bFound = false; //bFound = false;
if (!sub->open(parent, dname, O_READ, false)) if (!sub->open(parent, dname, O_READ, false))
{ {
if (!bMakeDirs) if (!bMakeDirs)
@ -1093,7 +1114,6 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const char* path, uint8_t oflag)
return open(&parent, dname, oflag, false); return open(&parent, dname, oflag, false);
} }
fail:
return false; 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 SdBaseFile::open(SdBaseFile* dirFile,const uint8_t *dname, uint8_t oflag, bool bDir) {
bool emptyFound = false; bool emptyFound = false;
uint8_t index = 0; uint8_t index = 0;
dir_t tempDir, *p; dir_t tempDir, *p = NULL;
const char *tempPtr; const char *tempPtr;
char newName[SHORT_FILENAME_LENGTH+2]; char newName[SHORT_FILENAME_LENGTH+2];
boolean bShortName = false; boolean bShortName = false;
int8_t cVFATNeeded = -1, wIndex, cVFATFoundCur; int8_t cVFATNeeded = -1, cVFATFoundCur;
uint32_t wIndexPos = 0; uint32_t wIndexPos = 0;
uint8_t cbFilename; uint8_t cbFilename;
char *Filename = (char *)dname; char *Filename = (char *)dname;
@ -1570,6 +1590,9 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
bool SdBaseFile::openRoot(SdVolume* vol) { bool SdBaseFile::openRoot(SdVolume* vol) {
// error if file is already open // error if file is already open
if (isOpen()) { if (isOpen()) {
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("Root already open"));
#endif
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -1587,6 +1610,10 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
} }
} else { } else {
// volume is not initialized, invalid, or FAT12 without support // 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; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -1603,6 +1630,9 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
return true; return true;
fail: fail:
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("SD open root dir failed"));
#endif
return false; 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) 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; int8_t cVFATFound = 0;
// if not a directory file or miss-positioned return an error // if not a directory file or miss-positioned return an error
if (!isDir()) return -1; 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)) if (DIR_IS_LONG_NAME(dir))
{ {
vfat_t *VFAT = (vfat_t*)dir; //vfat_t *VFAT = (vfat_t*)dir; // unused
cVFATFound++; cVFATFound++;
} }
else else
@ -3202,7 +3232,7 @@ uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
#if USE_SD_CRC #if USE_SD_CRC
// form message // 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 // add crc
d[5] = CRC7(d, 5); d[5] = CRC7(d, 5);
@ -3415,6 +3445,9 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
fail: fail:
chipSelectHigh(); chipSelectHigh();
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("SD card initalization failed"));
#endif
return false; return false;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -3469,7 +3502,7 @@ bool Sd2Card::readData(uint8_t* dst, size_t count) {
goto fail; goto fail;
} }
// transfer data // transfer data
if (status_ = spiRec(dst, count)) { if ((status_ = spiRec(dst, count))) {
error(SD_CARD_ERROR_SPI_DMA); error(SD_CARD_ERROR_SPI_DMA);
goto fail; goto fail;
} }
@ -4224,7 +4257,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
cacheStatus_ = 0; // cacheSync() will write block if true cacheStatus_ = 0; // cacheSync() will write block if true
cacheBlockNumber_ = 0XFFFFFFFF; cacheBlockNumber_ = 0XFFFFFFFF;
cacheFatOffset_ = 0; cacheFatOffset_ = 0;
#if USE_SERARATEFAT_CACHE #if defined(USE_SERARATEFAT_CACHE) && USE_SERARATEFAT_CACHE
cacheFatStatus_ = 0; // cacheSync() will write block if true cacheFatStatus_ = 0; // cacheSync() will write block if true
cacheFatBlockNumber_ = 0XFFFFFFFF; cacheFatBlockNumber_ = 0XFFFFFFFF;
#endif // USE_SERARATEFAT_CACHE #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 > 0 assume mbr volume with partition table
if (part) { if (part) {
if (part > 4) { if (part > 4) {
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("volume init: illegal part"));
#endif
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ); pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
if (!pc) { if (!pc) {
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("volume init: cache fetch failed"));
#endif
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -4245,6 +4284,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
p->totalSectors < 100 || p->totalSectors < 100 ||
p->firstSector == 0) { p->firstSector == 0) {
// not a valid partition // not a valid partition
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("volume init: invalid partition"));
#endif
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -4252,6 +4294,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
} }
pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ); pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
if (!pc) { if (!pc) {
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("volume init: cache fetch failed"));
#endif
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -4261,6 +4306,13 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
fbs->reservedSectorCount == 0 || fbs->reservedSectorCount == 0 ||
fbs->sectorsPerCluster == 0) { fbs->sectorsPerCluster == 0) {
// not valid FAT volume // 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; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -4303,6 +4355,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
if (clusterCount_ < 4085) { if (clusterCount_ < 4085) {
fatType_ = 12; fatType_ = 12;
if (!FAT12_SUPPORT) { if (!FAT12_SUPPORT) {
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("volume init: No FAT 12 support"));
#endif
DBG_FAIL_MACRO; DBG_FAIL_MACRO;
goto fail; goto fail;
} }
@ -4315,6 +4370,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
return true; return true;
fail: fail:
#if defined(DEBUG_SD_ERROR)
Com::printErrorFLN(PSTR("SD volume open failed"));
#endif
return false; return false;
} }
// =============== SdFile.cpp ==================== // =============== SdFile.cpp ====================
@ -4434,5 +4492,3 @@ void SdFatUtil::SerialPrintln_P(FSTRINGPARAM(str)) {
#endif // SDSUPPORT #endif // SDSUPPORT

View file

@ -2057,7 +2057,7 @@ class SdBaseFile {
dir_t* readDirCacheSpecial(); dir_t* readDirCacheSpecial();
dir_t *getLongFilename(dir_t *dir, char *longFilename, int8_t cVFATNeeded, uint32_t *pwIndexPos); 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); 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(); bool setDirSize();
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -2208,6 +2208,9 @@ class SdBaseFile {
static bool remove(SdBaseFile& dirFile, const char* path) // NOLINT static bool remove(SdBaseFile& dirFile, const char* path) // NOLINT
__attribute__((error("use remove(&dirFile, path)"))); __attribute__((error("use remove(&dirFile, path)")));
#endif // ALLOW_DEPRECATED_FUNCTIONS #endif // ALLOW_DEPRECATED_FUNCTIONS
#if JSON_OUTPUT
void lsJSON();
#endif
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
/** /**
@ -2321,5 +2324,3 @@ class SdFat {
SdBaseFile vwd_; SdBaseFile vwd_;
}; };
#endif // SdFat_h #endif // SdFat_h

View file

@ -1,3 +0,0 @@
/* Stub for CDC.cpp */
#include <CDC.cpp>

View file

@ -1,3 +0,0 @@
/* Stub for HardwareSerial.cpp */
#include <HardwareSerial.cpp>

View file

@ -1,3 +0,0 @@
/* Stub for IPAddress.cpp */
#include <IPAddress.cpp>

View file

@ -1 +0,0 @@
#include <Print.cpp>

View file

@ -1 +0,0 @@
#include <Stream.cpp>

View file

@ -1 +0,0 @@
#include <Tone.cpp>

View file

@ -1,2 +0,0 @@
#include <HID.cpp>
#include <USBCore.cpp>

View file

@ -1 +0,0 @@
#include <WInterrupts.c>

View file

@ -1 +0,0 @@
#include <WMath.cpp>

View file

@ -1 +0,0 @@
#include <WString.cpp>

View file

@ -1 +0,0 @@
#include <main.cpp>

View file

@ -1 +0,0 @@
#include <new.cpp>

View file

@ -1 +0,0 @@
#include <wiring.c>

View file

@ -1 +0,0 @@
#include <wiring_analog.c>

View file

@ -1 +0,0 @@
#include <wiring_digital.c>

View file

@ -1 +0,0 @@
#include <wiring_pulse.c>

View file

@ -1 +0,0 @@
#include <wiring_shift.c>

View file

@ -3735,5 +3735,3 @@ pins
#endif /* _ARDUINO_H */ #endif /* _ARDUINO_H */

View file

@ -224,7 +224,7 @@ void GCode::checkAndPushCommand()
} }
pushCommand(); pushCommand();
#ifdef DEBUG_COM_ERRORS #ifdef DEBUG_COM_ERRORS
if(M == 667) if(hasM() && M == 667)
return; // omit ok return; // omit ok
#endif #endif
#if ACK_WITH_LINENUMBER #if ACK_WITH_LINENUMBER
@ -428,7 +428,7 @@ void GCode::readFromSerial()
} }
} }
#if SDSUPPORT #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; return;
while( sd.filesize > sd.sdpos && commandsReceivingWritePosition < MAX_CMD_SIZE) // consume data until no data or buffer full while( sd.filesize > sd.sdpos && commandsReceivingWritePosition < MAX_CMD_SIZE) // consume data until no data or buffer full
{ {
@ -549,12 +549,12 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
return false; return false;
} }
p = buffer; p = buffer;
params = *(unsigned int *)p; params = *(uint16_t *)p;
p += 2; p += 2;
uint8_t textlen = 16; uint8_t textlen = 16;
if(isV2()) if(isV2())
{ {
params2 = *(unsigned int *)p; params2 = *(uint16_t *)p;
p += 2; p += 2;
if(hasString()) if(hasString())
textlen = *p++; textlen = *p++;
@ -567,12 +567,12 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
} }
if(isV2()) // Read G,M as 16 bit value if(isV2()) // Read G,M as 16 bit value
{ {
if(params & 2) if(hasM())
{ {
M = *(uint16_t *)p; M = *(uint16_t *)p;
p += 2; p += 2;
} }
if(params & 4) if(hasG())
{ {
G = *(uint16_t *)p; G = *(uint16_t *)p;
p += 2; p += 2;
@ -580,51 +580,51 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
} }
else else
{ {
if(params & 2) if(hasM())
{ {
M = *p++; M = *p++;
} }
if(params & 4) if(hasG())
{ {
G = *p++; G = *p++;
} }
} }
//if(code->params & 8) {memcpy(&code->X,p,4);p+=4;} //if(code->params & 8) {memcpy(&code->X,p,4);p+=4;}
if(params & 8) if(hasX())
{ {
X = *(float *)p; X = *(float *)p;
p += 4; p += 4;
} }
if(params & 16) if(hasY())
{ {
Y = *(float *)p; Y = *(float *)p;
p += 4; p += 4;
} }
if(params & 32) if(hasZ())
{ {
Z = *(float *)p; Z = *(float *)p;
p += 4; p += 4;
} }
if(params & 64) if(hasE())
{ {
E = *(float *)p; E = *(float *)p;
p += 4; p += 4;
} }
if(params & 256) if(hasF())
{ {
F = *(float *)p; F = *(float *)p;
p += 4; p += 4;
} }
if(params & 512) if(hasT())
{ {
T = *p++; T = *p++;
} }
if(params & 1024) if(hasS())
{ {
S = *(int32_t*)p; S = *(int32_t*)p;
p += 4; p += 4;
} }
if(params & 2048) if(hasP())
{ {
P = *(int32_t*)p; P = *(int32_t*)p;
p += 4; p += 4;
@ -706,6 +706,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
char c; char c;
while ( (c = *(pos++)) ) while ( (c = *(pos++)) )
{ {
if(c == '(' || c == '%') break; // alternative comment or program block
switch(c) switch(c)
{ {
case 'N': case 'N':
@ -731,7 +732,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
params |= 2; params |= 2;
if(M > 255) params |= 4096; if(M > 255) params |= 4096;
// handle non standard text arguments that some M codes have // 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 // after M command we got a filename or text
char digit; char digit;
@ -749,7 +750,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
text = pos; text = pos;
while (*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++; // find a space as file name end
} }
*pos = 0; // truncate filename by erasing space with nul, also skips checksum *pos = 0; // truncate filename by erasing space with nul, also skips checksum
@ -846,6 +847,62 @@ bool GCode::parseAscii(char *line,bool fromSerial)
params |= 4096; // Needs V2 for saving params |= 4096; // Needs V2 for saving
break; 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 case '*' : //checksum
{ {
uint8_t checksum_given = parseLongValue(pos); uint8_t checksum_given = parseLongValue(pos);
@ -885,7 +942,7 @@ void GCode::printCommand()
{ {
if(hasN()) { if(hasN()) {
Com::print('N'); Com::print('N');
Com::print((long)N); Com::print((int32_t)N);
Com::print(' '); Com::print(' ');
} }
if(hasM()) if(hasM())
@ -953,4 +1010,192 @@ void GCode::printCommand()
Com::println(); 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

View file

@ -19,22 +19,23 @@
#define _GCODE_H #define _GCODE_H
#define MAX_CMD_SIZE 96 #define MAX_CMD_SIZE 96
#define ARRAY_SIZE(_x) (sizeof(_x)/sizeof(_x[0]))
class SDCard; class SDCard;
class GCode // 52 uint8_ts per command needed class GCode // 52 uint8_ts per command needed
{ {
unsigned int params; uint16_t params;
unsigned int params2; uint16_t params2;
public: public:
unsigned int N; // Line number uint16_t N; // Line number
unsigned int M; uint16_t M;
unsigned int G; uint16_t G;
float X; float X;
float Y; float Y;
float Z; float Z;
float E; float E;
float F; float F;
long S; int32_t S;
long P; int32_t P;
float I; float I;
float J; float J;
float R; float R;
@ -191,6 +192,7 @@ private:
inline float parseFloatValue(char *s) inline float parseFloatValue(char *s)
{ {
char *endPtr; char *endPtr;
while(*s == 32) s++; // skip spaces
float f = (strtod(s, &endPtr)); float f = (strtod(s, &endPtr));
if(s == endPtr) f=0.0; // treat empty string "x " as "x0" if(s == endPtr) f=0.0; // treat empty string "x " as "x0"
return f; return f;
@ -198,6 +200,7 @@ private:
inline long parseLongValue(char *s) inline long parseLongValue(char *s)
{ {
char *endPtr; char *endPtr;
while(*s == 32) s++; // skip spaces
long l = (strtol(s, &endPtr, 10)); long l = (strtol(s, &endPtr, 10));
if(s == endPtr) l=0; // treat empty string argument "p " as "p0" if(s == endPtr) l=0; // treat empty string argument "p " as "p0"
return l; return l;
@ -221,8 +224,26 @@ private:
static uint8_t formatErrors; ///< Number of sequential format errors 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 #endif

View file

@ -1 +0,0 @@
#include <EEPROM.cpp>

View file

@ -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>

View file

@ -1 +0,0 @@
#include <Firmata.cpp>

View file

@ -1 +0,0 @@
#include <LiquidCrystal.cpp>

View file

@ -1 +0,0 @@
#include <OBD.cpp>

View file

@ -1,5 +0,0 @@
#include <SD.cpp>
#include <Sd2Card.cpp>
#include <SdFile.cpp>
#include <SdVolume.cpp>
#include <File.cpp>

View file

@ -1 +0,0 @@
#include <SPI.cpp>

View file

@ -1 +0,0 @@
#include <Servo.cpp>

View file

@ -1 +0,0 @@
#include <SoftwareSerial.cpp>

View file

@ -1 +0,0 @@
#include <Stepper.cpp>

View file

@ -1 +0,0 @@
#include <TinyGPS.cpp>

View file

@ -1 +0,0 @@
#include <U8glib.cpp>

View file

@ -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>

View file

@ -1,2 +0,0 @@
#include <twi.c>
#include <Wire.cpp>

View file

@ -1 +0,0 @@
#include <twi.c>

View file

@ -3,6 +3,7 @@
// http://en.radzio.dxp.pl/bitmap_converter/ // http://en.radzio.dxp.pl/bitmap_converter/
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
#ifndef CUSTOM_LOGO
#define LOGO_WIDTH 60 #define LOGO_WIDTH 60
#define LOGO_HEIGHT 64 #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, 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, 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 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

View file

@ -75,11 +75,11 @@ int maxadv = 0;
int maxadv2 = 0; int maxadv2 = 0;
float maxadvspeed = 0; float maxadvspeed = 0;
#endif #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 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::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 #if CPU_ARCH == ARCH_ARM
volatile bool PrintLine::nlFlag = false; volatile bool PrintLine::nlFlag = false;
#endif #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. 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 NUM_EXTRUDER > 0
if(Printer::debugDryrun() || (MIN_EXTRUDER_TEMP > 30 && Extruder::current->tempControl.currentTemperatureC < MIN_EXTRUDER_TEMP && !Printer::isColdExtrusionAllowed())) 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::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS] + e;
Printer::feedrate = feedrate; Printer::feedrate = feedrate;
#if NONLINEAR_SYSTEM #if NONLINEAR_SYSTEM
if (!queueDeltaMove(checkEndstop, false, false)) if (!queueDeltaMove(checkEndstop, pathOptimize, false))
{ {
Com::printWarningFLN(PSTR("moveRelativeDistanceInSteps / queueDeltaMove returns error")); Com::printWarningFLN(PSTR("moveRelativeDistanceInSteps / queueDeltaMove returns error"));
} }
#else #else
queueCartesianMove(checkEndstop, false); queueCartesianMove(checkEndstop, pathOptimize);
#endif #endif
Printer::feedrate = savedFeedrate; Printer::feedrate = savedFeedrate;
Printer::updateCurrentPosition(false); Printer::updateCurrentPosition(false);
@ -117,7 +117,7 @@ void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int
previousMillisCmd = HAL::timeInMilliseconds(); 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[X_AXIS] += x * Printer::invAxisStepsPerMM[X_AXIS];
Printer::lastCmdPos[Y_AXIS] += y * Printer::invAxisStepsPerMM[Y_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 e = 0; // should not be allowed for current temperature
#endif #endif
Printer::moveToReal(Printer::lastCmdPos[X_AXIS], Printer::lastCmdPos[Y_AXIS], Printer::lastCmdPos[Z_AXIS], 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(); Printer::updateCurrentPosition();
if(waitEnd) if(waitEnd)
Commands::waitUntilEndOfAllMoves(); Commands::waitUntilEndOfAllMoves();
@ -139,6 +139,130 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
} }
#if !NONLINEAR_SYSTEM #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. 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 If the cache is full, the method will wait, until a place gets free. During
@ -148,28 +272,75 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
void PrintLine::queueCartesianMove(uint8_t check_endstops, uint8_t pathOptimize) void PrintLine::queueCartesianMove(uint8_t check_endstops, uint8_t pathOptimize)
{ {
Printer::unsetAllSteppersDisabled(); 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); waitForXFreeLines(1);
uint8_t newPath = insertWaitMovesIfNeeded(pathOptimize, 0); uint8_t newPath = insertWaitMovesIfNeeded(pathOptimize, 0);
PrintLine *p = getNextWriteLine(); PrintLine *p = getNextWriteLine();
float axis_diff[E_AXIS_ARRAY]; // Axis movement in mm float axis_diff[E_AXIS_ARRAY]; // Axis movement in mm
if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS; p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
else p->flags = 0; #if MIXING_EXTRUDER
if(Printer::isAllEMotors()) {
p->flags |= FLAG_ALL_E_MOTORS;
}
#endif
p->joinFlags = 0; p->joinFlags = 0;
if(!pathOptimize) p->setEndSpeedFixed(true); if(!pathOptimize) p->setEndSpeedFixed(true);
p->dir = 0; p->dir = 0;
Printer::constrainDestinationCoords(); Printer::constrainDestinationCoords();
//Find direction //Find direction
Printer::zCorrectionStepsIncluded = 0;
for(uint8_t axis = 0; axis < 4; axis++) for(uint8_t axis = 0; axis < 4; axis++)
{ {
p->delta[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis]; p->delta[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
p->secondSpeed = Printer::fanSpeed;
if(axis == E_AXIS) if(axis == E_AXIS)
{
if(Printer::mode == PRINTER_MODE_FFF)
{ {
Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor); Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor);
p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError); p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
Printer::extrudeMultiplyError -= p->delta[E_AXIS]; Printer::extrudeMultiplyError -= p->delta[E_AXIS];
Printer::filamentPrinted += p->delta[E_AXIS] * Printer::invAxisStepsPerMM[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) if(p->delta[axis] >= 0)
p->setPositiveDirectionForAxis(axis); p->setPositiveDirectionForAxis(axis);
else else
@ -252,17 +423,18 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
long axisInterval[E_AXIS_ARRAY]; long axisInterval[E_AXIS_ARRAY];
#endif #endif
float timeForMove = (float)(F_CPU)*distance / (isXOrYMove() ? RMath::max(Printer::minimumSpeed, Printer::feedrate) : Printer::feedrate); // time is in ticks 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. 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. 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); //Com::printFLN(PSTR("Slow "),timeForMove);
critical = true; //critical = true;
} }
timeInTicks = timeForMove; timeInTicks = timeForMove;
UI_MEDIUM; // do check encoder 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 long limitInterval = timeForMove / stepsRemaining; // until not violated by other constraints it is your target speed
if(isXMove()) if(isXMove())
{ {
@ -345,14 +517,32 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
// slowest time to accelerate from v0 to limitInterval determines used acceleration // slowest time to accelerate from v0 to limitInterval determines used acceleration
// t = (v_end-v_start)/a // t = (v_end-v_start)/a
float slowest_axis_plateau_time_repro = 1e15; // repro to reduce division Unit: 1/s 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++) for(uint8_t i = 0; i < 4 ; i++)
{ {
if(isMoveOfAxis(i)) if(isMoveOfAxis(i))
// v = a * t => t = v/a = F_CPU/(c*a) => 1/t = c*a/F_CPU // 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 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) // Errors for delta move are initialized in timer (except extruder)
#if !NONLINEAR_SYSTEM #if !NONLINEAR_SYSTEM
error[X_AXIS] = error[Y_AXIS] = error[Z_AXIS] = delta[primaryAxis] >> 1; 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 // now first points to last segment before the end speed is fixed
// so start speed is also 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 act->block(); // Prevent steppe rinterrupt from using this
noInts.unprotect(); noInts.unprotect();
@ -521,7 +711,9 @@ void PrintLine::updateTrapezoids()
act->updateStepsParameter(); act->updateStepsParameter();
firstLine->unblock(); firstLine->unblock();
return; return;
} else { }
else
{
computeMaxJunctionSpeed(previous, act); // Set maximum junction speed if we have a real move before computeMaxJunctionSpeed(previous, act); // Set maximum junction speed if we have a real move before
} }
// Increase speed if possible neglecting current speed // 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. This sets jerk to 0 on zero angle change.
Old New Old New
0<EFBFBD><EFBFBD>: 0 0 0°: 0 0
30<EFBFBD><EFBFBD>: 51,8 13.4 30°: 51,8 13.4
45<EFBFBD><EFBFBD>: 76.53 29.3 45°: 76.53 29.3
90<EFBFBD><EFBFBD>: 141 100 90°: 141 100
180<EFBFBD><EFBFBD>: 200 200 180°: 200 200
von 100 auf 200 von 100 auf 200
Old New(min) New(max) Old New(min) New(max)
0<EFBFBD><EFBFBD>: 100 0 0 0°: 100 0 0
30<EFBFBD><EFBFBD>: 123,9 13.4 26.8 30°: 123,9 13.4 26.8
45<EFBFBD><EFBFBD>: 147.3 29.3 58.6 45°: 147.3 29.3 58.6
90<EFBFBD><EFBFBD>: 223 100 200 90°: 223 100 200
180<EFBFBD><EFBFBD>: 300 200 400 180°: 300 200 400
*/ */
inline void PrintLine::computeMaxJunctionSpeed(PrintLine *previous, PrintLine *current) inline void PrintLine::computeMaxJunctionSpeed(PrintLine *previous, PrintLine *current)
@ -833,10 +1025,13 @@ inline float PrintLine::safeSpeed()
if(isZMove()) if(isZMove())
{ {
float mz = Printer::maxZJerk * 0.5; float mz = Printer::maxZJerk * 0.5;
if(isXOrYMove()) { if(isXOrYMove())
{
if(fabs(speedZ) > mz) if(fabs(speedZ) > mz)
safe = RMath::min(safe,mz * fullSpeed / fabs(speedZ)); safe = RMath::min(safe,mz * fullSpeed / fabs(speedZ));
} else { }
else
{
safe = mz; safe = mz;
} }
} }
@ -866,6 +1061,7 @@ uint8_t PrintLine::insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExt
{ {
if(linesCount == 0 && waitRelax == 0 && pathOptimize) // First line after some time - warm up needed if(linesCount == 0 && waitRelax == 0 && pathOptimize) // First line after some time - warm up needed
{ {
//return 0;
#if NONLINEAR_SYSTEM #if NONLINEAR_SYSTEM
uint8_t w = 3; uint8_t w = 3;
#else #else
@ -879,12 +1075,13 @@ uint8_t PrintLine::insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExt
p->dir = 0; p->dir = 0;
p->setWaitForXLinesFilled(w + waitExtraLines); p->setWaitForXLinesFilled(w + waitExtraLines);
#if NONLINEAR_SYSTEM #if NONLINEAR_SYSTEM
p->setWaitTicks(50000); p->setWaitTicks(300000);
#else #else
p->setWaitTicks(25000); p->setWaitTicks(100000);
#endif // NONLINEAR_SYSTEM #endif // NONLINEAR_SYSTEM
pushLine(); pushLine();
} }
//Com::printFLN(PSTR("InsertWait"));
return 1; return 1;
} }
return 0; return 0;
@ -1020,7 +1217,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
+ zSteps); + zSteps);
else else
return 0; 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]; temp = Printer::deltaBPosYSteps - cartesianPosSteps[Y_AXIS];
opt = Printer::deltaDiagonalStepsSquaredB.f - temp * temp; opt = Printer::deltaDiagonalStepsSquaredB.f - temp * temp;
@ -1030,7 +1227,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
+ zSteps); + zSteps);
else else
return 0; 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]; temp = Printer::deltaCPosYSteps - cartesianPosSteps[Y_AXIS];
opt = Printer::deltaDiagonalStepsSquaredC.f - temp * temp; opt = Printer::deltaDiagonalStepsSquaredC.f - temp * temp;
@ -1040,7 +1237,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
+ zSteps); + zSteps);
else else
return 0; return 0;
if (deltaPosSteps[C_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0; if (deltaPosSteps[C_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
return 1; return 1;
#endif #endif
@ -1213,6 +1410,7 @@ void DeltaSegment::checkEndstops(PrintLine *cur,bool checkall)
{ {
if(Printer::isZProbingActive()) if(Printer::isZProbingActive())
{ {
Endstops::update();
#if FEATURE_Z_PROBE #if FEATURE_Z_PROBE
if(isZNegativeMove() && Endstops::zProbe()) if(isZNegativeMove() && Endstops::zProbe())
{ {
@ -1241,6 +1439,8 @@ void DeltaSegment::checkEndstops(PrintLine *cur,bool checkall)
} }
if(checkall) if(checkall)
{ {
if(!Printer::isZProbingActive())
Endstops::update(); // do not test twice
if(isXPositiveMove() && Endstops::xMax()) if(isXPositiveMove() && Endstops::xMax())
{ {
#if DRIVE_SYSTEM == DELTA #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 float axisDiff[5]; // Axis movement in mm
if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS; if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS;
else p->flags = 0; else p->flags = 0;
#if MIXING_EXTRUDER
if(Printer::isAllEMotors()) {
p->flags |= FLAG_ALL_E_MOTORS;
}
#endif
p->joinFlags = 0; p->joinFlags = 0;
if(!pathOptimize) p->setEndSpeedFixed(true); if(!pathOptimize) p->setEndSpeedFixed(true);
//Find direction //Find direction
@ -1510,10 +1715,13 @@ 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 //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]; int32_t difference[E_AXIS_ARRAY];
float axis_diff[VIRTUAL_AXIS_ARRAY]; // Axis movement in mm. Virtual axis in 4; 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++) for(fast8_t axis = 0; axis < E_AXIS_ARRAY; axis++)
{ {
difference[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis]; difference[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
if(axis == E_AXIS) if(axis == E_AXIS)
{
if(Printer::mode == PRINTER_MODE_FFF)
{ {
Printer::extrudeMultiplyError += (static_cast<float>(difference[E_AXIS]) * Printer::extrusionFactor); Printer::extrudeMultiplyError += (static_cast<float>(difference[E_AXIS]) * Printer::extrusionFactor);
difference[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError); difference[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
@ -1522,6 +1730,14 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
Printer::filamentPrinted += axis_diff[E_AXIS]; Printer::filamentPrinted += axis_diff[E_AXIS];
axis_diff[E_AXIS] = fabs(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 else
axis_diff[axis] = fabs(difference[axis] * Printer::invAxisStepsPerMM[axis]); 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); waitForXFreeLines(1);
// Insert dummy moves if necessary // 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)); insertWaitMovesIfNeeded(pathOptimize, RMath::min(PRINTLINE_CACHE_SIZE - 4, numLines));
uint32_t oldEDestination = Printer::destinationSteps[E_AXIS]; // flow and volumetric extrusion changed virtual target uint32_t oldEDestination = Printer::destinationSteps[E_AXIS]; // flow and volumetric extrusion changed virtual target
Printer::currentPositionSteps[E_AXIS] = 0; 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->joinFlags = 0;
p->secondSpeed = secondSpeed;
p->moveID = lastMoveID; p->moveID = lastMoveID;
// Only set fixed on last segment // 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->setEndSpeedFixed(true);
p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0); p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
#if MIXING_EXTRUDER
if(Printer::isAllEMotors()) {
p->flags |= FLAG_ALL_E_MOTORS;
}
#endif
p->numDeltaSegments = segmentsPerLine; p->numDeltaSegments = segmentsPerLine;
uint16_t maxDeltaStep = p->calculateDeltaSubSegments(softEndstop); 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 // 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_axis0 = position[X_AXIS] + offset[X_AXIS];
float center_axis1 = position[Y_AXIS] + offset[Y_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 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_axis0 = -offset[0]; // Radius vector from center to current location
float r_axis1 = -offset[1]; 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. // 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); 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; angular_travel += 2.0f * M_PI;
} }
@ -1875,7 +2097,7 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
//HAL::forbidInterrupts(); //HAL::forbidInterrupts();
//deltaSegmentCount -= cur->numDeltaSegments; // should always be zero //deltaSegmentCount -= cur->numDeltaSegments; // should always be zero
removeCurrentLineForbidInterrupt(); removeCurrentLineForbidInterrupt();
if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE); if(linesCount == 0) UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
return 1000; return 1000;
} }
#endif #endif
@ -1901,7 +2123,7 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
if(Printer::isZProbingActive() && Printer::stepsRemainingAtZHit >= 0) if(Printer::isZProbingActive() && Printer::stepsRemainingAtZHit >= 0)
{ {
removeCurrentLineForbidInterrupt(); removeCurrentLineForbidInterrupt();
if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE); if(linesCount == 0) UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
return 1000; return 1000;
} }
#endif #endif
@ -1958,6 +2180,15 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
Printer::advanceExecuted = cur->advanceStart; Printer::advanceExecuted = cur->advanceStart;
#endif #endif
cur->updateAdvanceSteps(cur->vStart, 0, false); 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 #endif
return Printer::interval; // Wait an other 50% from last step to make the 100% full return Printer::interval; // Wait an other 50% from last step to make the 100% full
} // End cur=0 } // End cur=0
@ -1965,7 +2196,6 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
if(curd != NULL) if(curd != NULL)
{ {
Endstops::update();
curd->checkEndstops(cur,(cur->isCheckEndstops())); curd->checkEndstops(cur,(cur->isCheckEndstops()));
} }
int maxLoops = (Printer::stepsPerTimerCall <= cur->stepsRemaining ? Printer::stepsPerTimerCall : cur->stepsRemaining); 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 (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 // Get the next delta segment
curd = &cur->segments[--cur->numDeltaSegments]; curd = &cur->segments[--cur->numDeltaSegments];
@ -2053,48 +2292,6 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
HAL::delayMicroseconds(DIRECTION_DELAY); HAL::delayMicroseconds(DIRECTION_DELAY);
#endif #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 else
curd = 0;// Release the last segment 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 //deltaSegmentCount -= cur->numDeltaSegments; // should always be zero
removeCurrentLineForbidInterrupt(); removeCurrentLineForbidInterrupt();
Printer::disableAllowedStepper(); 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 Printer::interval >>= 1; // 50% of time to next call to do cur=0
DEBUG_MEMORY; DEBUG_MEMORY;
} // Do even } // Do even
@ -2342,16 +2550,26 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
Printer::advanceExecuted = cur->advanceStart; Printer::advanceExecuted = cur->advanceStart;
#endif #endif
cur->updateAdvanceSteps(cur->vStart, 0, false); 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 #endif
return Printer::interval; // Wait an other 50% from last step to make the 100% full return Printer::interval; // Wait an other 50% from last step to make the 100% full
} // End cur=0 } // End cur=0
Endstops::update();
cur->checkEndstops(); 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++) for(fast8_t loop = 0; loop < max_loops; loop++)
{ {
#if STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY > 0 #if STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY > 0
if(loop > 0) if(loop)
HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY); HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY);
#endif #endif
if((cur->error[E_AXIS] -= cur->delta[E_AXIS]) < 0) if((cur->error[E_AXIS] -= cur->delta[E_AXIS]) < 0)
@ -2369,19 +2587,25 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
Extruder::step(); Extruder::step();
cur->error[E_AXIS] += cur_errupd; cur->error[E_AXIS] += cur_errupd;
} }
#if CPU_ARCH == ARCH_AVR
if(cur->isXMove()) if(cur->isXMove())
#endif
if((cur->error[X_AXIS] -= cur->delta[X_AXIS]) < 0) if((cur->error[X_AXIS] -= cur->delta[X_AXIS]) < 0)
{ {
cur->startXStep(); cur->startXStep();
cur->error[X_AXIS] += cur_errupd; cur->error[X_AXIS] += cur_errupd;
} }
#if CPU_ARCH == ARCH_AVR
if(cur->isYMove()) if(cur->isYMove())
#endif
if((cur->error[Y_AXIS] -= cur->delta[Y_AXIS]) < 0) if((cur->error[Y_AXIS] -= cur->delta[Y_AXIS]) < 0)
{ {
cur->startYStep(); cur->startYStep();
cur->error[Y_AXIS] += cur_errupd; cur->error[Y_AXIS] += cur_errupd;
} }
#if CPU_ARCH == ARCH_AVR
if(cur->isZMove()) if(cur->isZMove())
#endif
if((cur->error[Z_AXIS] -= cur->delta[Z_AXIS]) < 0) if((cur->error[Z_AXIS] -= cur->delta[Z_AXIS]) < 0)
{ {
cur->startZStep(); cur->startZStep();
@ -2401,6 +2625,7 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
#if USE_ADVANCE #if USE_ADVANCE
if(!Printer::isAdvanceActivated()) // Use interrupt for movement if(!Printer::isAdvanceActivated()) // Use interrupt for movement
#endif #endif
cur->stepsRemaining--;
Extruder::unstep(); Extruder::unstep();
Printer::endXYZSteps(); Printer::endXYZSteps();
} // for loop } // for loop
@ -2464,7 +2689,6 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
Printer::stepsPerTimerCall = 1; Printer::stepsPerTimerCall = 1;
Printer::interval = cur->fullInterval; // without RAMPS always use full speed Printer::interval = cur->fullInterval; // without RAMPS always use full speed
#endif // RAMP_ACCELERATION #endif // RAMP_ACCELERATION
cur->stepsRemaining -= max_loops;
long interval = Printer::interval; long interval = Printer::interval;
if(cur->stepsRemaining <= 0 || cur->isNoMove()) // line finished if(cur->stepsRemaining <= 0 || cur->isNoMove()) // line finished
{ {
@ -2477,16 +2701,27 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
#endif #endif
removeCurrentLineForbidInterrupt(); removeCurrentLineForbidInterrupt();
Printer::disableAllowedStepper(); 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 interval = Printer::interval = interval >> 1; // 50% of time to next call to do cur=0
DEBUG_MEMORY; DEBUG_MEMORY;
} // Do even } // Do even
if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing) if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing)
{ {
HAL::forbidInterrupts();
Printer::zBabystep(); Printer::zBabystep();
} }
return interval; return interval;
} }
#endif #endif

View file

@ -28,10 +28,10 @@
#define FLAG_WARMUP 1 #define FLAG_WARMUP 1
#define FLAG_NOMINAL 2 #define FLAG_NOMINAL 2
#define FLAG_DECELERATING 4 #define FLAG_DECELERATING 4
#define FLAG_ACCELERATION_ENABLED 8 #define FLAG_ACCELERATION_ENABLED 8 // unused
#define FLAG_CHECK_ENDSTOPS 16 #define FLAG_CHECK_ENDSTOPS 16
#define FLAG_SKIP_ACCELERATING 32 #define FLAG_ALL_E_MOTORS 32 // For mixed extruder move all motors instead of selected motor
#define FLAG_SKIP_DEACCELERATING 64 #define FLAG_SKIP_DEACCELERATING 64 // unused
#define FLAG_BLOCKED 128 #define FLAG_BLOCKED 128
/** Are the step parameter computed */ /** Are the step parameter computed */
@ -174,10 +174,11 @@ public:
static ufast8_t linesWritePos; // Position where we write the next cached line move static ufast8_t linesWritePos; // Position where we write the next cached line move
ufast8_t joinFlags; ufast8_t joinFlags;
volatile ufast8_t flags; volatile ufast8_t flags;
uint8_t secondSpeed; // for laser intensity or fan control
private: private:
fast8_t primaryAxis; fast8_t primaryAxis;
int32_t timeInTicks;
ufast8_t dir; ///< Direction of movement. 1 = X+, 2 = Y+, 4= Z+, values can be combined. 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 delta[E_AXIS_ARRAY]; ///< Steps we want to move.
int32_t error[E_AXIS_ARRAY]; ///< Error calculation for Bresenham algorithm int32_t error[E_AXIS_ARRAY]; ///< Error calculation for Bresenham algorithm
float speedX; ///< Speed in x direction at fullInterval in mm/s float speedX; ///< Speed in x direction at fullInterval in mm/s
@ -282,6 +283,9 @@ public:
{ {
return flags & FLAG_BLOCKED; return flags & FLAG_BLOCKED;
} }
inline bool isAllEMotors() {
return flags & FLAG_ALL_E_MOTORS;
}
inline bool isCheckEndstops() inline bool isCheckEndstops()
{ {
return flags & FLAG_CHECK_ENDSTOPS; return flags & FLAG_CHECK_ENDSTOPS;
@ -298,6 +302,7 @@ public:
{ {
if(isCheckEndstops()) if(isCheckEndstops())
{ {
Endstops::update();
if(isXNegativeMove() && Endstops::xMin()) if(isXNegativeMove() && Endstops::xMin())
setXMoveFinished(); setXMoveFinished();
else if(isXPositiveMove() && Endstops::xMax()) else if(isXPositiveMove() && Endstops::xMax())
@ -327,11 +332,14 @@ public:
} }
} }
#if FEATURE_Z_PROBE #if FEATURE_Z_PROBE
else if(Printer::isZProbingActive() && isZNegativeMove() && Endstops::zProbe()) else if(Printer::isZProbingActive() && isZNegativeMove()) {
Endstops::update();
if(Endstops::zProbe())
{ {
setZMoveFinished(); setZMoveFinished();
Printer::stepsRemainingAtZHit = stepsRemaining; Printer::stepsRemainingAtZHit = stepsRemaining;
} }
}
#endif #endif
} }
@ -488,7 +496,7 @@ public:
#endif #endif
#endif #endif
} }
inline bool moveDecelerating() INLINE bool moveDecelerating()
{ {
if(stepsRemaining <= decelSteps) if(stepsRemaining <= decelSteps)
{ {
@ -501,17 +509,14 @@ public:
} }
else return false; else return false;
} }
inline bool moveAccelerating() INLINE bool moveAccelerating()
{ {
return Printer::stepNumber <= accelSteps; return Printer::stepNumber <= accelSteps;
} }
inline void startXStep() INLINE void startXStep()
{ {
#if !(GANTRY) #if !(GANTRY)
WRITE(X_STEP_PIN,HIGH); Printer::startXStep();
#if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH);
#endif
#else #else
#if DRIVE_SYSTEM == XY_GANTRY || DRIVE_SYSTEM == XZ_GANTRY #if DRIVE_SYSTEM == XY_GANTRY || DRIVE_SYSTEM == XZ_GANTRY
if(isXPositiveMove()) if(isXPositiveMove())
@ -541,15 +546,11 @@ public:
#ifdef DEBUG_STEPCOUNT #ifdef DEBUG_STEPCOUNT
totalStepsRemaining--; totalStepsRemaining--;
#endif #endif
} }
inline void startYStep() INLINE void startYStep()
{ {
#if !(GANTRY) || DRIVE_SYSTEM == ZX_GANTRY || DRIVE_SYSTEM == XZ_GANTRY #if !(GANTRY) || DRIVE_SYSTEM == ZX_GANTRY || DRIVE_SYSTEM == XZ_GANTRY
WRITE(Y_STEP_PIN,HIGH); Printer::startYStep();
#if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,HIGH);
#endif
#else #else
#if DRIVE_SYSTEM == XY_GANTRY #if DRIVE_SYSTEM == XY_GANTRY
if(isYPositiveMove()) if(isYPositiveMove())
@ -579,17 +580,15 @@ public:
#ifdef DEBUG_STEPCOUNT #ifdef DEBUG_STEPCOUNT
totalStepsRemaining--; totalStepsRemaining--;
#endif #endif
} }
inline void startZStep() INLINE void startZStep()
{ {
#if !(GANTRY) || DRIVE_SYSTEM == YX_GANTRY || DRIVE_SYSTEM == XY_GANTRY #if !(GANTRY) || DRIVE_SYSTEM == YX_GANTRY || DRIVE_SYSTEM == XY_GANTRY
WRITE(Z_STEP_PIN,HIGH); Printer::startZStep();
#if FEATURE_TWO_ZSTEPPER
WRITE(Z2_STEP_PIN,HIGH);
#endif
#else #else
#if DRIVE_SYSTEM == XZ_GANTRY #if DRIVE_SYSTEM == XZ_GANTRY
if(isYPositiveMove()) if(isZPositiveMove())
{ {
Printer::motorX++; Printer::motorX++;
Printer::motorYorZ--; Printer::motorYorZ--;
@ -601,7 +600,7 @@ public:
} }
#endif #endif
#if DRIVE_SYSTEM == ZX_GANTRY #if DRIVE_SYSTEM == ZX_GANTRY
if(isYPositiveMove()) if(isZPositiveMove())
{ {
Printer::motorX++; Printer::motorX++;
Printer::motorYorZ++; Printer::motorYorZ++;
@ -612,26 +611,29 @@ public:
Printer::motorYorZ--; Printer::motorYorZ--;
} }
#endif #endif
#endif
#ifdef DEBUG_STEPCOUNT
totalStepsRemaining--;
#endif #endif
} }
void updateStepsParameter(); void updateStepsParameter();
inline float safeSpeed(); float safeSpeed();
void calculateMove(float axis_diff[],uint8_t pathOptimize); void calculateMove(float axis_diff[],uint8_t pathOptimize);
void logLine(); void logLine();
inline long getWaitTicks() INLINE long getWaitTicks()
{ {
return timeInTicks; return timeInTicks;
} }
inline void setWaitTicks(long wait) INLINE void setWaitTicks(long wait)
{ {
timeInTicks = wait; timeInTicks = wait;
} }
static inline bool hasLines() static INLINE bool hasLines()
{ {
return linesCount; return linesCount;
} }
static inline void setCurrentLine() static INLINE void setCurrentLine()
{ {
cur = &lines[linesPos]; cur = &lines[linesPos];
#if CPU_ARCH==ARCH_ARM #if CPU_ARCH==ARCH_ARM
@ -639,7 +641,7 @@ public:
#endif #endif
} }
// Only called from within interrupts // Only called from within interrupts
static inline void removeCurrentLineForbidInterrupt() static INLINE void removeCurrentLineForbidInterrupt()
{ {
linesPos++; linesPos++;
if(linesPos >= PRINTLINE_CACHE_SIZE) linesPos = 0; if(linesPos >= PRINTLINE_CACHE_SIZE) linesPos = 0;
@ -652,7 +654,7 @@ public:
if(!linesCount) if(!linesCount)
Printer::setMenuMode(MENU_MODE_PRINTING, false); Printer::setMenuMode(MENU_MODE_PRINTING, false);
} }
static inline void pushLine() static INLINE void pushLine()
{ {
linesWritePos++; linesWritePos++;
if(linesWritePos >= PRINTLINE_CACHE_SIZE) linesWritePos = 0; if(linesWritePos >= PRINTLINE_CACHE_SIZE) linesWritePos = 0;
@ -676,17 +678,22 @@ public:
static inline void backwardPlanner(ufast8_t p,ufast8_t last); static inline void backwardPlanner(ufast8_t p,ufast8_t last);
static void updateTrapezoids(); static void updateTrapezoids();
static uint8_t insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExtraLines); 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 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); #if DISTORTION_CORRECTION
static void moveRelativeDistanceInStepsReal(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd); 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 #if ARC_SUPPORT
static void arc(float *position, float *target, float *offset, float radius, uint8_t isclockwise); static void arc(float *position, float *target, float *offset, float radius, uint8_t isclockwise);
#endif #endif
static inline void previousPlannerIndex(ufast8_t &p) static INLINE void previousPlannerIndex(ufast8_t &p)
{ {
p = (p ? p - 1 : PRINTLINE_CACHE_SIZE - 1); 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); p = (p == PRINTLINE_CACHE_SIZE - 1 ? 0 : p + 1);
} }
@ -706,5 +713,3 @@ public:
#endif // MOTION_H_INCLUDED #endif // MOTION_H_INCLUDED

File diff suppressed because it is too large Load diff

View file

@ -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 ==================== // ============= u8g.h ====================
/* /*
@ -156,6 +161,7 @@ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef _U8G_H #ifndef _U8G_H
#define _U8G_H #define _U8G_H
/* uncomment the following line to support displays larger than 240x240 */ /* uncomment the following line to support displays larger than 240x240 */
//#define U8G_16BIT 1 //#define U8G_16BIT 1
@ -854,6 +860,7 @@ defined(__18CXX) || defined(__PIC32MX)
#define U8G_SPI_CLK_CYCLE_50NS 1 #define U8G_SPI_CLK_CYCLE_50NS 1
#define U8G_SPI_CLK_CYCLE_300NS 2 #define U8G_SPI_CLK_CYCLE_300NS 2
#define U8G_SPI_CLK_CYCLE_400NS 3 #define U8G_SPI_CLK_CYCLE_400NS 3
#define U8G_SPI_CLK_CYCLE_500NS 4
#define U8G_SPI_CLK_CYCLE_NONE 255 #define U8G_SPI_CLK_CYCLE_NONE 255
uint8_t u8g_InitCom(u8g_t *u8g, u8g_dev_t *dev, uint8_t clk_cycle_time); 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) U8G_NOINLINE;
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) 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 bitData = u8g_bitData;
uint8_t bitNotData = u8g_bitNotData; uint8_t bitNotData = u8g_bitNotData;
uint8_t bitClock = u8g_bitClock; 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(); U8G_ATOMIC_START();
#ifdef UI_SPI_MOSI #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_SCK, LOW);
WRITE(UI_SPI_MOSI, val&0x80); 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) static void u8g_com_arduino_st7920_write_byte_seq(uint8_t rs, uint8_t *ptr, uint8_t len)
{ {
uint8_t i;
if ( rs == 0 ) if ( rs == 0 )
{ {
/* command */ /* 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) static void u8g_com_arduino_st7920_write_byte(uint8_t rs, uint8_t val)
{ {
uint8_t i;
if ( rs == 0 ) if ( rs == 0 )
{ {
/* command */ /* 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) switch(msg)
{ {
case U8G_DEV_MSG_INIT: case U8G_DEV_MSG_INIT:
#if defined(__SAM3X8E__)
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_400NS); 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); u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_init_seq);
break; break;
case U8G_DEV_MSG_STOP: 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; 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 else
{ {
SPI0->SPI_CSR[0] = SPI_CSR_SCBR(84) | 1; 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

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -378,7 +378,7 @@ void uiInitKeys() {
// UI_KEYS_INIT_MATRIX(32,47,45,43,41,39,37,35); // UI_KEYS_INIT_MATRIX(32,47,45,43,41,39,37,35);
#endif #endif
} }
void uiCheckKeys(int &action) { void uiCheckKeys(uint16_t &action) {
#if UI_HAS_KEYS!=0 #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. //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::i2cWrite(0x12); // GIOA
HAL::i2cStop(); HAL::i2cStop();
HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ); HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ);
unsigned int keymask = HAL::i2cReadAck(); uint16_t keymask = HAL::i2cReadAck();
keymask = keymask + (HAL::i2cReadNak()<<8); keymask = keymask + (HAL::i2cReadNak()<<8);
#endif #endif
HAL::i2cStop(); 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. 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 #endif
} }
void uiCheckSlowKeys(int &action) { void uiCheckSlowKeys(uint16_t &action) {
#if defined(UI_HAS_I2C_KEYS) && UI_HAS_KEYS!=0 #if defined(UI_HAS_I2C_KEYS) && UI_HAS_KEYS!=0
#if UI_DISPLAY_I2C_CHIPTYPE==0 #if UI_DISPLAY_I2C_CHIPTYPE==0
HAL::i2cStartWait(UI_I2C_KEY_ADDRESS+I2C_READ); HAL::i2cStartWait(UI_I2C_KEY_ADDRESS+I2C_READ);
@ -421,7 +421,7 @@ void uiCheckSlowKeys(int &action) {
HAL::i2cWrite(0x12); // GPIOA HAL::i2cWrite(0x12); // GPIOA
HAL::i2cStop(); HAL::i2cStop();
HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ); HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ);
unsigned int keymask = HAL::i2cReadAck(); uint16_t keymask = HAL::i2cReadAck();
keymask = keymask + (HAL::i2cReadNak()<<8); keymask = keymask + (HAL::i2cReadNak()<<8);
#endif #endif
HAL::i2cStop(); HAL::i2cStop();
@ -451,5 +451,3 @@ void uiCheckSlowKeys(int &action) {

6065
Repetier/uilang.cpp Normal file

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff