a7ea87d1e3
Fixed bugs related to grid bed compensation and M571 in 1.17dev7 version Software reset code storage/retrieval now works on Duet WiFi Removed max average printing acceleration parameter M571 now accepts F parameter to set the PWM frequency M106 now shows if fan is disabled
319 lines
17 KiB
C++
319 lines
17 KiB
C++
/****************************************************************************************************
|
|
|
|
RepRapFirmware - G Codes
|
|
|
|
This class interprets G Codes from one or more sources, and calls the functions in Move, Heat etc
|
|
that drive the machine to do what the G Codes command.
|
|
|
|
-----------------------------------------------------------------------------------------------------
|
|
|
|
Version 0.1
|
|
|
|
13 February 2013
|
|
|
|
Adrian Bowyer
|
|
RepRap Professional Ltd
|
|
http://reprappro.com
|
|
|
|
Licence: GPL
|
|
|
|
****************************************************************************************************/
|
|
|
|
#ifndef GCODES_H
|
|
#define GCODES_H
|
|
|
|
#include "GCodeBuffer.h"
|
|
#include "Libraries/sha1/sha1.h"
|
|
|
|
const char feedrateLetter = 'F'; // GCode feedrate
|
|
const char extrudeLetter = 'E'; // GCode extrude
|
|
|
|
// Type for specifying which endstops we want to check
|
|
typedef uint16_t EndstopChecks; // must be large enough to hold a bitmap of drive numbers or ZProbeActive
|
|
const EndstopChecks ZProbeActive = 1 << 15; // must be distinct from 1 << (any drive number)
|
|
const EndstopChecks LogProbeChanges = 1 << 14; // must be distinct from 1 << (any drive number)
|
|
|
|
typedef uint16_t TriggerMask;
|
|
|
|
struct Trigger
|
|
{
|
|
TriggerMask rising;
|
|
TriggerMask falling;
|
|
uint8_t condition;
|
|
|
|
void Init()
|
|
{
|
|
rising = falling = 0;
|
|
condition = 0;
|
|
}
|
|
|
|
bool IsUnused() const
|
|
{
|
|
return rising == 0 && falling == 0;
|
|
}
|
|
};
|
|
|
|
//****************************************************************************************************
|
|
|
|
// The GCode interpreter
|
|
|
|
class GCodes
|
|
{
|
|
public:
|
|
struct RawMove
|
|
{
|
|
float coords[DRIVES]; // new positions for the axes, amount of movement for the extruders
|
|
float initialCoords[MAX_AXES]; // the initial positions of the axes
|
|
float feedRate; // feed rate of this move
|
|
FilePosition filePos; // offset in the file being printed at the end of reading this move
|
|
uint32_t xAxes; // axes that X is mapped to
|
|
EndstopChecks endStopsToCheck; // endstops to check
|
|
uint8_t moveType; // the S parameter from the G0 or G1 command, 0 for a normal move
|
|
bool isFirmwareRetraction; // true if this is a firmware retraction/un-retraction move
|
|
bool usePressureAdvance; // true if we want to us extruder pressure advance, if there is any extrusion
|
|
bool canPauseAfter; // true if we can pause just after this move and successfully restart
|
|
};
|
|
|
|
GCodes(Platform* p, Webserver* w);
|
|
void Spin(); // Called in a tight loop to make this class work
|
|
void Init(); // Set it up
|
|
void Exit(); // Shut it down
|
|
void Reset(); // Reset some parameter to defaults
|
|
bool ReadMove(RawMove& m); // Called by the Move class to get a movement set by the last G Code
|
|
void ClearMove();
|
|
void QueueFileToPrint(const char* fileName); // Open a file of G Codes to run
|
|
void DeleteFile(const char* fileName); // Does what it says
|
|
bool GetProbeCoordinates(int count, float& x, float& y, float& z) const; // Get pre-recorded probe coordinates
|
|
void GetCurrentCoordinates(StringRef& s) const; // Write where we are into a string
|
|
bool DoingFileMacro() const; // Or still busy processing a macro file?
|
|
float FractionOfFilePrinted() const; // Get fraction of file printed
|
|
void Diagnostics(MessageType mtype); // Send helpful information out
|
|
|
|
bool RunConfigFile(const char* fileName); // Start running the config file
|
|
bool IsRunningConfigFile() const; // Are we still running the config file?
|
|
|
|
bool GetAxisIsHomed(unsigned int axis) const // Has the axis been homed?
|
|
{ return (axesHomed & (1 << axis)) != 0; }
|
|
void SetAxisIsHomed(unsigned int axis) // Tell us that the axis is now homed
|
|
{ axesHomed |= (1 << axis); }
|
|
void SetAxisNotHomed(unsigned int axis) // Tell us that the axis is not homed
|
|
{ axesHomed &= ~(1 << axis); }
|
|
|
|
float GetSpeedFactor() const { return speedFactor * minutesToSeconds; } // Return the current speed factor
|
|
float GetExtrusionFactor(size_t extruder) { return extrusionFactors[extruder]; } // Return the current extrusion factors
|
|
float GetRawExtruderPosition(size_t drive) const; // Get the actual extruder position, after adjusting the extrusion factor
|
|
float GetRawExtruderTotalByDrive(size_t extruder) const; // Get the total extrusion since start of print, for one drive
|
|
float GetTotalRawExtrusion() const { return rawExtruderTotal; } // Get the total extrusion since start of print, all drives
|
|
|
|
bool IsFlashing() const { return isFlashing; } // Is a new firmware binary going to be flashed?
|
|
|
|
bool IsPaused() const;
|
|
bool IsPausing() const;
|
|
bool IsResuming() const;
|
|
bool IsRunning() const;
|
|
|
|
bool AllAxesAreHomed() const; // Return true if all axes are homed
|
|
|
|
void CancelPrint(); // Cancel the current print
|
|
|
|
void MoveStoppedByZProbe() { zProbeTriggered = true; } // Called from the step ISR when the Z probe is triggered, causing the move to be aborted
|
|
|
|
size_t GetNumAxes() const { return numAxes; }
|
|
size_t GetNumExtruders() const { return numExtruders; }
|
|
|
|
static const char axisLetters[MAX_AXES]; // 'X', 'Y', 'Z'
|
|
|
|
private:
|
|
enum class CannedMoveType : uint8_t { none, relative, absolute };
|
|
|
|
struct RestorePoint
|
|
{
|
|
float moveCoords[DRIVES];
|
|
float feedRate;
|
|
RestorePoint() { Init(); }
|
|
void Init();
|
|
};
|
|
|
|
// Resources that can be locked.
|
|
// To avoid deadlock, if you need multiple resources then you must lock them in increasing numerical order.
|
|
typedef unsigned int Resource;
|
|
static const Resource MoveResource = 0; // Movement system, including canned cycle variables
|
|
static const Resource FileSystemResource = 1; // Non-sharable parts of the file system
|
|
static const Resource HeaterResourceBase = 2;
|
|
static const Resource FanResourceBase = HeaterResourceBase + HEATERS;
|
|
static const size_t NumResources = FanResourceBase + NUM_FANS;
|
|
|
|
static_assert(NumResources <= 32, "Too many resources to keep a bitmap of them in class GCodeMachineState");
|
|
|
|
bool LockResource(const GCodeBuffer& gb, Resource r); // Lock the resource, returning true if success
|
|
bool LockHeater(const GCodeBuffer& gb, int heater);
|
|
bool LockFan(const GCodeBuffer& gb, int fan);
|
|
bool LockFileSystem(const GCodeBuffer& gb); // Lock the unshareable parts of the file system
|
|
bool LockMovement(const GCodeBuffer& gb); // Lock movement
|
|
bool LockMovementAndWaitForStandstill(const GCodeBuffer& gb); // Lock movement and wait for pending moves to finish
|
|
void UnlockAll(const GCodeBuffer& gb); // Release all locks
|
|
|
|
void StartNextGCode(GCodeBuffer& gb, StringRef& reply); // Fetch a new or old GCode and process it
|
|
void DoFilePrint(GCodeBuffer& gb, StringRef& reply); // Get G Codes from a file and print them
|
|
bool DoFileMacro(GCodeBuffer& gb, const char* fileName, bool reportMissing = true); // Run a GCode macro in a file, optionally report error if not found
|
|
bool DoCannedCycleMove(GCodeBuffer& gb, EndstopChecks ce); // Do a move from an internally programmed canned cycle
|
|
void FileMacroCyclesReturn(GCodeBuffer& gb); // End a macro
|
|
bool ActOnCode(GCodeBuffer& gb, StringRef& reply); // Do a G, M or T Code
|
|
bool HandleGcode(GCodeBuffer& gb, StringRef& reply); // Do a G code
|
|
bool HandleMcode(GCodeBuffer& gb, StringRef& reply); // Do an M code
|
|
bool HandleTcode(GCodeBuffer& gb, StringRef& reply); // Do a T code
|
|
int SetUpMove(GCodeBuffer& gb, StringRef& reply); // Pass a move on to the Move module
|
|
bool DoDwell(GCodeBuffer& gb); // Wait for a bit
|
|
bool DoDwellTime(float dwell); // Really wait for a bit
|
|
bool DoHome(GCodeBuffer& gb, StringRef& reply, bool& error); // Home some axes
|
|
bool DoSingleZProbeAtPoint(GCodeBuffer& gb, int probePointIndex, float heightAdjust); // Probe at a given point
|
|
bool DoSingleZProbe(GCodeBuffer& gb, bool reportOnly, float heightAdjust); // Probe where we are
|
|
int DoZProbe(GCodeBuffer& gb, float distance); // Do a Z probe cycle up to the maximum specified distance
|
|
bool SetSingleZProbeAtAPosition(GCodeBuffer& gb, StringRef& reply); // Probes at a given position - see the comment at the head of the function itself
|
|
void SetBedEquationWithProbe(int sParam, StringRef& reply); // Probes a series of points and sets the bed equation
|
|
bool SetPrintZProbe(GCodeBuffer& gb, StringRef& reply); // Either return the probe value, or set its threshold
|
|
bool SetOrReportOffsets(GCodeBuffer& gb, StringRef& reply); // Deal with a G10
|
|
bool SetPositions(GCodeBuffer& gb); // Deal with a G92
|
|
unsigned int LoadMoveBufferFromGCode(GCodeBuffer& gb, int moveType); // Set up a move for the Move class
|
|
bool NoHome() const; // Are we homing and not finished?
|
|
bool Push(GCodeBuffer& gb); // Push feedrate etc on the stack
|
|
void Pop(GCodeBuffer& gb); // Pop feedrate etc
|
|
void DisableDrives(); // Turn the motors off
|
|
void SetEthernetAddress(GCodeBuffer& gb, int mCode); // Does what it says
|
|
void SetMACAddress(GCodeBuffer& gb); // Deals with an M540
|
|
void HandleReply(GCodeBuffer& gb, bool error, const char *reply); // Handle G-Code replies
|
|
void HandleReply(GCodeBuffer& gb, bool error, OutputBuffer *reply);
|
|
bool OpenFileToWrite(GCodeBuffer& gb, const char* directory, const char* fileName); // Start saving GCodes in a file
|
|
void WriteGCodeToFile(GCodeBuffer& gb); // Write this GCode into a file
|
|
bool SendConfigToLine(); // Deal with M503
|
|
void WriteHTMLToFile(GCodeBuffer& gb, char b); // Save an HTML file (usually to upload a new web interface)
|
|
bool OffsetAxes(GCodeBuffer& gb); // Set offsets - deprecated, use G10
|
|
void SetPidParameters(GCodeBuffer& gb, int heater, StringRef& reply); // Set the P/I/D parameters for a heater
|
|
void SetHeaterParameters(GCodeBuffer& gb, StringRef& reply); // Set the thermistor and ADC parameters for a heater
|
|
void ManageTool(GCodeBuffer& gb, StringRef& reply); // Create a new tool definition
|
|
void SetToolHeaters(Tool *tool, float temperature); // Set all a tool's heaters to the temperature. For M104...
|
|
bool ToolHeatersAtSetTemperatures(const Tool *tool, bool waitWhenCooling) const; // Wait for the heaters associated with the specified tool to reach their set temperatures
|
|
void StartToolChange(GCodeBuffer& gb, bool inM109); // Begin the tool change sequence
|
|
|
|
void SetAllAxesNotHomed(); // Flag all axes as not homed
|
|
void SetPositions(float positionNow[DRIVES]); // Set the current position to be this
|
|
const char *TranslateEndStopResult(EndStopHit es); // Translate end stop result to text
|
|
bool RetractFilament(GCodeBuffer& gb, bool retract); // Retract or un-retract filaments
|
|
bool ChangeMicrostepping(size_t drive, int microsteps, int mode) const; // Change microstepping on the specified drive
|
|
void ListTriggers(StringRef reply, TriggerMask mask); // Append a list of trigger endstops to a message
|
|
void CheckTriggers(); // Check for and execute triggers
|
|
void DoEmergencyStop(); // Execute an emergency stop
|
|
|
|
void DoPause(GCodeBuffer& gb) // Pause the print
|
|
pre(resourceOwners[movementResource] = &gb);
|
|
|
|
void SetMappedFanSpeed(); // Set the speeds of fans mapped for the current tool
|
|
|
|
bool DefineGrid(GCodeBuffer& gb, StringRef &reply); // Define the probing grid, returning true if error
|
|
bool ProbeGrid(GCodeBuffer& gb, StringRef& reply); // Start probing the grid, returning true if we didn't because of an error
|
|
bool SaveHeightMapToFile(StringRef& reply) const; // Save the height map to file
|
|
|
|
static uint32_t LongArrayToBitMap(const long *arr, size_t numEntries); // Convert an array of longs to a bit map
|
|
|
|
Platform* platform; // The RepRap machine
|
|
Webserver* webserver; // The web server class
|
|
|
|
GCodeBuffer* gcodeSources[6]; // The various sources of gcodes
|
|
|
|
GCodeBuffer*& httpGCode = gcodeSources[0];
|
|
GCodeBuffer*& telnetGCode = gcodeSources[1];
|
|
GCodeBuffer*& fileGCode = gcodeSources[2];
|
|
GCodeBuffer*& serialGCode = gcodeSources[3];
|
|
GCodeBuffer*& auxGCode = gcodeSources[4]; // This one is for the LCD display on the async serial interface
|
|
GCodeBuffer*& daemonGCode = gcodeSources[5]; // Used for executing config.g and trigger macro files
|
|
size_t nextGcodeSource; // The one to check next
|
|
|
|
const GCodeBuffer* resourceOwners[NumResources]; // Which gcode buffer owns each resource
|
|
|
|
bool active; // Live and running?
|
|
bool isPaused; // true if the print has been paused
|
|
bool dwellWaiting; // We are in a dwell
|
|
unsigned int segmentsLeft; // The number of segments left to do in the current move, or 0 if no move available
|
|
float dwellTime; // How long a pause for a dwell (seconds)?
|
|
RawMove moveBuffer; // Move details to pass to Move class
|
|
RestorePoint simulationRestorePoint; // The position and feed rate when we started a simulation
|
|
RestorePoint pauseRestorePoint; // The position and feed rate when we paused the print
|
|
RestorePoint toolChangeRestorePoint; // The position and feed rate when we freed a tool
|
|
size_t numAxes; // How many axes we have
|
|
size_t numExtruders; // How many extruders we have, or may have
|
|
float axisScaleFactors[MAX_AXES]; // Scale XYZ coordinates by this factor (for Delta configurations)
|
|
float lastRawExtruderPosition[MaxExtruders]; // Extruder position of the last move fed into the Move class
|
|
float rawExtruderTotalByDrive[MaxExtruders]; // Total extrusion amount fed to Move class since starting print, before applying extrusion factor, per drive
|
|
float rawExtruderTotal; // Total extrusion amount fed to Move class since starting print, before applying extrusion factor, summed over all drives
|
|
float record[DRIVES]; // Temporary store for move positions
|
|
float cannedMoveCoords[DRIVES]; // Where to go or how much to move by in a canned cycle move, last is feed rate
|
|
float cannedFeedRate; // How fast to do it
|
|
CannedMoveType cannedMoveType[DRIVES]; // Is this drive involved in a canned cycle move?
|
|
bool offSetSet; // Are any axis offsets non-zero?
|
|
float distanceScale; // MM or inches
|
|
FileData fileToPrint;
|
|
FileStore* fileBeingWritten; // A file to write G Codes (or sometimes HTML) to
|
|
uint16_t toBeHomed; // Bitmap of axes still to be homed
|
|
int oldToolNumber, newToolNumber; // Tools being changed
|
|
const char* eofString; // What's at the end of an HTML file?
|
|
uint8_t eofStringCounter; // Check the...
|
|
uint8_t eofStringLength; // ... EoF string as we read.
|
|
int probeCount; // Counts multiple probe points
|
|
int8_t cannedCycleMoveCount; // Counts through internal (i.e. not macro) canned cycle moves
|
|
bool cannedCycleMoveQueued; // True if a canned cycle move has been set
|
|
float longWait; // Timer for things that happen occasionally (seconds)
|
|
bool limitAxes; // Don't think outside the box.
|
|
uint32_t axesHomed; // Bitmap of which axes have been homed
|
|
float pausedFanValues[NUM_FANS]; // Fan speeds when the print was paused
|
|
float lastDefaultFanSpeed; // Last speed given in a M106 command with on fan number
|
|
float speedFactor; // speed factor, including the conversion from mm/min to mm/sec, normally 1/60
|
|
float extrusionFactors[MaxExtruders]; // extrusion factors (normally 1.0)
|
|
|
|
// Z probe
|
|
float lastProbedZ; // the last height at which the Z probe stopped
|
|
uint32_t lastProbedTime; // time in milliseconds that the probe was last triggered
|
|
bool zProbesSet; // True if all Z probing is done and we can set the bed equation
|
|
volatile bool zProbeTriggered; // Set by the step ISR when a move is aborted because the Z probe is triggered
|
|
size_t gridXindex, gridYindex; // Which grid probe point is next
|
|
size_t numPointsProbed;
|
|
double heightSum, heightSquaredSum;
|
|
const char *heightMapFile;
|
|
|
|
float simulationTime; // Accumulated simulation time
|
|
uint8_t simulationMode; // 0 = not simulating, 1 = simulating, >1 are simulation modes for debugging
|
|
|
|
// Firmware retraction settings
|
|
float retractLength, retractExtra; // retraction length and extra length to un-retract
|
|
float retractSpeed; // retract speed in mm/min
|
|
float unRetractSpeed; // un=retract speed in mm/min
|
|
float retractHop; // Z hop when retracting
|
|
|
|
// Triggers
|
|
Trigger triggers[MaxTriggers]; // Trigger conditions
|
|
TriggerMask lastEndstopStates; // States of the endstop inputs last time we looked
|
|
static_assert(MaxTriggers <= 32, "Too many triggers");
|
|
uint32_t triggersPending; // Bitmap of triggers pending but not yet executed
|
|
|
|
// Firmware update
|
|
uint8_t firmwareUpdateModuleMap; // Bitmap of firmware modules to be updated
|
|
bool isFlashing; // Is a new firmware binary going to be flashed?
|
|
|
|
// SHA1 hashing
|
|
FileStore *fileBeingHashed;
|
|
SHA1Context hash;
|
|
bool StartHash(const char* filename);
|
|
bool AdvanceHash(StringRef &reply);
|
|
|
|
// Misc
|
|
bool isWaiting; // True if waiting to reach temperature
|
|
bool cancelWait; // Set true to cancel waiting
|
|
};
|
|
|
|
//*****************************************************************************************************
|
|
|
|
inline bool GCodes::DoingFileMacro() const
|
|
{
|
|
return fileGCode->IsDoingFileMacro();
|
|
}
|
|
|
|
#endif
|