Michal
/
printer-monitor
mirror of https://github.com/Qrome/printer-monitor
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added initial preheat and cooldown menus

pull/93/head
Drachenkatze 2019-08-12 13:13:20 +02:00
parent 12528dac1e
commit 8acfa5b7fd
13 changed files with 514 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
printermonitor/Menu/CooldownMenu.cpp Normal file
View File

@ -0,0 +1,80 @@
#include "CooldownMenu.h"
#include "TemperatureMenuItem.h"
#include "TemperaturePreset.h"
CooldownMenu::CooldownMenu()
{
MenuTitle = "Cooldown Menu";
}
void CooldownMenu::processKey(char c)
{
if (c >= '1' && c <= '6')
{
TemperatureMenuItem *item = (TemperatureMenuItem *)getItemForKey(c);
if (item != NULL)
{
TriggerCooldown(item);
doExit();
}
}
Menu::processKey(c);
}
void CooldownMenu::TriggerCooldown(TemperatureMenuItem *item)
{
if (item->preheatBed)
{
client->preheatBed(item->preset->bed);
}
if (item->preheatChamber)
{
client->preheatChamber(item->preset->chamber);
}
if (item->preheatExtruder)
{
client->preheatTool(0, item->preset->extruder);
}
}
void CooldownMenu::beforeShow()
{
TemperaturePreset *cooldown = new TemperaturePreset();
cooldown->bed = 0;
cooldown->chamber = 0;
cooldown->extruder = 0;
menuItems.clear();
TemperatureMenuItem *all = new TemperatureMenuItem("All");
all->preset = cooldown;
all->preheatBed = true;
all->preheatChamber = true;
all->preheatExtruder = true;
menuItems.add(all);
TemperatureMenuItem *extruder = new TemperatureMenuItem("Extruder");
extruder->preset = cooldown;
extruder->preheatExtruder = true;
menuItems.add(extruder);
TemperatureMenuItem *bed = new TemperatureMenuItem("Bed");
bed->preset = cooldown;
bed->preheatBed = true;
menuItems.add(bed);
TemperatureMenuItem *chamber = new TemperatureMenuItem("Chamber");
chamber->preset = cooldown;
chamber->preheatChamber = true;
menuItems.add(chamber);
}

17
printermonitor/Menu/CooldownMenu.h Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "Menu.h"
#include "../OctoPrintClient.h"
#include <LinkedList.h>
#include "TemperatureMenuItem.h"
class CooldownMenu : public Menu
{
public:
CooldownMenu();
void beforeShow() override;
void processKey(char c) override;
void TriggerCooldown (TemperatureMenuItem* item);
OctoPrintClient *client;
};

24
printermonitor/Menu/Menu.cpp
View File

@ -12,6 +12,25 @@ Menu::Menu(String menuTitle)
Menu();
}
void Menu::beforeShow() {
}
MenuItem* Menu::getItemForKey (char c) {
if (c >= '1' && c <= '6') {
int offset = c - '1';
if (offset < MENU_MAX_DISPLAY_ITEMS) {
int itemNum = startPage * MENU_MAX_DISPLAY_ITEMS + offset;
if (itemNum < menuItems.size()) {
return menuItems[itemNum];
}
}
}
return NULL;
}
void Menu::processKey(char c)
{
switch (c)
@ -32,6 +51,8 @@ void Menu::processKey(char c)
}
break;
}
displayMillis = millis();
}
void Menu::doExit(void)
@ -105,6 +126,7 @@ void Menu::drawMenu(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
yPos = MENU_ITEM_START_POS_Y;
xPos = MENU_ITEM_SECOND_COLUMN_START_X;
}
}
display->fillRect(0, MENU_BOTTOM_BAR_LINE, 128, 64 - MENU_BOTTOM_BAR_LINE + 1);
@ -146,7 +168,7 @@ void Menu::drawMenu(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
display->drawString(44 + SMALL_KEYPAD_BUTTON_ICON_WIDTH + 1, bottomBarStart - 2, "Exit");
drawSmallKeyboardButtonIcon(display, 45, bottomBarStart, '0', true, true);
}
}
void Menu::drawKeyboardButtonIcon(OLEDDisplay *display, int16_t x, int16_t y, char keyButton, const uint8_t *font, int16_t iconWidth, int16_t iconHeight, int16_t xOffset, int16_t yOffset, bool inverted, bool filled)

10
printermonitor/Menu/Menu.h
View File

@ -1,3 +1,4 @@
#pragma once
#include <Arduino.h>
#include "MenuItem.h"
@ -31,14 +32,19 @@ public:
Menu(String menuTitle);
String MenuTitle;
void drawMenu(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
void processKey(char c);
virtual void beforeShow();
virtual void processKey(char c);
MenuItem* getItemForKey (char c);
int getMaxPage();
void (*exitCallback)(void) = NULL;
int startPage = 0;
LinkedList<MenuItem *> menuItems;
unsigned long displayMillis;
protected:
void doExit (void);
private:
void doExit (void);
void drawRegularKeyboardButtonIcon(OLEDDisplay *display, int16_t x, int16_t y, char keyButton, bool inverted, bool filled);
void drawSmallKeyboardButtonIcon(OLEDDisplay *display, int16_t x, int16_t y, char keyButton, bool inverted, bool filled);
void drawKeyboardButtonIcon(OLEDDisplay *display, int16_t x, int16_t y, char keyButton, const uint8_t *font, int16_t iconWidth, int16_t iconHeight, int16_t xOffset, int16_t yOffset, bool inverted, bool filled);

2
printermonitor/Menu/MenuItem.h
View File

@ -1,3 +1,5 @@
#pragma once
#include <Arduino.h>
class MenuItem {

111
printermonitor/Menu/PreheatMenu.cpp
View File

@ -1,9 +1,116 @@
#include "PreheatMenu.h"
#include "TemperatureMenuItem.h"
PreheatMenu::PreheatMenu () {
PreheatMenu::PreheatMenu()
{
MenuTitle = "Preheat Menu";
presetMenuItems = LinkedList<MenuItem *>();
temperatureItems = LinkedList<MenuItem *>();
}
void PreheatMenu::RetrieveTemperatures () {
void PreheatMenu::RetrieveTemperatures()
{
presetMenuItems.clear();
Serial.println(client->temperaturePresets.size());
for (int i = 0; i < client->temperaturePresets.size(); i++)
{
TemperatureMenuItem *item = new TemperatureMenuItem(client->temperaturePresets[i]->PresetName);
item->preset = client->temperaturePresets[i];
presetMenuItems.add(item);
}
}
void PreheatMenu::processKey(char c)
{
if (c >= '1' && c <= '6')
{
if (selectPreset)
{
TemperatureMenuItem *item = (TemperatureMenuItem *)getItemForKey(c);
if (item != NULL)
{
CreateTemperatureMenu(item);
menuItems = temperatureItems;
MenuTitle = "Preheat: " + item->ItemName;
selectPreset = false;
}
}
else
{
TemperatureMenuItem *item = (TemperatureMenuItem *)getItemForKey(c);
if (item != NULL)
{
TriggerPreheat(item);
doExit();
}
}
}
Menu::processKey(c);
}
void PreheatMenu::TriggerPreheat(TemperatureMenuItem *item) {
if (item->preheatBed) {
client->preheatBed(item->preset->bed);
}
if (item->preheatChamber) {
client->preheatChamber(item->preset->chamber);
}
if (item->preheatExtruder) {
client->preheatTool(0, item->preset->extruder);
}
}
void PreheatMenu::CreateTemperatureMenu(TemperatureMenuItem *item)
{
temperatureItems.clear();
TemperatureMenuItem *all = new TemperatureMenuItem("All");
all->preset = item->preset;
all->preheatBed = true;
all->preheatChamber = true;
all->preheatExtruder = true;
temperatureItems.add(all);
if (item->preset->extruder > 0)
{
TemperatureMenuItem *extruder = new TemperatureMenuItem("Extruder");
extruder->preset = item->preset;
extruder->preheatExtruder = true;
temperatureItems.add(extruder);
}
if (item->preset->bed > 0)
{
TemperatureMenuItem *bed = new TemperatureMenuItem("Bed");
bed->preset = item->preset;
bed->preheatBed = true;
temperatureItems.add(bed);
}
if (item->preset->chamber > 0)
{
TemperatureMenuItem *chamber = new TemperatureMenuItem("Chamber");
chamber->preset = item->preset;
chamber->preheatChamber = true;
temperatureItems.add(chamber);
}
}
void PreheatMenu::beforeShow()
{
RetrieveTemperatures();
selectPreset = true;
MenuTitle = "Preheat Menu";
menuItems = presetMenuItems;
}

23
printermonitor/Menu/PreheatMenu.h
View File

@ -1,7 +1,22 @@
#include "Menu.h"
#pragma once
class PreheatMenu: public Menu {
#include "Menu.h"
#include "../OctoPrintClient.h"
#include <LinkedList.h>
#include "TemperatureMenuItem.h"
class PreheatMenu : public Menu
{
public:
PreheatMenu();
void RetrieveTemperatures();
PreheatMenu();
void beforeShow() override;
void processKey(char c) override;
void RetrieveTemperatures();
void CreateTemperatureMenu (TemperatureMenuItem* item);
void TriggerPreheat (TemperatureMenuItem* item);
LinkedList<MenuItem *> presetMenuItems;
LinkedList<MenuItem *> temperatureItems;
OctoPrintClient *client;
private:
bool selectPreset = true;
};

13
printermonitor/Menu/TemperatureMenuItem.h
View File

@ -1,13 +1,14 @@
#pragma once
#include "MenuItem.h"
#include "TemperaturePreset.h"
class TemperatureMenuItem : public MenuItem
{
public:
TemperatureMenuItem(String itemName);
int bed;
int chamber;
int extruder;
bool has_bed_temp;
bool has_extruder_temp;
bool has_chamber_temp;
TemperaturePreset* preset;
bool preheatBed = false;
bool preheatChamber = false;
bool preheatExtruder = false;
};

314
printermonitor/OctoPrintClient.cpp
View File

@ -26,17 +26,20 @@ SOFTWARE.
#include "OctoPrintClient.h"
OctoPrintClient::OctoPrintClient(String ApiKey, String server, int port, String user, String pass, boolean psu) {
OctoPrintClient::OctoPrintClient(String ApiKey, String server, int port, String user, String pass, boolean psu)
{
temperaturePresets = LinkedList<TemperaturePreset *>();
updatePrintClient(ApiKey, server, port, user, pass, psu);
}
void OctoPrintClient::updatePrintClient(String ApiKey, String server, int port, String user, String pass, boolean psu) {
void OctoPrintClient::updatePrintClient(String ApiKey, String server, int port, String user, String pass, boolean psu)
{
server.toCharArray(myServer, 100);
myApiKey = ApiKey;
myPort = port;
encodedAuth = "";
if (user != "") {
if (user != "")
{
String userpass = user + ":" + pass;
base64 b64;
encodedAuth = b64.encode(userpass, true);
@ -44,39 +47,47 @@ void OctoPrintClient::updatePrintClient(String ApiKey, String server, int port,
pollPsu = psu;
}
boolean OctoPrintClient::validate() {
boolean OctoPrintClient::validate()
{
boolean rtnValue = false;
printerData.error = "";
if (String(myServer) == "") {
if (String(myServer) == "")
{
printerData.error += "Server address is required; ";
}
if (myApiKey == "") {
if (myApiKey == "")
{
printerData.error += "ApiKey is required; ";
}
if (printerData.error == "") {
if (printerData.error == "")
{
rtnValue = true;
}
return rtnValue;
}
WiFiClient OctoPrintClient::getSubmitRequest(String apiGetData) {
WiFiClient OctoPrintClient::getSubmitRequest(String apiGetData)
{
WiFiClient printClient;
printClient.setTimeout(5000);
Serial.println("Getting Octoprint Data via GET");
Serial.println(apiGetData);
result = "";
if (printClient.connect(myServer, myPort)) { //starts client connection, checks for connection
if (printClient.connect(myServer, myPort))
{ //starts client connection, checks for connection
printClient.println(apiGetData);
printClient.println("Host: " + String(myServer) + ":" + String(myPort));
printClient.println("X-Api-Key: " + myApiKey);
if (encodedAuth != "") {
if (encodedAuth != "")
{
printClient.print("Authorization: ");
printClient.println("Basic " + encodedAuth);
}
printClient.println("User-Agent: ArduinoWiFi/1.1");
printClient.println("Connection: close");
if (printClient.println() == 0) {
if (printClient.println() == 0)
{
Serial.println("Connection to " + String(myServer) + ":" + String(myPort) + " failed.");
Serial.println();
resetPrintData();
@ -84,7 +95,8 @@ WiFiClient OctoPrintClient::getSubmitRequest(String apiGetData) {
return printClient;
}
}
else {
else
{
Serial.println("Connection to OctoPrint failed: " + String(myServer) + ":" + String(myPort)); //error message if no client connect
Serial.println();
resetPrintData();
@ -95,7 +107,8 @@ WiFiClient OctoPrintClient::getSubmitRequest(String apiGetData) {
// Check HTTP status
char status[32] = {0};
printClient.readBytesUntil('\r', status, sizeof(status));
if (strcmp(status, "HTTP/1.1 200 OK") != 0 && strcmp(status, "HTTP/1.1 409 CONFLICT") != 0) {
if (strcmp(status, "HTTP/1.1 200 OK") != 0 && strcmp(status, "HTTP/1.1 409 CONFLICT") != 0)
{
Serial.print(F("Unexpected response: "));
Serial.println(status);
printerData.state = "";
@ -105,7 +118,8 @@ WiFiClient OctoPrintClient::getSubmitRequest(String apiGetData) {
// Skip HTTP headers
char endOfHeaders[] = "\r\n\r\n";
if (!printClient.find(endOfHeaders)) {
if (!printClient.find(endOfHeaders))
{
Serial.println(F("Invalid response"));
printerData.error = "Invalid response from " + String(myServer) + ":" + String(myPort);
printerData.state = "";
@ -114,19 +128,22 @@ WiFiClient OctoPrintClient::getSubmitRequest(String apiGetData) {
return printClient;
}
WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBody) {
WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBody)
{
WiFiClient printClient;
printClient.setTimeout(5000);
Serial.println("Getting Octoprint Data via POST");
Serial.println(apiPostData + " | " + apiPostBody);
result = "";
if (printClient.connect(myServer, myPort)) { //starts client connection, checks for connection
if (printClient.connect(myServer, myPort))
{ //starts client connection, checks for connection
printClient.println(apiPostData);
printClient.println("Host: " + String(myServer) + ":" + String(myPort));
printClient.println("Connection: close");
printClient.println("X-Api-Key: " + myApiKey);
if (encodedAuth != "") {
if (encodedAuth != "")
{
printClient.print("Authorization: ");
printClient.println("Basic " + encodedAuth);
}
@ -136,7 +153,8 @@ WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBod
printClient.println(apiPostBody.length());
printClient.println();
printClient.println(apiPostBody);
if (printClient.println() == 0) {
if (printClient.println() == 0)
{
Serial.println("Connection to " + String(myServer) + ":" + String(myPort) + " failed.");
Serial.println();
resetPrintData();
@ -144,7 +162,8 @@ WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBod
return printClient;
}
}
else {
else
{
Serial.println("Connection to OctoPrint failed: " + String(myServer) + ":" + String(myPort)); //error message if no client connect
Serial.println();
resetPrintData();
@ -155,7 +174,8 @@ WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBod
// Check HTTP status
char status[32] = {0};
printClient.readBytesUntil('\r', status, sizeof(status));
if (strcmp(status, "HTTP/1.1 200 OK") != 0 && strcmp(status, "HTTP/1.1 409 CONFLICT") != 0) {
if (strcmp(status, "HTTP/1.1 200 OK") != 0 && strcmp(status, "HTTP/1.1 409 CONFLICT") != 0)
{
Serial.print(F("Unexpected response: "));
Serial.println(status);
printerData.state = "";
@ -165,7 +185,8 @@ WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBod
// Skip HTTP headers
char endOfHeaders[] = "\r\n\r\n";
if (!printClient.find(endOfHeaders)) {
if (!printClient.find(endOfHeaders))
{
Serial.println(F("Invalid response"));
printerData.error = "Invalid response from " + String(myServer) + ":" + String(myPort);
printerData.state = "";
@ -174,93 +195,161 @@ WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBod
return printClient;
}
void OctoPrintClient::getPrinterJobResults() {
if (!validate()) {
void OctoPrintClient::preheatTool(int tool, int temperature)
{
if (!validate())
{
return;
}
char stringBuffer[255];
String apiPostData = "POST /api/printer/tool HTTP/1.1";
sprintf(stringBuffer, "{\"command\":\"target\", \"targets\":{\"tool%d\":%d}}", tool, temperature);
Serial.println(stringBuffer);
WiFiClient printClient = getPostRequest(apiPostData, stringBuffer);
}
void OctoPrintClient::preheatBed(int temperature)
{
if (!validate())
{
return;
}
char stringBuffer[255];
String apiPostData = "POST /api/printer/bed HTTP/1.1";
sprintf(stringBuffer, "{\"command\":\"target\", \"target\": %d}", temperature);
Serial.println(stringBuffer);
WiFiClient printClient = getPostRequest(apiPostData, stringBuffer);
}
void OctoPrintClient::preheatChamber(int temperature)
{
if (!validate())
{
return;
}
char stringBuffer[255];
String apiPostData = "POST /api/printer/chamber HTTP/1.1";
sprintf(stringBuffer, "{\"command\":\"target\", \"target\": %d}", temperature);
Serial.println(stringBuffer);
WiFiClient printClient = getPostRequest(apiPostData, stringBuffer);
}
void OctoPrintClient::getPrinterJobResults()
{
if (!validate())
{
return;
}
//**** get the Printer Job status
String apiGetData = "GET /api/job HTTP/1.1";
WiFiClient printClient = getSubmitRequest(apiGetData);
if (printerData.error != "") {
if (printerData.error != "")
{
return;
}
const size_t bufferSize = JSON_OBJECT_SIZE(1) + JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(3) + 2*JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(6) + 710;
const size_t bufferSize = JSON_OBJECT_SIZE(1) + JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(3) + 2 * JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(6) + 710;
DynamicJsonBuffer jsonBuffer(bufferSize);
// Parse JSON object
JsonObject& root = jsonBuffer.parseObject(printClient);
if (!root.success()) {
JsonObject &root = jsonBuffer.parseObject(printClient);
if (!root.success())
{
Serial.println("OctoPrint Data Parsing failed: " + String(myServer) + ":" + String(myPort));
printerData.error = "OctoPrint Data Parsing failed: " + String(myServer) + ":" + String(myPort);
printerData.state = "";
return;
}
printerData.averagePrintTime = (const char*)root["job"]["averagePrintTime"];
printerData.estimatedPrintTime = (const char*)root["job"]["estimatedPrintTime"];
printerData.fileName = (const char*)root["job"]["file"]["name"];
printerData.fileSize = (const char*)root["job"]["file"]["size"];
printerData.lastPrintTime = (const char*)root["job"]["lastPrintTime"];
printerData.progressCompletion = (const char*)root["progress"]["completion"];
printerData.progressFilepos = (const char*)root["progress"]["filepos"];
printerData.progressPrintTime = (const char*)root["progress"]["printTime"];
printerData.progressPrintTimeLeft = (const char*)root["progress"]["printTimeLeft"];
printerData.filamentLength = (const char*)root["job"]["filament"]["tool0"]["length"];
printerData.state = (const char*)root["state"];
printerData.averagePrintTime = (const char *)root["job"]["averagePrintTime"];
printerData.estimatedPrintTime = (const char *)root["job"]["estimatedPrintTime"];
printerData.fileName = (const char *)root["job"]["file"]["name"];
printerData.fileSize = (const char *)root["job"]["file"]["size"];
printerData.lastPrintTime = (const char *)root["job"]["lastPrintTime"];
printerData.progressCompletion = (const char *)root["progress"]["completion"];
printerData.progressFilepos = (const char *)root["progress"]["filepos"];
printerData.progressPrintTime = (const char *)root["progress"]["printTime"];
printerData.progressPrintTimeLeft = (const char *)root["progress"]["printTimeLeft"];
printerData.filamentLength = (const char *)root["job"]["filament"]["tool0"]["length"];
printerData.state = (const char *)root["state"];
if (isOperational()) {
if (isOperational())
{
Serial.println("Status: " + printerData.state);
} else {
}
else
{
Serial.println("Printer Not Operational");
}
//**** get the Printer Temps and Stat
apiGetData = "GET /api/printer?exclude=sd,history HTTP/1.1";
printClient = getSubmitRequest(apiGetData);
if (printerData.error != "") {
if (printerData.error != "")
{
return;
}
const size_t bufferSize2 = 3*JSON_OBJECT_SIZE(2) + 2*JSON_OBJECT_SIZE(3) + JSON_OBJECT_SIZE(9) + 300;
const size_t bufferSize2 = 3 * JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(3) + JSON_OBJECT_SIZE(9) + 300;
DynamicJsonBuffer jsonBuffer2(bufferSize2);
// Parse JSON object
JsonObject& root2 = jsonBuffer2.parseObject(printClient);
if (!root2.success()) {
JsonObject &root2 = jsonBuffer2.parseObject(printClient);
if (!root2.success())
{
printerData.isPrinting = false;
printerData.toolTemp = "";
printerData.toolTargetTemp = "";
printerData.bedTemp = "";
printerData.bedTargetTemp = (const char*)root2["temperature"]["bed"]["target"];
printerData.bedTargetTemp = (const char *)root2["temperature"]["bed"]["target"];
return;
}
String printing = (const char*)root2["state"]["flags"]["printing"];
if (printing == "true") {
String printing = (const char *)root2["state"]["flags"]["printing"];
if (printing == "true")
{
printerData.isPrinting = true;
} else {
}
else
{
printerData.isPrinting = false;
}
printerData.toolTemp = (const char*)root2["temperature"]["tool0"]["actual"];
printerData.toolTargetTemp = (const char*)root2["temperature"]["tool0"]["target"];
printerData.bedTemp = (const char*)root2["temperature"]["bed"]["actual"];
printerData.bedTargetTemp = (const char*)root2["temperature"]["bed"]["target"];
printerData.toolTemp = (const char *)root2["temperature"]["tool0"]["actual"];
printerData.toolTargetTemp = (const char *)root2["temperature"]["tool0"]["target"];
printerData.bedTemp = (const char *)root2["temperature"]["bed"]["actual"];
printerData.bedTargetTemp = (const char *)root2["temperature"]["bed"]["target"];
if (isPrinting()) {
if (isPrinting())
{
Serial.println("Status: " + printerData.state + " " + printerData.fileName + "(" + printerData.progressCompletion + "%)");
}
}
void OctoPrintClient::getPrinterPsuState() {
void OctoPrintClient::getPrinterPsuState()
{
//**** get the PSU state (if enabled and printer operational)
if (pollPsu && isOperational()) {
if (!validate()) {
if (pollPsu && isOperational())
{
if (!validate())
{
printerData.isPSUoff = false; // we do not know PSU state, so assume on.
return;
}
String apiPostData = "POST /api/plugin/psucontrol HTTP/1.1";
String apiPostBody = "{\"command\":\"getPSUState\"}";
WiFiClient printClient = getPostRequest(apiPostData,apiPostBody);
if (printerData.error != "") {
WiFiClient printClient = getPostRequest(apiPostData, apiPostBody);
if (printerData.error != "")
{
printerData.isPSUoff = false; // we do not know PSU state, so assume on.
return;
}
@ -268,25 +357,31 @@ void OctoPrintClient::getPrinterPsuState() {
DynamicJsonBuffer jsonBuffer3(bufferSize3);
// Parse JSON object
JsonObject& root3 = jsonBuffer3.parseObject(printClient);
if (!root3.success()) {
JsonObject &root3 = jsonBuffer3.parseObject(printClient);
if (!root3.success())
{
printerData.isPSUoff = false; // we do not know PSU state, so assume on
return;
}
String psu = (const char*)root3["isPSUOn"];
if (psu == "true") {
String psu = (const char *)root3["isPSUOn"];
if (psu == "true")
{
printerData.isPSUoff = false; // PSU checked and is on
} else {
}
else
{
printerData.isPSUoff = true; // PSU checked and is off, set flag
}
printClient.stop(); //stop client
} else {
}
else
{
printerData.isPSUoff = false; // we are not checking PSU state, so assume on
}
}
void OctoPrintClient::getTemperaturePresets()
void OctoPrintClient::updateTemperaturePresets()
{
if (!validate())
{
@ -302,6 +397,8 @@ void OctoPrintClient::getTemperaturePresets()
const size_t bufferSize3 = JSON_ARRAY_SIZE(4) + JSON_OBJECT_SIZE(1) + 20 * JSON_OBJECT_SIZE(4) + 245;
DynamicJsonBuffer jsonBuffer3(bufferSize3);
temperaturePresets.clear();
printClient.find("\"temperature\": ");
do
{
@ -313,8 +410,6 @@ void OctoPrintClient::getTemperaturePresets()
}
else
{
temperaturePresets.clear();
JsonArray &temperature_profiles = root3["profiles"];
for (int i = 0; i < temperature_profiles.size(); i++)
@ -326,6 +421,8 @@ void OctoPrintClient::getTemperaturePresets()
preset->extruder = temperature_profiles[i]["extruder"];
preset->PresetName = temperature_profiles[i]["name"].as<String>();
temperaturePresets.add(preset);
}
}
} while (printClient.findUntil(",", "]"));
@ -334,7 +431,8 @@ void OctoPrintClient::getTemperaturePresets()
}
// Reset all PrinterData
void OctoPrintClient::resetPrintData() {
void OctoPrintClient::resetPrintData()
{
printerData.averagePrintTime = "";
printerData.estimatedPrintTime = "";
printerData.fileName = "";
@ -355,108 +453,134 @@ void OctoPrintClient::resetPrintData() {
printerData.error = "";
}
String OctoPrintClient::getAveragePrintTime(){
String OctoPrintClient::getAveragePrintTime()
{
return printerData.averagePrintTime;
}
String OctoPrintClient::getEstimatedPrintTime() {
String OctoPrintClient::getEstimatedPrintTime()
{
return printerData.estimatedPrintTime;
}
String OctoPrintClient::getFileName() {
String OctoPrintClient::getFileName()
{
return printerData.fileName;
}
String OctoPrintClient::getFileSize() {
String OctoPrintClient::getFileSize()
{
return printerData.fileSize;
}
String OctoPrintClient::getLastPrintTime(){
String OctoPrintClient::getLastPrintTime()
{
return printerData.lastPrintTime;
}
String OctoPrintClient::getProgressCompletion() {
String OctoPrintClient::getProgressCompletion()
{
return String(printerData.progressCompletion.toInt());
}
String OctoPrintClient::getProgressFilepos() {
String OctoPrintClient::getProgressFilepos()
{
return printerData.progressFilepos;
}
String OctoPrintClient::getProgressPrintTime() {
String OctoPrintClient::getProgressPrintTime()
{
return printerData.progressPrintTime;
}
String OctoPrintClient::getProgressPrintTimeLeft() {
String OctoPrintClient::getProgressPrintTimeLeft()
{
String rtnValue = printerData.progressPrintTimeLeft;
if (getProgressCompletion() == "100") {
if (getProgressCompletion() == "100")
{
rtnValue = "0"; // Print is done so this should be 0 this is a fix for OctoPrint
}
return rtnValue;
}
String OctoPrintClient::getState() {
String OctoPrintClient::getState()
{
return printerData.state;
}
boolean OctoPrintClient::isPrinting() {
boolean OctoPrintClient::isPrinting()
{
return printerData.isPrinting;
}
boolean OctoPrintClient::isPSUoff() {
boolean OctoPrintClient::isPSUoff()
{
return printerData.isPSUoff;
}
boolean OctoPrintClient::isOperational() {
boolean OctoPrintClient::isOperational()
{
boolean operational = false;
if (printerData.state == "Operational" || isPrinting()) {
if (printerData.state == "Operational" || isPrinting())
{
operational = true;
}
return operational;
}
String OctoPrintClient::getTempBedActual() {
String OctoPrintClient::getTempBedActual()
{
return printerData.bedTemp;
}
String OctoPrintClient::getTempBedTarget() {
String OctoPrintClient::getTempBedTarget()
{
return printerData.bedTargetTemp;
}
String OctoPrintClient::getTempToolActual() {
String OctoPrintClient::getTempToolActual()
{
return printerData.toolTemp;
}
String OctoPrintClient::getTempToolTarget() {
String OctoPrintClient::getTempToolTarget()
{
return printerData.toolTargetTemp;
}
String OctoPrintClient::getFilamentLength() {
String OctoPrintClient::getFilamentLength()
{
return printerData.filamentLength;
}
String OctoPrintClient::getError() {
String OctoPrintClient::getError()
{
return printerData.error;
}
String OctoPrintClient::getValueRounded(String value) {
String OctoPrintClient::getValueRounded(String value)
{
float f = value.toFloat();
int rounded = (int)(f+0.5f);
int rounded = (int)(f + 0.5f);
return String(rounded);
}
String OctoPrintClient::getPrinterType() {
String OctoPrintClient::getPrinterType()
{
return printerType;
}
int OctoPrintClient::getPrinterPort() {
int OctoPrintClient::getPrinterPort()
{
return myPort;
}
String OctoPrintClient::getPrinterName() {
String OctoPrintClient::getPrinterName()
{
return printerData.printerName;
}
void OctoPrintClient::setPrinterName(String printer) {
void OctoPrintClient::setPrinterName(String printer)
{
printerData.printerName = printer;
}

7
printermonitor/OctoPrintClient.h
View File

@ -77,10 +77,13 @@ public:
OctoPrintClient(String ApiKey, String server, int port, String user, String pass, boolean psu);
void getPrinterJobResults();
void getPrinterPsuState();
void preheatTool(int toolIndex, int temperature);
void preheatBed(int temperature);
void preheatChamber (int temperature);
void updatePrintClient(String ApiKey, String server, int port, String user, String pass, boolean psu);
void getTemperaturePresets();
void updateTemperaturePresets();
LinkedList<TemperaturePreset *> temperaturePresets;
LinkedList<TemperaturePreset *> temperaturePresets;
String getAveragePrintTime();
String getEstimatedPrintTime();

2
printermonitor/Settings.h
View File

@ -56,6 +56,8 @@ SOFTWARE.
#include "OLEDDisplayUi.h"
#include "libs/Keypad_tw/Keypad_tw.h"
#include "Menu/Menu.h"
#include "Menu/PreheatMenu.h"
#include "Menu/CooldownMenu.h"
#define KEYPAD_I2CADDR 0x27 // keypad on PCF8574A

1
printermonitor/TemperaturePreset.h
View File

@ -1,3 +1,4 @@
#pragma once
#include <Arduino.h>
class TemperaturePreset

27
printermonitor/printermonitor.ino
View File

@ -77,7 +77,9 @@ FrameCallback clockFrame[2];
FrameCallback menuFrame[1];
boolean isClockOn = false;
Menu* temperatureMenu;
PreheatMenu* preheatMenu;
CooldownMenu* cooldownMenu;
Menu* activeMenu;
OverlayCallback overlays[] = {drawHeaderOverlay};
OverlayCallback clockOverlay[] = {drawClockHeaderOverlay};
@ -278,15 +280,11 @@ void setup()
menuFrame[0] = drawMenu;
ui.setOverlays(overlays, numberOfOverlays);
temperatureMenu = new Menu("Preheat Menu");
temperatureMenu->menuItems.add(new MenuItem("LangesFilament"));
temperatureMenu->menuItems.add(new MenuItem("ABS"));
temperatureMenu->menuItems.add(new MenuItem("PET"));
temperatureMenu->menuItems.add(new MenuItem("PLA"));
preheatMenu = new PreheatMenu();
preheatMenu->client = &printerClient;
temperatureMenu->menuItems.add(new MenuItem("Dingsda"));
displayMenu(temperatureMenu);
cooldownMenu = new CooldownMenu();
cooldownMenu->client = &printerClient;
// Inital UI takes care of initalising the display too.
ui.init();
@ -415,10 +413,12 @@ void menuExitCallback () {
}
void displayMenu (Menu *menu) {
printerClient.getTemperaturePresets();
Serial.println("Display Menu");
menu->displayMillis = millis();
menu->exitCallback = menuExitCallback;
menu->startPage = 0;
menu->beforeShow();
activeMenu = menu;
}
//************************************************************
@ -439,7 +439,10 @@ void loop()
switch (key) {
case 'A':
displayMenu(temperatureMenu);
displayMenu(preheatMenu);
break;
case 'B':
displayMenu(cooldownMenu);
break;
}
}
@ -458,6 +461,7 @@ void loop()
lastMinute = timeClient.getMinutes(); // reset the check value
printerClient.getPrinterJobResults();
printerClient.getPrinterPsuState();
printerClient.updateTemperaturePresets();
ledOnOff(false);
}
else if (printerClient.isPrinting())
@ -581,6 +585,7 @@ void handleUpdateConfig()
findMDNS();
printerClient.getPrinterJobResults();
printerClient.getPrinterPsuState();
printerClient.updateTemperaturePresets();
if (INVERT_DISPLAY != flipOld)
{
ui.init();