Compare commits

...
7 Commits
13 changed files with 658 additions and 480 deletions

No files matched your search

+1 -1
View File
@@ -9,7 +9,7 @@
; https://docs.platformio.org/page/projectconf.html ; https://docs.platformio.org/page/projectconf.html
[common] [common]
version = "3.3.0" version = "3.3.1"
to_old_version = "3.2.0" to_old_version = "3.2.0"
## ##
+7 -6
View File
@@ -136,7 +136,7 @@ bool sendWeight(int spoolId, String tagUuid, float measuredWeight) {
Serial.printf("API payload: %s\n", payload.c_str()); Serial.printf("API payload: %s\n", payload.c_str());
int httpCode = http.POST(payload); int httpCode = http.POST(payload);
Serial.printf("API response code: %d\n", httpCode); Serial.printf("API response code: %d\n", httpCode);
if (httpCode == 200) { if (httpCode == 200) {
String response = http.getString(); String response = http.getString();
JsonDocument responseDoc; JsonDocument responseDoc;
@@ -157,7 +157,7 @@ bool sendWeight(int spoolId, String tagUuid, float measuredWeight) {
vTaskDelay(pdMS_TO_TICKS(2000)); vTaskDelay(pdMS_TO_TICKS(2000));
oledClearPriority(); oledClearPriority();
} }
http.end(); http.end();
return false; return false;
} }
@@ -192,7 +192,7 @@ bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, S
http.addHeader("Content-Type", "application/json"); http.addHeader("Content-Type", "application/json");
http.addHeader("Authorization", "Device " + filamanToken); http.addHeader("Authorization", "Device " + filamanToken);
http.addHeader("Connection", "keep-alive"); http.addHeader("Connection", "keep-alive");
JsonDocument doc; JsonDocument doc;
doc["success"] = success; doc["success"] = success;
if (tagUuid.length() > 0) doc["tag_uuid"] = tagUuid; if (tagUuid.length() > 0) doc["tag_uuid"] = tagUuid;
@@ -200,7 +200,7 @@ bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, S
if (locationId > 0) doc["location_id"] = locationId; if (locationId > 0) doc["location_id"] = locationId;
if (errorMessage.length() > 0) doc["error_message"] = errorMessage; if (errorMessage.length() > 0) doc["error_message"] = errorMessage;
if (remainingWeight > 0) doc["remaining_weight_g"] = remainingWeight; if (remainingWeight > 0) doc["remaining_weight_g"] = remainingWeight;
String payload; String payload;
serializeJson(doc, payload); serializeJson(doc, payload);
int httpCode = http.POST(payload); int httpCode = http.POST(payload);
@@ -212,7 +212,7 @@ void filamanApiTask(void* pvParameters) {
for (;;) { for (;;) {
ApiRequest req; ApiRequest req;
bool hasReq = false; bool hasReq = false;
if (xSemaphoreTake(queueMutex, pdMS_TO_TICKS(100)) == pdTRUE) { if (xSemaphoreTake(queueMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
for(int i=0; i<MAX_API_QUEUE; i++) { for(int i=0; i<MAX_API_QUEUE; i++) {
if(apiQueue[i].active) { if(apiQueue[i].active) {
@@ -324,11 +324,12 @@ void sendRfidResultAsync(String tagUuid, int spoolId, int locationId, bool succe
} }
bool initFilaman() { bool initFilaman() {
oledShowProgressBar(3, NUM_SETUP_STEPS, DISPLAY_BOOT_TEXT, tr(STR_API_INIT));
loadFilamanConfig(); loadFilamanConfig();
queueMutex = xSemaphoreCreateMutex(); queueMutex = xSemaphoreCreateMutex();
// Move to Core 1 (Hardware Core) to free up Core 0 for WiFi/Webserver // Move to Core 1 (Hardware Core) to free up Core 0 for WiFi/Webserver
// Set priority to 1 (same as Scale/NFC) to ensure fair scheduling // Set priority to 1 (same as Scale/NFC) to ensure fair scheduling
xTaskCreatePinnedToCore(filamanApiTask, "FilaManApi", 6144, NULL, 1, NULL, 1); xTaskCreatePinnedToCore(filamanApiTask, "FilaManApi", 6144, NULL, 1, NULL, 1);
if (checkFilamanRegistration()) sendHeartbeatAsync(); if (checkFilamanRegistration()) sendHeartbeatAsync();
return true; return true;
} }
+3 -1
View File
@@ -29,6 +29,8 @@
#define DISPLAY_UPDATE_INTERVAL 1000U #define DISPLAY_UPDATE_INTERVAL 1000U
#define FILAMAN_HEARTBEAT_INTERVAL 60000U #define FILAMAN_HEARTBEAT_INTERVAL 60000U
#define NUM_SETUP_STEPS 6 // 0:Display 1:WiFi 2:Web-Server 3:API 4:NFC 5:Scale 6:<finished>
extern const uint8_t PN532_IRQ; extern const uint8_t PN532_IRQ;
extern const uint8_t PN532_RESET; extern const uint8_t PN532_RESET;
@@ -72,4 +74,4 @@ extern uint8_t scaleTaskPrio;
extern uint16_t defaultScaleCalibrationValue; extern uint16_t defaultScaleCalibrationValue;
extern uint16_t oledSleepTimeout; extern uint16_t oledSleepTimeout;
#endif #endif
+53 -31
View File
@@ -115,7 +115,7 @@ void setupDisplay() {
lastActivityMillis = millis(); lastActivityMillis = millis();
oledShowTopRow(); oledShowTopRow();
oledShowProgressBar(0, 7, DISPLAY_BOOT_TEXT, tr(STR_DISPLAY_INIT)); oledShowProgressBar(0, NUM_SETUP_STEPS, DISPLAY_BOOT_TEXT, tr(STR_DISPLAY_INIT));
} }
void oledclearline() { void oledclearline() {
@@ -144,14 +144,14 @@ int oled_center_v(const String &text) {
std::vector<String> splitTextIntoLines(const String &text, uint8_t textSize) { std::vector<String> splitTextIntoLines(const String &text, uint8_t textSize) {
std::vector<String> lines; std::vector<String> lines;
display.setTextSize(textSize); display.setTextSize(textSize);
// Text in Wörter aufteilen // Text in Wörter aufteilen
std::vector<String> words; std::vector<String> words;
int pos = 0; int pos = 0;
while (pos < text.length()) { while (pos < text.length()) {
// Überspringe Leerzeichen am Anfang // Überspringe Leerzeichen am Anfang
while (pos < text.length() && text[pos] == ' ') pos++; while (pos < text.length() && text[pos] == ' ') pos++;
// Finde nächstes Leerzeichen // Finde nächstes Leerzeichen
int nextSpace = text.indexOf(' ', pos); int nextSpace = text.indexOf(' ', pos);
if (nextSpace == -1) { if (nextSpace == -1) {
@@ -165,19 +165,19 @@ std::vector<String> splitTextIntoLines(const String &text, uint8_t textSize) {
words.push_back(text.substring(pos, nextSpace)); words.push_back(text.substring(pos, nextSpace));
pos = nextSpace + 1; pos = nextSpace + 1;
} }
// Wörter zu Zeilen zusammenfügen // Wörter zu Zeilen zusammenfügen
String currentLine = ""; String currentLine = "";
for (size_t i = 0; i < words.size(); i++) { for (size_t i = 0; i < words.size(); i++) {
String testLine = currentLine; String testLine = currentLine;
if (currentLine.length() > 0) testLine += " "; if (currentLine.length() > 0) testLine += " ";
testLine += words[i]; testLine += words[i];
// Prüfe ob diese Kombination auf die Zeile passt // Prüfe ob diese Kombination auf die Zeile passt
int16_t x1, y1; int16_t x1, y1;
uint16_t lineWidth, h; uint16_t lineWidth, h;
display.getTextBounds(testLine, 0, OLED_DATA_START, &x1, &y1, &lineWidth, &h); display.getTextBounds(testLine, 0, OLED_DATA_START, &x1, &y1, &lineWidth, &h);
if (lineWidth <= SCREEN_WIDTH) { if (lineWidth <= SCREEN_WIDTH) {
// Passt noch in diese Zeile // Passt noch in diese Zeile
currentLine = testLine; currentLine = testLine;
@@ -192,40 +192,40 @@ std::vector<String> splitTextIntoLines(const String &text, uint8_t textSize) {
} }
} }
} }
// Letzte Zeile hinzufügen // Letzte Zeile hinzufügen
if (currentLine.length() > 0) { if (currentLine.length() > 0) {
lines.push_back(currentLine); lines.push_back(currentLine);
} }
return lines; return lines;
} }
void oledShowMultilineMessage(const String &message, uint8_t size) { void oledShowMultilineMessage(const String &message, uint8_t size) {
std::vector<String> lines; std::vector<String> lines;
int maxLines = 3; // Maximale Anzahl Zeilen für size 2 int maxLines = 3; // Maximale Anzahl Zeilen für size 2
// Erste Prüfung mit aktueller Größe // Erste Prüfung mit aktueller Größe
lines = splitTextIntoLines(message, size); lines = splitTextIntoLines(message, size);
// Wenn mehr als maxLines Zeilen, reduziere Textgröße // Wenn mehr als maxLines Zeilen, reduziere Textgröße
if (lines.size() > maxLines && size > 1) { if (lines.size() > maxLines && size > 1) {
size = 1; size = 1;
lines = splitTextIntoLines(message, size); lines = splitTextIntoLines(message, size);
} }
// Ausgabe // Ausgabe
display.setTextSize(size); display.setTextSize(size);
int lineHeight = size * 8; int lineHeight = size * 8;
int totalHeight = lines.size() * lineHeight; int totalHeight = lines.size() * lineHeight;
int startY = OLED_DATA_START + ((OLED_DATA_END - OLED_DATA_START - totalHeight) / 2); int startY = OLED_DATA_START + ((OLED_DATA_END - OLED_DATA_START - totalHeight) / 2);
uint8_t lineDistance = (lines.size() == 2) ? 5 : 0; uint8_t lineDistance = (lines.size() == 2) ? 5 : 0;
for (size_t i = 0; i < lines.size(); i++) { for (size_t i = 0; i < lines.size(); i++) {
display.setCursor(oled_center_h(lines[i]), startY + (i * lineHeight) + (i == 1 ? lineDistance : 0)); display.setCursor(oled_center_h(lines[i]), startY + (i * lineHeight) + (i == 1 ? lineDistance : 0));
display.print(lines[i]); display.print(lines[i]);
} }
display.display(); display.display();
} }
@@ -233,12 +233,12 @@ void oledDisplayText(const String &message, uint8_t size) {
oledcleardata(); oledcleardata();
display.setTextSize(size); display.setTextSize(size);
display.setTextWrap(false); display.setTextWrap(false);
// Prüfe ob Text in eine Zeile passt // Prüfe ob Text in eine Zeile passt
int16_t x1, y1; int16_t x1, y1;
uint16_t textWidth, h; uint16_t textWidth, h;
display.getTextBounds(message, 0, 0, &x1, &y1, &textWidth, &h); display.getTextBounds(message, 0, 0, &x1, &y1, &textWidth, &h);
// Text passt in eine Zeile? // Text passt in eine Zeile?
if (textWidth <= SCREEN_WIDTH) { if (textWidth <= SCREEN_WIDTH) {
display.setCursor(oled_center_h(message), oled_center_v(message)); display.setCursor(oled_center_h(message), oled_center_v(message));
@@ -250,6 +250,12 @@ void oledDisplayText(const String &message, uint8_t size) {
} }
void oledShowTopRow() { void oledShowTopRow() {
const u_int8_t rightmost_x = 108;
const u_int8_t x_offset = 25;
const u_int8_t symbol_width =16;
const u_int8_t symbol_height =16;
u_int8_t x_pos = rightmost_x;
oledclearline(); oledclearline();
display.setTextSize(1); display.setTextSize(1);
@@ -259,29 +265,45 @@ void oledShowTopRow() {
iconToggle = !iconToggle; iconToggle = !iconToggle;
// draw symbols from right to left
// Do not show status indicators during boot // Do not show status indicators during boot
if(!booting){ if(!booting){
if (filamanConnected) { // WiFi
display.drawBitmap(80, 0, bitmap_spoolman_on , 16, 16, WHITE); x_pos = rightmost_x;
if (wifiOn == 1) {
display.drawBitmap(x_pos, 0, wifi_on , symbol_width, symbol_height, WHITE);
} else { } else {
if(iconToggle){ if(iconToggle){
display.drawBitmap(80, 0, bitmap_spoolman_on , 16, 16, WHITE); display.drawBitmap(x_pos, 0, wifi_on , symbol_width, symbol_height, WHITE);
display.drawLine(80, 15, 96, 0, WHITE); display.drawLine(x_pos, symbol_height-1, x_pos + symbol_width, 0, WHITE);
display.drawLine(81, 15, 97, 0, WHITE); display.drawLine(x_pos+1, symbol_height-1, x_pos+1 + symbol_width, 0, WHITE);
} }
} }
if (wifiOn == 1) { // Backend
display.drawBitmap(107, 0, wifi_on , 16, 16, WHITE); x_pos -= x_offset; // change x position to the left
if (filamanConnected) {
display.drawBitmap(x_pos, 0, bitmap_spoolman_on , symbol_width, symbol_height, WHITE);
} else { } else {
if(iconToggle){ if(iconToggle){
display.drawBitmap(107, 0, wifi_on , 16, 16, WHITE); display.drawBitmap(x_pos, 0, bitmap_spoolman_on , symbol_width, symbol_height, WHITE);
display.drawLine(107, 15, 123, 0, WHITE); display.drawLine(x_pos, symbol_height-1, x_pos + symbol_width, 0, WHITE);
display.drawLine(108, 15, 124, 0, WHITE); display.drawLine(x_pos+1, symbol_height-1, x_pos+1 + symbol_width, 0, WHITE);
} }
} }
// Scale
x_pos -= x_offset; // change x position to the left
if (scaleConnected) {
display.drawBitmap(x_pos, 0, bitmap_scale_on , symbol_width, symbol_height, WHITE);
} else {
display.drawBitmap(x_pos, 0, bitmap_scale_on , symbol_width, symbol_height, WHITE);
display.drawLine(x_pos-1, symbol_height-1, x_pos-1 + symbol_width, 0, WHITE);
display.drawLine(x_pos, symbol_height-1, x_pos + symbol_width, 0, WHITE);
display.drawLine(x_pos+1, symbol_height-1, x_pos+1 + symbol_width, 0, WHITE);
}
} }
display.display(); display.display();
} }
@@ -313,7 +335,7 @@ void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char*
// clear data and bar area // clear data and bar area
display.fillRect(0, OLED_DATA_START, SCREEN_WIDTH, SCREEN_HEIGHT-16, BLACK); display.fillRect(0, OLED_DATA_START, SCREEN_WIDTH, SCREEN_HEIGHT-16, BLACK);
display.setTextWrap(false); display.setTextWrap(false);
display.setTextSize(2); display.setTextSize(2);
display.setCursor(0, OLED_DATA_START+4); display.setCursor(0, OLED_DATA_START+4);
@@ -343,7 +365,7 @@ void oledShowRemainingWeight(uint16_t remainingWeight) {
display.setTextSize(1); display.setTextSize(1);
display.setCursor(oled_center_h(tr(STR_WEIGHT_SENT_REST)), OLED_DATA_START + 4); display.setCursor(oled_center_h(tr(STR_WEIGHT_SENT_REST)), OLED_DATA_START + 4);
display.print(tr(STR_WEIGHT_SENT_REST)); display.print(tr(STR_WEIGHT_SENT_REST));
display.setTextSize(3); display.setTextSize(3);
String weightStr = String(remainingWeight) + " g"; String weightStr = String(remainingWeight) + " g";
display.setCursor(oled_center_h(weightStr), OLED_DATA_START + 22); display.setCursor(oled_center_h(weightStr), OLED_DATA_START + 22);
@@ -354,15 +376,15 @@ void oledShowRemainingWeight(uint16_t remainingWeight) {
void oledShowConnectionError(const char* error, const String& ip) { void oledShowConnectionError(const char* error, const String& ip) {
oledcleardata(); oledcleardata();
display.setTextSize(1); display.setTextSize(1);
// Error Message // Error Message
display.setCursor(oled_center_h(error), OLED_DATA_START + 4); display.setCursor(oled_center_h(error), OLED_DATA_START + 4);
display.print(error); display.print(error);
// IP Address // IP Address
display.setTextSize(1); display.setTextSize(1);
display.setCursor(oled_center_h(ip), OLED_DATA_START + 24); display.setCursor(oled_center_h(ip), OLED_DATA_START + 24);
display.print(ip); display.print(ip);
display.display(); display.display();
} }
+81 -75
View File
@@ -1,7 +1,7 @@
#include <Arduino.h> #include <Arduino.h>
/* /*
// Create Icons // Create Icons
https://javl.github.io/image2cpp/ https://javl.github.io/image2cpp/
Size: 47x47 Size: 47x47
BG Color: Black BG Color: Black
@@ -10,117 +10,123 @@ Ohters in default
*/ */
const unsigned char wifi_on [] PROGMEM = { const unsigned char wifi_on [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x1f, 0xf8, 0x78, 0x1e, 0x60, 0x06, 0x07, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x1f, 0xf8, 0x78, 0x1e, 0x60, 0x06, 0x07, 0xe0,
0x0f, 0xf0, 0x08, 0x10, 0x00, 0x00, 0x03, 0xc0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x0f, 0xf0, 0x08, 0x10, 0x00, 0x00, 0x03, 0xc0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
const unsigned char wifi_off [] PROGMEM = { const unsigned char wifi_off [] PROGMEM = {
0x00, 0x00, 0x20, 0x00, 0x30, 0x00, 0x1b, 0xf0, 0x3d, 0xfc, 0x7e, 0x1e, 0x63, 0x06, 0x07, 0xa0, 0x00, 0x00, 0x20, 0x00, 0x30, 0x00, 0x1b, 0xf0, 0x3d, 0xfc, 0x7e, 0x1e, 0x63, 0x06, 0x07, 0xa0,
0x1f, 0xd8, 0x08, 0x60, 0x01, 0xb0, 0x03, 0xd8, 0x01, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x1f, 0xd8, 0x08, 0x60, 0x01, 0xb0, 0x03, 0xd8, 0x01, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
// 'off', 16x16px // 'off', 16x16px
const unsigned char bitmap_off [] PROGMEM = { const unsigned char bitmap_off [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
// 'spoolman_on', 16x16px // 'spoolman_on', 16x16px
const unsigned char bitmap_spoolman_on [] PROGMEM = { const unsigned char bitmap_spoolman_on [] PROGMEM = {
0x03, 0xc0, 0x08, 0xf0, 0x20, 0xfc, 0x00, 0xfc, 0x40, 0xfe, 0x70, 0xf0, 0xf8, 0xc1, 0xff, 0xc1, 0x03, 0xc0, 0x08, 0xf0, 0x20, 0xfc, 0x00, 0xfc, 0x40, 0xfe, 0x70, 0xf0, 0xf8, 0xc1, 0xff, 0xc1,
0xff, 0xc1, 0xf9, 0xc1, 0x70, 0xf0, 0x40, 0xfe, 0x00, 0xfc, 0x20, 0xfc, 0x08, 0xf0, 0x03, 0xc0 0xff, 0xc1, 0xf9, 0xc1, 0x70, 0xf0, 0x40, 0xfe, 0x00, 0xfc, 0x20, 0xfc, 0x08, 0xf0, 0x03, 0xc0
}; };
// 'bambu_on', 16x16px // 'bambu_on', 16x16px
const unsigned char bitmap_bambu_on [] PROGMEM = { const unsigned char bitmap_bambu_on [] PROGMEM = {
0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x1c, 0x3e, 0x00, 0x3e, 0x40, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x1c, 0x3e, 0x00, 0x3e, 0x40,
0x30, 0x78, 0x00, 0x7c, 0x06, 0x7c, 0x1e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c 0x30, 0x78, 0x00, 0x7c, 0x06, 0x7c, 0x1e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c, 0x3e, 0x7c
}; };
// 'scale_on', 16x16px
const unsigned char bitmap_scale_on [] PROGMEM = {
0x01, 0x80, 0x3f, 0xfc, 0x3f, 0xfc, 0x11, 0x88, 0x21, 0x84, 0x09, 0x90, 0x49, 0x92, 0x45, 0xa2,
0x05, 0xa1, 0xff, 0xbf, 0xfd, 0xbf, 0x79, 0x9e, 0x01, 0x80, 0x01, 0x80, 0x0f, 0xf0, 0x0f, 0xf8
};
// 'failed', 47x47px // 'failed', 47x47px
const unsigned char icon_failed [] PROGMEM = { const unsigned char icon_failed [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff,
0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x1f, 0xfc, 0x7f, 0xf0, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x1f, 0xfc, 0x7f, 0xf0, 0x00, 0x00, 0x7f,
0x80, 0x03, 0xf8, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00, 0x80, 0x03, 0xf8, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00,
0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x07, 0xc0, 0x00, 0x00, 0x0f, 0x80, 0x07, 0x80, 0x00, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x07, 0xc0, 0x00, 0x00, 0x0f, 0x80, 0x07, 0x80, 0x00, 0x00,
0x07, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x1f, 0x00, 0x00, 0x00, 0x01, 0xe0, 0x1e, 0x03, 0x07, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x1f, 0x00, 0x00, 0x00, 0x01, 0xe0, 0x1e, 0x03,
0x80, 0x07, 0x80, 0xf0, 0x3e, 0x03, 0xc0, 0x07, 0x80, 0xf0, 0x3c, 0x03, 0xe0, 0x0f, 0x80, 0x78, 0x80, 0x07, 0x80, 0xf0, 0x3e, 0x03, 0xc0, 0x07, 0x80, 0xf0, 0x3c, 0x03, 0xe0, 0x0f, 0x80, 0x78,
0x3c, 0x01, 0xf0, 0x1f, 0x00, 0x78, 0x78, 0x00, 0xf8, 0x3e, 0x00, 0x38, 0x78, 0x00, 0x7c, 0x7c, 0x3c, 0x01, 0xf0, 0x1f, 0x00, 0x78, 0x78, 0x00, 0xf8, 0x3e, 0x00, 0x38, 0x78, 0x00, 0x7c, 0x7c,
0x00, 0x3c, 0x78, 0x00, 0x3c, 0xf8, 0x00, 0x3c, 0x78, 0x00, 0x3f, 0xf0, 0x00, 0x3c, 0x70, 0x00, 0x00, 0x3c, 0x78, 0x00, 0x3c, 0xf8, 0x00, 0x3c, 0x78, 0x00, 0x3f, 0xf0, 0x00, 0x3c, 0x70, 0x00,
0x1f, 0xf0, 0x00, 0x3c, 0x70, 0x00, 0x0f, 0xe0, 0x00, 0x3c, 0xf0, 0x00, 0x07, 0xc0, 0x00, 0x1c, 0x1f, 0xf0, 0x00, 0x3c, 0x70, 0x00, 0x0f, 0xe0, 0x00, 0x3c, 0xf0, 0x00, 0x07, 0xc0, 0x00, 0x1c,
0xf0, 0x00, 0x0f, 0xe0, 0x00, 0x3c, 0x70, 0x00, 0x1f, 0xf0, 0x00, 0x3c, 0x78, 0x00, 0x3f, 0xf0, 0xf0, 0x00, 0x0f, 0xe0, 0x00, 0x3c, 0x70, 0x00, 0x1f, 0xf0, 0x00, 0x3c, 0x78, 0x00, 0x3f, 0xf0,
0x00, 0x3c, 0x78, 0x00, 0x3e, 0xf8, 0x00, 0x3c, 0x78, 0x00, 0x7c, 0x7c, 0x00, 0x3c, 0x78, 0x00, 0x00, 0x3c, 0x78, 0x00, 0x3e, 0xf8, 0x00, 0x3c, 0x78, 0x00, 0x7c, 0x7c, 0x00, 0x3c, 0x78, 0x00,
0xf8, 0x3e, 0x00, 0x3c, 0x3c, 0x01, 0xf0, 0x1f, 0x00, 0x78, 0x3c, 0x03, 0xe0, 0x0f, 0x80, 0x78, 0xf8, 0x3e, 0x00, 0x3c, 0x3c, 0x01, 0xf0, 0x1f, 0x00, 0x78, 0x3c, 0x03, 0xe0, 0x0f, 0x80, 0x78,
0x3e, 0x03, 0xc0, 0x0f, 0x80, 0xf0, 0x1e, 0x03, 0x80, 0x07, 0x80, 0xf0, 0x1f, 0x00, 0x00, 0x00, 0x3e, 0x03, 0xc0, 0x0f, 0x80, 0xf0, 0x1e, 0x03, 0x80, 0x07, 0x80, 0xf0, 0x1f, 0x00, 0x00, 0x00,
0x01, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xe0, 0x07, 0x80, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xc0, 0x01, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xe0, 0x07, 0x80, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xc0,
0x00, 0x00, 0x0f, 0xc0, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00,
0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x7f, 0x80, 0x03, 0xfc, 0x00, 0x00, 0x1f, 0xf8, 0x3f, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x7f, 0x80, 0x03, 0xfc, 0x00, 0x00, 0x1f, 0xf8, 0x3f,
0xf0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x03, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x03, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00,
0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
// 'loading', 47x47px // 'loading', 47x47px
const unsigned char icon_loading [] PROGMEM = { const unsigned char icon_loading [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80,
0x00, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x00, 0x00,
0x03, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00,
0x00, 0x01, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x07, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xfe, 0x00, 0x01, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x07, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xfe,
0x00, 0x00, 0x00, 0x3f, 0xf9, 0xfc, 0x00, 0x00, 0x00, 0x7f, 0x83, 0xf8, 0x38, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x3f, 0xf9, 0xfc, 0x00, 0x00, 0x00, 0x7f, 0x83, 0xf8, 0x38, 0x00, 0x00, 0xff,
0x07, 0xf0, 0x7c, 0x00, 0x00, 0xfc, 0x07, 0xe0, 0x7e, 0x00, 0x01, 0xf8, 0x0f, 0xc0, 0x3f, 0x00, 0x07, 0xf0, 0x7c, 0x00, 0x00, 0xfc, 0x07, 0xe0, 0x7e, 0x00, 0x01, 0xf8, 0x0f, 0xc0, 0x3f, 0x00,
0x03, 0xf0, 0x07, 0x80, 0x1f, 0x00, 0x03, 0xe0, 0x03, 0x00, 0x1f, 0x80, 0x07, 0xe0, 0x00, 0x00, 0x03, 0xf0, 0x07, 0x80, 0x1f, 0x00, 0x03, 0xe0, 0x03, 0x00, 0x1f, 0x80, 0x07, 0xe0, 0x00, 0x00,
0x0f, 0x80, 0x07, 0xc0, 0x00, 0x00, 0x0f, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x07, 0xc0, 0x0f, 0x80, 0x0f, 0x80, 0x07, 0xc0, 0x00, 0x00, 0x0f, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x07, 0xc0, 0x0f, 0x80,
0x00, 0x00, 0x07, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x00, 0x00, 0x07, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0,
0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00,
0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0x80,
0x00, 0x00, 0x03, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x03, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x07, 0xc0,
0x07, 0xc0, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xe0, 0x00, 0x00, 0x0f, 0x80, 0x03, 0xe0, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xe0, 0x00, 0x00, 0x0f, 0x80, 0x03, 0xe0, 0x00, 0x00,
0x1f, 0x80, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00, 0x01, 0xfc, 0x1f, 0x80, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00, 0x01, 0xfc,
0x00, 0x00, 0x7e, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x7f, 0x80, 0x07, 0xf8, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x7f, 0x80, 0x07, 0xf8, 0x00,
0x00, 0x3f, 0xf0, 0x3f, 0xf0, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x07, 0xff, 0xff, 0x00, 0x3f, 0xf0, 0x3f, 0xf0, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x07, 0xff, 0xff,
0xc0, 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00,
0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
// 'success', 47x47px // 'success', 47x47px
const unsigned char icon_success [] PROGMEM = { const unsigned char icon_success [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff,
0x80, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0xf0, 0x00, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0xf0, 0x00, 0x00, 0x7f,
0x80, 0x03, 0xfc, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00, 0x80, 0x03, 0xfc, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00,
0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x03, 0xe0, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xc0, 0x00, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x03, 0xe0, 0x00, 0x00, 0x07, 0xc0, 0x07, 0xc0, 0x00, 0x00,
0x03, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x01, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x01, 0xf0, 0x1e, 0x00, 0x03, 0xc0, 0x0f, 0x80, 0x00, 0x00, 0x01, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x01, 0xf0, 0x1e, 0x00,
0x00, 0x00, 0x00, 0xf0, 0x1e, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0x3c, 0x00, 0x00, 0x01, 0xe0, 0x78, 0x00, 0x00, 0x00, 0xf0, 0x1e, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0x3c, 0x00, 0x00, 0x01, 0xe0, 0x78,
0x3c, 0x00, 0x00, 0x03, 0xe0, 0x78, 0x38, 0x00, 0x00, 0x03, 0xc0, 0x3c, 0x78, 0x00, 0x00, 0x07, 0x3c, 0x00, 0x00, 0x03, 0xe0, 0x78, 0x38, 0x00, 0x00, 0x03, 0xc0, 0x3c, 0x78, 0x00, 0x00, 0x07,
0xc0, 0x3c, 0x78, 0x00, 0x00, 0x0f, 0x80, 0x3c, 0x78, 0x00, 0x00, 0x1f, 0x00, 0x1c, 0x78, 0x00, 0xc0, 0x3c, 0x78, 0x00, 0x00, 0x0f, 0x80, 0x3c, 0x78, 0x00, 0x00, 0x1f, 0x00, 0x1c, 0x78, 0x00,
0x00, 0x1e, 0x00, 0x1c, 0x78, 0x0f, 0x00, 0x3e, 0x00, 0x1e, 0x78, 0x0f, 0x80, 0x7c, 0x00, 0x1e, 0x00, 0x1e, 0x00, 0x1c, 0x78, 0x0f, 0x00, 0x3e, 0x00, 0x1e, 0x78, 0x0f, 0x80, 0x7c, 0x00, 0x1e,
0x78, 0x0f, 0xc0, 0xf8, 0x00, 0x1e, 0x78, 0x07, 0xe0, 0xf0, 0x00, 0x1c, 0x78, 0x03, 0xf1, 0xf0, 0x78, 0x0f, 0xc0, 0xf8, 0x00, 0x1e, 0x78, 0x07, 0xe0, 0xf0, 0x00, 0x1c, 0x78, 0x03, 0xf1, 0xf0,
0x00, 0x1c, 0x78, 0x01, 0xfb, 0xe0, 0x00, 0x3c, 0x78, 0x00, 0xff, 0xc0, 0x00, 0x3c, 0x38, 0x00, 0x00, 0x1c, 0x78, 0x01, 0xfb, 0xe0, 0x00, 0x3c, 0x78, 0x00, 0xff, 0xc0, 0x00, 0x3c, 0x38, 0x00,
0x7f, 0x80, 0x00, 0x3c, 0x3c, 0x00, 0x3f, 0x80, 0x00, 0x78, 0x3c, 0x00, 0x1f, 0x00, 0x00, 0x78, 0x7f, 0x80, 0x00, 0x3c, 0x3c, 0x00, 0x3f, 0x80, 0x00, 0x78, 0x3c, 0x00, 0x1f, 0x00, 0x00, 0x78,
0x1e, 0x00, 0x0e, 0x00, 0x00, 0xf8, 0x1e, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x00, 0xf8, 0x1e, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00,
0x01, 0xf0, 0x0f, 0x80, 0x00, 0x00, 0x01, 0xe0, 0x07, 0xc0, 0x00, 0x00, 0x03, 0xc0, 0x03, 0xe0, 0x01, 0xf0, 0x0f, 0x80, 0x00, 0x00, 0x01, 0xe0, 0x07, 0xc0, 0x00, 0x00, 0x03, 0xc0, 0x03, 0xe0,
0x00, 0x00, 0x07, 0xc0, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x07, 0xc0, 0x03, 0xf0, 0x00, 0x00, 0x1f, 0x80, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0x00,
0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x7f, 0x80, 0x03, 0xfc, 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x7f, 0x80, 0x03, 0xfc, 0x00, 0x00, 0x1f, 0xfc, 0x3f,
0xf0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x03, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x03, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00,
0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
// 'transfer', 47x47px // 'transfer', 47x47px
const unsigned char icon_transfer [] PROGMEM = { const unsigned char icon_transfer [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x01,
0xfe, 0x00, 0x00, 0x3f, 0xe0, 0x07, 0xff, 0x80, 0x00, 0xff, 0xc0, 0x0f, 0xff, 0xc0, 0x01, 0xfb, 0xfe, 0x00, 0x00, 0x3f, 0xe0, 0x07, 0xff, 0x80, 0x00, 0xff, 0xc0, 0x0f, 0xff, 0xc0, 0x01, 0xfb,
0xc0, 0x1f, 0x03, 0xe0, 0x03, 0xe3, 0x80, 0x3c, 0x00, 0xf0, 0x07, 0xc3, 0x80, 0x78, 0x00, 0x78, 0xc0, 0x1f, 0x03, 0xe0, 0x03, 0xe3, 0x80, 0x3c, 0x00, 0xf0, 0x07, 0xc3, 0x80, 0x78, 0x00, 0x78,
0x0f, 0x80, 0x00, 0x70, 0x00, 0x78, 0x0f, 0x00, 0x00, 0x70, 0x00, 0x38, 0x1e, 0x00, 0x00, 0xf0, 0x0f, 0x80, 0x00, 0x70, 0x00, 0x78, 0x0f, 0x00, 0x00, 0x70, 0x00, 0x38, 0x1e, 0x00, 0x00, 0xf0,
0x00, 0x3c, 0x1c, 0x00, 0x00, 0xe0, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x38, 0x00, 0x00, 0x3c, 0x1c, 0x00, 0x00, 0xe0, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x38, 0x00,
0x00, 0xe0, 0x00, 0x3c, 0x38, 0x00, 0x00, 0xf0, 0x00, 0x3c, 0x38, 0x00, 0x00, 0x70, 0x00, 0x38, 0x00, 0xe0, 0x00, 0x3c, 0x38, 0x00, 0x00, 0xf0, 0x00, 0x3c, 0x38, 0x00, 0x00, 0x70, 0x00, 0x38,
0x38, 0x00, 0x00, 0x78, 0x00, 0x78, 0x38, 0x00, 0x00, 0x78, 0x00, 0x78, 0x30, 0x00, 0x00, 0x3c, 0x38, 0x00, 0x00, 0x78, 0x00, 0x78, 0x38, 0x00, 0x00, 0x78, 0x00, 0x78, 0x30, 0x00, 0x00, 0x3c,
0x00, 0xf0, 0x00, 0x00, 0x00, 0x1f, 0x03, 0xe0, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xc0, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x1f, 0x03, 0xe0, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xc0, 0x00, 0x00,
0x00, 0x07, 0xff, 0x80, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0x80, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xfc, 0x00, 0x01, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xfc, 0x00,
0x00, 0x00, 0x1f, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x1e, 0x00, 0x00, 0x18, 0x38, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x1e, 0x00, 0x00, 0x18, 0x38, 0x00,
0x0e, 0x00, 0x00, 0x1c, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x1c, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x3c, 0x0e, 0x00, 0x00, 0x1c, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x1c, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x3c,
0x38, 0x00, 0x0e, 0x00, 0x00, 0x3c, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x38, 0x38, 0x00, 0x0e, 0x00, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x3c, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x38, 0x38, 0x00, 0x0e, 0x00,
0x00, 0x38, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x78, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x70, 0x38, 0x00, 0x00, 0x38, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x78, 0x38, 0x00, 0x0e, 0x00, 0x00, 0x70, 0x38, 0x00,
0x0e, 0x00, 0x00, 0xf0, 0x38, 0x00, 0x0e, 0x00, 0x01, 0xe0, 0x38, 0x00, 0x0e, 0x01, 0x83, 0xe0, 0x0e, 0x00, 0x00, 0xf0, 0x38, 0x00, 0x0e, 0x00, 0x01, 0xe0, 0x38, 0x00, 0x0e, 0x01, 0x83, 0xe0,
0x38, 0x00, 0x0e, 0x03, 0x87, 0xc0, 0x3c, 0x00, 0x1e, 0x03, 0x9f, 0x80, 0x1f, 0x80, 0xfc, 0x07, 0x38, 0x00, 0x0e, 0x03, 0x87, 0xc0, 0x3c, 0x00, 0x1e, 0x03, 0x9f, 0x80, 0x1f, 0x80, 0xfc, 0x07,
0xff, 0x00, 0x1f, 0xff, 0xf8, 0x07, 0xfc, 0x00, 0x07, 0xff, 0xf0, 0x0f, 0xf0, 0x00, 0x01, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xf8, 0x07, 0xfc, 0x00, 0x07, 0xff, 0xf0, 0x0f, 0xf0, 0x00, 0x01, 0xff,
0xc0, 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0xc0, 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
+16
View File
@@ -10,8 +10,10 @@ Lang currentLang = LANG_EN;
static const char EN_DISPLAY_INIT[] = "Display init"; static const char EN_DISPLAY_INIT[] = "Display init";
static const char EN_WIFI_INIT[] = "WiFi init"; static const char EN_WIFI_INIT[] = "WiFi init";
static const char EN_WEBSERVER_INIT[] = "Webserver init"; static const char EN_WEBSERVER_INIT[] = "Webserver init";
static const char EN_API_INIT[] = "API init";
static const char EN_NFC_INIT[] = "NFC init"; static const char EN_NFC_INIT[] = "NFC init";
static const char EN_SEARCHING_SCALE[] = "Searching scale"; static const char EN_SEARCHING_SCALE[] = "Searching scale";
static const char EN_INIT_DONE[] = "Setup finished";
static const char EN_TARE_SCALE[] = "TARE Scale"; static const char EN_TARE_SCALE[] = "TARE Scale";
static const char EN_SCALE_NOT_CAL[] = "Scale not calibrated"; static const char EN_SCALE_NOT_CAL[] = "Scale not calibrated";
@@ -76,14 +78,19 @@ static const char EN_WIFI_RECONN[] = "WiFi reconnecting";
static const char EN_UPDATE[] = "Update"; static const char EN_UPDATE[] = "Update";
static const char EN_DOWNLOAD[] = "Download"; static const char EN_DOWNLOAD[] = "Download";
static const char EN_NOSCALE_MODE[] = "Activate NFC-only mode";
static const char EN_NOSCALE_PROMPT[] = "ready...";
// ===================================================================== // =====================================================================
// German strings // German strings
// ===================================================================== // =====================================================================
static const char DE_DISPLAY_INIT[] = "Display init"; static const char DE_DISPLAY_INIT[] = "Display init";
static const char DE_WIFI_INIT[] = "WiFi init"; static const char DE_WIFI_INIT[] = "WiFi init";
static const char DE_WEBSERVER_INIT[] = "Webserver init"; static const char DE_WEBSERVER_INIT[] = "Webserver init";
static const char DE_API_INIT[] = "API init";
static const char DE_NFC_INIT[] = "NFC init"; static const char DE_NFC_INIT[] = "NFC init";
static const char DE_SEARCHING_SCALE[] = "Suche Waage"; static const char DE_SEARCHING_SCALE[] = "Suche Waage";
static const char DE_INIT_DONE[] = "Setup abgeschlossen";
static const char DE_TARE_SCALE[] = "Waage tarieren"; static const char DE_TARE_SCALE[] = "Waage tarieren";
static const char DE_SCALE_NOT_CAL[] = "Waage nicht kalibriert"; static const char DE_SCALE_NOT_CAL[] = "Waage nicht kalibriert";
@@ -148,6 +155,9 @@ static const char DE_WIFI_RECONN[] = "WiFi Neuverbindung";
static const char DE_UPDATE[] = "Update"; static const char DE_UPDATE[] = "Update";
static const char DE_DOWNLOAD[] = "Download"; static const char DE_DOWNLOAD[] = "Download";
static const char DE_NOSCALE_MODE[] = "Aktiviere NFC-only Modus";
static const char DE_NOSCALE_PROMPT[] = "bereit...";
// ===================================================================== // =====================================================================
// String table: [StringID][Lang] // String table: [StringID][Lang]
// ===================================================================== // =====================================================================
@@ -156,8 +166,10 @@ static const char* const stringTable[STR_COUNT][LANG_COUNT] = {
{ EN_DISPLAY_INIT, DE_DISPLAY_INIT }, { EN_DISPLAY_INIT, DE_DISPLAY_INIT },
{ EN_WIFI_INIT, DE_WIFI_INIT }, { EN_WIFI_INIT, DE_WIFI_INIT },
{ EN_WEBSERVER_INIT, DE_WEBSERVER_INIT }, { EN_WEBSERVER_INIT, DE_WEBSERVER_INIT },
{ EN_API_INIT, DE_API_INIT },
{ EN_NFC_INIT, DE_NFC_INIT }, { EN_NFC_INIT, DE_NFC_INIT },
{ EN_SEARCHING_SCALE, DE_SEARCHING_SCALE }, { EN_SEARCHING_SCALE, DE_SEARCHING_SCALE },
{ EN_INIT_DONE, DE_INIT_DONE },
// Scale // Scale
{ EN_TARE_SCALE, DE_TARE_SCALE }, { EN_TARE_SCALE, DE_TARE_SCALE },
@@ -227,6 +239,10 @@ static const char* const stringTable[STR_COUNT][LANG_COUNT] = {
// OTA // OTA
{ EN_UPDATE, DE_UPDATE }, { EN_UPDATE, DE_UPDATE },
{ EN_DOWNLOAD, DE_DOWNLOAD }, { EN_DOWNLOAD, DE_DOWNLOAD },
// No-Scale mode
{ EN_NOSCALE_MODE, DE_NOSCALE_MODE },
{ EN_NOSCALE_PROMPT, DE_NOSCALE_PROMPT },
}; };
const char* tr(StringID id) { const char* tr(StringID id) {
+6
View File
@@ -16,8 +16,10 @@ enum StringID : uint8_t {
STR_DISPLAY_INIT, STR_DISPLAY_INIT,
STR_WIFI_INIT, STR_WIFI_INIT,
STR_WEBSERVER_INIT, STR_WEBSERVER_INIT,
STR_API_INIT,
STR_NFC_INIT, STR_NFC_INIT,
STR_SEARCHING_SCALE, STR_SEARCHING_SCALE,
STR_INIT_DONE,
// Scale // Scale
STR_TARE_SCALE, STR_TARE_SCALE,
@@ -88,6 +90,10 @@ enum StringID : uint8_t {
STR_UPDATE, STR_UPDATE,
STR_DOWNLOAD, STR_DOWNLOAD,
// No-Scale mode
STR_NOSCALE_MODE,
STR_NOSCALE_PROMPT,
STR_COUNT // must be last STR_COUNT // must be last
}; };
+32 -19
View File
@@ -53,7 +53,7 @@ void setup() {
// Touch Sensor // Touch Sensor
pinMode(TTP223_PIN, INPUT_PULLUP); pinMode(TTP223_PIN, INPUT_PULLUP);
if (digitalRead(TTP223_PIN) == LOW) if (digitalRead(TTP223_PIN) == LOW)
{ {
Serial.println("Touch Sensor is connected"); Serial.println("Touch Sensor is connected");
touchSensorConnected = true; touchSensorConnected = true;
@@ -61,15 +61,24 @@ void setup() {
// Scale // Scale
start_scale(touchSensorConnected); start_scale(touchSensorConnected);
scaleTareRequest = true; if (scaleConnected){
scaleTareRequest = true;
}
// WDT initialisieren mit 10 Sekunden Timeout // WDT initialisieren mit 10 Sekunden Timeout
bool panic = true; // Wenn true, löst ein WDT-Timeout einen System-Panik aus bool panic = true; // Wenn true, löst ein WDT-Timeout einen System-Panik aus
esp_task_wdt_init(10, panic); esp_task_wdt_init(10, panic);
booting = false; booting = false;
oledShowProgressBar(6, NUM_SETUP_STEPS, DISPLAY_BOOT_TEXT, tr(STR_INIT_DONE));
// Aktuellen Task (loopTask) zum Watchdog hinzufügen // Aktuellen Task (loopTask) zum Watchdog hinzufügen
esp_task_wdt_add(NULL); esp_task_wdt_add(NULL);
if ( !scaleConnected ) {
// Clear Display after Boot
oledDisplayText(tr(STR_NOSCALE_PROMPT));
}
} }
@@ -119,11 +128,14 @@ void loop() {
oledShowConnectionError(tr(STR_API_CONN_LOST), WiFi.localIP().toString()); oledShowConnectionError(tr(STR_API_CONN_LOST), WiFi.localIP().toString());
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000); oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
mainTaskWasPaused = true; mainTaskWasPaused = true;
} else if ( !scaleConnected ){
// everything fine again: without scale manual clearing of the error msg is needed
oledDisplayText(tr(STR_NOSCALE_PROMPT));
} }
} }
// Überprüfe den Status des Touch Sensors // Überprüfe den Status des Touch Sensors (nur wenn Waage vorhanden)
if (touchSensorConnected && digitalRead(TTP223_PIN) == HIGH && currentMillis - lastButtonPress > debounceDelay) if (scaleConnected && touchSensorConnected && digitalRead(TTP223_PIN) == HIGH && currentMillis - lastButtonPress > debounceDelay)
{ {
lastButtonPress = currentMillis; lastButtonPress = currentMillis;
scaleTareRequest = true; scaleTareRequest = true;
@@ -131,18 +143,18 @@ void loop() {
} }
// Überprüfe regelmäßig die WLAN-Verbindung // Überprüfe regelmäßig die WLAN-Verbindung
if (intervalElapsed(currentMillis, lastWifiCheckTime, WIFI_CHECK_INTERVAL)) if (intervalElapsed(currentMillis, lastWifiCheckTime, WIFI_CHECK_INTERVAL))
{ {
checkWiFiConnection(); checkWiFiConnection();
} }
// Periodic display update // Periodic display update
if (intervalElapsed(currentMillis, lastTopRowUpdateTime, DISPLAY_UPDATE_INTERVAL)) if (intervalElapsed(currentMillis, lastTopRowUpdateTime, DISPLAY_UPDATE_INTERVAL))
{ {
oledShowTopRow(); oledShowTopRow();
oledCheckSleep(); // Put display to sleep if timeout elapsed oledCheckSleep(); // Put display to sleep if timeout elapsed
} }
// WebSocket Cleanup alle 5 Sekunden (häufiger als vorher) // WebSocket Cleanup alle 5 Sekunden (häufiger als vorher)
// Tote Clients können WiFi-Ressourcen blockieren // Tote Clients können WiFi-Ressourcen blockieren
static unsigned long lastWsCleanup = 0; static unsigned long lastWsCleanup = 0;
@@ -152,21 +164,22 @@ void loop() {
} }
// Periodic FilaMan heartbeat // Periodic FilaMan heartbeat
if (intervalElapsed(currentMillis, lastFilamanHeartbeatTime, FILAMAN_HEARTBEAT_INTERVAL)) if (intervalElapsed(currentMillis, lastFilamanHeartbeatTime, FILAMAN_HEARTBEAT_INTERVAL))
{ {
sendHeartbeatAsync(); sendHeartbeatAsync();
} }
// If scale is not calibrated, only show a warning // If scale is not calibrated, only show a warning
if (!scaleCalibrated) if (scaleConnected && !scaleCalibrated)
{ {
// Do not show the warning if the calibratin process is onging // Do not show the warning if the calibratin process is onging
if(!scaleCalibrationActive){ if(!scaleCalibrationActive){
oledDisplayText(tr(STR_SCALE_NOT_CALIBRATED)); oledDisplayText(tr(STR_SCALE_NOT_CALIBRATED));
vTaskDelay(pdMS_TO_TICKS(1000)); vTaskDelay(pdMS_TO_TICKS(1000));
} }
} }
else
if (scaleConnected && scaleCalibrated)
{ {
// Ausgabe der Waage auf Display // Ausgabe der Waage auf Display
// Block weight display during NFC write operations and higher-priority display messages // Block weight display during NFC write operations and higher-priority display messages
@@ -201,8 +214,8 @@ void loop() {
oledShowProgressBar(2, 4, tr(STR_SPOOL_TAG), tr(STR_WEIGHT_STABLE)); oledShowProgressBar(2, 4, tr(STR_SPOOL_TAG), tr(STR_WEIGHT_STABLE));
oledSetPriority(DISPLAY_PRIORITY_INFO, 1000); oledSetPriority(DISPLAY_PRIORITY_INFO, 1000);
} }
} }
else else
{ {
// Show visual feedback when tag is present and weight is unstable // Show visual feedback when tag is present and weight is unstable
if (weightCounterToApi > 0 && nfcReaderState == NFC_READ_SUCCESS && !tagProcessed && weightSend == 0) { if (weightCounterToApi > 0 && nfcReaderState == NFC_READ_SUCCESS && !tagProcessed && weightSend == 0) {
@@ -216,10 +229,10 @@ void loop() {
lastWeight = weight; lastWeight = weight;
// Wenn ein Tag erkannt wurde und das Gewicht stabil ist (4+ seconds), an FilaMan senden // Wenn ein Tag erkannt wurde und das Gewicht stabil ist (4+ seconds), an FilaMan senden
if (weightCounterToApi > 3 && weightSend == 0 && nfcReaderState == NFC_READ_SUCCESS && tagProcessed == false) if (weightCounterToApi > 3 && weightSend == 0 && nfcReaderState == NFC_READ_SUCCESS && tagProcessed == false)
{ {
tagProcessed = true; tagProcessed = true;
// Check if it's a Bambu tag - if so, send only UUID without spoolId // Check if it's a Bambu tag - if so, send only UUID without spoolId
if (isBambuTag) { if (isBambuTag) {
sendWeightAsync(0, activeTagUuid, weight); sendWeightAsync(0, activeTagUuid, weight);
@@ -231,24 +244,24 @@ void loop() {
Serial.println("Weight queued for FilaMan"); Serial.println("Weight queued for FilaMan");
} }
weightSend = 1; weightSend = 1;
// Feedback to user // Feedback to user
oledShowProgressBar(3, 4, tr(STR_SPOOL_TAG), tr(STR_SENDING)); oledShowProgressBar(3, 4, tr(STR_SPOOL_TAG), tr(STR_SENDING));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000); oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
} }
// Handle successful tag write // Handle successful tag write
if (nfcReaderState == NFC_WRITE_SUCCESS && tagProcessed == false) if (nfcReaderState == NFC_WRITE_SUCCESS && tagProcessed == false)
{ {
tagProcessed = true; tagProcessed = true;
// Only send weight if a valid spoolId exists (spool tag, not location tag) // Only send weight if a valid spoolId exists (spool tag, not location tag)
if (activeSpoolId.length() > 0 && activeSpoolId != "0") { if (activeSpoolId.length() > 0 && activeSpoolId != "0") {
int sId = activeSpoolId.toInt(); int sId = activeSpoolId.toInt();
sendWeightAsync(sId, activeTagUuid, weight); sendWeightAsync(sId, activeTagUuid, weight);
weightSend = 1; weightSend = 1;
Serial.println("Weight queued for FilaMan after spool tag write"); Serial.println("Weight queued for FilaMan after spool tag write");
// Feedback to user // Feedback to user
oledShowProgressBar(3, 4, tr(STR_TAG_WRITTEN), tr(STR_SENDING)); oledShowProgressBar(3, 4, tr(STR_TAG_WRITTEN), tr(STR_SENDING));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000); oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
+267 -267
View File
File diff suppressed because it is too large. Load diff
+172 -61
View File
@@ -35,10 +35,22 @@ uint8_t scale_tare_counter = 0;
bool scaleTareRequest = false; bool scaleTareRequest = false;
uint8_t pauseMainTask = 0; uint8_t pauseMainTask = 0;
bool scaleCalibrated; bool scaleCalibrated;
bool scaleConnected;
bool autoTare = true; bool autoTare = true;
bool scaleCalibrationActive = false; bool scaleCalibrationActive = false;
volatile bool scaleCalibrationRequest = false; volatile bool scaleCalibrationRequest = false;
/**
* Non blocking wait function
*/
void friendlyWait(uint16_t ticks) {
for (uint16_t i = 0; i < ticks; i++) {
yield();
vTaskDelay(pdMS_TO_TICKS(1));
esp_task_wdt_reset();
}
}
// ##### Weight stabilization functions ##### // ##### Weight stabilization functions #####
/** /**
@@ -50,7 +62,7 @@ void resetWeightFilter() {
filteredWeight = 0.0f; filteredWeight = 0.0f;
lastDisplayedWeight = 0; lastDisplayedWeight = 0;
lastStableWeight = 0; // Reset stable weight for API actions lastStableWeight = 0; // Reset stable weight for API actions
// Initialize buffer with zeros // Initialize buffer with zeros
for (int i = 0; i < MOVING_AVERAGE_SIZE; i++) { for (int i = 0; i < MOVING_AVERAGE_SIZE; i++) {
weightBuffer[i] = 0.0f; weightBuffer[i] = 0.0f;
@@ -63,11 +75,11 @@ void resetWeightFilter() {
float calculateMovingAverage() { float calculateMovingAverage() {
float sum = 0.0f; float sum = 0.0f;
int count = bufferFilled ? MOVING_AVERAGE_SIZE : bufferIndex; int count = bufferFilled ? MOVING_AVERAGE_SIZE : bufferIndex;
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
sum += weightBuffer[i]; sum += weightBuffer[i];
} }
return (count > 0) ? sum / count : 0.0f; return (count > 0) ? sum / count : 0.0f;
} }
@@ -88,33 +100,33 @@ int16_t processWeightReading(float rawWeight) {
// Add to moving average buffer // Add to moving average buffer
weightBuffer[bufferIndex] = rawWeight; weightBuffer[bufferIndex] = rawWeight;
bufferIndex = (bufferIndex + 1) % MOVING_AVERAGE_SIZE; bufferIndex = (bufferIndex + 1) % MOVING_AVERAGE_SIZE;
if (bufferIndex == 0) { if (bufferIndex == 0) {
bufferFilled = true; bufferFilled = true;
} }
// Calculate moving average // Calculate moving average
float avgWeight = calculateMovingAverage(); float avgWeight = calculateMovingAverage();
// Apply low-pass filter // Apply low-pass filter
float smoothedWeight = applyLowPassFilter(avgWeight); float smoothedWeight = applyLowPassFilter(avgWeight);
// Round to nearest gram // Round to nearest gram
int16_t newWeight = round(smoothedWeight); int16_t newWeight = round(smoothedWeight);
// Update displayed weight if display threshold is reached // Update displayed weight if display threshold is reached
if (abs(newWeight - lastDisplayedWeight) >= DISPLAY_THRESHOLD) { if (abs(newWeight - lastDisplayedWeight) >= DISPLAY_THRESHOLD) {
lastDisplayedWeight = newWeight; lastDisplayedWeight = newWeight;
} }
// Update global weight for API actions only if stable threshold is reached // Update global weight for API actions only if stable threshold is reached
int16_t weightToReturn = weight; // Default: keep current weight int16_t weightToReturn = weight; // Default: keep current weight
if (abs(newWeight - lastStableWeight) >= API_THRESHOLD) { if (abs(newWeight - lastStableWeight) >= API_THRESHOLD) {
lastStableWeight = newWeight; lastStableWeight = newWeight;
weightToReturn = newWeight; weightToReturn = newWeight;
} }
return weightToReturn; return weightToReturn;
} }
@@ -145,7 +157,7 @@ uint8_t tareScale() {
Serial.println("Tare scale"); Serial.println("Tare scale");
scale.tare(); scale.tare();
resetWeightFilter(); resetWeightFilter();
return 1; return 1;
} }
@@ -161,13 +173,13 @@ void scale_loop(void * parameter) {
for(;;) { for(;;) {
unsigned long currentTime = millis(); unsigned long currentTime = millis();
// Only measure at defined intervals to reduce noise // Only measure at defined intervals to reduce noise
if (currentTime - lastMeasurementTime >= MEASUREMENT_INTERVAL_MS) { if (currentTime - lastMeasurementTime >= MEASUREMENT_INTERVAL_MS) {
if (scale.is_ready()) if (scale.is_ready())
{ {
// Waage manuell Taren // Waage manuell Taren
if (scaleTareRequest == true || (autoTare && scale_tare_counter >= 20)) if (scaleTareRequest == true || (autoTare && scale_tare_counter >= 20))
{ {
Serial.println("Re-Tare scale"); Serial.println("Re-Tare scale");
oledDisplayText(tr(STR_TARE_SCALE)); oledDisplayText(tr(STR_TARE_SCALE));
@@ -189,16 +201,16 @@ void scale_loop(void * parameter) {
// Get raw weight reading // Get raw weight reading
float rawWeight = scale.get_units(); float rawWeight = scale.get_units();
// Process weight with stabilization // Process weight with stabilization
int16_t stabilizedWeight = processWeightReading(rawWeight); int16_t stabilizedWeight = processWeightReading(rawWeight);
// Update global weight variable only if it changed significantly (for API actions) // Update global weight variable only if it changed significantly (for API actions)
if (stabilizedWeight != weight) { if (stabilizedWeight != weight) {
weight = stabilizedWeight; weight = stabilizedWeight;
oledResetActivityTimer(); // Wake display on weight change oledResetActivityTimer(); // Wake display on weight change
} }
// Prüfen ob die Waage korrekt genullt ist // Prüfen ob die Waage korrekt genullt ist
// Abweichung von 2g ignorieren // Abweichung von 2g ignorieren
if (autoTare && (rawWeight > 2 && rawWeight < 7) || rawWeight < -2) if (autoTare && (rawWeight > 2 && rawWeight < 7) || rawWeight < -2)
@@ -215,15 +227,111 @@ void scale_loop(void * parameter) {
if (currentTime - lastDebugTime > 2000) { // Print every 2 seconds if (currentTime - lastDebugTime > 2000) { // Print every 2 seconds
lastDebugTime = currentTime; lastDebugTime = currentTime;
} }
lastMeasurementTime = currentTime; lastMeasurementTime = currentTime;
} }
} }
vTaskDelay(pdMS_TO_TICKS(10)); // Shorter delay for more responsive loop vTaskDelay(pdMS_TO_TICKS(10)); // Shorter delay for more responsive loop
} }
} }
long readHX711Raw() {
long value = 0;
for (int i = 0; i < 24; i++) {
digitalWrite(LOADCELL_SCK_PIN, HIGH);
delayMicroseconds(1);
value = (value << 1) | digitalRead(LOADCELL_DOUT_PIN);
digitalWrite(LOADCELL_SCK_PIN, LOW);
delayMicroseconds(1);
}
// Gain = 128 (1 extra pulse)
digitalWrite(LOADCELL_SCK_PIN, HIGH);
delayMicroseconds(1);
digitalWrite(LOADCELL_SCK_PIN, LOW);
return value;
}
bool deepSearchScale() {
// without pull-up resistor (10k) on LOADCELL_DOUT_PIN the hx711 lib functions
// are not reliable in detecting a missing chip
// these tests work even without pull-up resistor
const uint32_t timeout = 1000;
const int samples = 10;
pinMode(LOADCELL_DOUT_PIN, INPUT);
pinMode(LOADCELL_SCK_PIN, OUTPUT);
digitalWrite(LOADCELL_SCK_PIN, LOW);
//delay(500);
friendlyWait(500);
// 1. HX711 vorhanden?
uint32_t start = millis();
while (digitalRead(LOADCELL_DOUT_PIN) == HIGH) {
if (millis() - start > timeout) {
Serial.println("HX711 not found (DOUT stays HIGH).");
return false;
}
}
Serial.println("HX711 seems to answer...");
// 2. Mehrere Werte lesen
long values[samples];
for (int i = 0; i < samples; i++) {
// warten bis bereit
uint32_t t = millis();
while (digitalRead(LOADCELL_DOUT_PIN) == HIGH) {
if (millis() - t > timeout) {
Serial.println("HX711 not found (Timeout during read).");
return false;
}
}
values[i] = readHX711Raw();
delay(50);
}
// 3. Analyse
int invalidCount = 0;
for (int i = 0; i < samples; i++) {
if (values[i] == 0 || values[i] == 0xFFFFFF) {
invalidCount++;
}
}
// 4. Entscheidungen
// Kein Sensor
if (invalidCount > samples / 2) {
Serial.println("HX711 not ready (Loadcell missing).");
return false;
}
Serial.println("HX711 found.");
return true;
}
bool scaleDetected(){
// Step 1: use hx711 library functions (need pull-up resistor to recognize missing hx711)
if ( !(scale.wait_ready_timeout(1000))) {
Serial.println("HX711 not found (pull-up resistor installed).");
return false;
}
//Step 2: when pull-up resistor is missing, then deep search...
return deepSearchScale();
}
void start_scale(bool touchSensorConnected) { void start_scale(bool touchSensorConnected) {
Serial.println("Prüfe Calibration Value"); Serial.println("Prüfe Calibration Value");
float calibrationValue; float calibrationValue;
@@ -238,7 +346,7 @@ void start_scale(bool touchSensorConnected) {
calibrationValue = SCALE_DEFAULT_CALIBRATION_VALUE; calibrationValue = SCALE_DEFAULT_CALIBRATION_VALUE;
scaleCalibrated = false; scaleCalibrated = false;
} }
// auto Tare // auto Tare
// Wenn Touch Sensor verbunden, dann autoTare auf false setzen // Wenn Touch Sensor verbunden, dann autoTare auf false setzen
// Danach prüfen was in NVS gespeichert ist // Danach prüfen was in NVS gespeichert ist
@@ -252,40 +360,43 @@ void start_scale(bool touchSensorConnected) {
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN); scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
oledShowProgressBar(6, 7, DISPLAY_BOOT_TEXT, tr(STR_SEARCHING_SCALE)); oledShowProgressBar(5, NUM_SETUP_STEPS, DISPLAY_BOOT_TEXT, tr(STR_SEARCHING_SCALE));
for (uint16_t i = 0; i < 3000; i++) { friendlyWait(3000);
yield();
vTaskDelay(pdMS_TO_TICKS(1)); scaleConnected = scaleDetected();
esp_task_wdt_reset(); if ( scaleConnected ) {
scale.set_scale(calibrationValue);
//vTaskDelay(pdMS_TO_TICKS(5000));
// Initialize weight stabilization filter
resetWeightFilter();
// Display Gewicht
oledShowWeight(0);
Serial.println("starte Scale Task");
BaseType_t result = xTaskCreatePinnedToCore(
scale_loop, /* Function to implement the task */
"ScaleLoop", /* Name of the task */
2048, /* Stack size in words */
NULL, /* Task input parameter */
scaleTaskPrio, /* Priority of the task */
&ScaleTask, /* Task handle. */
scaleTaskCore); /* Core where the task should run */
if (result != pdPASS) {
Serial.println("Fehler beim Erstellen des ScaleLoop-Tasks");
} else {
Serial.println("ScaleLoop-Task erfolgreich erstellt");
}
} }
else {
while(!scale.is_ready()) { // No HX711 - switching to NFC-only mode
vTaskDelay(pdMS_TO_TICKS(5000)); Serial.println("Kann kein HX711 Board finden !"); // Sende Text "Kann kein..." an seriellen Monitor
} oledDisplayText(tr(STR_HX711_NOT_FOUND));
vTaskDelay(pdMS_TO_TICKS(1500));
scale.set_scale(calibrationValue); oledDisplayText(tr(STR_NOSCALE_MODE));
//vTaskDelay(pdMS_TO_TICKS(5000)); vTaskDelay(pdMS_TO_TICKS(1500));
// Initialize weight stabilization filter
resetWeightFilter();
// Display Gewicht
oledShowWeight(0);
Serial.println("starte Scale Task");
BaseType_t result = xTaskCreatePinnedToCore(
scale_loop, /* Function to implement the task */
"ScaleLoop", /* Name of the task */
2048, /* Stack size in words */
NULL, /* Task input parameter */
scaleTaskPrio, /* Priority of the task */
&ScaleTask, /* Task handle. */
scaleTaskCore); /* Core where the task should run */
if (result != pdPASS) {
Serial.println("Fehler beim Erstellen des ScaleLoop-Tasks");
} else {
Serial.println("ScaleLoop-Task erfolgreich erstellt");
} }
} }
@@ -300,10 +411,10 @@ uint8_t calibrate_scale() {
if (ScaleTask != NULL && xTaskGetCurrentTaskHandle() != ScaleTask) vTaskSuspend(ScaleTask); if (ScaleTask != NULL && xTaskGetCurrentTaskHandle() != ScaleTask) vTaskSuspend(ScaleTask);
pauseMainTask = 1; pauseMainTask = 1;
if (scale.wait_ready_timeout(1000)) if (scale.wait_ready_timeout(1000))
{ {
scale.set_scale(); scale.set_scale();
oledShowProgressBar(0, 3, tr(STR_SCALE_CAL), tr(STR_EMPTY_SCALE)); oledShowProgressBar(0, 3, tr(STR_SCALE_CAL), tr(STR_EMPTY_SCALE));
@@ -324,7 +435,7 @@ uint8_t calibrate_scale() {
vTaskDelay(pdMS_TO_TICKS(1)); vTaskDelay(pdMS_TO_TICKS(1));
esp_task_wdt_reset(); esp_task_wdt_reset();
} }
float newCalibrationValue = scale.get_units(10); float newCalibrationValue = scale.get_units(10);
Serial.print("Result: "); Serial.print("Result: ");
Serial.println(newCalibrationValue); Serial.println(newCalibrationValue);
@@ -359,7 +470,7 @@ uint8_t calibrate_scale() {
vTaskDelay(pdMS_TO_TICKS(1)); vTaskDelay(pdMS_TO_TICKS(1));
esp_task_wdt_reset(); esp_task_wdt_reset();
} }
oledShowProgressBar(3, 3, tr(STR_SCALE_CAL), tr(STR_COMPLETED)); oledShowProgressBar(3, 3, tr(STR_SCALE_CAL), tr(STR_COMPLETED));
// For some reason it is not possible to re-tare the scale here, it will result in a wdt timeout. Instead let the scale loop do the taring // For some reason it is not possible to re-tare the scale here, it will result in a wdt timeout. Instead let the scale loop do the taring
@@ -387,12 +498,12 @@ uint8_t calibrate_scale() {
esp_task_wdt_reset(); esp_task_wdt_reset();
} }
returnState = 0; returnState = 0;
} }
} }
else else
{ {
Serial.println("HX711 not found."); Serial.println("HX711 not found.");
oledDisplayText(tr(STR_HX711_NOT_FOUND)); oledDisplayText(tr(STR_HX711_NOT_FOUND));
for (uint16_t i = 0; i < 30000; i++) { for (uint16_t i = 0; i < 30000; i++) {
+1
View File
@@ -23,6 +23,7 @@ extern uint8_t scale_tare_counter;
extern bool scaleTareRequest; extern bool scaleTareRequest;
extern uint8_t pauseMainTask; extern uint8_t pauseMainTask;
extern bool scaleCalibrated; extern bool scaleCalibrated;
extern bool scaleConnected;
extern bool autoTare; extern bool autoTare;
extern bool scaleCalibrationActive; extern bool scaleCalibrationActive;
extern volatile bool scaleCalibrationRequest; extern volatile bool scaleCalibrationRequest;
+5 -5
View File
@@ -124,8 +124,8 @@ void sendNfcData() {
} }
void setupWebserver(AsyncWebServer &server) { void setupWebserver(AsyncWebServer &server) {
oledShowProgressBar(2, 7, DISPLAY_BOOT_TEXT, tr(STR_WEBSERVER_INIT)); oledShowProgressBar(2, NUM_SETUP_STEPS, DISPLAY_BOOT_TEXT, tr(STR_WEBSERVER_INIT));
ws.onEvent(onWsEvent); ws.onEvent(onWsEvent);
server.addHandler(&ws); server.addHandler(&ws);
@@ -138,7 +138,7 @@ void setupWebserver(AsyncWebServer &server) {
.setCacheControl(CACHE_ASSETS); .setCacheControl(CACHE_ASSETS);
server.serveStatic("/favicon.ico", LittleFS, "/favicon.ico") server.serveStatic("/favicon.ico", LittleFS, "/favicon.ico")
.setCacheControl(CACHE_ASSETS); .setCacheControl(CACHE_ASSETS);
// ===== STATISCHE HTML-SEITEN (ohne Template-Ersetzung) ===== // ===== STATISCHE HTML-SEITEN (ohne Template-Ersetzung) =====
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){ server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
Serial.println("Web: Request /"); Serial.println("Web: Request /");
@@ -214,7 +214,7 @@ void setupWebserver(AsyncWebServer &server) {
String payloadString; String payloadString;
serializeJson(doc, payloadString); serializeJson(doc, payloadString);
bool hasSpoolId = !doc["spool_id"].isNull() || !doc["sm_id"].isNull(); bool hasSpoolId = !doc["spool_id"].isNull() || !doc["sm_id"].isNull();
int spoolId = doc["spool_id"] | 0; int spoolId = doc["spool_id"] | 0;
if (spoolId == 0 && doc["sm_id"].is<String>()) { if (spoolId == 0 && doc["sm_id"].is<String>()) {
@@ -223,7 +223,7 @@ void setupWebserver(AsyncWebServer &server) {
int locationId = doc["location_id"] | 0; int locationId = doc["location_id"] | 0;
startWriteJsonToTag(hasSpoolId, payloadString.c_str(), spoolId, locationId); startWriteJsonToTag(hasSpoolId, payloadString.c_str(), spoolId, locationId);
// Respond immediately // Respond immediately
request->send(200, "application/json", "{\"success\": true, \"message\": \"Schreibvorgang wurde gestartet. Bitte Tag bereit halten...\"}"); request->send(200, "application/json", "{\"success\": true, \"message\": \"Schreibvorgang wurde gestartet. Bitte Tag bereit halten...\"}");
}); });
+14 -14
View File
@@ -14,17 +14,17 @@ uint8_t wifiErrorCounter = 0;
void wifiSettings() { void wifiSettings() {
// Standard WiFi-Einstellungen für höchste Stabilität mit ESPAsyncWebServer // Standard WiFi-Einstellungen für höchste Stabilität mit ESPAsyncWebServer
WiFi.mode(WIFI_STA); WiFi.mode(WIFI_STA);
WiFi.setHostname("FilaMan"); WiFi.setHostname("FilaMan");
// KRITISCH: Power-Save deaktivieren für stabilen Webserver-Betrieb // KRITISCH: Power-Save deaktivieren für stabilen Webserver-Betrieb
// Ohne dies geht WiFi in Modem-Sleep und verpasst Requests/Responses // Ohne dies geht WiFi in Modem-Sleep und verpasst Requests/Responses
// Dies ist die Hauptursache für Verbindungsabbrüche bei regelmäßigen API-Calls // Dies ist die Hauptursache für Verbindungsabbrüche bei regelmäßigen API-Calls
esp_wifi_set_ps(WIFI_PS_NONE); esp_wifi_set_ps(WIFI_PS_NONE);
// Angemessene Sendeleistung (reduziert Hitzeprobleme) // Angemessene Sendeleistung (reduziert Hitzeprobleme)
WiFi.setTxPower(WIFI_POWER_17dBm); WiFi.setTxPower(WIFI_POWER_17dBm);
// Aktiviere WiFi-Roaming für bessere Stabilität bei schwachem Signal // Aktiviere WiFi-Roaming für bessere Stabilität bei schwachem Signal
esp_wifi_set_rssi_threshold(-80); esp_wifi_set_rssi_threshold(-80);
} }
@@ -51,19 +51,19 @@ void initWiFi() {
wm.setWiFiAutoReconnect(true); wm.setWiFiAutoReconnect(true);
wm.setConnectTimeout(10); wm.setConnectTimeout(10);
oledShowProgressBar(1, 7, DISPLAY_BOOT_TEXT, tr(STR_WIFI_INIT)); oledShowProgressBar(1, NUM_SETUP_STEPS, DISPLAY_BOOT_TEXT, tr(STR_WIFI_INIT));
//bool res = wm.autoConnect("FilaMan"); // anonymous ap //bool res = wm.autoConnect("FilaMan"); // anonymous ap
if(!wm.autoConnect("FilaMan")) { if(!wm.autoConnect("FilaMan")) {
Serial.println("Failed to connect or hit timeout"); Serial.println("Failed to connect or hit timeout");
// ESP.restart(); // ESP.restart();
oledShowTopRow(); oledShowTopRow();
oledDisplayText(tr(STR_WIFI_NOT_CONNECTED)); oledDisplayText(tr(STR_WIFI_NOT_CONNECTED));
} }
else { else {
wifiOn = true; wifiOn = true;
//if you get here you have connected to the WiFi //if you get here you have connected to the WiFi
Serial.println("connected...yeey :)"); Serial.println("connected...yeey :)");
Serial.print("IP address: "); Serial.print("IP address: ");
Serial.println(WiFi.localIP()); Serial.println(WiFi.localIP());
@@ -73,23 +73,23 @@ void initWiFi() {
} }
void checkWiFiConnection() { void checkWiFiConnection() {
if (WiFi.status() != WL_CONNECTED) if (WiFi.status() != WL_CONNECTED)
{ {
if (wifiOn) { if (wifiOn) {
Serial.println("WiFi connection lost. Attempting active reconnect..."); Serial.println("WiFi connection lost. Attempting active reconnect...");
wifiOn = false; wifiOn = false;
oledShowTopRow(); oledShowTopRow();
oledDisplayText(tr(STR_WIFI_RECONNECTING)); oledDisplayText(tr(STR_WIFI_RECONNECTING));
// Aktiver Reconnect-Versuch statt nur auf LwIP auto-reconnect zu warten // Aktiver Reconnect-Versuch statt nur auf LwIP auto-reconnect zu warten
WiFi.reconnect(); WiFi.reconnect();
} }
wifiErrorCounter++; wifiErrorCounter++;
// Only restart after a significant time of no connection (e.g. 5 minutes) // Only restart after a significant time of no connection (e.g. 5 minutes)
// Assuming WIFI_CHECK_INTERVAL is 60000ms (1 minute), 5 errors = 5 minutes // Assuming WIFI_CHECK_INTERVAL is 60000ms (1 minute), 5 errors = 5 minutes
if (wifiErrorCounter >= 5) if (wifiErrorCounter >= 5)
{ {
Serial.println("WiFi unable to reconnect for 5 minutes. Restarting..."); Serial.println("WiFi unable to reconnect for 5 minutes. Restarting...");
ESP.restart(); ESP.restart();
@@ -102,7 +102,7 @@ void checkWiFiConnection() {
wifiErrorCounter = 0; wifiErrorCounter = 0;
wifiOn = true; wifiOn = true;
oledShowTopRow(); oledShowTopRow();
// Power-Save erneut deaktivieren nach Reconnect (wird manchmal zurückgesetzt) // Power-Save erneut deaktivieren nach Reconnect (wird manchmal zurückgesetzt)
esp_wifi_set_ps(WIFI_PS_NONE); esp_wifi_set_ps(WIFI_PS_NONE);
} else { } else {
@@ -110,4 +110,4 @@ void checkWiFiConnection() {
wifiErrorCounter = 0; wifiErrorCounter = 0;
} }
} }
} }