Spannung/main.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"sync"

	"spannung/web" // Importiert das eigene web-Paket

	"periph.io/x/conn/v3/gpio"
	"periph.io/x/conn/v3/gpio/gpioreg"
	"periph.io/x/conn/v3/i2c/i2creg"
	"periph.io/x/conn/v3/physic"
	"periph.io/x/devices/v3/ads1x15"
	"periph.io/x/host/v3"
)

type Config struct {
	WebPort         string       `json:"web_port"`
	I2CBus          string       `json:"i2c_bus"`
	ADS1115Address1 uint16       `json:"ads1115_address_1"`
	ADS1115Address2 uint16       `json:"ads1115_address_2"`
	FactorAdc1Ch0   float64      `json:"factor_adc1_ch0"`
	FactorAdc1Ch1   float64      `json:"factor_adc1_ch1"`
	FactorAdc1Ch2   float64      `json:"factor_adc1_ch2"`
	FactorAdc1Ch3   float64      `json:"factor_adc1_ch3"`
	FactorAdc2Ch0   float64      `json:"factor_adc2_ch0"`
	Relais          []RelaisConf `json:"relais_pins"`
}

type RelaisConf struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	GPIO  string `json:"gpio"`
	State bool   `json:"-"`
}

var (
	config     Config
	adsDevice1 *ads1x15.Dev
	adsDevice2 *ads1x15.Dev
	relaisMap  = make(map[int]gpio.PinIO)
	mutex      sync.Mutex
	Version    = "Entwicklung"
	BuildDate  = "Unbekannt"
)

func main() {
	confFile, err := os.ReadFile("config.json")
	if err != nil {
		log.Fatalf("Fehler beim Lesen der config.json: %v", err)
	}
	if err := json.Unmarshal(confFile, &config); err != nil {
		log.Fatalf("Fehler beim Parsen der config.json: %v", err)
	}

	if _, err = host.Init(); err != nil {
		log.Fatalf("Hardware-Init fehlgeschlagen: %v", err)
	}

	bus, err := i2creg.Open(config.I2CBus)
	if err != nil {
		log.Fatalf("I2C Bus Fehler: %v", err)
	}

	// 1. Ersten ADS1115 initialisieren (z.B. Adresse 72 / 0x48)
	opts1 := ads1x15.DefaultOpts
	opts1.I2cAddress = config.ADS1115Address1
	adsDevice1, err = ads1x15.NewADS1115(bus, &opts1)
	if err != nil {
		log.Fatalf("ADS1115 #1 Init fehlgeschlagen: %v", err)
	}

	// 2. Zweiten ADS1115 initialisieren (z.B. Adresse 73 / 0x49)
	opts2 := ads1x15.DefaultOpts
	opts2.I2cAddress = config.ADS1115Address2
	adsDevice2, err = ads1x15.NewADS1115(bus, &opts2)
	if err != nil {
		log.Fatalf("ADS1115 #2 Init fehlgeschlagen: %v", err)
	}

	// GPIO-Pins registrieren
	for i, r := range config.Relais {
		pin := gpioreg.ByName(r.GPIO)
		if pin == nil {
			log.Fatalf("GPIO-Pin %s existiert nicht", r.GPIO)
		}
		if err := pin.Out(gpio.Low); err != nil {
			log.Fatalf("Pin-Konfiguration für %s fehlgeschlagen: %v", r.GPIO, err)
		}
		relaisMap[r.ID] = pin
		config.Relais[i].State = false
	}

	// Instanziierung des Webservers mit Übergabe der Callback-Funktionen
	server := web.NewServer(config.WebPort, readVoltageCallback, toggleRelaisCallback, getRelaisStateCallback, callbackGetVersion)

	fmt.Printf("Webserver gestartet auf Port %s\n", config.WebPort)
	log.Fatal(server.Start())
}

// Callback: Wird vom Webserver aufgerufen, um Kanäle zu messen
// Kanäle 0-3 = ADS1115 Nr. 1 (A0-A3)
// Kanal 4   = ADS1115 Nr. 2 (A0)
func readVoltageCallback(channel int) float64 {
	mutex.Lock()
	defer mutex.Unlock()

	var targetDevice *ads1x15.Dev
	var adsChannel ads1x15.Channel
	var factor float64

	switch channel {
	case 0:
		targetDevice = adsDevice1
		adsChannel = ads1x15.Channel0
		factor = config.FactorAdc1Ch0
	case 1:
		targetDevice = adsDevice1
		adsChannel = ads1x15.Channel1
		factor = config.FactorAdc1Ch1
	case 2:
		targetDevice = adsDevice1
		adsChannel = ads1x15.Channel2
		factor = config.FactorAdc1Ch2
	case 3:
		targetDevice = adsDevice1
		adsChannel = ads1x15.Channel3
		factor = config.FactorAdc1Ch3
	case 4:
		targetDevice = adsDevice2
		adsChannel = ads1x15.Channel0 // Erster Eingang vom zweiten Chip
		factor = config.FactorAdc2Ch0

	default:
		fmt.Printf("Ungültiger Kanal abgefragt: %v\n", channel)
		return 0.0
	}

	pin, err := targetDevice.PinForChannel(adsChannel, physic.Volt*4096/1000, 128*physic.Hertz, 0)
	if err != nil {
		fmt.Printf("Fehler beim Erzeugen des Pins für Kanal %v: %v\n", channel, err)
		return 0.0
	}

	sample, err := pin.Read()
	if err != nil {
		fmt.Printf("Fehler beim Lesen von Kanal %v: %v\n", channel, err)
		return 0.0
	}

	voltValue := float64(sample.V) / 1000000000.0
	return voltValue * factor
}

// Callback: Wird vom Webserver aufgerufen, um ein Relais zu schalten
func toggleRelaisCallback(id int) {
	mutex.Lock()
	defer mutex.Unlock()

	pin, exists := relaisMap[id]
	if !exists {
		return
	}

	// Direkt über den Index das globale Slice manipulieren
	for i := range config.Relais {
		if config.Relais[i].ID == id {
			// Status sauber invertieren
			config.Relais[i].State = !config.Relais[i].State

			// Hardware basierend auf dem neuen, echten Zustand schalten
			if config.Relais[i].State {
				pin.Out(gpio.High) // Wenn True -> Pin High
			} else {
				pin.Out(gpio.Low)  // Wenn False -> Pin Low
			}
			break
		}
	}
}


// Callback: Wird vom Webserver aufgerufen, um den aktuellen UI-Status abzufragen
func getRelaisStateCallback() []web.RelaisData {
	mutex.Lock()
	defer mutex.Unlock()

	data := make([]web.RelaisData, len(config.Relais))
	for i, r := range config.Relais {
		data[i] = web.RelaisData{
			ID:    r.ID,
			Name:  r.Name,
			State: r.State,
		}
	}
	return data
}

// Versionangaben aus version.json in Webserver übernehmen
func callbackGetVersion() (string, string) {
	return Version, BuildDate
}