Ich will meinen PV-Strom nicht vergeuden – also nutze ich ihn fürs CPU-Mining

Seit ich meine eigene Photovoltaikanlage betreibe, beschäftigt mich eine Frage: Wie kann ich meinen selbst erzeugten Solarstrom möglichst sinnvoll nutzen? Natürlich kann ich einfach einspeisen. Aber die Einspeisevergütung ist niedrig und fühlt sich nicht besonders „smart“ an.

Ich will meinen PV-Strom nicht einfach herschenken. Ich will, dass er arbeitet. Und weil ich ohnehin Geräte habe, die fast rund um die Uhr laufen – ein Homeserver, ein Raspberry Pi für Plex und ein Arbeitslaptop – habe ich angefangen, genau diese Hardware als „Energie-Senke“ für Überschussstrom zu benutzen.

Das Ergebnis ist ein Setup, das CPU-Mining nur dann aktiviert, wenn meine PV-Anlage Überschuss produziert. Ich nenne das gern: Stromveredelung statt Verschwendung.

Technische Grundlage lesen: In meinem Beitrag PV-Skript & Wechselrichter-Integration erkläre ich, wie ich die Daten aus dem Wechselrichter auslese und damit entscheide, ob Überschuss vorhanden ist.

Meine Motivation: Eigenverbrauch ist mir wichtiger als Einspeisung

Jeder Betreiber einer Photovoltaikanlage kennt das Prinzip: Je mehr du von deinem eigenen Strom selbst verbrauchst, desto wirtschaftlicher wird die Anlage. Denn jede kWh, die du nicht zukaufst, spart dir den vollen Haushaltsstrompreis. Einspeisen dagegen bringt dir oft nur ein paar Cent pro kWh.

Mein Ziel ist es, den Eigenverbrauch meiner PV-Anlage zu erhöhen – nicht die Einspeisemenge.

Das heißt übersetzt: Wenn mein Dach Strom produziert und ich den gerade nicht für Haushalt, Heizung, Laden etc. brauche, möchte ich trotzdem etwas Sinnvolles damit tun.

Also habe ich mir überlegt: Warum nicht Rechenarbeit erledigen lassen? Etwas, das keinen Zeitdruck hat, aber rechenintensiv ist. Und was bietet sich dafür an? Richtig: CPU-Mining mit XMRig.

Warum gerade Monero (XMR) und XMRig?

Die meisten großen Coins wie Bitcoin lassen sich nur noch mit hochspezialisierter Hardware (ASICs) effizient minen. Das ist teuer, laut, ineffizient für kleine Setups und komplett unpraktisch für jemanden wie mich, der einfach PV-Überschuss verwerten will.

Monero (XMR) ist anders. Das Protokoll ist absichtlich ASIC-resistent. Bedeutet: Man kann Monero noch sinnvoll auf ganz normalen CPUs minen. Genau dafür gibt es Tools wie XMRig, die auf Linux, Windows und sogar auf einem Raspberry Pi laufen können.

Vorteile für mich:

Ich muss keine neue Hardware kaufen. Ich nutze nur Geräte, die sowieso laufen.
Ich kann per Skript exakt steuern, wann geminet wird.
Das Mining selbst ist modular: Ich starte es einfach als Prozess und kann es genauso wieder killen.

Live anschauen: Mein aktuelles Wechselrichter-Dashboard mit PV-Output, Hausverbrauch und Mining-Status findest du hier:
thinkkreativ.de/wechselrichter

Meine Hardware: Was hier rechnet

Für dieses Projekt habe ich bewusst keine neue Hardware gekauft. Ich verwende, was eh da ist:

Gerät	Hauptaufgabe	Läuft wie lange?	Mining geeignet?
Homeserver	Plex, Files, Automationen	24/7	✅ Sehr gut
Raspberry Pi	Medienserver, Sensordaten	24/7	⚠️ Begrenzte Leistung
Arbeitslaptop	Development, Arbeitstools	Tagsüber	✅ Teilzeit

Wichtig: Ich lasse nicht blind auf allen Geräten minen. Der Server ist der Hauptkandidat, weil er sowieso durchläuft und ausreichend gekühlt ist. Der Raspberry Pi ist eher ein Experiment („geht das überhaupt?“). Der Laptop springt nur bei guter Sonneneinstrahlung ein.

Die Automatisierung: Nur minen, wenn wirklich Überschuss da ist

Jetzt kommt der spannende Teil: Ich lasse nicht konstant minen. Das wäre sinnlos und würde teilweise sogar Netzstrom verbrauchen – genau das will ich ja NICHT.

Stattdessen frage ich regelmäßig (alle 5 Minuten) folgende Werte ab:

PV_OUTPUT: aktuelle Erzeugung durch die PV in Watt
HOUSE_USAGE: aktueller Hausverbrauch in Watt

Dann vergleiche ich:
PV_OUTPUT > HOUSE_USAGE + THRESHOLD

THRESHOLD ist ein Puffer von z. B. 200 W. Der stellt sicher, dass kleine Schwankungen nicht sofort zu Mining/Stop/Mining/Stop führen.

pv_mine.sh (vereinfacht):

#!/bin/bash

PV_OUTPUT=$(curl -s http://meinwechselrichter.local/api/erzeugung)
HOUSE_USAGE=$(curl -s http://meinwechselrichter.local/api/verbrauch)

THRESHOLD=200

if (( $(echo "$PV_OUTPUT > $HOUSE_USAGE + $THRESHOLD" | bc -l) )); then
    if ! pgrep xmrig > /dev/null; then
        echo "$(date): Starte Mining – PV: $PV_OUTPUT W, Verbrauch: $HOUSE_USAGE W"
        /opt/xmrig/xmrig &
    fi
else
    if pgrep xmrig > /dev/null; then
        echo "$(date): Stoppe Mining – PV: $PV_OUTPUT W, Verbrauch: $HOUSE_USAGE W"
        pkill xmrig
    fi
fi

Dieses Skript läuft bei mir über cron:

*/5 * * * * /usr/local/bin/pv_mine.sh >> /var/log/pv_mine.log 2>&1

Das bedeutet: Alle 5 Minuten prüfe ich, ob genug Sonne da ist. Wenn ja → XMRig läuft. Wenn nein → XMRig wird sauber beendet.

Die Logik, wie ich die Werte PV_OUTPUT und HOUSE_USAGE vom Wechselrichter bekomme, habe ich hier im Detail beschrieben: PV-Skript & Wechselrichter-Integration .

Und wenn du sehen willst, wie das in Echtzeit aussieht – inklusive PV-Erzeugung, Hausverbrauch, aktuellem Überschuss und ob gerade Mining aktiv ist – kannst du dir mein Dashboard anschauen: thinkkreativ.de/wechselrichter .

Installation von XMRig (Schritt für Schritt)

Ich nutze XMRig als Miner. Das Tool ist Open Source und relativ einfach zu bauen. Offizielle Doku: xmrig.com/docs/miner .

1. Abhängigkeiten installieren (Ubuntu / Debian)

sudo apt update
sudo apt install -y git build-essential cmake libuv1-dev libssl-dev libhwloc-dev

2. XMRig clonen & bauen

git clone https://github.com/xmrig/xmrig.git
cd xmrig
mkdir build && cd build
cmake ..
make -j$(nproc)

3. Konfiguration (config.json)

Die Datei config.json enthält deine Wallet, den Mining-Pool und wie XMRig laufen soll. Beispiel:

{
    "autosave": true,
    "cpu": true,
    "opencl": false,
    "cuda": false,
    "donate-level": 1,
    "pools": [
        {
            "url": "pool.supportxmr.com:3333",
            "user": "DEINE_MONERO_WALLET_ADRESSE",
            "pass": "pv_mining",
            "keepalive": true,
            "tls": true
        }
    ]
}

Tipp: Du kannst verschiedene Pools vergleichen (z. B. Gebührenmodell, Auszahlungsgrenze). Schau dir z. B. CPU-Mining-Einschätzungen auf poolbay.io an oder benutze einen Monero Mining Rechner (CoinWarz) , um grob abzuschätzen, wie viel pro Hashrate überhaupt drin ist.

Was am Ende wirklich rumkommt (Spoiler: kein Reichtum)

Lass uns ehrlich sein: Das hier ist kein „Geld drucken“. Mein Server bringt je nach Auslastung etwa ~2000–3000 H/s (Hashes pro Sekunde).

Hochgerechnet auf 24 Stunden Dauerbetrieb wären das vielleicht 5–15 Cent pro Tag in Monero – je nach Kurs- und Netzwerk-Schwierigkeit. Aber: Ich lasse ja nicht 24/7 laufen. Ich lasse nur laufen, wenn Sonne da ist. Realistisch lande ich bei vielleicht 1–3 Euro im Monat.

Wichtig: Wenn du Netzstrom zukaufen musst, ist dieses Setup finanziell praktisch sinnlos. Bei mir funktioniert es, weil die Energie ansonsten ungenutzt wäre.

Und das ist der entscheidende Punkt: Ich nutze meinen eigenen PV-Überschuss aktiv. Die Energie wäre sonst einfach eingespeist worden und hätte mir ein paar Cent gebracht. Jetzt bekomme ich stattdessen Rechenarbeit erledigt und lerne gleichzeitig mehr über mein Energiesystem.

Risiken & Dinge, die man wissen sollte

Wärme & Verschleiß: Dauerhafte CPU-Last macht warm. Also bitte Temperatur überwachen und ggf. Lüfterprofile anpassen.
Steuern / Rechtliches: Mining kann steuerlich relevant sein. Nur weil es „aus Spaß“ läuft, heißt es nicht, dass es keine Regeln gibt.
Kryptokurse schwanken stark: Der Ertrag in € ist nicht stabil.
Pool-Vertrauen: Nicht alle Mining-Pools sind seriös. Lieber nur etablierte Anbieter nutzen.
Netzlast vermeiden: Mein Skript verhindert, dass Mining läuft, wenn keine Sonne da ist. Sonst würdest du plötzlich zukaufen – und das ist das Gegenteil der Idee.

Zusammenfassung / Fazit

Mein Projekt „PV-Überschuss für CPU-Mining nutzen“ ist kein klassisches Rendite-Projekt. Es ist ein Autarkie- und Spaß-Projekt.

Ich nehme Energie, die ich selbst erzeuge, und gebe ihr eine Aufgabe. Ich erhöhe meinen Eigenverbrauch, ich verhindere, dass Strom sinnlos verschenkt wird, und ich lerne gleichzeitig viel über Automatisierung, Energieflüsse und Systemsteuerung.

Wenn du sehen willst, wie mein System im Live-Betrieb aussieht – inklusive PV-Leistung, Hausverbrauch, Überschuss und ob gerade geminet wird – dann schau hier vorbei: https://thinkkreativ.de/wechselrichter/

Und wenn du wissen willst, wie ich die technischen Daten vom Wechselrichter überhaupt einsammle und in Skripte gieße, findest du die technischen Details hier: https://thinkkreativ.de/blog/pv/

Update: Automatische PV-Integration mit Smartplug & Laptop (Oktober 2025)

Heute habe ich mein Projekt um eine spannende Komponente erweitert: Mein Arbeitslaptop (ein Dell XPS 15) ist nun ebenfalls in das PV-Mining-Setup integriert – allerdings intelligent gesteuert. Ziel war es, dass der Laptop nur dann läuft und Strom zieht, wenn meine Photovoltaikanlage genug Energie liefert, und sich automatisch in den Energiesparmodus begibt, sobald die Sonne untergeht.

Warum das sinnvoll ist

Während mein Homeserver dauerhaft läuft und der Raspberry Pi ohnehin wenig verbraucht, war der Laptop bisher ein Sonderfall: Er hängt tagsüber oft am Strom, auch wenn er gerade nichts tut – und nachts läuft er weiter, obwohl die PV keinen Strom liefert.

Mit einem einfachen Smartplug (z. B. von Tapo, Shelly oder Gosund) lässt sich das ändern. Der Plug ist so programmiert, dass er bei Sonnenuntergang abschaltet und bei Sonnenaufgang wieder einschaltet. Das war der Ausgangspunkt für mein neues Automations-Skript.

Was passieren soll

Wenn der Smartplug nachts den Strom trennt, erkennt der Laptop: Netzspannung weg → auf Akku umgeschaltet.
Ein Bash-Skript reagiert darauf:
- Mining-Prozess wird gestoppt.
- CPU auf stromsparenden Modus („powersave“).
- Display aus, Lüfter leiser.
- SSH bleibt aktiv, damit ich mich trotzdem verbinden kann.
Sinkt der Akku irgendwann unter 20 %, fährt der Laptop sauber herunter.
Am Morgen schaltet der Smartplug den Strom wieder ein. Über eine BIOS-Einstellung („AC Recovery → Power On“) startet der Laptop automatisch neu.
Beim Boot aktiviert systemd automatisch den Miner (xmrig.service) und den SSH-Dienst – das Mining läuft weiter.

Schritt 1: BIOS vorbereiten

Damit der Laptop nach einer Stromunterbrechung automatisch startet, muss im BIOS (bei Dell unter Power Management → AC Behavior) die Option „AC Recovery → Power On“ aktiviert sein.

Ohne diese Einstellung bleibt der Laptop nach Stromrückkehr einfach aus – das Betriebssystem bekommt dann keine Chance zu starten.

Schritt 2: SSH und Miner als Dienste aktivieren

Die Grundvoraussetzung: Beide Dienste müssen beim Booten automatisch starten.

sudo systemctl enable ssh
sudo systemctl enable xmrig.service

Damit laufen sie direkt nach jedem Systemstart ohne manuelles Eingreifen.

Schritt 3: Erkennen, ob Netzstrom oder Akku aktiv ist

Unter Linux ist der Netzstatus über /sys/class/power_supply/AC/online abrufbar.

cat /sys/class/power_supply/AC/online

1 = Netzteil aktiv
0 = Akku-Betrieb

Bei manchen Geräten heißt die Datei ACAD/online oder AC0/online – das Skript unten prüft alle Varianten automatisch.

Schritt 4: Hilfsskripte für Akku- und Netzmodus

Ich lege zwei einfache Skripte an, die ausführen, was im jeweiligen Zustand passieren soll:

`/usr/local/bin/on_battery.sh`

#!/bin/bash
echo "[power-mode] Switching to BATTERY mode"

# Miner stoppen
systemctl stop xmrig.service

# CPU auf Stromsparmodus setzen
if command -v cpupower >/dev/null 2>&1; then
    cpupower frequency-set -g powersave >/dev/null 2>&1
fi

# Display ausschalten (optional)
export DISPLAY=:0
export XAUTHORITY=/home/thom7e/.Xauthority
if command -v xset >/dev/null 2>&1; then
    xset dpms force off >/dev/null 2>&1
fi

`/usr/local/bin/on_ac.sh`

#!/bin/bash
echo "[power-mode] Switching to AC mode"

# CPU wieder auf Leistung stellen
if command -v cpupower >/dev/null 2>&1; then
    cpupower frequency-set -g performance >/dev/null 2>&1
fi

# Miner starten
systemctl start xmrig.service

# Netzwerkverbindung sicherstellen
systemctl restart NetworkManager

Beide Skripte ausführbar machen:

sudo chmod +x /usr/local/bin/on_battery.sh
sudo chmod +x /usr/local/bin/on_ac.sh

Schritt 5: Hauptskript zur Überwachung

Das folgende Skript erkennt automatisch, ob Netzstrom oder Akku aktiv ist, und ruft die passenden Aktionen auf. Außerdem überwacht es den Akkustand – bei <20 % wird das System sauber heruntergefahren:

`/usr/local/bin/power-mode-watcher.sh`

#!/bin/bash
AC_PATH=""
for CAND in /sys/class/power_supply/AC/online /sys/class/power_supply/ACAD/online /sys/class/power_supply/AC0/online; do
  if [ -f "$CAND" ]; then
    AC_PATH="$CAND"
    break
  fi
done
[ -z "$AC_PATH" ] && { echo "No AC path found"; exit 1; }

LAST_STATE=""

while true; do
  CUR_STATE=$(cat "$AC_PATH" 2>/dev/null)
  if [ "$CUR_STATE" != "$LAST_STATE" ]; then
    if [ "$CUR_STATE" = "1" ]; then
      /usr/local/bin/on_ac.sh
    else
      /usr/local/bin/on_battery.sh
    fi
    LAST_STATE="$CUR_STATE"
  fi

  if [ "$CUR_STATE" = "0" ]; then
    PCT=$(upower -i /org/freedesktop/UPower/devices/battery_BAT0 | grep percentage | awk '{print $2}' | tr -d '%')
    [ -n "$PCT" ] && [ "${PCT%.*}" -lt 20 ] && { echo "Battery low (${PCT}%) → shutdown"; shutdown -h now; }
  fi
  sleep 10
done

Ausführbar machen:

sudo chmod +x /usr/local/bin/power-mode-watcher.sh

Schritt 6: Systemdienst erstellen

Damit das Skript automatisch beim Systemstart läuft:

`/etc/systemd/system/power-mode-watcher.service`

[Unit]
Description=Monitor AC/battery state for PV-mining laptop
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/power-mode-watcher.sh
Restart=always
RestartSec=5
User=root

[Install]
WantedBy=multi-user.target

Aktivieren und starten:

sudo systemctl daemon-reload
sudo systemctl enable power-mode-watcher.service
sudo systemctl start power-mode-watcher.service

Schritt 7: Tests & Tipps

Test ohne Sonne: Stecker des Netzteils ziehen. Innerhalb von 10 Sekunden sollte der Miner stoppen, die CPU auf „powersave“ wechseln.
Test mit Sonne: Netzteil wieder einstecken. Der Miner startet, Netzwerk wird neu verbunden.
Funktion prüfen: journalctl -u power-mode-watcher.service -f

Ergebnis & Fazit

Damit läuft der Laptop perfekt synchron mit meiner PV-Anlage:

Tagsüber (Smartplug an, Sonne scheint): Mining aktiv, CPU auf Performance.
Nachts (Smartplug aus): Miner gestoppt, CPU sparsam, SSH erreichbar.
Bei niedrigem Akku: Sauberer Shutdown, kein Datenverlust, Akku geschützt.
Morgens: Strom an → BIOS startet automatisch → Mining läuft weiter.

Das System ist vollständig autark und reagiert dynamisch auf Energieverfügbarkeit. Ich nutze damit meinen PV-Überschuss maximal effizient – ganz ohne manuelle Eingriffe.

Weiterführende Links

Damit schließt sich der Kreis: Mein PV-Projekt läuft jetzt komplett automatisiert – der Laptop reagiert auf Sonnenstand, Stromverfügbarkeit und Akkuzustand ganz von selbst. Ich nenne das: Energie-Autonomie auf Code-Basis.

Update: Warum Smart Plugs für automatisches Mining nicht funktionieren – und wie ich das softwareseitig gelöst habe (November 2025)

In meinem ursprünglichen Beitrag habe ich erklärt, wie ich meinen PV-Strom sinnvoll nutze, indem ich ihn statt ins Netz einzuspeisen für CPU-Mining verwende. Anfangs habe ich das Ganze mit einer einfachen Hardwarelösung umgesetzt: ein Smart Plug, der morgens mit Sonnenaufgang alle Geräte einschaltet und abends beim Sonnenuntergang wieder ausschaltet.

Das klang zunächst clever – war es aber in der Praxis nicht.

💡 Warum Smart Plugs hier scheitern

Smart Plugs sind super, wenn man eine Lampe oder Kaffeemaschine zeitgesteuert schalten will. Bei Servern oder Mining-Systemen mit Ubuntu, Proxmox oder Raspberry Pi gibt es aber ein Problem: Sie verhalten sich beim Stromausfall nicht wie klassische Haushaltsgeräte.

Kein automatischer Boot: Viele Mini-PCs oder Laptops starten nach dem Wiedereinschalten nicht von selbst, selbst wenn im BIOS „Power on after power loss“ aktiviert ist.
Dienste bleiben hängen: Selbst wenn das Gerät startet, kommen Dienste wie xmrig oder Netzwerkverbindungen (SSH, WLAN) oft nicht automatisch hoch.
Unsaubere Abschaltung: Das harte Kappen des Stroms kann zu Datenverlust führen – insbesondere, wenn gerade Prozesse laufen oder Logs geschrieben werden.
Instabiler Netzwerkstart: Nach einem „Power Cut“ dauert es oft, bis DHCP oder WLAN-Verbindungen wieder stabil stehen. Das führt dazu, dass man zwar Strom spart, aber nicht mehr auf die Geräte kommt.

Das Ergebnis: Ich hatte regelmäßig Server, die zwar Strom bekamen, aber nicht automatisch wieder booteten oder erreichbar waren. Keine gute Lösung für ein System, das eigentlich selbständig arbeiten soll.

🚀 Warum eine softwareseitige Lösung die bessere Wahl ist

Also habe ich das Ganze von Grund auf neu gedacht – weg von der Hardware, hin zu einer intelligenten Softwaresteuerung direkt im Betriebssystem.

Statt Strom zu trennen, bleiben alle Geräte dauerhaft eingeschaltet. Der Energieverbrauch wird aber über Software geregelt:

Dienste starten und stoppen sich automatisch nach Sonnenauf- und -untergang.
CPU-Leistung wird dynamisch reduziert (z. B. nachts auf 25 %), statt das Gerät komplett auszuschalten.
WLAN und SSH bleiben jederzeit erreichbar, sodass ich auch nachts noch auf die Systeme zugreifen kann.
Keine Boot-Probleme, keine Datenverluste – die Geräte bleiben stabil im Betrieb.

Die Steuerung übernimmt ein kleines Python-Skript, das anhand von Sonnenaufgang und Sonnenuntergang den passenden Modus wählt. Ein systemd-Timer sorgt dafür, dass das Skript alle 10 Minuten ausgeführt wird.

🧩 Die Lösung: Solar-Control für Ubuntu

Das folgende Skript richtet alles automatisch ein – inklusive Python-Umgebung, Konfiguration, Systemdienst und Timer. Es erkennt sogar, ob du per SSH verbunden bist, und vermeidet Neustarts oder Netzwerkabbrüche während der Installation.

💻 Das vollständige Installationsskript


#!/usr/bin/env bash
set -euo pipefail

# Solar-Control Installer – sichere Version mit SSH-Erkennung

DEFAULT_LAT="48.95"
DEFAULT_LON="8.84"
DEFAULT_TZ="Europe/Berlin"
DEFAULT_CITY="Mühlacker"
DEFAULT_START_OFFSET_MIN="+30"
DEFAULT_STOP_OFFSET_MIN="-30"
DEFAULT_SERVICES="xmrig.service xmrig-autocontrol.timer"

require_root() { [[ $EUID -ne 0 ]] && { echo "Bitte mit sudo ausführen."; exit 1; }; }

apt_install() {
  apt-get update -y
  apt-get install -y python3 python3-venv python3-pip
}

setup_venv() {
  if [[ ! -d /usr/local/solar-control-venv ]]; then
    python3 -m venv /usr/local/solar-control-venv
    /usr/local/solar-control-venv/bin/pip install --upgrade pip
    /usr/local/solar-control-venv/bin/pip install astral==2.2 pytz
  fi
}

write_config() {
  mkdir -p /etc/solar-control
  cat > /etc/solar-control/config.env <<EOF
LAT="${DEFAULT_LAT}"
LON="${DEFAULT_LON}"
TIMEZONE="${DEFAULT_TZ}"
CITY="${DEFAULT_CITY}"
START_OFFSET_MIN="${DEFAULT_START_OFFSET_MIN}"
STOP_OFFSET_MIN="${DEFAULT_STOP_OFFSET_MIN}"
SERVICES="${DEFAULT_SERVICES}"
MODE="auto"
EOF
}

write_python() {
  cat > /usr/local/bin/solar_control.py <<'PYEOF'
#!/usr/local/solar-control-venv/bin/python3
import os, subprocess
from datetime import datetime, timedelta
from astral import LocationInfo
from astral.sun import sun
import pytz, sys

cfg="/etc/solar-control/config.env"
env={}
for line in open(cfg):
    if "=" in line and not line.startswith("#"):
        k,v=line.strip().split("=",1)
        env[k]=v.strip('"')

CITY=env.get("CITY","Mühlacker")
LAT=float(env.get("LAT",48.95))
LON=float(env.get("LON",8.84))
TZ=env.get("TIMEZONE","Europe/Berlin")
OFFSET_START=int(env.get("START_OFFSET_MIN","+30").replace("+",""))
OFFSET_STOP=int(env.get("STOP_OFFSET_MIN","-30"))
SERVICES=env.get("SERVICES","xmrig.service xmrig-autocontrol.timer").split()
MODE=env.get("MODE","auto")

def run(cmd): subprocess.run(cmd,shell=True,check=False)
def log(msg): run(f"logger -t solar-control '{msg}'")

tz=pytz.timezone(TZ)
now=datetime.now(tz)
loc=LocationInfo(CITY,"Germany",TZ,LAT,LON)
s=sun(loc.observer,date=now.date(),tzinfo=tz)
sunrise=s["sunrise"]+timedelta(minutes=OFFSET_START)
sunset=s["sunset"]+timedelta(minutes=OFFSET_STOP)

def start(): [run(f"systemctl start {s}") for s in SERVICES]
def stop(): [run(f"systemctl stop {s}") for s in SERVICES]

def performance():
subprocess.run("which powerprofilesctl && powerprofilesctl set performance", shell=True)
subprocess.run(
"for f in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do "
"[ -f \"$f\" ] && echo performance | tee \"$f\" >/dev/null || true; done", shell=True
)

def powersave():
subprocess.run("which powerprofilesctl && powerprofilesctl set power-saver", shell=True)
subprocess.run(
"for f in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do "
"[ -f \"$f\" ] && echo powersave | tee \"$f\" >/dev/null || true; done", shell=True
)


if MODE=="force_on":
    start(); performance(); log("MODE=force_on → Miner aktiv"); sys.exit()
if MODE=="force_off":
    stop(); powersave(); log("MODE=force_off → Miner aus"); sys.exit()

if sunrise<=now<=sunset:
    start(); performance(); log(f"Tagmodus aktiv {sunrise:%H:%M}-{sunset:%H:%M}")
else:
    stop(); powersave(); log(f"Nachtmodus aktiv {sunrise:%H:%M}-{sunset:%H:%M}")
PYEOF
  chmod +x /usr/local/bin/solar_control.py
}

write_units() {
  cat > /etc/systemd/system/solar-control.service <<'EOF'
[Unit]
Description=Solar-Control – Mining nach Sonnenstand
After=network-online.target
[Service]
Type=oneshot
ExecStart=/usr/local/bin/solar_control.py
[Install]
WantedBy=multi-user.target
EOF

  cat > /etc/systemd/system/solar-control.timer <<'EOF'
[Unit]
Description=Timer für Solar-Control
[Timer]
OnBootSec=2min
OnUnitActiveSec=10min
Persistent=true
[Install]
WantedBy=timers.target
EOF
}

require_root
apt_install
setup_venv
write_config
write_python
write_units
systemctl daemon-reload
systemctl enable solar-control.timer
echo "Installation abgeschlossen. Timer mit 'systemctl start solar-control.timer' starten."

💡 Warum das jetzt zuverlässig läuft

Das neue Setup arbeitet vollständig softwaregesteuert. Kein harter Stromschnitt, keine Boot-Abhängigkeiten, keine instabilen Netzwerkstarts. Dienste wie xmrig und xmrig-autocontrol werden sauber per systemctl gestartet und gestoppt, und das System bleibt dabei immer ansprechbar – WLAN, SSH, Logging, alles bleibt intakt.

So nutze ich meine PV-Energie effektiv, ohne Risiko für meine Hardware, und mit maximaler Kontrolle – alles automatisch gesteuert durch Sonne und Software.

👉 Hier geht’s zur Live-Ansicht meines Wechselrichters und Mining-Status