31adc97abf
Corrected case of geometry string passed to PanelDue Added stepper motor idle mode Added experimental 6-point Delta calibration
1457 lines
38 KiB
C++
1457 lines
38 KiB
C++
|
|
/****************************************************************************************************
|
|
|
|
RepRapFirmware - Main Program
|
|
|
|
This firmware is intended to be a fully object-oriented highly modular control program for
|
|
RepRap self-replicating 3D printers.
|
|
|
|
It owes a lot to Marlin and to the original RepRap FiveD_GCode.
|
|
|
|
|
|
General design principles:
|
|
|
|
* Control by RepRap G Codes. These are taken to be machine independent, though some may be unsupported.
|
|
* Full use of C++ OO techniques,
|
|
* Make classes hide their data,
|
|
* Make everything except the Platform class (see below) as stateless as possible,
|
|
* No use of conditional compilation except for #include guards - if you need that, you should be
|
|
forking the repository to make a new branch - let the repository take the strain,
|
|
* Concentration of all machine-dependent definitions and code in Platform.h and Platform.cpp,
|
|
* No specials for (X,Y) or (Z) - all movement is 3-dimensional,
|
|
* Except in Platform.h, use real units (mm, seconds etc) throughout the rest of the code wherever possible,
|
|
* Try to be efficient in memory use, but this is not critical,
|
|
* Labour hard to be efficient in time use, and this is critical,
|
|
* Don't abhor floats - they work fast enough if you're clever,
|
|
* Don't avoid arrays and structs/classes,
|
|
* Don't avoid pointers,
|
|
* Use operator and function overloading where appropriate.
|
|
|
|
|
|
Naming conventions:
|
|
|
|
* #defines are all CAPITALS_WITH_OPTIONAL_UNDERSCORES_BETWEEN_WORDS
|
|
* No underscores in other names - MakeReadableWithCapitalisation
|
|
* Class names and functions start with a CapitalLetter
|
|
* Variables start with a lowerCaseLetter
|
|
* Use veryLongDescriptiveNames
|
|
|
|
|
|
Structure:
|
|
|
|
There are eight main classes:
|
|
|
|
* RepRap
|
|
* GCodes
|
|
* Heat
|
|
* Move
|
|
* Platform
|
|
* Network
|
|
* Webserver, and
|
|
* PrintMonitor
|
|
|
|
RepRap:
|
|
|
|
This is just a container class for the single instances of all the others, and otherwise does very little.
|
|
|
|
GCodes:
|
|
|
|
This class is fed GCodes, either from the web interface, or from GCode files, or from a serial interface,
|
|
Interprets them, and requests actions from the RepRap machine via the other classes.
|
|
|
|
Heat:
|
|
|
|
This class implements all heating and temperature control in the RepRap machine.
|
|
|
|
Move:
|
|
|
|
This class controls all movement of the RepRap machine, both along its axes, and in its extruder drives.
|
|
|
|
Platform:
|
|
|
|
This is the only class that knows anything about the physical setup of the RepRap machine and its
|
|
controlling electronics. It implements the interface between all the other classes and the RepRap machine.
|
|
All the other classes are completely machine-independent (though they may declare arrays dimensioned
|
|
to values #defined in Platform.h).
|
|
|
|
Network:
|
|
|
|
This class implements a basic TCP interface for the Webserver classes using lwip.
|
|
|
|
Webserver:
|
|
|
|
This class talks to the network (via Platform) and implements a simple webserver to give an interactive
|
|
interface to the RepRap machine. It uses the Knockout and Jquery Javascript libraries to achieve this.
|
|
In addition, FTP and Telnet servers are provided for easier SD card file management and G-Code handling.
|
|
|
|
PrintMonitor:
|
|
|
|
This class provides methods to obtain statistics (height, filament usage etc.) from generated G-Code
|
|
files and to calculate estimated print end-times for a live print.
|
|
|
|
|
|
When the software is running there is one single instance of each main class, and all the memory allocation is
|
|
done on initialization. new/malloc should not be used in the general running code, and delete is never
|
|
used. Each class has an Init() function that resets it to its boot-up state; the constructors merely handle
|
|
that memory allocation on startup. Calling RepRap.Init() calls all the other Init()s in the right sequence.
|
|
|
|
There are other ancillary classes that are declared in the .h files for the master classes that use them. For
|
|
example, Move has a DDA class that implements a Bresenham/digital differential analyser.
|
|
|
|
|
|
Timing:
|
|
|
|
There is a single interrupt chain entered via Platform.Interrupt(). This controls movement step timing, and
|
|
this chain of code should be the only place that volatile declarations and structure/variable-locking are
|
|
required. All the rest of the code is called sequentially and repeatedly as follows:
|
|
|
|
All the main classes have a Spin() function. These are called in a loop by the RepRap.Spin() function and implement
|
|
simple timesharing. No class does, or ever should, wait inside one of its functions for anything to happen or call
|
|
any sort of delay() function. The general rule is:
|
|
|
|
Can I do a thing?
|
|
Yes - do it
|
|
No - set a flag/timer to remind me to do it next-time-I'm-called/at-a-future-time and return.
|
|
|
|
The restriction this strategy places on almost all the code in the firmware (that it must execute quickly and
|
|
never cause waits or delays) is balanced by the fact that none of that code needs to worry about synchronization,
|
|
locking, or other areas of code accessing items upon which it is working. As mentioned, only the interrupt
|
|
chain needs to concern itself with such problems. Unlike movement, heating (including PID controllers) does
|
|
not need the fast precision of timing that interrupts alone can offer. Indeed, most heating code only needs
|
|
to execute a couple of times a second.
|
|
|
|
Most data is transferred bytewise, with classes' Spin() functions typically containing code like this:
|
|
|
|
Is a byte available for me?
|
|
Yes
|
|
read it and add it to my buffer
|
|
Is my buffer complete?
|
|
Yes
|
|
Act on the contents of my buffer
|
|
No
|
|
Return
|
|
No
|
|
Return
|
|
|
|
Note that it is simple to raise the "priority" of any class's activities relative to the others by calling its
|
|
Spin() function more than once from RepRap.Spin().
|
|
|
|
-----------------------------------------------------------------------------------------------------
|
|
|
|
Version 0.1
|
|
|
|
18 November 2012
|
|
|
|
Adrian Bowyer
|
|
RepRap Professional Ltd
|
|
http://reprappro.com
|
|
|
|
Licence: GPL
|
|
|
|
****************************************************************************************************/
|
|
|
|
#include "RepRapFirmware.h"
|
|
|
|
// We just need one instance of RepRap; everything else is contained within it and hidden
|
|
|
|
RepRap reprap;
|
|
|
|
const char *moduleName[] =
|
|
{
|
|
"Platform",
|
|
"Network",
|
|
"Webserver",
|
|
"GCodes",
|
|
"Move",
|
|
"Heat",
|
|
"DDA",
|
|
"PrintMonitor",
|
|
"?","?","?","?","?","?","?",
|
|
"none"
|
|
};
|
|
|
|
//*************************************************************************************************
|
|
|
|
// RepRap member functions.
|
|
|
|
// Do nothing more in the constructor; put what you want in RepRap:Init()
|
|
|
|
RepRap::RepRap() : active(false), debug(0), stopped(false), spinningModule(noModule), ticksInSpinState(0),
|
|
resetting(false), gcodeReply(gcodeReplyBuffer, GCODE_REPLY_LENGTH)
|
|
{
|
|
platform = new Platform();
|
|
network = new Network(platform);
|
|
webserver = new Webserver(platform, network);
|
|
gCodes = new GCodes(platform, webserver);
|
|
move = new Move(platform, gCodes);
|
|
heat = new Heat(platform, gCodes);
|
|
printMonitor = new PrintMonitor(platform, gCodes);
|
|
toolList = NULL;
|
|
}
|
|
|
|
void RepRap::Init()
|
|
{
|
|
debug = 0;
|
|
activeExtruders = 1; // we always report at least 1 extruder to the web interface
|
|
activeHeaters = 2; // we always report the bed heater + 1 extruder heater to the web interface
|
|
SetPassword(DEFAULT_PASSWORD);
|
|
SetName(DEFAULT_NAME);
|
|
|
|
beepFrequency = beepDuration = 0;
|
|
message[0] = 0;
|
|
|
|
gcodeReply[0] = 0;
|
|
replySeq = 0;
|
|
processingConfig = true;
|
|
|
|
// All of the following init functions must execute reasonably quickly before the watchdog times us out
|
|
platform->Init();
|
|
gCodes->Init();
|
|
webserver->Init();
|
|
move->Init();
|
|
heat->Init();
|
|
printMonitor->Init();
|
|
currentTool = NULL;
|
|
message[0] = 0;
|
|
const uint32_t wdtTicks = 256; // number of watchdog ticks @ 32768Hz/128 before the watchdog times out (max 4095)
|
|
WDT_Enable(WDT, (wdtTicks << WDT_MR_WDV_Pos) | (wdtTicks << WDT_MR_WDD_Pos) | WDT_MR_WDRSTEN); // enable watchdog, reset the mcu if it times out
|
|
coldExtrude = true; // DC42 changed default to true for compatibility because for now we are aiming for compatibility with RRP 0.78
|
|
active = true; // must do this before we start the network, else the watchdog may time out
|
|
|
|
platform->Message(HOST_MESSAGE, "%s Version %s dated %s\n", NAME, VERSION, DATE);
|
|
FileStore *startup = platform->GetFileStore(platform->GetSysDir(), platform->GetConfigFile(), false);
|
|
|
|
platform->AppendMessage(HOST_MESSAGE, "\n\nExecuting ");
|
|
if(startup != NULL)
|
|
{
|
|
startup->Close();
|
|
platform->AppendMessage(HOST_MESSAGE, "%s...\n\n", platform->GetConfigFile());
|
|
scratchString.printf("M98 P%s\n", platform->GetConfigFile());
|
|
}
|
|
else
|
|
{
|
|
platform->AppendMessage(HOST_MESSAGE, "%s (no configuration file found)...\n\n", platform->GetDefaultFile());
|
|
scratchString.printf("M98 P%s\n", platform->GetDefaultFile());
|
|
}
|
|
|
|
// We inject an M98 into the serial input stream to run the start-up macro
|
|
|
|
platform->GetLine()->InjectString(scratchString.Pointer());
|
|
|
|
bool runningTheFile = false;
|
|
bool initialisingInProgress = true;
|
|
while (initialisingInProgress)
|
|
{
|
|
Spin();
|
|
if(gCodes->DoingFileMacro())
|
|
{
|
|
runningTheFile = true;
|
|
}
|
|
if(runningTheFile)
|
|
{
|
|
if(!gCodes->DoingFileMacro())
|
|
{
|
|
initialisingInProgress = false;
|
|
}
|
|
}
|
|
}
|
|
processingConfig = false;
|
|
|
|
if (network->IsEnabled())
|
|
{
|
|
platform->AppendMessage(HOST_MESSAGE, "\nStarting network...\n");
|
|
network->Init(); // Need to do this here, as the configuration GCodes may set IP address etc.
|
|
}
|
|
else
|
|
{
|
|
platform->AppendMessage(HOST_MESSAGE, "\nNetwork disabled.\n");
|
|
}
|
|
|
|
platform->AppendMessage(HOST_MESSAGE, "\n%s is up and running.\n", NAME);
|
|
fastLoop = FLT_MAX;
|
|
slowLoop = 0.0;
|
|
lastTime = platform->Time();
|
|
}
|
|
|
|
void RepRap::Exit()
|
|
{
|
|
active = false;
|
|
heat->Exit();
|
|
move->Exit();
|
|
gCodes->Exit();
|
|
webserver->Exit();
|
|
platform->Message(HOST_MESSAGE, "RepRap class exited.\n");
|
|
platform->Exit();
|
|
}
|
|
|
|
void RepRap::Spin()
|
|
{
|
|
if(!active)
|
|
return;
|
|
|
|
spinningModule = modulePlatform;
|
|
ticksInSpinState = 0;
|
|
platform->Spin();
|
|
|
|
spinningModule = moduleNetwork;
|
|
ticksInSpinState = 0;
|
|
network->Spin();
|
|
|
|
spinningModule = moduleWebserver;
|
|
ticksInSpinState = 0;
|
|
webserver->Spin();
|
|
|
|
spinningModule = moduleGcodes;
|
|
ticksInSpinState = 0;
|
|
gCodes->Spin();
|
|
|
|
spinningModule = moduleMove;
|
|
ticksInSpinState = 0;
|
|
move->Spin();
|
|
|
|
spinningModule = moduleHeat;
|
|
ticksInSpinState = 0;
|
|
heat->Spin();
|
|
|
|
spinningModule = modulePrintMonitor;
|
|
ticksInSpinState = 0;
|
|
printMonitor->Spin();
|
|
|
|
spinningModule = noModule;
|
|
ticksInSpinState = 0;
|
|
|
|
// Keep track of the loop time
|
|
|
|
float t = platform->Time();
|
|
float dt = t - lastTime;
|
|
if(dt < fastLoop)
|
|
{
|
|
fastLoop = dt;
|
|
}
|
|
if(dt > slowLoop)
|
|
{
|
|
slowLoop = dt;
|
|
}
|
|
lastTime = t;
|
|
}
|
|
|
|
void RepRap::Timing()
|
|
{
|
|
platform->AppendMessage(BOTH_MESSAGE, "Slowest main loop (seconds): %f; fastest: %f\n", slowLoop, fastLoop);
|
|
fastLoop = FLT_MAX;
|
|
slowLoop = 0.0;
|
|
}
|
|
|
|
void RepRap::Diagnostics()
|
|
{
|
|
platform->Diagnostics(); // this includes a call to our Timing() function
|
|
move->Diagnostics();
|
|
heat->Diagnostics();
|
|
gCodes->Diagnostics();
|
|
network->Diagnostics();
|
|
webserver->Diagnostics();
|
|
}
|
|
|
|
// Turn off the heaters, disable the motors, and
|
|
// deactivate the Heat and Move classes. Leave everything else
|
|
// working.
|
|
|
|
void RepRap::EmergencyStop()
|
|
{
|
|
stopped = true;
|
|
platform->SetAtxPower(false); // turn off the ATX power if we can
|
|
|
|
//platform->DisableInterrupts();
|
|
|
|
Tool* tool = toolList;
|
|
while(tool)
|
|
{
|
|
tool->Standby();
|
|
tool = tool->Next();
|
|
}
|
|
|
|
heat->Exit();
|
|
for(int8_t heater = 0; heater < HEATERS; heater++)
|
|
{
|
|
platform->SetHeater(heater, 0.0);
|
|
}
|
|
|
|
// We do this twice, to avoid an interrupt switching
|
|
// a drive back on. move->Exit() should prevent
|
|
// interrupts doing this.
|
|
|
|
for(int8_t i = 0; i < 2; i++)
|
|
{
|
|
move->Exit();
|
|
for(int8_t drive = 0; drive < DRIVES; drive++)
|
|
{
|
|
platform->SetMotorCurrent(drive, 0.0);
|
|
platform->DisableDrive(drive);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RepRap::SetDebug(Module m, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
debug |= (1 << m);
|
|
}
|
|
else
|
|
{
|
|
debug &= ~(1 << m);
|
|
}
|
|
PrintDebug();
|
|
}
|
|
|
|
void RepRap::SetDebug(bool enable)
|
|
{
|
|
debug = (enable) ? 0xFFFF : 0;
|
|
}
|
|
|
|
void RepRap::PrintDebug()
|
|
{
|
|
if (debug != 0)
|
|
{
|
|
platform->Message(BOTH_MESSAGE, "Debugging enabled for modules:");
|
|
for(uint8_t i=0; i<16;i++)
|
|
{
|
|
if (debug & (1 << i))
|
|
{
|
|
platform->AppendMessage(BOTH_MESSAGE, " %s", moduleName[i]);
|
|
}
|
|
}
|
|
platform->AppendMessage(BOTH_MESSAGE, "\n");
|
|
}
|
|
else
|
|
{
|
|
platform->Message(BOTH_MESSAGE, "Debugging disabled\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The first tool added becomes the one selected. This will not happen in future releases.
|
|
*/
|
|
|
|
void RepRap::AddTool(Tool* tool)
|
|
{
|
|
if(toolList == NULL)
|
|
{
|
|
toolList = tool;
|
|
currentTool = tool;
|
|
tool->Activate(currentTool);
|
|
return;
|
|
}
|
|
|
|
toolList->AddTool(tool);
|
|
tool->UpdateExtruderAndHeaterCount(activeExtruders, activeHeaters);
|
|
}
|
|
|
|
void RepRap::SelectTool(int toolNumber)
|
|
{
|
|
Tool* tool = toolList;
|
|
|
|
while(tool)
|
|
{
|
|
if(tool->Number() == toolNumber)
|
|
{
|
|
tool->Activate(currentTool);
|
|
currentTool = tool;
|
|
return;
|
|
}
|
|
tool = tool->Next();
|
|
}
|
|
|
|
// Selecting a non-existent tool is valid. It sets them all to standby.
|
|
|
|
if(currentTool != NULL)
|
|
{
|
|
StandbyTool(currentTool->Number());
|
|
}
|
|
currentTool = NULL;
|
|
|
|
}
|
|
|
|
void RepRap::PrintTool(int toolNumber, StringRef& reply) const
|
|
{
|
|
for(Tool *tool = toolList; tool != NULL; tool = tool->next)
|
|
{
|
|
if(tool->Number() == toolNumber)
|
|
{
|
|
tool->Print(reply);
|
|
return;
|
|
}
|
|
}
|
|
reply.copy("Attempt to print details of non-existent tool.\n");
|
|
}
|
|
|
|
void RepRap::StandbyTool(int toolNumber)
|
|
{
|
|
Tool* tool = toolList;
|
|
|
|
while(tool)
|
|
{
|
|
if(tool->Number() == toolNumber)
|
|
{
|
|
tool->Standby();
|
|
if(currentTool == tool)
|
|
{
|
|
currentTool = NULL;
|
|
}
|
|
return;
|
|
}
|
|
tool = tool->Next();
|
|
}
|
|
|
|
platform->Message(BOTH_MESSAGE, "Attempt to standby a non-existent tool: %d.\n", toolNumber);
|
|
}
|
|
|
|
Tool* RepRap::GetTool(int toolNumber)
|
|
{
|
|
Tool* tool = toolList;
|
|
|
|
while(tool)
|
|
{
|
|
if(tool->Number() == toolNumber)
|
|
{
|
|
return tool;
|
|
}
|
|
tool = tool->Next();
|
|
}
|
|
return NULL; // Not an error
|
|
}
|
|
|
|
#if 0 // not used
|
|
Tool* RepRap::GetToolByDrive(int driveNumber)
|
|
{
|
|
Tool* tool = toolList;
|
|
|
|
while (tool)
|
|
{
|
|
for(uint8_t drive = 0; drive < tool->DriveCount(); drive++)
|
|
{
|
|
if (tool->Drive(drive) + AXES == driveNumber)
|
|
{
|
|
return tool;
|
|
}
|
|
}
|
|
|
|
tool = tool->Next();
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
void RepRap::SetToolVariables(int toolNumber, float* standbyTemperatures, float* activeTemperatures)
|
|
{
|
|
Tool* tool = toolList;
|
|
|
|
while(tool)
|
|
{
|
|
if(tool->Number() == toolNumber)
|
|
{
|
|
tool->SetVariables(standbyTemperatures, activeTemperatures);
|
|
return;
|
|
}
|
|
tool = tool->Next();
|
|
}
|
|
|
|
platform->Message(BOTH_MESSAGE, "Attempt to set variables for a non-existent tool: %d.\n", toolNumber);
|
|
}
|
|
|
|
|
|
void RepRap::Tick()
|
|
{
|
|
if (active)
|
|
{
|
|
WDT_Restart(WDT); // kick the watchdog
|
|
if (!resetting)
|
|
{
|
|
platform->Tick();
|
|
++ticksInSpinState;
|
|
if (ticksInSpinState >= 20000) // if we stall for 20 seconds, save diagnostic data and reset
|
|
{
|
|
resetting = true;
|
|
for(uint8_t i = 0; i < HEATERS; i++)
|
|
{
|
|
platform->SetHeater(i, 0.0);
|
|
}
|
|
for(uint8_t i = 0; i < DRIVES; i++)
|
|
{
|
|
platform->DisableDrive(i);
|
|
// We can't set motor currents to 0 here because that requires interrupts to be working, and we are in an ISR
|
|
}
|
|
|
|
platform->SoftwareReset(SoftwareResetReason::stuckInSpin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the JSON status response for the web server (or later for the M105 command).
|
|
// Type 1 is the ordinary JSON status response.
|
|
// Type 2 is the same except that static parameters are also included.
|
|
// Type 3 is the same but instead of static parameters we report print estimation values.
|
|
void RepRap::GetStatusResponse(StringRef& response, uint8_t type, bool forWebserver)
|
|
{
|
|
// Machine status
|
|
response.printf("{\"status\":\"%c\",\"coords\":{", GetStatusCharacter());
|
|
|
|
/* Coordinates */
|
|
{
|
|
float liveCoordinates[DRIVES + 1];
|
|
if (currentTool != NULL)
|
|
{
|
|
const float *offset = currentTool->GetOffset();
|
|
for (size_t i = 0; i < AXES; ++i)
|
|
{
|
|
liveCoordinates[i] += offset[i];
|
|
}
|
|
}
|
|
move->LiveCoordinates(liveCoordinates);
|
|
|
|
// Homed axes
|
|
response.catf("\"axesHomed\":[%d,%d,%d]",
|
|
(gCodes->GetAxisIsHomed(0)) ? 1 : 0,
|
|
(gCodes->GetAxisIsHomed(1)) ? 1 : 0,
|
|
(gCodes->GetAxisIsHomed(2)) ? 1 : 0);
|
|
|
|
// Actual and theoretical extruder positions since power up, last G92 or last M23
|
|
response.catf(",\"extr\":"); // announce actual extruder positions
|
|
char ch = '[';
|
|
for (size_t extruder = 0; extruder < GetExtrudersInUse(); extruder++)
|
|
{
|
|
response.catf("%c%.1f", ch, liveCoordinates[AXES + extruder]);
|
|
ch = ',';
|
|
}
|
|
|
|
// XYZ positions
|
|
response.cat("],\"xyz\":");
|
|
ch = '[';
|
|
for (size_t axis = 0; axis < AXES; axis++)
|
|
{
|
|
response.catf("%c%.2f", ch, liveCoordinates[axis]);
|
|
ch = ',';
|
|
}
|
|
}
|
|
|
|
// Current tool number
|
|
int toolNumber = (currentTool == NULL) ? 0 : currentTool->Number();
|
|
response.catf("]},\"currentTool\":%d", toolNumber);
|
|
|
|
/* Output - only reported once */
|
|
{
|
|
bool sendBeep = (beepDuration != 0 && beepFrequency != 0);
|
|
bool sendMessage = (message[0]) && ((gCodes->HaveAux() && !forWebserver) || (!gCodes->HaveAux() && forWebserver));
|
|
if (sendBeep || sendMessage)
|
|
{
|
|
response.cat(",\"output\":{");
|
|
|
|
// Report beep values
|
|
if (sendBeep)
|
|
{
|
|
response.catf("\"beepDuration\":%d,\"beepFrequency\":%d", beepDuration, beepFrequency);
|
|
if (sendMessage)
|
|
{
|
|
response.cat(",");
|
|
}
|
|
|
|
beepFrequency = beepDuration = 0;
|
|
}
|
|
|
|
// Report message
|
|
if (sendMessage)
|
|
{
|
|
response.cat("\"message\":");
|
|
EncodeString(response, message, 2, false);
|
|
|
|
message[0] = 0;
|
|
}
|
|
response.cat("}");
|
|
}
|
|
}
|
|
|
|
/* Parameters */
|
|
{
|
|
// ATX power
|
|
response.catf(",\"params\":{\"atxPower\":%d", platform->AtxPower() ? 1 : 0);
|
|
|
|
// Cooling fan value
|
|
float fanValue = (gCodes->CoolingInverted() ? 1.0 - platform->GetFanValue() : platform->GetFanValue());
|
|
response.catf(",\"fanPercent\":%.2f", fanValue * 100.0);
|
|
|
|
// Speed and Extrusion factors
|
|
response.catf(",\"speedFactor\":%.2f,\"extrFactors\":", gCodes->GetSpeedFactor() * 100.0);
|
|
for (uint8_t extruder = 0; extruder < GetExtrudersInUse(); extruder++)
|
|
{
|
|
response.catf("%c%.2f", (extruder == 0) ? '[' : ',', gCodes->GetExtrusionFactors()[extruder] * 100.0);
|
|
}
|
|
response.cat("]}");
|
|
}
|
|
|
|
// G-code reply sequence for webserver
|
|
if (forWebserver)
|
|
{
|
|
response.catf(",\"seq\":%d", replySeq);
|
|
|
|
// There currently appears to be no need for this one, so skip it
|
|
//response.catf(",\"buff\":%u", webserver->GetGcodeBufferSpace());
|
|
}
|
|
|
|
/* Sensors */
|
|
{
|
|
response.cat(",\"sensors\":{");
|
|
|
|
// Probe
|
|
int v0 = platform->ZProbe();
|
|
int v1, v2;
|
|
switch (platform->GetZProbeSecondaryValues(v1, v2))
|
|
{
|
|
case 1:
|
|
response.catf("\"probeValue\":\%d,\"probeSecondary\":[%d]", v0, v1);
|
|
break;
|
|
case 2:
|
|
response.catf("\"probeValue\":\%d,\"probeSecondary\":[%d,%d]", v0, v1, v2);
|
|
break;
|
|
default:
|
|
response.catf("\"probeValue\":%d", v0);
|
|
break;
|
|
}
|
|
|
|
// Fan RPM
|
|
response.catf(",\"fanRPM\":%d}", (unsigned int)platform->GetFanRPM());
|
|
}
|
|
|
|
/* Temperatures */
|
|
{
|
|
response.cat(",\"temps\":{");
|
|
|
|
/* Bed */
|
|
#if HOT_BED != -1
|
|
{
|
|
response.catf("\"bed\":{\"current\":%.1f,\"active\":%.1f,\"state\":%d},",
|
|
heat->GetTemperature(HOT_BED), heat->GetActiveTemperature(HOT_BED),
|
|
heat->GetStatus(HOT_BED));
|
|
}
|
|
#endif
|
|
|
|
/* Heads */
|
|
{
|
|
response.cat("\"heads\":{\"current\":");
|
|
|
|
// Current temperatures
|
|
char ch = '[';
|
|
for (int8_t heater = E0_HEATER; heater < GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%.1f", ch, heat->GetTemperature(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Active temperatures
|
|
response.catf("],\"active\":");
|
|
ch = '[';
|
|
for (int8_t heater = E0_HEATER; heater < GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%.1f", ch, heat->GetActiveTemperature(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Standby temperatures
|
|
response.catf("],\"standby\":");
|
|
ch = '[';
|
|
for (int8_t heater = E0_HEATER; heater < GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%.1f", ch, heat->GetStandbyTemperature(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Heater statuses (0=off, 1=standby, 2=active, 3=fault)
|
|
response.cat("],\"state\":");
|
|
ch = '[';
|
|
for (int8_t heater = E0_HEATER; heater < GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%d", ch, (int)heat->GetStatus(heater));
|
|
ch = ',';
|
|
}
|
|
}
|
|
response.cat("]}}");
|
|
}
|
|
|
|
// Time since last reset
|
|
response.catf(",\"time\":%.1f", platform->Time());
|
|
|
|
/* Extended Status Response */
|
|
if (type == 2)
|
|
{
|
|
// Cold Extrude/Retract
|
|
response.catf(",\"coldExtrudeTemp\":%1.f", ColdExtrude() ? 0 : HOT_ENOUGH_TO_EXTRUDE);
|
|
response.catf(",\"coldRetractTemp\":%1.f", ColdExtrude() ? 0 : HOT_ENOUGH_TO_RETRACT);
|
|
|
|
// Delta configuration
|
|
response.catf(",\"geometry\":\"%s\"", move->GetGeometryString());
|
|
|
|
// Machine name
|
|
response.cat(",\"name\":");
|
|
EncodeString(response, myName, 2, false);
|
|
|
|
/* Probe */
|
|
{
|
|
const ZProbeParameters& probeParams = platform->GetZProbeParameters();
|
|
|
|
// Trigger threshold
|
|
response.catf(",\"probe\":{\"threshold\":%d", probeParams.adcValue);
|
|
|
|
// Trigger height
|
|
response.catf(",\"height\":%.2f", probeParams.height);
|
|
|
|
// Type
|
|
response.catf(",\"type\":%d}", platform->GetZProbeType());
|
|
}
|
|
|
|
/* Tool Mapping */
|
|
{
|
|
response.cat(",\"tools\":[");
|
|
for (Tool *tool=toolList; tool != NULL; tool = tool->Next())
|
|
{
|
|
// Heaters
|
|
response.catf("{\"number\":%d,\"heaters\":[", tool->Number());
|
|
for (int heater=0; heater<tool->HeaterCount(); heater++)
|
|
{
|
|
response.catf("%d", tool->Heater(heater));
|
|
if (heater < tool->HeaterCount() - 1)
|
|
{
|
|
response.cat(",");
|
|
}
|
|
}
|
|
|
|
// Extruder drives
|
|
response.cat("],\"drives\":[");
|
|
for (int drive=0; drive<tool->DriveCount(); drive++)
|
|
{
|
|
response.catf("%d", tool->Drive(drive));
|
|
if (drive < tool->DriveCount() - 1)
|
|
{
|
|
response.cat(",");
|
|
}
|
|
}
|
|
|
|
// Do we have any more tools?
|
|
if (tool->Next() != NULL)
|
|
{
|
|
response.cat("]},");
|
|
}
|
|
else
|
|
{
|
|
response.cat("]}");
|
|
}
|
|
}
|
|
response.cat("]");
|
|
}
|
|
}
|
|
else if (type == 3)
|
|
{
|
|
// Current Layer
|
|
response.catf(",\"currentLayer\":%d", printMonitor->GetCurrentLayer());
|
|
|
|
// Current Layer Time
|
|
response.catf(",\"currentLayerTime\":%.1f", printMonitor->GetCurrentLayerTime());
|
|
|
|
// Raw Extruder Positions
|
|
response.cat(",\"extrRaw\":"); // announce the extruder positions
|
|
char ch = '[';
|
|
for (size_t drive = 0; drive < reprap.GetExtrudersInUse(); drive++) // loop through extruders
|
|
{
|
|
response.catf("%c%.1f", ch, gCodes->GetRawExtruderPosition(drive));
|
|
ch = ',';
|
|
}
|
|
|
|
// Fraction of file printed
|
|
response.catf("],\"fractionPrinted\":%.1f", (gCodes->PrintingAFile()) ? (gCodes->FractionOfFilePrinted() * 100.0) : 0.0);
|
|
|
|
// First Layer Duration
|
|
response.catf(",\"firstLayerDuration\":%.1f", printMonitor->GetFirstLayerDuration());
|
|
|
|
// First Layer Height
|
|
response.catf(",\"firstLayerHeight\":%.2f", printMonitor->GetFirstLayerHeight());
|
|
|
|
// Print Duration
|
|
response.catf(",\"printDuration\":%.1f", printMonitor->GetPrintDuration());
|
|
|
|
// Warm-Up Time
|
|
response.catf(",\"warmUpDuration\":%.1f", printMonitor->GetWarmUpDuration());
|
|
|
|
/* Print Time Estimations */
|
|
{
|
|
// Based on file progress
|
|
response.catf(",\"timesLeft\":{\"file\":%.1f", printMonitor->EstimateTimeLeft(fileBased));
|
|
|
|
// Based on filament usage
|
|
response.catf(",\"filament\":%.1f", printMonitor->EstimateTimeLeft(filamentBased));
|
|
|
|
// Based on layers
|
|
response.catf(",\"layer\":%.1f}", printMonitor->EstimateTimeLeft(layerBased));
|
|
}
|
|
}
|
|
|
|
response.cat("}");
|
|
}
|
|
|
|
// Get the JSON status response for the web server or M105 command.
|
|
// Type 0 is the old-style webserver status response (we should be able to bet rid of this soon).
|
|
// Type 1 is the new-style webserver status response.
|
|
// Type 2 is the M105 S2 response, which is like the new-style status response but some fields are omitted.
|
|
// Type 3 is the M105 S3 response, which is like the M105 S2 response except that static values are also included.
|
|
// 'seq' is the response sequence number, if it is not -1 and we have a different sequence number then we send the gcode response
|
|
void RepRap::GetLegacyStatusResponse(StringRef& response, uint8_t type, int seq) const
|
|
{
|
|
if (type != 0)
|
|
{
|
|
// Send the status. Note that 'S' has always meant that the machine is halted in this version of the status response, so we use A for pAused.
|
|
char ch = GetStatusCharacter();
|
|
if (ch == 'S') // if paused then send 'A'
|
|
{
|
|
ch = 'A';
|
|
}
|
|
else if (ch == 'H') // if halted then send 'S'
|
|
{
|
|
ch = 'S';
|
|
}
|
|
response.printf("{\"status\":\"%c\",\"heaters\":", ch);
|
|
|
|
// Send the heater actual temperatures
|
|
const Heat *heat = reprap.GetHeat();
|
|
ch = '[';
|
|
for (int8_t heater = 0; heater < reprap.GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%.1f", ch, heat->GetTemperature(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Send the heater active temperatures
|
|
response.catf("],\"active\":");
|
|
ch = '[';
|
|
for (int8_t heater = 0; heater < reprap.GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%.1f", ch, heat->GetActiveTemperature(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Send the heater standby temperatures
|
|
response.catf("],\"standby\":");
|
|
ch = '[';
|
|
for (int8_t heater = 0; heater < reprap.GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%.1f", ch, heat->GetStandbyTemperature(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Send the heater statuses (0=off, 1=standby, 2=active)
|
|
response.cat("],\"hstat\":");
|
|
ch = '[';
|
|
for (int8_t heater = 0; heater < reprap.GetHeatersInUse(); heater++)
|
|
{
|
|
response.catf("%c%d", ch, (int)heat->GetStatus(heater));
|
|
ch = ',';
|
|
}
|
|
|
|
// Send XYZ positions
|
|
float liveCoordinates[DRIVES];
|
|
reprap.GetMove()->LiveCoordinates(liveCoordinates);
|
|
const Tool* currentTool = reprap.GetCurrentTool();
|
|
if (currentTool != NULL)
|
|
{
|
|
const float *offset = currentTool->GetOffset();
|
|
for (size_t i = 0; i < AXES; ++i)
|
|
{
|
|
liveCoordinates[i] += offset[i];
|
|
}
|
|
}
|
|
response.catf("],\"pos\":"); // announce the XYZ position
|
|
ch = '[';
|
|
for (int8_t drive = 0; drive < AXES; drive++)
|
|
{
|
|
response.catf("%c%.2f", ch, liveCoordinates[drive]);
|
|
ch = ',';
|
|
}
|
|
|
|
// Send extruder total extrusion since power up, last G92 or last M23
|
|
response.catf("],\"extr\":"); // announce the extruder positions
|
|
ch = '[';
|
|
for (int8_t drive = 0; drive < reprap.GetExtrudersInUse(); drive++) // loop through extruders
|
|
{
|
|
response.catf("%c%.1f", ch, gCodes->GetRawExtruderPosition(drive));
|
|
ch = ',';
|
|
}
|
|
response.cat("]");
|
|
|
|
// Send the speed and extruder override factors
|
|
response.catf(",\"sfactor\":%.2f,\"efactor\":", gCodes->GetSpeedFactor() * 100.0);
|
|
const float *extrusionFactors = gCodes->GetExtrusionFactors();
|
|
for (unsigned int i = 0; i < reprap.GetExtrudersInUse(); ++i)
|
|
{
|
|
response.catf("%c%.2f", (i == 0) ? '[' : ',', extrusionFactors[i] * 100.0);
|
|
}
|
|
response.cat("]");
|
|
|
|
// Send the current tool number
|
|
int toolNumber = (currentTool == NULL) ? 0 : currentTool->Number();
|
|
response.catf(",\"tool\":%d", toolNumber);
|
|
}
|
|
else
|
|
{
|
|
// The old (deprecated) poll response lists the status, then all the heater temperatures, then the XYZ positions, then all the extruder positions.
|
|
// These are all returned in a single vector called "poll".
|
|
// This is a poor choice of format because we can't easily tell which is which unless we already know the number of heaters and extruders.
|
|
// RRP reversed the order at version 0.65 to send the positions before the heaters, but we haven't yet done that.
|
|
char c = (gCodes->PrintingAFile()) ? 'P' : 'I';
|
|
response.printf("{\"poll\":[\"%c\",", c); // Printing
|
|
for (int8_t heater = 0; heater < HEATERS; heater++)
|
|
{
|
|
response.catf("\"%.1f\",", reprap.GetHeat()->GetTemperature(heater));
|
|
}
|
|
// Send XYZ and extruder positions
|
|
float liveCoordinates[DRIVES];
|
|
reprap.GetMove()->LiveCoordinates(liveCoordinates);
|
|
for (int8_t drive = 0; drive < DRIVES; drive++) // loop through extruders
|
|
{
|
|
char ch = (drive == DRIVES - 1) ? ']' : ','; // append ] to the last one but , to the others
|
|
response.catf("\"%.2f\"%c", liveCoordinates[drive], ch);
|
|
}
|
|
}
|
|
|
|
// Send the Z probe value
|
|
int v0 = platform->ZProbe();
|
|
int v1, v2;
|
|
switch (platform->GetZProbeSecondaryValues(v1, v2))
|
|
{
|
|
case 1:
|
|
response.catf(",\"probe\":\"%d (%d)\"", v0, v1);
|
|
break;
|
|
case 2:
|
|
response.catf(",\"probe\":\"%d (%d, %d)\"", v0, v1, v2);
|
|
break;
|
|
default:
|
|
response.catf(",\"probe\":\"%d\"", v0);
|
|
break;
|
|
}
|
|
|
|
// Send fan RPM value
|
|
response.catf(",\"fanRPM\":%u", (unsigned int)platform->GetFanRPM());
|
|
|
|
// Send the home state. To keep the messages short, we send 1 for homed and 0 for not homed, instead of true and false.
|
|
if (type != 0)
|
|
{
|
|
response.catf(",\"homed\":[%d,%d,%d]",
|
|
(gCodes->GetAxisIsHomed(0)) ? 1 : 0,
|
|
(gCodes->GetAxisIsHomed(1)) ? 1 : 0,
|
|
(gCodes->GetAxisIsHomed(2)) ? 1 : 0);
|
|
}
|
|
else
|
|
{
|
|
response.catf(",\"hx\":%d,\"hy\":%d,\"hz\":%d",
|
|
(gCodes->GetAxisIsHomed(0)) ? 1 : 0,
|
|
(gCodes->GetAxisIsHomed(1)) ? 1 : 0,
|
|
(gCodes->GetAxisIsHomed(2)) ? 1 : 0);
|
|
}
|
|
|
|
if (gCodes->PrintingAFile())
|
|
{
|
|
// Send the fraction printed
|
|
response.catf(",\"fraction_printed\":%.4f", max<float>(0.0, gCodes->FractionOfFilePrinted()));
|
|
}
|
|
|
|
response.cat(",\"message\":");
|
|
EncodeString(response, message, 2, false);
|
|
|
|
if (type < 2)
|
|
{
|
|
response.catf(",\"buff\":%u", webserver->GetGcodeBufferSpace()); // send the amount of buffer space available for gcodes
|
|
}
|
|
else if (type == 2)
|
|
{
|
|
if (gCodes->PrintingAFile())
|
|
{
|
|
// Send estimated times left based on file progress, filament usage, and layers
|
|
response.catf(",\"timesLeft\":[%.1f,%.1f,%.1f]",
|
|
printMonitor->EstimateTimeLeft(fileBased),
|
|
printMonitor->EstimateTimeLeft(filamentBased),
|
|
printMonitor->EstimateTimeLeft(layerBased));
|
|
}
|
|
}
|
|
else if (type == 3)
|
|
{
|
|
// Add the static fields. For now this is just geometry and the machine name, but other fields could be added e.g. axis lengths.
|
|
response.catf(",\"geometry\":\"%s\",\"myName\":", move->GetGeometryString());
|
|
EncodeString(response, myName, 2, false);
|
|
}
|
|
|
|
if (type < 2 || (seq != -1 && replySeq != seq))
|
|
{
|
|
|
|
// Send the response to the last command. Do this last because it can be long and may need to be truncated.
|
|
response.catf(",\"seq\":%u,\"resp\":", replySeq); // send the response sequence number
|
|
EncodeString(response, GetGcodeReply().Pointer(), 2, true);
|
|
}
|
|
|
|
response.cat("}");
|
|
}
|
|
|
|
// Copy some parameter text, stopping at the first control character or when the destination buffer is full, and removing trailing spaces
|
|
void RepRap::CopyParameterText(const char* src, char *dst, size_t length)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i + 1 < length && src[i] >= ' '; ++i)
|
|
{
|
|
dst[i] = src[i];
|
|
}
|
|
// Remove any trailing spaces
|
|
while (i > 0 && dst[i - 1] == ' ')
|
|
{
|
|
--i;
|
|
}
|
|
dst[i] = 0;
|
|
}
|
|
|
|
// Encode a string in JSON format and append it to a string buffer, truncating it if necessary to leave the specified amount of room
|
|
void RepRap::EncodeString(StringRef& response, const char* src, size_t spaceToLeave, bool allowControlChars)
|
|
{
|
|
response.cat("\"");
|
|
size_t j = response.strlen();
|
|
while (j + spaceToLeave + 2 <= response.Length()) // while there is room for a character and a trailing quote
|
|
{
|
|
char c = *src++;
|
|
if (c == 0 || (c < ' ' && !allowControlChars)) // if null terminator or bad character
|
|
{
|
|
break;
|
|
}
|
|
char esc;
|
|
switch (c)
|
|
{
|
|
case '\r':
|
|
esc = 'r';
|
|
break;
|
|
case '\n':
|
|
esc = 'n';
|
|
break;
|
|
case '\t':
|
|
esc = 't';
|
|
break;
|
|
case '"':
|
|
esc = '"';
|
|
break;
|
|
case '\\':
|
|
esc = '\\';
|
|
break;
|
|
default:
|
|
esc = 0;
|
|
break;
|
|
}
|
|
if (esc)
|
|
{
|
|
if (j + spaceToLeave + 2 == response.Length())
|
|
{
|
|
break; // if no room for the extra backslash then quit
|
|
}
|
|
response[j++] = '\\';
|
|
response[j++] = esc;
|
|
}
|
|
else
|
|
{
|
|
response[j++] = c;
|
|
}
|
|
}
|
|
response[j++] = '"';
|
|
response[j] = 0;
|
|
}
|
|
|
|
// Get just the machine name in JSON format
|
|
void RepRap::GetNameResponse(StringRef& response) const
|
|
{
|
|
response.copy("{\"myName\":");
|
|
EncodeString(response, myName, 2, false);
|
|
response.cat("}");
|
|
}
|
|
|
|
// Get the list of files in the specified directory in JSON format
|
|
void RepRap::GetFilesResponse(StringRef& response, const char* dir) const
|
|
{
|
|
response.copy("{\"dir\":");
|
|
EncodeString(response, dir, 3, false);
|
|
response.cat(",\"files\":[");
|
|
FileInfo file_info;
|
|
bool firstFile = true;
|
|
bool gotFile = platform->GetMassStorage()->FindFirst(dir, file_info);
|
|
while (gotFile)
|
|
{
|
|
if ( file_info.fileName[0] != '.' // ignore Mac resource files and Linux hidden files
|
|
&& response.strlen() + strlen(file_info.fileName) + 6 < response.Length()
|
|
)
|
|
{
|
|
if (!firstFile)
|
|
{
|
|
response.catf(",");
|
|
}
|
|
EncodeString(response, file_info.fileName, 3, false);
|
|
firstFile = false;
|
|
}
|
|
gotFile = platform->GetMassStorage()->FindNext(file_info);
|
|
}
|
|
response.cat("]}");
|
|
}
|
|
|
|
void RepRap::Beep(int freq, int ms)
|
|
{
|
|
if (gCodes->HaveAux())
|
|
{
|
|
// If there is an LCD device present, make it beep
|
|
platform->Beep(freq, ms);
|
|
}
|
|
else
|
|
{
|
|
// Otherwise queue it until the webserver can process it
|
|
beepFrequency = freq;
|
|
beepDuration = ms;
|
|
}
|
|
}
|
|
|
|
void RepRap::SetMessage(const char *msg)
|
|
{
|
|
strncpy(message, msg, maxMessageLength);
|
|
message[maxMessageLength] = 0;
|
|
}
|
|
|
|
void RepRap::MessageToGCodeReply(const char *message)
|
|
{
|
|
gcodeReply.copy(message);
|
|
++replySeq;
|
|
}
|
|
|
|
void RepRap::AppendMessageToGCodeReply(const char *message)
|
|
{
|
|
gcodeReply.cat(message);
|
|
}
|
|
|
|
void RepRap::AppendCharToStatusResponse(const char c)
|
|
{
|
|
gcodeReply.catf("%c", c);
|
|
}
|
|
|
|
// Get the status character for the new-style status response
|
|
char RepRap::GetStatusCharacter() const
|
|
{
|
|
return (processingConfig) ? 'C' // Reading the configuration file
|
|
: (IsStopped()) ? 'H' // Halted
|
|
: (gCodes->IsPausing()) ? 'D' // Pausing / Decelerating
|
|
: (gCodes->IsResuming()) ? 'R' // Resuming
|
|
: (gCodes->IsPaused()) ? 'S' // Paused / Stopped
|
|
: (gCodes->PrintingAFile() && !gCodes->DoingFileMacro()) ? 'P' // Printing
|
|
: (gCodes->DoingFileMacro() || !move->NoLiveMovement()) ? 'B' // Busy
|
|
: 'I'; // Idle
|
|
}
|
|
|
|
bool RepRap::NoPasswordSet() const
|
|
{
|
|
return (!password[0] || StringEquals(password, DEFAULT_PASSWORD));
|
|
}
|
|
|
|
bool RepRap::CheckPassword(const char *pw) const
|
|
{
|
|
return StringEquals(pw, password);
|
|
}
|
|
|
|
void RepRap::SetPassword(const char* pw)
|
|
{
|
|
// Users sometimes put a tab character between the password and the comment, so allow for this
|
|
CopyParameterText(pw, password, ARRAY_SIZE(password));
|
|
}
|
|
|
|
const char *RepRap::GetName() const
|
|
{
|
|
return myName;
|
|
}
|
|
|
|
void RepRap::SetName(const char* nm)
|
|
{
|
|
// Users sometimes put a tab character between the machine name and the comment, so allow for this
|
|
CopyParameterText(nm, myName, ARRAY_SIZE(myName));
|
|
}
|
|
|
|
void RepRap::GetExtruderCapabilities(bool canDrive[], const bool directions[]) const
|
|
{
|
|
for (uint8_t extruder=0; extruder<DRIVES - AXES; extruder++)
|
|
{
|
|
canDrive[extruder] = false;
|
|
}
|
|
|
|
Tool *tool = toolList;
|
|
while (tool != nullptr)
|
|
{
|
|
for(uint8_t driveNum = 0; driveNum < tool->DriveCount(); driveNum++)
|
|
{
|
|
const int extruderDrive = tool->Drive(driveNum);
|
|
canDrive[extruderDrive] = tool->ToolCanDrive(directions[extruderDrive + AXES] == FORWARDS);
|
|
}
|
|
|
|
tool = tool->Next();
|
|
}
|
|
}
|
|
|
|
void RepRap::FlagTemperatureFault(int8_t dudHeater)
|
|
{
|
|
if (toolList != NULL)
|
|
{
|
|
toolList->FlagTemperatureFault(dudHeater);
|
|
}
|
|
}
|
|
|
|
void RepRap::ClearTemperatureFault(int8_t wasDudHeater)
|
|
{
|
|
reprap.GetHeat()->ResetFault(wasDudHeater);
|
|
if (toolList != NULL)
|
|
{
|
|
toolList->ClearTemperatureFault(wasDudHeater);
|
|
}
|
|
}
|
|
|
|
//*************************************************************************************************
|
|
// StringRef class member implementations
|
|
|
|
size_t StringRef::strlen() const
|
|
{
|
|
return strnlen(p, len - 1);
|
|
}
|
|
|
|
int StringRef::printf(const char *fmt, ...)
|
|
{
|
|
va_list vargs;
|
|
va_start(vargs, fmt);
|
|
int ret = vsnprintf(p, len, fmt, vargs);
|
|
va_end(vargs);
|
|
return ret;
|
|
}
|
|
|
|
int StringRef::vprintf(const char *fmt, va_list vargs)
|
|
{
|
|
return vsnprintf(p, len, fmt, vargs);
|
|
}
|
|
|
|
int StringRef::catf(const char *fmt, ...)
|
|
{
|
|
size_t n = strlen();
|
|
if (n + 1 < len) // if room for at least 1 more character and a null
|
|
{
|
|
va_list vargs;
|
|
va_start(vargs, fmt);
|
|
int ret = vsnprintf(p + n, len - n, fmt, vargs);
|
|
va_end(vargs);
|
|
return ret + n;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// This is quicker than printf for printing constant strings
|
|
size_t StringRef::copy(const char* src)
|
|
{
|
|
size_t length = strnlen(src, len - 1);
|
|
memcpy(p, src, length);
|
|
p[length] = 0;
|
|
return length;
|
|
}
|
|
|
|
// This is quicker than catf for printing constant strings
|
|
size_t StringRef::cat(const char* src)
|
|
{
|
|
size_t length = strlen();
|
|
size_t toCopy = strnlen(src, len - length - 1);
|
|
memcpy(p + length, src, toCopy);
|
|
length += toCopy;
|
|
p[length] = 0;
|
|
return length;
|
|
}
|
|
|
|
//*************************************************************************************************
|
|
|
|
// Utilities and storage not part of any class
|
|
|
|
static char scratchStringBuffer[100]; // this is now used only for short messages
|
|
StringRef scratchString(scratchStringBuffer, ARRAY_SIZE(scratchStringBuffer));
|
|
|
|
// For debug use
|
|
void debugPrintf(const char* fmt, ...)
|
|
{
|
|
va_list vargs;
|
|
va_start(vargs, fmt);
|
|
reprap.GetPlatform()->Message(DEBUG_MESSAGE, fmt, vargs);
|
|
va_end(vargs);
|
|
}
|
|
|
|
// String testing
|
|
|
|
bool StringEndsWith(const char* string, const char* ending)
|
|
{
|
|
int j = strlen(string);
|
|
int k = strlen(ending);
|
|
if(k > j)
|
|
return false;
|
|
|
|
return(StringEquals(&string[j - k], ending));
|
|
}
|
|
|
|
bool StringEquals(const char* s1, const char* s2)
|
|
{
|
|
int i = 0;
|
|
while(s1[i] && s2[i])
|
|
{
|
|
if(tolower(s1[i]) != tolower(s2[i]))
|
|
return false;
|
|
i++;
|
|
}
|
|
|
|
return !(s1[i] || s2[i]);
|
|
}
|
|
|
|
bool StringStartsWith(const char* string, const char* starting)
|
|
{
|
|
int j = strlen(string);
|
|
int k = strlen(starting);
|
|
if(k > j)
|
|
return false;
|
|
|
|
for(int i = 0; i < k; i++)
|
|
if(string[i] != starting[i])
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int StringContains(const char* string, const char* match)
|
|
{
|
|
int i = 0;
|
|
int count = 0;
|
|
|
|
while(string[i])
|
|
{
|
|
if(string[i++] == match[count])
|
|
{
|
|
count++;
|
|
if(!match[count])
|
|
return i;
|
|
} else
|
|
{
|
|
count = 0;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|