EchoLot/EchoLotSetup.cpp

/*
 * EchoLotSetup.cpp
 *
 *  Created on: 10.01.2026
 *      Author: FSmilari
 */

#include "EchoLotSetup.h"
#include "fonts/FreeSans7pt7b.h"
//#include <Fonts/FreeSans9pt7b.h>

#define ADDR_AIR_TEMP     0   // WORD
#define ADDR_WATER_TEMP   2   // +2 WORDs
#define ADDR_SONIC_AIR    4   // +2 WORDs
#define ADDR_SALTPERMIL   6   // +2 WORDs

// --------------------------------------------------
// Konstruktor
// --------------------------------------------------
EchoLotSetup::EchoLotSetup(Display &display) : display(display) {
	airTemp = 20.0f;
	waterTemp = 20.0f;
	sonicSpeedAir = 343.0f;
	saltPromilleWater = 35;

	doInitialization = true;
	configStepIndex = 0;
}

// --------------------------------------------------
// Initialisierung
// --------------------------------------------------
void EchoLotSetup::initialize() {
	EEPROM.init();
	readFromEEPROM();
	display.setStatusValues(airTemp, waterTemp);

	display.clearDisplay();
	display.showFrame(INITIALIZATION);
	printValues();
	delay(2000);

	configStepIndex = 0;
	doInitialization = false;
}

// --------------------------------------------------
// Rotary Switch (kurz)
// --------------------------------------------------
void EchoLotSetup::onRotaryControlerSwitch() {
	configStepIndex++;
	if (configStepIndex >= 5) {
		configStepIndex = 0;
	}
}

// --------------------------------------------------
// Rotary Switch (lang)
// --------------------------------------------------
void EchoLotSetup::onRotaryControlerLongSwitch() {

}

// --------------------------------------------------
// Rotary Drehung
// --------------------------------------------------
void EchoLotSetup::onRotaryControlerTurn(RotaryEncoder::Direction turn)
		{
	float delta = (turn == RotaryEncoder::Direction::CLOCKWISE) ? 1.0f : -1.0f;

	switch (configStepIndex) {
		case 0:
			airTemp += delta;
			break;
		case 1:
			waterTemp += delta;
			break;
		case 2:
			sonicSpeedAir += delta;
			break;
		case 3:
			saltPromilleWater += delta;
			break;
		default:
			break;
	}

}

// --------------------------------------------------
// Speichern bestätigen
// --------------------------------------------------
void EchoLotSetup::save() {
	saveToEEPROM();
}

// --------------------------------------------------
// Abbrechen
// --------------------------------------------------
void EchoLotSetup::cancel() {
	readFromEEPROM();
}

// --------------------------------------------------
// Display leeren
// --------------------------------------------------
void EchoLotSetup::clear() {
	display.clearDisplay();
}

// --------------------------------------------------
// EEPROM lesen
// --------------------------------------------------
void EchoLotSetup::readFromEEPROM() {
	setAirTemp(readFloatFromEEPROM(ADDR_AIR_TEMP));
	setWaterTemp(readFloatFromEEPROM(ADDR_WATER_TEMP));
	setSonicSpeedAir(readFloatFromEEPROM(ADDR_SONIC_AIR));
	setSaltPromilleWater(readIntegerFromEEPROM(ADDR_SALTPERMIL));
}

// --------------------------------------------------
// EEPROM schreiben
// --------------------------------------------------
void EchoLotSetup::saveToEEPROM() {
	writeFloatToEEPROM(ADDR_AIR_TEMP, airTemp);
	writeFloatToEEPROM(ADDR_WATER_TEMP, waterTemp);
	writeFloatToEEPROM(ADDR_SONIC_AIR, sonicSpeedAir);
	writeIntegerToEEPROM(ADDR_SALTPERMIL, saltPromilleWater);
}

// --------------------------------------------------
// Werte anzeigen
// --------------------------------------------------
void EchoLotSetup::printValues() {
	String value = String(sonicSpeedAir);
	Serial.print(String(AIRTEMP) + ": " + String(getAirTemp(), 1) + ", ");
	Serial.print(String(WATERTEMP) + ": " + String(getWaterTemp(), 1) + ", ");
	Serial.print(String(SONICSPEEDAIR) + ": " + String(getSonicSpeedAir(), 1) + ", ");
	Serial.println(String(SALTPROMILLEWATER) + ": " + String(getSaltPromilleWater()));

	display.drawText(ConfigStep[0], &FreeSans7pt7b, 1, ST7735_WHITE, 7, 30);
	display.drawRightAlignedText(String(getAirTemp(), 1) + "  C", &FreeSans7pt7b, 1, ST7735_WHITE, 8, 30);
	display.drawCircle(140, 23, 2, ST7735_WHITE);

	display.drawText(ConfigStep[1], &FreeSans7pt7b, 1, ST7735_WHITE, 7, 55);
	display.drawRightAlignedText(String(getWaterTemp(), 1) + "  C", &FreeSans7pt7b, 1, ST7735_WHITE, 8, 55);
	display.drawCircle(140, 48, 2, ST7735_WHITE);

	display.drawText(ConfigStep[2], &FreeSans7pt7b, 1, ST7735_WHITE, 7, 80);
	display.drawRightAlignedText(String(getSonicSpeedAir(), 1) + " m/s", &FreeSans7pt7b, 1, ST7735_WHITE, 8, 80);

	display.drawText(ConfigStep[3], &FreeSans7pt7b, 1, ST7735_WHITE, 7, 105);
	display.drawRightAlignedText(String(getSaltPromilleWater()) + "  /  ", &FreeSans7pt7b, 1, ST7735_WHITE, 8, 105);
	display.drawCircle(140, 98, 2, ST7735_WHITE);
	display.drawCircle(148, 104, 2, ST7735_WHITE);
	display.drawCircle(153, 104, 2, ST7735_WHITE);
}

// --------------------------------------------------
// Private Helper
// --------------------------------------------------
String EchoLotSetup::getCfgOptForStepIndex(byte index) {
	return ConfigStep[index];
}

String EchoLotSetup::getCfgOptUnitForStepIndex(byte index) {
	switch (index) {
		case 0:
			case 1:
			return "°C";
		case 2:
			case 3:
			return "m/s";
		default:
			return "";
	}
}

float EchoLotSetup::getAirTemp() const {
	return airTemp;
}

void EchoLotSetup::setAirTemp(float airTemp) {
	this->airTemp = airTemp;
}

float EchoLotSetup::getWaterTemp() const {
	return waterTemp;
}

void EchoLotSetup::setWaterTemp(float waterTemp) {
	this->waterTemp = waterTemp;
}

float EchoLotSetup::getSonicSpeedAir() const {
	return sonicSpeedAir;
}

void EchoLotSetup::setSonicSpeedAir(float sonicSpeedAir) {
	this->sonicSpeedAir = sonicSpeedAir;
}

int EchoLotSetup::getSaltPromilleWater() const {
	return saltPromilleWater;
}

void EchoLotSetup::setSaltPromilleWater(int saltPromilleWater) {
	this->saltPromilleWater = saltPromilleWater;
}

void EchoLotSetup::writeFloatToEEPROM(uint16_t addr, float value) {
	uint16_t *p = (uint16_t*) (void*) &value;

	// float = 2 x uint16_t
	EEPROM.update(addr, p[0]);
	EEPROM.update(addr + 1, p[1]);
}

float EchoLotSetup::readFloatFromEEPROM(uint16_t addr) {
	float value;
	uint16_t *p = (uint16_t*) (void*) &value;

	p[0] = EEPROM.read(addr);
	p[1] = EEPROM.read(addr + 1);

	return value;
}

void EchoLotSetup::writeIntegerToEEPROM(uint16_t addr, int value) {
	EEPROM.update(addr, (uint16_t) value);
}

int EchoLotSetup::readIntegerFromEEPROM(uint16_t addr) {
	return (int) EEPROM.read(addr);
}