sungrow/main.go

/*
   Copyright 2023 Josh Deprez

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

	   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

// The sungrow binary periodically reads inverter data from a sungrow inverter
// and exports the data as prometheus metrics.
package main

import (
	"errors"
	"flag"
	"fmt"
	"log"
	"net/http"
	"strings"
	"sync"
	"time"

	"gitea.drjosh.dev/josh/sungrow/modbus"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
	"github.com/prometheus/client_golang/prometheus/promhttp"
)

const maxScrapeAge = 3 * time.Second

var (
	httpAddr       = flag.String("http-addr", ":9455", "Address to listen on")
	inverterAddrs  = flag.String("inverter-addrs", "rakmodule_00DBC1:502,192.168.86.6:502", "Comma-separated list of inverter addresses (modbus-tcp with 'encryption')")
	scrapeInterval = flag.Duration("scrape-interval", 15*time.Second, "Period of modbus scraping loop")

	scrapeMu   sync.Mutex
	lastScrape time.Time
	lastValues = make(map[uint16]float64)

	scrapeCounter = promauto.NewCounter(prometheus.CounterOpts{
		Namespace: "sungrow",
		Subsystem: "scraper",
		Name:      "scrapes_total",
	})
	scrapeStart = promauto.NewGauge(prometheus.GaugeOpts{
		Namespace: "sungrow",
		Subsystem: "scraper",
		Name:      "scrape_start",
	})
	scrapeEnd = promauto.NewGauge(prometheus.GaugeOpts{
		Namespace: "sungrow",
		Subsystem: "scraper",
		Name:      "scrape_end",
	})
	scrapeDuration = promauto.NewGauge(prometheus.GaugeOpts{
		Namespace: "sungrow",
		Subsystem: "scraper",
		Name:      "scrape_duration",
		Help:      "units:s",
	})
)

func init() {
	promauto.NewGaugeFunc(
		prometheus.GaugeOpts{
			Namespace: "sungrow",
			Subsystem: "scraper",
			Name:      "scrape_interval",
			Help:      "units:s",
		},
		func() float64 { return scrapeInterval.Seconds() },
	)
	promauto.NewGaugeFunc(
		prometheus.GaugeOpts{
			Namespace: "sungrow",
			Subsystem: "tariff",
			Name:      "daily_charge",
			Help:      "unit:$",
		},
		func() float64 { return dailySupplyCharge },
	)
	promauto.NewGaugeFunc(
		prometheus.GaugeOpts{
			Namespace: "sungrow",
			Subsystem: "tariff",
			Name:      "import_tariff",
			Help:      "unit:$",
		},
		func() float64 { return tariff93.pricePerKWh(time.Now()) },
	)
	promauto.NewGaugeFunc(
		prometheus.GaugeOpts{
			Namespace: "sungrow",
			Subsystem: "tariff",
			Name:      "export_tariff",
			Help:      "unit:$",
		},
		func() float64 { return solarFeedInTariff.pricePerKWh(time.Now()) },
	)
}

func statusHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "current time: %v\n", time.Now())
}

// Called under scrapeMu.
func readRegs(client modbus.Client, start, qty uint16) {
	data, err := client.ReadInputRegisters(start, qty)
	if err != nil {
		log.Fatalf("Couldn't read input registers %d-%d: %v", start+1, start+qty, err)
	}
	if len(data) != int(2*qty) {
		log.Fatalf("Couldn't read input registers %d-%d: len(data) = %d != %d = 2*qty", start+1, start+qty, len(data), 2*qty)
	}
	for addr, reg := range sungrowInputRegs {
		if addr <= start || addr > start+qty {
			continue
		}
		val, err := reg.read(data[(addr-start-1)*2:])
		if err != nil {
			if errors.Is(err, errSkippableRead) {
				log.Printf("Couldn't parse input register data at %d, skipping: %v", addr, err)
				continue
			}
			log.Fatalf("Couldn't parse input register data at %d: %v", addr, err)
		}
		//fmt.Printf("%s: %v %s\n", reg.name, val, reg.unit)
		lastValues[addr] = val
	}
}

// Called under scrapeMu.
func scrape(client modbus.Client) {
	start := time.Now()
	scrapeStart.SetToCurrentTime()
	readRegs(client, 5000, 100)
	readRegs(client, 5100, 50)
	scrapeEnd.SetToCurrentTime()
	lastScrape = time.Now()
	scrapeDuration.Set(time.Since(start).Seconds())
	scrapeCounter.Inc()
}

func main() {
	flag.Parse()

	// Is the inverter reachable?
	var sgc *sungrowConn
	for _, addr := range strings.Split(*inverterAddrs, ",") {
		conn, err := dialSungrow(addr)
		if err != nil {
			log.Printf("Couldn't dial inverter: %v", err)
			continue
		}
		sgc = conn
		defer conn.Close()
		break
	}
	if sgc == nil {
		log.Fatal("Couldn't dial any addresses, aborting")
	}

	// HTTP setup
	http.Handle("/metrics", promhttp.Handler())
	http.HandleFunc("/", statusHandler)

	handler := modbus.TCPHandlerFromConnection(sgc)
	handler.SlaveId = 0x01
	//handler.Connect()
	defer handler.Close()
	client := modbus.NewClient(handler)

	// Finally, create all the register gauges.
	// These are GaugeFuncs to more closely align Prometheus scrape time with
	// the modbus scrape time.
	for addr, reg := range sungrowInputRegs {
		addr, reg := addr, reg
		promauto.NewGaugeFunc(
			prometheus.GaugeOpts{
				Namespace: "sungrow",
				Subsystem: "inverter",
				Name:      reg.name,
				Help:      fmt.Sprintf("addr: %d, unit: %s", addr, reg.unit),
			},
			func() float64 {
				scrapeMu.Lock()
				defer scrapeMu.Unlock()
				if time.Since(lastScrape) <= maxScrapeAge {
					return lastValues[addr]
				}
				scrape(client)
				return lastValues[addr]
			},
		)
	}

	log.Fatalf("http.ListenAndServe: %v", http.ListenAndServe(*httpAddr, nil))
}