Compare commits

...
23 Commits
Author SHA1 Message Date
Manuel Weiser 60af915c9f docs: update platformio.ini for version v3.2.5 2026-03-09 19:25:41 +01:00
Manuel Weiser 4d318bf4ec fix: change weight parameter type to int16_t in oledShowWeight function 2026-03-09 19:25:01 +01:00
Manuel Weiser 9311162463 Add multilingual support with language selection and translation strings
- Introduced language management with English and German translations.
- Added language settings to NVS for persistent storage.
- Updated display functions to use translated strings for various messages.
- Implemented API endpoints for language retrieval and setting.
- Refactored existing text strings in the codebase to utilize the new translation system.
2026-03-09 19:18:59 +01:00
Manuel Weiser 067807d1a6 docs: update platformio.ini for version v3.2.4 2026-03-09 17:08:28 +01:00
Manuel Weiser 04bf05cb05 Merge branch 'devel' 2026-03-09 17:06:41 +01:00
Manuel Weiser 045e450744 feat: add feedback display and clear lastSpoolId after setting location 2026-03-09 17:06:06 +01:00
Manuel Weiser 7b03b359ba feat: enhance tag detection with countdown display during write operation 2026-03-09 16:51:46 +01:00
Manuel Weiser a5d9902149 fix: update registration success message and change reboot to page reload 2026-03-09 16:25:44 +01:00
Manuel Weiser 1c19413970 feat: add documentation rules and project paths; implement display priority management in code 2026-03-09 16:18:41 +01:00
Manuel Weiser 35e0167398 docs: update platformio.ini for beta version v3.2.3-beta1 2026-03-09 08:14:42 +01:00
Manuel Weiser 89f176b188 docs: update platformio.ini for version v3.2.3 2026-03-09 07:42:15 +01:00
Manuel Weiser b78f34c1d3 feat: enhance deployment process with SSH support for Gitea and remove FTP integration from GitHub release 2026-03-09 07:41:47 +01:00
Manuel Weiser f9d8fc7a61 docs: update platformio.ini for version v3.2.2 2026-03-08 20:18:35 +01:00
Manuel Weiser c77b9c8503 Merge branch 'devel' 2026-03-08 20:17:58 +01:00
Manuel Weiser 1096585b56 fix: ensure UID strings are zero-padded for consistent formatting in Bambu tag detection 2026-03-08 20:17:23 +01:00
Manuel Weiser 17ba353f17 docs: update platformio.ini for version v3.2.1 2026-02-21 20:41:05 +01:00
Manuel Weiser 01e36bd39e Merge branch 'devel' 2026-02-21 20:34:41 +01:00
Manuel Weiser 01b8ced7e9 fix: reduce delay times for API tasks and NFC scanning to improve responsiveness 2026-02-21 20:33:43 +01:00
Manuel Weiser 5f9ad13ea9 feat: enhance RFID handling for Bambu tags and update API interactions 2026-02-21 20:04:05 +01:00
Manuel Weiser 29e8b09c5a fix: ensure weight is only sent for valid spool tags in loop 2026-02-21 16:55:40 +01:00
Manuel Weiser 2593d048c2 Merge branch 'devel' 2026-02-21 12:29:43 +01:00
Manuel Weiser d916d06127 fix: update version and old version in platformio.ini 2026-02-21 12:28:17 +01:00
Manuel Weiser 0a4b3f1e1b fix: improve connection error handling and display logic in main loop 2026-02-21 12:25:41 +01:00
26 changed files with 1010 additions and 237 deletions

No files matched your search

+40
View File
@@ -6,6 +6,18 @@ on:
GITEA_TOKEN:
description: 'Token für Gitea API-Zugriff'
required: true
FILAMAN_SSH_PRIVATE_KEY:
description: 'SSH Private Key für Deployment'
required: true
FILAMAN_SSH_HOST:
description: 'SSH Host für Deployment'
required: true
FILAMAN_SSH_USER:
description: 'SSH User für Deployment'
required: true
FILAMAN_SSH_FIRMWARE_PATH:
description: 'SSH Pfad für Firmware Upload'
required: true
outputs:
version:
@@ -212,3 +224,31 @@ jobs:
fi
fi
done
- name: SSH-Deploy Firmware
if: success()
env:
SSH_PRIVATE_KEY: ${{ secrets.FILAMAN_SSH_PRIVATE_KEY }}
SSH_HOST: ${{ secrets.FILAMAN_SSH_HOST }}
SSH_USER: ${{ secrets.FILAMAN_SSH_USER }}
SSH_PATH: ${{ secrets.FILAMAN_SSH_FIRMWARE_PATH }}
VERSION: ${{ steps.get_version.outputs.VERSION }}
run: |
set -euo pipefail
# SSH-Key einrichten
mkdir -p ~/.ssh
echo "$SSH_PRIVATE_KEY" > ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_rsa
ssh-keyscan -H "$SSH_HOST" >> ~/.ssh/known_hosts 2>/dev/null
cd .pio/build/esp32dev
# Full-Binary per SCP hochladen
echo "📤 Upload filaman_full_${VERSION}.bin per SCP ..."
scp -o StrictHostKeyChecking=no "filaman_full_${VERSION}.bin" "${SSH_USER}@${SSH_HOST}:${SSH_PATH}/filaman_full.bin"
echo "✅ filaman_full.bin auf ${SSH_HOST}:${SSH_PATH}/ hochgeladen."
# Aufräumen
rm -f ~/.ssh/id_rsa
-35
View File
@@ -6,15 +6,6 @@ on:
RELEASE_TOKEN:
description: 'GitHub token for release creation'
required: true
FTP_PASSWORD:
description: 'FTP Password'
required: false
FTP_USER:
description: 'FTP User'
required: false
FTP_HOST:
description: 'FTP Host'
required: false
permissions:
contents: write
@@ -160,29 +151,3 @@ jobs:
echo "Error: No files found to upload"
exit 1
fi
- name: Install lftp
run: sudo apt-get install -y lftp
- name: Upload Firmware via FTP
if: success()
env:
FTP_PASSWORD: ${{ secrets.FTP_PASSWORD }}
FTP_USER: ${{ secrets.FTP_USER }}
FTP_HOST: ${{ secrets.FTP_HOST }}
VERSION: ${{ steps.get_version.outputs.VERSION }}
run: |
cd .pio/build/esp32dev
if [ -n "$FTP_USER" ] && [ -n "$FTP_PASSWORD" ] && [ -n "$FTP_HOST" ]; then
echo "All FTP credentials are present, attempting upload..."
lftp -c "set ssl:verify-certificate no; \
set ftp:ssl-protect-data true; \
set ftp:ssl-force true; \
set ssl:check-hostname false; \
set ftp:ssl-auth TLS; \
open -u $FTP_USER,$FTP_PASSWORD $FTP_HOST; \
put -O / filaman_full_${VERSION}.bin -o filaman_full.bin"
else
echo "Error: Some FTP credentials are missing"
exit 1
fi
+5 -4
View File
@@ -32,13 +32,14 @@ jobs:
uses: ./.github/workflows/github-release.yml
secrets:
RELEASE_TOKEN: ${{ secrets.GITHUB_TOKEN }}
FTP_PASSWORD: ${{ secrets.FTP_PASSWORD }}
FTP_USER: ${{ secrets.FTP_USER }}
FTP_HOST: ${{ secrets.FTP_HOST }}
gitea-release:
needs: detect-provider
if: needs.detect-provider.outputs.provider == 'gitea'
uses: ./.github/workflows/gitea-release.yml
secrets:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
FILAMAN_SSH_PRIVATE_KEY: ${{ secrets.FILAMAN_SSH_PRIVATE_KEY }}
FILAMAN_SSH_HOST: ${{ secrets.FILAMAN_SSH_HOST }}
FILAMAN_SSH_USER: ${{ secrets.FILAMAN_SSH_USER }}
FILAMAN_SSH_FIRMWARE_PATH: ${{ secrets.FILAMAN_SSH_FIRMWARE_PATH }}
+1 -2
View File
@@ -27,8 +27,7 @@ test/README
# important
html/bambu_credentials.json
html/spoolman_url.json
_local/*
website/*
release.sh
wiki
_layout
_*
@@ -0,0 +1,9 @@
# Dokumentations-Regeln für Code-Projekte
## Handbuch und Dokumentation
Achte bitte darauf, dass du mit der aktualisierung von openmemory auch die Dokumentation und Endanwender-Handbuch
mit aktualisierst, wenn es neue Funktionen für Nutzer gibt.
- path for documentation and user manual: ~/dev/FilaMan/FilaMan-System-docu/
## Readme
Halte bitte außerdem auch die Readme Files im Repo aktuell.
+5
View File
@@ -0,0 +1,5 @@
# Nutzung von MCP Servern
### Nutze bitte möglichst immer die bereitgestellten MCP Server.
- Um die Codebasis zu erforschen, nutze jcodemunch-mcp
- Für Coding an sich, nutze context7
@@ -0,0 +1,44 @@
**# OpenMemory Rules for Code Projects**
- Use the OpenMemory/Memory tools whenever possible to store and retrieve important project knowledge.
- search openmemory before you inspect folders and files
- Goal: decisions, code changes, and bug fixes should be saved in a way that they can be reused in new sessions.
**## When Something Should Be Stored**
- **After every major code change**
- Create a brief memory note with:
- Affected files/modules
- What was changed?
- Why was it changed? (goal / requirements)
- Potential risks or TODOs
- **For every decision** (API design, architecture, important trade‑offs)
- Create a memory note of type “Decision” with:
- Context / problem
- Considered options
- Chosen option
- Justification
- **For every bug fix**
- Create a memory note of type “Bugfix” with:
- Symptom / error picture (e.g., error message)
- Cause
- Fix (which files/lines)
- What to note for the future
**## How Memories Should Be Structured**
- Use consistent project tags, e.g., `project:my-project`.
- Use type tags like `type:decision`, `type:change`, `type:bugfix`.
- If possible, link commits or exact file paths / line numbers in the note.
**## Usage in New Sessions or Tasks**
- At the start of a new session or task:
- Load the most important OpenMemory entries for the current project (e.g., last decisions, relevant bug fixes).
- Create a short overview for yourself before new suggestions are made.
- If a new error occurs:
- First check OpenMemory for previous similar errors, relevant changes or decisions before re‑analyzing the code or making a new decision.
**# Git Rules**
- **NEVER** push independently to a git repository/branch!
+14
View File
@@ -0,0 +1,14 @@
# rules for the FilaMan project
## path
- path for project: ~/dev/FilaMan/FilaMan-System-opencode
- path for project documentation and user manuel: ~/dev/FilaMan/FilaMan-System-docu
- path for Bambulab Local-Communication Plugin: ~/dev/FilaMan/FilaMan-BambuLab-Plugin
- path for BambuLab Cloud-Communication Plugin: ~/dev/FilaMan/FilaMan-BambuLabCloud-Plugin
- path for SpoolmanDB Impoft Plugin: ~/Users/manuel~/dev/FilaMan/FilaMan-SpoolmanDB-Plugin
- path for SpoolmanAPI Plugin: ~/Users/manuel~/dev/FilaMan/FilaMan-SpoolmanAPI-Plugin
## User Version Info: changelog.json
- File: frontend/src/changelog.json
- Inhalt: eine Userfreundeliche Information über Neuerungen, Änderungen oder Entfernte Funktionen für den User. Keine technischen Details oder ähnliches, Kurz und pregnant.
- Als Platzhalter für die Version wird "UNRELEASED" genutzt. Dieser wird beim bump im Workflow ersetzt.
+5
View File
@@ -0,0 +1,5 @@
# Agent rules
- sprich IMMER auf Deutsch mit mir!
- Please checkt .opencode/instructions/ for the project rules
- you have never to push to git by urself!
+33 -8
View File
@@ -57,12 +57,12 @@ Geräte sollten regelmäßig einen Heartbeat senden, um ihren Status auf "Online
- **Request Body:**
```json
{
"spool_id": 123, // Optional: Interne ID der Spule
"tag_uuid": "E280...", // Optional: RFID Tag UID
"tag_uuid": "sf:25:s5:...", // Optional: RFID Tag UID (bevorzugt)
"spool_id": 123, // Optional: Interne ID der Spule (Fallback)
"measured_weight_g": 850.5 // Aktuelles Gesamtgewicht in Gramm
}
```
*Hinweis: Mindestens `spool_id` oder `tag_uuid` muss angegeben werden.*
*Hinweis: Mindestens `tag_uuid` oder `spool_id` muss angegeben werden. `tag_uuid` hat Vorrang vor `spool_id`.*
- **Response:**
```json
@@ -80,12 +80,14 @@ Verknüpft eine Spule mit einem Lagerort.
- **Request Body:**
```json
{
"spool_id": 123, // Optional: ID der Spule
"spool_tag_uuid": "E280...", // Optional: RFID UID der Spule
"location_id": 1, // Optional: ID des Ortes
"location_tag_uuid": "LOC-1" // Optional: RFID UID des Ortes
"spool_tag_uuid": "sf:25:s5:...", // Optional: RFID UID der Spule (bevorzugt)
"spool_id": 123, // Optional: ID der Spule (Fallback)
"location_tag_uuid": "LOC-1" // Optional: RFID UID des Ortes (bevorzugt)
"location_id": 1 // Optional: ID des Ortes (Fallback)
}
```
*Hinweis: RFID UUIDs haben Vorrang vor IDs. Mindestens Spule und Standort müssen durch UUID oder ID identifiziert werden.*
- **Response:**
```json
{
@@ -115,10 +117,33 @@ Das System sendet eine Anfrage an die IP des Geräts.
- **Erwartete Response vom Gerät:**
```json
{
"tag_uuid": "E2801234..." // Die UID des beschriebenen Tags
"tag_uuid": "sf:25:s5:..." // Die UID des beschriebenen Tags
}
```
### RFID Ergebnis zurückmelden
Das Device meldet das Ergebnis des Schreibvorgangs an das System zurück.
- **Endpunkt:** `POST /api/v1/devices/rfid-result`
- **Request Body:**
```json
{
"success": true,
"tag_uuid": "sf:25:s5:a1:00",
"spool_id": 123,
"remaining_weight_g": 850.5
}
```
*Hinweis: `remaining_weight_g` ist optional und wird beim erstmaligen Beschreiben einer neuen Spule benötigt.*
- **Felder:**
- `success` (boolean): War der Schreibvorgang erfolgreich?
- `tag_uuid` (string): Die UID des geschriebenen Tags
- `spool_id` (int, optional): DB-ID der Spule falls vorhanden
- `remaining_weight_g` (float, optional): Aktuelles Gewicht der Spule beim Schreibvorgang
- **Response:** `{"status": "ok", "message": "Processed successfully"}`
---
## 6. Fehlercodes
+37 -2
View File
@@ -57,6 +57,18 @@
<button id="registerBtn" class="fm-btn fm-btn-primary">Register Device</button>
<div id="statusMessage" style="margin-top: 1.5rem;"></div>
</div>
<div class="fm-card">
<h2>General Settings</h2>
<div class="fm-form-group" style="margin-top: 1rem;">
<label class="fm-label" for="languageSelect">Display Language</label>
<select id="languageSelect" class="fm-input">
<option value="en">English</option>
<option value="de">Deutsch</option>
</select>
</div>
</div>
</main>
</div>
@@ -70,6 +82,29 @@
})
.catch(error => console.error('Error fetching version:', error));
// Language setting
fetch('/api/language')
.then(response => response.json())
.then(data => {
document.getElementById('languageSelect').value = data.lang;
})
.catch(error => console.error('Error fetching language:', error));
document.getElementById('languageSelect').addEventListener('change', function() {
fetch('/api/language', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ lang: this.value })
})
.then(response => response.json())
.then(data => {
if (data.success) {
console.log('Language saved');
}
})
.catch(error => console.error('Error saving language:', error));
});
document.getElementById('registerBtn').addEventListener('click', () => {
const url = document.getElementById('filamanUrl').value;
const code = document.getElementById('deviceCode').value;
@@ -92,9 +127,9 @@
.then(response => response.json())
.then(data => {
if (data.success) {
statusMessage.textContent = 'Registration successful! Rebooting...';
statusMessage.textContent = 'Registration successful!';
statusMessage.style.color = 'var(--success-text)';
setTimeout(() => fetch('/reboot'), 2000);
setTimeout(() => location.reload(), 2000);
} else {
statusMessage.textContent = 'Registration failed. Please check your code and URL.';
statusMessage.style.color = 'var(--error-text)';
+2 -2
View File
@@ -9,8 +9,8 @@
; https://docs.platformio.org/page/projectconf.html
[common]
version = "3.0.9"
to_old_version = "2.0.10"
version = "3.2.5"
to_old_version = "3.0.9"
##
[env:esp32dev]
+34 -11
View File
@@ -8,6 +8,8 @@
#include "nfc.h"
#include "config.h"
#include <WiFi.h>
#include "display.h"
#include "lang.h"
volatile filamanApiStateType filamanApiState = API_IDLE;
bool filamanConnected = false;
@@ -21,6 +23,7 @@ struct ApiRequest {
float val;
bool bool1; // success
String str3; // error message
float remainingWeight; // remaining weight from rfid-result
bool active = false;
};
@@ -92,19 +95,28 @@ bool sendHeartbeat() {
}
bool sendWeight(int spoolId, String tagUuid, float measuredWeight) {
if (!checkFilamanRegistration() || WiFi.status() != WL_CONNECTED) return false;
Serial.printf("sendWeight: sending to API - spoolId=%d, tagUuid=%s, weight=%.1f\n", spoolId, tagUuid.c_str(), measuredWeight);
if (!checkFilamanRegistration() || WiFi.status() != WL_CONNECTED) {
Serial.println("ERROR: Not registered or WiFi not connected");
return false;
}
HTTPClient http;
http.setTimeout(3000);
http.begin(filamanUrl + "/api/v1/devices/scale/weight");
http.addHeader("Content-Type", "application/json");
http.addHeader("Authorization", "Device " + filamanToken);
JsonDocument doc;
// Only add spool_id if it's > 0 (for NTAG tags with spool ID)
// For Bambu tags (spoolId == 0), only send tag_uuid
if (spoolId > 0) doc["spool_id"] = spoolId;
// Always add tag_uuid if available (this is what we want for Bambu tags)
if (tagUuid.length() > 0) doc["tag_uuid"] = tagUuid;
doc["measured_weight_g"] = measuredWeight;
String payload;
serializeJson(doc, payload);
Serial.printf("API payload: %s\n", payload.c_str());
int httpCode = http.POST(payload);
Serial.printf("API response code: %d\n", httpCode);
if (httpCode == 200) {
String response = http.getString();
@@ -112,19 +124,19 @@ bool sendWeight(int spoolId, String tagUuid, float measuredWeight) {
DeserializationError error = deserializeJson(responseDoc, response);
if (!error && responseDoc["remaining_weight_g"].is<float>()) {
int remaining = (int)responseDoc["remaining_weight_g"].as<float>();
pauseMainTask = 1;
oledShowRemainingWeight(remaining);
oledSetPriority(DISPLAY_PRIORITY_ACTION, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
pauseMainTask = 0;
oledClearPriority();
}
http.end();
return true;
}
else {
pauseMainTask = 1;
oledShowProgressBar(1, 1, "Failure", "API Error");
oledShowProgressBar(1, 1, tr(STR_FAILURE), tr(STR_API_ERROR));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
vTaskDelay(pdMS_TO_TICKS(2000));
pauseMainTask = 0;
oledClearPriority();
}
http.end();
@@ -150,7 +162,7 @@ bool sendLocation(int spoolId, String spoolTagUuid, int locationId, String locat
return (httpCode == 200);
}
bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, String errorMessage) {
bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, String errorMessage, float remainingWeight) {
if (!checkFilamanRegistration() || WiFi.status() != WL_CONNECTED) return false;
HTTPClient http;
http.setTimeout(5000);
@@ -164,6 +176,7 @@ bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, S
if (spoolId > 0) doc["spool_id"] = spoolId;
if (locationId > 0) doc["location_id"] = locationId;
if (errorMessage.length() > 0) doc["error_message"] = errorMessage;
if (remainingWeight > 0) doc["remaining_weight_g"] = remainingWeight;
String payload;
serializeJson(doc, payload);
@@ -195,12 +208,12 @@ void filamanApiTask(void* pvParameters) {
case API_REQUEST_HEARTBEAT: sendHeartbeat(); break;
case API_REQUEST_WEIGHT: sendWeight(req.id1, req.str1, req.val); break;
case API_REQUEST_LOCATE: sendLocation(req.id1, req.str1, req.id2, req.str2); break;
case API_REQUEST_RFID_RESULT: sendRfidResult(req.str1, req.id1, req.id2, req.bool1, req.str3); break;
case API_REQUEST_RFID_RESULT: sendRfidResult(req.str1, req.id1, req.id2, req.bool1, req.str3, req.remainingWeight); break;
default: break;
}
filamanApiState = API_IDLE;
}
vTaskDelay(pdMS_TO_TICKS(1000));
vTaskDelay(pdMS_TO_TICKS(100));
}
}
@@ -227,7 +240,15 @@ void sendHeartbeatAsync() {
}
void sendWeightAsync(int spoolId, String tagUuid, float weight) {
if (!checkFilamanRegistration()) return;
Serial.printf("sendWeightAsync: spoolId=%d, tagUuid=%s, weight=%.1f\n", spoolId, tagUuid.c_str(), weight);
if (!checkFilamanRegistration()) {
Serial.println("ERROR: Not registered with FilaMan, cannot send weight");
return;
}
if (weight <= 0) {
Serial.println("ERROR: Weight is 0 or negative, cannot send");
return;
}
if (xSemaphoreTake(queueMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
for(int i=0; i<MAX_API_QUEUE; i++) if(!apiQueue[i].active) {
apiQueue[i].type = API_REQUEST_WEIGHT;
@@ -237,6 +258,7 @@ void sendWeightAsync(int spoolId, String tagUuid, float weight) {
apiQueue[i].str2 = "";
apiQueue[i].val = weight;
apiQueue[i].active = true;
Serial.printf("Weight queued for API (slot %d)\n", i);
break;
}
xSemaphoreGive(queueMutex);
@@ -260,7 +282,7 @@ void sendLocationAsync(int spoolId, String spoolTagUuid, int locationId, String
}
}
void sendRfidResultAsync(String tagUuid, int spoolId, int locationId, bool success, String errorMessage) {
void sendRfidResultAsync(String tagUuid, int spoolId, int locationId, bool success, String errorMessage, float remainingWeight) {
if (!checkFilamanRegistration()) return;
if (xSemaphoreTake(queueMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
for(int i=0; i<MAX_API_QUEUE; i++) if(!apiQueue[i].active) {
@@ -270,6 +292,7 @@ void sendRfidResultAsync(String tagUuid, int spoolId, int locationId, bool succe
apiQueue[i].id2 = locationId;
apiQueue[i].bool1 = success;
apiQueue[i].str3 = errorMessage;
apiQueue[i].remainingWeight = remainingWeight;
apiQueue[i].active = true;
break;
}
+2 -2
View File
@@ -29,13 +29,13 @@ bool registerDevice(const String& deviceCode);
void sendHeartbeatAsync();
void sendWeightAsync(int spoolId, String tagUuid, float weight);
void sendLocationAsync(int spoolId, String spoolTagUuid, int locationId, String locationTagUuid);
void sendRfidResultAsync(String tagUuid, int spoolId, int locationId, bool success, String errorMessage);
void sendRfidResultAsync(String tagUuid, int spoolId, int locationId, bool success, String errorMessage, float remainingWeight = 0);
// Internal blocking functions (used by async task)
bool sendHeartbeat();
bool sendWeight(int spoolId, String tagUuid, float weight);
bool sendLocation(int spoolId, String spoolTagUuid, int locationId, String locationTagUuid);
bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, String errorMessage);
bool sendRfidResult(String tagUuid, int spoolId, int locationId, bool success, String errorMessage, float remainingWeight = 0);
// Helper functions
void saveFilamanConfig();
+3
View File
@@ -11,6 +11,9 @@
#define NVS_NAMESPACE_SCALE "scale"
#define NVS_KEY_CALIBRATION "cal_value"
#define NVS_KEY_AUTOTARE "auto_tare"
#define NVS_NAMESPACE_SETTINGS "settings"
#define NVS_KEY_LANGUAGE "language"
#define SCALE_DEFAULT_CALIBRATION_VALUE 430.0f;
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
+48 -22
View File
@@ -3,12 +3,50 @@
#include <vector>
#include "icons.h"
#include "main.h"
#include <cstring>
#include "lang.h"
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
bool wifiOn = false;
bool iconToggle = false;
// Display priority management
static DisplayPriority currentPriority = DISPLAY_PRIORITY_NONE;
static unsigned long prioritySetTime = 0;
static unsigned long priorityMinDuration = 0;
bool oledCanUpdate(DisplayPriority newPriority) {
if (currentPriority == DISPLAY_PRIORITY_NONE) return true;
// Higher priority can always preempt
if (newPriority > currentPriority) return true;
// Same or lower priority: only if minimum duration has elapsed
unsigned long elapsed = millis() - prioritySetTime;
return elapsed >= priorityMinDuration;
}
void oledSetPriority(DisplayPriority priority, unsigned long minDurationMs) {
currentPriority = priority;
prioritySetTime = millis();
priorityMinDuration = minDurationMs;
}
void oledClearPriority() {
currentPriority = DISPLAY_PRIORITY_NONE;
prioritySetTime = 0;
priorityMinDuration = 0;
}
DisplayPriority oledGetCurrentPriority() {
// Auto-expire: if min duration has passed, priority is effectively NONE
if (currentPriority != DISPLAY_PRIORITY_NONE) {
unsigned long elapsed = millis() - prioritySetTime;
if (elapsed >= priorityMinDuration) {
currentPriority = DISPLAY_PRIORITY_NONE;
}
}
return currentPriority;
}
void setupDisplay() {
if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println(F("SSD1306 allocation failed"));
@@ -19,27 +57,15 @@ void setupDisplay() {
oledShowTopRow();
oledShowProgressBar(0, 7, DISPLAY_BOOT_TEXT, "Display init");
oledShowProgressBar(0, 7, DISPLAY_BOOT_TEXT, tr(STR_DISPLAY_INIT));
}
void oledclearline() {
int x, y;
for (y = 0; y < 16; y++) {
for (x = 0; x < SCREEN_WIDTH; x++) {
display.drawPixel(x, y, BLACK);
}
}
//display.display();
display.fillRect(0, 0, SCREEN_WIDTH, 16, BLACK);
}
void oledcleardata() {
int x, y;
for (y = OLED_DATA_START; y < OLED_DATA_END; y++) {
for (x = 0; x < SCREEN_WIDTH; x++) {
display.drawPixel(x, y, BLACK);
}
}
//display.display();
display.fillRect(0, OLED_DATA_START, SCREEN_WIDTH, OLED_DATA_END - OLED_DATA_START, BLACK);
}
int oled_center_h(const String &text) {
@@ -207,16 +233,16 @@ void oledShowIcon(const char* icon) {
uint16_t iconSize = OLED_DATA_END-OLED_DATA_START;
uint16_t iconStart = (SCREEN_WIDTH - iconSize) / 2;
if (icon == "failed") {
if (strcmp(icon, "failed") == 0) {
display.drawBitmap(iconStart, OLED_DATA_START, icon_failed , iconSize, iconSize, WHITE);
}
else if (icon == "success") {
else if (strcmp(icon, "success") == 0) {
display.drawBitmap(iconStart, OLED_DATA_START, icon_success , iconSize, iconSize, WHITE);
}
else if (icon == "transfer") {
else if (strcmp(icon, "transfer") == 0) {
display.drawBitmap(iconStart, OLED_DATA_START, icon_transfer , iconSize, iconSize, WHITE);
}
else if (icon == "loading") {
else if (strcmp(icon, "loading") == 0) {
display.drawBitmap(iconStart, OLED_DATA_START, icon_loading , iconSize, iconSize, WHITE);
}
@@ -244,7 +270,7 @@ void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char*
display.display();
}
void oledShowWeight(uint16_t weight) {
void oledShowWeight(int16_t weight) {
// Display Gewicht
oledcleardata();
display.setTextSize(3);
@@ -257,8 +283,8 @@ void oledShowWeight(uint16_t weight) {
void oledShowRemainingWeight(uint16_t remainingWeight) {
oledcleardata();
display.setTextSize(1);
display.setCursor(oled_center_h("Weight sent, rest:"), OLED_DATA_START + 4);
display.print("Weight sent, rest:");
display.setCursor(oled_center_h(tr(STR_WEIGHT_SENT_REST)), OLED_DATA_START + 4);
display.print(tr(STR_WEIGHT_SENT_REST));
display.setTextSize(3);
String weightStr = String(remainingWeight) + " g";
+15 -1
View File
@@ -6,10 +6,24 @@
#include <Adafruit_SSD1306.h>
#include "config.h"
// Display message priority levels (higher = more important)
enum DisplayPriority : uint8_t {
DISPLAY_PRIORITY_NONE = 0, // No message active
DISPLAY_PRIORITY_STATUS = 1, // Weight display, idle info
DISPLAY_PRIORITY_INFO = 2, // Progress bars, boot messages
DISPLAY_PRIORITY_ACTION = 3, // NFC feedback, user actions
DISPLAY_PRIORITY_WARNING = 4 // Errors, connection issues
};
extern Adafruit_SSD1306 display;
extern bool wifiOn;
// Display priority management
bool oledCanUpdate(DisplayPriority newPriority);
void oledSetPriority(DisplayPriority priority, unsigned long minDurationMs);
void oledClearPriority();
DisplayPriority oledGetCurrentPriority();
void setupDisplay();
void oledclearline();
void oledcleardata();
@@ -18,7 +32,7 @@ int oled_center_v(const String &text);
void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char* largeText, const char* statusMessage);
void oledShowWeight(uint16_t weight);
void oledShowWeight(int16_t weight);
void oledShowRemainingWeight(uint16_t remainingWeight);
void oledDisplayText(const String &message, uint8_t size = 2);
void oledShowConnectionError(const char* error, const String& ip);
+258
View File
@@ -0,0 +1,258 @@
#include "lang.h"
#include "config.h"
#include <Preferences.h>
Lang currentLang = LANG_EN;
// =====================================================================
// English strings
// =====================================================================
static const char EN_DISPLAY_INIT[] = "Display init";
static const char EN_WIFI_INIT[] = "WiFi init";
static const char EN_WEBSERVER_INIT[] = "Webserver init";
static const char EN_NFC_INIT[] = "NFC init";
static const char EN_SEARCHING_SCALE[] = "Searching scale";
static const char EN_TARE_SCALE[] = "TARE Scale";
static const char EN_SCALE_NOT_CAL[] = "Scale not calibrated";
static const char EN_SCALE_CAL[] = "Scale Cal.";
static const char EN_EMPTY_SCALE[] = "Empty Scale";
static const char EN_PLACE_WEIGHT[] = "Place the weight";
static const char EN_REMOVE_WEIGHT[] = "Remove weight";
static const char EN_COMPLETED[] = "Completed";
static const char EN_CAL_ERROR[] = "Calibration error";
static const char EN_HX711_NOT_FOUND[] = "HX711 not found";
static const char EN_READING[] = "Reading";
static const char EN_DECODING_DATA[] = "Decoding data";
static const char EN_SPOOL_TAG[] = "Spool Tag";
static const char EN_WEIGHING[] = "Weighing...";
static const char EN_WEIGHT_STABLE[] = "Weight stable";
static const char EN_SENDING[] = "Sending...";
static const char EN_TAG_WRITTEN[] = "Tag written";
static const char EN_WRITING[] = "Writing";
static const char EN_WRITE_TAG[] = "Write Tag";
static const char EN_DONE[] = "Done!";
static const char EN_PLACE_TAG_NOW[] = "Place tag now";
static const char EN_DETECTING_TAG[] = "Detecting tag";
static const char EN_KNOWN_SPOOL[] = "Known Spool";
static const char EN_QUICK_MODE[] = "Quick mode";
static const char EN_LOCATION[] = "Location";
static const char EN_LOCATION_SET[] = "Location set";
static const char EN_SCAN_SPOOL_FIRST[] = "Scan spool first";
static const char EN_WAIT_FMT[] = "Wait... %ds";
static const char EN_NOT_REGISTERED[] = "Not Registered";
static const char EN_API_CONN_LOST[] = "API Connection Lost";
static const char EN_API_ERROR[] = "API Error";
static const char EN_API_OFFLINE[] = "API offline";
static const char EN_WEIGHT_SENT_REST[] = "Weight sent, rest:";
static const char EN_FAILURE[] = "Failure";
static const char EN_FAILURE_EXCL[] = "Failure!";
static const char EN_UNKNOWN_TAG[] = "Unknown tag";
static const char EN_UNKNOWN_TAG_TYPE[] = "Unknown tag type";
static const char EN_NO_TAG_FOUND[] = "No tag found";
static const char EN_NFC_BUSY[] = "NFC busy!";
static const char EN_TAG_READ_ERROR[] = "Tag read error";
static const char EN_TAG_TOO_SMALL[] = "Tag too small for data";
static const char EN_NFC_RESET_FAIL[] = "NFC Reset failed";
static const char EN_TAG_LOST_RESET[] = "Tag lost after reset";
static const char EN_NFC_STILL_BROKEN[] = "NFC still broken";
static const char EN_TAG_DEFECT[] = "Tag/Interface defect";
static const char EN_TEST_READ_ERROR[] = "Test page read error";
static const char EN_TAG_REMOVED[] = "Tag removed";
static const char EN_TAG_WRITE_PROT[] = "Tag write protected?";
static const char EN_TEST_VERIFY_FAIL[] = "Test verify failed";
static const char EN_NDEF_INIT_FAIL[] = "NDEF init failed";
static const char EN_NFC_UNSTABLE[] = "NFC Interface unstable";
static const char EN_MEMORY_ERROR[] = "Memory error";
static const char EN_NO_RFID_BOARD[] = "No RFID Board found";
static const char EN_WIFI_CONFIG[] = "WiFi Config Mode";
static const char EN_WIFI_NOT_CONN[] = "WiFi not connected Check Portal";
static const char EN_WIFI_RECONN[] = "WiFi reconnecting";
static const char EN_UPDATE[] = "Update";
static const char EN_DOWNLOAD[] = "Download";
// =====================================================================
// German strings
// =====================================================================
static const char DE_DISPLAY_INIT[] = "Display init";
static const char DE_WIFI_INIT[] = "WiFi init";
static const char DE_WEBSERVER_INIT[] = "Webserver init";
static const char DE_NFC_INIT[] = "NFC init";
static const char DE_SEARCHING_SCALE[] = "Suche Waage";
static const char DE_TARE_SCALE[] = "Waage tarieren";
static const char DE_SCALE_NOT_CAL[] = "Waage nicht kalibriert";
static const char DE_SCALE_CAL[] = "Kalibrieren";
static const char DE_EMPTY_SCALE[] = "Waage leeren";
static const char DE_PLACE_WEIGHT[] = "Gewicht auflegen";
static const char DE_REMOVE_WEIGHT[] = "Gewicht entfernen";
static const char DE_COMPLETED[] = "Abgeschlossen";
static const char DE_CAL_ERROR[] = "Kalibrierungsfehler";
static const char DE_HX711_NOT_FOUND[] = "HX711 nicht gefunden";
static const char DE_READING[] = "Lesen";
static const char DE_DECODING_DATA[] = "Daten dekodieren";
static const char DE_SPOOL_TAG[] = "Spulen-Tag";
static const char DE_WEIGHING[] = "Wiegen...";
static const char DE_WEIGHT_STABLE[] = "Gewicht stabil";
static const char DE_SENDING[] = "Senden...";
static const char DE_TAG_WRITTEN[] = "Tag beschrieben";
static const char DE_WRITING[] = "Schreiben";
static const char DE_WRITE_TAG[] = "Tag schreiben";
static const char DE_DONE[] = "Fertig!";
static const char DE_PLACE_TAG_NOW[] = "Tag jetzt auflegen";
static const char DE_DETECTING_TAG[] = "Tag erkennen";
static const char DE_KNOWN_SPOOL[] = "Bekannte Spule";
static const char DE_QUICK_MODE[] = "Schnellmodus";
static const char DE_LOCATION[] = "Standort";
static const char DE_LOCATION_SET[] = "Standort gesetzt";
static const char DE_SCAN_SPOOL_FIRST[] = "Zuerst Spule scannen";
static const char DE_WAIT_FMT[] = "Warte... %ds";
static const char DE_NOT_REGISTERED[] = "Nicht registriert";
static const char DE_API_CONN_LOST[] = "API-Verbindung weg";
static const char DE_API_ERROR[] = "API-Fehler";
static const char DE_API_OFFLINE[] = "API offline";
static const char DE_WEIGHT_SENT_REST[] = "Gesendet, Rest:";
static const char DE_FAILURE[] = "Fehler";
static const char DE_FAILURE_EXCL[] = "Fehler!";
static const char DE_UNKNOWN_TAG[] = "Unbekannter Tag";
static const char DE_UNKNOWN_TAG_TYPE[] = "Unbekannter Tagtyp";
static const char DE_NO_TAG_FOUND[] = "Kein Tag gefunden";
static const char DE_NFC_BUSY[] = "NFC belegt!";
static const char DE_TAG_READ_ERROR[] = "Tag-Lesefehler";
static const char DE_TAG_TOO_SMALL[] = "Tag zu klein";
static const char DE_NFC_RESET_FAIL[] = "NFC-Reset fehlgeschl.";
static const char DE_TAG_LOST_RESET[] = "Tag nach Reset weg";
static const char DE_NFC_STILL_BROKEN[] = "NFC immer noch defekt";
static const char DE_TAG_DEFECT[] = "Tag/Interface defekt";
static const char DE_TEST_READ_ERROR[] = "Testseite Lesefehler";
static const char DE_TAG_REMOVED[] = "Tag entfernt";
static const char DE_TAG_WRITE_PROT[] = "Tag schreibgeschuetzt";
static const char DE_TEST_VERIFY_FAIL[] = "Test fehlgeschlagen";
static const char DE_NDEF_INIT_FAIL[] = "NDEF-Init Fehler";
static const char DE_NFC_UNSTABLE[] = "NFC instabil";
static const char DE_MEMORY_ERROR[] = "Speicherfehler";
static const char DE_NO_RFID_BOARD[] = "Kein RFID-Board";
static const char DE_WIFI_CONFIG[] = "WiFi Konfig-Modus";
static const char DE_WIFI_NOT_CONN[] = "WiFi nicht verbunden Portal pruefen";
static const char DE_WIFI_RECONN[] = "WiFi Neuverbindung";
static const char DE_UPDATE[] = "Update";
static const char DE_DOWNLOAD[] = "Download";
// =====================================================================
// String table: [StringID][Lang]
// =====================================================================
static const char* const stringTable[STR_COUNT][LANG_COUNT] = {
// Boot / Init
{ EN_DISPLAY_INIT, DE_DISPLAY_INIT },
{ EN_WIFI_INIT, DE_WIFI_INIT },
{ EN_WEBSERVER_INIT, DE_WEBSERVER_INIT },
{ EN_NFC_INIT, DE_NFC_INIT },
{ EN_SEARCHING_SCALE, DE_SEARCHING_SCALE },
// Scale
{ EN_TARE_SCALE, DE_TARE_SCALE },
{ EN_SCALE_NOT_CAL, DE_SCALE_NOT_CAL },
{ EN_SCALE_CAL, DE_SCALE_CAL },
{ EN_EMPTY_SCALE, DE_EMPTY_SCALE },
{ EN_PLACE_WEIGHT, DE_PLACE_WEIGHT },
{ EN_REMOVE_WEIGHT, DE_REMOVE_WEIGHT },
{ EN_COMPLETED, DE_COMPLETED },
{ EN_CAL_ERROR, DE_CAL_ERROR },
{ EN_HX711_NOT_FOUND, DE_HX711_NOT_FOUND },
// NFC / Spool
{ EN_READING, DE_READING },
{ EN_DECODING_DATA, DE_DECODING_DATA },
{ EN_SPOOL_TAG, DE_SPOOL_TAG },
{ EN_WEIGHING, DE_WEIGHING },
{ EN_WEIGHT_STABLE, DE_WEIGHT_STABLE },
{ EN_SENDING, DE_SENDING },
{ EN_TAG_WRITTEN, DE_TAG_WRITTEN },
{ EN_WRITING, DE_WRITING },
{ EN_WRITE_TAG, DE_WRITE_TAG },
{ EN_DONE, DE_DONE },
{ EN_PLACE_TAG_NOW, DE_PLACE_TAG_NOW },
{ EN_DETECTING_TAG, DE_DETECTING_TAG },
{ EN_KNOWN_SPOOL, DE_KNOWN_SPOOL },
{ EN_QUICK_MODE, DE_QUICK_MODE },
{ EN_LOCATION, DE_LOCATION },
{ EN_LOCATION_SET, DE_LOCATION_SET },
{ EN_SCAN_SPOOL_FIRST, DE_SCAN_SPOOL_FIRST },
{ EN_WAIT_FMT, DE_WAIT_FMT },
// Connection / API
{ EN_NOT_REGISTERED, DE_NOT_REGISTERED },
{ EN_API_CONN_LOST, DE_API_CONN_LOST },
{ EN_API_ERROR, DE_API_ERROR },
{ EN_API_OFFLINE, DE_API_OFFLINE },
{ EN_WEIGHT_SENT_REST, DE_WEIGHT_SENT_REST },
// Errors
{ EN_FAILURE, DE_FAILURE },
{ EN_FAILURE_EXCL, DE_FAILURE_EXCL },
{ EN_UNKNOWN_TAG, DE_UNKNOWN_TAG },
{ EN_UNKNOWN_TAG_TYPE, DE_UNKNOWN_TAG_TYPE },
{ EN_NO_TAG_FOUND, DE_NO_TAG_FOUND },
{ EN_NFC_BUSY, DE_NFC_BUSY },
{ EN_TAG_READ_ERROR, DE_TAG_READ_ERROR },
{ EN_TAG_TOO_SMALL, DE_TAG_TOO_SMALL },
{ EN_NFC_RESET_FAIL, DE_NFC_RESET_FAIL },
{ EN_TAG_LOST_RESET, DE_TAG_LOST_RESET },
{ EN_NFC_STILL_BROKEN, DE_NFC_STILL_BROKEN },
{ EN_TAG_DEFECT, DE_TAG_DEFECT },
{ EN_TEST_READ_ERROR, DE_TEST_READ_ERROR },
{ EN_TAG_REMOVED, DE_TAG_REMOVED },
{ EN_TAG_WRITE_PROT, DE_TAG_WRITE_PROT },
{ EN_TEST_VERIFY_FAIL, DE_TEST_VERIFY_FAIL },
{ EN_NDEF_INIT_FAIL, DE_NDEF_INIT_FAIL },
{ EN_NFC_UNSTABLE, DE_NFC_UNSTABLE },
{ EN_MEMORY_ERROR, DE_MEMORY_ERROR },
{ EN_NO_RFID_BOARD, DE_NO_RFID_BOARD },
// WiFi
{ EN_WIFI_CONFIG, DE_WIFI_CONFIG },
{ EN_WIFI_NOT_CONN, DE_WIFI_NOT_CONN },
{ EN_WIFI_RECONN, DE_WIFI_RECONN },
// OTA
{ EN_UPDATE, DE_UPDATE },
{ EN_DOWNLOAD, DE_DOWNLOAD },
};
const char* tr(StringID id) {
if (id >= STR_COUNT) return "???";
return stringTable[id][currentLang];
}
void loadLanguage() {
Preferences preferences;
preferences.begin(NVS_NAMESPACE_SETTINGS, true);
currentLang = (Lang)preferences.getUChar(NVS_KEY_LANGUAGE, LANG_EN);
if (currentLang >= LANG_COUNT) currentLang = LANG_EN;
preferences.end();
Serial.printf("Language loaded: %s\n", getLangCode());
}
void saveLanguage(Lang lang) {
if (lang >= LANG_COUNT) return;
currentLang = lang;
Preferences preferences;
preferences.begin(NVS_NAMESPACE_SETTINGS, false);
preferences.putUChar(NVS_KEY_LANGUAGE, (uint8_t)lang);
preferences.end();
Serial.printf("Language saved: %s\n", getLangCode());
}
const char* getLangCode() {
return (currentLang == LANG_DE) ? "de" : "en";
}
+109
View File
@@ -0,0 +1,109 @@
#ifndef LANG_H
#define LANG_H
#include <Arduino.h>
// Supported languages
enum Lang : uint8_t {
LANG_EN = 0,
LANG_DE = 1,
LANG_COUNT
};
// String IDs for all translatable display texts
enum StringID : uint8_t {
// Boot / Init
STR_DISPLAY_INIT,
STR_WIFI_INIT,
STR_WEBSERVER_INIT,
STR_NFC_INIT,
STR_SEARCHING_SCALE,
// Scale
STR_TARE_SCALE,
STR_SCALE_NOT_CALIBRATED,
STR_SCALE_CAL,
STR_EMPTY_SCALE,
STR_PLACE_WEIGHT,
STR_REMOVE_WEIGHT,
STR_COMPLETED,
STR_CALIBRATION_ERROR,
STR_HX711_NOT_FOUND,
// NFC / Spool
STR_READING,
STR_DECODING_DATA,
STR_SPOOL_TAG,
STR_WEIGHING,
STR_WEIGHT_STABLE,
STR_SENDING,
STR_TAG_WRITTEN,
STR_WRITING,
STR_WRITE_TAG,
STR_DONE,
STR_PLACE_TAG_NOW,
STR_DETECTING_TAG,
STR_KNOWN_SPOOL,
STR_QUICK_MODE,
STR_LOCATION,
STR_LOCATION_SET,
STR_SCAN_SPOOL_FIRST,
STR_WAIT_FMT, // format string: "Wait... %ds" / "Warte... %ds"
// Connection / API
STR_NOT_REGISTERED,
STR_API_CONN_LOST,
STR_API_ERROR,
STR_API_OFFLINE,
STR_WEIGHT_SENT_REST,
// Errors
STR_FAILURE,
STR_FAILURE_EXCL,
STR_UNKNOWN_TAG,
STR_UNKNOWN_TAG_TYPE,
STR_NO_TAG_FOUND,
STR_NFC_BUSY,
STR_TAG_READ_ERROR,
STR_TAG_TOO_SMALL,
STR_NFC_RESET_FAILED,
STR_TAG_LOST_RESET,
STR_NFC_STILL_BROKEN,
STR_TAG_DEFECT,
STR_TEST_READ_ERROR,
STR_TAG_REMOVED,
STR_TAG_WRITE_PROT,
STR_TEST_VERIFY_FAIL,
STR_NDEF_INIT_FAILED,
STR_NFC_UNSTABLE,
STR_MEMORY_ERROR,
STR_NO_RFID_BOARD,
// WiFi
STR_WIFI_CONFIG_MODE,
STR_WIFI_NOT_CONNECTED,
STR_WIFI_RECONNECTING,
// OTA
STR_UPDATE,
STR_DOWNLOAD,
STR_COUNT // must be last
};
// Current language (default: English)
extern Lang currentLang;
// Get translated string by ID
const char* tr(StringID id);
// Load language setting from NVS
void loadLanguage();
// Save language setting to NVS
void saveLanguage(Lang lang);
// Get current language as string ("en" or "de")
const char* getLangCode();
#endif
+53 -28
View File
@@ -13,6 +13,7 @@
#include "scale.h"
#include "esp_task_wdt.h"
#include "commonFS.h"
#include "lang.h"
bool mainTaskWasPaused = 0;
uint8_t scaleTareCounter = 0;
@@ -32,6 +33,9 @@ void setup() {
// Initialize SPIFFS
initializeFileSystem();
// Load language setting from NVS (before display init)
loadLanguage();
// Start Display
setupDisplay();
@@ -107,13 +111,13 @@ void loop() {
// Handle connection errors (not registered or not connected)
if (intervalElapsed(currentMillis, lastConnErrorShowTime, connErrorShowInterval)) {
if (!filamanRegistered) {
oledShowConnectionError("Not Registered", WiFi.localIP().toString());
vTaskDelay(pdMS_TO_TICKS(3000));
if (!filamanRegistered && oledCanUpdate(DISPLAY_PRIORITY_WARNING)) {
oledShowConnectionError(tr(STR_NOT_REGISTERED), WiFi.localIP().toString());
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
mainTaskWasPaused = true;
} else if (!filamanConnected) {
oledShowConnectionError("API Connection Lost", WiFi.localIP().toString());
vTaskDelay(pdMS_TO_TICKS(3000));
} else if (!filamanConnected && oledCanUpdate(DISPLAY_PRIORITY_WARNING)) {
oledShowConnectionError(tr(STR_API_CONN_LOST), WiFi.localIP().toString());
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
mainTaskWasPaused = true;
}
}
@@ -150,21 +154,22 @@ void loop() {
{
// Do not show the warning if the calibratin process is onging
if(!scaleCalibrationActive){
oledDisplayText("Scale not calibrated");
oledDisplayText(tr(STR_SCALE_NOT_CALIBRATED));
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
else
{
// Ausgabe der Waage auf Display
// Block weight display during NFC write operations
if(pauseMainTask == 0 && !nfcWriteInProgress)
// Block weight display during NFC write operations and higher-priority display messages
if(pauseMainTask == 0 && !nfcWriteInProgress && oledCanUpdate(DISPLAY_PRIORITY_STATUS))
{
// Use filtered weight for smooth display, but still check API weight for significant changes
int16_t displayWeight = getFilteredDisplayWeight();
if (mainTaskWasPaused || (weight != lastWeight && (nfcReaderState == NFC_IDLE || tagProcessed)))
{
(displayWeight < 2) ? ((displayWeight < -2) ? oledDisplayText("!! -0") : oledShowWeight(0)) : oledShowWeight(displayWeight);
oledShowWeight((abs(displayWeight) < 2) ? 0 : displayWeight);
oledSetPriority(DISPLAY_PRIORITY_STATUS, 0); // Weight can always be overwritten
}
mainTaskWasPaused = false;
}
@@ -183,48 +188,68 @@ void loop() {
if (abs(weight - lastWeight) <= 2 && weight > 5)
{
weightCounterToApi++;
// Show stable weight feedback when approaching send threshold
if (weightCounterToApi == 3 && nfcReaderState == NFC_READ_SUCCESS && !tagProcessed && weightSend == 0) {
oledShowProgressBar(2, 4, tr(STR_SPOOL_TAG), tr(STR_WEIGHT_STABLE));
oledSetPriority(DISPLAY_PRIORITY_INFO, 1000);
}
}
else
{
// Show visual feedback when tag is present and weight is unstable
if (weightCounterToApi > 0 && nfcReaderState == NFC_READ_SUCCESS && !tagProcessed && weightSend == 0) {
oledShowProgressBar(1, 4, tr(STR_SPOOL_TAG), tr(STR_WEIGHING));
oledSetPriority(DISPLAY_PRIORITY_INFO, 1000);
}
weightCounterToApi = 0;
weightSend = 0;
}
}
lastWeight = weight;
// Wenn ein Tag erkannt wurde und das Gewicht stabil ist, 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)
{
// set the current tag as processed to prevent it beeing processed again
tagProcessed = true;
// Get UID from nfcJsonData or similar (nfc.cpp should set it)
// For now, use activeSpoolId if available
int sId = activeSpoolId.toInt();
sendWeightAsync(sId, activeTagUuid, weight);
// Check if it's a Bambu tag - if so, send only UUID without spoolId
if (isBambuTag) {
sendWeightAsync(0, activeTagUuid, weight);
Serial.println("Bambu weight queued for FilaMan (UUID only)");
} else {
// Normal NTAG: send spoolId + UUID
int sId = activeSpoolId.toInt();
sendWeightAsync(sId, activeTagUuid, weight);
Serial.println("Weight queued for FilaMan");
}
weightSend = 1;
Serial.println("Weight queued for FilaMan");
// Feedback to user
pauseMainTask = 1;
oledShowProgressBar(3, 4, "Spool Tag", "Sending...");
oledShowProgressBar(3, 4, tr(STR_SPOOL_TAG), tr(STR_SENDING));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
}
// Handle successful tag write
if (nfcReaderState == NFC_WRITE_SUCCESS && tagProcessed == false)
{
tagProcessed = true;
int sId = activeSpoolId.toInt();
sendWeightAsync(sId, activeTagUuid, weight);
weightSend = 1;
Serial.println("Weight queued for FilaMan after tag write");
// Feedback to user
pauseMainTask = 1;
oledShowProgressBar(3, 4, "Tag written", "Sending...");
// Only send weight if a valid spoolId exists (spool tag, not location tag)
if (activeSpoolId.length() > 0 && activeSpoolId != "0") {
int sId = activeSpoolId.toInt();
sendWeightAsync(sId, activeTagUuid, weight);
weightSend = 1;
Serial.println("Weight queued for FilaMan after spool tag write");
// Feedback to user
oledShowProgressBar(3, 4, tr(STR_TAG_WRITTEN), tr(STR_SENDING));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
} else {
// Location tag written - no weight to send
Serial.println("Location tag written successfully - no weight send needed");
}
}
}
}
esp_task_wdt_reset();
}
+212 -68
View File
@@ -8,6 +8,7 @@
#include "esp_task_wdt.h"
#include "scale.h"
#include "main.h"
#include "lang.h"
//Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
@@ -22,6 +23,7 @@ String activeTagUuid = "";
String lastSpoolId = "";
String nfcJsonData = "";
bool tagProcessed = false;
bool isBambuTag = false;
volatile bool nfcReadingTaskSuspendRequest = false;
volatile bool nfcReadingTaskSuspendState = false;
volatile bool nfcWriteInProgress = false; // Prevent any tag operations during write
@@ -36,6 +38,42 @@ volatile nfcReaderStateType nfcReaderState = NFC_IDLE;
// 6 = reading
// ***** PN532
// ##### Bambu Tag Helper Functions #####
// Simplified: only read UID, no decryption needed (UID is always visible)
bool detectBambuTag(const uint8_t* uid, uint8_t uidLength) {
Serial.println("Detected Bambu Lab tag (Mifare Classic) - reading UID only");
// Create UID string with separators (same format as NTAG)
String uidString = "";
for (uint8_t i = 0; i < uidLength; i++) {
if (uid[i] < 0x10) uidString += "0";
uidString += String(uid[i], HEX);
if (i < uidLength - 1) {
uidString += ":";
}
}
uidString.toUpperCase();
Serial.print(" UID: ");
Serial.println(uidString);
isBambuTag = true;
activeTagUuid = uidString;
activeSpoolId = ""; // Will be resolved by FilaMan API based on tag UID
// Create minimal JSON for compatibility
JsonDocument doc;
doc["vendor"] = "Bambu Lab";
doc["type"] = "Bambu";
nfcJsonData = "";
serializeJson(doc, nfcJsonData);
// Set normal read success state - isBambuTag flag is set for later use
nfcReaderState = NFC_READ_SUCCESS;
return true;
}
// ##### Funktionen für RFID #####
void payloadToJson(uint8_t *data) {
const char* startJson = strchr((char*)data, '{');
@@ -461,8 +499,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
Serial.println("!!!!!!!!!!!!!!!!!!!!!!!!");
Serial.println();
oledDisplayText("Tag zu klein für Payload");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_TAG_TOO_SMALL));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -503,8 +543,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
Serial.println("✓ PN532 Kommunikation wiederhergestellt");
} else {
Serial.println("❌ PN532 Kommunikation fehlgeschlagen");
oledDisplayText("NFC Reset failed");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_NFC_RESET_FAILED));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -537,8 +579,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
if (!tagRedetected) {
Serial.println("❌ Tag konnte nach Reset nicht wiedererkannt werden");
oledDisplayText("Tag lost after reset");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_TAG_LOST_RESET));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -555,8 +599,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
if (!ccReadable) {
Serial.println("❌ NFC-Interface funktioniert nach Reset immer noch nicht");
oledDisplayText("NFC still broken");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_NFC_STILL_BROKEN));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -608,8 +654,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
if (!basicPagesReadable) {
Serial.println("❌ KRITISCHER FEHLER: Grundlegende NDEF-Seiten nicht lesbar!");
Serial.println("Tag oder Interface ist defekt");
oledDisplayText("Tag/Interface defect");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_TAG_DEFECT));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -629,8 +677,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
// First, read original content of test page
if (!nfc.ntag2xx_ReadPage(10, originalPage)) {
Serial.println("FEHLER: Kann Testseite nicht lesen für Backup");
oledDisplayText("Test page read error");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_TEST_READ_ERROR));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -660,15 +710,18 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
if (!tagStillPresent) {
Serial.println("URSACHE: Tag wurde während Schreibtest entfernt!");
oledDisplayText("Tag removed");
oledDisplayText(tr(STR_TAG_REMOVED));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
} else {
Serial.println("URSACHE: Tag ist vorhanden aber nicht beschreibbar");
Serial.println("Möglicherweise: Schreibschutz, Defekt, oder Interface-Problem");
oledDisplayText("Tag write protected?");
oledDisplayText(tr(STR_TAG_WRITE_PROT));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
}
Serial.println("==========================================");
vTaskDelay(pdMS_TO_TICKS(3000));
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -679,8 +732,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
if (!nfc.ntag2xx_ReadPage(10, readBack)) {
Serial.println("FEHLER: Kann Testdaten nicht zurücklesen!");
oledDisplayText("Test verify failed");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_TEST_VERIFY_FAIL));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -724,8 +779,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
Serial.println("=== SCHRITT 4: NDEF-INITIALISIERUNG ===");
if (!initializeNdefStructure()) {
Serial.println("FEHLER: Konnte NDEF-Struktur nicht initialisieren!");
oledDisplayText("NDEF init failed");
oledDisplayText(tr(STR_NDEF_INIT_FAILED));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
vTaskDelay(pdMS_TO_TICKS(2000));
oledClearPriority();
return 0;
}
@@ -780,8 +837,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
if (!interfaceStable) {
Serial.println("FEHLER: NFC-Interface ist nicht stabil genug für Schreibvorgang");
oledDisplayText("NFC Interface unstable");
vTaskDelay(pdMS_TO_TICKS(3000));
oledDisplayText(tr(STR_NFC_UNSTABLE));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
vTaskDelay(pdMS_TO_TICKS(3000));
oledClearPriority();
return 0;
}
@@ -793,8 +852,10 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
uint8_t* tlvData = (uint8_t*) malloc(totalTlvSize);
if (tlvData == NULL) {
Serial.println("Fehler: Nicht genug Speicher für TLV-Daten vorhanden.");
oledDisplayText("Memory error");
oledDisplayText(tr(STR_MEMORY_ERROR));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
vTaskDelay(pdMS_TO_TICKS(2000));
oledClearPriority();
return 0;
}
@@ -1062,7 +1123,8 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
}
bool decodeNdefAndReturnJson(const byte* encodedMessage, String uidString) {
oledShowProgressBar(1, 4, "Reading", "Decoding data");
oledShowProgressBar(1, 4, tr(STR_READING), tr(STR_DECODING_DATA));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 1500);
// Debug: Print first 32 bytes of the raw data
Serial.println("Raw NDEF data (first 32 bytes):");
@@ -1255,7 +1317,8 @@ bool decodeNdefAndReturnJson(const byte* encodedMessage, String uidString) {
Serial.println("JSON-Dokument erfolgreich verarbeitet");
if (doc["sm_id"].is<String>() && doc["sm_id"] != "" && doc["sm_id"] != "0")
{
oledShowProgressBar(2, 4, "Spool Tag", "Weighing");
oledShowProgressBar(2, 4, tr(STR_SPOOL_TAG), tr(STR_WEIGHING));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
activeSpoolId = doc["sm_id"].as<String>();
lastSpoolId = activeSpoolId;
}
@@ -1264,17 +1327,39 @@ bool decodeNdefAndReturnJson(const byte* encodedMessage, String uidString) {
{
Serial.println("Location Tag found!");
int locId = doc["location_id"].as<int>();
int sId = lastSpoolId.toInt();
sendLocationAsync(sId, "", locId, "");
// Check if a spool was scanned before
if (lastSpoolId.length() == 0 || lastSpoolId == "0") {
Serial.println("No spool scanned before location tag - showing warning");
oledShowProgressBar(1, 1, tr(STR_LOCATION), tr(STR_SCAN_SPOOL_FIRST));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 3000);
} else {
int sId = lastSpoolId.toInt();
sendLocationAsync(sId, "", locId, "");
// Display feedback - location was set
oledShowProgressBar(1, 1, tr(STR_LOCATION), tr(STR_LOCATION_SET));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 3000);
// Clear lastSpoolId to prevent accidental re-assignment
lastSpoolId = "";
Serial.println("Location set - lastSpoolId cleared to prevent re-assignment");
}
// Mark as processed so main.cpp doesn't try to send weight
tagProcessed = true;
activeSpoolId = "";
}
else
{
Serial.println("Unbekannter Tag-Inhalt.");
activeSpoolId = "";
oledShowProgressBar(1, 1, "Failure", "Unknown tag");
oledShowProgressBar(1, 1, tr(STR_FAILURE), tr(STR_UNKNOWN_TAG));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
}
} else {
oledShowProgressBar(4, 4, "Failure!", "API offline");
oledShowProgressBar(4, 4, tr(STR_FAILURE_EXCL), tr(STR_API_OFFLINE));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
}
}
@@ -1483,7 +1568,8 @@ bool quickSpoolIdCheck(String uidString) {
Serial.println("⚠ FAST-PATH: Could not read complete JSON, web interface may show limited data");
}
oledShowProgressBar(2, 4, "Known Spool", "Quick mode");
oledShowProgressBar(2, 4, tr(STR_KNOWN_SPOOL), tr(STR_QUICK_MODE));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 1500);
Serial.println("✓ FAST-PATH SUCCESS: Known spool processed quickly");
return true;
} else {
@@ -1538,7 +1624,8 @@ bool quickSpoolIdCheck(String uidString) {
Serial.println("⚠ FAST-PATH: Could not read complete JSON, web interface may show limited data");
}
oledShowProgressBar(2, 4, "Known Spool", "Quick mode");
oledShowProgressBar(2, 4, tr(STR_KNOWN_SPOOL), tr(STR_QUICK_MODE));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 1500);
Serial.println("✓ FAST-PATH SUCCESS: Known spool processed quickly");
return true;
} else {
@@ -1584,31 +1671,47 @@ void writeJsonToTag(void *parameter) {
sendNfcData();
vTaskDelay(pdMS_TO_TICKS(100));
// Show waiting message for tag detection
oledShowProgressBar(0, 1, "Write Tag", "Warte auf Tag");
// Show initial waiting message with countdown
char _waitBuf[20];
snprintf(_waitBuf, sizeof(_waitBuf), tr(STR_WAIT_FMT), 30);
oledShowProgressBar(0, 30, tr(STR_WRITE_TAG), _waitBuf);
oledSetPriority(DISPLAY_PRIORITY_ACTION, 1500);
// Wait up to 30 seconds for tag
uint8_t success = 0;
String uidString = "";
uint8_t uidLength = 0;
unsigned long startTime = millis();
uint8_t lastSecondsShown = 30;
while (millis() - startTime < 30000) {
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer to store the returned UID
uint8_t uidLength;
// yield before potentially waiting for 400ms
yield();
esp_task_wdt_reset();
// Update countdown display every second
unsigned long elapsed = millis() - startTime;
uint8_t remainingSeconds = (30000 - elapsed) / 1000;
if (remainingSeconds != lastSecondsShown) {
lastSecondsShown = remainingSeconds;
char countdownText[20];
snprintf(countdownText, sizeof(countdownText), tr(STR_WAIT_FMT), remainingSeconds);
oledShowProgressBar(elapsed / 1000, 30, tr(STR_WRITE_TAG), countdownText);
oledSetPriority(DISPLAY_PRIORITY_ACTION, 1500);
}
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 400);
if (success) {
for (uint8_t i = 0; i < uidLength; i++) {
if (uid[i] < 0x10) uidString += "0";
uidString += String(uid[i], HEX);
if (i < uidLength - 1) {
uidString += ":"; // Trennzeichen hinzufügen
}
}
foundNfcTag(nullptr, success);
uidString.toUpperCase();
break;
}
@@ -1619,7 +1722,28 @@ void writeJsonToTag(void *parameter) {
if (success)
{
oledShowProgressBar(1, 3, "Write Tag", "Writing");
// Check if this is a Bambu tag (Mifare Classic has 4 byte UID, NTAG has 7 byte)
// If so, skip writing and just send success with weight to API
if (uidLength != 7) {
Serial.println("Bambu Lab tag detected during write - skipping write, sending result with weight");
oledShowProgressBar(1, 1, tr(STR_WRITE_TAG), tr(STR_DONE));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
// Send success to API with tag_uuid and current weight
sendRfidResultAsync(uidString, params->spoolId, params->locationId, true, "", weight);
vTaskDelay(pdMS_TO_TICKS(500));
// Clean up and exit
nfcWriteInProgress = false;
nfcReaderState = NFC_IDLE;
free(params->payload);
delete params;
vTaskDelete(NULL);
}
oledShowProgressBar(1, 3, tr(STR_WRITE_TAG), tr(STR_WRITING));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
// Schreibe die NDEF-Message auf den Tag
success = ntag2xx_WriteNDEF(params->payload);
@@ -1632,10 +1756,11 @@ void writeJsonToTag(void *parameter) {
// aktualisieren der Website wenn sich der Status ändert
sendNfcData();
if(params->tagType){
oledShowProgressBar(1, 1, "Write Tag", "Done!");
oledShowProgressBar(1, 1, tr(STR_WRITE_TAG), tr(STR_DONE));
}else{
oledShowProgressBar(1, 1, "Write Tag", "Done!");
oledShowProgressBar(1, 1, tr(STR_WRITE_TAG), tr(STR_DONE));
}
oledSetPriority(DISPLAY_PRIORITY_ACTION, 3000);
// CRITICAL: Properly stabilize NFC interface after write operation
Serial.println();
@@ -1710,9 +1835,9 @@ void writeJsonToTag(void *parameter) {
Serial.println("=========================================");
// Send success response to API with tag_uuid (with separators)
// Send success response to API with tag_uuid and current weight
Serial.println("Sending result to API via fire-and-forget...");
sendRfidResultAsync(uidString, params->spoolId, params->locationId, true, "");
sendRfidResultAsync(uidString, params->spoolId, params->locationId, true, "", weight);
// vTaskResume(RfidReaderTask); // Don't resume as it was not suspended
vTaskDelay(pdMS_TO_TICKS(500));
@@ -1721,7 +1846,9 @@ void writeJsonToTag(void *parameter) {
{
Serial.println("Fehler beim Schreiben der NDEF-Message auf den Tag");
oledShowIcon("failed");
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
vTaskDelay(pdMS_TO_TICKS(2000));
oledClearPriority();
nfcReaderState = NFC_WRITE_ERROR;
// Send error response to API
@@ -1732,19 +1859,19 @@ void writeJsonToTag(void *parameter) {
else
{
Serial.println("Fehler: Kein Tag zu schreiben gefunden.");
oledShowProgressBar(1, 1, "Failure!", "No tag found");
oledShowProgressBar(1, 1, tr(STR_FAILURE_EXCL), tr(STR_NO_TAG_FOUND));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
vTaskDelay(pdMS_TO_TICKS(2000));
oledClearPriority();
nfcReaderState = NFC_IDLE;
// Send timeout response to API
Serial.println("Sending timeout result to API via fire-and-forget...");
sendRfidResultAsync("", params->spoolId, params->locationId, false, "Timeout - no tag found");
}
sendWriteResult(nullptr, success);
sendNfcData();
// Reset write protection and cleanup
oledClearPriority();
nfcWriteInProgress = false; // Re-enable high-level tag operations
// Make sure we are in a safe state
@@ -1828,7 +1955,8 @@ void startWriteJsonToTag(const bool isSpoolTag, const char* payload, int spoolId
nfcWriteInProgress = true; // Lock immediately to prevent race conditions
Serial.println("startWriteJsonToTag: Starting task, lock acquired.");
oledShowProgressBar(0, 1, "Write Tag", "Place tag now");
oledShowProgressBar(0, 1, tr(STR_WRITE_TAG), tr(STR_PLACE_TAG_NOW));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 2000);
// Erstelle die Task
BaseType_t result = xTaskCreatePinnedToCore(
writeJsonToTag, // Task-Funktion
@@ -1848,7 +1976,8 @@ void startWriteJsonToTag(const bool isSpoolTag, const char* payload, int spoolId
}
}else{
Serial.printf("startWriteJsonToTag: State mismatch (State: %d)\n", nfcReaderState);
oledShowProgressBar(0, 1, "FAILURE", "NFC busy!");
oledShowProgressBar(0, 1, tr(STR_FAILURE), tr(STR_NFC_BUSY));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
free(parameters->payload);
delete parameters;
}
@@ -1917,17 +2046,20 @@ void scanRfidTask(void * parameter) {
Serial.println("Found an ISO14443A card");
nfcReaderState = NFC_READING;
pauseMainTask = 1;
oledShowProgressBar(0, 4, "Reading", "Detecting tag");
oledShowProgressBar(0, 4, tr(STR_READING), tr(STR_DETECTING_TAG));
oledSetPriority(DISPLAY_PRIORITY_ACTION, 1500);
// Reduced stabilization time for better responsiveness
Serial.println("Tag detected, minimal stabilization...");
vTaskDelay(pdMS_TO_TICKS(200)); // Reduced from 1000ms to 200ms
// Stabilization time for reliable tag communication
Serial.println("Tag detected, stabilizing...");
vTaskDelay(pdMS_TO_TICKS(500)); // Increased from 200ms for reliable reads
// create Tag UID string
String uidString = "";
for (uint8_t i = 0; i < uidLength; i++) {
//TBD: Rework to remove all the string operations
if (uid[i] < 0x10) uidString += "0";
uidString += String(uid[i], HEX);
if (i < uidLength - 1) {
uidString += ":"; // Optional: Trennzeichen hinzufügen
@@ -1942,7 +2074,7 @@ void scanRfidTask(void * parameter) {
Serial.println("✓ FAST-PATH: Tag processed quickly, skipping full read");
// Set reader back to idle for next scan
nfcReaderState = NFC_READ_SUCCESS;
delay(500); // Small delay before next scan
vTaskDelay(pdMS_TO_TICKS(500)); // Small delay before next scan
continue; // Skip full tag reading and continue scan loop
}
@@ -1988,7 +2120,8 @@ void scanRfidTask(void * parameter) {
if (!decodeNdefAndReturnJson(data, uidString))
{
oledShowProgressBar(1, 1, "Failure", "Unknown tag");
oledShowProgressBar(1, 1, tr(STR_FAILURE), tr(STR_UNKNOWN_TAG));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
nfcReaderState = NFC_READ_ERROR;
}
else
@@ -2000,21 +2133,30 @@ void scanRfidTask(void * parameter) {
}
else
{
oledShowProgressBar(1, 1, "Failure", "Tag read error");
nfcReaderState = NFC_READ_ERROR;
// Reset activeSpoolId when tag reading fails to prevent autoSet
activeSpoolId = "";
Serial.println("Tag read failed - activeSpoolId reset to prevent autoSet");
// NTAG reading failed, try reading as Bambu Lab tag
Serial.println("NTAG read failed, trying Bambu Lab tag...");
if (!detectBambuTag(uid, uidLength)) {
oledShowProgressBar(1, 1, tr(STR_FAILURE), tr(STR_TAG_READ_ERROR));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
nfcReaderState = NFC_READ_ERROR;
activeSpoolId = "";
Serial.println("Tag read failed - activeSpoolId reset to prevent autoSet");
}
}
}
else
{
//TBD: Show error here?!
oledShowProgressBar(1, 1, "Failure", "Unkown tag type");
Serial.println("This doesn't seem to be an NTAG2xx tag (UUID length != 7 bytes)!");
// Reset activeSpoolId when tag type is unknown to prevent autoSet
activeSpoolId = "";
Serial.println("Unknown tag type - activeSpoolId reset to prevent autoSet");
// UID length != 7, might be a Mifare Classic (Bambu tags)
Serial.println("Not a standard NTAG (UID length != 7), trying Bambu Lab tag...");
if (!detectBambuTag(uid, uidLength)) {
//TBD: Show error here?!
oledShowProgressBar(1, 1, tr(STR_FAILURE), tr(STR_UNKNOWN_TAG_TYPE));
oledSetPriority(DISPLAY_PRIORITY_WARNING, 2000);
Serial.println("This doesn't seem to be an NTAG2xx tag (UUID length != 7 bytes)!");
// Reset activeSpoolId when tag type is unknown to prevent autoSet
activeSpoolId = "";
Serial.println("Unknown tag type - activeSpoolId reset to prevent autoSet");
}
}
}
@@ -2026,6 +2168,8 @@ void scanRfidTask(void * parameter) {
activeSpoolId = "";
activeTagUuid = "";
tagProcessed = false;
pauseMainTask = 0;
oledClearPriority();
oledShowWeight(weight);
}
@@ -2034,18 +2178,18 @@ void scanRfidTask(void * parameter) {
{
nfcReaderState = NFC_IDLE;
tagProcessed = false;
isBambuTag = false;
Serial.println("Tag nach erfolgreichem Lesen entfernt - bereit für nächsten Tag");
}
// Add a pause after successful reading to prevent immediate re-reading
if (nfcReaderState == NFC_READ_SUCCESS) {
Serial.println("Tag erfolgreich gelesen - warte 3 Sekunden vor nächstem Scan");
vTaskDelay(pdMS_TO_TICKS(3000));
// Reduced from 5 seconds to 3 seconds
// After tag is processed, slow down scanning to give API time
Serial.println("Tag processed - slowing scan to 2 seconds");
vTaskDelay(pdMS_TO_TICKS(2000));
} else {
// Faster scanning when no tag or idle state
vTaskDelay(pdMS_TO_TICKS(250));
// Faster scan interval
vTaskDelay(pdMS_TO_TICKS(500));
}
// aktualisieren der Website wenn sich der Status ändert
@@ -2072,14 +2216,14 @@ void scanRfidTask(void * parameter) {
void startNfc() {
nfcRequestMutex = xSemaphoreCreateMutex();
oledShowProgressBar(5, 7, DISPLAY_BOOT_TEXT, "NFC init");
oledShowProgressBar(5, 7, DISPLAY_BOOT_TEXT, tr(STR_NFC_INIT));
nfc.begin(); // Beginne Kommunikation mit RFID Leser
delay(1000);
unsigned long versiondata = nfc.getFirmwareVersion(); // Lese Versionsnummer der Firmware aus
if (! versiondata) { // Wenn keine Antwort kommt
Serial.println("Kann kein RFID Board finden !"); // Sende Text "Kann kein..." an seriellen Monitor
oledDisplayText("No RFID Board found");
oledDisplayText(tr(STR_NO_RFID_BOARD));
vTaskDelay(pdMS_TO_TICKS(2000));
}
else {
+5 -4
View File
@@ -11,7 +11,9 @@ typedef enum{
NFC_READ_ERROR,
NFC_WRITING,
NFC_WRITE_SUCCESS,
NFC_WRITE_ERROR
NFC_WRITE_ERROR,
NFC_BAMBU_DETECTED,
NFC_BAMBU_ERROR
} nfcReaderStateType;
struct NfcWriteParameterType {
@@ -35,7 +37,6 @@ extern String lastSpoolId;
extern volatile nfcReaderStateType nfcReaderState;
extern volatile bool nfcWriteInProgress;
extern bool tagProcessed;
extern bool isBambuTag;
#endif
#endif
+2 -1
View File
@@ -3,6 +3,7 @@
#include <commonFS.h>
#include "scale.h"
#include "nfc.h"
#include "lang.h"
// Globale Variablen für Config Backups hinzufügen
@@ -178,7 +179,7 @@ void handleUpdate(AsyncWebServer &server) {
static int lastProgress = -1;
if (currentProgress != lastProgress && (currentProgress % 10 == 0 || final)) {
sendUpdateProgress(currentProgress, "uploading");
oledShowProgressBar(currentProgress, 100, "Update", "Download");
oledShowProgressBar(currentProgress, 100, tr(STR_UPDATE), tr(STR_DOWNLOAD));
vTaskDelay(pdMS_TO_TICKS(50));
lastProgress = currentProgress;
}
+9 -8
View File
@@ -7,6 +7,7 @@
#include "display.h"
#include "esp_task_wdt.h"
#include <Preferences.h>
#include "lang.h"
HX711 scale;
@@ -169,7 +170,7 @@ void scale_loop(void * parameter) {
if (scaleTareRequest == true || (autoTare && scale_tare_counter >= 20))
{
Serial.println("Re-Tare scale");
oledDisplayText("TARE Scale");
oledDisplayText(tr(STR_TARE_SCALE));
vTaskDelay(pdMS_TO_TICKS(1000));
scale.tare();
resetWeightFilter(); // Reset filter after manual tare
@@ -250,7 +251,7 @@ void start_scale(bool touchSensorConnected) {
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
oledShowProgressBar(6, 7, DISPLAY_BOOT_TEXT, "Serching scale");
oledShowProgressBar(6, 7, DISPLAY_BOOT_TEXT, tr(STR_SEARCHING_SCALE));
for (uint16_t i = 0; i < 3000; i++) {
yield();
vTaskDelay(pdMS_TO_TICKS(1));
@@ -303,7 +304,7 @@ uint8_t calibrate_scale() {
{
scale.set_scale();
oledShowProgressBar(0, 3, "Scale Cal.", "Empty Scale");
oledShowProgressBar(0, 3, tr(STR_SCALE_CAL), tr(STR_EMPTY_SCALE));
for (uint16_t i = 0; i < 5000; i++) {
yield();
@@ -315,7 +316,7 @@ uint8_t calibrate_scale() {
Serial.println("Tare done...");
Serial.print("Place a known weight on the scale...");
oledShowProgressBar(1, 3, "Scale Cal.", "Place the weight");
oledShowProgressBar(1, 3, tr(STR_SCALE_CAL), tr(STR_PLACE_WEIGHT));
for (uint16_t i = 0; i < 5000; i++) {
yield();
@@ -348,7 +349,7 @@ uint8_t calibrate_scale() {
Serial.print("Verified stored value: ");
Serial.println(verifyValue);
oledShowProgressBar(2, 3, "Scale Cal.", "Remove weight");
oledShowProgressBar(2, 3, tr(STR_SCALE_CAL), tr(STR_REMOVE_WEIGHT));
scale.set_scale(newCalibrationValue);
resetWeightFilter(); // Reset filter after calibration
@@ -358,7 +359,7 @@ uint8_t calibrate_scale() {
esp_task_wdt_reset();
}
oledShowProgressBar(3, 3, "Scale Cal.", "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
//scale.tare();
@@ -377,7 +378,7 @@ uint8_t calibrate_scale() {
{
Serial.println("Calibration value is invalid. Please recalibrate.");
oledShowProgressBar(3, 3, "Failure", "Calibration error");
oledShowProgressBar(3, 3, tr(STR_FAILURE), tr(STR_CALIBRATION_ERROR));
for (uint16_t i = 0; i < 50000; i++) {
yield();
@@ -391,7 +392,7 @@ uint8_t calibrate_scale() {
{
Serial.println("HX711 not found.");
oledDisplayText("HX711 not found");
oledDisplayText(tr(STR_HX711_NOT_FOUND));
for (uint16_t i = 0; i < 30000; i++) {
yield();
+30 -1
View File
@@ -11,6 +11,7 @@
#include "ota.h"
#include "config.h"
#include "debug.h"
#include "lang.h"
#ifndef VERSION
#define VERSION "1.2.0"
@@ -113,7 +114,7 @@ void sendNfcData() {
}
void setupWebserver(AsyncWebServer &server) {
oledShowProgressBar(2, 7, DISPLAY_BOOT_TEXT, "Webserver init");
oledShowProgressBar(2, 7, DISPLAY_BOOT_TEXT, tr(STR_WEBSERVER_INIT));
ws.onEvent(onWsEvent);
server.addHandler(&ws);
@@ -240,6 +241,34 @@ void setupWebserver(AsyncWebServer &server) {
request->send(200, "application/json", "{\"version\": \"" VERSION "\"}");
});
// Language API
server.on("/api/language", HTTP_GET, [](AsyncWebServerRequest *request){
JsonDocument doc;
doc["lang"] = getLangCode();
String response;
serializeJson(doc, response);
request->send(200, "application/json", response);
});
server.on("/api/language", HTTP_POST, [](AsyncWebServerRequest *request){}, NULL, [](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){
JsonDocument doc;
DeserializationError error = deserializeJson(doc, (const uint8_t*)data, len);
if (error) {
request->send(400, "application/json", "{\"success\": false, \"error\": \"Invalid JSON\"}");
return;
}
String lang = doc["lang"] | "";
if (lang == "de") {
saveLanguage(LANG_DE);
} else if (lang == "en") {
saveLanguage(LANG_EN);
} else {
request->send(400, "application/json", "{\"success\": false, \"error\": \"Invalid language\"}");
return;
}
request->send(200, "application/json", "{\"success\": true}");
});
server.on("/reboot", HTTP_GET, [](AsyncWebServerRequest *request){
request->send(200, "text/plain", "Rebooting...");
delay(500);
+35 -38
View File
@@ -6,23 +6,24 @@
#include <DNSServer.h>
#include "display.h"
#include "config.h"
#include "lang.h"
WiFiManager wm;
bool wm_nonblocking = false;
uint8_t wifiErrorCounter = 0;
void wifiSettings() {
// Optimierte WiFi-Einstellungen
WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
WiFi.setSleep(false); // disable sleep mode
// Standard WiFi-Einstellungen für höchste Stabilität mit ESPAsyncWebServer
WiFi.mode(WIFI_STA);
WiFi.setHostname("FilaMan");
esp_wifi_set_ps(WIFI_PS_NONE);
// Maximale Sendeleistung
WiFi.setTxPower(WIFI_POWER_19_5dBm); // Set maximum transmit power
// Wir lassen das Power Management (Sleep) auf dem ESP-Standard.
// Ein erzwungenes Ausschalten führt zu RF-Abstürzen bei vielen asynchronen HTTP-Requests.
// Angemessene Sendeleistung (reduziert Hitzeprobleme)
WiFi.setTxPower(WIFI_POWER_17dBm); // Set stable transmit power (default is 19.5 which gets hot)
// Optimiere TCP/IP Stack
esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N);
// Wir überlassen die Protokoll-Aushandlung (b/g/n) dem Treiber. Harte Vorgaben crashen unter Last.
// Aktiviere WiFi-Roaming für bessere Stabilität
esp_wifi_set_rssi_threshold(-80);
@@ -31,7 +32,7 @@ void wifiSettings() {
void configModeCallback (WiFiManager *myWiFiManager) {
Serial.println("Entered config mode");
oledShowTopRow();
oledDisplayText("WiFi Config Mode");
oledDisplayText(tr(STR_WIFI_CONFIG_MODE));
}
void initWiFi() {
@@ -50,14 +51,14 @@ void initWiFi() {
wm.setWiFiAutoReconnect(true);
wm.setConnectTimeout(10);
oledShowProgressBar(1, 7, DISPLAY_BOOT_TEXT, "WiFi init");
oledShowProgressBar(1, 7, DISPLAY_BOOT_TEXT, tr(STR_WIFI_INIT));
//bool res = wm.autoConnect("FilaMan"); // anonymous ap
if(!wm.autoConnect("FilaMan")) {
Serial.println("Failed to connect or hit timeout");
// ESP.restart();
oledShowTopRow();
oledDisplayText("WiFi not connected Check Portal");
oledDisplayText(tr(STR_WIFI_NOT_CONNECTED));
}
else {
wifiOn = true;
@@ -74,37 +75,33 @@ void initWiFi() {
void checkWiFiConnection() {
if (WiFi.status() != WL_CONNECTED)
{
Serial.println("WiFi connection lost. Reconnecting...");
wifiOn = false;
oledShowTopRow();
oledDisplayText("WiFi reconnecting");
WiFi.reconnect(); // Versuche, die Verbindung wiederherzustellen
vTaskDelay(pdMS_TO_TICKS(5000)); // Warte 5 Sekunden, bevor erneut geprüft wird
if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Failed to reconnect. Restarting WiFi...");
WiFi.disconnect();
Serial.println("WiFi disconnected.");
vTaskDelay(pdMS_TO_TICKS(1000));
wifiErrorCounter++;
if (wifiOn) {
Serial.println("WiFi connection lost. LwIP is auto-reconnecting...");
wifiOn = false;
oledShowTopRow();
oledDisplayText(tr(STR_WIFI_RECONNECTING));
}
wifiErrorCounter++;
//wifiSettings();
WiFi.reconnect();
Serial.println("WiFi reconnecting...");
WiFi.waitForConnectResult();
}
else
// 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
if (wifiErrorCounter >= 5)
{
Serial.println("WiFi reconnected.");
wifiErrorCounter = 0;
wifiOn = true;
oledShowTopRow();
Serial.println("WiFi unable to reconnect for 5 minutes. Restarting...");
ESP.restart();
}
}
if (wifiErrorCounter >= 5)
else
{
Serial.println("Too many WiFi errors. Restarting...");
ESP.restart();
if (!wifiOn) {
Serial.println("WiFi reconnected.");
wifiErrorCounter = 0;
wifiOn = true;
oledShowTopRow();
} else {
// Reset error counter if we are connected (just to be safe)
wifiErrorCounter = 0;
}
}
}