Quelltext /~heha/ewa/Logger/Batterieanzeige.zip/X728BatteryStatus

#!/usr/bin/env python3
# Zeigt X728-Batterie-Ladezustand im System-Tray des Desktops an.
# Nur für diese USV-Platine (von geekworm.com) gemacht und geeignet!
#
# Da dieses Programm permanent laufen sollte,
# bietet sich ein Autostart an.
#
# Bei mir (2023, LXDE) ist das wie folgt einzutragen:
# sudo nano /etc/xdg/lxsession/LXDE-pi/autostart
# Neue Zeile (anfügen):
# @[pfad/]X728BatteryStatus.py -a

import smbus   # I²C = Batteriemonitor
from RPi import GPIO # Netz/Batteriebetrieb, Piezo
from struct import unpack
from time import sleep
from os import system
from sys import argv
import PyQt5
from PyQt5.QtGui import (
 QIcon,QPixmap,QColor,QPainter,QPainterPath,QPen,QPolygonF
)
from PyQt5.QtWidgets import (
 QApplication,QSystemTrayIcon,
 QMenu,QAction,QDialog,QMessageBox,
 QLabel,QSpinBox,QPushButton,QGridLayout,
)
from PyQt5.QtCore import (
 Qt,QTimer,
 QSettings,QLocale,QDateTime,QPointF,QRectF,
)

locale = QLocale("de")   # für Dezimalkommas

# Ein Wrapper für den künftig ohne GUI laufenden Systemdienst
# Die Kommunikation wird wohl künftig über mqtt laufen …
class SystemService():
 def __init__(self):
  self.bus = smbus.SMBus(1)     # X728 Batteriemonitor an I²C-Adresse 0x26
  self.voltage = 0  # Spannung in V
  self.current = 0  # Ladestrom in A (hier: fiktiv)
  self.percent = 0  # Füllstand in %, NaN bei Fehler
# h#s = haftmann#software (für Windows: HKCU/Software/h#s/X728BatteryStatus)
  self.settings= QSettings("h#s","X728BatteryStatus")
  self.buzzlev = int(self.settings.value("buzzlev",10)) # Prozent, darunter piepsen
  self.downlev = int(self.settings.value("downlev",2)) # Prozent, darunter PowerDown
  self.lastoff = int(self.settings.value("lastoff",0)) # Millisekunden seit 1970-01-01T00:00:00.000UTC
  GPIO.setmode(GPIO.BCM)   # Was für ein hanebüchener Unsinn: Was denn sonst??
  GPIO.setwarnings(False)  # (was RPi.GPIO so will)
  GPIO.setup(6,GPIO.IN)    # X728 H = Batteriebetrieb L = Netzbetrieb
  GPIO.setup(20,GPIO.OUT)  # X728 H = Piezokapsel ein

 def queryData(self):
  try:
   block = self.bus.read_i2c_block_data(0x36,2,4);
  except:
#   print("I²C-Lesefehler")
   self.percent = float("nan")
   self.current = 0 # Spannung unverändert belassen
   return
  v,p = unpack(">HH",bytes(block));
  self.voltage = v/12800  # scheint so zu stimmen
  self.percent = p/256
  self.current = 0 if GPIO.input(6) else 2.0 # Annahme: 2 A Ladestrom

 def cyclic(self):
  self.queryData()
  if self.current<=0 and self.percent>=0:
   if self.percent<=self.buzzlev: self.buzz()
   if self.percent<=self.downlev: self.goDown()
  if self.current>0: self.buzz(0) # ausschalten beim Laden

 def setbuzzlev(self,val:int):
  if val<0 or val>50: return False
  self.buzzlev = val;
  self.settings.setValue("buzzlev",val)
  return True

 def setdownlev(self,val:int):
  if val<0 or val>=self.buzzlev: return False
  self.downlev = val
  self.settings.setValue("downlev",val)
  return True

 def buzz(self,sta=2):     # sta=0: aus, sta=1: ein, sta=2: toggle
  if sta!=0 and sta!=1: sta=not(GPIO.input(20))
  GPIO.output(20,sta)

 def goDown(self):
# Aktion vermerken
  self.lastoff = QDateTime.currentMSecsSinceEpoch()
  self.settings.setValue("lastoff",self.lastoff)
  self.settings.sync()
# TODO: Fenstern ein WM_ENDSESSION schicken, wenn ich's herausfinde.
# Gesittete Programme speichern daraufhin ihre Daten,
# bspw. der Browser seine geöffneten Tabs oder der Texteditor ein Backup.
# root scheint nicht erforderlich zu sein! Geht auch so!
  system("systemctl poweroff") # als root

 def clearLastoff(self):
  self.lastoff = 0
  self.settings.remove("lastoff")

svc = SystemService()

class ConfigDialog(QDialog):
 def __init__(self):
  super().__init__()
  self.setWindowTitle("X728-Batteriestatus")
  g = QGridLayout()

  def GridRow(row,label,maxvalid,value,onchange,testlabel,ontest):
   l = QLabel(label)
   e = QSpinBox(self) # Windows: Editfenster mit UpDownControl
   e.setRange(0,maxvalid)
   e.setValue(value)
   e.setSuffix(" %")
   e.setPrefix("≤ ")
   l.setBuddy(e) # bewirkt dass '&' wie unter Windows funktioniert
   g.addWidget(l,row,0,Qt.AlignmentFlag.AlignRight)
   e.setAlignment(Qt.AlignmentFlag.AlignRight)
   e.valueChanged.connect(onchange)
   g.addWidget(e,row,1)
   b = QPushButton(testlabel)
   b.clicked.connect(ontest)
   g.addWidget(b,row,2)

  def reallyDown(): # Sicherheitsabfrage
   if QMessageBox.warning(self,
     "X728-Batteriestatus",
     "Wirklich sofort herunterfahren und ausschalten?",
     QMessageBox.Yes|QMessageBox.Cancel,
     QMessageBox.Cancel)==QMessageBox.Yes: svc.goDown()

  def gelesen(): # Mehrere Aktionen lassen sich nicht in ein Lambda packen
   svc.clearLastoff()
   # Dritte Grid-Zeile löschen beim Klick auf "Gelesen"
   g.itemAtPosition(2,0).widget().hide()
   g.itemAtPosition(2,2).widget().hide()
   # Der Dialog bleibt so groß (hoch) wie er ist.
   # Nach "stackoverflow.com" artet das anschließende Verkleinern
   # in viel Arbeit aus und das Weglassen ist hier verzeihlich.

  GridRow(0,"&Piep wenn",
    30,svc.buzzlev,
    lambda i:svc.setbuzzlev(i),
    "&Test",lambda:svc.buzz())
  GridRow(1,"&Ausschalten wenn",
    svc.buzzlev,svc.downlev,
    lambda i:svc.setdownlev(i),
    "T&est",reallyDown)
  # Maximum für Ausschaltpegel nachführen
  g.itemAtPosition(0,1).widget().valueChanged.connect(
    lambda i:g.itemAtPosition(1,1).widget().setMaximum(i))
  if svc.lastoff: # In einer weiteren Zeile letztes PowerDown anzeigen
   s = "Letztes Ausschalten: " # TODO: locale-spezifische Anzeige
   t = QDateTime.fromMSecsSinceEpoch(svc.lastoff)
   s += t.toString("yyyy-MM-dd hh:mm:ss")
   g.addWidget(QLabel(s),2,0,1,2) # mit "colspan"
   b = QPushButton("&Gelesen")
   b.clicked.connect(gelesen)
   g.addWidget(b,2,2)
  self.setLayout(g)

 def done(self,r):    # beim Beenden Piepser ausmachen
  svc.buzz(0)
  return super().done(r) # "done" ist eine überladene virtuelle Memberfunktion

def getIconSize():
# Das ist hochgradig plattformspezifisch!!
# Mir ist kein Königsweg für die Symbolgröße bekannt,
# und es scheint auch keinen zu geben.
# Ach wie schön ist doch GetSystemMetrics() unter Windows …
 st = QSettings("lxsession/LXDE-pi","desktop")
 st.beginGroup("GTK")  # geht in [GTK]
 ret = st.value("sGtk/IconSizes") # liefert leider List-Of-Strings
 st.endGroup()
 if type(ret) is list: ret = ','.join(ret)
 ret = ret.split('=')[1] # "gtk-large-toolbar=" weg
 return list(map(int,ret.split(',')))  # x und y getrennt (sollte gleich sein für quadratische Symbole)
# Wahrscheinlich ist es sicherer, alle Dateien unter /home/pi/.config/*/LXDE*/
# nach dem Muster /IconSize[^=]*=.*?([0-9]{2}),([0-9]{2})/ zu durchsuchen.

iconsize = getIconSize()
if len(iconsize)!=2 or iconsize[0]<16 or iconsize[1]<16:
 print("Falsche Symbolgröße:",iconsize)    # Komma generiert Leerzeichen!
 iconsize = [32,32] # Defaultwert

anistate = 0

# Das „handgemalte“ Symbol beachtet p und i sowie iconsize
def makeIcon(p:float,u:float,i:float):
 global anistate
 color = Qt.darkGray # (#808080)
 alarm = 30          # Unterhalb dieser Prozentangabe Alarmfarben
# TODO: Die 30 % könnten/sollten einstellbar sein
 if p==p: # nicht NaN
# beim Laden grün, sonst blau, unter 30% gelb-orange-rot
  hue = 1/3 if i>0 else 200/360 if p>alarm else p/alarm/6
  v = 1 if i<=0 and p<=alarm else 0.75 # 0.75 = nicht ganz stechend (dunkler)
  color = QColor.fromHsvF(hue,1,v)
# TODO: Icon-Animation bei Alarm (Welle beim „Flüssigkeitsstand“)
 bm = QPixmap(*iconsize) # beide Zahlen der Liste als Argumente
 bm.fill(Qt.transparent)
 dc = QPainter(bm)
 dc.setRenderHint(QPainter.Antialiasing)
 dc.scale(*iconsize) # auf [0..1> skalieren
 dc.scale(0.01,0.01) # X/Y fortan in handlichen Prozentangaben
 pa = QPainterPath()
 pa.addRoundedRect(25,20,50,75,6,6) # Korpus: aufrechte Rundzelle
 pa.addRect(40,5,20,15) # Pluspol
 dc.fillPath(pa,color)
 del pa
 if p>=0 and p<=100:
  bottom = int((100-p)*0.7) # Füllgrad: Mit 100-p der Leere-Grad
  if p<=alarm: bottom-=3 # Platz für „Welle“ (TODO: Schönere Animation)
  dc.fillRect(30,25,40,bottom,Qt.white)
  if p<=alarm: # Hier: Absichtlich Animation während des Ladens (stört kaum)
   tal = -10 if anistate==0 else 10 if anistate==2 else 0
   dc.fillRect(50+tal-10,25+bottom,20,6,Qt.white)
   anistate = 0 if anistate==3 else anistate+1
 if i>0: # Beim Laden
  pa = QPainterPath()
  p = QPolygonF()
  p.append(QPointF(50,30)) # Ein Blitz
  p.append(QPointF(30,65))
  p.append(QPointF(50,65))
  p.append(QPointF(50,90))
  p.append(QPointF(70,55))
  p.append(QPointF(50,55))
  p.append(QPointF(50,30)) # Pfad schließen (für Linie)
  pa.addPolygon(p)
  dc.fillPath(pa,Qt.yellow) # gelb
  dc.setPen(QPen(Qt.darkYellow,2))
  dc.drawPath(pa) # mit dunkelgelber Umrandung
  del p,pa
 del dc
 return QIcon(bm)

def changeBatteryStatus(p:float,u:float,i:float):
 tray.setIcon(makeIcon(p,u,i))
 def pui():
  s = locale.toString(p,'f',1)+" %"
  if u or i:
   s+= " ("
   if u: s+= locale.toString(u,'f',2)+" V"
   if u and i: s+= ", "
   if i: s+= locale.toString(i,'f',2)+" A"
   s+= ")"
  return s
 s = "Batteriestatus unbekannt!"
 if p==p: # nicht NaN
  s = "lade bei" if i>0 else "noch"
  s+= " "+pui()
 tray.setToolTip(s)

def onTimer():
 svc.cyclic()
 changeBatteryStatus(svc.percent,svc.voltage,svc.current)

app = QApplication(argv)
app.setObjectName("X728") # wozu auch immer, wohl für interne Logs
app.setApplicationDisplayName("Batteriestatus") # für app.aboutQt()
app.setQuitOnLastWindowClosed(False) # es gibt kein permanentes Fenster
tray = QSystemTrayIcon()
tray.setIcon(makeIcon(float("nan"),0,0)) # Graue Batterie beim Start
tray.setVisible(True)
timer = QTimer(app)
timer.timeout.connect(onTimer)
timer.start(500)

# Popup-Menü
menu = QMenu()
menu.addAction("&Konfigurieren …").triggered.connect(lambda:ConfigDialog().exec())
# Die Option -a oder --autostart unterdrückt die Möglichkeit des Beendens
if not("-a" in argv or "--autostart" in argv):
 menu.addAction("&Beenden").triggered.connect(app.quit)
if "-f" in argv or "--fullmenu" in argv:
 menu.addSeparator()
 menu.addAction("&Über Qt …").triggered.connect(lambda:app.aboutQt())
tray.setContextMenu(menu)

app.exec()
svc.buzz(0) # beim Beenden Piepser aus
Vorgefundene Kodierung: UTF-80