63ea3b0554
This will allow for multi extruder printing support in future pull requests. It works fine for single extruder setups as well as the selected head is always E0.
241 lines
11 KiB
C++
241 lines
11 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
|
|
|
|
#define STACK 5
|
|
#define GCODE_LENGTH 100 // Maximum length of internally-generated G Code string
|
|
|
|
#define GCODE_LETTERS { 'X', 'Y', 'Z', 'E', 'F' } // The drives and feedrate in a GCode //FIXME when working with multiple extruders GCODE_LETTERS[DRIVES] is out of scope
|
|
#define FEEDRATE_LETTER 'F'//FIX to work with multiple extruders without having to re-define GCODE_LETTERS array
|
|
|
|
// Small class to hold an individual GCode and provide functions to allow it to be parsed
|
|
|
|
class GCodeBuffer
|
|
{
|
|
public:
|
|
GCodeBuffer(Platform* p, const char* id);
|
|
void Init(); // Set it up
|
|
bool Put(char c); // Add a character to the end
|
|
bool Seen(char c); // Is a character present?
|
|
float GetFValue(); // Get a float after a key letter
|
|
int GetIValue(); // Get an integer after a key letter
|
|
long GetLValue(); // Get a long integer after a key letter
|
|
const char* GetUnprecedentedString(); // Get a string with no preceeding key letter
|
|
const char* GetString(); // Get a string after a key letter
|
|
const char* Buffer(); // All of the G Code itself
|
|
bool Finished() const; // Has the G Code been executed?
|
|
void SetFinished(bool f); // Set the G Code executed (or not)
|
|
const char* WritingFileDirectory() const; // If we are writing the G Code to a file, where that file is
|
|
void SetWritingFileDirectory(const char* wfd); // Set the directory for the file to write the GCode in
|
|
|
|
private:
|
|
int CheckSum(); // Compute the checksum (if any) at the end of the G Code
|
|
Platform* platform; // Pointer to the RepRap's controlling class
|
|
char gcodeBuffer[GCODE_LENGTH]; // The G Code
|
|
const char* identity; // Where we are from (web, file, serial line etc)
|
|
int gcodePointer; // Index in the buffer
|
|
int readPointer; // Where in the buffer to read next
|
|
bool inComment; // Are we after a ';' character?
|
|
bool finished; // Has the G Code been executed?
|
|
const char* writingFileDirectory; // If the G Code is going into a file, where that is
|
|
};
|
|
|
|
//****************************************************************************************************
|
|
|
|
// The GCode interpreter
|
|
|
|
class GCodes
|
|
{
|
|
public:
|
|
|
|
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
|
|
bool RunConfigurationGCodes(); // Run the configuration G Code file on reboot
|
|
bool ReadMove(float* m, bool& ce); // Called by the Move class to get a movement set by the last G Code
|
|
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); // Get pre-recorded probe coordinates
|
|
char* GetCurrentCoordinates(); // Get where we are as a string
|
|
bool PrintingAFile() const; // Are we in the middle of printing a file?
|
|
void Diagnostics(); // Send helpful information out
|
|
int8_t GetSelectedHead(); // return which tool is selected
|
|
bool HaveIncomingData() const; // Is there something that we have to do?
|
|
bool GetAxisIsHomed(uint8_t axis) const { return axisIsHomed[axis]; } // Is the axis at 0?
|
|
|
|
private:
|
|
|
|
void DoFilePrint(GCodeBuffer* gb); // Get G Codes from a file and print them
|
|
bool AllMovesAreFinishedAndMoveBufferIsLoaded(); // Wait for move queue to exhaust and the current position is loaded
|
|
bool DoCannedCycleMove(bool ce); // Do a move from an internally programmed canned cycle
|
|
bool DoFileCannedCycles(const char* fileName); // Run a GCode macro in a file
|
|
bool FileCannedCyclesReturn(); // End a macro
|
|
bool ActOnGcode(GCodeBuffer* gb); // Do the G Code
|
|
bool SetUpMove(GCodeBuffer* gb); // Set up a new movement
|
|
bool DoDwell(GCodeBuffer *gb); // Wait for a bit
|
|
bool DoHome(char *reply, bool& error); // Home some axes
|
|
bool DoSingleZProbeAtPoint(); // Probe at a given point
|
|
bool DoSingleZProbe(); // Probe where we are
|
|
bool SetSingleZProbeAtAPosition(GCodeBuffer *gb); // Probes at a given position - see the comment at the head of the function itself
|
|
bool DoMultipleZProbe(); // Probes a series of points and sets the bed equation
|
|
bool SetPrintZProbe(GCodeBuffer *gb, char *reply); // Either return the probe value, or set its threshold
|
|
bool SetOffsets(GCodeBuffer *gb); // Deal with a G10
|
|
bool SetPositions(GCodeBuffer *gb); // Deal with a G92
|
|
void LoadMoveBufferFromGCode(GCodeBuffer *gb, // Set up a move for the Move class
|
|
bool doingG92, bool applyLimits);
|
|
bool NoHome() const; // Are we homing and not finished?
|
|
bool Push(); // Push feedrate etc on the stack
|
|
bool Pop(); // Pop feedrate etc
|
|
bool DisableDrives(); // Turn the motors off
|
|
bool StandbyHeaters(); // Set all heaters to standby temperatures
|
|
void SetEthernetAddress(GCodeBuffer *gb, int mCode); // Does what it says
|
|
void HandleReply(bool error, bool fromLine, const char* reply, // If the GCode is from the serial interface, reply to it
|
|
char gMOrT, int code, bool resend);
|
|
void OpenFileToWrite(const char* directory, // Start saving GCodes in a file
|
|
const char* fileName, GCodeBuffer *gb);
|
|
void WriteGCodeToFile(GCodeBuffer *gb); // Write this GCode into a file
|
|
bool SendConfigToLine(); // Deal with M503
|
|
void WriteHTMLToFile(char b, GCodeBuffer *gb); // Save an HTML file (usually to upload a new web interface)
|
|
bool OffsetAxes(GCodeBuffer *gb); // Set offsets - deprecated, use G10
|
|
int8_t Heater(int8_t head) const; // Legacy G codes start heaters at 0, but we use 0 for the bed. This sorts that out.
|
|
|
|
Platform* platform; // The RepRap machine
|
|
bool active; // Live and running?
|
|
Webserver* webserver; // The webserver class
|
|
float dwellTime; // How long a pause for a dwell (seconds)?
|
|
bool dwellWaiting; // We are in a dwell
|
|
GCodeBuffer* webGCode; // The sources...
|
|
GCodeBuffer* fileGCode; // ...
|
|
GCodeBuffer* serialGCode; // ...
|
|
GCodeBuffer* cannedCycleGCode; // ... of G Codes
|
|
bool moveAvailable; // Have we seen a move G Code and set it up?
|
|
float moveBuffer[DRIVES+1]; // Move coordinates; last is feed rate
|
|
bool checkEndStops; // Should we check them on the next move?
|
|
bool drivesRelative; // Are movements relative - all except X, Y and Z
|
|
bool axesRelative; // Are movements relative - X, Y and Z
|
|
bool drivesRelativeStack[STACK]; // For dealing with Push and Pop
|
|
bool axesRelativeStack[STACK]; // For dealing with Push and Pop
|
|
float feedrateStack[STACK]; // For dealing with Push and Pop
|
|
FileStore* fileStack[STACK]; // For dealing with Push and Pop
|
|
int8_t stackPointer; // Push and Pop stack pointer
|
|
char gCodeLetters[DRIVES + 1]; // 'X', 'Y' etc. Extra is for F
|
|
float lastPos[DRIVES - AXES]; // Just needed for relative moves; i.e. not X, Y and Z
|
|
float record[DRIVES+1]; // Temporary store for move positions
|
|
float moveToDo[DRIVES+1]; // Where to go set by G1 etc
|
|
bool activeDrive[DRIVES+1]; // Is this drive involved in a move?
|
|
bool offSetSet; // Are any axis offsets non-zero?
|
|
float distanceScale; // MM or inches
|
|
FileStore* fileBeingPrinted; // The file being printed at the moment (if any)
|
|
FileStore* fileToPrint; // A file to print in the future, or one that has been paused
|
|
FileStore* fileBeingWritten; // A file to write G Codes (or sometimes HTML) in
|
|
FileStore* configFile; // A file containing a macro
|
|
bool doingCannedCycleFile; // Are we executing a macro file?
|
|
char* eofString; // What's at the end of an HTML file?
|
|
uint8_t eofStringCounter; // Check the...
|
|
uint8_t eofStringLength; // ... EoF string as we read.
|
|
int8_t selectedHead; // Which extruder is in use
|
|
bool homeX; // True to home the X axis this move
|
|
bool homeY; // True to home the Y axis this move
|
|
bool homeZ; // True to home the Z axis this move
|
|
int8_t homeAxisMoveCount; // Counts homing moves
|
|
float gFeedRate; // Store for the current feedrate
|
|
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
|
|
bool zProbesSet; // True if all Z probing is done and we can set the bed equation
|
|
float longWait; // Timer for things that happen occasionally (seconds)
|
|
bool axisIsHomed[3]; // These record which of the axes have been homed
|
|
};
|
|
|
|
//*****************************************************************************************************
|
|
|
|
// Get an Int after a G Code letter
|
|
|
|
inline int GCodeBuffer::GetIValue()
|
|
{
|
|
return (int)GetLValue();
|
|
}
|
|
|
|
inline const char* GCodeBuffer::Buffer()
|
|
{
|
|
return gcodeBuffer;
|
|
}
|
|
|
|
inline bool GCodeBuffer::Finished() const
|
|
{
|
|
return finished;
|
|
}
|
|
|
|
inline void GCodeBuffer::SetFinished(bool f)
|
|
{
|
|
finished = f;
|
|
}
|
|
|
|
inline const char* GCodeBuffer::WritingFileDirectory() const
|
|
{
|
|
return writingFileDirectory;
|
|
}
|
|
|
|
inline void GCodeBuffer::SetWritingFileDirectory(const char* wfd)
|
|
{
|
|
writingFileDirectory = wfd;
|
|
}
|
|
|
|
inline bool GCodes::PrintingAFile() const
|
|
{
|
|
return fileBeingPrinted != NULL;
|
|
}
|
|
|
|
inline bool GCodes::HaveIncomingData() const
|
|
{
|
|
return fileBeingPrinted != NULL || webserver->GCodeAvailable() || (platform->GetLine()->Status() & byteAvailable);
|
|
}
|
|
|
|
inline bool GCodes::NoHome() const
|
|
{
|
|
return !(homeX || homeY || homeZ || homeAxisMoveCount);
|
|
}
|
|
|
|
// This function takes care of the fact that the heater and head indices
|
|
// don't match because the bed is heater 0.
|
|
|
|
inline int8_t GCodes::Heater(int8_t head) const
|
|
{
|
|
return head+1;
|
|
}
|
|
|
|
// Run the configuration G Code file to set up the machine. Usually just called once
|
|
// on re-boot.
|
|
|
|
inline bool GCodes::RunConfigurationGCodes()
|
|
{
|
|
return !DoFileCannedCycles(platform->GetConfigFile());
|
|
}
|
|
|
|
inline int8_t GCodes::GetSelectedHead()
|
|
{
|
|
return selectedHead;
|
|
}
|
|
|
|
#endif
|