Added initial preheat and cooldown menus

printermonitor/Menu/CooldownMenu.cpp

@@ -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);
+}

printermonitor/Menu/CooldownMenu.h

@@ -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;
+};

printermonitor/Menu/Menu.cpp

@@ -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)

printermonitor/Menu/Menu.h

@@ -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);

printermonitor/Menu/MenuItem.h

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

printermonitor/Menu/PreheatMenu.cpp

@@ -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;
 }

printermonitor/Menu/PreheatMenu.h

@@ -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();
+    PreheatMenu();
-void RetrieveTemperatures();
+    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;
 };

printermonitor/Menu/TemperatureMenuItem.h

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

printermonitor/OctoPrintClient.cpp

@@ -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,47 +47,56 @@ 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();
       printerData.error = "Connection to " + String(myServer) + ":" + String(myPort) + " failed.";
       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,15 +153,17 @@ 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();
       printerData.error = "Connection to " + String(myServer) + ":" + String(myPort) + " failed.";
       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,119 +195,193 @@ WiFiClient OctoPrintClient::getPostRequest(String apiPostData, String apiPostBod
   return printClient;
 }
 
-void OctoPrintClient::getPrinterJobResults() {
+void OctoPrintClient::preheatTool(int tool, int temperature)
-  if (!validate()) {
+{
+  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);
+  JsonObject &root = jsonBuffer.parseObject(printClient);
-  if (!root.success()) {
+  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"];
 
-  if (isOperational()) {
+  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())
+  {
     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);
+  JsonObject &root2 = jsonBuffer2.parseObject(printClient);
-  if (!root2.success()) {
+  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"];
+  String printing = (const char *)root2["state"]["flags"]["printing"];
-  if (printing == "true") {
+  if (printing == "true")
+  {
     printerData.isPrinting = true;
-  } else {
+  }
+  else
+  {
     printerData.isPrinting = false;
   }
-  printerData.toolTemp = (const char*)root2["temperature"]["tool0"]["actual"];
+  printerData.toolTemp = (const char *)root2["temperature"]["tool0"]["actual"];
-  printerData.toolTargetTemp = (const char*)root2["temperature"]["tool0"]["target"];
+  printerData.toolTargetTemp = (const char *)root2["temperature"]["tool0"]["target"];
-  printerData.bedTemp = (const char*)root2["temperature"]["bed"]["actual"];
+  printerData.bedTemp = (const char *)root2["temperature"]["bed"]["actual"];
-  printerData.bedTargetTemp = (const char*)root2["temperature"]["bed"]["target"];
+  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 (pollPsu && isOperational())
-    if (!validate()) {
+  {
+    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);
+    WiFiClient printClient = getPostRequest(apiPostData, apiPostBody);
-    if (printerData.error != "") {
+    if (printerData.error != "")
+    {
       printerData.isPSUoff = false; // we do not know PSU state, so assume on.
       return;
     }
     const size_t bufferSize3 = JSON_OBJECT_SIZE(2) + 300;
     DynamicJsonBuffer jsonBuffer3(bufferSize3);
-  
+
     // Parse JSON object
-    JsonObject& root3 = jsonBuffer3.parseObject(printClient);
+    JsonObject &root3 = jsonBuffer3.parseObject(printClient);
-    if (!root3.success()) {
+    if (!root3.success())
+    {
       printerData.isPSUoff = false; // we do not know PSU state, so assume on
       return;
     }
-  
+
-    String psu = (const char*)root3["isPSUOn"];
+    String psu = (const char *)root3["isPSUOn"];
-    if (psu == "true") {
+    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;  
+{
+  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;
 }

printermonitor/OctoPrintClient.h

@@ -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();

printermonitor/Settings.h

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

printermonitor/TemperaturePreset.h

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

printermonitor/printermonitor.ino

@@ -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");
+preheatMenu = new PreheatMenu();
-temperatureMenu->menuItems.add(new MenuItem("LangesFilament"));
+preheatMenu->client = &printerClient;
-temperatureMenu->menuItems.add(new MenuItem("ABS"));
-temperatureMenu->menuItems.add(new MenuItem("PET"));
-temperatureMenu->menuItems.add(new MenuItem("PLA"));
 
-temperatureMenu->menuItems.add(new MenuItem("Dingsda"));
+cooldownMenu = new CooldownMenu();
-
+cooldownMenu->client = &printerClient;
-displayMenu(temperatureMenu);
 
   // 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();