path: root/src/GCodes/GCodes.h

/****************************************************************************************************

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 that this move was read from
		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
	};
  
    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(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
	FilePosition filePos;						// The position we got up to in the file being printed

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