1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/*
* GCodeBuffer.h
*
* Created on: 6 Feb 2015
* Author: David
*/
#ifndef GCODEBUFFER_H_
#define GCODEBUFFER_H_
#include "RepRapFirmware.h"
#include "GCodeMachineState.h"
#include "MessageType.h"
// Class to hold an individual GCode and provide functions to allow it to be parsed
class GCodeBuffer
{
public:
GCodeBuffer(const char* id, MessageType mt, bool useCodeQueue);
void Reset(); // Reset it to its state after start-up
void Init(); // Set it up to parse another G-code
void Diagnostics(MessageType mtype); // Write some debug info
bool Put(char c) __attribute__((hot)); // Add a character to the end
bool Put(const char *str, size_t len); // Add an entire string, overwriting any existing content
bool IsEmpty() const; // Does this buffer contain any code?
bool Seen(char c) __attribute__((hot)); // Is a character present?
char GetCommandLetter() __attribute__((hot)); // Find the first G, M or T command
float GetFValue() __attribute__((hot)); // Get a float after a key letter
int32_t GetIValue() __attribute__((hot)); // Get an integer after a key letter
uint32_t GetUIValue(); // Get an unsigned integer value
bool GetIPAddress(uint8_t ip[4]); // Get an IP address quad after a key letter
bool GetIPAddress(uint32_t& ip); // Get an IP address quad after a key letter
const char* GetUnprecedentedString(bool optional = false); // Get a string with no preceding key letter
const char* GetString(); // Get an unquoted string after a key letter
bool GetQuotedString(const StringRef& str); // Get and copy a quoted string
bool GetPossiblyQuotedString(const StringRef& str); // Get and copy a string which may or may not be quoted
const void GetFloatArray(float a[], size_t& length, bool doPad) __attribute__((hot)); // Get a :-separated list of floats after a key letter
const void GetLongArray(long l[], size_t& length); // Get a :-separated list of longs after a key letter
void TryGetFValue(char c, float& val, bool& seen);
void TryGetIValue(char c, int32_t& val, bool& seen);
void TryGetUIValue(char c, uint32_t& val, bool& seen);
bool TryGetFloatArray(char c, size_t numVals, float vals[], const StringRef& reply, bool& seen, bool doPad = false);
bool TryGetQuotedString(char c, const StringRef& str, bool& seen);
bool TryGetPossiblyQuotedString(char c, const StringRef& str, bool& seen);
const char* Buffer() const;
bool IsIdle() const;
bool IsReady() const; // Return true if a gcode is ready but hasn't been started yet
bool IsExecuting() const; // Return true if a gcode has been started and is not paused
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
int GetToolNumberAdjust() const { return toolNumberAdjust; }
void SetToolNumberAdjust(int arg) { toolNumberAdjust = arg; }
void SetCommsProperties(uint32_t arg) { checksumRequired = (arg & 1); }
bool StartingNewCode() const { return gcodePointer == 0; }
MessageType GetResponseMessageType() const { return responseMessageType; }
GCodeMachineState& MachineState() const { return *machineState; }
GCodeMachineState& OriginalMachineState() const;
bool PushState(); // Push state returning true if successful (i.e. stack not overflowed)
bool PopState(); // Pop state returning true if successful (i.e. no stack underrun)
bool IsDoingFileMacro() const; // Return true if this source is executing a file macro
GCodeState GetState() const;
void SetState(GCodeState newState);
void AdvanceState();
const char *GetIdentity() const { return identity; }
const bool CanQueueCodes() const { return queueCodes; }
void MessageAcknowledged(bool cancelled);
FilePosition GetFilePosition(size_t bytesCached) const; // Get the file position at the start of the current command
bool IsWritingBinary() const; // returns true if writing binary
void SetBinaryWriting(bool state); // set true if writing binary
uint32_t GetCRC32() const;
void SetCRC32(uint32_t newCRC32);
uint32_t whenTimerStarted; // when we started waiting
bool timerRunning; // true if we are waiting
private:
enum class GCodeBufferState
{
idle, // we don't have a complete gcode ready
ready, // we have a complete gcode but haven't started executing it
executing // we have a complete gcode and have started executing it
};
int CheckSum() const; // Compute the checksum (if any) at the end of the G Code
GCodeMachineState *machineState; // Machine state for this gcode source
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
unsigned int commandLength; // Number of characters we read to build this command including the final \r or \n
int readPointer; // Where in the buffer to read next
bool inQuotes; // Are we inside double quotation marks?
bool inComment; // Are we after a ';' character?
bool checksumRequired; // True if we only accept commands with a valid checksum
GCodeBufferState bufferState; // Idle, executing or paused
const char* writingFileDirectory; // If the G Code is going into a file, where that is
int toolNumberAdjust; // The adjustment to tool numbers in commands we receive
const MessageType responseMessageType; // The message type we use for responses to commands coming from this channel
bool queueCodes; // Can we queue certain G-codes from this source?
bool binaryWriting; // Executing gcode or writing binary file?
uint32_t crc32; // crc32 of the binary file
};
inline uint32_t GCodeBuffer::GetCRC32() const
{
return crc32;
}
inline void GCodeBuffer::SetCRC32(uint32_t newCRC32)
{
crc32 = newCRC32;
}
inline bool GCodeBuffer::IsWritingBinary() const
{
return binaryWriting;
}
inline void GCodeBuffer::SetBinaryWriting(bool state)
{
binaryWriting = state;
}
inline const char* GCodeBuffer::Buffer() const
{
return gcodeBuffer;
}
inline bool GCodeBuffer::IsIdle() const
{
return bufferState == GCodeBufferState::idle;
}
inline bool GCodeBuffer::IsReady() const
{
return bufferState == GCodeBufferState::ready;
}
inline bool GCodeBuffer::IsExecuting() const
{
return bufferState == GCodeBufferState::executing;
}
inline const char* GCodeBuffer::WritingFileDirectory() const
{
return writingFileDirectory;
}
inline void GCodeBuffer::SetWritingFileDirectory(const char* wfd)
{
writingFileDirectory = wfd;
}
inline GCodeState GCodeBuffer::GetState() const
{
return machineState->state;
}
inline void GCodeBuffer::SetState(GCodeState newState)
{
machineState->state = newState;
}
inline void GCodeBuffer::AdvanceState()
{
machineState->state = static_cast<GCodeState>(static_cast<uint8_t>(machineState->state) + 1);
}
#endif /* GCODEBUFFER_H_ */
|
