fix: capitalize voltage unit 'v' to 'V' in VoltPlot y-axis label

Agent-Logs-Url: https://github.com/UtilitechAS/amsreader-firmware/sessions/742a66fe-8e10-467b-97c0-f54620131698

Co-authored-by: gskjold <4446828+gskjold@users.noreply.github.com>

.github/workflows/build.yml

@@ -27,6 +27,7 @@ jobs:
       run: |
         sed -i 's/NO_AMS2MQTT_PRICE_KEY/AMS2MQTT_PRICE_KEY="${{secrets.AMS2MQTT_PRICE_KEY}}"/g' platformio.ini
         sed -i 's/NO_AMS2MQTT_PRICE_AUTHENTICATION/AMS2MQTT_PRICE_AUTHENTICATION="${{secrets.AMS2MQTT_PRICE_AUTHENTICATION}}"/g' platformio.ini
+        sed -i 's/NO_AMS2MQTT_SC_KEY/AMS2MQTT_SC_KEY=\\"${{secrets.AMS2MQTT_SC_KEY}}\\"/g' platformio.ini
         sed -i 's/NO_ENERGY_SPEEDOMETER_USER/ENERGY_SPEEDOMETER_USER=\\"${{secrets.ENERGY_SPEEDOMETER_USER}}\\"/g' platformio.ini
         sed -i 's/NO_ENERGY_SPEEDOMETER_PASS/ENERGY_SPEEDOMETER_PASS=\\"${{secrets.ENERGY_SPEEDOMETER_PASS}}\\"/g' platformio.ini
     - name: Cache Python dependencies

.github/workflows/localazy.yml

@@ -38,4 +38,4 @@ jobs:
       run: localazy download -k localazy-keys.json
 
     - name: Upload translations to S3
-      run: aws s3 sync ./localazy/language/ s3://amscloud-private/language/
+      run: aws s3 sync ./localazy/language/ s3://${{ secrets.AWS_S3_BUCKET }}/language/

.github/workflows/pr-build-env.yml

@@ -0,0 +1,82 @@
+name: PR build with env
+
+on:
+  workflow_call:
+    inputs:
+      env:
+        description: 'The environment to build for'
+        required: true
+        type: string
+      is_esp32:
+        description: 'Whether the build is for ESP32 based firmware'
+        required: false
+        type: boolean
+        default: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code from repo
+        uses: actions/checkout@v4
+
+      - name: Cache Python dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('platformio.ini') }}
+
+      - name: Cache PlatformIO dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.pio/libdeps
+          key: ${{ runner.os }}-pio-${{ hashFiles('platformio.ini') }}
+
+      - name: Set up Python 3.9
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.9
+
+      - name: Inject secrets into ini file
+        run: |
+          sed -i 's/NO_AMS2MQTT_PRICE_KEY/AMS2MQTT_PRICE_KEY="${{secrets.AMS2MQTT_PRICE_KEY}}"/g' platformio.ini
+          sed -i 's/NO_AMS2MQTT_PRICE_AUTHENTICATION/AMS2MQTT_PRICE_AUTHENTICATION="${{secrets.AMS2MQTT_PRICE_AUTHENTICATION}}"/g' platformio.ini
+          sed -i 's/NO_AMS2MQTT_SC_KEY/AMS2MQTT_SC_KEY=\\"${{secrets.AMS2MQTT_SC_KEY}}\\"/g' platformio.ini
+          sed -i 's/NO_ENERGY_SPEEDOMETER_USER/ENERGY_SPEEDOMETER_USER=\\"${{secrets.ENERGY_SPEEDOMETER_USER}}\\"/g' platformio.ini
+          sed -i 's/NO_ENERGY_SPEEDOMETER_PASS/ENERGY_SPEEDOMETER_PASS=\\"${{secrets.ENERGY_SPEEDOMETER_PASS}}\\"/g' platformio.ini
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U platformio css_html_js_minify
+
+      - name: Set up node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '19.x'
+
+      - name: Build with node
+        run: |
+          cd lib/SvelteUi/app
+          npm ci
+          npm run build
+          cd -
+        env:
+          CI: false
+
+      - name: PlatformIO lib install
+        run: pio lib install
+
+      - name: Build firmware
+        run: pio run -e ${{ inputs.env }}
+
+      - name: Create zip file
+        run: /bin/sh scripts/${{ inputs.env }}/mkzip.sh
+
+      - name: Upload zip as artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ inputs.env }}.zip
+          path: ${{ inputs.env }}.zip
+          archive: false
+          retention-days: 7

.github/workflows/prerelease.yml

@@ -0,0 +1,85 @@
+name: Release candidate build and upload
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+-rc[0-9]+'
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out code from repo
+      uses: actions/checkout@v4
+    - name: Get release version for filenames
+      id: release_tag
+      env:
+        GITHUB_REF: ${{ github.ref }}
+      run: echo ::set-output name=tag::$(echo ${GITHUB_REF:11})
+
+    - name: Create release with release notes
+      id: create_release
+      uses: ncipollo/release-action@v1
+      with:
+        name: Release candidate v${{ steps.release_tag.outputs.tag }}
+        prerelease: true
+
+    outputs:
+      version: ${{ steps.release_tag.outputs.tag }}
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+
+  esp32s2:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32s2
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      subfolder: /rc
+  esp32s3:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32s3
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      subfolder: /rc
+  esp32c3:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32c3
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      subfolder: /rc
+  esp32:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      subfolder: /rc
+  esp32solo:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32solo
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      subfolder: /rc
+  esp8266:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp8266
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      subfolder: /rc
+      is_esp32: false

.github/workflows/pull-request.yml

@@ -0,0 +1,110 @@
+name: Pull Request build
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  build-esp32s2:
+    uses: ./.github/workflows/pr-build-env.yml
+    secrets: inherit
+    with:
+      env: esp32s2
+      is_esp32: true
+
+  build-esp32s3:
+    uses: ./.github/workflows/pr-build-env.yml
+    secrets: inherit
+    with:
+      env: esp32s3
+      is_esp32: true
+
+  build-esp32c3:
+    uses: ./.github/workflows/pr-build-env.yml
+    secrets: inherit
+    with:
+      env: esp32c3
+      is_esp32: true
+
+  build-esp32:
+    uses: ./.github/workflows/pr-build-env.yml
+    secrets: inherit
+    with:
+      env: esp32
+      is_esp32: true
+
+  build-esp32solo:
+    uses: ./.github/workflows/pr-build-env.yml
+    secrets: inherit
+    with:
+      env: esp32solo
+      is_esp32: true
+
+  build-esp8266:
+    uses: ./.github/workflows/pr-build-env.yml
+    secrets: inherit
+    with:
+      env: esp8266
+      is_esp32: false
+
+  comment:
+    needs:
+      - build-esp32s2
+      - build-esp32s3
+      - build-esp32c3
+      - build-esp32
+      - build-esp32solo
+      - build-esp8266
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Post PR comment with download links
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const prNumber = context.payload.pull_request.number;
+            const runId = context.runId;
+            const runUrl = `https://github.com/${owner}/${repo}/actions/runs/${runId}`;
+            
+            // Get the commit SHA (short version)
+            const sha = context.payload.pull_request.head.sha;
+            const shortSha = sha.substring(0, 7);
+
+            // Fetch the list of artifacts for this run via the API
+            const artifactsResp = await github.rest.actions.listWorkflowRunArtifacts({ owner, repo, run_id: runId });
+            const artifacts = artifactsResp.data.artifacts;
+
+            const envs = ['esp32s2', 'esp32s3', 'esp32c3', 'esp32', 'esp32solo', 'esp8266'];
+            const lines = envs.map(env => {
+              const artifact = artifacts.find(a => a.name === `${env}.zip`);
+              if (artifact) {
+                // The artifact download page URL - directly navigable in the browser
+                const artifactUrl = `${runUrl}#artifacts-${env}`;
+                return `- **${env}**: [Download ${env}.zip](https://github.com/${owner}/${repo}/actions/runs/${runId}/artifacts/${artifact.id})`;
+              }
+              return `- **${env}**: ⚠️ artifact not found`;
+            });
+
+            const body = [
+              '## 🔧 PR Build Artifacts',
+              '',
+              `**Version**: \`${shortSha}\``,
+              '',
+              'All environments built successfully. Download the zip files:',
+              '',
+              ...lines,
+              '',
+              `> Artifacts expire after 7 days. [View workflow run](${runUrl})`,
+            ].join('\n');
+
+            // Find and delete any previous bot comment to keep the PR clean
+            const comments = await github.rest.issues.listComments({ owner, repo, issue_number: prNumber });
+            for (const comment of comments.data) {
+              if (comment.user.type === 'Bot' && comment.body.includes('PR Build Artifacts')) {
+                await github.rest.issues.deleteComment({ owner, repo, comment_id: comment.id });
+              }
+            }
+
+            await github.rest.issues.createComment({ owner, repo, issue_number: prNumber, body });

.github/workflows/release-deploy-env.yml

@@ -0,0 +1,136 @@
+name: Build with env and deploy
+
+on:
+  workflow_call:
+    inputs:
+      env:
+        description: 'The environment to build for'
+        required: true
+        type: string
+      upload_url:
+        description: 'The upload URL for the release assets'
+        required: true
+        type: string
+      version:
+        description: 'The version tag for the release assets'
+        required: true
+        type: string
+      subfolder:
+        description: 'The subfolder in S3 to upload the binary to'
+        required: false
+        type: string
+        default: ''
+      is_esp32:
+        description: 'Whether the build is for ESP32 based firmware'
+        required: false
+        type: boolean
+        default: true
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out code from repo
+      uses: actions/checkout@v4
+
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v2
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: eu-north-1
+
+    - name: Cache Python dependencies
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('platformio.ini') }}
+
+    - name: Cache PlatformIO dependencies
+      uses: actions/cache@v4
+      with:
+        path: ~/.pio/libdeps
+        key: ${{ runner.os }}-pio-${{ hashFiles('platformio.ini') }}
+
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.9
+
+    - name: Inject secrets into ini file
+      run: |
+        sed -i 's/NO_AMS2MQTT_PRICE_KEY/AMS2MQTT_PRICE_KEY="${{secrets.AMS2MQTT_PRICE_KEY}}"/g' platformio.ini
+        sed -i 's/NO_AMS2MQTT_PRICE_AUTHENTICATION/AMS2MQTT_PRICE_AUTHENTICATION="${{secrets.AMS2MQTT_PRICE_AUTHENTICATION}}"/g' platformio.ini
+        sed -i 's/NO_AMS2MQTT_SC_KEY/AMS2MQTT_SC_KEY=\\"${{secrets.AMS2MQTT_SC_KEY}}\\"/g' platformio.ini
+        sed -i 's/NO_ENERGY_SPEEDOMETER_USER/ENERGY_SPEEDOMETER_USER=\\"${{secrets.ENERGY_SPEEDOMETER_USER}}\\"/g' platformio.ini
+        sed -i 's/NO_ENERGY_SPEEDOMETER_PASS/ENERGY_SPEEDOMETER_PASS=\\"${{secrets.ENERGY_SPEEDOMETER_PASS}}\\"/g' platformio.ini
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -U platformio css_html_js_minify
+
+    - name: Set up node
+      uses: actions/setup-node@v4
+      with:
+        node-version: '19.x'
+    - name: Build with node
+      run: |
+        cd lib/SvelteUi/app
+        npm ci
+        npm run build
+        cd -
+      env:
+        CI: false
+
+    - name: PlatformIO lib install
+      run: pio lib install
+
+    - name: Build firmware
+      env:
+        GITHUB_TAG: v${{ inputs.version }}
+      run: pio run -e ${{ inputs.env }}
+
+    - name: Create zip file
+      run: /bin/sh scripts/${{ inputs.env }}/mkzip.sh
+
+    - name: Upload binary to release
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ inputs.upload_url }}
+        asset_path: .pio/build/${{ inputs.env }}/firmware.bin
+        asset_name: ams2mqtt-${{ inputs.env }}-${{ inputs.version }}.bin
+        asset_content_type: application/octet-stream
+
+    - name: Upload zip to release
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ inputs.upload_url }}
+        asset_path: ${{ inputs.env }}.zip
+        asset_name: ams2mqtt-${{ inputs.env }}-${{ inputs.version }}.zip
+        asset_content_type: application/zip
+    
+    - name: Create MD5 checksum file
+      run: md5sum .pio/build/${{ inputs.env }}/firmware.bin | cut -z -d ' ' -f 1 > firmware.md5
+
+    - name: Upload binary to S3
+      run: aws s3 cp .pio/build/${{ inputs.env }}/firmware.bin s3://${{ secrets.AWS_S3_BUCKET }}/firmware${{ inputs.subfolder }}/ams2mqtt-${{ inputs.env }}-${{ inputs.version }}.bin
+
+    - name: Upload MD5 checksum to S3
+      run: aws s3 cp firmware.md5 s3://${{ secrets.AWS_S3_BUCKET }}/firmware${{ inputs.subfolder }}/ams2mqtt-${{ inputs.env }}-${{ inputs.version }}.md5
+
+    - name: Upload bootloader to S3
+      if: ${{ inputs.is_esp32 }}
+      run: aws s3 cp .pio/build/${{ inputs.env }}/bootloader.bin s3://${{ secrets.AWS_S3_BUCKET }}/firmware${{ inputs.subfolder }}/ams2mqtt-${{ inputs.env }}-${{ inputs.version }}-bootloader.bin
+    
+    - name: Upload partition table to S3
+      if: ${{ inputs.is_esp32 }}
+      run: aws s3 cp .pio/build/${{ inputs.env }}/partitions.bin s3://${{ secrets.AWS_S3_BUCKET }}/firmware${{ inputs.subfolder }}/ams2mqtt-${{ inputs.env }}-${{ inputs.version }}-partitions.bin
+
+    - name: Upload app0 to S3
+      if: ${{ inputs.is_esp32 }}
+      run: aws s3 cp ~/.platformio/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin s3://${{ secrets.AWS_S3_BUCKET }}/firmware${{ inputs.subfolder }}/ams2mqtt-${{ inputs.env }}-${{ inputs.version }}-app0.bin

.github/workflows/release.yml

@@ -1,213 +1,79 @@
-name: Release
+name: Release build and upload
 
 on:
   push:
     tags:
-      - 'v*.*.*'
-
+      - 'v[0-9]+.[0-9]+.[0-9]+'
 
 jobs:
-  build:
-
+  prepare:
     runs-on: ubuntu-latest
-
     steps:
-    - name: Check out code from repo
-      uses: actions/checkout@v4
-    - name: Get release version for filenames
-      id: release_tag
-      env:
-        GITHUB_REF: ${{ github.ref }}
-      run: echo ::set-output name=tag::$(echo ${GITHUB_REF:11})
-    - name: Get release version for code
-      env:
-        GITHUB_REF: ${{ github.ref }}
-      run: echo "GITHUB_TAG=$(echo ${GITHUB_REF##*/})" >> $GITHUB_ENV
+      - name: Check out code from repo
+        uses: actions/checkout@v4
+      - name: Get release version for filenames
+        id: release_tag
+        env:
+          GITHUB_REF: ${{ github.ref }}
+        run: echo ::set-output name=tag::$(echo ${GITHUB_REF:11})
 
-    - name: Inject secrets into ini file
-      run: |
-        sed -i 's/NO_AMS2MQTT_PRICE_KEY/AMS2MQTT_PRICE_KEY="${{secrets.AMS2MQTT_PRICE_KEY}}"/g' platformio.ini
-        sed -i 's/NO_AMS2MQTT_PRICE_AUTHENTICATION/AMS2MQTT_PRICE_AUTHENTICATION="${{secrets.AMS2MQTT_PRICE_AUTHENTICATION}}"/g' platformio.ini
-        sed -i 's/NO_AMS2MQTT_SC_KEY/AMS2MQTT_SC_KEY=\\"${{secrets.AMS2MQTT_SC_KEY}}\\"/g' platformio.ini
-        sed -i 's/NO_ENERGY_SPEEDOMETER_USER/ENERGY_SPEEDOMETER_USER=\\"${{secrets.ENERGY_SPEEDOMETER_USER}}\\"/g' platformio.ini
-        sed -i 's/NO_ENERGY_SPEEDOMETER_PASS/ENERGY_SPEEDOMETER_PASS=\\"${{secrets.ENERGY_SPEEDOMETER_PASS}}\\"/g' platformio.ini
+      - name: Create release with release notes
+        id: create_release
+        uses: ncipollo/release-action@v1
+        with:
+          name: Release v${{ steps.release_tag.outputs.tag }}
+          generateReleaseNotes: true
 
-    - name: Cache Python dependencies
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('platformio.ini') }}
-    - name: Cache PlatformIO dependencies
-      uses: actions/cache@v4
-      with:
-        path: ~/.pio/libdeps
-        key: ${{ runner.os }}-pio-${{ hashFiles('platformio.ini') }}
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v5
-      with:
-        python-version: 3.9
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -U platformio css_html_js_minify
+    outputs:
+      version: ${{ steps.release_tag.outputs.tag }}
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
 
-    - name: Set up node
-      uses: actions/setup-node@v4
-      with:
-        node-version: '19.x'
-    - name: Build with node
-      run: |
-        cd lib/SvelteUi/app
-        npm ci
-        npm run build
-        cd -
-      env:
-        CI: false
-
-    - name: PlatformIO lib install
-      run: pio lib install
-
-    - name: Create release with release notes
-      id: create_release
-      uses: ncipollo/release-action@v1
-      with:
-        name: Release v${{ steps.release_tag.outputs.tag }}
-        generateReleaseNotes: true
-
-    - name: Build esp8266 firmware
-      run: pio run -e esp8266
-    - name: Create esp8266 zip file
-      run: /bin/sh scripts/esp8266/mkzip.sh
-    - name: Upload esp8266 binary to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: .pio/build/esp8266/firmware.bin
-        asset_name: ams2mqtt-esp8266-${{ steps.release_tag.outputs.tag }}.bin
-        asset_content_type: application/octet-stream
-    - name: Upload esp8266 zip to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: esp8266.zip
-        asset_name: ams2mqtt-esp8266-${{ steps.release_tag.outputs.tag }}.zip
-        asset_content_type: application/zip
-
-    - name: Build esp32 firmware
-      run: pio run -e esp32
-    - name: Create esp32 zip file
-      run: /bin/sh scripts/esp32/mkzip.sh
-    - name: Upload esp32 binary to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: .pio/build/esp32/firmware.bin
-        asset_name: ams2mqtt-esp32-${{ steps.release_tag.outputs.tag }}.bin
-        asset_content_type: application/octet-stream
-    - name: Upload esp32 zip to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: esp32.zip
-        asset_name: ams2mqtt-esp32-${{ steps.release_tag.outputs.tag }}.zip
-        asset_content_type: application/zip
-
-    - name: Build esp32s2 firmware
-      run: pio run -e esp32s2
-    - name: Create esp32s2 zip file
-      run: /bin/sh scripts/esp32s2/mkzip.sh
-    - name: Upload esp32s2 binary to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: .pio/build/esp32s2/firmware.bin
-        asset_name: ams2mqtt-esp32s2-${{ steps.release_tag.outputs.tag }}.bin
-        asset_content_type: application/octet-stream
-    - name: Upload esp32s2 zip to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: esp32s2.zip
-        asset_name: ams2mqtt-esp32s2-${{ steps.release_tag.outputs.tag }}.zip
-        asset_content_type: application/zip
-
-    - name: Build esp32s3 firmware
-      run: pio run -e esp32s3
-    - name: Create esp32s3 zip file
-      run: /bin/sh scripts/esp32s3/mkzip.sh
-    - name: Upload esp32s3 binary to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: .pio/build/esp32s3/firmware.bin
-        asset_name: ams2mqtt-esp32s3-${{ steps.release_tag.outputs.tag }}.bin
-        asset_content_type: application/octet-stream
-    - name: Upload esp32s3 zip to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: esp32s3.zip
-        asset_name: ams2mqtt-esp32s3-${{ steps.release_tag.outputs.tag }}.zip
-        asset_content_type: application/zip
-
-    - name: Build esp32solo firmware
-      run: pio run -e esp32solo
-    - name: Create esp32solo zip file
-      run: /bin/sh scripts/esp32solo/mkzip.sh
-    - name: Upload esp32solo binary to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: .pio/build/esp32solo/firmware.bin
-        asset_name: ams2mqtt-esp32solo-${{ steps.release_tag.outputs.tag }}.bin
-        asset_content_type: application/octet-stream
-    - name: Upload esp32solo zip to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: esp32solo.zip
-        asset_name: ams2mqtt-esp32solo-${{ steps.release_tag.outputs.tag }}.zip
-        asset_content_type: application/zip
-
-    - name: Build esp32c3 firmware
-      run: pio run -e esp32c3
-    - name: Create esp32c3 zip file
-      run: /bin/sh scripts/esp32c3/mkzip.sh
-    - name: Upload esp32c3 binary to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: .pio/build/esp32c3/firmware.bin
-        asset_name: ams2mqtt-esp32c3-${{ steps.release_tag.outputs.tag }}.bin
-        asset_content_type: application/octet-stream
-    - name: Upload esp32c3 zip to release
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: esp32c3.zip
-        asset_name: ams2mqtt-esp32c3-${{ steps.release_tag.outputs.tag }}.zip
-        asset_content_type: application/zip
+  esp32s2:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32s2
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+  esp32s3:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32s3
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+  esp32c3:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32c3
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+  esp32:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+  esp32solo:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp32solo
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+  esp8266:
+    needs: prepare
+    uses: ./.github/workflows/release-deploy-env.yml
+    secrets: inherit
+    with:
+      env: esp8266
+      version: ${{ needs.prepare.outputs.version }}
+      upload_url: ${{ needs.prepare.outputs.upload_url }}
+      is_esp32: false

README.md

@@ -1,12 +1,15 @@
 # AMS Reader
 This code is designed to decode data from electric smart meters installed in many countries in Europe these days. The data is presented in a graphical web interface and can also send the data to a MQTT broker which makes it suitable for home automation project. Originally it was only designed to work with Norwegian meters, but has since been adapter to read any IEC-62056-7-5 or IEC-62056-21 compliant meters.
 
-Later development have added Energy usage graph for both day and month, as well as future energy price. The code can run on any ESP8266 or ESP32 hardware which you can read more about in the [WiKi](https://github.com/UtilitechAS/amsreader-firmware/wiki). If you don't have the knowledge to set up a ESP device yourself, or you would like to support our work, please have a look at our shop at [amsleser.no](https://amsleser.no/).
+Later development have added Energy usage graph for both day and month, as well as future energy price. The code can run on any ESP8266 or ESP32 hardware which you can read more about in the [WiKi](https://github.com/UtilitechAS/amsreader-firmware/wiki). If you don't have the knowledge to set up a ESP device yourself, or you would like to support our work, please have a look at our shop at [amsleser.no](https://www.amsleser.no/).
 
 
 <img src="images/dashboard.png">
 
-Go to the [WiKi](https://github.com/UtilitechAS/amsreader-firmware/wiki) for information on how to get your own device! And find the latest prebuilt firmware file at the [release section](https://github.com/UtilitechAS/amsreader-firmware/releases).
+## Installing pre-built firmware
+If you have a device already running this firmware and you for some reason need to upgrade via USB port, you can use a [this web-based tool](https://www.amsleser.cloud/flasher)
+
+If you are using a development board and want to flash a pre-built firmware manually, get the necessary files from the [release](https://github.com/UtilitechAS/amsreader-firmware/releases) section and visit the [WiKi](https://github.com/UtilitechAS/amsreader-firmware/wiki) and have a look at the [Flashing](https://github.com/UtilitechAS/amsreader-firmware/wiki/flashinghttps://github.com/UtilitechAS/amsreader-firmware/wiki/flashing) section
 
 ## Building this project with PlatformIO
 To build this project, you need [PlatformIO](https://platformio.org/) installed.

frames/iskra_croatia.txt

@@ -0,0 +1,48 @@
+They actually use multiple frames, so this is a "fake" frame combining the two into one, but without checksum fields.
+
+7E 
+A0 BD 
+CF 02 23 03 00 00
+E6 E7 00 
+0F 00 03 46 3B 
+0C 07 E9 0C 13 05 17 37 28 00 FF C4 00
+
+02 21 
+09 08 39 32 30 32 39 36 39 31 
+09 04 17 37 28 00 
+09 05 07 E9 0C 13 05 
+06 00 6C 28 5A 
+06 00 4B 76 1A 
+06 00 20 B2 40 
+06 00 58 68 AA 
+06 00 57 A1 62 
+06 00 00 C7 48 
+06 00 17 EE D7 
+06 00 12 F5 5C 
+06 00 00 D9 6A 
+06 00 15 36 84 
+06 00 00 01 7E
+06 00 00 00 00 
+12 03 79 
+06 00 00 00 7F 
+06 00 00 00 BD 
+06 00 00 00 41 
+06 00 00 00 00 
+06 00 00 00 00 
+06 00 00 00 00 
+12 09 54 
+12 09 35 
+12 09 49 
+12 00 37 
+12 00 59 
+12 00 4D 
+06 00 00 43 62 
+01 01 
+  12 24 B8 
+01 01 
+  12 24 B8 
+01 01 
+  12 24 B8 
+03 01
+
+00 00 7E

lib/AmsConfiguration/include/AmsConfiguration.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -50,6 +50,22 @@
 #define LED_BEHAVIOUR_ERROR_ONLY 3
 #define LED_BEHAVIOUR_OFF 9
 
+#define FIRMWARE_CHANNEL_STABLE 0
+#define FIRMWARE_CHANNEL_EARLY 1
+#define FIRMWARE_CHANNEL_RC 2
+#define FIRMWARE_CHANNEL_SNAPSHOT 3
+
+#define REBOOT_CAUSE_WEB_SYSINFO_JSON 1
+#define REBOOT_CAUSE_WEB_SAVE 2
+#define REBOOT_CAUSE_WEB_REBOOT 3
+#define REBOOT_CAUSE_WEB_FACTORY_RESET 4
+#define REBOOT_CAUSE_BTN_FACTORY_RESET 5
+#define REBOOT_CAUSE_REPARTITION 6
+#define REBOOT_CAUSE_CONFIG_FILE_UPDATE 7
+#define REBOOT_CAUSE_FIRMWARE_UPDATE 8
+#define REBOOT_CAUSE_MQTT_DISCONNECTED 9
+#define REBOOT_CAUSE_SMART_CONFIG 10
+
 struct ResetDataContainer {
 	uint8_t cause;
 	uint8_t last_cause;
@@ -63,7 +79,8 @@ struct SystemConfig {
 	uint8_t dataCollectionConsent; // 0 = unknown, 1 = accepted, 2 = declined
 	char country[3];
 	uint8_t energyspeedometer;
-}; // 8
+	uint8_t firmwareChannel;
+}; // 9
 
 struct NetworkConfig {
 	char ssid[32];
@@ -97,7 +114,8 @@ struct MqttConfig {
 	uint16_t stateUpdateInterval;
 	uint16_t timeout;
 	uint8_t keepalive;
-}; // 685
+	uint8_t rebootMinutes;
+}; // 684
 
 struct WebConfig {
 	uint8_t security;
@@ -157,7 +175,8 @@ struct GpioConfig {
 	uint16_t vccResistorVcc;
 	uint8_t ledDisablePin;
 	uint8_t ledBehaviour;
-}; // 21
+	uint8_t powersaving;
+}; // 22
 
 struct GpioConfig103 {
 	uint8_t hanPin;
@@ -206,10 +225,12 @@ struct PriceServiceConfig {
 	char entsoeToken[37];
 	char area[17];
 	char currency[4];
-	uint32_t unused1;
-	bool enabled;
+	uint8_t resolutionInMinutes;
 	uint16_t unused2;
-}; // 64
+	uint16_t unused3;
+	bool enabled;
+	uint16_t unused6;
+};
 
 struct EnergyAccountingConfig {
 	uint16_t thresholds[10];
@@ -236,14 +257,14 @@ struct UiConfig {
 }; // 15
 
 struct UpgradeInformation {
-	char fromVersion[8];
-	char toVersion[8];
+	char fromVersion[16];
+	char toVersion[16];
     uint32_t size;
     uint16_t block_position;
     uint8_t retry_count;
     uint8_t reboot_count;
 	int8_t errorCode;
-}; // 25
+}; // 41+3
 
 struct CloudConfig {
 	bool enabled;
@@ -360,6 +381,8 @@ public:
 	bool isZmartChargeConfigChanged();
 	void ackZmartChargeConfig();
 	
+	uint32_t getChipId();
+	void getUniqueName(char* buffer, size_t length);
 
 	void clear();
 

lib/AmsConfiguration/include/AmsStorage.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsConfiguration/include/Timezones.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsConfiguration/include/hexutils.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsConfiguration/src/AmsConfiguration.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -13,19 +13,26 @@
 bool AmsConfiguration::getSystemConfig(SystemConfig& config) {
 	EEPROM.begin(EEPROM_SIZE);
 	uint8_t configVersion = EEPROM.read(EEPROM_CONFIG_ADDRESS);
+	EEPROM.get(CONFIG_SYSTEM_START, config);
+	EEPROM.end();
+
+	if(config.firmwareChannel > 3) {
+		config.firmwareChannel = 0;
+	}
+
 	if(configVersion == EEPROM_CHECK_SUM) {
-		EEPROM.get(CONFIG_SYSTEM_START, config);
-		EEPROM.end();
 		return true;
 	} else {
-		if(configVersion == EEPROM_CLEARED_INDICATOR) {
+		if(configVersion == EEPROM_CLEARED_INDICATOR && config.boardType > 0 && config.boardType < 250) {
 			config.vendorConfigured = true;
 		} else {
 			config.vendorConfigured = false;
 			config.boardType = 0xFF;
+			clear();
 		}
 		config.userConfigured = false;
 		config.dataCollectionConsent = 0;
+		config.firmwareChannel = 0;
 		config.energyspeedometer = 0;
 		memset(config.country, 0, 3);
 		return false;
@@ -41,6 +48,9 @@ bool AmsConfiguration::setSystemConfig(SystemConfig& config) {
 		sysChanged |= config.dataCollectionConsent != existing.dataCollectionConsent;
 		sysChanged |= strcmp(config.country, existing.country) != 0;
 		sysChanged |= config.energyspeedometer != existing.energyspeedometer;
+		sysChanged |= config.firmwareChannel != existing.firmwareChannel;
+	} else {
+		sysChanged = true;
 	}
 	EEPROM.begin(EEPROM_SIZE);
 	stripNonAscii((uint8_t*) config.country, 2);
@@ -114,16 +124,12 @@ void AmsConfiguration::clearNetworkConfig(NetworkConfig& config) {
 	memset(config.ssid, 0, 32);
 	memset(config.psk, 0, 64);
 	clearNetworkConfigIp(config);
-
-	uint16_t chipId;
+	getUniqueName(config.hostname, 32);
 	#if defined(ESP32)
-		chipId = ( ESP.getEfuseMac() >> 32 ) % 0xFFFFFFFF;
 		config.power = 195;
 	#else
-		chipId = ESP.getChipId();
 		config.power = 205;
 	#endif
-	strcpy(config.hostname, (String("ams-") + String(chipId, HEX)).c_str());
 	config.mdns = true;
 	config.sleep = 0xFF;
 	config.use11b = 1;
@@ -151,14 +157,17 @@ bool AmsConfiguration::getMqttConfig(MqttConfig& config) {
 		EEPROM.begin(EEPROM_SIZE);
 		EEPROM.get(CONFIG_MQTT_START, config);
 		EEPROM.end();
-		if(config.magic != 0x9C) {
-			if(config.magic != 0x7B) {
-				config.stateUpdate = false;
-				config.stateUpdateInterval = 10;
+		if(config.magic != 0xA5) { // New magic for 2.4.11
+			if(config.magic != 0x9C) {
+				if(config.magic != 0x7B) {
+					config.stateUpdate = false;
+					config.stateUpdateInterval = 10;
+				}
+				config.timeout = 1000;
+				config.keepalive = 60;
 			}
-			config.timeout = 1000;
-			config.keepalive = 60;
-			config.magic = 0x9C;
+			config.rebootMinutes = config.ssl ? 5 : 0;
+			config.magic = 0xA5;
 		}
 		return true;
 	} else {
@@ -181,6 +190,9 @@ bool AmsConfiguration::setMqttConfig(MqttConfig& config) {
 		mqttChanged |= config.ssl != existing.ssl;
 		mqttChanged |= config.stateUpdate != existing.stateUpdate;
 		mqttChanged |= config.stateUpdateInterval != existing.stateUpdateInterval;
+		mqttChanged |= config.timeout != existing.timeout;
+		mqttChanged |= config.keepalive != existing.keepalive;
+		mqttChanged |= config.rebootMinutes != existing.rebootMinutes;
 	} else {
 		mqttChanged = true;
 	}
@@ -195,6 +207,7 @@ bool AmsConfiguration::setMqttConfig(MqttConfig& config) {
 	if(config.timeout > 10000) config.timeout = 1000;
 	if(config.keepalive < 5) config.keepalive = 60;
 	if(config.keepalive > 240) config.keepalive = 60;
+	if(config.rebootMinutes > 240) config.rebootMinutes = 0;
 
 	EEPROM.begin(EEPROM_SIZE);
 	EEPROM.put(CONFIG_MQTT_START, config);
@@ -219,6 +232,7 @@ void AmsConfiguration::clearMqtt(MqttConfig& config) {
 	config.stateUpdateInterval = 10;
 	config.timeout = 1000;
 	config.keepalive = 60;
+	config.rebootMinutes = 0;
 }
 
 void AmsConfiguration::setMqttChanged() {
@@ -282,8 +296,9 @@ void AmsConfiguration::ackWebChange() {
 }
 
 bool AmsConfiguration::getMeterConfig(MeterConfig& config) {
-	if(hasConfig()) {
-		EEPROM.begin(EEPROM_SIZE);
+	EEPROM.begin(EEPROM_SIZE);
+	uint8_t configVersion = EEPROM.read(EEPROM_CONFIG_ADDRESS);
+	if(configVersion == EEPROM_CHECK_SUM || configVersion == EEPROM_CLEARED_INDICATOR) {
 		EEPROM.get(CONFIG_METER_START, config);
 		EEPROM.end();
 		if(config.bufferSize < 1 || config.bufferSize > 64) {
@@ -498,6 +513,7 @@ bool AmsConfiguration::getGpioConfig(GpioConfig& config) {
 	if(configVersion == EEPROM_CHECK_SUM || configVersion == EEPROM_CLEARED_INDICATOR) {
 		EEPROM.get(CONFIG_GPIO_START, config);
 		EEPROM.end();
+		if(config.powersaving > 4) config.powersaving = 0;
 		return true;
 	} else {
 		clearGpio(config);
@@ -579,6 +595,7 @@ void AmsConfiguration::clearGpio(GpioConfig& config, bool all) {
 		config.vccResistorGnd = 0;
 		config.vccResistorVcc = 0;
 		config.ledBehaviour = LED_BEHAVIOUR_DEFAULT;
+		config.powersaving = 0;
 	}
 }
 
@@ -645,6 +662,9 @@ bool AmsConfiguration::getPriceServiceConfig(PriceServiceConfig& config) {
 			clearPriceServiceConfig(config);
 			return false;
 		}
+		if(config.resolutionInMinutes != 15 && config.resolutionInMinutes != 60) {
+			config.resolutionInMinutes = 60;
+		}
 		return true;
 	} else {
 		clearPriceServiceConfig(config);
@@ -659,6 +679,7 @@ bool AmsConfiguration::setPriceServiceConfig(PriceServiceConfig& config) {
 		priceChanged |= strcmp(config.area, existing.area) != 0;
 		priceChanged |= strcmp(config.currency, existing.currency) != 0;
 		priceChanged |= config.enabled != existing.enabled;
+		priceChanged |= config.resolutionInMinutes != existing.resolutionInMinutes;
 	} else {
 		priceChanged = true;
 	}
@@ -678,9 +699,8 @@ void AmsConfiguration::clearPriceServiceConfig(PriceServiceConfig& config) {
 	memset(config.entsoeToken, 0, 37);
 	memset(config.area, 0, 17);
 	memset(config.currency, 0, 4);
-	config.unused1 = 1000;
 	config.enabled = false;
-	config.unused2 = 0;
+	config.resolutionInMinutes = 60;
 }
 
 bool AmsConfiguration::isPriceServiceChanged() {
@@ -808,8 +828,8 @@ void AmsConfiguration::ackUiLanguageChange() {
 }
 
 bool AmsConfiguration::setUpgradeInformation(UpgradeInformation& upinfo) {
-	stripNonAscii((uint8_t*) upinfo.fromVersion, 8);
-	stripNonAscii((uint8_t*) upinfo.toVersion, 8);
+	stripNonAscii((uint8_t*) upinfo.fromVersion, 16);
+	stripNonAscii((uint8_t*) upinfo.toVersion, 16);
 
 	EEPROM.begin(EEPROM_SIZE);
 	EEPROM.put(CONFIG_UPGRADE_INFO_START, upinfo);
@@ -823,7 +843,7 @@ bool AmsConfiguration::getUpgradeInformation(UpgradeInformation& upinfo) {
 		EEPROM.begin(EEPROM_SIZE);
 		EEPROM.get(CONFIG_UPGRADE_INFO_START, upinfo);
 		EEPROM.end();
-		if(stripNonAscii((uint8_t*) upinfo.fromVersion, 8) || stripNonAscii((uint8_t*) upinfo.toVersion, 8)) {
+		if(stripNonAscii((uint8_t*) upinfo.fromVersion, 16) || stripNonAscii((uint8_t*) upinfo.toVersion, 16)) {
 			clearUpgradeInformation(upinfo);
 			return false;
 		}
@@ -835,8 +855,8 @@ bool AmsConfiguration::getUpgradeInformation(UpgradeInformation& upinfo) {
 }
 
 void AmsConfiguration::clearUpgradeInformation(UpgradeInformation& upinfo) {
-	memset(upinfo.fromVersion, 0, 8);
-	memset(upinfo.toVersion, 0, 8);
+	memset(upinfo.fromVersion, 0, 16);
+	memset(upinfo.toVersion, 0, 16);
 	upinfo.errorCode = 0;
 	upinfo.size = 0;
 	upinfo.block_position = 0;
@@ -903,12 +923,12 @@ bool AmsConfiguration::getZmartChargeConfig(ZmartChargeConfig& config) {
 		EEPROM.end();
 		stripNonAscii((uint8_t*) config.token, 21);
 		stripNonAscii((uint8_t*) config.baseUrl, 64);
-		if(strlen(config.token) < 20) {
+		if(strlen(config.token) != 20 || !config.enabled) {
 			config.enabled = false;
 			memset(config.token, 0, 64);
 			memset(config.baseUrl, 0, 64);
 		}
-		if(strncmp_P(config.baseUrl, PSTR("https"), 5) != 0) {
+		if(strlen(config.baseUrl) == 0 || strncmp_P(config.baseUrl, PSTR("https"), 5) != 0) {
 			memset(config.baseUrl, 0, 64);
 	        snprintf_P(config.baseUrl, 64, PSTR("https://main.zmartcharge.com/api"));
 		}
@@ -923,8 +943,8 @@ bool AmsConfiguration::setZmartChargeConfig(ZmartChargeConfig& config) {
 	ZmartChargeConfig existing;
 	if(getZmartChargeConfig(existing)) {
 		zcChanged |= config.enabled != existing.enabled;
-		zcChanged |= memcmp(config.token, existing.token, 21) != 0;
-		zcChanged |= memcmp(config.token, existing.baseUrl, 64) != 0;
+		zcChanged |= strcmp(config.token, existing.token) != 0;
+		zcChanged |= strcmp(config.baseUrl, existing.baseUrl) != 0;
 	} else {
 		zcChanged = true;
 	}
@@ -959,6 +979,23 @@ void AmsConfiguration::setUiLanguageChanged() {
 	uiLanguageChanged = true;
 }
 
+uint32_t AmsConfiguration::getChipId() {
+	uint32_t chipId;
+	#if defined(ESP32)
+		for(int i=0; i<17; i=i+8) {
+			chipId |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
+		}
+	#else
+		chipId = ESP.getChipId();
+	#endif
+	return chipId;
+}	
+
+void AmsConfiguration::getUniqueName(char* buffer, size_t length) {
+	uint32_t chipId = getChipId();
+	snprintf(buffer, length, "ams-%06x", chipId);
+}
+
 void AmsConfiguration::clear() {
 	EEPROM.begin(EEPROM_SIZE);
 
@@ -966,6 +1003,7 @@ void AmsConfiguration::clear() {
 	EEPROM.get(CONFIG_SYSTEM_START, sys);
 	sys.userConfigured = false;
 	sys.dataCollectionConsent = 0;
+	sys.firmwareChannel = 0;
 	sys.energyspeedometer = 0;
 	memset(sys.country, 0, 3);
 	EEPROM.put(CONFIG_SYSTEM_START, sys);
@@ -1022,6 +1060,10 @@ void AmsConfiguration::clear() {
 	clearCloudConfig(cloud);
 	EEPROM.put(CONFIG_CLOUD_START, cloud);
 
+	ZmartChargeConfig zc;
+	clearZmartChargeConfig(zc);
+	EEPROM.put(CONFIG_ZC_START, zc);
+
 	EEPROM.put(EEPROM_CONFIG_ADDRESS, EEPROM_CLEARED_INDICATOR);
 	EEPROM.commit();
 	EEPROM.end();
@@ -1124,7 +1166,8 @@ bool AmsConfiguration::relocateConfig103() {
 		gpio103.vccResistorGnd,
 		gpio103.vccResistorVcc,
 		gpio103.ledDisablePin,
-		gpio103.ledBehaviour
+		gpio103.ledBehaviour,
+		0
 	};
 
 	WebConfig web = {web103.security};
@@ -1240,6 +1283,9 @@ void AmsConfiguration::print(Print* debugger)
 			}
 			debugger->printf_P(PSTR("Payload format:       %i\r\n"), mqtt.payloadFormat);
 			debugger->printf_P(PSTR("SSL:                  %s\r\n"), mqtt.ssl ? "Yes" : "No");
+			debugger->printf_P(PSTR("Timeout:              %i\r\n"), mqtt.timeout);
+			debugger->printf_P(PSTR("Keep-alive:           %i\r\n"), mqtt.keepalive);
+			debugger->printf_P(PSTR("Auto reboot minutes:  %i\r\n"), mqtt.rebootMinutes);
 		} else {
 			debugger->printf_P(PSTR("Enabled:              No\r\n"));
 		}
@@ -1293,6 +1339,7 @@ void AmsConfiguration::print(Print* debugger)
 		debugger->printf_P(PSTR("Vcc pin:              %i\r\n"), gpio.vccPin);
 		debugger->printf_P(PSTR("LED disable pin:      %i\r\n"), gpio.ledDisablePin);
 		debugger->printf_P(PSTR("LED behaviour:        %i\r\n"), gpio.ledBehaviour);
+		debugger->printf_P(PSTR("Power saving:         %i\r\n"), gpio.powersaving);
 		if(gpio.vccMultiplier > 0) {
 			debugger->printf_P(PSTR("Vcc multiplier:       %f\r\n"), gpio.vccMultiplier / 1000.0);
 		}
@@ -1348,10 +1395,10 @@ void AmsConfiguration::print(Print* debugger)
 			debugger->printf_P(PSTR("Area:                 %s\r\n"), price.area);
 			debugger->printf_P(PSTR("Currency:             %s\r\n"), price.currency);
 			debugger->printf_P(PSTR("ENTSO-E Token:        %s\r\n"), price.entsoeToken);
+			debugger->println(F(""));
+			delay(10);
+			debugger->flush();
 		}
-		debugger->println(F(""));
-		delay(10);
-		debugger->flush();
 	}
 
 	UiConfig ui;
@@ -1369,9 +1416,29 @@ void AmsConfiguration::print(Print* debugger)
 		String uuid = ESPRandom::uuidToString(cc.clientId);;
 		debugger->println(F("--Cloud configuration--"));
 		debugger->printf_P(PSTR("Enabled:              %s\r\n"), cc.enabled ? "Yes" : "No");
-		debugger->printf_P(PSTR("Hostname:             %s\r\n"), cc.hostname);
-		debugger->printf_P(PSTR("Client ID:            %s\r\n"), uuid.c_str());
-		debugger->printf_P(PSTR("Interval:             %d\r\n"), cc.interval);
+		if(cc.enabled) {
+			debugger->printf_P(PSTR("Hostname:             %s\r\n"), cc.hostname);
+			debugger->printf_P(PSTR("Client ID:            %s\r\n"), uuid.c_str());
+			debugger->printf_P(PSTR("Interval:             %d\r\n"), cc.interval);
+		}
+		debugger->println(F(""));
+		delay(10);
+		debugger->flush();
+	}
+	#endif
+
+	#if defined(ZMART_CHARGE)
+	ZmartChargeConfig zc;
+	if(getZmartChargeConfig(zc)) {
+		debugger->println(F("--ZmartCharge configuration--"));
+		debugger->printf_P(PSTR("Enabled:              %s\r\n"), zc.enabled ? "Yes" : "No");
+		if(zc.enabled) {
+			debugger->printf_P(PSTR("Base URL:            '%s'\r\n"), zc.baseUrl);
+			debugger->printf_P(PSTR("Token:               '%s'\r\n"), zc.token);
+		}
+		debugger->println(F(""));
+		delay(10);
+		debugger->flush();
 	}
 	#endif
 

lib/AmsConfiguration/src/hexutils.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsData/include/AmsData.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -7,8 +7,7 @@
 #ifndef _AMSDATA_H
 #define _AMSDATA_H
 
-#include "Arduino.h"
-#include <Timezone.h>
+#include <WString.h>
 #include "OBIScodes.h"
 
 enum AmsType {
@@ -28,7 +27,7 @@ public:
     AmsData();
 
     void apply(AmsData& other);
-    void apply(const OBIS_code_t obis, double value);
+    void apply(const OBIS_code_t obis, double value, uint64_t millis64);
 
     uint64_t getLastUpdateMillis();
 

lib/AmsData/include/OBIScodes.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsData/src/AmsData.cpp

@@ -1,10 +1,11 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
 
 #include "AmsData.h"
+#include <algorithm>
 
 AmsData::AmsData() {}
 
@@ -17,7 +18,6 @@ void AmsData::apply(AmsData& other) {
                 uint32_t power = (activeImportPower + other.getActiveImportPower()) / 2;
                 float add = power * (((float) ms) / 3600000.0);
                 activeImportCounter += add / 1000.0;
-                //Serial.printf("%dW, %dms, %.6fkWh added\n", other.getActiveImportPower(), ms, add);
             }
 
             if(other.getListType() > 1) {
@@ -112,7 +112,7 @@ void AmsData::apply(AmsData& other) {
         this->activeExportPower = other.getActiveExportPower();
 }
 
-void AmsData::apply(OBIS_code_t obis, double value) {
+void AmsData::apply(OBIS_code_t obis, double value, uint64_t millis64) {
     if(obis.sensor == 0 && obis.gr == 0 && obis.tariff == 0) {
         meterType = value;
     }
@@ -127,138 +127,137 @@ void AmsData::apply(OBIS_code_t obis, double value) {
         }
     }
     if(obis.tariff != 0) {
-        Serial.println("Tariff not implemented");
         return;
     }
     if(obis.gr == 7) { // Instant values
         switch(obis.sensor) {
             case 1:
                 activeImportPower = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 2:
                 activeExportPower = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 3:
                 reactiveImportPower = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 4:
                 reactiveExportPower = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 13:
                 powerFactor = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 21:
                 l1activeImportPower = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 22:
                 l1activeExportPower = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 31:
                 l1current = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 32:
                 l1voltage = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 33:
                 l1PowerFactor = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 41:
                 l2activeImportPower = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 42:
                 l2activeExportPower = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 51:
                 l2current = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 52:
                 l2voltage = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 53:
                 l2PowerFactor = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 61:
                 l3activeImportPower = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 62:
                 l3activeExportPower = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 71:
                 l3current = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 72:
                 l3voltage = value;
-                listType = max(listType, (uint8_t) 2);
+                listType = std::max(listType, (uint8_t) 2);
                 break;
             case 73:
                 l3PowerFactor = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
         }
     } else if(obis.gr == 8) { // Accumulated values
         switch(obis.sensor) {
             case 1:
                 activeImportCounter = value;
-                listType = max(listType, (uint8_t) 3);
+                listType = std::max(listType, (uint8_t) 3);
                 break;
             case 2:
                 activeExportCounter = value;
-                listType = max(listType, (uint8_t) 3);
+                listType = std::max(listType, (uint8_t) 3);
                 break;
             case 3:
                 reactiveImportCounter = value;
-                listType = max(listType, (uint8_t) 3);
+                listType = std::max(listType, (uint8_t) 3);
                 break;
             case 4:
                 reactiveExportCounter = value;
-                listType = max(listType, (uint8_t) 3);
+                listType = std::max(listType, (uint8_t) 3);
                 break;
             case 21:
                 l1activeImportCounter = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 22:
                 l1activeExportCounter = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 41:
                 l2activeImportCounter = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 42:
                 l2activeExportCounter = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 61:
                 l3activeImportCounter = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
             case 62:
                 l3activeExportCounter = value;
-                listType = max(listType, (uint8_t) 4);
+                listType = std::max(listType, (uint8_t) 4);
                 break;
         }
     }
     if(listType > 0)
-        lastUpdateMillis = millis();
+        lastUpdateMillis = millis64;
 
     threePhase = l1voltage > 0 && l2voltage > 0 && l3voltage > 0;
     if(!threePhase)

lib/AmsDataStorage/include/AmsDataStorage.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDataStorage/src/AmsDataStorage.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -639,25 +639,22 @@ bool AmsDataStorage::isDayHappy(time_t now) {
         return false;
     }
 
-    if(now < FirmwareVersion::BuildEpoch) return false;
-
-    if(now < day.lastMeterReadTime) {
+    // If the timestamp is before the firware was built, there is something seriously wrong..
+    if(now < FirmwareVersion::BuildEpoch) {
         return false;
     }
-    // There are cases where the meter reports before the hour. The update method will then receive the meter timestamp as reference, thus there will not be 3600s between. 
-    // Leaving a 100s buffer for these cases
-    if(now-day.lastMeterReadTime > 3500) {
+
+    // If the timestamp is before the last time we updated, there is also something wrong..
+    if(now < day.lastMeterReadTime) {
         return false;
     }
 
     tmElements_t tm, last;
     breakTime(tz->toLocal(now), tm);
     breakTime(tz->toLocal(day.lastMeterReadTime), last);
-    if(tm.Hour != last.Hour) {
-        return false;
-    }
 
-    return true;
+    // If the timestamp is at the same day and hour as last update, we are happy
+    return tm.Day == last.Day && tm.Hour == last.Hour;
 }
 
 bool AmsDataStorage::isMonthHappy(time_t now) {

lib/AmsDecoder/include/Cosem.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/DataParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/DataParsers.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/DlmsParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/DsmrParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/GbtParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/GcmParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/HdlcParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/LlcParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/MbusParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/crc.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/include/ntohll.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/Cosem.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/DlmsParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/DsmrParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -74,7 +74,7 @@ int8_t DSMRParser::parse(uint8_t *buf, DataParserContext &ctx, bool verified, Pr
         fromHex((uint8_t*) &crc, String((char*) buf+crcPos), 2);
         crc = ntohs(crc);
 
-        if(crc != crc_calc) {
+        if(crc > 0 && crc != crc_calc) {
             if(debugger != NULL) {
                 debugger->printf_P(PSTR("CRC incorrrect, %04X != %04X at position %lu\n"), crc, crc_calc, crcPos);
             }

lib/AmsDecoder/src/GbtParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/GcmParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -96,7 +96,7 @@ int8_t GCMParser::parse(uint8_t *d, DataParserContext &ctx, bool hastag) {
         footersize += authkeylen;
         memcpy(additional_authenticated_data + 1, authentication_key, 16);
         memcpy(authentication_tag, ptr + len - footersize - 5, authkeylen);
-        for(uint8_t i; i < 16; i++) authenticate |= authentication_key[i] > 0;
+        for(uint8_t i = 0; i < 16; i++) authenticate |= authentication_key[i] > 0;
     }
 
     #if defined(ESP8266)

lib/AmsDecoder/src/HdlcParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -32,7 +32,7 @@ int8_t HDLCParser::parse(uint8_t *d, DataParserContext &ctx) {
             return DATA_PARSE_BOUNDARY_FLAG_MISSING;
 
         // Verify FCS
-        if(ntohs(f->fcs) != crc16_x25(d + 1, len - sizeof *f - 1))
+        if(f->fcs > 0 && ntohs(f->fcs) != crc16_x25(d + 1, len - sizeof *f - 1))
             return DATA_PARSE_FOOTER_CHECKSUM_ERROR;
 
         // Skip destination address, LSB marks last byte
@@ -50,7 +50,7 @@ int8_t HDLCParser::parse(uint8_t *d, DataParserContext &ctx) {
         HDLC3CtrlHcs* t3 = (HDLC3CtrlHcs*) (ptr);
 
         // Verify HCS
-        if(ntohs(t3->hcs) != crc16_x25(d + 1, ptr-d))
+        if(t3->hcs > 0 && ntohs(t3->hcs) != crc16_x25(d + 1, ptr-d))
             return DATA_PARSE_HEADER_CHECKSUM_ERROR;
         ptr += 3;
 
@@ -69,7 +69,12 @@ int8_t HDLCParser::parse(uint8_t *d, DataParserContext &ctx) {
 
             if(buf == NULL) return DATA_PARSE_FAIL;
 
-            memcpy(buf + pos, ptr+3, ctx.length); // +3 to skip LLC
+            if((*ptr) == DATA_TAG_LLC) {
+                ptr += 3; // Skip LLC
+                ctx.length -= 3;
+            }
+
+            memcpy(buf + pos, ptr, ctx.length);
             pos += ctx.length;
 
             lastSequenceNumber++;
@@ -78,7 +83,12 @@ int8_t HDLCParser::parse(uint8_t *d, DataParserContext &ctx) {
             lastSequenceNumber = 0;
             if(buf == NULL) return DATA_PARSE_FAIL;
 
-            memcpy(buf + pos, ptr+3, ctx.length); // +3 to skip LLC
+            if((*ptr) == DATA_TAG_LLC) {
+                ptr += 3; // Skip LLC
+                ctx.length -= 3;
+            }
+
+            memcpy(buf + pos, ptr, ctx.length);
             pos += ctx.length;
 
             memcpy((uint8_t *) d, buf, pos);

lib/AmsDecoder/src/LlcParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/MbusParser.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/crc.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsDecoder/src/ntohll.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/AmsFirmwareUpdater/include/AmsFirmwareUpdater.h

@@ -1,3 +1,8 @@
+/**
+ * @copyright Utilitech AS 2023-2026
+ * License: Fair Source
+ * 
+ */
 #pragma once
 #include <stdint.h>
 #include <Print.h>
@@ -39,6 +44,8 @@
 #define AMS_UPDATE_ERR_SUCCESS_CONFIRMED 123
 
 #define UPDATE_BUF_SIZE 4096
+#define UPDATE_MAX_BLOCK_RETRY 25
+#define UPDATE_MAX_REBOOT_RETRY 12
 
 class AmsFirmwareUpdater {
 public:
@@ -60,6 +67,13 @@ public:
     bool isUpgradeInformationChanged();
     void ackUpgradeInformationChanged();
 
+    void setFirmwareChannel(uint8_t channel) {
+        if(firmwareChannel != channel) {
+            firmwareChannel = channel;
+            lastVersionCheck = 0;
+        }
+    }
+
     bool startFirmwareUpload(uint32_t size, const char* version);
     bool addFirmwareUploadChunk(uint8_t* buf, size_t length);
     bool completeFirmwareUpload(uint32_t size);
@@ -95,10 +109,11 @@ private:
     String md5;
 
     uint32_t lastVersionCheck = 0;
-    uint8_t firmwareVariant;
+    uint8_t firmwareChannel;
     bool autoUpgrade;
-    char nextVersion[10];
+    char nextVersion[17];
 
+    void getChannelName(char * buffer);
 
     bool fetchNextVersion();
     bool fetchVersionDetails();

lib/AmsFirmwareUpdater/src/AmsFirmwareUpdater.cpp

@@ -1,3 +1,8 @@
+/**
+ * @copyright Utilitech AS 2023-2026
+ * License: Fair Source
+ * 
+ */
 #include "AmsFirmwareUpdater.h"
 #include "AmsStorage.h"
 #include "FirmwareVersion.h"
@@ -22,7 +27,7 @@ this->debugger = debugger;
     this->hw = hw;
     this->meterState = meterState;
     memset(nextVersion, 0, sizeof(nextVersion));
-    firmwareVariant = 0;
+    firmwareChannel = 0;
     autoUpgrade = false;
 }
 
@@ -74,7 +79,7 @@ void AmsFirmwareUpdater::setUpgradeInformation(UpgradeInformation& upinfo) {
         #endif
         debugger->printf_P(PSTR("Resuming uprade to %s\n"), updateStatus.toVersion);
 
-        if(updateStatus.reboot_count++ < 8) {
+        if(updateStatus.reboot_count++ < UPDATE_MAX_REBOOT_RETRY) {
             updateStatus.errorCode = AMS_UPDATE_ERR_OK;
         } else {
             updateStatus.errorCode = AMS_UPDATE_ERR_REBOOT;
@@ -129,7 +134,7 @@ void AmsFirmwareUpdater::loop() {
             HTTPClient http;
             start = millis();
             if(!fetchFirmwareChunk(http)) {
-                if(updateStatus.retry_count++ == 3) {
+                if(updateStatus.retry_count++ > UPDATE_MAX_BLOCK_RETRY) {
                     updateStatus.errorCode = AMS_UPDATE_ERR_FETCH;
                     updateStatusChanged = true;
                 }
@@ -208,15 +213,33 @@ void AmsFirmwareUpdater::loop() {
     }
 }
 
+void AmsFirmwareUpdater::getChannelName(char * buffer) {
+    switch(firmwareChannel) {
+        case FIRMWARE_CHANNEL_EARLY:
+            strcpy(buffer, PSTR("early"));
+            break;
+        case FIRMWARE_CHANNEL_RC:
+            strcpy(buffer, PSTR("rc"));
+            break;
+        case FIRMWARE_CHANNEL_SNAPSHOT:
+            strcpy(buffer, PSTR("snapshot"));
+            break;  
+        default:
+            strcpy(buffer, PSTR("stable"));
+            break;
+    }
+}
+
 bool AmsFirmwareUpdater::fetchNextVersion() {
     HTTPClient http;
     const char * headerkeys[] = { "x-version" };
     http.collectHeaders(headerkeys, 1);
 
-    char firmwareVariant[10] = "stable";
+    char channel[10] = "";
+    getChannelName(channel);
 
     char url[128];
-    snprintf_P(url, 128, PSTR("http://hub.amsleser.no/hub/firmware/%s/%s/next"), chipType, firmwareVariant);
+    snprintf_P(url, 128, PSTR("http://hub.amsleser.no/hub/firmware/%s/%s/next"), chipType, channel);
     #if defined(ESP8266)
     WiFiClient client;
     client.setTimeout(5000);
@@ -230,6 +253,16 @@ bool AmsFirmwareUpdater::fetchNextVersion() {
         http.setUserAgent("AMS-Firmware-Updater");
         http.addHeader(F("Cache-Control"), "no-cache");
         http.addHeader(F("x-AMS-version"), FirmwareVersion::VersionString);
+        http.addHeader(F("x-AMS-STA-MAC"), WiFi.macAddress());
+        http.addHeader(F("x-AMS-AP-MAC"), WiFi.softAPmacAddress());
+        http.addHeader(F("x-AMS-chip-size"), String(ESP.getFlashChipSize()));
+		http.addHeader(F("x-AMS-board-type"), String(hw->getBoardType(), 10));
+		if(meterState->getMeterType() != AmsTypeAutodetect) {
+			http.addHeader(F("x-AMS-meter-mfg"), String(meterState->getMeterType(), 10));
+		}
+		if(!meterState->getMeterModel().isEmpty()) {
+			http.addHeader(F("x-AMS-meter-model"), meterState->getMeterModel());
+		}
         int status = http.GET();
         if(status == 204) {
             String nextVersion = http.header("x-version");
@@ -253,10 +286,11 @@ bool AmsFirmwareUpdater::fetchVersionDetails() {
     const char * headerkeys[] = { "x-size" };
     http.collectHeaders(headerkeys, 1);
 
-    char firmwareVariant[10] = "stable";
+    char channel[10] = "";
+    getChannelName(channel);
 
     char url[128];
-    snprintf_P(url, 128, PSTR("http://hub.amsleser.no/hub/firmware/%s/%s/%s/details"), chipType, firmwareVariant, updateStatus.toVersion);
+    snprintf_P(url, 128, PSTR("http://hub.amsleser.no/hub/firmware/%s/%s/%s/details"), chipType, channel, updateStatus.toVersion);
     #if defined(ESP8266)
     WiFiClient client;
     client.setTimeout(5000);
@@ -309,10 +343,11 @@ bool AmsFirmwareUpdater::fetchFirmwareChunk(HTTPClient& http) {
     char range[24];
     snprintf_P(range, 24, PSTR("bytes=%lu-%lu"), start, end);
 
-    char firmwareVariant[10] = "stable";
+    char channel[10] = "";
+    getChannelName(channel);
 
     char url[128];
-    snprintf_P(url, 128, PSTR("http://hub.amsleser.no/hub/firmware/%s/%s/%s/chunk"), chipType, firmwareVariant, updateStatus.toVersion);
+    snprintf_P(url, 128, PSTR("http://hub.amsleser.no/hub/firmware/%s/%s/%s/chunk"), chipType, channel, updateStatus.toVersion);
     #if defined(ESP8266)
     WiFiClient client;
     client.setTimeout(5000);

lib/AmsJsonGenerator/include/AmsJsonGenerator.h

@@ -0,0 +1,14 @@
+/**
+ * @copyright Utilitech AS 2023-2026
+ * License: Fair Source
+ * 
+ */
+#pragma once
+
+#include "AmsDataStorage.h"
+
+class AmsJsonGenerator {
+public:
+    static void generateDayPlotJson(AmsDataStorage* ds, char* buf, size_t bufSize);
+    static void generateMonthPlotJson(AmsDataStorage* ds, char* buf, size_t bufSize);
+};

lib/AmsJsonGenerator/src/AmsJsonGenerator.cpp

@@ -0,0 +1,22 @@
+/**
+ * @copyright Utilitech AS 2023-2026
+ * License: Fair Source
+ * 
+ */
+#include "AmsJsonGenerator.h"
+
+void AmsJsonGenerator::generateDayPlotJson(AmsDataStorage* ds, char* buf, size_t bufSize) {
+		uint16_t pos = snprintf_P(buf, bufSize, PSTR("{\"unit\":\"kwh\""));
+		for(uint8_t i = 0; i < 24; i++) {
+			pos += snprintf_P(buf+pos, bufSize-pos, PSTR(",\"i%02d\":%.3f,\"e%02d\":%.3f"), i, ds->getHourImport(i) / 1000.0, i, ds->getHourExport(i) / 1000.0);
+		}
+		snprintf_P(buf+pos, bufSize-pos, PSTR("}"));
+}
+
+void AmsJsonGenerator::generateMonthPlotJson(AmsDataStorage* ds, char* buf, size_t bufSize) {
+		uint16_t pos = snprintf_P(buf, bufSize, PSTR("{\"unit\":\"kwh\""));
+		for(uint8_t i = 1; i < 32; i++) {
+			pos += snprintf_P(buf+pos, bufSize-pos, PSTR(",\"i%02d\":%.3f,\"e%02d\":%.3f"), i, ds->getDayImport(i) / 1000.0, i, ds->getDayExport(i) / 1000.0);
+		}
+		snprintf_P(buf+pos, bufSize-pos, PSTR("}"));
+}

lib/AmsMqttHandler/include/AmsMqttHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -24,31 +24,31 @@ class AmsMqttHandler {
 public:
     #if defined(AMS_REMOTE_DEBUG)
     AmsMqttHandler(MqttConfig& mqttConfig, RemoteDebug* debugger, char* buf, AmsFirmwareUpdater* updater) {
+    #else
+    AmsMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, AmsFirmwareUpdater* updater) {
+    #endif
         this->mqttConfig = mqttConfig;
     	this->mqttConfigChanged = true;
         this->debugger = debugger;
         this->json = buf;
         this->updater = updater;
         mqtt.dropOverflow(true);
+
+        pubTopic = String(mqttConfig.publishTopic);
+        subTopic = String(mqttConfig.subscribeTopic);
+        if(subTopic.isEmpty()) subTopic = pubTopic+"/command";
     };
-    #else
-    AmsMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf) {
-        this->mqttConfig = mqttConfig;
-    	this->mqttConfigChanged = true;
-        this->debugger = debugger;
-        this->json = buf;
-        mqtt.dropOverflow(true);
-    };
-    #endif
 
     void setCaVerification(bool);
     void setConfig(MqttConfig& mqttConfig);
 
     bool connect();
+    bool defaultSubscribe();
     void disconnect();
     lwmqtt_err_t lastError();
     bool connected();
     bool loop();
+    bool isRebootSuggested();
 
     virtual uint8_t getFormat() { return 0; };
 
@@ -57,11 +57,16 @@ public:
     virtual bool publishTemperatures(AmsConfiguration*, HwTools*) { return false; };
     virtual bool publishPrices(PriceService* ps) { return false; };
     virtual bool publishSystem(HwTools*, PriceService*, EnergyAccounting*) { return false; };
-    virtual bool publishRaw(String data) { return false; };
+    virtual bool publishRaw(uint8_t* raw, size_t length) { return false; };
     virtual bool publishFirmware() { return false; };
     virtual void onMessage(String &topic, String &payload) {};
 
     virtual ~AmsMqttHandler() {
+        if(mqttSecureClient != NULL) {
+            mqttSecureClient->stop();
+            delete mqttSecureClient;
+        }
+
         if(mqttClient != NULL) {
             mqttClient->stop();
             delete mqttClient;
@@ -81,11 +86,17 @@ protected:
     bool caVerification = true;
     WiFiClient *mqttClient = NULL;
     WiFiClientSecure *mqttSecureClient = NULL;
+    boolean _connected = false;
     char* json;
     uint16_t BufferSize = 2048;
     uint64_t lastStateUpdate = 0;
+    uint64_t lastSuccessfulLoop = 0;
+
+    String pubTopic;
+    String subTopic;
 
     AmsFirmwareUpdater* updater = NULL;
+    bool rebootSuggested = false;
 };
 
 #endif

lib/AmsMqttHandler/src/AmsMqttHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -8,6 +8,7 @@
 #include "FirmwareVersion.h"
 #include "AmsStorage.h"
 #include "LittleFS.h"
+#include "Uptime.h"
 
 void AmsMqttHandler::setCaVerification(bool caVerification) {
 	this->caVerification = caVerification;
@@ -102,6 +103,17 @@ bool AmsMqttHandler::connect() {
 		actualClient = mqttClient;
 	}
 
+	// This section helps with power saving on ESP32 devices by reducing timeouts
+	// The timeout is multiplied by 10 because WiFiClient is retrying 10 times internally
+	// Power drain for this timeout is too great when using the default 3s timeout
+	// On ESP8266 the timeout is used differently and the following code causes MQTT instability
+	#if defined(ESP32)
+		int clientTimeout = mqttConfig.timeout / 1000;
+		if(clientTimeout > 3) clientTimeout = 3; // 3000ms is default, see WiFiClient.cpp WIFI_CLIENT_DEF_CONN_TIMEOUT_MS
+		actualClient->setTimeout(clientTimeout);
+		// Why can't we set number of retries for write here? WiFiClient defaults to 10 (10*3s == 30s)
+	#endif
+
 	mqttConfigChanged = false;
 	mqtt.setTimeout(mqttConfig.timeout);
 	mqtt.setKeepAlive(mqttConfig.keepalive);
@@ -124,20 +136,9 @@ bool AmsMqttHandler::connect() {
 		#endif
 		debugger->printf_P(PSTR("Successfully connected to MQTT\n"));
 		mqtt.onMessage(std::bind(&AmsMqttHandler::onMessage, this, std::placeholders::_1, std::placeholders::_2));
-		if(strlen(mqttConfig.subscribeTopic) > 0) {
-			#if defined(AMS_REMOTE_DEBUG)
-			if (debugger->isActive(RemoteDebug::INFO))
-			#endif
-			debugger->printf_P(PSTR("  Subscribing to [%s]\n"), mqttConfig.subscribeTopic);
-			if(!mqtt.subscribe(mqttConfig.subscribeTopic)) {
-				#if defined(AMS_REMOTE_DEBUG)
-				if (debugger->isActive(RemoteDebug::ERROR))
-				#endif
-				debugger->printf_P(PSTR("  Unable to subscribe to to [%s]\n"), mqttConfig.subscribeTopic);
-			}
-		}
-		mqtt.publish(statusTopic, "online", true, 0);
+		_connected = mqtt.publish(statusTopic, "online", true, 0);
         mqtt.loop();
+		defaultSubscribe();
 		postConnect();
         return true;
 	} else {
@@ -157,13 +158,29 @@ bool AmsMqttHandler::connect() {
 	}
 }
 
+bool AmsMqttHandler::defaultSubscribe() {
+	bool ret = true;
+	if(!subTopic.isEmpty()) {
+        if(mqtt.subscribe(subTopic)) {
+            #if defined(AMS_REMOTE_DEBUG)
+            if (debugger->isActive(RemoteDebug::ERROR))
+            #endif
+            debugger->printf_P(PSTR("  Subscribed to [%s]\n"), subTopic.c_str());
+        } else {
+            #if defined(AMS_REMOTE_DEBUG)
+            if (debugger->isActive(RemoteDebug::ERROR))
+            #endif
+            debugger->printf_P(PSTR("  Unable to subscribe to [%s]\n"), subTopic.c_str());
+            ret = false;
+        }
+    }
+	return ret;
+}
+
 void AmsMqttHandler::disconnect() {
     mqtt.disconnect();
     mqtt.loop();
-	if(mqttSecureClient != NULL) {
-		delete mqttSecureClient;
-		mqttSecureClient = NULL;
-	}
+	_connected = false;
     delay(10);
     yield();
 }
@@ -173,12 +190,25 @@ lwmqtt_err_t AmsMqttHandler::lastError() {
 }
 
 bool AmsMqttHandler::connected() {
-	return mqtt.connected();
+	return _connected && mqtt.connected();
 }
 
 bool AmsMqttHandler::loop() {
-    bool ret = mqtt.loop();
-    delay(10);
+	uint64_t now = millis64();
+    bool ret = connected() && mqtt.loop();
+	if(ret) {
+		lastSuccessfulLoop = now;
+	} else if(mqttConfig.rebootMinutes > 0) {
+		if(now - lastSuccessfulLoop > (uint64_t) mqttConfig.rebootMinutes * 60000) {
+			// Reboot the device if the MQTT connection is lost for too long
+			#if defined(AMS_REMOTE_DEBUG)
+			if (debugger->isActive(RemoteDebug::WARNING))
+			#endif
+			debugger->printf_P(PSTR("MQTT connection lost for over %d minutes, rebooting device\n"), mqttConfig.rebootMinutes);
+			rebootSuggested = true;
+		}
+	}
+	delay(10); // Needed to preserve power. After adding this, the voltage is super smooth on a HAN powered device
     yield();
 	#if defined(ESP32)
 		esp_task_wdt_reset();
@@ -186,4 +216,8 @@ bool AmsMqttHandler::loop() {
 		ESP.wdtFeed();
 	#endif
     return ret;
+}
+
+bool AmsMqttHandler::isRebootSuggested() {
+	return rebootSuggested;
 }

lib/CloudConnector/include/CloudConnector.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/CloudConnector/src/CloudConnector.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/ConnectionHandler/include/ConnectionHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/ConnectionHandler/include/EthernetConnectionHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/ConnectionHandler/include/WiFiAccessPointConnectionHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/ConnectionHandler/include/WiFiClientConnectionHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/ConnectionHandler/src/EthernetConnectionHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -114,6 +114,7 @@ bool EthernetConnectionHandler::connect(NetworkConfig config, SystemConfig sys)
                     debugger->printf_P(PSTR("Static IP configuration is invalid, not using\n"));
                 }
             }
+            this->config = config;
         } else {
 			#if defined(AMS_REMOTE_DEBUG)
             if (debugger->isActive(RemoteDebug::ERROR))
@@ -147,6 +148,9 @@ void EthernetConnectionHandler::eventHandler(WiFiEvent_t event, WiFiEventInfo_t
             {
                 debugger->printf_P(PSTR("Successfully connected to Ethernet!\n"));
             }
+			if(config.ipv6 && !ETH.enableIpV6()) {
+				debugger->printf_P(PSTR("Unable to enable IPv6\n"));
+			}
             break;
         case ARDUINO_EVENT_ETH_GOT_IP:
             #if defined(AMS_REMOTE_DEBUG)

lib/ConnectionHandler/src/WiFiAccessPointConnectionHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -19,6 +19,7 @@ bool WiFiAccessPointConnectionHandler::connect(NetworkConfig config, SystemConfi
 		//wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, 0); // Disable default gw
 
 		WiFi.mode(WIFI_AP);
+		WiFi.persistent(false);
 		WiFi.softAP(config.ssid, config.psk);
 
 		dnsServer.setErrorReplyCode(DNSReplyCode::NoError);

lib/ConnectionHandler/src/WiFiClientConnectionHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -100,6 +100,7 @@ bool WiFiClientConnectionHandler::connect(NetworkConfig config, SystemConfig sys
 			}
 		#endif
 		WiFi.setAutoReconnect(true);
+		WiFi.persistent(false);
         this->config = config;
 		#if defined(ESP32)
 		if(begin(config.ssid, config.psk)) {

lib/DomoticzMqttHandler/include/DomoticzMqttHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -17,7 +17,7 @@ public:
         this->config = config;
     };
     #else
-    DomoticzMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, DomoticzConfig config) : AmsMqttHandler(mqttConfig, debugger, buf) {
+    DomoticzMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, DomoticzConfig config, AmsFirmwareUpdater* updater) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
         this->config = config;
     };
     #endif
@@ -25,7 +25,7 @@ public:
     bool publishTemperatures(AmsConfiguration*, HwTools*);
     bool publishPrices(PriceService*);
     bool publishSystem(HwTools* hw, PriceService* ps, EnergyAccounting* ea);
-    bool publishRaw(String data);
+    bool publishRaw(uint8_t* raw, size_t length);
 
     void onMessage(String &topic, String &payload);
 

lib/DomoticzMqttHandler/src/DomoticzMqttHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -103,7 +103,7 @@ uint8_t DomoticzMqttHandler::getFormat() {
     return 3;
 }
 
-bool DomoticzMqttHandler::publishRaw(String data) {
+bool DomoticzMqttHandler::publishRaw(uint8_t* raw, size_t length) {
     return false;
 }
 

lib/EnergyAccounting/include/EnergyAccounting.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -7,17 +7,39 @@
 #ifndef _ENERGYACCOUNTING_H
 #define _ENERGYACCOUNTING_H
 
-#include "Arduino.h"
-#include "AmsData.h"
 #include "AmsDataStorage.h"
 #include "PriceService.h"
 
 struct EnergyAccountingPeak {
+    uint8_t day;
+    uint8_t hour;
+    uint16_t value;
+};
+
+struct EnergyAccountingPeak6 {
     uint8_t day;
     uint16_t value;
 };
 
 struct EnergyAccountingData {
+    uint8_t version;
+    uint8_t month;
+    int32_t costToday;
+    int32_t costYesterday;
+    int32_t costThisMonth;
+    int32_t costLastMonth;
+    int32_t incomeToday;
+    int32_t incomeYesterday;
+    int32_t incomeThisMonth;
+    int32_t incomeLastMonth;
+    uint32_t lastMonthImport;
+    uint32_t lastMonthExport;
+    uint8_t lastMonthAccuracy;
+    EnergyAccountingPeak peaks[5];
+    time_t lastUpdated;
+};
+
+struct EnergyAccountingData6 {
     uint8_t version;
     uint8_t month;
     int32_t costYesterday;
@@ -29,37 +51,7 @@ struct EnergyAccountingData {
     uint32_t lastMonthImport;
     uint32_t lastMonthExport;
     uint8_t lastMonthAccuracy;
-    EnergyAccountingPeak peaks[5];
-};
-
-struct EnergyAccountingData5 {
-    uint8_t version;
-    uint8_t month;
-    uint16_t costYesterday;
-    uint16_t costThisMonth;
-    uint16_t costLastMonth;
-    uint16_t incomeYesterday;
-    uint16_t incomeThisMonth;
-    uint16_t incomeLastMonth;
-    EnergyAccountingPeak peaks[5];
-};
-
-struct EnergyAccountingData4 {
-    uint8_t version;
-    uint8_t month;
-    uint16_t costYesterday;
-    uint16_t costThisMonth;
-    uint16_t costLastMonth;
-    EnergyAccountingPeak peaks[5];
-};
-
-struct EnergyAccountingData2 {
-    uint8_t version;
-    uint8_t month;
-    uint16_t maxHour;
-    uint16_t costYesterday;
-    uint16_t costThisMonth;
-    uint16_t costLastMonth;
+    EnergyAccountingPeak6 peaks[5];
 };
 
 struct EnergyAccountingRealtimeData {
@@ -89,7 +81,7 @@ public:
     void setPriceService(PriceService *ps);
     void setTimezone(Timezone*);
     EnergyAccountingConfig* getConfig();
-    bool update(AmsData* amsData);
+    bool update(time_t now, uint64_t lastUpdatedMillis, uint8_t listType, uint32_t activeImportPower, uint32_t activeExportPower);
     bool load();
     bool save();
     bool isInitialized();
@@ -124,7 +116,6 @@ public:
     void setData(EnergyAccountingData&);
 
     void setCurrency(String currency);
-    float getPriceForHour(uint8_t d, uint8_t h);
 
 private:
     #if defined(AMS_REMOTE_DEBUG)
@@ -137,12 +128,12 @@ private:
     PriceService *ps = NULL;
     EnergyAccountingConfig *config = NULL;
     Timezone *tz = NULL;
-    EnergyAccountingData data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+    EnergyAccountingData data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     EnergyAccountingRealtimeData* realtimeData = NULL;
     String currency = "";
 
     void calcDayCost();
-    bool updateMax(uint16_t val, uint8_t day);
+    bool updateMax(uint16_t val, uint8_t day, uint8_t hour);
 };
 
 #endif

lib/EnergyAccounting/src/EnergyAccounting.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -30,7 +30,7 @@ EnergyAccounting::EnergyAccounting(Stream* Stream, EnergyAccountingRealtimeData*
         rtd->lastImportUpdateMillis = 0;
         rtd->lastExportUpdateMillis = 0;
     }
-    this->realtimeData = rtd;
+    realtimeData = rtd;
 }
 
 void EnergyAccounting::setup(AmsDataStorage *ds, EnergyAccountingConfig *config) {
@@ -54,9 +54,8 @@ bool EnergyAccounting::isInitialized() {
     return this->init;
 }
 
-bool EnergyAccounting::update(AmsData* amsData) {
+bool EnergyAccounting::update(time_t now, uint64_t lastUpdatedMillis, uint8_t listType, uint32_t activeImportPower, uint32_t activeExportPower) {
     if(config == NULL) return false;
-    time_t now = time(nullptr);
     if(now < FirmwareVersion::BuildEpoch) return false;
     if(tz == NULL) {
         return false;
@@ -67,59 +66,55 @@ bool EnergyAccounting::update(AmsData* amsData) {
     breakTime(tz->toLocal(now), local);
 
     if(!init) {
-        this->realtimeData->lastImportUpdateMillis = 0;
-        this->realtimeData->lastExportUpdateMillis = 0;
-        this->realtimeData->currentHour = local.Hour;
-        this->realtimeData->currentDay = local.Day;
+        realtimeData->lastImportUpdateMillis = 0;
+        realtimeData->lastExportUpdateMillis = 0;
+        realtimeData->currentHour = local.Hour;
+        realtimeData->currentDay = local.Day;
         if(!load()) {
-            data = { 6, local.Month, 
-                0, 0, 0, // Cost
-                0, 0, 0, // Income
+            data = { 7, local.Month, 
+                0, 0, 0, 0, // Cost
+                0, 0, 0, 0, // Income
                 0, 0, 0, // Last month import, export and accuracy
-                0, 0, // Peak 1
-                0, 0, // Peak 2
-                0, 0, // Peak 3
-                0, 0, // Peak 4
-                0, 0 // Peak 5
+                0, 0, 0, // Peak 1
+                0, 0, 0, // Peak 2
+                0, 0, 0, // Peak 3
+                0, 0, 0, // Peak 4
+                0, 0, 0  // Peak 5
             };
         }
         init = true;
     }
 
-    float importPrice = getPriceForHour(PRICE_DIRECTION_IMPORT, 0);
-    if(!initPrice && importPrice != PRICE_NO_VALUE) {
+    if(!initPrice && ps != NULL && ps->hasPrice()) {
         calcDayCost();
     }
 
-    if(local.Hour != this->realtimeData->currentHour && (amsData->getListType() >= 3 || local.Minute == 1)) {
+    if(local.Hour != realtimeData->currentHour && (listType >= 3 || local.Minute == 1)) {
         tmElements_t oneHrAgo, oneHrAgoLocal;
         breakTime(now-3600, oneHrAgo);
         uint16_t val = round(ds->getHourImport(oneHrAgo.Hour) / 10.0);
 
         breakTime(tz->toLocal(now-3600), oneHrAgoLocal);
-        ret |= updateMax(val, oneHrAgoLocal.Day);
+        ret |= updateMax(val, oneHrAgoLocal.Day, oneHrAgoLocal.Hour);
 
-        this->realtimeData->currentHour = local.Hour; // Need to be defined here so that day cost is correctly calculated
-        if(local.Hour > 0) {
-            calcDayCost();
-        }
+        realtimeData->currentHour = local.Hour; // Need to be defined here so that day cost is correctly calculated
 
-        this->realtimeData->use = 0;
-        this->realtimeData->produce = 0;
-        this->realtimeData->costHour = 0;
-        this->realtimeData->incomeHour = 0;
+        realtimeData->use = 0;
+        realtimeData->produce = 0;
+        realtimeData->costHour = 0;
+        realtimeData->incomeHour = 0;
 
-        uint8_t prevDay = this->realtimeData->currentDay;
-        if(local.Day != this->realtimeData->currentDay) {
-            data.costYesterday = this->realtimeData->costDay * 100;
-            data.costThisMonth += this->realtimeData->costDay * 100;
-            this->realtimeData->costDay = 0;
+        uint8_t prevDay = realtimeData->currentDay;
+        if(local.Day != realtimeData->currentDay) {
+            data.costYesterday = realtimeData->costDay * 100;
+            data.costThisMonth += realtimeData->costDay * 100;
+            realtimeData->costDay = 0;
 
-            data.incomeYesterday = this->realtimeData->incomeDay * 100;
-            data.incomeThisMonth += this->realtimeData->incomeDay * 100;
-            this->realtimeData->incomeDay = 0;
+            data.incomeYesterday = realtimeData->incomeDay * 100;
+            data.incomeThisMonth += realtimeData->incomeDay * 100;
+            realtimeData->incomeDay = 0;
 
-            this->realtimeData->currentDay = local.Day;
+            realtimeData->currentDay = local.Day;
             ret = true;
         }
 
@@ -149,42 +144,49 @@ bool EnergyAccounting::update(AmsData* amsData) {
             data.lastMonthAccuracy = accuracy;
 
             data.month = local.Month;
-            this->realtimeData->currentThresholdIdx = 0;
+            realtimeData->currentThresholdIdx = 0;
             ret = true;
         }
+
+        if(ret) {
+            data.costToday = realtimeData->costDay * 100;
+            data.incomeToday = realtimeData->incomeDay * 100;
+            data.lastUpdated = now;
+        }
     }
 
-    if(this->realtimeData->lastImportUpdateMillis < amsData->getLastUpdateMillis()) {
-        unsigned long ms = amsData->getLastUpdateMillis() - this->realtimeData->lastImportUpdateMillis;
-        float kwhi = (amsData->getActiveImportPower() * (((float) ms) / 3600000.0)) / 1000.0;
+    if(realtimeData->lastImportUpdateMillis < lastUpdatedMillis) {
+        unsigned long ms = lastUpdatedMillis - realtimeData->lastImportUpdateMillis;
+        float kwhi = (activeImportPower * (((float) ms) / 3600000.0)) / 1000.0;
         if(kwhi > 0) {
-            this->realtimeData->use += kwhi;
+            realtimeData->use += kwhi;
+            float importPrice = ps == NULL ? PRICE_NO_VALUE : ps->getCurrentPrice(PRICE_DIRECTION_IMPORT);
             if(importPrice != PRICE_NO_VALUE) {
                 float cost = importPrice * kwhi;
-                this->realtimeData->costHour += cost;
-                this->realtimeData->costDay += cost;
+                realtimeData->costHour += cost;
+                realtimeData->costDay += cost;
             }
         }
-        this->realtimeData->lastImportUpdateMillis = amsData->getLastUpdateMillis();
+        realtimeData->lastImportUpdateMillis = lastUpdatedMillis;
     }
 
-    if(amsData->getListType() > 1 && this->realtimeData->lastExportUpdateMillis < amsData->getLastUpdateMillis()) {
-        unsigned long ms = amsData->getLastUpdateMillis() - this->realtimeData->lastExportUpdateMillis;
-        float kwhe = (amsData->getActiveExportPower() * (((float) ms) / 3600000.0)) / 1000.0;
+    if(listType > 1 && realtimeData->lastExportUpdateMillis < lastUpdatedMillis) {
+        unsigned long ms = lastUpdatedMillis - realtimeData->lastExportUpdateMillis;
+        float kwhe = (activeExportPower * (((float) ms) / 3600000.0)) / 1000.0;
         if(kwhe > 0) {
-            this->realtimeData->produce += kwhe;
-            float exportPrice = getPriceForHour(PRICE_DIRECTION_EXPORT, 0);
+            realtimeData->produce += kwhe;
+            float exportPrice = ps == NULL ? PRICE_NO_VALUE : ps->getCurrentPrice(PRICE_DIRECTION_EXPORT);
             if(exportPrice != PRICE_NO_VALUE) {
                 float income = exportPrice * kwhe;
-                this->realtimeData->incomeHour += income;
-                this->realtimeData->incomeDay += income;
+                realtimeData->incomeHour += income;
+                realtimeData->incomeDay += income;
             }
         }
-        this->realtimeData->lastExportUpdateMillis = amsData->getLastUpdateMillis();
+        realtimeData->lastExportUpdateMillis = lastUpdatedMillis;
     }
 
     if(config != NULL) {
-        while(getMonthMax() > config->thresholds[this->realtimeData->currentThresholdIdx] && this->realtimeData->currentThresholdIdx < 10) this->realtimeData->currentThresholdIdx++;
+        while(getMonthMax() > config->thresholds[realtimeData->currentThresholdIdx] && realtimeData->currentThresholdIdx < 10) realtimeData->currentThresholdIdx++;
     }
 
     return ret;
@@ -192,28 +194,36 @@ bool EnergyAccounting::update(AmsData* amsData) {
 
 void EnergyAccounting::calcDayCost() {
     time_t now = time(nullptr);
-    tmElements_t local, utc;
+    tmElements_t local, utc, lastUpdateUtc;
     if(tz == NULL) return;
     breakTime(tz->toLocal(now), local);
+    if(ps == NULL) return;
 
-    if(getPriceForHour(PRICE_DIRECTION_IMPORT, 0) != PRICE_NO_VALUE) {
-        if(initPrice) {
-            this->realtimeData->costDay = 0;
-            this->realtimeData->incomeDay = 0;
+    if(ps->hasPrice()) {
+        breakTime(data.lastUpdated, lastUpdateUtc);
+        uint8_t calcFromHour = 0;
+        if(lastUpdateUtc.Day != local.Day || lastUpdateUtc.Month != local.Month || lastUpdateUtc.Year != local.Year) {
+            realtimeData->costDay = 0;
+            realtimeData->incomeDay = 0;
+            calcFromHour = 0;
+        } else {
+            realtimeData->costDay = data.costToday / 100.0;
+            realtimeData->incomeDay = data.incomeToday / 100.0;
+            calcFromHour = lastUpdateUtc.Hour;
         }
-        for(uint8_t i = 0; i < this->realtimeData->currentHour; i++) {
+        for(uint8_t i = calcFromHour; i < realtimeData->currentHour; i++) {
             breakTime(now - ((local.Hour - i) * 3600), utc);
 
-            float priceIn = getPriceForHour(PRICE_DIRECTION_IMPORT, i - local.Hour);
+            float priceIn = ps->getPriceForRelativeHour(PRICE_DIRECTION_IMPORT, i - local.Hour);
             if(priceIn != PRICE_NO_VALUE) {
                 int16_t wh = ds->getHourImport(utc.Hour);
-                this->realtimeData->costDay += priceIn * (wh / 1000.0);
+                realtimeData->costDay += priceIn * (wh / 1000.0);
             }
 
-            float priceOut = getPriceForHour(PRICE_DIRECTION_EXPORT, i - local.Hour);
+            float priceOut = ps->getPriceForRelativeHour(PRICE_DIRECTION_EXPORT, i - local.Hour);
             if(priceOut != PRICE_NO_VALUE) {
                 int16_t wh = ds->getHourExport(utc.Hour);
-                this->realtimeData->incomeDay += priceOut * (wh / 1000.0);
+                realtimeData->incomeDay += priceOut * (wh / 1000.0);
             }
         }
         initPrice = true;
@@ -221,7 +231,7 @@ void EnergyAccounting::calcDayCost() {
 }
 
 float EnergyAccounting::getUseThisHour() {
-    return this->realtimeData->use;
+    return realtimeData->use;
 }
 
 float EnergyAccounting::getUseToday() {
@@ -231,7 +241,7 @@ float EnergyAccounting::getUseToday() {
     if(now < FirmwareVersion::BuildEpoch) return 0.0;
     tmElements_t utc, local;
     breakTime(tz->toLocal(now), local);
-    for(uint8_t i = 0; i < this->realtimeData->currentHour; i++) {
+    for(uint8_t i = 0; i < realtimeData->currentHour; i++) {
         breakTime(now - ((local.Hour - i) * 3600), utc);
         ret += ds->getHourImport(utc.Hour) / 1000.0;
     }
@@ -242,18 +252,20 @@ float EnergyAccounting::getUseThisMonth() {
     time_t now = time(nullptr);
     if(now < FirmwareVersion::BuildEpoch) return 0.0;
     float ret = 0;
-    for(uint8_t i = 1; i < this->realtimeData->currentDay; i++) {
+    for(uint8_t i = 1; i < realtimeData->currentDay; i++) {
         ret += ds->getDayImport(i) / 1000.0;
     }
     return ret + getUseToday();
 }
 
 float EnergyAccounting::getUseLastMonth() {
-    return (data.lastMonthImport * pow(10, data.lastMonthAccuracy)) / 1000;
+    float ret = (data.lastMonthImport * pow(10, data.lastMonthAccuracy)) / 1000;
+    if(std::isnan(ret)) return 0.0;
+    return ret;
 }
 
 float EnergyAccounting::getProducedThisHour() {
-    return this->realtimeData->produce;
+    return realtimeData->produce;
 }
 
 float EnergyAccounting::getProducedToday() {
@@ -263,7 +275,7 @@ float EnergyAccounting::getProducedToday() {
     if(now < FirmwareVersion::BuildEpoch) return 0.0;
     tmElements_t utc, local;
     breakTime(tz->toLocal(now), local);
-    for(uint8_t i = 0; i < this->realtimeData->currentHour; i++) {
+    for(uint8_t i = 0; i < realtimeData->currentHour; i++) {
         breakTime(now - ((local.Hour - i) * 3600), utc);
         ret += ds->getHourExport(utc.Hour) / 1000.0;
     }
@@ -274,22 +286,24 @@ float EnergyAccounting::getProducedThisMonth() {
     time_t now = time(nullptr);
     if(now < FirmwareVersion::BuildEpoch) return 0.0;
     float ret = 0;
-    for(uint8_t i = 1; i < this->realtimeData->currentDay; i++) {
+    for(uint8_t i = 1; i < realtimeData->currentDay; i++) {
         ret += ds->getDayExport(i) / 1000.0;
     }
     return ret + getProducedToday();
 }
 
 float EnergyAccounting::getProducedLastMonth() {
-    return (data.lastMonthExport * pow(10, data.lastMonthAccuracy)) / 1000;
+    float ret = (data.lastMonthExport * pow(10, data.lastMonthAccuracy)) / 1000;
+    if(std::isnan(ret)) return 0.0;
+    return ret;
 }
 
 float EnergyAccounting::getCostThisHour() {
-    return this->realtimeData->costHour;
+    return realtimeData->costHour;
 }
 
 float EnergyAccounting::getCostToday() {
-    return this->realtimeData->costDay;
+    return realtimeData->costDay;
 }
 
 float EnergyAccounting::getCostYesterday() {
@@ -305,11 +319,11 @@ float EnergyAccounting::getCostLastMonth() {
 }
 
 float EnergyAccounting::getIncomeThisHour() {
-    return this->realtimeData->incomeHour;
+    return realtimeData->incomeHour;
 }
 
 float EnergyAccounting::getIncomeToday() {
-    return this->realtimeData->incomeDay;
+    return realtimeData->incomeDay;
 }
 
 float EnergyAccounting::getIncomeYesterday() {
@@ -327,7 +341,7 @@ float EnergyAccounting::getIncomeLastMonth() {
 uint8_t EnergyAccounting::getCurrentThreshold() {
     if(config == NULL)
         return 0;
-    return config->thresholds[this->realtimeData->currentThresholdIdx];
+    return config->thresholds[realtimeData->currentThresholdIdx];
 }
 
 float EnergyAccounting::getMonthMax() {
@@ -407,85 +421,31 @@ bool EnergyAccounting::load() {
         char buf[file.size()];
         file.readBytes(buf, file.size());
 
-        if(buf[0] == 6) {
+        if(buf[0] == 7) {
             EnergyAccountingData* data = (EnergyAccountingData*) buf;
             memcpy(&this->data, data, sizeof(this->data));
             ret = true;
-        } else if(buf[0] == 5) {
-            EnergyAccountingData5* data = (EnergyAccountingData5*) buf;
-            this->data = { 6, data->month, 
-                ((uint32_t) data->costYesterday) * 10,
-                ((uint32_t) data->costThisMonth) * 100,
-                ((uint32_t) data->costLastMonth) * 100,
-                ((uint32_t) data->incomeYesterday) * 10,
-                ((uint32_t) data->incomeThisMonth) * 100,
-                ((uint32_t) data->incomeLastMonth) * 100,
-                0,0,0, // Last month import, export and accuracy
-                data->peaks[0].day, data->peaks[0].value,
-                data->peaks[1].day, data->peaks[1].value,
-                data->peaks[2].day, data->peaks[2].value,
-                data->peaks[3].day, data->peaks[3].value,
-                data->peaks[4].day, data->peaks[4].value
-            };
-            ret = true;
-        } else if(buf[0] == 4) {
-            EnergyAccountingData4* data = (EnergyAccountingData4*) buf;
-            this->data = { 5, data->month, 
-                ((uint32_t) data->costYesterday) * 10,
-                ((uint32_t) data->costThisMonth) * 100,
-                ((uint32_t) data->costLastMonth) * 100,
-                0,0,0, // Income from production
-                0,0,0, // Last month import, export and accuracy
-                data->peaks[0].day, data->peaks[0].value,
-                data->peaks[1].day, data->peaks[1].value,
-                data->peaks[2].day, data->peaks[2].value,
-                data->peaks[3].day, data->peaks[3].value,
-                data->peaks[4].day, data->peaks[4].value
-            };
-            ret = true;
-        } else if(buf[0] == 3) {
-            EnergyAccountingData* data = (EnergyAccountingData*) buf;
-            this->data = { 5, data->month, 
-                data->costYesterday * 10,
+        } else if(buf[0] == 6) {
+            EnergyAccountingData6* data = (EnergyAccountingData6*) buf;
+            this->data = { 7, data->month, 
+                0, // Cost today
+                data->costYesterday,
                 data->costThisMonth,
                 data->costLastMonth,
-                0,0,0, // Income from production
-                0,0,0, // Last month import, export and accuracy
-                data->peaks[0].day, data->peaks[0].value,
-                data->peaks[1].day, data->peaks[1].value,
-                data->peaks[2].day, data->peaks[2].value,
-                data->peaks[3].day, data->peaks[3].value,
-                data->peaks[4].day, data->peaks[4].value
+                0, // Income today
+                data->incomeYesterday,
+                data->incomeThisMonth,
+                data->incomeLastMonth,
+                data->lastMonthImport,
+                data->lastMonthExport,
+                data->lastMonthAccuracy,
+                data->peaks[0].day, 0, data->peaks[0].value,
+                data->peaks[1].day, 0, data->peaks[1].value,
+                data->peaks[2].day, 0, data->peaks[2].value,
+                data->peaks[3].day, 0, data->peaks[3].value,
+                data->peaks[4].day, 0, data->peaks[4].value
             };
             ret = true;
-        } else {
-            data = { 5, 0, 
-                0, 0, 0, // Cost
-                0,0,0, // Income from production
-                0,0,0, // Last month import, export and accuracy
-                0, 0, // Peak 1
-                0, 0, // Peak 2
-                0, 0, // Peak 3
-                0, 0, // Peak 4
-                0, 0 // Peak 5
-            };
-            if(buf[0] == 2) {
-                EnergyAccountingData2* data = (EnergyAccountingData2*) buf;
-                this->data.month = data->month;
-                this->data.costYesterday = data->costYesterday * 10;
-                this->data.costThisMonth = data->costThisMonth;
-                this->data.costLastMonth = data->costLastMonth;
-                uint8_t b = 0;
-                for(uint8_t i = sizeof(this->data); i < file.size(); i+=2) {
-                    this->data.peaks[b].day = b;
-                    memcpy(&this->data.peaks[b].value, buf+i, 2);
-                    b++;
-                    if(b >= config->hours || b >= 5) break;
-                }
-                ret = true;
-            } else {
-                ret = false;
-            }
         }
 
         file.close();
@@ -518,11 +478,12 @@ void EnergyAccounting::setData(EnergyAccountingData& data) {
     this->data = data;
 }
 
-bool EnergyAccounting::updateMax(uint16_t val, uint8_t day) {
+bool EnergyAccounting::updateMax(uint16_t val, uint8_t day, uint8_t hour) {
     for(uint8_t i = 0; i < 5; i++) {
         if(data.peaks[i].day == day || data.peaks[i].day == 0) {
             if(val > data.peaks[i].value) {
                 data.peaks[i].day = day;
+                data.peaks[i].hour = hour;
                 data.peaks[i].value = val;
                 return true;
             }
@@ -550,8 +511,3 @@ bool EnergyAccounting::updateMax(uint16_t val, uint8_t day) {
 void EnergyAccounting::setCurrency(String currency) {
     this->currency = currency;
 }
-
-float EnergyAccounting::getPriceForHour(uint8_t d, uint8_t h) {
-    if(ps == NULL) return PRICE_NO_VALUE;
-    return ps->getValueForHour(d, h);
-}

lib/FirmwareVersion/include/FirmwareVersion.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/FirmwareVersion/src/FirmwareVersion.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/HomeAssistantMqttHandler/include/HomeAssistantMqttHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -15,19 +15,19 @@
 class HomeAssistantMqttHandler : public AmsMqttHandler {
 public:
     #if defined(AMS_REMOTE_DEBUG)
-    HomeAssistantMqttHandler(MqttConfig& mqttConfig, RemoteDebug* debugger, char* buf, uint8_t boardType, HomeAssistantConfig config, HwTools* hw, AmsFirmwareUpdater* updater) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
+    HomeAssistantMqttHandler(MqttConfig& mqttConfig, RemoteDebug* debugger, char* buf, uint8_t boardType, HomeAssistantConfig config, HwTools* hw, AmsFirmwareUpdater* updater, char* hostname) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
     #else
-    HomeAssistantMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, uint8_t boardType, HomeAssistantConfig config, HwTools* hw) : AmsMqttHandler(mqttConfig, debugger, buf) {
+    HomeAssistantMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, uint8_t boardType, HomeAssistantConfig config, HwTools* hw, AmsFirmwareUpdater* updater, char* hostname) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
     #endif
         this->boardType = boardType;
         this->hw = hw;
-        setHomeAssistantConfig(config);
+        setHomeAssistantConfig(config, hostname);
     };
     bool publish(AmsData* data, AmsData* previousState, EnergyAccounting* ea, PriceService* ps);
     bool publishTemperatures(AmsConfiguration*, HwTools*);
     bool publishPrices(PriceService*);
     bool publishSystem(HwTools* hw, PriceService* ps, EnergyAccounting* ea);
-    bool publishRaw(String data);
+    bool publishRaw(uint8_t* raw, size_t length);
     bool publishFirmware();
 
     bool postConnect();
@@ -36,14 +36,10 @@ public:
 
     uint8_t getFormat();
 
-    void setHomeAssistantConfig(HomeAssistantConfig config);
+    void setHomeAssistantConfig(HomeAssistantConfig config, char* hostname);
 private:
     uint8_t boardType;
 
-    String pubTopic;
-    String subTopic;
-
-
     String deviceName;
     String deviceModel;
     String deviceUid;
@@ -55,9 +51,9 @@ private:
     String updateTopic;
     String sensorNamePrefix;
 
-    bool l1Init, l2Init, l2eInit, l3Init, l3eInit, l4Init, l4eInit, rtInit, rteInit, pInit, sInit, rInit, fInit;
+    bool l1Init, l2Init, l2eInit, l3Init, l3eInit, l4Init, l4eInit, rtInit, rteInit, pInit, sInit, rInit, fInit, dInit;
     bool tInit[32] = {false};
-    bool prInit[38] = {false};
+    uint8_t priceImportInit = 0, priceExportInit = 0;
     uint32_t lastThresholdPublish = 0;
 
     HwTools* hw;
@@ -83,6 +79,7 @@ private:
     void publishPriceSensors(PriceService* ps);
     void publishSystemSensors();
     void publishThresholdSensors();
+    void toJsonIsoTimestamp(time_t t, char* buf, size_t buflen);
 
     String boardTypeToString(uint8_t b) {
         switch(b) {

lib/HomeAssistantMqttHandler/include/HomeAssistantStatic.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -17,113 +17,113 @@ struct HomeAssistantSensor {
     const char* uom;
     const char* devcl;
     const char* stacl;
+    const char* uid;
 };
 
 
 const uint8_t List1SensorCount PROGMEM = 2;
 const HomeAssistantSensor List1Sensors[List1SensorCount] PROGMEM = {
-    {"Active import",              "/power",   "P",                   30, "W",    "power",           "measurement"},
-    {"Data timestamp",             "/power",   "t",                   30, "",     "timestamp",       ""}
+    {"Active import",              "/power",   "P",                   30, "W",    "power",           "measurement", ""},
+    {"Data timestamp",             "/power",   "t",                   30, "",     "timestamp",       "",            ""}
 };
 
 const uint8_t List2SensorCount PROGMEM = 8;
 const HomeAssistantSensor List2Sensors[List2SensorCount] PROGMEM = {
-    {"Reactive import",            "/power",   "Q",                   30, "var",  "reactive_power",  "measurement"},
-    {"Reactive export",            "/power",   "QO",                  30, "var",  "reactive_power",  "measurement"},
-    {"L1 current",                 "/power",   "I1",                  30, "A",    "current",         "measurement"},
-    {"L2 current",                 "/power",   "I2",                  30, "A",    "current",         "measurement"},
-    {"L3 current",                 "/power",   "I3",                  30, "A",    "current",         "measurement"},
-    {"L1 voltage",                 "/power",   "U1",                  30, "V",    "voltage",         "measurement"},
-    {"L2 voltage",                 "/power",   "U2",                  30, "V",    "voltage",         "measurement"},
-    {"L3 voltage",                 "/power",   "U3",                  30, "V",    "voltage",         "measurement"}
+    {"Reactive import",            "/power",   "Q",                   30, "var",  "reactive_power",  "measurement", ""},
+    {"Reactive export",            "/power",   "QO",                  30, "var",  "reactive_power",  "measurement", ""},
+    {"L1 current",                 "/power",   "I1",                  30, "A",    "current",         "measurement", ""},
+    {"L2 current",                 "/power",   "I2",                  30, "A",    "current",         "measurement", ""},
+    {"L3 current",                 "/power",   "I3",                  30, "A",    "current",         "measurement", ""},
+    {"L1 voltage",                 "/power",   "U1",                  30, "V",    "voltage",         "measurement", ""},
+    {"L2 voltage",                 "/power",   "U2",                  30, "V",    "voltage",         "measurement", ""},
+    {"L3 voltage",                 "/power",   "U3",                  30, "V",    "voltage",         "measurement", ""}
 };
 
 const uint8_t List2ExportSensorCount PROGMEM = 1;
 const HomeAssistantSensor List2ExportSensors[List2ExportSensorCount] PROGMEM = {
-    {"Active export",              "/power",   "PO",                  30, "W",    "power",           "measurement"}
+    {"Active export",              "/power",   "PO",                  30, "W",    "power",           "measurement", ""}
 };
 
 const uint8_t List3SensorCount PROGMEM = 4;
 const HomeAssistantSensor List3Sensors[List3SensorCount] PROGMEM = {
-    {"Accumulated active import",  "/energy",  "tPI",               4000, "kWh",  "energy",          "total_increasing"},
-    {"Accumulated reactive import","/energy",  "tQI",               4000, "kvarh","",                "total_increasing"},
-    {"Accumulated reactive export","/energy",  "tQO",               4000, "kvarh","",                "total_increasing"},
-    {"Meter timestamp",            "/energy",  "rtc",               4000, "",     "timestamp",       ""}
+    {"Accumulated active import",  "/energy",  "tPI",               4000, "kWh",  "energy",          "total_increasing", ""},
+    {"Accumulated reactive import","/energy",  "tQI",               4000, "kvarh","",                "total_increasing", ""},
+    {"Accumulated reactive export","/energy",  "tQO",               4000, "kvarh","",                "total_increasing", ""},
+    {"Meter timestamp",            "/energy",  "rtc",               4000, "",     "timestamp",       "",                 ""}
 };
 
 const uint8_t List3ExportSensorCount PROGMEM = 1;
 const HomeAssistantSensor List3ExportSensors[List3ExportSensorCount] PROGMEM = {
-    {"Accumulated active export",  "/energy",  "tPO",               4000, "kWh",  "energy",          "total_increasing"}
+    {"Accumulated active export",  "/energy",  "tPO",               4000, "kWh",  "energy",          "total_increasing", ""}
 };
 
 const uint8_t List4SensorCount PROGMEM = 10;
 const HomeAssistantSensor List4Sensors[List4SensorCount] PROGMEM = {
-    {"Power factor",                "/power",   "PF",                  30, "%",    "power_factor",    "measurement"},
-    {"L1 power factor",             "/power",   "PF1",                 30, "%",    "power_factor",    "measurement"},
-    {"L2 power factor",             "/power",   "PF2",                 30, "%",    "power_factor",    "measurement"},
-    {"L3 power factor",             "/power",   "PF3",                 30, "%",    "power_factor",    "measurement"},
-    {"L1 active import",            "/power",   "P1",                  30, "W",    "power",           "measurement"},
-    {"L2 active import",            "/power",   "P2",                  30, "W",    "power",           "measurement"},
-    {"L3 active import",            "/power",   "P3",                  30, "W",    "power",           "measurement"},
-    {"L1 accumulated active import","/power",   "tPI1",                30, "kWh",  "energy",          "total_increasing"},
-    {"L2 accumulated active import","/power",   "tPI2",                30, "kWh",  "energy",          "total_increasing"},
-    {"L3 accumulated active import","/power",   "tPI3",                30, "kWh",  "energy",          "total_increasing"}
+    {"Power factor",                "/power",   "PF",                  30, "%",    "power_factor",    "measurement", ""},
+    {"L1 power factor",             "/power",   "PF1",                 30, "%",    "power_factor",    "measurement", ""},
+    {"L2 power factor",             "/power",   "PF2",                 30, "%",    "power_factor",    "measurement", ""},
+    {"L3 power factor",             "/power",   "PF3",                 30, "%",    "power_factor",    "measurement", ""},
+    {"L1 active import",            "/power",   "P1",                  30, "W",    "power",           "measurement", ""},
+    {"L2 active import",            "/power",   "P2",                  30, "W",    "power",           "measurement", ""},
+    {"L3 active import",            "/power",   "P3",                  30, "W",    "power",           "measurement", ""},
+    {"L1 accumulated active import","/power",   "tPI1",                30, "kWh",  "energy",          "total_increasing", ""},
+    {"L2 accumulated active import","/power",   "tPI2",                30, "kWh",  "energy",          "total_increasing", ""},
+    {"L3 accumulated active import","/power",   "tPI3",                30, "kWh",  "energy",          "total_increasing", ""}
 };
 
 const uint8_t List4ExportSensorCount PROGMEM = 6;
 const HomeAssistantSensor List4ExportSensors[List4ExportSensorCount] PROGMEM = {
-    {"L1 active export",            "/power",   "PO1",                 30, "W",    "power",           "measurement"},
-    {"L2 active export",            "/power",   "PO2",                 30, "W",    "power",           "measurement"},
-    {"L3 active export",            "/power",   "PO3",                 30, "W",    "power",           "measurement"},
-    {"L1 accumulated active export","/power",   "tPO1",                30, "kWh",  "energy",          "total_increasing"},
-    {"L2 accumulated active export","/power",   "tPO2",                30, "kWh",  "energy",          "total_increasing"},
-    {"L3 accumulated active export","/power",   "tPO3",                30, "kWh",  "energy",          "total_increasing"}
+    {"L1 active export",            "/power",   "PO1",                 30, "W",    "power",           "measurement", ""},
+    {"L2 active export",            "/power",   "PO2",                 30, "W",    "power",           "measurement", ""},
+    {"L3 active export",            "/power",   "PO3",                 30, "W",    "power",           "measurement", ""},
+    {"L1 accumulated active export","/power",   "tPO1",                30, "kWh",  "energy",          "total_increasing", ""},
+    {"L2 accumulated active export","/power",   "tPO2",                30, "kWh",  "energy",          "total_increasing", ""},
+    {"L3 accumulated active export","/power",   "tPO3",                30, "kWh",  "energy",          "total_increasing", ""}
 };
 
 const uint8_t RealtimeSensorCount PROGMEM = 8;
 const HomeAssistantSensor RealtimeSensors[RealtimeSensorCount] PROGMEM = {
-    {"Month max",                  "/realtime","max",                120, "kWh",  "energy",          ""},
-    {"Tariff threshold",           "/realtime","threshold",          120, "kWh",  "energy",          ""},
-    {"Current hour used",          "/realtime","hour.use",           120, "kWh",  "energy",          "total_increasing"},
-    {"Current hour cost",          "/realtime","hour.cost",          120, "",     "monetary",        ""},
-    {"Current day used",           "/realtime","day.use",            120, "kWh",  "energy",          "total_increasing"},
-    {"Current day cost",           "/realtime","day.cost",           120, "",     "monetary",        ""},
-    {"Current month used",         "/realtime","month.use",          120, "kWh",  "energy",          "total_increasing"},
-    {"Current month cost",         "/realtime","month.cost",         120, "",     "monetary",        ""}
+    {"Month max",                  "/realtime","max",                120, "kWh",  "energy",          "",  ""},
+    {"Tariff threshold",           "/realtime","threshold",          120, "kWh",  "energy",          "",  ""},
+    {"Current hour used",          "/realtime","hour.use",           120, "kWh",  "energy",          "total_increasing", ""},
+    {"Current hour cost",          "/realtime","hour.cost",          120, "",     "monetary",        "",  ""},
+    {"Current day used",           "/realtime","day.use",            120, "kWh",  "energy",          "total_increasing", ""},
+    {"Current day cost",           "/realtime","day.cost",           120, "",     "monetary",        "",  ""},
+    {"Current month used",         "/realtime","month.use",          120, "kWh",  "energy",          "total_increasing", ""},
+    {"Current month cost",         "/realtime","month.cost",         120, "",     "monetary",        "",  ""}
 };
 
 const uint8_t RealtimeExportSensorCount PROGMEM = 6;
 const HomeAssistantSensor RealtimeExportSensors[RealtimeExportSensorCount] PROGMEM = {
-    {"Current hour produced",      "/realtime","hour.produced",      120, "kWh",  "energy",          "total_increasing"},
-    {"Current hour income",        "/realtime","hour.income",        120, "",     "monetary",        ""},
-    {"Current day produced",       "/realtime","day.produced",       120, "kWh",  "energy",          "total_increasing"},
-    {"Current day income",         "/realtime","day.income",         120, "",     "monetary",        ""},
-    {"Current month produced",     "/realtime","month.produced",     120, "kWh",  "energy",          "total_increasing"},
-    {"Current month income",       "/realtime","month.income",       120, "",     "monetary",        ""}
+    {"Current hour produced",      "/realtime","hour.produced",      120, "kWh",  "energy",          "total_increasing", ""},
+    {"Current hour income",        "/realtime","hour.income",        120, "",     "monetary",        "",  ""},
+    {"Current day produced",       "/realtime","day.produced",       120, "kWh",  "energy",          "total_increasing", ""},
+    {"Current day income",         "/realtime","day.income",         120, "",     "monetary",        "",  ""},
+    {"Current month produced",     "/realtime","month.produced",     120, "kWh",  "energy",          "total_increasing", ""},
+    {"Current month income",       "/realtime","month.income",       120, "",     "monetary",        "",  ""}
 };
 
-const HomeAssistantSensor RealtimePeakSensor PROGMEM = {"Current month peak %d", "/realtime", "peaks[%d]", 4000, "kWh", "energy", ""};
-const HomeAssistantSensor RealtimeThresholdSensor PROGMEM = {"Tariff threshold %d", "/realtime", "thresholds[%d]", 4000, "kWh", "energy", ""};
+const HomeAssistantSensor RealtimePeakSensor PROGMEM = {"Current month peak %d", "/realtime", "peaks[%d]", 4000, "kWh", "energy", "",  ""};
+const HomeAssistantSensor RealtimeThresholdSensor PROGMEM = {"Tariff threshold %d", "/realtime", "thresholds[%d]", 4000, "kWh", "energy", "",  ""};
 
 const uint8_t PriceSensorCount PROGMEM = 5;
 const HomeAssistantSensor PriceSensors[PriceSensorCount] PROGMEM = {
-    {"Minimum price ahead",        "/prices",  "prices.min",        4000, "",     "monetary",        ""},
-    {"Maximum price ahead",        "/prices",  "prices.max",        4000, "",     "monetary",        ""},
-    {"Cheapest 1hr period ahead",  "/prices",  "prices.cheapest1hr",4000, "",     "timestamp",       ""},
-    {"Cheapest 3hr period ahead",  "/prices",  "prices.cheapest3hr",4000, "",     "timestamp",       ""},
-    {"Cheapest 6hr period ahead",  "/prices",  "prices.cheapest6hr",4000, "",     "timestamp",       ""}
+    {"Minimum price ahead",        "/prices",  "prices.min",     4000, "",     "monetary",        "",  ""},
+    {"Maximum price ahead",        "/prices",  "prices.max",     4000, "",     "monetary",        "",  ""},
+    {"Cheapest 1hr period ahead",  "/prices",  "prices.cheapest1hr",    4000, "",     "timestamp",       "",  ""},
+    {"Cheapest 3hr period ahead",  "/prices",  "prices.cheapest3hr",    4000, "",     "timestamp",       "",  ""},
+    {"Cheapest 6hr period ahead",  "/prices",  "prices.cheapest6hr",    4000, "",     "timestamp",       "",  ""}
 };
 
-const HomeAssistantSensor PriceSensor PROGMEM = {"Price in %02d %s", "/prices", "prices['%d']", 4000, "", "monetary", ""};
-
 const uint8_t SystemSensorCount PROGMEM = 3;
 const HomeAssistantSensor SystemSensors[SystemSensorCount] PROGMEM = {
-    {"Status",                     "/state",   "rssi",               180, "dBm",  "signal_strength", "measurement"},
-    {"Supply volt",                "/state",   "vcc",                180, "V",    "voltage",         "measurement"},
-    {"Uptime",                     "/state",   "up",                 180, "s",    "duration",        "measurement"}
+    {"Status",                     "/state",   "rssi",               180, "dBm",  "signal_strength", "measurement", ""},
+    {"Supply volt",                "/state",   "vcc",                180, "V",    "voltage",         "measurement", ""},
+    {"Uptime",                     "/state",   "up",                 180, "s",    "duration",        "measurement", ""}
 };
 
-const HomeAssistantSensor TemperatureSensor PROGMEM = {"Temperature sensor %s", "/temperatures", "temperatures['%s']", 900, "°C", "temperature", "measurement"};
+const HomeAssistantSensor TemperatureSensor PROGMEM = {"Temperature sensor %s", "/temperatures", "temperatures['%s']", 900, "°C", "temperature", "measurement", ""};
 
+const HomeAssistantSensor DataSensor PROGMEM = {"Data", "/data", "data", 900, "", "", "", ""};
 
 #endif

lib/HomeAssistantMqttHandler/json/ha1.json

@@ -1,4 +1,4 @@
 {
     "P" : %lu,
-    "t" : "%s"
+    "t" : %s
 }

lib/HomeAssistantMqttHandler/json/ha2.json

@@ -3,6 +3,6 @@
     "tPO" : %.3f,
     "tQI" : %.3f,
     "tQO" : %.3f,
-    "rtc" : "%s",
-    "t" : "%s"
+    "rtc" : %s,
+    "t" : %s
 }

lib/HomeAssistantMqttHandler/json/ha3.json

@@ -12,5 +12,5 @@
     "U1" : %.2f,
     "U2" : %.2f,
     "U3" : %.2f,
-    "t" : "%s"
+    "t" : %s
 }

lib/HomeAssistantMqttHandler/json/ha4.json

@@ -28,5 +28,5 @@
     "tPO1" : %.3f,
     "tPO2" : %.3f,
     "tPO3" : %.3f,
-    "t" : "%s"
+    "t" : %s
 }

lib/HomeAssistantMqttHandler/json/hadiscover.json

@@ -2,8 +2,7 @@
     "name" : "%s%s",
     "stat_t" : "%s%s",
     "uniq_id" : "%s_%s",
-    "obj_id" : "%s_%s",
-    "unit_of_meas" : "%s",
+    "default_entity_id" : "sensor.%s_%s",
     "val_tpl" : "{{ value_json.%s | is_defined }}",
     "expire_after" : %d,
     "dev" : {
@@ -13,5 +12,8 @@
       "sw" : "%s",
       "mf" : "%s",
       "cu" : "%s"
-    }%s%s%s%s%s%s
+    }
+    %s%s%s
+    %s%s%s
+    %s%s%s
 }

lib/HomeAssistantMqttHandler/src/HomeAssistantMqttHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -19,12 +19,8 @@
 #include <esp_task_wdt.h>
 #endif
 
-void HomeAssistantMqttHandler::setHomeAssistantConfig(HomeAssistantConfig config) {
-    l1Init = l2Init = l2eInit = l3Init = l3eInit = l4Init = l4eInit = rtInit = rteInit = pInit = sInit = rInit = fInit = false;
-
-    pubTopic = String(mqttConfig.publishTopic);
-    subTopic = String(mqttConfig.subscribeTopic);
-    if(subTopic.isEmpty()) subTopic = pubTopic+"/command";
+void HomeAssistantMqttHandler::setHomeAssistantConfig(HomeAssistantConfig config, char* hostname) {
+    l1Init = l2Init = l2eInit = l3Init = l3eInit = l4Init = l4eInit = rtInit = rteInit = pInit = sInit = rInit = fInit = dInit = false;
 
     if(strlen(config.discoveryNameTag) > 0) {
         snprintf_P(json, 128, PSTR("AMS reader (%s)"), config.discoveryNameTag);
@@ -32,21 +28,18 @@ void HomeAssistantMqttHandler::setHomeAssistantConfig(HomeAssistantConfig config
         snprintf_P(json, 128, PSTR("[%s] "), config.discoveryNameTag);
         sensorNamePrefix = String(json);
     } else {
-        deviceName = F("AMS reader");
+        snprintf_P(json, 128, PSTR("AMS reader"));
+        deviceName = String(json);
         sensorNamePrefix = "";
     }
     deviceModel = boardTypeToString(boardType);
     manufacturer = boardManufacturerToString(boardType);
 
-    char hostname[32];
-    #if defined(ESP8266)
-        strcpy(hostname, WiFi.hostname().c_str());
-    #elif defined(ESP32)
-        strcpy(hostname, WiFi.getHostname());
-    #endif
-
-    stripNonAscii((uint8_t*) hostname, 32, false);
     deviceUid = String(hostname); // Maybe configurable in the future?
+    #if defined(AMS_REMOTE_DEBUG)
+    if (debugger->isActive(RemoteDebug::INFO))
+    #endif
+    debugger->printf_P(PSTR("  Hostname is [%s]\n"), hostname);
 
     if(strlen(config.discoveryHostname) > 0) {
         if(strncmp_P(config.discoveryHostname, PSTR("http"), 4) == 0) {
@@ -60,36 +53,42 @@ void HomeAssistantMqttHandler::setHomeAssistantConfig(HomeAssistantConfig config
         deviceUrl = String(json);
     }
 
-    if(strlen(config.discoveryPrefix) > 0) {
-        snprintf_P(json, 128, PSTR("%s/status"), config.discoveryPrefix);
-        statusTopic = String(json);
-
-        snprintf_P(json, 128, PSTR("%s/sensor"), config.discoveryPrefix);
-        sensorTopic = String(json);
-
-        snprintf_P(json, 128, PSTR("%s/update"), config.discoveryPrefix);
-        updateTopic = String(json);
-    } else {
-        statusTopic = F("homeassistant/status");
-        sensorTopic = F("homeassistant/sensor");
-        updateTopic = F("homeassistant/update");
+    if(strlen(config.discoveryPrefix) == 0) {
+        snprintf_P(config.discoveryPrefix, 64, PSTR("homeassistant"));
     }
+
+    snprintf_P(json, 128, PSTR("%s/status"), config.discoveryPrefix);
+    statusTopic = String(json);
+
+    snprintf_P(json, 128, PSTR("%s/sensor"), config.discoveryPrefix);
+    sensorTopic = String(json);
+
+    snprintf_P(json, 128, PSTR("%s/update"), config.discoveryPrefix);
+    updateTopic = String(json);
     strcpy(this->mqttConfig.subscribeTopic, statusTopic.c_str());
 }
 
 bool HomeAssistantMqttHandler::postConnect() {
-    if(!subTopic.isEmpty() && !mqtt.subscribe(subTopic)) {
-        #if defined(AMS_REMOTE_DEBUG)
-        if (debugger->isActive(RemoteDebug::ERROR))
-        #endif
-        debugger->printf_P(PSTR("  Unable to subscribe to to [%s]\n"), subTopic.c_str());
-        return false;
+    bool ret = true;
+    if(!statusTopic.isEmpty()) {
+        if(mqtt.subscribe(statusTopic)) {
+            #if defined(AMS_REMOTE_DEBUG)
+            if (debugger->isActive(RemoteDebug::ERROR))
+            #endif
+            debugger->printf_P(PSTR("  Subscribed to [%s]\n"), statusTopic.c_str());
+        } else {
+            #if defined(AMS_REMOTE_DEBUG)
+            if (debugger->isActive(RemoteDebug::ERROR))
+            #endif
+            debugger->printf_P(PSTR("  Unable to subscribe to [%s]\n"), statusTopic.c_str());
+            ret = false;
+        }
     }
-    return true;
+    return ret;
 }
 
 bool HomeAssistantMqttHandler::publish(AmsData* update, AmsData* previousState, EnergyAccounting* ea, PriceService* ps) {
-	if(pubTopic.isEmpty() || !mqtt.connected())
+	if(pubTopic.isEmpty() || !connected())
 		return false;
 
     if(time(nullptr) < FirmwareVersion::BuildEpoch)
@@ -134,12 +133,7 @@ bool HomeAssistantMqttHandler::publishList1(AmsData* data, EnergyAccounting* ea)
     publishList1Sensors();
 
 	char pt[24];
-    memset(pt, 0, 24);
-    if(data->getPackageTimestamp() > 0) {
-        tmElements_t tm;
-        breakTime(data->getPackageTimestamp(), tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
+    toJsonIsoTimestamp(data->getPackageTimestamp(), pt, sizeof(pt));
 
     snprintf_P(json, BufferSize, HA1_JSON, data->getActiveImportPower(), pt);
     return mqtt.publish(pubTopic + "/power", json);
@@ -150,12 +144,7 @@ bool HomeAssistantMqttHandler::publishList2(AmsData* data, EnergyAccounting* ea)
     if(data->getActiveExportPower() > 0) publishList2ExportSensors();
 
 	char pt[24];
-    memset(pt, 0, 24);
-    if(data->getPackageTimestamp() > 0) {
-        tmElements_t tm;
-        breakTime(data->getPackageTimestamp(), tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
+    toJsonIsoTimestamp(data->getPackageTimestamp(), pt, sizeof(pt));
 
     snprintf_P(json, BufferSize, HA3_JSON,
         data->getListId().c_str(),
@@ -181,20 +170,11 @@ bool HomeAssistantMqttHandler::publishList3(AmsData* data, EnergyAccounting* ea)
     if(data->getActiveExportCounter() > 0.0) publishList3ExportSensors();
 
 	char mt[24];
-    memset(mt, 0, 24);
-    if(data->getMeterTimestamp() > 0) {
-        tmElements_t tm;
-        breakTime(data->getMeterTimestamp(), tm);
-        sprintf_P(mt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
+    toJsonIsoTimestamp(data->getMeterTimestamp(), mt, sizeof(mt));
 
 	char pt[24];
     memset(pt, 0, 24);
-    if(data->getPackageTimestamp() > 0) {
-        tmElements_t tm;
-        breakTime(data->getPackageTimestamp(), tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
+    toJsonIsoTimestamp(data->getPackageTimestamp(), pt, sizeof(pt));
 
     snprintf_P(json, BufferSize, HA2_JSON,
         data->getActiveImportCounter(),
@@ -212,12 +192,7 @@ bool HomeAssistantMqttHandler::publishList4(AmsData* data, EnergyAccounting* ea)
     if(data->getL1ActiveExportPower() > 0 || data->getL2ActiveExportPower() > 0 || data->getL3ActiveExportPower() > 0) publishList4ExportSensors();
 
 	char pt[24];
-    memset(pt, 0, 24);
-    if(data->getPackageTimestamp() > 0) {
-        tmElements_t tm;
-        breakTime(data->getPackageTimestamp(), tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
+    toJsonIsoTimestamp(data->getPackageTimestamp(), pt, sizeof(pt));
 
     snprintf_P(json, BufferSize, HA4_JSON,
         data->getListId().c_str(),
@@ -307,13 +282,8 @@ bool HomeAssistantMqttHandler::publishRealtime(AmsData* data, EnergyAccounting*
 
     time_t now = time(nullptr);
 	char pt[24];
-    memset(pt, 0, 24);
-    if(now > 0) {
-        tmElements_t tm;
-        breakTime(now, tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
-    pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"t\":\"%s\""), pt);
+    toJsonIsoTimestamp(now, pt, sizeof(pt));
+    pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"t\":%s"), pt);
     
     json[pos++] = '}';
     json[pos] = '\0';
@@ -343,13 +313,8 @@ bool HomeAssistantMqttHandler::publishTemperatures(AmsConfiguration* config, HwT
 
     time_t now = time(nullptr);
 	char pt[24];
-    memset(pt, 0, 24);
-    if(now > 0) {
-        tmElements_t tm;
-        breakTime(now, tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
-    pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"t\":\"%s\""), pt);
+    toJsonIsoTimestamp(now, pt, sizeof(pt));
+    pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"t\":%s"), pt);
 	pos += snprintf_P(json+pos, BufferSize-pos, PSTR("}"));
 
     bool ret = mqtt.publish(pubTopic + "/temperatures", json);
@@ -358,9 +323,9 @@ bool HomeAssistantMqttHandler::publishTemperatures(AmsConfiguration* config, HwT
 }
 
 bool HomeAssistantMqttHandler::publishPrices(PriceService* ps) {
-	if(pubTopic.isEmpty() || !mqtt.connected())
+	if(pubTopic.isEmpty() || !connected())
 		return false;
-	if(ps->getValueForHour(PRICE_DIRECTION_IMPORT, 0) == PRICE_NO_VALUE)
+	if(!ps->hasPrice())
 		return false;
 
     publishPriceSensors(ps);
@@ -373,7 +338,7 @@ bool HomeAssistantMqttHandler::publishPrices(PriceService* ps) {
 	float values[38];
     for(int i = 0;i < 38; i++) values[i] = PRICE_NO_VALUE;
 	for(uint8_t i = 0; i < 38; i++) {
-		float val = ps->getValueForHour(PRICE_DIRECTION_IMPORT, now, i);
+		float val = ps->getPriceForRelativeHour(PRICE_DIRECTION_IMPORT, i);
 		values[i] = val;
 
 		if(val == PRICE_NO_VALUE) break;
@@ -421,59 +386,73 @@ bool HomeAssistantMqttHandler::publishPrices(PriceService* ps) {
     memset(ts1hr, 0, 24);
 	if(min1hrIdx > -1) {
         time_t ts = now + (SECS_PER_HOUR * min1hrIdx);
-		tmElements_t tm;
+        tmElements_t tm;
         breakTime(ts, tm);
-		sprintf_P(ts1hr, PSTR("%04d-%02d-%02dT%02d:00:00Z"), tm.Year+1970, tm.Month, tm.Day, tm.Hour);
+        tm.Minute = 0;
+        tm.Second = 0;
+        ts = makeTime(tm);
+        toJsonIsoTimestamp(ts, ts1hr, sizeof(ts1hr));
 	}
 	char ts3hr[24];
     memset(ts3hr, 0, 24);
 	if(min3hrIdx > -1) {
         time_t ts = now + (SECS_PER_HOUR * min3hrIdx);
-		tmElements_t tm;
+        tmElements_t tm;
         breakTime(ts, tm);
-		sprintf_P(ts3hr, PSTR("%04d-%02d-%02dT%02d:00:00Z"), tm.Year+1970, tm.Month, tm.Day, tm.Hour);
+        tm.Minute = 0;
+        tm.Second = 0;
+        ts = makeTime(tm);
+        toJsonIsoTimestamp(ts, ts3hr, sizeof(ts3hr));
 	}
 	char ts6hr[24];
     memset(ts6hr, 0, 24);
 	if(min6hrIdx > -1) {
         time_t ts = now + (SECS_PER_HOUR * min6hrIdx);
-		tmElements_t tm;
+        tmElements_t tm;
         breakTime(ts, tm);
-		sprintf_P(ts6hr, PSTR("%04d-%02d-%02dT%02d:00:00Z"), tm.Year+1970, tm.Month, tm.Day, tm.Hour);
+        tm.Minute = 0;
+        tm.Second = 0;
+        ts = makeTime(tm);
+        toJsonIsoTimestamp(ts, ts6hr, sizeof(ts6hr));
 	}
 
-    uint16_t pos = snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\",\"prices\":{"), WiFi.macAddress().c_str());
-    for(uint8_t i = 0;i < 38; i++) {
-        if(values[i] == PRICE_NO_VALUE) {
-            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"%d\":null,"), i);
+    uint16_t pos = snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\",\"prices\":{\"import\":["), WiFi.macAddress().c_str());
+
+    uint8_t currentPricePointIndex = ps->getCurrentPricePointIndex();
+	uint8_t numberOfPoints = ps->getNumberOfPointsAvailable();
+	for(int i = currentPricePointIndex; i < numberOfPoints; i++) {
+		float val = ps->getPricePoint(PRICE_DIRECTION_IMPORT, i);
+        if(val == PRICE_NO_VALUE) {
+            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("null,"));
         } else {
-            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"%d\":%.4f,"), i, values[i]);
+            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("%.4f,"), val);
+        }
+	}
+    if(rteInit && ps->isExportPricesDifferentFromImport()) {
+        pos--;
+        pos += snprintf_P(json+pos, BufferSize-pos, PSTR("],\"export\":["));
+        for(int i = currentPricePointIndex; i < numberOfPoints; i++) {
+            float val = ps->getPricePoint(PRICE_DIRECTION_EXPORT, i);
+            if(val == PRICE_NO_VALUE) {
+                pos += snprintf_P(json+pos, BufferSize-pos, PSTR("null,"));
+            } else {
+                pos += snprintf_P(json+pos, BufferSize-pos, PSTR("%.4f,"), val);
+            }
         }
     }
 
-    pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"min\":%.4f,\"max\":%.4f,\"cheapest1hr\":\"%s\",\"cheapest3hr\":\"%s\",\"cheapest6hr\":\"%s\"}"),
+    pos--;
+    pos += snprintf_P(json+pos, BufferSize-pos, PSTR("],\"min\":%.4f,\"max\":%.4f,\"cheapest1hr\":%s,\"cheapest3hr\":%s,\"cheapest6hr\":%s}"),
         min == INT16_MAX ? 0.0 : min,
         max == INT16_MIN ? 0.0 : max,
         ts1hr,
         ts3hr,
         ts6hr
     );
-
-    float val = ps->getValueForHour(PRICE_DIRECTION_EXPORT, now, 0);
-    if(val == PRICE_NO_VALUE) {
-        pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"exportprices\":{\"0\":null}"));
-    } else {
-        pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"exportprices\":{\"0\":%.4f}"), val);
-    }
-
-	char pt[24];
-    memset(pt, 0, 24);
-    if(now > 0) {
-        tmElements_t tm;
-        breakTime(now, tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
-    pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"t\":\"%s\""), pt);
+    
+    char pt[24];
+    toJsonIsoTimestamp(now, pt, sizeof(pt));
+    pos += snprintf_P(json+pos, BufferSize-pos, PSTR(",\"t\":%s"), pt);
 
     json[pos++] = '}';
     json[pos] = '\0';
@@ -484,7 +463,7 @@ bool HomeAssistantMqttHandler::publishPrices(PriceService* ps) {
 }
 
 bool HomeAssistantMqttHandler::publishSystem(HwTools* hw, PriceService* ps, EnergyAccounting* ea) {
-	if(pubTopic.isEmpty() || !mqtt.connected())
+	if(pubTopic.isEmpty() || !connected())
 		return false;
 
     publishSystemSensors();
@@ -492,14 +471,9 @@ bool HomeAssistantMqttHandler::publishSystem(HwTools* hw, PriceService* ps, Ener
 
 	time_t now = time(nullptr);
 	char pt[24];
-    memset(pt, 0, 24);
-    if(now > 0) {
-        tmElements_t tm;
-        breakTime(now, tm);
-        sprintf_P(pt, PSTR("%04d-%02d-%02dT%02d:%02d:%02dZ"), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
-    }
+    toJsonIsoTimestamp(now, pt, sizeof(pt));
 
-    snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\",\"name\":\"%s\",\"up\":%d,\"vcc\":%.3f,\"rssi\":%d,\"temp\":%.2f,\"version\":\"%s\",\"t\":\"%s\"}"),
+    snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\",\"name\":\"%s\",\"up\":%d,\"vcc\":%.3f,\"rssi\":%d,\"temp\":%.2f,\"version\":\"%s\",\"t\":%s}"),
         WiFi.macAddress().c_str(),
         mqttConfig.clientId,
         (uint32_t) (millis64()/1000),
@@ -515,18 +489,22 @@ bool HomeAssistantMqttHandler::publishSystem(HwTools* hw, PriceService* ps, Ener
 }
 
 void HomeAssistantMqttHandler::publishSensor(const HomeAssistantSensor sensor) {
-    String uid = String(sensor.path);
-    uid.replace(".", "");
-    uid.replace("[", "");
-    uid.replace("]", "");
-    uid.replace("'", "");
+    String uid;
+    if(strlen(sensor.uid) > 0) {
+        uid = String(sensor.uid);
+    } else {
+        uid = String(sensor.path);
+        uid.replace(".", "");
+        uid.replace("[", "");
+        uid.replace("]", "");
+        uid.replace("'", "");
+    }
     snprintf_P(json, BufferSize, HADISCOVER_JSON,
         sensorNamePrefix.c_str(),
         sensor.name,
         mqttConfig.publishTopic, sensor.topic,
         deviceUid.c_str(), uid.c_str(),
         deviceUid.c_str(), uid.c_str(),
-        sensor.uom,
         sensor.path,
         sensor.ttl,
         deviceUid.c_str(),
@@ -535,14 +513,21 @@ void HomeAssistantMqttHandler::publishSensor(const HomeAssistantSensor sensor) {
         FirmwareVersion::VersionString,
         manufacturer.c_str(),
         deviceUrl.c_str(),
+
         strlen_P(sensor.devcl) > 0 ? ",\"dev_cla\":\"" : "",
         strlen_P(sensor.devcl) > 0 ? (char *) FPSTR(sensor.devcl) : "",
         strlen_P(sensor.devcl) > 0 ? "\"" : "",
+
         strlen_P(sensor.stacl) > 0 ? ",\"stat_cla\":\"" : "",
         strlen_P(sensor.stacl) > 0 ? (char *) FPSTR(sensor.stacl) : "",
-        strlen_P(sensor.stacl) > 0 ? "\"" : ""
+        strlen_P(sensor.stacl) > 0 ? "\"" : "",
+
+        strlen_P(sensor.uom) > 0 ? ",\"unit_of_meas\":\"" : "",
+        strlen_P(sensor.uom) > 0 ? (char *) FPSTR(sensor.uom) : "",
+        strlen_P(sensor.uom) > 0 ? "\"" : ""
     );
-    mqtt.publish(sensorTopic + "/" + deviceUid + "_" + uid.c_str() + "/config", json, true, 0);
+
+    mqtt.publish(sensorTopic + "/" + deviceUid + "_" + uid + "/config", json, true, 0);
     loop();
 }
 
@@ -631,7 +616,8 @@ void HomeAssistantMqttHandler::publishRealtimeSensors(EnergyAccounting* ea, Pric
             RealtimePeakSensor.ttl,
             RealtimePeakSensor.uom,
             RealtimePeakSensor.devcl,
-            RealtimePeakSensor.stacl
+            RealtimePeakSensor.stacl,
+            RealtimePeakSensor.uid
         };
         publishSensor(sensor);
     }
@@ -670,7 +656,8 @@ void HomeAssistantMqttHandler::publishTemperatureSensor(uint8_t index, String id
         TemperatureSensor.ttl,
         TemperatureSensor.uom,
         TemperatureSensor.devcl,
-        TemperatureSensor.stacl
+        TemperatureSensor.stacl,
+        TemperatureSensor.uid
     };
     publishSensor(sensor);
     tInit[index] = true;
@@ -690,45 +677,96 @@ void HomeAssistantMqttHandler::publishPriceSensors(PriceService* ps) {
         }
         pInit = true;
     }
-    for(uint8_t i = 0; i < 38; i++) {
-        if(prInit[i]) continue;
-        float val = ps->getValueForHour(PRICE_DIRECTION_IMPORT, i);
-        if(val == PRICE_NO_VALUE) continue;
-        
-        char name[strlen(PriceSensor.name)+2];
-        snprintf(name, strlen(PriceSensor.name)+2, PriceSensor.name, i, i == 1 ? "hour" : "hours");
-        char path[strlen(PriceSensor.path)+1];
-        snprintf(path, strlen(PriceSensor.path)+1, PriceSensor.path, i);
-        HomeAssistantSensor sensor = {
-            i == 0 ? "Price current hour" : name,
-            PriceSensor.topic,
-            path,
-            PriceSensor.ttl,
-            uom.c_str(),
-            PriceSensor.devcl,
-            i == 0 ? "total" : PriceSensor.stacl
-        };
-        publishSensor(sensor);
-        prInit[i] = true;
+
+    uint8_t currentPricePointIndex = ps->getCurrentPricePointIndex();
+	uint8_t numberOfPoints = ps->getNumberOfPointsAvailable();
+
+    if(priceImportInit < numberOfPoints-currentPricePointIndex) {
+        uint8_t importPriceSensorNo = 0;
+        for(int pricePointIndex = currentPricePointIndex; pricePointIndex < numberOfPoints; pricePointIndex++) {
+            float val = ps->getPricePoint(PRICE_DIRECTION_IMPORT, pricePointIndex);
+            if(val == PRICE_NO_VALUE) break;
+            if(importPriceSensorNo < priceImportInit) {
+                importPriceSensorNo++;
+                continue;
+            }
+
+            uint8_t resolution = ps->getResolutionInMinutes();
+
+            char path[64];
+            memset(path, 0, 64);
+            snprintf_P(path, 64, PSTR("prices.import[%d]"), importPriceSensorNo);
+
+            char uid[32];
+            memset(uid, 0, 32);
+            snprintf_P(uid, 32, PSTR("prices%d"), importPriceSensorNo);
+
+            char name[64];
+            if(resolution == 60) 
+                snprintf_P(name, 64, PSTR("Import price in %02d hour%s"), importPriceSensorNo, importPriceSensorNo == 1 ? "" : "s");
+            else    
+                snprintf_P(name, 64, PSTR("Import price in %03d minutes"), importPriceSensorNo * resolution);
+
+            HomeAssistantSensor sensor = {
+                importPriceSensorNo == 0 ? "Current import price" : name,
+                "/prices",
+                path,
+                resolution * 60 + 300,
+                uom.c_str(),
+                "monetary",
+                importPriceSensorNo == 0 ? "total" : "",
+                uid
+            };
+            publishSensor(sensor);
+
+            priceImportInit = importPriceSensorNo++;
+        }
     }
 
-    float exportPrice = ps->getValueForHour(PRICE_DIRECTION_EXPORT, 0);
-    if(exportPrice != PRICE_NO_VALUE) {
-        char path[20];
-        snprintf(path, 20, "exportprices['%d']", 0);
-        HomeAssistantSensor sensor = {
-            "Export price current hour",
-            PriceSensor.topic,
-            path,
-            PriceSensor.ttl,
-            uom.c_str(),
-            PriceSensor.devcl,
-            "total"
-        };
-        publishSensor(sensor);
+    if(priceExportInit < numberOfPoints-currentPricePointIndex) {
+        uint8_t exportPriceSensorNo = 0;
+        for(int pricePointIndex = currentPricePointIndex; pricePointIndex < numberOfPoints; pricePointIndex++) {
+            float val = ps->getPricePoint(PRICE_DIRECTION_EXPORT, pricePointIndex);
+            if(val == PRICE_NO_VALUE) break;
+            if(exportPriceSensorNo < priceExportInit) {
+                exportPriceSensorNo++;
+                continue;
+            }
+
+            uint8_t resolution = ps->getResolutionInMinutes();
+
+            char path[64];
+            memset(path, 0, 64);
+            snprintf_P(path, 64, PSTR("prices.export[%d]"), exportPriceSensorNo);
+
+            char uid[32];
+            memset(uid, 0, 32);
+            snprintf_P(uid, 32, PSTR("exportprices%d"), exportPriceSensorNo);
+
+                        char name[64];
+            if(resolution == 60) 
+                snprintf_P(name, 64, PSTR("Export price in %02d hour%s"), exportPriceSensorNo, exportPriceSensorNo == 1 ? "" : "s");
+            else    
+                snprintf_P(name, 64, PSTR("Export price in %03d minutes"), exportPriceSensorNo * resolution);
+
+            HomeAssistantSensor sensor = {
+                exportPriceSensorNo == 0 ? "Current export price" : name,
+                "/prices",
+                path,
+                resolution * 60 + 300,
+                uom.c_str(),
+                "monetary",
+                exportPriceSensorNo == 0 ? "total" : "",
+                uid
+            };
+            publishSensor(sensor);
+
+            priceExportInit = exportPriceSensorNo++;
+        }
     }
 }
 
+
 void HomeAssistantMqttHandler::publishSystemSensors() {
     if(sInit) return;
     for(uint8_t i = 0; i < SystemSensorCount; i++) {
@@ -751,7 +789,8 @@ void HomeAssistantMqttHandler::publishThresholdSensors() {
             RealtimeThresholdSensor.ttl,
             RealtimeThresholdSensor.uom,
             RealtimeThresholdSensor.devcl,
-            RealtimeThresholdSensor.stacl
+            RealtimeThresholdSensor.stacl,
+            RealtimeThresholdSensor.uid
         };
         publishSensor(sensor);
     }
@@ -762,15 +801,34 @@ uint8_t HomeAssistantMqttHandler::getFormat() {
     return 4;
 }
 
-bool HomeAssistantMqttHandler::publishRaw(String data) {
-    return false;
+bool HomeAssistantMqttHandler::publishRaw(uint8_t* raw, size_t length) {
+	if(strlen(mqttConfig.publishTopic) == 0 || !mqtt.connected())
+		return false;
+    
+    if(length <= 0 || length > BufferSize) return false;
+
+    if(!dInit) {
+        // Not sure how this sensor should be defined in HA, so skipping for now
+        //publishSensor(DataSensor);
+        dInit = true;
+    }
+
+    String str = toHex(raw, length);
+
+    snprintf_P(json, BufferSize, PSTR("{\"data\":\"%s\"}"), str.c_str());
+    char topic[192];
+    snprintf_P(topic, 192, PSTR("%s/data"), mqttConfig.publishTopic);
+    bool ret = mqtt.publish(topic, json);
+    loop();
+    return ret;
 }
 
 bool HomeAssistantMqttHandler::publishFirmware() {
     if(!fInit) {
-        snprintf_P(json, BufferSize, PSTR("{\"name\":\"%sFirmware\",\"stat_t\":\"%s/firmware\",\"dev_cla\":\"firmware\",\"cmd_t\":\"%s\",\"pl_inst\":\"fwupgrade\"}"),
+        snprintf_P(json, BufferSize, PSTR("{\"name\":\"%sFirmware\",\"stat_t\":\"%s/firmware\",\"uniq_id\":\"%s_fwupgrade\",\"dev_cla\":\"firmware\",\"cmd_t\":\"%s\",\"pl_inst\":\"fwupgrade\"}"),
             sensorNamePrefix.c_str(),
             pubTopic.c_str(),
+            deviceUid.c_str(),
             subTopic.c_str()
         );
         fInit = mqtt.publish(updateTopic + "/" + deviceUid + "/config", json, true, 0);
@@ -795,9 +853,10 @@ void HomeAssistantMqttHandler::onMessage(String &topic, String &payload) {
             if (debugger->isActive(RemoteDebug::INFO))
             #endif
             debugger->printf_P(PSTR("Received online status from HA, resetting sensor status\n"));
-            l1Init = l2Init = l2eInit = l3Init = l3eInit = l4Init = l4eInit = rtInit = rteInit = pInit = sInit = rInit = false;
+            l1Init = l2Init = l2eInit = l3Init = l3eInit = l4Init = l4eInit = rtInit = rteInit = pInit = sInit = rInit = fInit = dInit = false;
             for(uint8_t i = 0; i < 32; i++) tInit[i] = false;
-            for(uint8_t i = 0; i < 38; i++) prInit[i] = false;
+            priceImportInit = 0;
+            priceExportInit = 0;
         }
     } else if(topic.equals(subTopic)) {
         if(payload.equals("fwupgrade")) {
@@ -807,3 +866,14 @@ void HomeAssistantMqttHandler::onMessage(String &topic, String &payload) {
         }
     }
 }
+
+void HomeAssistantMqttHandler::toJsonIsoTimestamp(time_t t, char* buf, size_t buflen) {
+    memset(buf, 0, buflen);
+    if(t > 0) {
+        tmElements_t tm;
+        breakTime(t, tm);
+        snprintf_P(buf, buflen, PSTR("\"%04d-%02d-%02dT%02d:%02d:%02dZ\""), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
+    } else {
+        snprintf_P(buf, buflen, PSTR("null"));
+    }
+}

lib/HwTools/include/HwTools.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -45,6 +45,7 @@ public:
     bool applyBoardConfig(uint8_t boardType, GpioConfig& gpioConfig, MeterConfig& meterConfig, uint8_t hanPin);
     void setup(SystemConfig* sys, GpioConfig* gpio);
     float getVcc();
+    void setMaxVcc(float maxVcc);
     uint8_t getTempSensorCount();
     TempSensorData* getTempSensorData(uint8_t);
     bool updateTemperatures();
@@ -67,7 +68,9 @@ private:
     bool ledInvert, rgbInvert;
     uint8_t vccPin, vccGnd_r, vccVcc_r;
     float vccOffset, vccMultiplier;
-    float maxVcc = 3.25; // Best to have this close to max as a start, in case Pow-U reboots and starts off with a low voltage, we dont want that to be perceived as max
+    float vcc = 3.3; // Last known Vcc
+    float maxVcc = 3.28; // Best to have this close to max as a start, in case Pow-U reboots and starts off with a low voltage, we dont want that to be perceived as max
+    unsigned long lastVccRead = 0;
 
     uint16_t analogRange = 1024;
     AdcConfig voltAdc, tempAdc;

lib/HwTools/src/HwTools.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -22,6 +22,9 @@ bool HwTools::applyBoardConfig(uint8_t boardType, GpioConfig& gpioConfig, MeterC
                 gpioConfig.vccResistorGnd = 22;
                 gpioConfig.vccResistorVcc = 33;
                 gpioConfig.ledDisablePin = 6;
+                gpioConfig.vccBootLimit = 0;
+                gpioConfig.vccOffset = 0;
+                gpioConfig.vccMultiplier = 0;
                 return true;
             case 51: // Wemos S2 mini
                 gpioConfig.ledPin = 15;
@@ -416,7 +419,6 @@ float HwTools::getVcc() {
             }
             volts = (x * 3.3) / 10.0 / analogRange;
         #endif
-    } else {
     }
     if(volts == 0.0) {
         #if defined(ESP8266)
@@ -426,8 +428,11 @@ float HwTools::getVcc() {
         #endif
     }
 
-    if(vccGnd_r > 0 && vccVcc_r > 0)
-        volts *= ((float) (vccGnd_r + vccVcc_r) / vccGnd_r);
+    if(vccPin != 0xFF) {
+        if(vccGnd_r > 0 && vccVcc_r > 0) {
+            volts *= ((float) (vccGnd_r + vccVcc_r) / vccGnd_r);
+        }
+    }
     if(vccOffset != 0.0)
         volts += vccOffset;
     if(vccMultiplier != 0.0)
@@ -654,10 +659,15 @@ bool HwTools::writeLedPin(uint8_t color, uint8_t state) {
 }
 
 bool HwTools::isVoltageOptimal(float range) {
-	if(boardType >= 5 && boardType <= 7 && maxVcc > 2.8) { // Pow-*
-		float vcc = getVcc();
+	if(boardType >= 1 && boardType <= 8 && maxVcc > 2.8) { // BUS-Power boards
+        unsigned long now = millis();
+        if(now - lastVccRead > 250) {
+		    vcc = getVcc();
+            lastVccRead = now;
+        }
 		if(vcc > 3.4 || vcc < 2.8) {
-			maxVcc = 0; // Voltage is outside the operating range, we have to assume voltage is OK
+            maxVcc = 0;
+			return true; // Voltage is outside the operating range, we have to assume voltage is OK
 		} else if(vcc > maxVcc) {
 			maxVcc = vcc;
 		} else {
@@ -670,4 +680,8 @@ bool HwTools::isVoltageOptimal(float range) {
 
 uint8_t HwTools::getBoardType() {
     return boardType;
+}
+
+void HwTools::setMaxVcc(float vcc) {
+    this->maxVcc = min(3.3f, vcc);
 }

lib/JsonMqttHandler/include/JsonMqttHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -12,19 +12,18 @@
 class JsonMqttHandler : public AmsMqttHandler {
 public:
     #if defined(AMS_REMOTE_DEBUG)
-    JsonMqttHandler(MqttConfig& mqttConfig, RemoteDebug* debugger, char* buf, HwTools* hw, AmsFirmwareUpdater* updater) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
-        this->hw = hw;
-    };
+    JsonMqttHandler(MqttConfig& mqttConfig, RemoteDebug* debugger, char* buf, HwTools* hw, AmsDataStorage* ds, AmsFirmwareUpdater* updater) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
     #else
-    JsonMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, HwTools* hw) : AmsMqttHandler(mqttConfig, debugger, buf) {
-        this->hw = hw;
-    };
+    JsonMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, HwTools* hw, AmsDataStorage* ds, AmsFirmwareUpdater* updater) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
     #endif
+        this->hw = hw;
+        this->ds = ds;
+    };
     bool publish(AmsData* data, AmsData* previousState, EnergyAccounting* ea, PriceService* ps);
     bool publishTemperatures(AmsConfiguration*, HwTools*);
     bool publishPrices(PriceService*);
     bool publishSystem(HwTools* hw, PriceService* ps, EnergyAccounting* ea);
-    bool publishRaw(String data);
+    bool publishRaw(uint8_t* raw, size_t length);
     bool publishFirmware();
 
     void onMessage(String &topic, String &payload);
@@ -33,6 +32,9 @@ public:
 
 private:
     HwTools* hw;
+    bool hasExport = false;
+    AmsDataStorage* ds;
+
     uint16_t appendJsonHeader(AmsData* data);
     uint16_t appendJsonFooter(EnergyAccounting* ea, uint16_t pos);
     bool publishList1(AmsData* data, EnergyAccounting* ea);
@@ -40,5 +42,6 @@ private:
     bool publishList3(AmsData* data, EnergyAccounting* ea);
     bool publishList4(AmsData* data, EnergyAccounting* ea);
     String getMeterModel(AmsData* data);
+    void toJsonIsoTimestamp(time_t t, char* buf, size_t buflen);
 };
 #endif

lib/JsonMqttHandler/src/JsonMqttHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -8,12 +8,13 @@
 #include "FirmwareVersion.h"
 #include "hexutils.h"
 #include "Uptime.h"
+#include "AmsJsonGenerator.h"
 
 bool JsonMqttHandler::publish(AmsData* update, AmsData* previousState, EnergyAccounting* ea, PriceService* ps) {
     if(strlen(mqttConfig.publishTopic) == 0) {
         return false;
     }
-	if(!mqtt.connected()) {
+	if(!connected()) {
 		return false;
     }
 
@@ -44,6 +45,15 @@ bool JsonMqttHandler::publish(AmsData* update, AmsData* previousState, EnergyAcc
         ret = publishList4(&data, ea);
         mqtt.loop();
     }
+
+    if(data.getListType() >= 2 && data.getActiveExportPower() > 0.0) {
+        hasExport = true;
+    }
+
+    if(data.getListType() >= 3 && data.getActiveExportCounter() > 0.0) {
+        hasExport = true;
+    }
+
     loop();
     return ret;
 }
@@ -67,14 +77,24 @@ uint16_t JsonMqttHandler::appendJsonFooter(EnergyAccounting* ea, uint16_t pos) {
     } else {
         memset(pf, 0, 4);
     }
+
+    String peaks = "";
+    uint8_t peakCount = ea->getConfig()->hours;
+    if(peakCount > 5) peakCount = 5;
+    for(uint8_t i = 1; i <= peakCount; i++) {
+        if(!peaks.isEmpty()) peaks += ",";
+        peaks += String(ea->getPeak(i).value / 100.0, 2);
+    }
     
-    return snprintf_P(json+pos, BufferSize-pos, PSTR("%s\"%sh\":%.2f,\"%sd\":%.1f,\"%st\":%d,\"%sx\":%.2f,\"%she\":%.2f,\"%sde\":%.1f%s"),
+    return snprintf_P(json+pos, BufferSize-pos, PSTR("%s\"%sh\":%.3f,\"%sd\":%.2f,\"%sm\":%.1f,\"%st\":%d,\"%sx\":%.2f,\"%she\":%.3f,\"%sde\":%.2f,\"%sme\":%.1f,\"peaks\":[%s]%s"),
         strlen(pf) == 0 ? "},\"realtime\":{" : ",",
         pf,
         ea->getUseThisHour(),
         pf,
         ea->getUseToday(),
         pf,
+        ea->getUseThisMonth(),
+        pf,
         ea->getCurrentThreshold(),
         pf,
         ea->getMonthMax(),
@@ -82,6 +102,9 @@ uint16_t JsonMqttHandler::appendJsonFooter(EnergyAccounting* ea, uint16_t pos) {
         ea->getProducedThisHour(),
         pf,
         ea->getProducedToday(),
+        pf,
+        ea->getProducedThisMonth(),
+        peaks.c_str(),
         strlen(pf) == 0 ? "}" : ""
     );
 }
@@ -272,9 +295,9 @@ bool JsonMqttHandler::publishTemperatures(AmsConfiguration* config, HwTools* hw)
 }
 
 bool JsonMqttHandler::publishPrices(PriceService* ps) {
-	if(strlen(mqttConfig.publishTopic) == 0 || !mqtt.connected())
+	if(strlen(mqttConfig.publishTopic) == 0 || !connected())
 		return false;
-	if(ps->getValueForHour(PRICE_DIRECTION_IMPORT, 0) == PRICE_NO_VALUE)
+	if(!ps->hasPrice())
 		return false;
 
 	time_t now = time(nullptr);
@@ -285,7 +308,7 @@ bool JsonMqttHandler::publishPrices(PriceService* ps) {
 	float values[38];
     for(int i = 0;i < 38; i++) values[i] = PRICE_NO_VALUE;
 	for(uint8_t i = 0; i < 38; i++) {
-		float val = ps->getValueForHour(PRICE_DIRECTION_IMPORT, now, i);
+		float val = ps->getPriceForRelativeHour(PRICE_DIRECTION_IMPORT, i);
 		values[i] = val;
 
 		if(val == PRICE_NO_VALUE) break;
@@ -333,59 +356,89 @@ bool JsonMqttHandler::publishPrices(PriceService* ps) {
     memset(ts1hr, 0, 24);
 	if(min1hrIdx > -1) {
         time_t ts = now + (SECS_PER_HOUR * min1hrIdx);
-		tmElements_t tm;
+        tmElements_t tm;
         breakTime(ts, tm);
-		sprintf_P(ts1hr, PSTR("%04d-%02d-%02dT%02d:00:00Z"), tm.Year+1970, tm.Month, tm.Day, tm.Hour);
+        tm.Minute = 0;
+        tm.Second = 0;
+        ts = makeTime(tm);
+        toJsonIsoTimestamp(ts, ts1hr, sizeof(ts1hr));
 	}
 	char ts3hr[24];
     memset(ts3hr, 0, 24);
 	if(min3hrIdx > -1) {
         time_t ts = now + (SECS_PER_HOUR * min3hrIdx);
-		tmElements_t tm;
+        tmElements_t tm;
         breakTime(ts, tm);
-		sprintf_P(ts3hr, PSTR("%04d-%02d-%02dT%02d:00:00Z"), tm.Year+1970, tm.Month, tm.Day, tm.Hour);
+        tm.Minute = 0;
+        tm.Second = 0;
+        ts = makeTime(tm);
+        toJsonIsoTimestamp(ts, ts3hr, sizeof(ts3hr));
 	}
 	char ts6hr[24];
     memset(ts6hr, 0, 24);
 	if(min6hrIdx > -1) {
         time_t ts = now + (SECS_PER_HOUR * min6hrIdx);
-		tmElements_t tm;
+        tmElements_t tm;
         breakTime(ts, tm);
-		sprintf_P(ts6hr, PSTR("%04d-%02d-%02dT%02d:00:00Z"), tm.Year+1970, tm.Month, tm.Day, tm.Hour);
+        tm.Minute = 0;
+        tm.Second = 0;
+        ts = makeTime(tm);
+        toJsonIsoTimestamp(ts, ts6hr, sizeof(ts6hr));
 	}
 
-    char pf[4];
-    uint16_t pos = snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\","), WiFi.macAddress().c_str());
-    if(mqttConfig.payloadFormat != 6) {
-        memset(pf, 0, 4);
-        pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"prices\":{"));
-    } else {
-        strcpy_P(pf, PSTR("pr_"));
-    }
+    if(mqttConfig.payloadFormat == 6) {
+        uint16_t pos = snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\","), WiFi.macAddress().c_str());
 
-    for(uint8_t i = 0;i < 38; i++) {
-        if(values[i] == PRICE_NO_VALUE) {
-            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"%s%d\":null,"), pf, i);
-        } else {
-            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"%s%d\":%.4f,"), pf, i, values[i]);
+        for(uint8_t i = 0;i < 38; i++) {
+            if(values[i] == PRICE_NO_VALUE) {
+                pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"pr_%d\":null,"), i);
+            } else {
+                pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"pr_%d\":%.4f,"), i, values[i]);
+            }
         }
-    }
 
-    pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"%smin\":%.4f,\"%smax\":%.4f,\"%scheapest1hr\":\"%s\",\"%scheapest3hr\":\"%s\",\"%scheapest6hr\":\"%s\"}"),
-        pf,
-        min == INT16_MAX ? 0.0 : min,
-        pf,
-        max == INT16_MIN ? 0.0 : max,
-        pf,
-        ts1hr,
-        pf,
-        ts3hr,
-        pf,
-        ts6hr
-    );
-    if(mqttConfig.payloadFormat != 6) {
-        json[pos++] = '}';
-        json[pos] = '\0';
+        pos += snprintf_P(json+pos, BufferSize-pos, PSTR("\"pr_min\":%.4f,\"pr_max\":%.4f,\"pr_cheapest1hr\":%s,\"pr_cheapest3hr\":%s,\"pr_cheapest6hr\":%s}"),
+            min == INT16_MAX ? 0.0 : min,
+            max == INT16_MIN ? 0.0 : max,
+            ts1hr,
+            ts3hr,
+            ts6hr
+        );
+    } else {
+        uint16_t pos = snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\",\"prices\":{\"import\":["), WiFi.macAddress().c_str());
+
+        uint8_t currentPricePointIndex = ps->getCurrentPricePointIndex();
+        uint8_t numberOfPoints = ps->getNumberOfPointsAvailable();
+        for(int i = currentPricePointIndex; i < numberOfPoints; i++) {
+            float val = ps->getPricePoint(PRICE_DIRECTION_IMPORT, i);
+            if(val == PRICE_NO_VALUE) {
+                pos += snprintf_P(json+pos, BufferSize-pos, PSTR("null,"));
+            } else {
+                pos += snprintf_P(json+pos, BufferSize-pos, PSTR("%.4f,"), val);
+            }
+        }
+        if(hasExport && ps->isExportPricesDifferentFromImport()) {
+            pos--;
+            pos += snprintf_P(json+pos, BufferSize-pos, PSTR("],\"export\":["));
+            for(int i = currentPricePointIndex; i < numberOfPoints; i++) {
+                float val = ps->getPricePoint(PRICE_DIRECTION_EXPORT, i);
+                if(val == PRICE_NO_VALUE) {
+                    pos += snprintf_P(json+pos, BufferSize-pos, PSTR("null,"));
+                } else {
+                    pos += snprintf_P(json+pos, BufferSize-pos, PSTR("%.4f,"), val);
+                }
+            }
+        }
+
+        pos--;
+        pos += snprintf_P(json+pos, BufferSize-pos, PSTR("],\"min\":%.4f,\"max\":%.4f,\"cheapest1hr\":%s,\"cheapest3hr\":%s,\"cheapest6hr\":%s}}"),
+            min == INT16_MAX ? 0.0 : min,
+            max == INT16_MIN ? 0.0 : max,
+            ts1hr,
+            ts3hr,
+            ts6hr
+        );
+        
     }
     bool ret = false;
     if(mqttConfig.payloadFormat == 5) {
@@ -400,7 +453,7 @@ bool JsonMqttHandler::publishPrices(PriceService* ps) {
 }
 
 bool JsonMqttHandler::publishSystem(HwTools* hw, PriceService* ps, EnergyAccounting* ea) {
-	if(strlen(mqttConfig.publishTopic) == 0 || !mqtt.connected())
+	if(strlen(mqttConfig.publishTopic) == 0 || !connected())
 		return false;
 
     snprintf_P(json, BufferSize, PSTR("{\"id\":\"%s\",\"name\":\"%s\",\"up\":%d,\"vcc\":%.3f,\"rssi\":%d,\"temp\":%.2f,\"version\":\"%s\"}"),
@@ -428,8 +481,20 @@ uint8_t JsonMqttHandler::getFormat() {
     return 0;
 }
 
-bool JsonMqttHandler::publishRaw(String data) {
-    return false;
+bool JsonMqttHandler::publishRaw(uint8_t* raw, size_t length) {
+	if(strlen(mqttConfig.publishTopic) == 0 || !mqtt.connected())
+		return false;
+    
+    if(length <= 0 || length > BufferSize) return false;
+
+    String str = toHex(raw, length);
+
+    snprintf_P(json, BufferSize, PSTR("{\"data\":\"%s\"}"), str.c_str());
+    char topic[192];
+    snprintf_P(topic, 192, PSTR("%s/data"), mqttConfig.publishTopic);
+    bool ret = mqtt.publish(topic, json);
+    loop();
+    return ret;
 }
 
 bool JsonMqttHandler::publishFirmware() {
@@ -447,11 +512,46 @@ bool JsonMqttHandler::publishFirmware() {
 }
 
 void JsonMqttHandler::onMessage(String &topic, String &payload) {
-    if(strncmp(topic.c_str(), mqttConfig.subscribeTopic, 12) == 0) {
+    if(strlen(mqttConfig.publishTopic) == 0 || !connected())
+		return;
+
+    #if defined(AMS_REMOTE_DEBUG)
+    if (debugger->isActive(RemoteDebug::INFO))
+    #endif
+    debugger->printf_P(PSTR("Received command [%s] to [%s]\n"), payload.c_str(), topic.c_str());
+
+    if(topic.equals(subTopic)) {
+        #if defined(AMS_REMOTE_DEBUG)
+        if (debugger->isActive(RemoteDebug::DEBUG))
+        #endif
+        debugger->printf_P(PSTR(" - this is our subscribed topic\n"));
         if(payload.equals("fwupgrade")) {
             if(strcmp(updater->getNextVersion(), FirmwareVersion::VersionString) != 0) {
                 updater->setTargetVersion(updater->getNextVersion());
             }
+        } else if(payload.equals("dayplot")) {
+            char pubTopic[192];
+            snprintf_P(pubTopic, 192, PSTR("%s/dayplot"), mqttConfig.publishTopic);
+            AmsJsonGenerator::generateDayPlotJson(ds, json, BufferSize);
+            bool ret = mqtt.publish(pubTopic, json);
+            loop();
+        } else if(payload.equals("monthplot")) {
+            char pubTopic[192];
+            snprintf_P(pubTopic, 192, PSTR("%s/monthplot"), mqttConfig.publishTopic);
+            AmsJsonGenerator::generateMonthPlotJson(ds, json, BufferSize);
+            bool ret = mqtt.publish(pubTopic, json);
+            loop();
         }
     }
 }
+
+void JsonMqttHandler::toJsonIsoTimestamp(time_t t, char* buf, size_t buflen) {
+    memset(buf, 0, buflen);
+    if(t > 0) {
+        tmElements_t tm;
+        breakTime(t, tm);
+        snprintf_P(buf, buflen, PSTR("\"%04d-%02d-%02dT%02d:%02d:%02dZ\""), tm.Year+1970, tm.Month, tm.Day, tm.Hour, tm.Minute, tm.Second);
+    } else {
+        snprintf_P(buf, buflen, PSTR("null"));
+    }
+}

lib/MeterCommunicators/include/IEC6205621.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/include/IEC6205675.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -11,6 +11,7 @@
 #include "AmsConfiguration.h"
 #include "DataParser.h"
 #include "Cosem.h"
+#include "Timezone.h"
 #if defined(AMS_REMOTE_DEBUG)
 #include "RemoteDebug.h"
 #endif
@@ -25,9 +26,9 @@ struct AmsOctetTimestamp {
 class IEC6205675 : public AmsData {
 public:
     #if defined(AMS_REMOTE_DEBUG)
-    IEC6205675(const char* payload, uint8_t useMeterType, MeterConfig* meterConfig, DataParserContext &ctx, AmsData &state, RemoteDebug* debugger);
+    IEC6205675(const char* payload, Timezone* tz, uint8_t useMeterType, MeterConfig* meterConfig, DataParserContext &ctx, AmsData &state, RemoteDebug* debugger);
     #else
-    IEC6205675(const char* payload, uint8_t useMeterType, MeterConfig* meterConfig, DataParserContext &ctx, AmsData &state, Stream* debugger);
+    IEC6205675(const char* payload, Timezone* tz, uint8_t useMeterType, MeterConfig* meterConfig, DataParserContext &ctx, AmsData &state, Stream* debugger);
     #endif
 
 private:
@@ -37,8 +38,9 @@ private:
     float getNumber(uint8_t* obis, int matchlength, const char* ptr);
     float getNumber(CosemData*);
     time_t getTimestamp(uint8_t* obis, int matchlength, const char* ptr);
+    time_t adjustForKnownIssues(CosemDateTime dt, Timezone* tz, uint8_t meterType);
 
-    uint8_t AMS_OBIS_UNKNOWN_1[4]                 = { 25, 9, 0, 255 };
+    uint8_t AMS_OBIS_UNKNOWN_1[4]               = { 25, 9, 0, 255 };
 
     uint8_t AMS_OBIS_VERSION[4]                 = {  0, 2, 129, 255 };
     uint8_t AMS_OBIS_METER_MODEL[4]             = { 96, 1, 1, 255 };

lib/MeterCommunicators/include/ImpulseAmsData.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/include/KmpCommunicator.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2024
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/include/KmpTalker.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: All rights reserved
  * 
  */

lib/MeterCommunicators/include/LNG.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/include/LNG2.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -12,7 +12,22 @@
 #include "DataParser.h"
 #include "Cosem.h"
 
-struct Lng2Data_3p {
+struct Lng2Data_3p_0b {
+    CosemBasic header;
+    CosemLongUnsigned u1;
+    CosemLongUnsigned u2;
+    CosemLongUnsigned u3;
+    CosemLongUnsigned i1;
+    CosemLongUnsigned i2;
+    CosemLongUnsigned i3;
+    CosemDLongUnsigned activeImport;
+    CosemDLongUnsigned activeExport;
+    CosemDLongUnsigned acumulatedImport;
+    CosemDLongUnsigned accumulatedExport;
+    CosemString meterId;
+} __attribute__((packed));
+
+struct Lng2Data_3p_0e {
     CosemBasic header;
     CosemLongUnsigned u1;
     CosemLongUnsigned u2;

lib/MeterCommunicators/include/MeterCommunicator.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -13,6 +13,7 @@
 #endif
 #include "AmsData.h"
 #include "AmsConfiguration.h"
+#include "AmsMqttHandler.h"
 
 class MeterCommunicator {
 public:
@@ -24,6 +25,13 @@ public:
     virtual bool isConfigChanged();
     virtual void ackConfigChanged();
     virtual void getCurrentConfig(MeterConfig& meterConfig);
+    virtual void setMqttHandlerForDebugging(AmsMqttHandler* mqttHandler) {
+        this->mqttDebug = mqttHandler;
+    };
+
+protected:
+    AmsMqttHandler* mqttDebug = NULL;
+
 };
 
 #endif

lib/MeterCommunicators/include/PassiveMeterCommunicator.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -14,7 +14,7 @@
 #include "AmsConfiguration.h"
 #include "DataParsers.h"
 #include "Timezone.h"
-#include "PassthroughMqttHandler.h"
+#include "AmsMqttHandler.h"
 
 #if defined(ESP8266)
 #include "SoftwareSerial.h"
@@ -36,7 +36,9 @@ public:
     bool isConfigChanged();
     void ackConfigChanged();
     void getCurrentConfig(MeterConfig& meterConfig);
-    void setPassthroughMqttHandler(PassthroughMqttHandler*);
+    void setTimezone(Timezone* tz) {
+        this->tz = tz;
+    };
 
     HardwareSerial* getHwSerial();
     void rxerr(int err);
@@ -51,8 +53,6 @@ protected:
     bool configChanged = false;
     Timezone* tz;
 
-    PassthroughMqttHandler* pt = NULL;
-
     uint8_t *hanBuffer = NULL;
     uint16_t hanBufferSize = 0;
     Stream *hanSerial;
@@ -62,7 +62,8 @@ protected:
     HardwareSerial *hwSerial = NULL;
     uint8_t rxBufferErrors = 0;
 
-    bool autodetect = false, validDataReceived = false;
+    bool autodetect = false;
+    uint8_t validDataReceived = 0;
     unsigned long meterAutodetectLastChange = 0;
     long rate = 10000;
     uint32_t autodetectBaud = 0;

lib/MeterCommunicators/include/PulseMeterCommunicator.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2024
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/src/IEC6205621.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/src/ImpulseAmsData.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/src/KmpCommunicator.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -24,8 +24,6 @@ void KmpCommunicator::configure(MeterConfig& meterConfig) {
 }
 
 bool KmpCommunicator::loop() {
-	uint64_t now = millis64();
-
     bool ret = talker->loop();
     int lastError = getLastError();
     if(ret) {
@@ -58,35 +56,36 @@ AmsData* KmpCommunicator::getData(AmsData& meterState) {
     if(talker == NULL) return NULL;
     KmpDataHolder kmpData;
     talker->getData(kmpData);
+	uint64_t now = millis64();
     AmsData* data = new AmsData();
-    data->apply(OBIS_ACTIVE_IMPORT_COUNT, kmpData.activeImportCounter);
-    data->apply(OBIS_ACTIVE_EXPORT_COUNT, kmpData.activeExportCounter);
-    data->apply(OBIS_REACTIVE_IMPORT_COUNT, kmpData.reactiveImportCounter);
-    data->apply(OBIS_REACTIVE_EXPORT_COUNT, kmpData.reactiveExportCounter);
-    data->apply(OBIS_ACTIVE_IMPORT, kmpData.activeImportPower);
-    data->apply(OBIS_ACTIVE_EXPORT, kmpData.activeExportPower);
-    data->apply(OBIS_REACTIVE_IMPORT, kmpData.reactiveImportPower);
-    data->apply(OBIS_REACTIVE_EXPORT, kmpData.reactiveExportPower);
-    data->apply(OBIS_VOLTAGE_L1, kmpData.l1voltage);
-    data->apply(OBIS_VOLTAGE_L2, kmpData.l2voltage);
-    data->apply(OBIS_VOLTAGE_L3, kmpData.l3voltage);
-    data->apply(OBIS_CURRENT_L1, kmpData.l1current);
-    data->apply(OBIS_CURRENT_L2, kmpData.l2current);
-    data->apply(OBIS_CURRENT_L3, kmpData.l3current);
-    data->apply(OBIS_POWER_FACTOR_L1, kmpData.l1PowerFactor);
-    data->apply(OBIS_POWER_FACTOR_L2, kmpData.l2PowerFactor);
-    data->apply(OBIS_POWER_FACTOR_L3, kmpData.l3PowerFactor);
-    data->apply(OBIS_POWER_FACTOR, kmpData.powerFactor);
-    data->apply(OBIS_ACTIVE_IMPORT_L1, kmpData.l1activeImportPower);
-    data->apply(OBIS_ACTIVE_IMPORT_L2, kmpData.l2activeImportPower);
-    data->apply(OBIS_ACTIVE_IMPORT_L3, kmpData.l3activeImportPower);
-    data->apply(OBIS_ACTIVE_EXPORT_L1, kmpData.l1activeExportPower);
-    data->apply(OBIS_ACTIVE_EXPORT_L2, kmpData.l2activeExportPower);
-    data->apply(OBIS_ACTIVE_EXPORT_L3, kmpData.l3activeExportPower);
-    data->apply(OBIS_ACTIVE_IMPORT_COUNT_L1, kmpData.l1activeImportCounter);
-    data->apply(OBIS_ACTIVE_IMPORT_COUNT_L2, kmpData.l2activeImportCounter);
-    data->apply(OBIS_ACTIVE_IMPORT_COUNT_L3, kmpData.l3activeImportCounter);
-    data->apply(OBIS_METER_ID, kmpData.meterId);
-    data->apply(OBIS_NULL, AmsTypeKamstrup);
+    data->apply(OBIS_ACTIVE_IMPORT_COUNT, kmpData.activeImportCounter, now);
+    data->apply(OBIS_ACTIVE_EXPORT_COUNT, kmpData.activeExportCounter, now);
+    data->apply(OBIS_REACTIVE_IMPORT_COUNT, kmpData.reactiveImportCounter, now);
+    data->apply(OBIS_REACTIVE_EXPORT_COUNT, kmpData.reactiveExportCounter, now);
+    data->apply(OBIS_ACTIVE_IMPORT, kmpData.activeImportPower, now);
+    data->apply(OBIS_ACTIVE_EXPORT, kmpData.activeExportPower, now);
+    data->apply(OBIS_REACTIVE_IMPORT, kmpData.reactiveImportPower, now);
+    data->apply(OBIS_REACTIVE_EXPORT, kmpData.reactiveExportPower, now);
+    data->apply(OBIS_VOLTAGE_L1, kmpData.l1voltage, now);
+    data->apply(OBIS_VOLTAGE_L2, kmpData.l2voltage, now);
+    data->apply(OBIS_VOLTAGE_L3, kmpData.l3voltage, now);
+    data->apply(OBIS_CURRENT_L1, kmpData.l1current, now);
+    data->apply(OBIS_CURRENT_L2, kmpData.l2current, now);
+    data->apply(OBIS_CURRENT_L3, kmpData.l3current, now);
+    data->apply(OBIS_POWER_FACTOR_L1, kmpData.l1PowerFactor, now);
+    data->apply(OBIS_POWER_FACTOR_L2, kmpData.l2PowerFactor, now);
+    data->apply(OBIS_POWER_FACTOR_L3, kmpData.l3PowerFactor, now);
+    data->apply(OBIS_POWER_FACTOR, kmpData.powerFactor, now);
+    data->apply(OBIS_ACTIVE_IMPORT_L1, kmpData.l1activeImportPower, now);
+    data->apply(OBIS_ACTIVE_IMPORT_L2, kmpData.l2activeImportPower, now);
+    data->apply(OBIS_ACTIVE_IMPORT_L3, kmpData.l3activeImportPower, now);
+    data->apply(OBIS_ACTIVE_EXPORT_L1, kmpData.l1activeExportPower, now);
+    data->apply(OBIS_ACTIVE_EXPORT_L2, kmpData.l2activeExportPower, now);
+    data->apply(OBIS_ACTIVE_EXPORT_L3, kmpData.l3activeExportPower, now);
+    data->apply(OBIS_ACTIVE_IMPORT_COUNT_L1, kmpData.l1activeImportCounter, now);
+    data->apply(OBIS_ACTIVE_IMPORT_COUNT_L2, kmpData.l2activeImportCounter, now);
+    data->apply(OBIS_ACTIVE_IMPORT_COUNT_L3, kmpData.l3activeImportCounter, now);
+    data->apply(OBIS_METER_ID, kmpData.meterId, now);
+    data->apply(OBIS_NULL, AmsTypeKamstrup, now);
     return data;
 }

lib/MeterCommunicators/src/LNG.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/MeterCommunicators/src/LNG2.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -14,7 +14,33 @@ LNG2::LNG2(AmsData& meterState, const char* payload, uint8_t useMeterType, Meter
         meterType = AmsTypeLandisGyr;
         this->packageTimestamp = ctx.timestamp;
 
-        Lng2Data_3p* d = (Lng2Data_3p*) payload;
+        Lng2Data_3p_0e* d = (Lng2Data_3p_0e*) payload;
+        this->l1voltage = ntohs(d->u1.data);
+        this->l2voltage = ntohs(d->u2.data);
+        this->l3voltage = ntohs(d->u3.data);
+
+        this->l1current = ntohs(d->i1.data) / 100.0;
+        this->l2current = ntohs(d->i2.data) / 100.0;
+        this->l3current = ntohs(d->i3.data) / 100.0;
+
+        this->activeImportPower = ntohl(d->activeImport.data);
+        this->activeExportPower = ntohl(d->activeExport.data);
+        this->activeImportCounter = ntohl(d->acumulatedImport.data) / 1000.0;
+        this->activeExportCounter = ntohl(d->accumulatedExport.data) / 1000.0;
+
+        char str[64];
+        uint8_t str_len = getString((CosemData*) &d->meterId, str);
+        if(str_len > 0) {
+            this->meterId = String(str);
+        }
+        listType = 3;
+        lastUpdateMillis = millis64();
+    } else if(h->length == 0x0b) {
+        apply(meterState);
+        meterType = AmsTypeLandisGyr;
+        this->packageTimestamp = ctx.timestamp;
+
+        Lng2Data_3p_0b* d = (Lng2Data_3p_0b*) payload;
         this->l1voltage = ntohs(d->u1.data);
         this->l2voltage = ntohs(d->u2.data);
         this->l3voltage = ntohs(d->u3.data);

lib/MeterCommunicators/src/PassiveMeterCommunicator.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -174,8 +174,8 @@ bool PassiveMeterCommunicator::loop() {
         lastError = pos;
 		printHanReadError(pos);
 		len += hanSerial->readBytes(hanBuffer+len, hanBufferSize-len);
-        if(pt != NULL) {
-            pt->publishBytes(hanBuffer, len);
+        if(mqttDebug != NULL) {
+            mqttDebug->publishRaw(hanBuffer, len);
         }
 		#if defined(AMS_REMOTE_DEBUG)
 		if (debugger->isActive(RemoteDebug::VERBOSE))
@@ -229,8 +229,8 @@ AmsData* PassiveMeterCommunicator::getData(AmsData& meterState) {
 	char* payload = ((char *) (hanBuffer)) + pos;
 	if(maxDetectedPayloadSize < pos) maxDetectedPayloadSize = pos;
 	if(ctx.type == DATA_TAG_DLMS) {
-        if(pt != NULL) {
-            pt->publishBytes((uint8_t*) payload, ctx.length);
+        if(mqttDebug != NULL) {
+            mqttDebug->publishRaw((uint8_t*) payload, ctx.length);
         }
 
 		#if defined(AMS_REMOTE_DEBUG)
@@ -278,7 +278,7 @@ AmsData* PassiveMeterCommunicator::getData(AmsData& meterState) {
 			#endif
 			debugger->printf_P(PSTR("DLMS\n"));
 			// TODO: Split IEC6205675 into DataParserKaifa and DataParserObis. This way we can add other means of parsing, for those other proprietary formats
-			data = new IEC6205675(payload, meterState.getMeterType(), &meterConfig, ctx, meterState, debugger);
+			data = new IEC6205675(payload, tz, meterState.getMeterType(), &meterConfig, ctx, meterState, debugger);
 		}
 	} else if(ctx.type == DATA_TAG_DSMR) {
 		data = new IEC6205621(payload, tz, &meterConfig);
@@ -286,7 +286,7 @@ AmsData* PassiveMeterCommunicator::getData(AmsData& meterState) {
 	len = 0;
     if(data != NULL) {
         if(data->getListType() > 0) {
-            validDataReceived = true;
+            validDataReceived++;
             if(rxBufferErrors > 0) rxBufferErrors--;
         }
     }
@@ -405,8 +405,8 @@ int16_t PassiveMeterCommunicator::unwrapData(uint8_t *buf, DataParserContext &co
 				if (debugger->isActive(RemoteDebug::VERBOSE))
 				#endif
 				debugger->printf_P(PSTR("HDLC frame:\n"));
-                if(pt != NULL) {
-                    pt->publishBytes(buf, curLen);
+                if(mqttDebug != NULL) {
+                    mqttDebug->publishRaw(buf, curLen);
                 }
                 break;
             case DATA_TAG_MBUS:
@@ -414,8 +414,8 @@ int16_t PassiveMeterCommunicator::unwrapData(uint8_t *buf, DataParserContext &co
 				if (debugger->isActive(RemoteDebug::VERBOSE))
 				#endif
 				debugger->printf_P(PSTR("MBUS frame:\n"));
-                if(pt != NULL) {
-                    pt->publishBytes(buf, curLen);
+                if(mqttDebug != NULL) {
+                    mqttDebug->publishRaw(buf, curLen);
                 }
                 break;
             case DATA_TAG_GBT:
@@ -447,8 +447,8 @@ int16_t PassiveMeterCommunicator::unwrapData(uint8_t *buf, DataParserContext &co
 				if (debugger->isActive(RemoteDebug::VERBOSE))
 				#endif
 				debugger->printf_P(PSTR("DSMR frame:\n"));
-                if(pt != NULL) {
-                    pt->publishString((char*) buf);
+                if(mqttDebug != NULL) {
+                    mqttDebug->publishRaw(buf, curLen);
                 }
                 break;
 			case DATA_TAG_SNRM:
@@ -586,15 +586,15 @@ void PassiveMeterCommunicator::setupHanPort(uint32_t baud, uint8_t parityOrdinal
 		autodetectBaud = baud = 2400;
 	}
 
+	if(parityOrdinal == 0) {
+		parityOrdinal = 11; // 8E1
+	}
+
 	#if defined(AMS_REMOTE_DEBUG)
 	if (debugger->isActive(RemoteDebug::INFO))
 	#endif
 	debugger->printf_P(PSTR("(setupHanPort) Setting up HAN on pin %d/%d with baud %d and parity %d\n"), rxpin, txpin, baud, parityOrdinal);
 
-	if(parityOrdinal == 0) {
-		parityOrdinal = 3; // 8N1
-	}
-
 	if(rxpin == 3 || rxpin == 113) {
 		#if ARDUINO_USB_CDC_ON_BOOT
 			hwSerial = &Serial0;
@@ -799,6 +799,7 @@ HardwareSerial* PassiveMeterCommunicator::getHwSerial() {
 
 void PassiveMeterCommunicator::rxerr(int err) {
 	if(err == 0) return;
+	if(lastError == 90+err) return; // Do not flood with same error
 	switch(err) {
 		case 2:
 			#if defined(AMS_REMOTE_DEBUG)
@@ -806,6 +807,7 @@ void PassiveMeterCommunicator::rxerr(int err) {
 			#endif
 			debugger->printf_P(PSTR("Serial buffer overflow\n"));
 			rxBufferErrors++;
+			#if defined(ESP32)
 			if(rxBufferErrors > 1 && meterConfig.bufferSize < 8) {
 				meterConfig.bufferSize += 2;
 				#if defined(AMS_REMOTE_DEBUG)
@@ -815,6 +817,7 @@ void PassiveMeterCommunicator::rxerr(int err) {
                 configChanged = true;
 				rxBufferErrors = 0;
 			}
+			#endif
 			break;
 		case 3:
 			#if defined(AMS_REMOTE_DEBUG)
@@ -836,10 +839,9 @@ void PassiveMeterCommunicator::rxerr(int err) {
 		    unsigned long now = millis();
 			if(autodetect) {
 				meterAutodetectLastChange = 0;
-			} else if(meterAutodetectLastChange > 0 && now - meterAutodetectLastChange < 120000 && validDataReceived) {
+			} else if(validDataReceived > 2) {
 				meterConfig.parity = getNextParity(meterConfig.parity);
 				configChanged = true;
-				setupHanPort(meterConfig.baud, meterConfig.parity, meterConfig.invert);
 			}
 			break;
 	}
@@ -849,12 +851,14 @@ void PassiveMeterCommunicator::rxerr(int err) {
 
 void PassiveMeterCommunicator::handleAutodetect(unsigned long now) {
     if(!autodetect) return;
+	if(now - meterAutodetectLastChange < 12000) return;
 
-	if(!validDataReceived) {
-		if(now - meterAutodetectLastChange > 12000 && (meterConfig.baud == 0 || meterConfig.parity == 0)) {
+	if(validDataReceived < 2) {
+		if(meterConfig.baud == 0 || meterConfig.parity == 0) {
 			autodetect = true;
 			if(lastError == 95) { // If parity error, switch parity
 				autodetectParity = getNextParity(autodetectParity);
+				lastError = 0;
 			} else {
 				autodetectCount++;
 			}

lib/MeterCommunicators/src/PulseMeterCommunicator.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/PassthroughMqttHandler/include/PassthroughMqttHandler.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -16,7 +16,7 @@ public:
         this->topic = String(mqttConfig.publishTopic);
     };
     #else
-    PassthroughMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf) : AmsMqttHandler(mqttConfig, debugger, buf) {
+    PassthroughMqttHandler(MqttConfig& mqttConfig, Stream* debugger, char* buf, AmsFirmwareUpdater* updater) : AmsMqttHandler(mqttConfig, debugger, buf, updater) {
         this->topic = String(mqttConfig.publishTopic);
     };
     #endif

lib/PassthroughMqttHandler/src/PassthroughMqttHandler.cpp

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/PriceService/include/DnbCurrParser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */

lib/PriceService/include/EntsoeA44Parser.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -15,28 +15,23 @@
 #define DOCPOS_MEASUREMENTUNIT 2
 #define DOCPOS_POSITION 3
 #define DOCPOS_AMOUNT 4
+#define DOCPOS_RESOLUTION 5
 
 class EntsoeA44Parser: public Stream {
 public:
-    EntsoeA44Parser();
+    EntsoeA44Parser(PricesContainer *container);
     virtual ~EntsoeA44Parser();
 
-    char* getCurrency();
-    char* getMeasurementUnit();
-    float getPoint(uint8_t position);
-    
     int available();
     int read();
     int peek();
     void flush();
     size_t write(const uint8_t *buffer, size_t size);
     size_t write(uint8_t);
-    void get(PricesContainer*);
 
 private:
-    char currency[4];
-    char measurementUnit[4];
-    float points[25];
+    PricesContainer *container;
+    float multiplier = 1.0;
 
     char buf[64];
     uint8_t pos = 0;

lib/PriceService/include/PriceService.h

@@ -1,5 +1,5 @@
 /**
- * @copyright Utilitech AS 2023
+ * @copyright Utilitech AS 2023-2026
  * License: Fair Source
  * 
  */
@@ -27,10 +27,6 @@
 
 #define SSL_BUF_SIZE 512
 
-#define PRICE_DIRECTION_IMPORT 0x01
-#define PRICE_DIRECTION_EXPORT 0x02
-#define PRICE_DIRECTION_BOTH 0x03
-
 #define PRICE_DAY_MO 0x01
 #define PRICE_DAY_TU 0x02
 #define PRICE_DAY_WE 0x04
@@ -57,10 +53,13 @@ struct PriceConfig {
     uint8_t end_dayofmonth;
 };
 
-struct PricePart {
-    char name[32];
-    char description[32];
-    uint32_t value;
+struct AmsPriceV2Header {
+    char currency[4];
+    char measurementUnit[4];
+    char source[4];
+    uint8_t resolutionInMinutes;
+    bool differentExportPrices;
+    uint8_t numberOfPoints;
 };
 
 class PriceService {
@@ -78,17 +77,25 @@ public:
     char* getCurrency();
     char* getArea();
     char* getSource();
-    float getValueForHour(uint8_t direction, int8_t hour);
-    float getValueForHour(uint8_t direction, time_t ts, int8_t hour);
 
-    float getEnergyPriceForHour(uint8_t direction, time_t ts, int8_t hour);
+    uint8_t getResolutionInMinutes();
+    uint8_t getNumberOfPointsAvailable();
+    uint8_t getCurrentPricePointIndex();
+
+    bool isExportPricesDifferentFromImport();
+
+    bool hasPrice() { return hasPrice(PRICE_DIRECTION_IMPORT); }
+    bool hasPrice(uint8_t direction) { return getCurrentPrice(direction) != PRICE_NO_VALUE; }
+    bool hasPricePoint(uint8_t direction, int8_t point) { return getPricePoint(direction, point) != PRICE_NO_VALUE; }
+    
+    float getCurrentPrice(uint8_t direction);
+    float getPricePoint(uint8_t direction, uint8_t point);
+    float getPriceForRelativeHour(uint8_t direction, int8_t hour); // If not 60min interval, average
 
     std::vector<PriceConfig>& getPriceConfig();
     void setPriceConfig(uint8_t index, PriceConfig &priceConfig);
     void cropPriceConfig(uint8_t size);
 
-    PricePart getPricePart(uint8_t index);
-
     int16_t getLastError();
 
     bool load();
@@ -103,7 +110,7 @@ private:
     PriceServiceConfig* config = NULL;
     HTTPClient* http = NULL;
 
-    uint8_t currentDay = 0, currentHour = 0;
+    uint8_t currentDay = 0, currentPricePoint = 0;
     uint8_t tomorrowFetchMinute = 15; // How many minutes over 13:00 should it fetch prices
     uint8_t nextFetchDelayMinutes = 15;
     uint64_t lastTodayFetch = 0;
@@ -117,9 +124,6 @@ private:
     Timezone* tz = NULL;
     Timezone* entsoeTz = NULL;
 
-    static const uint16_t BufferSize = 256;
-    char* buf;
-
     bool hub = false;
     uint8_t* key = NULL;
     uint8_t* auth = NULL;
@@ -132,5 +136,7 @@ private:
     bool retrieve(const char* url, Stream* doc);
     float getCurrencyMultiplier(const char* from, const char* to, time_t t);
     bool timeIsInPeriod(tmElements_t tm, PriceConfig pc);
+    float getFixedPrice(uint8_t direction, int8_t point);
+    float getEnergyPricePoint(uint8_t direction, uint8_t point);
 };
 #endif