feat: Read last value on start up, ignore decreases

`ocr-incr-only` and `ocr-max-incr` flags are meant to protect against
faulty OCR, but they can't help if the very first reading after start up
is faulty.

Protect against that scenario by reading the last valid value from the
CSV file during start up.

Author: dcelasun

http.go

@@ -114,16 +114,14 @@ func processOCR(imageData []byte, batLevel, batVoltage int) {
 
 	reading := extractReading(ocrOut.Texts, ocrMatchRe, ocrFixRules, ocrMergeTexts)
 
-	// Append reading to CSV unconditionally so discarded values are still on disk.
-	storeReading(imagePath, reading)
-
 	if reading == "" {
 		log.Printf("OCR completed in %s: no reading found, texts=%v", elapsed, ocrOut.Texts)
 		return
 	}
 
 	val, err := strconv.ParseFloat(reading, 64)
 	if err != nil {
+		storeReading(imagePath, reading, false)
 		log.Printf("OCR completed in %s: invalid reading %q, texts=%v", elapsed, reading, ocrOut.Texts)
 		return
 	}
@@ -135,13 +133,15 @@ func processOCR(imageData []byte, batLevel, batVoltage int) {
 		prev := lastReading
 		if reason := checkReadingFilter(divided, prev, ocrIncrOnly, ocrMaxIncr); reason != "" {
 			lastReadingMu.Unlock()
+			storeReading(imagePath, reading, false)
 			log.Printf("%s", reason)
 			return
 		}
 		lastReading = divided
 		lastReadingMu.Unlock()
 	}
 
+	storeReading(imagePath, reading, true)
 	metricMeterReading.Set(val)
 
 	if mqttBroker != "" {

main.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"regexp"
 
 	"github.com/prometheus/client_golang/prometheus/promhttp"
@@ -180,6 +181,14 @@ func run(_ context.Context, cmd *cli.Command) error {
 	ocrMaxIncr = cmd.Float("ocr-max-incr")
 	ocrMergeTexts = cmd.Bool("ocr-merge-texts")
 
+	if storagePath != "" && (ocrIncrOnly || ocrMaxIncr > 0) {
+		csvPath := filepath.Join(storagePath, "readings.csv")
+		if prev, ok := lastStoredReading(csvPath, meterDivisor); ok {
+			lastReading = prev
+			log.Printf("seeded last reading from CSV: %.3f m³", prev)
+		}
+	}
+
 	if mqttBroker != "" {
 		initMQTT()
 	}

storage.go

@@ -5,13 +5,14 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strconv"
 	"sync"
 	"time"
 )
 
 var csvMu sync.Mutex
 
-func appendCSV(csvPath, imagePath, reading string) error {
+func appendCSV(csvPath, imagePath, reading string, valid bool) error {
 	csvMu.Lock()
 	defer csvMu.Unlock()
 
@@ -21,8 +22,13 @@ func appendCSV(csvPath, imagePath, reading string) error {
 	}
 	defer f.Close()
 
+	validStr := "0"
+	if valid {
+		validStr = "1"
+	}
+
 	w := csv.NewWriter(f)
-	if err := w.Write([]string{imagePath, reading, time.Now().UTC().Format(time.RFC3339)}); err != nil {
+	if err := w.Write([]string{imagePath, reading, time.Now().UTC().Format(time.RFC3339), validStr}); err != nil {
 		return err
 	}
 	w.Flush()
@@ -77,13 +83,52 @@ func storeImages(imageData, processedData []byte, cropped, masked bool) string {
 }
 
 // storeReading appends a row to readings.csv.
-func storeReading(imagePath, reading string) {
+func storeReading(imagePath, reading string, valid bool) {
 	if storagePath == "" || imagePath == "" || reading == "" {
 		return
 	}
 
 	csvPath := filepath.Join(storagePath, "readings.csv")
-	if err := appendCSV(csvPath, imagePath, reading); err != nil {
+	if err := appendCSV(csvPath, imagePath, reading, valid); err != nil {
 		log.Printf("csv append error: %v", err)
 	}
+}
+
+// lastStoredReading reads the last valid reading from a readings.csv file.
+// For backwards compatibility, rows without a valid column (old 3-column format)
+// are assumed valid.
+func lastStoredReading(csvPath string, divisor float64) (float64, bool) {
+	f, err := os.Open(csvPath)
+	if err != nil {
+		return 0, false
+	}
+	defer f.Close()
+
+	r := csv.NewReader(f)
+	r.FieldsPerRecord = -1
+
+	var lastVal float64
+	var found bool
+
+	for {
+		row, err := r.Read()
+		if err != nil {
+			break
+		}
+		if len(row) < 2 {
+			continue
+		}
+		// Column 3 (index 3) is the valid flag. If absent (old format), assume valid.
+		if len(row) >= 4 && row[3] == "0" {
+			continue
+		}
+		val, err := strconv.ParseFloat(row[1], 64)
+		if err != nil {
+			continue
+		}
+		lastVal = val / divisor
+		found = true
+	}
+
+	return lastVal, found
 }

storage_test.go

@@ -0,0 +1,117 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLastStoredReading(t *testing.T) {
+	tests := []struct {
+		name    string
+		csv     string // file contents; empty string = don't create file
+		noFile  bool
+		divisor float64
+		wantVal float64
+		wantOK  bool
+	}{
+		{
+			name:   "file does not exist",
+			noFile: true,
+			wantOK: false,
+		},
+		{
+			name:   "empty file",
+			csv:    "",
+			wantOK: false,
+		},
+		{
+			name:    "single valid row 4-column",
+			csv:     "img.jpg,00036596,2026-05-07T14:50:45Z,1\n",
+			divisor: 1000,
+			wantVal: 36.596,
+			wantOK:  true,
+		},
+		{
+			name:    "multiple rows returns last valid",
+			csv:     "a.jpg,10000,2026-01-01T00:00:00Z,1\nb.jpg,20000,2026-01-02T00:00:00Z,1\n",
+			divisor: 1000,
+			wantVal: 20,
+			wantOK:  true,
+		},
+		{
+			name:    "last row invalid skipped",
+			csv:     "a.jpg,10000,2026-01-01T00:00:00Z,1\nb.jpg,20000,2026-01-02T00:00:00Z,0\n",
+			divisor: 1000,
+			wantVal: 10,
+			wantOK:  true,
+		},
+		{
+			name:    "all rows invalid",
+			csv:     "a.jpg,10000,2026-01-01T00:00:00Z,0\nb.jpg,20000,2026-01-02T00:00:00Z,0\n",
+			divisor: 1000,
+			wantOK:  false,
+		},
+		{
+			name:    "old 3-column format assumed valid",
+			csv:     "img.jpg,00036596,2026-05-07T14:50:45Z\n",
+			divisor: 1000,
+			wantVal: 36.596,
+			wantOK:  true,
+		},
+		{
+			name:    "mixed old and new format",
+			csv:     "a.jpg,10000,2026-01-01T00:00:00Z\nb.jpg,20000,2026-01-02T00:00:00Z,1\nc.jpg,30000,2026-01-03T00:00:00Z,0\n",
+			divisor: 1000,
+			wantVal: 20,
+			wantOK:  true,
+		},
+		{
+			name:    "unparseable reading skipped",
+			csv:     "a.jpg,10000,2026-01-01T00:00:00Z,1\nb.jpg,notanumber,2026-01-02T00:00:00Z,1\n",
+			divisor: 1000,
+			wantVal: 10,
+			wantOK:  true,
+		},
+		{
+			name:    "divisor applied",
+			csv:     "img.jpg,5000,2026-01-01T00:00:00Z,1\n",
+			divisor: 100,
+			wantVal: 50,
+			wantOK:  true,
+		},
+		{
+			name:    "row with too few columns skipped",
+			csv:     "onlyonefield\na.jpg,10000,2026-01-01T00:00:00Z,1\n",
+			divisor: 1000,
+			wantVal: 10,
+			wantOK:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := t.TempDir()
+			csvPath := filepath.Join(dir, "readings.csv")
+
+			if !tt.noFile {
+				if err := os.WriteFile(csvPath, []byte(tt.csv), 0644); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			divisor := tt.divisor
+			if divisor == 0 {
+				divisor = 1
+			}
+
+			gotVal, gotOK := lastStoredReading(csvPath, divisor)
+			if gotOK != tt.wantOK {
+				t.Fatalf("ok = %v, want %v", gotOK, tt.wantOK)
+			}
+			if gotOK && gotVal != tt.wantVal {
+				t.Errorf("val = %f, want %f", gotVal, tt.wantVal)
+			}
+		})
+	}
+}