NMErr
OTIPEnumerator::ReceiveDatagram(void)
{
DEBUG_ENTRY_EXIT("IPEnumerator::ReceiveDatagram");
NMErr status = kNMNoError;
OTResult result;
OTFlags flags = 0;
do
{
result = OTRcvUData(mEP, &mIncomingData, &flags);
if (result == kOTLookErr)
HandleLookErr();
else if (result == kNMNoError)
HandleReply(mIncomingData.udata.buf, mIncomingData.udata.len, (InetAddress *) mIncomingData.addr.buf);
} while (result != kNMNoError && result == kOTLookErr);
if (result == kOTNoDataErr)
bDataWaiting = false;
return status;
}
void GCodes::WriteHTMLToFile(char b, GCodeBuffer *gb)
{
char reply[1];
reply[0] = 0;
if(fileBeingWritten == NULL)
{
platform->Message(HOST_MESSAGE, "Attempt to write to a null file.\n");
return;
}
fileBeingWritten->Write(b);
if(b == eofString[eofStringCounter])
{
eofStringCounter++;
if(eofStringCounter >= eofStringLength)
{
fileBeingWritten->Close();
fileBeingWritten = NULL;
gb->SetWritingFileDirectory(NULL);
char* r = reply;
if(platform->Emulating() == marlin)
r = "Done saving file.";
HandleReply(false, gb == serialGCode , r, 'M', 560, false);
return;
}
} else
eofStringCounter = 0;
}
void GCodes::WriteGCodeToFile(GCodeBuffer *gb)
{
char reply[1];
reply[0] = 0;
if(fileBeingWritten == NULL)
{
platform->Message(HOST_MESSAGE, "Attempt to write to a null file.\n");
return;
}
// End of file?
if(gb->Seen('M'))
{
if(gb->GetIValue() == 29)
{
fileBeingWritten->Close();
fileBeingWritten = NULL;
gb->SetWritingFileDirectory(NULL);
char* r = reply;
if(platform->Emulating() == marlin)
r = "Done saving file.";
HandleReply(false, gb == serialGCode , r, 'M', 29, false);
return;
}
}
// Resend request?
if(gb->Seen('G'))
{
if(gb->GetIValue() == 998)
{
if(gb->Seen('P'))
{
snprintf(scratchString, STRING_LENGTH, "%s", gb->GetIValue());
HandleReply(false, gb == serialGCode , scratchString, 'G', 998, true);
return;
}
}
}
fileBeingWritten->Write(gb->Buffer());
fileBeingWritten->Write('\n');
HandleReply(false, gb == serialGCode , reply, 'G', 1, false);
}
QObject* EntryBase::Ping (const QString& variant)
{
auto jid = GetJID ();
if (!variant.isEmpty ())
jid += '/' + variant;
auto reply = new PingReplyObject { this };
Account_->GetClientConnection ()->GetPingManager ()->Ping (jid,
[reply] (int msecs) { reply->HandleReply (msecs); });
return reply;
}
// Process a received string of gcodes
void Webserver::LoadGcodeBuffer(const char* gc)
{
char gcodeTempBuf[GCODE_LENGTH];
uint16_t gtp = 0;
bool inComment = false;
for (;;)
{
char c = *gc++;
if (c == 0)
{
gcodeTempBuf[gtp] = 0;
ProcessGcode(gcodeTempBuf);
return;
}
if (c == '\n')
{
gcodeTempBuf[gtp] = 0;
ProcessGcode(gcodeTempBuf);
gtp = 0;
inComment = false;
}
else
{
if (c == ';')
{
inComment = true;
}
if (gtp == ARRAY_UPB(gcodeTempBuf))
{
// gcode is too long, we haven't room for another character and a null
if (c != ' ' && !inComment)
{
platform->Message(HOST_MESSAGE, "Webserver: GCode local buffer overflow.\n");
HandleReply("Webserver: GCode local buffer overflow", true);
return;
}
// else we're either in a comment or the current character is a space.
// If we're in a comment, we'll silently truncate it.
// If the current character is a space, we'll wait until we see a non-comment character before reporting an error,
// in case the next character is end-of-line or the start of a comment.
}
else
{
gcodeTempBuf[gtp++] = c;
}
}
}
}
void Webserver::ProcessGcode(const char* gc)
{
if (StringStartsWith(gc, "M30 ")) // delete SD card file
{
reprap.GetGCodes()->DeleteFile(&gc[4]);
}
else if (StringStartsWith(gc, "M23 ")) // select SD card file to print next
{
reprap.GetGCodes()->QueueFileToPrint(&gc[4]);
}
else if (StringStartsWith(gc, "M112") && !isdigit(gc[4])) // emergency stop
{
reprap.EmergencyStop();
gcodeReadIndex = gcodeWriteIndex; // clear the buffer
reprap.GetGCodes()->Reset();
}
else if (StringStartsWith(gc, "M503") && !isdigit(gc[4])) // echo config.g file
{
FileStore *configFile = platform->GetFileStore(platform->GetSysDir(), platform->GetConfigFile(), false);
if (configFile == NULL)
{
HandleReply("Configuration file not found", true);
}
else
{
char c;
size_t i = 0;
while (i < ARRAY_UPB(gcodeReply) && configFile->Read(c))
{
gcodeReply[i++] = c;
}
configFile->Close();
gcodeReply[i] = 0;
++seq;
}
}
else if (StringStartsWith(gc, "M25") && !isDigit(gc[3])) // pause SD card print
{
reprap.GetGCodes()->PauseSDPrint();
}
else
{
StoreGcodeData(gc, strlen(gc) + 1);
}
}
// Process a received string of gcodes
void Webserver::StoreGcodeData(const char* data, size_t len)
{
if (len > GetGcodeBufferSpace())
{
platform->Message(HOST_MESSAGE, "Webserver: GCode buffer overflow.\n");
HandleReply("Webserver: GCode buffer overflow", true);
}
else
{
size_t remaining = gcodeBufLength - gcodeWriteIndex;
if (len <= remaining)
{
memcpy(gcodeBuffer + gcodeWriteIndex, data, len);
}
else
{
memcpy(gcodeBuffer + gcodeWriteIndex, data, remaining);
memcpy(gcodeBuffer, data + remaining, len - remaining);
}
gcodeWriteIndex = (gcodeWriteIndex + len) % gcodeBufLength;
}
}
void Webserver::ProcessGcode(const char* gc)
{
int8_t specialAction = 0;
if(StringStartsWith(gc, "M30 "))
{
specialAction = 1;
}
else if(StringStartsWith(gc, "M23 "))
{
specialAction = 2;
}
else if(StringStartsWith(gc, "M112") && !isdigit(gc[4]))
{
specialAction = 3;
}
else if(StringStartsWith(gc, "M503") && !isdigit(gc[4]))
{
specialAction = 4;
}
if(specialAction != 0) // Delete or print a file?
{
switch (specialAction)
{
case 1: // Delete
reprap.GetGCodes()->DeleteFile(&gc[4]);
break;
case 2: // print
reprap.GetGCodes()->QueueFileToPrint(&gc[4]);
break;
case 3:
reprap.EmergencyStop();
break;
case 4:
{
FileStore *configFile = platform->GetFileStore(platform->GetSysDir(), platform->GetConfigFile(), false);
if(configFile == NULL)
{
HandleReply("Configuration file not found", true);
}
else
{
char c;
size_t i = 0;
while(i < STRING_LENGTH && configFile->Read(c))
{
gcodeReply[i++] = c;
}
configFile->Close();
gcodeReply[i] = 0;
++seq;
}
}
break;
}
}
else
{
// Copy the gcode to the buffer
size_t len = strlen(gc) + 1; // number of characters to copy
if (len > GetGcodeBufferSpace())
{
platform->Message(HOST_MESSAGE, "Webserver: GCode buffer overflow.\n");
HandleReply("Webserver: GCode buffer overflow", true);
}
else
{
size_t remaining = gcodeBufLength - gcodeWriteIndex;
if (len <= remaining)
{
memcpy(&gcodeBuffer[gcodeWriteIndex], gc, len);
}
else
{
memcpy(&gcodeBuffer[gcodeWriteIndex], gc, remaining);
memcpy(gcodeBuffer, gc + remaining, len - remaining);
}
gcodeWriteIndex = (gcodeWriteIndex + len) % gcodeBufLength;
}
}
}
//---------------------------------------------------------------------------
bool TFileZillaIntf::HandleMessage(WPARAM wParam, LPARAM lParam)
{
bool Result;
unsigned int MessageID = FZ_MSG_ID(wParam);
switch (MessageID)
{
case FZ_MSG_STATUS:
{
ASSERT(FZ_MSG_PARAM(wParam) == 0);
t_ffam_statusmessage * Status = (t_ffam_statusmessage *)lParam;
ASSERT(Status->post);
Result = HandleStatus(Status->status, Status->type);
delete Status;
}
break;
case FZ_MSG_ASYNCREQUEST:
if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_OVERWRITE)
{
int RequestResult = 0;
wchar_t FileName1[MAX_PATH];
COverwriteRequestData * Data = (COverwriteRequestData *)lParam;
try
{
ASSERT(Data != NULL);
wcsncpy(FileName1, Data->FileName1, _countof(FileName1));
FileName1[_countof(FileName1) - 1] = L'\0';
TRemoteFileTime RemoteTime;
CopyFileTime(RemoteTime, Data->remotetime);
Result = HandleAsynchRequestOverwrite(
FileName1, _countof(FileName1), Data->FileName2, Data->path1, Data->path2,
Data->size1, Data->size2,
(Data->localtime != NULL) ? Data->localtime->GetTime() : 0,
(Data->localtime != NULL) && ((Data->localtime->GetHour() != 0) || (Data->localtime->GetMinute() != 0)),
RemoteTime,
ToPtr(Data->pTransferFile->nUserData),
Data->localFileHandle,
RequestResult);
}
catch (...)
{
FFileZillaApi->SetAsyncRequestResult(FILEEXISTS_SKIP, Data);
throw;
}
if (Result)
{
Data->FileName1 = FileName1;
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, Data),
L"setasyncrequestresult");
}
}
else if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_VERIFYCERT)
{
int RequestResult;
CVerifyCertRequestData * AData = (CVerifyCertRequestData *)lParam;
try
{
ASSERT(AData != NULL);
TFtpsCertificateData Data;
CopyContact(Data.Subject, AData->pCertData->subject);
CopyContact(Data.Issuer, AData->pCertData->issuer);
CopyValidityTime(Data.ValidFrom, AData->pCertData->validFrom);
CopyValidityTime(Data.ValidUntil, AData->pCertData->validUntil);
Data.SubjectAltName = AData->pCertData->subjectAltName;
Data.Hash = AData->pCertData->hash;
Data.Certificate = AData->pCertData->certificate;
Data.CertificateLen = AData->pCertData->certificateLen;
Data.VerificationResult = AData->pCertData->verificationResult;
Data.VerificationDepth = AData->pCertData->verificationDepth;
Result = HandleAsynchRequestVerifyCertificate(Data, RequestResult);
}
catch (...)
{
FFileZillaApi->SetAsyncRequestResult(0, AData);
throw;
}
if (Result)
{
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, AData),
L"setasyncrequestresult");
}
}
else if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_NEEDPASS)
{
int RequestResult = 0;
CNeedPassRequestData * AData = (CNeedPassRequestData *)lParam;
try
{
TNeedPassRequestData Data;
Data.Password = NULL;
Data.Password = AData->Password.GetBuffer(AData->Password.GetLength());
Result = HandleAsynchRequestNeedPass(Data, RequestResult);
AData->Password.ReleaseBuffer(AData->Password.GetLength());
if (Result && (RequestResult == TFileZillaIntf::REPLY_OK))
{
AData->Password = Data.Password;
free(Data.Password);
Data.Password = NULL;
}
}
catch (...)
{
FFileZillaApi->SetAsyncRequestResult(0, AData);
throw;
}
if (Result)
{
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, AData),
L"setasyncrequestresult");
}
}
else
{
// FZ_ASYNCREQUEST_GSS_AUTHFAILED
// FZ_ASYNCREQUEST_GSS_NEEDUSER
// FZ_ASYNCREQUEST_GSS_NEEDPASS
ASSERT(FALSE);
Result = false;
}
break;
case FZ_MSG_LISTDATA:
{
ASSERT(FZ_MSG_PARAM(wParam) == 0);
t_directory * Directory = (t_directory *)lParam;
CString Path = Directory->path.GetPath();
rde::vector<TListDataEntry> Entries(Directory->num);
for (intptr_t Index = 0; Index < Directory->num; ++Index)
{
t_directory::t_direntry & Source = Directory->direntry[Index];
TListDataEntry & Dest = Entries[Index];
Dest.Name = Source.name;
Dest.Permissions = Source.permissionstr;
Dest.HumanPerm = Source.humanpermstr;
Dest.OwnerGroup = Source.ownergroup;
Dest.Size = Source.size;
Dest.Dir = Source.dir;
Dest.Link = Source.bLink;
CopyFileTime(Dest.Time, Source.date);
Dest.LinkTarget = Source.linkTarget;
}
int Num = Directory->num;
TListDataEntry * pEntries = Num > 0 ? &Entries[0] : NULL;
Result = HandleListData(Path, pEntries, Num);
delete Directory;
}
break;
case FZ_MSG_TRANSFERSTATUS:
{
ASSERT(FZ_MSG_PARAM(wParam) == 0);
t_ffam_transferstatus * Status = reinterpret_cast<t_ffam_transferstatus *>(lParam);
if (Status != NULL)
{
Result = HandleTransferStatus(true, Status->transfersize, Status->bytes,
Status->percent, Status->timeelapsed, Status->timeleft,
Status->transferrate, Status->bFileTransfer != 0);
delete Status;
}
else
{
Result = HandleTransferStatus(false, -1, -1, -1, -1, -1, -1, false);
}
}
break;
case FZ_MSG_REPLY:
Result = HandleReply(FZ_MSG_PARAM(wParam), lParam);
break;
case FZ_MSG_CAPABILITIES:
Result = HandleCapabilities((TFTPServerCapabilities *)lParam);
break;
case FZ_MSG_SOCKETSTATUS:
case FZ_MSG_SECURESERVER:
case FZ_MSG_QUITCOMPLETE:
default:
ASSERT(false);
Result = false;
break;
}
return Result;
}
bool GCodes::ActOnGcode(GCodeBuffer *gb)
{
int code;
float value;
int iValue;
char* str;
bool result = true;
bool error = false;
bool resend = false;
bool seen;
char reply[STRING_LENGTH];
reply[0] = 0;
if(gb->Seen('G'))
{
code = gb->GetIValue();
switch(code)
{
case 0: // There are no rapid moves...
case 1: // Ordinary move
result = SetUpMove(gb);
break;
case 4: // Dwell
result = DoDwell(gb);
break;
case 10: // Set offsets
result = SetOffsets(gb);
break;
case 20: // Inches (which century are we living in, here?)
distanceScale = INCH_TO_MM;
break;
case 21: // mm
distanceScale = 1.0;
break;
case 28: // Home
if(NoHome())
{
homeAxisMoveCount = 0;
homeX = gb->Seen(gCodeLetters[X_AXIS]);
homeY = gb->Seen(gCodeLetters[Y_AXIS]);
homeZ = gb->Seen(gCodeLetters[Z_AXIS]);
if(NoHome())
{
homeX = true;
homeY = true;
homeZ = true;
}
}
result = DoHome();
break;
case 30: // Z probe/manually set at a position and set that as point P
result = SetSingleZProbeAtAPosition(gb);
break;
case 31: // Return the probe value, or set probe variables
result = SetPrintZProbe(gb, reply);
break;
case 32: // Probe Z at multiple positions and generate the bed transform
result = DoMultipleZProbe();
break;
case 90: // Absolute coordinates
drivesRelative = false;
axesRelative = false;
break;
case 91: // Relative coordinates
drivesRelative = true; // Non-axis movements (i.e. extruders)
axesRelative = true; // Axis movements (i.e. X, Y and Z)
break;
case 92: // Set position
result = SetPositions(gb);
break;
default:
error = true;
snprintf(reply, STRING_LENGTH, "invalid G Code: %s", gb->Buffer());
}
if(result)
HandleReply(error, gb == serialGCode, reply, 'G', code, resend);
return result;
}
if(gb->Seen('M'))
{
code = gb->GetIValue();
switch(code)
{
case 0: // Stop
case 1: // Sleep
if(fileBeingPrinted != NULL)
{
fileToPrint = fileBeingPrinted;
fileBeingPrinted = NULL;
}
if(!DisableDrives())
return false;
if(!StandbyHeaters())
return false; // Should never happen
break;
case 18: // Motors off
result = DisableDrives();
break;
case 20: // Deprecated...
if(platform->Emulating() == me || platform->Emulating() == reprapFirmware)
snprintf(reply, STRING_LENGTH, "GCode files:\n%s", platform->GetMassStorage()->FileList(platform->GetGCodeDir(), gb == serialGCode));
else
snprintf(reply, STRING_LENGTH, "%s", platform->GetMassStorage()->FileList(platform->GetGCodeDir(), gb == serialGCode));
break;
case 21: // Initialise SD - ignore
break;
case 23: // Set file to print
QueueFileToPrint(gb->GetUnprecedentedString());
if(platform->Emulating() == marlin)
snprintf(reply, STRING_LENGTH, "%s", "File opened\nFile selected\n");
break;
case 24: // Print/resume-printing the selected file
if(fileBeingPrinted != NULL)
break;
fileBeingPrinted = fileToPrint;
fileToPrint = NULL;
break;
case 25: // Pause the print
fileToPrint = fileBeingPrinted;
fileBeingPrinted = NULL;
break;
case 27: // Report print status - Depricated
if(this->PrintingAFile())
strncpy(reply, "SD printing.", STRING_LENGTH);
else
strncpy(reply, "Not SD printing.", STRING_LENGTH);
break;
case 28: // Write to file
str = gb->GetUnprecedentedString();
OpenFileToWrite(platform->GetGCodeDir(), str, gb);
snprintf(reply, STRING_LENGTH, "Writing to file: %s", str);
break;
case 29: // End of file being written; should be intercepted before getting here
platform->Message(HOST_MESSAGE, "GCode end-of-file being interpreted.\n");
break;
case 82:
for(int8_t extruder = AXES; extruder < DRIVES; extruder++)
lastPos[extruder - AXES] = 0.0;
drivesRelative = false;
break;
case 83:
for(int8_t extruder = AXES; extruder < DRIVES; extruder++)
lastPos[extruder - AXES] = 0.0;
drivesRelative = true;
break;
case 84: // Motors off - deprecated, use M18
result = DisableDrives();
break;
case 85: // Set inactive time
break;
case 92: // Set/report steps/mm for some axes
seen = false;
for(int8_t drive = 0; drive < DRIVES; drive++)
if(gb->Seen(gCodeLetters[drive]))
{
platform->SetDriveStepsPerUnit(drive, gb->GetFValue());
seen = true;
}
reprap.GetMove()->SetStepHypotenuse();
if(!seen)
snprintf(reply, STRING_LENGTH, "Steps/mm: X: %d, Y: %d, Z: %d, E: %d",
(int)platform->DriveStepsPerUnit(X_AXIS), (int)platform->DriveStepsPerUnit(Y_AXIS),
(int)platform->DriveStepsPerUnit(Z_AXIS), (int)platform->DriveStepsPerUnit(AXES)); // FIXME - needs to do multiple extruders
break;
case 98:
if(gb->Seen('P'))
result = DoFileCannedCycles(gb->GetString());
break;
case 99:
result = FileCannedCyclesReturn();
break;
case 104: // Depricated
if(gb->Seen('S'))
{
reprap.GetHeat()->SetActiveTemperature(1, gb->GetFValue()); // 0 is the bed
reprap.GetHeat()->Activate(1);
}
break;
case 105: // Deprecated...
strncpy(reply, "T:", STRING_LENGTH);
for(int8_t heater = HEATERS - 1; heater > 0; heater--)
{
strncat(reply, ftoa(0, reprap.GetHeat()->GetTemperature(heater), 1), STRING_LENGTH);
strncat(reply, " ", STRING_LENGTH);
}
strncat(reply, "B:", STRING_LENGTH);
strncat(reply, ftoa(0, reprap.GetHeat()->GetTemperature(0), 1), STRING_LENGTH);
break;
case 106: // Fan on or off
if(gb->Seen('S'))
platform->CoolingFan(gb->GetFValue());
break;
case 107: // Fan off - depricated
platform->CoolingFan(0.0);
break;
case 110: // Set line numbers - line numbers are dealt with in the GCodeBuffer class, so ignore
break;
case 111: // Debug level
if(gb->Seen('S'))
reprap.SetDebug(gb->GetIValue());
break;
case 112: // Emergency stop - acted upon in Webserver
break;
case 114: // Deprecated
str = GetCurrentCoordinates();
if(str != 0)
{
strncpy(reply, str, STRING_LENGTH);
} else
result = false;
break;
case 115: // Print firmware version
snprintf(reply, STRING_LENGTH, "FIRMWARE_NAME:%s FIRMWARE_VERSION:%s ELECTRONICS:%s DATE:%s", NAME, VERSION, ELECTRONICS, DATE);
break;
case 109: // Depricated
if(gb->Seen('S'))
{
reprap.GetHeat()->SetActiveTemperature(1, gb->GetFValue()); // 0 is the bed
reprap.GetHeat()->Activate(1);
}
case 116: // Wait for everything, especially set temperatures
if(!AllMovesAreFinishedAndMoveBufferIsLoaded())
return false;
result = reprap.GetHeat()->AllHeatersAtSetTemperatures();
break;
case 120:
result = Push();
break;
case 121:
result = Pop();
break;
case 122:
reprap.Diagnostics();
break;
case 126: // Valve open
platform->Message(HOST_MESSAGE, "M126 - valves not yet implemented\n");
break;
case 127: // Valve closed
platform->Message(HOST_MESSAGE, "M127 - valves not yet implemented\n");
break;
case 135: // Set PID sample interval
break;
case 140: // Set bed temperature
if(gb->Seen('S'))
{
reprap.GetHeat()->SetActiveTemperature(0, gb->GetFValue());
reprap.GetHeat()->Activate(0);
}
break;
case 141: // Chamber temperature
platform->Message(HOST_MESSAGE, "M141 - heated chamber not yet implemented\n");
break;
case 201: // Set axis accelerations
for(int8_t drive = 0; drive < DRIVES; drive++)
{
if(gb->Seen(gCodeLetters[drive]))
{
value = gb->GetFValue();
}else{
value = -1;
}
platform->SetAcceleration(drive, value);
}
break;
case 203: // Set maximum feedrates
for(int8_t drive = 0; drive < DRIVES; drive++)
{
if(gb->Seen(gCodeLetters[drive]))
{
value = gb->GetFValue()*distanceScale*0.016666667; // G Code feedrates are in mm/minute; we need mm/sec;
platform->SetMaxFeedrate(drive, value);
}
}
break;
case 205: //M205 advanced settings: minimum travel speed S=while printing T=travel only, B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk
break;
case 206: // Offset axes
result = OffsetAxes(gb);
break;
case 208: // Set maximum axis lengths
for(int8_t axis = 0; axis < AXES; axis++)
{
if(gb->Seen(gCodeLetters[axis]))
{
value = gb->GetFValue()*distanceScale;
platform->SetAxisLength(axis, value);
}
}
break;
case 210: // Set homing feedrates
for(int8_t axis = 0; axis < AXES; axis++)
{
if(gb->Seen(gCodeLetters[axis]))
{
value = gb->GetFValue()*distanceScale*0.016666667;
platform->SetHomeFeedRate(axis, value);
}
}
break;
case 301: // Set PID values
break;
case 302: // Allow cold extrudes
break;
case 304: // Set thermistor parameters
break;
case 503: // list variable settings
result = SendConfigToLine();
break;
case 550: // Set machine name
if(gb->Seen('P'))
reprap.GetWebserver()->SetName(gb->GetString());
break;
case 551: // Set password
if(gb->Seen('P'))
reprap.GetWebserver()->SetPassword(gb->GetString());
break;
case 552: // Set/Get IP address
if(gb->Seen('P'))
SetEthernetAddress(gb, code);
else
{
byte *ip = platform->IPAddress();
snprintf(reply, STRING_LENGTH, "IP address: %d.%d.%d.%d\n ", ip[0], ip[1], ip[2], ip[3]);
}
break;
case 553: // Set/Get netmask
if(gb->Seen('P'))
SetEthernetAddress(gb, code);
else
{
byte *nm = platform->NetMask();
snprintf(reply, STRING_LENGTH, "Net mask: %d.%d.%d.%d\n ", nm[0], nm[1], nm[2], nm[3]);
}
break;
case 554: // Set/Get gateway
if(gb->Seen('P'))
SetEthernetAddress(gb, code);
else
{
byte *gw = platform->GateWay();
snprintf(reply, STRING_LENGTH, "Gateway: %d.%d.%d.%d\n ", gw[0], gw[1], gw[2], gw[3]);
}
break;
case 555: // Set firmware type to emulate
if(gb->Seen('P'))
platform->SetEmulating((Compatibility)gb->GetIValue());
break;
case 556: // Axis compensation
if(gb->Seen('S'))
{
value = gb->GetFValue();
for(int8_t axis = 0; axis < AXES; axis++)
if(gb->Seen(gCodeLetters[axis]))
reprap.GetMove()->SetAxisCompensation(axis, gb->GetFValue()/value);
}
break;
case 557: // Set Z probe point coordinates
if(gb->Seen('P'))
{
iValue = gb->GetIValue();
if(gb->Seen(gCodeLetters[X_AXIS]))
reprap.GetMove()->SetXBedProbePoint(iValue, gb->GetFValue());
if(gb->Seen(gCodeLetters[Y_AXIS]))
reprap.GetMove()->SetYBedProbePoint(iValue, gb->GetFValue());
}
break;
case 558: // Set Z probe type
if(gb->Seen('P'))
platform->SetZProbeType(gb->GetIValue());
break;
case 559: // Upload config.g
if(gb->Seen('P'))
str = gb->GetString();
else
str = platform->GetConfigFile();
OpenFileToWrite(platform->GetSysDir(), str, gb);
snprintf(reply, STRING_LENGTH, "Writing to file: %s", str);
break;
case 560: // Upload reprap.htm
str = INDEX_PAGE;
OpenFileToWrite(platform->GetWebDir(), str, gb);
snprintf(reply, STRING_LENGTH, "Writing to file: %s", str);
break;
case 561:
reprap.GetMove()->SetIdentityTransform();
break;
case 562: // Reset temperature fault - use with great caution
if(gb->Seen('P'))
{
iValue = gb->GetIValue();
reprap.GetHeat()->ResetFault(iValue);
}
break;
case 876: // TEMPORARY - this will go away...
if(gb->Seen('P'))
{
iValue = gb->GetIValue();
if(iValue != 1)
platform->SetHeatOn(0);
else
platform->SetHeatOn(1);
}
break;
case 900:
result = DoFileCannedCycles("homex.g");
break;
case 901:
result = DoFileCannedCycles("homey.g");
break;
case 906: // Set Motor currents
for(uint8_t i = 0; i < DRIVES; i++)
{
if(gb->Seen(gCodeLetters[i]))
{
value = gb->GetFValue(); // mA
platform->SetMotorCurrent(i, value);
}
}
break;
case 998:
if(gb->Seen('P'))
{
snprintf(reply, STRING_LENGTH, "%s", gb->GetIValue());
resend = true;
}
break;
default:
error = true;
snprintf(reply, STRING_LENGTH, "invalid M Code: %s", gb->Buffer());
}
if(result)
HandleReply(error, gb == serialGCode, reply, 'M', code, resend);
return result;
}
if(gb->Seen('T'))
{
code = gb->GetIValue();
if(code == selectedHead)
{
if(result)
HandleReply(error, gb == serialGCode, reply, 'T', code, resend);
return result;
}
error = true;
for(int8_t i = AXES; i < DRIVES; i++)
{
if(selectedHead == i - AXES)
reprap.GetHeat()->Standby(selectedHead + 1); // + 1 because 0 is the Bed
}
for(int8_t i = AXES; i < DRIVES; i++)
{
if(code == i - AXES)
{
selectedHead = code;
reprap.GetHeat()->Activate(selectedHead + 1); // 0 is the Bed
error = false;
}
}
if(error)
snprintf(reply, STRING_LENGTH, "Invalid T Code: %s", gb->Buffer());
if(result)
HandleReply(error, gb == serialGCode, reply, 'T', code, resend);
return result;
}
// An empty buffer jumps to here and gets discarded
if(result)
HandleReply(error, gb == serialGCode, reply, 'X', code, resend);
return result;
}
