tasmota-webserial-esptool 6.4.0 → 6.5.0

package/.github/workflows/build_upload.yml

@@ -12,8 +12,11 @@ concurrency:
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write  # required to use OIDC
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Remove old files and folders
         run: |
           rm -rf package-lock.json
@@ -21,7 +24,7 @@ jobs:
           rm -rf js/modules
           mkdir js/modules
       - name: install node v20
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: 20
       - name: Install Yarn with NPM
@@ -40,11 +43,11 @@ jobs:
           mv js/modules/index.js js/modules/esptool.js
           #ls js/modules/
       - name: Commit Distribution Files
-        uses: stefanzweifel/git-auto-commit-action@v5
+        uses: stefanzweifel/git-auto-commit-action@v7
         with:
           commit_message: "Github Action: Updated dist files"
       - name: Publish to NPM registry
-        uses: JS-DevTools/npm-publish@v3
+        uses: JS-DevTools/npm-publish@v4
         with:
           registry: https://registry.npmjs.org/
           token: ${{ secrets.NPM_TOKEN }}
@@ -52,7 +55,7 @@ jobs:
       - name: Setup Pages
         uses: actions/configure-pages@v5
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v4
         with:
           path: "."
 

package/.github/workflows/ci.yml

@@ -12,9 +12,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Use Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: 20
       - name: Remove old package-lock.json
@@ -25,6 +25,6 @@ jobs:
       - run: script/build
       - run: npm exec -- prettier --check src
       - name: Commit changed files
-        uses: stefanzweifel/git-auto-commit-action@v5
+        uses: stefanzweifel/git-auto-commit-action@v7
         with:
           commit_message: "Github Action: Updated files"

package/CHANGELOG_CHIP_VARIANT.md

@@ -0,0 +1,169 @@
+# Changelog: Chip Variant Support
+
+## Änderungen in WebSerial_ESPTool
+
+### Neue Features
+
+#### 1. `chipVariant` Feld in ESPLoader
+- Neues öffentliches Feld: `chipVariant: string | null`
+- Wird automatisch bei der Chip-Erkennung gesetzt
+- Für ESP32-P4: `"rev0"` (Revision < 300) oder `"rev300"` (Revision >= 300)
+- Für alle anderen Chips: `null`
+
+#### 2. Erweiterte ESP32-P4 Erkennung
+- Revision wird aus eFuses gelesen (EFUSE_BLOCK1)
+- Funktioniert sowohl bei IMAGE_CHIP_ID als auch Magic Value Erkennung
+- Logging der erkannten Variante im Debug-Modus
+
+### Geänderte Dateien
+
+- `src/esp_loader.ts`:
+  - Hinzugefügt: `chipVariant: string | null` Feld
+  - Erweitert: `detectChip()` Methode setzt chipVariant für ESP32-P4
+  - Erweitert: Logging für bessere Nachvollziehbarkeit
+
+### API-Änderungen
+
+```typescript
+// Vorher
+const esploader = new ESPLoader(port, logger);
+await esploader.initialize();
+console.log(esploader.chipName);      // "ESP32-P4"
+console.log(esploader.chipRevision);  // 300
+
+// Nachher (zusätzlich)
+console.log(esploader.chipVariant);   // "rev300"
+```
+
+### Abwärtskompatibilität
+
+✅ Vollständig abwärtskompatibel
+- Bestehendes Code funktioniert unverändert
+- Neues Feld ist optional und kann ignoriert werden
+- Keine Breaking Changes
+
+## Änderungen in esp-web-tools
+
+### Neue Features
+
+#### 1. `chipVariant` Support in Manifesten
+- Neues optionales Feld in `Build` Interface: `chipVariant?: string`
+- Ermöglicht spezifische Firmware-Builds für verschiedene Chip-Varianten
+- Intelligente Matching-Logik mit Fallback-Unterstützung
+
+#### 2. Erweiterte Build-Auswahl
+- Priorisiert Builds mit passendem `chipVariant`
+- Fallback auf Builds ohne `chipVariant` Angabe
+- Bessere Fehlermeldungen mit Varianten-Information
+
+### Geänderte Dateien
+
+- `src/const.ts`:
+  - Erweitert: `Build` Interface mit `chipVariant?: string`
+  - Erweitert: `BaseFlashState` Interface mit `chipVariant?: string | null`
+
+- `src/flash.ts`:
+  - Erweitert: Build-Matching-Logik berücksichtigt chipVariant
+  - Erweitert: Fehlermeldungen zeigen chipVariant an
+  - Erweitert: Initialisierungsmeldung zeigt chipVariant an
+
+- `README.md`:
+  - Hinzugefügt: Dokumentation für Chip Variant Support
+  - Hinzugefügt: Beispiel für P4-Varianten
+
+### Manifest-Beispiel
+
+```json
+{
+  "name": "My Firmware",
+  "version": "1.0.0",
+  "builds": [
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev0",
+      "parts": [...]
+    },
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev300",
+      "parts": [...]
+    }
+  ]
+}
+```
+
+### Abwärtskompatibilität
+
+✅ Vollständig abwärtskompatibel
+- Bestehende Manifeste ohne `chipVariant` funktionieren weiterhin
+- `chipVariant` ist optional
+- Keine Breaking Changes
+
+## Testing
+
+### Build-Tests
+- ✅ WebSerial_ESPTool kompiliert erfolgreich
+- ✅ esp-web-tools kompiliert erfolgreich
+- ✅ Keine TypeScript-Fehler
+- ✅ Keine Linting-Fehler
+
+### Funktionale Tests (empfohlen)
+- [ ] Test mit ESP32-P4 Rev. 0 Hardware
+- [ ] Test mit ESP32-P4 Rev. 300 Hardware
+- [ ] Test mit Manifest mit chipVariant
+- [ ] Test mit Manifest ohne chipVariant (Fallback)
+- [ ] Test mit anderen ESP32-Chips (sollte chipVariant = null sein)
+
+## Deployment
+
+### WebSerial_ESPTool
+1. Version in `package.json` erhöhen
+2. `npm run prepublishOnly` ausführen
+3. `npm publish` ausführen
+
+### esp-web-tools
+1. Warten bis neue WebSerial_ESPTool Version verfügbar ist
+2. `package.json` aktualisieren: `"tasmota-webserial-esptool": "^6.5.0"` (oder höher)
+3. Version in `package.json` erhöhen
+4. `npm install`
+5. `npm run prepublishOnly` ausführen
+6. `npm publish` ausführen
+
+## Dokumentation
+
+- ✅ `CHIP_VARIANT_SUPPORT.md` - Vollständige technische Dokumentation
+- ✅ `manifest-example-p4-variants.json` - Beispiel-Manifest
+- ✅ `README.md` (esp-web-tools) - Kurze Anleitung
+- ✅ `CHANGELOG_CHIP_VARIANT.md` - Diese Datei
+
+## Verwendungsbeispiele
+
+### Szenario 1: Separate Builds für jede Variante
+```json
+{
+  "builds": [
+    { "chipFamily": "ESP32-P4", "chipVariant": "rev0", "parts": [...] },
+    { "chipFamily": "ESP32-P4", "chipVariant": "rev300", "parts": [...] }
+  ]
+}
+```
+
+### Szenario 2: Ein Build für alle Varianten
+```json
+{
+  "builds": [
+    { "chipFamily": "ESP32-P4", "parts": [...] }
+  ]
+}
+```
+
+### Szenario 3: Spezifischer Build + Fallback
+```json
+{
+  "builds": [
+    { "chipFamily": "ESP32-P4", "chipVariant": "rev300", "parts": [...] },
+    { "chipFamily": "ESP32-P4", "parts": [...] }
+  ]
+}
+```
+Rev300 verwendet ersten Build, Rev0 verwendet zweiten Build (Fallback).

package/CHIP_VARIANT_SUPPORT.md

@@ -0,0 +1,170 @@
+# ESP32-P4 Chip Variant Support
+
+## Übersicht
+
+Die beiden Projekte unterstützen jetzt die Unterscheidung zwischen verschiedenen ESP32-P4 Varianten über das neue `chipVariant` Feld.
+
+## WebSerial_ESPTool
+
+### Änderungen
+
+Das `ESPLoader` Objekt hat jetzt ein neues Feld:
+- `chipVariant: string | null` - Identifiziert die Chip-Variante
+
+### ESP32-P4 Varianten
+
+Für ESP32-P4 Chips werden folgende Varianten erkannt:
+- `"rev0"` - ESP32-P4 Revision < 300 (ältere Versionen)
+- `"rev300"` - ESP32-P4 Revision >= 300 (neuere Versionen)
+
+Die Erkennung erfolgt automatisch basierend auf der Chip-Revision, die aus den eFuses gelesen wird.
+
+### Beispiel
+
+```typescript
+const esploader = new ESPLoader(port, logger);
+await esploader.initialize();
+
+console.log(esploader.chipName);      // "ESP32-P4"
+console.log(esploader.chipFamily);    // CHIP_FAMILY_ESP32P4
+console.log(esploader.chipRevision);  // z.B. 0 oder 300
+console.log(esploader.chipVariant);   // "rev0" oder "rev300"
+```
+
+## esp-web-tools
+
+### Änderungen
+
+#### Manifest Format
+
+Das `Build` Interface unterstützt jetzt ein optionales `chipVariant` Feld:
+
+```typescript
+interface Build {
+  chipFamily: "ESP32-P4" | ...;
+  chipVariant?: string;  // NEU
+  parts: { path: string; offset: number; }[];
+}
+```
+
+#### Flash State
+
+Der `FlashState` enthält jetzt auch die `chipVariant` Information:
+
+```typescript
+interface BaseFlashState {
+  chipFamily?: "ESP32-P4" | ...;
+  chipVariant?: string | null;  // NEU
+  // ...
+}
+```
+
+### Manifest Beispiel
+
+Hier ist ein Beispiel-Manifest, das verschiedene Firmware-Builds für die zwei P4-Varianten bereitstellt:
+
+```json
+{
+  "name": "My ESP32-P4 Firmware",
+  "version": "1.0.0",
+  "builds": [
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev0",
+      "parts": [
+        { "path": "bootloader_rev0.bin", "offset": 0 },
+        { "path": "partition-table.bin", "offset": 32768 },
+        { "path": "firmware_rev0.bin", "offset": 65536 }
+      ]
+    },
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev300",
+      "parts": [
+        { "path": "bootloader_rev300.bin", "offset": 0 },
+        { "path": "partition-table.bin", "offset": 32768 },
+        { "path": "firmware_rev300.bin", "offset": 65536 }
+      ]
+    },
+    {
+      "chipFamily": "ESP32-S3",
+      "parts": [
+        { "path": "bootloader_s3.bin", "offset": 0 },
+        { "path": "partition-table.bin", "offset": 32768 },
+        { "path": "firmware_s3.bin", "offset": 65536 }
+      ]
+    }
+  ]
+}
+```
+
+### Matching-Logik
+
+Die Firmware-Auswahl funktioniert wie folgt:
+
+1. **Wenn `chipVariant` im Build angegeben ist**: Der Build wird nur verwendet, wenn sowohl `chipFamily` als auch `chipVariant` übereinstimmen.
+
+2. **Wenn `chipVariant` im Build NICHT angegeben ist**: Der Build wird für alle Varianten dieser `chipFamily` verwendet (Fallback).
+
+#### Beispiele
+
+**Szenario 1: Spezifische Builds für jede Variante**
+```json
+{
+  "builds": [
+    { "chipFamily": "ESP32-P4", "chipVariant": "rev0", "parts": [...] },
+    { "chipFamily": "ESP32-P4", "chipVariant": "rev300", "parts": [...] }
+  ]
+}
+```
+- ESP32-P4 rev0 → verwendet ersten Build
+- ESP32-P4 rev300 → verwendet zweiten Build
+
+**Szenario 2: Ein Build für alle Varianten**
+```json
+{
+  "builds": [
+    { "chipFamily": "ESP32-P4", "parts": [...] }
+  ]
+}
+```
+- ESP32-P4 rev0 → verwendet den Build
+- ESP32-P4 rev300 → verwendet den Build
+
+**Szenario 3: Spezifischer Build + Fallback**
+```json
+{
+  "builds": [
+    { "chipFamily": "ESP32-P4", "chipVariant": "rev300", "parts": [...] },
+    { "chipFamily": "ESP32-P4", "parts": [...] }
+  ]
+}
+```
+- ESP32-P4 rev0 → verwendet zweiten Build (Fallback)
+- ESP32-P4 rev300 → verwendet ersten Build (spezifisch)
+
+## Abwärtskompatibilität
+
+Alle Änderungen sind vollständig abwärtskompatibel:
+
+- Bestehende Manifeste ohne `chipVariant` funktionieren weiterhin
+- Das `chipVariant` Feld ist optional
+- Für alle Chips außer ESP32-P4 ist `chipVariant` `null`
+
+## Technische Details
+
+### Chip-Erkennung
+
+Die ESP32-P4 Revision wird aus den eFuses gelesen (EFUSE_BLOCK1):
+- Minor Revision: Bits [3:0]
+- Major Revision: Bit [23] << 2 | Bits [5:4]
+- Revision = Major * 100 + Minor
+
+### Erkennungsmethoden
+
+ESP32-P4 kann auf zwei Arten erkannt werden:
+
+1. **IMAGE_CHIP_ID** (Rev. 300+): Verwendet `GET_SECURITY_INFO` Kommando
+2. **Magic Value** (Rev. < 300): Liest Magic-Wert aus Register
+
+In beiden Fällen wird die Revision gelesen und die entsprechende Variante gesetzt.

package/IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,232 @@
+# Implementation Summary: ESP32-P4 Chip Variant Support
+
+## ✅ Erfolgreich implementiert
+
+### Ziel
+Unterscheidung zwischen ESP32-P4 Revision 0 und Revision 300, damit esp-web-tools separate Manifeste für beide Varianten bereitstellen kann.
+
+## Implementierte Änderungen
+
+### 1. WebSerial_ESPTool
+
+**Datei: `src/esp_loader.ts`**
+
+#### Neues Feld:
+```typescript
+chipVariant: string | null = null;
+```
+
+#### Erweiterte Chip-Erkennung:
+- Bei IMAGE_CHIP_ID Erkennung (Rev. 300+):
+  - Revision wird aus eFuses gelesen
+  - `chipVariant` wird auf `"rev300"` oder `"rev0"` gesetzt
+  
+- Bei Magic Value Erkennung (Rev. < 300):
+  - Revision wird aus eFuses gelesen
+  - `chipVariant` wird auf `"rev300"` oder `"rev0"` gesetzt
+
+#### Revision-Berechnung:
+```typescript
+// Aus EFUSE_BLOCK1 (Word 2):
+const minorRev = word2 & 0x0f;
+const majorRev = (((word2 >> 23) & 1) << 2) | ((word2 >> 4) & 0x03);
+const revision = majorRev * 100 + minorRev;
+
+// Variante setzen:
+if (revision >= 300) {
+  chipVariant = "rev300";
+} else {
+  chipVariant = "rev0";
+}
+```
+
+### 2. esp-web-tools
+
+**Datei: `src/const.ts`**
+
+#### Erweitertes Build Interface:
+```typescript
+export interface Build {
+  chipFamily: "ESP32-P4" | ...;
+  chipVariant?: string;  // NEU - optional
+  parts: { path: string; offset: number; }[];
+}
+```
+
+#### Erweitertes FlashState Interface:
+```typescript
+export interface BaseFlashState {
+  chipFamily?: Build["chipFamily"] | "Unknown Chip";
+  chipVariant?: string | null;  // NEU
+  // ...
+}
+```
+
+**Datei: `src/flash.ts`**
+
+#### Erweiterte Build-Auswahl:
+```typescript
+build = manifest.builds.find((b) => {
+  // Match chipFamily
+  if (b.chipFamily !== chipFamily) {
+    return false;
+  }
+  // Wenn Build chipVariant spezifiziert, muss es matchen
+  if (b.chipVariant !== undefined) {
+    return b.chipVariant === chipVariant;
+  }
+  // Ohne chipVariant: Match für alle Varianten
+  return true;
+});
+```
+
+#### Verbesserte Meldungen:
+- Initialisierung zeigt chipVariant an
+- Fehlermeldungen enthalten chipVariant-Info
+
+**Datei: `README.md`**
+- Dokumentation für Chip Variant Support hinzugefügt
+- Beispiel für P4-Varianten
+
+## Verwendung
+
+### Manifest mit spezifischen Builds:
+```json
+{
+  "name": "My Firmware",
+  "version": "1.0.0",
+  "builds": [
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev0",
+      "parts": [
+        { "path": "firmware_p4_old.bin", "offset": 0 }
+      ]
+    },
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev300",
+      "parts": [
+        { "path": "firmware_p4_new.bin", "offset": 0 }
+      ]
+    }
+  ]
+}
+```
+
+### Manifest mit Fallback:
+```json
+{
+  "builds": [
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev300",
+      "parts": [...]
+    },
+    {
+      "chipFamily": "ESP32-P4",
+      "parts": [...]  // Fallback für rev0
+    }
+  ]
+}
+```
+
+## Build-Status
+
+✅ **WebSerial_ESPTool**: Kompiliert erfolgreich
+✅ **esp-web-tools**: Kompiliert erfolgreich
+✅ **TypeScript**: Keine Fehler
+✅ **Abwärtskompatibilität**: Vollständig gewährleistet
+
+## Nächste Schritte
+
+### Für Deployment:
+
+1. **WebSerial_ESPTool**:
+   ```bash
+   cd WebSerial_ESPTool
+   # Version in package.json erhöhen (z.B. 6.5.0)
+   npm run prepublishOnly
+   npm publish
+   ```
+
+2. **esp-web-tools**:
+   ```bash
+   cd esp-web-tools
+   # package.json aktualisieren: "tasmota-webserial-esptool": "^6.5.0"
+   npm install
+   # Version in package.json erhöhen (z.B. 8.2.0)
+   npm run prepublishOnly
+   npm publish
+   ```
+
+### Für Testing:
+
+1. **Hardware-Tests**:
+   - Test mit ESP32-P4 Rev. 0 Hardware
+   - Test mit ESP32-P4 Rev. 300 Hardware
+   - Verifizierung der korrekten Varianten-Erkennung
+
+2. **Manifest-Tests**:
+   - Test mit chipVariant-spezifischen Builds
+   - Test mit Fallback-Builds
+   - Test mit gemischten Manifesten
+
+## Dokumentation
+
+Erstellt:
+- ✅ `CHIP_VARIANT_SUPPORT.md` - Vollständige technische Dokumentation
+- ✅ `CHANGELOG_CHIP_VARIANT.md` - Detaillierte Änderungsliste
+- ✅ `IMPLEMENTATION_SUMMARY.md` - Diese Datei
+- ✅ `manifest-example-p4-variants.json` - Beispiel-Manifest
+- ✅ README.md Update in esp-web-tools
+
+## Technische Details
+
+### Chip-Erkennung Flow:
+
+```
+1. ESPLoader.initialize()
+   ↓
+2. detectChip()
+   ↓
+3a. Versuche GET_SECURITY_INFO (IMAGE_CHIP_ID)
+    → Erfolg: chipId = 18 (ESP32-P4)
+    → getChipRevision() → chipVariant setzen
+    
+3b. Fallback: Magic Value Detection
+    → chipMagicValue = 0x0, 0x7039ad9, oder 0x0addbad0
+    → getChipRevision() → chipVariant setzen
+    
+4. chipVariant ist nun "rev0" oder "rev300"
+```
+
+### Manifest Matching Flow:
+
+```
+1. Chip erkannt: chipFamily = "ESP32-P4", chipVariant = "rev300"
+   ↓
+2. Durchsuche manifest.builds[]
+   ↓
+3. Für jeden Build:
+   - chipFamily muss matchen
+   - Wenn Build.chipVariant definiert: muss exakt matchen
+   - Wenn Build.chipVariant undefined: immer Match
+   ↓
+4. Ersten passenden Build verwenden
+```
+
+## Vorteile
+
+1. **Flexibilität**: Manifeste können spezifische oder generische Builds anbieten
+2. **Abwärtskompatibilität**: Bestehende Manifeste funktionieren unverändert
+3. **Zukunftssicher**: Erweiterbar für weitere Chip-Varianten
+4. **Transparent**: Variante wird dem Benutzer angezeigt
+5. **Robust**: Fallback-Mechanismus verhindert Fehler
+
+## Getestet
+
+- ✅ TypeScript Kompilierung
+- ✅ Build-Prozess
+- ✅ Keine Diagnostics-Fehler
+- ⏳ Hardware-Tests (ausstehend)

package/css/style.css

@@ -195,6 +195,7 @@ div.clear {
   display: inline-block;
   position: relative;
   width: 50px;
+  margin-right: 25px;
   -webkit-user-select: none;
   -moz-user-select: none;
   -ms-user-select: none;

package/dist/const.d.ts

@@ -146,6 +146,7 @@ export declare const ESP32H2_UART_DATE_REG_ADDR = 1610612860;
 export declare const ESP32H2_BOOTLOADER_FLASH_OFFSET = 0;
 export declare const ESP32P4_SPI_REG_BASE = 1342754816;
 export declare const ESP32P4_BASEFUSEADDR = 1343410176;
+export declare const ESP32P4_EFUSE_BLOCK1_ADDR: number;
 export declare const ESP32P4_MACFUSEADDR: number;
 export declare const ESP32P4_SPI_USR_OFFS = 24;
 export declare const ESP32P4_SPI_USR1_OFFS = 28;
@@ -182,6 +183,13 @@ export declare const CHIP_FAMILY_ESP32C61 = 207969;
 export declare const CHIP_FAMILY_ESP32H2 = 12914;
 export declare const CHIP_FAMILY_ESP32P4 = 12928;
 export type ChipFamily = typeof CHIP_FAMILY_ESP8266 | typeof CHIP_FAMILY_ESP32 | typeof CHIP_FAMILY_ESP32S2 | typeof CHIP_FAMILY_ESP32S3 | typeof CHIP_FAMILY_ESP32C2 | typeof CHIP_FAMILY_ESP32C3 | typeof CHIP_FAMILY_ESP32C5 | typeof CHIP_FAMILY_ESP32C6 | typeof CHIP_FAMILY_ESP32C61 | typeof CHIP_FAMILY_ESP32H2 | typeof CHIP_FAMILY_ESP32P4;
+interface ChipIdInfo {
+    name: string;
+    family: ChipFamily;
+}
+export declare const CHIP_ID_TO_INFO: {
+    [chipId: number]: ChipIdInfo;
+};
 interface ChipInfo {
     [magicValue: number]: {
         name: string;
@@ -204,6 +212,7 @@ export declare const ESP_SPI_SET_PARAMS = 11;
 export declare const ESP_SPI_ATTACH = 13;
 export declare const ESP_CHANGE_BAUDRATE = 15;
 export declare const ESP_SPI_FLASH_MD5 = 19;
+export declare const ESP_GET_SECURITY_INFO = 20;
 export declare const ESP_CHECKSUM_MAGIC = 239;
 export declare const ESP_FLASH_DEFL_BEGIN = 16;
 export declare const ESP_FLASH_DEFL_DATA = 17;