Entwicklungshilfe / Tipps / Verbesserungsvorschläge

myraspberrystd · December 30, 2018 at 2:53 PM

Hallo liebe Community,

ich habe für unseren Verein nach einer Möglichkeit gesucht den Strom nur Vereinsmitgliedern zugänglich zu machen. Mir kam spontan der Raspberry als mögliches "Herz" in Sinn. Persönlich habe ich den Raspberry bisher nur als Medienserver eingesetzt.

Nach etwas googlen habe ich angefangen mir über die Pflichten des Systems Gedanken zu machen und verschiedene "Module" Display, Relais und ein RFID-Leser (125kHz) heraussuchen.

Pflichten:

vier unabhängige Steckdosen
automatische Abschaltung nach x Minuten
Aktivierung einer der Steckdosen per RFID-Karte
Anzeige der aktiven Steckdose inkl. Abschaltzeit
Erfassung der Zugriffe

Anschließen habe ich ein Script zusammen gebastett.

Hier würde ich um eure Hilfe bitte. Ich habt bestimmt mehr Erfahrung als ich und könnt mir Verbesserungsvorschläge geben. Zumindest hoffe ich das. Mein Script hat in den ersten Tests funktioniert. Solltest Ihr wider erwartet keine Verbesserungen für mich haben, kann ja vielleicht jemand anders das Script für seine Bedürfnisse anpassen. Und auch nutzen.

Ich DANKE euch für eure Unterstützung.

Guten Rutsch

Python

#!/usr/bin/env python
# -*- coding: utf8 -*-
import pdb
import RPi.GPIO as GPIO
import signal
import /home/pi/125/lcddriver
import sys
from time import *
import datetime
import csv
import serial
import string
from operator import xor
import os

# UART oeffnen
UART = serial.Serial("/dev/ttyAMA0", 9600, timeout=1)
lcd = lcddriver.lcd()
lcd.lcd_clear()
lcd.lcd_backlight("on")
lcd.lcd_display_string("myrfid.py geladen",1)
lcd.lcd_display_string("COM-Port geoeffnet",2)
aktuhrzeit = datetime.datetime(int(strftime("%Y")),int(strftime("%m")),int(strftime("%d")),int(strftime("%H")),int(strftime("%M")),000) #timer1start
lcd.lcd_display_string(str(aktuhrzeit),3)

continue_reading = True
#    0      1           2              3            4              5
# timer1, timer1user, timer1start, timer1ende, displaymeldung, uid der Karte
timerarray = [["false", " ",0,0," ",""],["false", " ",0,0," ",""],["false", " ",0,0," ",""],["false", " ",0,0," ",""]]
endezeit = [" "," "," "," "]
dtobj = [" "," "," "," "]
tdelta = [" "," "," "," "]
namederkarte = ""

# Flags
Startflag = "\x02"
Endflag = "\x03"

# Port aktivieren
GPIO.setmode(GPIO.BCM)

outputtimer = [17,18,27,22] #Timer 1 , 2 , 3 , 4
#Port 18 an Pin 12 #outtimer1 = 17 
#Port 17 an Pin 11 #outtimer2 = 18
#Port 22 an Pin 15 #outtimer3 = 22
#Port 27 an Pin 13 #outtimer4 = 27

GPIO.setup(outputtimer[0], GPIO.OUT)
GPIO.output(outputtimer[0], GPIO.HIGH)
GPIO.setup(outputtimer[1], GPIO.OUT)
GPIO.output(outputtimer[1], GPIO.HIGH)
GPIO.setup(outputtimer[2], GPIO.OUT)
GPIO.output(outputtimer[2], GPIO.HIGH)
GPIO.setup(outputtimer[3], GPIO.OUT)
GPIO.output(outputtimer[3], GPIO.HIGH)

lcd.lcd_display_string("Ausgaenge gesetzt",4)
sleep(3)

#Abschaltzeit in Minuten
Abschaltzeit = 60

lcd.lcd_clear()
lcd.lcd_display_string("Abschaltzeit auf",1)
lcd.lcd_display_string(str(Abschaltzeit) +" Minuten gesetzt",2)
sleep(1)
lcd.lcd_clear()

#------------ Logdatei erstellen -----------------
# path and name of the log file
logfile = '/home/pi/125/Zugriffe.log'
timerfile = '/home/pi/125/Timerlog.log'
# function to save log messages to specified log file
def log(msg, pfad):
     # open the specified log file
     if (pfad == 1):
         file = open(logfile,"a")
     elif (pfad == 0):
         file = open(timerfile,"a")
     # write log message with timestamp to log file
     file.write("%s: %s\n" % (strftime("%d.%m.%Y %H:%M:%S"),";" + str(msg) + "\n\r"))
     # close log file
     file.close

# -------------------  ID und Namen aus Array lesen -------------
def kartendateneinlesen:
  try:
     portfolio = csv.reader(open("/home/pi/125/KartenIDs.csv", "r"),delimiter=';')
     portfolio_list = []
     portfolio_list.extend(portfolio)
     arrayname = []
     for data in portfolio_list:
        arrayname.append(data)

     lcd = lcddriver.lcd()
     lcd.lcd_clear()
     lcd.lcd_display_string("Karten-IDs gelesen",1)
     lcd.lcd_display_string(str(portfolio_list) +" Karten eingelesen",2)
     sleep(1)
     lcd.lcd_clear()
except:
     end_read
#--------------------------- ENDE --------------

#------------- Timer schalten ---------------------
def timerschalten(timernummer):
     timerarray[0][4] = ""
     timerarray[timernummer][0] = "true"
     timerarray[timernummer][3] = 0
     timerarray[timernummer][2] = 0
     print "In timer "+ str(timernummer) +" : "+ namederkarte
     timerarray[timernummer][1] = namederkarte
     timerarray[timernummer][5] = ID
     GPIO.output(outputtimer[timernummer], GPIO.LOW) # rot an
     timerlog = namederkarte + ";" + ID + ";" + "Timer " + str(timernummer) + "; eingeschaltet"
     log(timerlog ,0)
     lcd = lcddriver.lcd()
     lcd.lcd_clear()
     lcd.lcd_display_string(namederkarte,1)
     lcd.lcd_display_string("3sek...",2)
     sleep(1)
     lcd.lcd_display_string("2sek...",2)
     sleep(1)
     lcd.lcd_display_string("1sek...",2)
     sleep(1)
     lcd.lcd_clear()
# ------------ ENDE Timerschalten

# Capture SIGINT for cleanup when the script is aborted
def end_read(signal,frame):
     global continue_reading
     print "Ctrl+C captured, ending read."
     continue_reading = False
     UART.close()
     lcd = lcddriver.lcd()
     lcd.lcd_clear()
     lcd.lcd_display_string("Programm wird jetzt", 1)
     lcd.lcd_display_string("beendet", 2)
     lcd.lcd_display_string("3sek.", 3)
     sleep(1)
     lcd.lcd_display_string("2sek.", 3)
     sleep(1)
     lcd.lcd_display_string("1sek.", 3)
     sleep(1)
     lcd.lcd_clear()
     lcd.lcd_display_string("Programm beendet", 1)
     sleep(1)
     lcd.lcd_clear()
     lcd.lcd_backlight("off")
     GPIO.cleanup()

kartendateneinlesen

# Hook the SIGINT
signal.signal(signal.SIGINT, end_read)

# Welcome message
print "Willkommen RFID 125kHz ' Kartenleser"
print "Druecke Strg+C zum Abbrechen."


lcd = lcddriver.lcd() #leert das Dispaly beim Programmstart
lcd.lcd_clear()
lcd.lcd_display_string("Warte auf Karte...", 1)

try:
     while continue_reading:
          # Aktuelle Zeit um Timer abzuschalten
          aktuhrzeit = datetime.datetime(int(strftime("%Y")),int(strftime("%m")),int(strftime("%d")),int(strftime("%H")),int(strftime("%M")),int(strftime("%S")),000) #timer1start

          for z in range(0, 4):
              #print str(z) + " "+ timerarray[z][0]
              if (timerarray[z][0] == "true"): #timer == true
                  #print "startzeit: " +  str(z) + " " + str(timerarray[z][2])
                  if (timerarray[z][2] == 0): #timerstart == 0
                      #Die aktuelle Uhrzeit ermittel und die Timer-Abschaltzeit ausrechnen  %d.%m.
                      timerarray[z][2] = datetime.datetime(int(strftime("%Y")),int(strftime("%m")),int(strftime("%d")),int(strftime("%H")),int(strftime("%M")),int(strftime("%S")),000) #timer1start
                      print "Timer-Startzeit"+ str(timerarray[z][2]) #gibt die Startzeit aus #timer1start
                      #dtobj[z] = datetime.datetime.combine(datetime.datetime.today(), timerarray[z][2]) #formatiert die Uhrzeit ins Datumsformat #timer1start
                      print dtobj[z] #gibt das Datumformat aus

                      tdelta[z] = datetime.timedelta(hours=0, minutes=Abschaltzeit, seconds=0)
                      print tdelta[z] #gibt die eingestellt Zeit aus
                      timerarray[z][3] = timerarray[z][2] + tdelta[z] #Timerende berechnen #timer1ende
                      print "Timerende: "+str(timerarray[z][3]) #gibt die neue (Endzeit) aus #timer1ende
                  #print "Tendezeit: " + str(z) + " " + str(timerarray[z][3])
                  if (aktuhrzeit >= timerarray[z][3]): #timer1ende
                      GPIO.output(outputtimer[z], GPIO.HIGH) 
                      timerlog = str(timerarray[z][1]) + ";" + str(timerarray[z][5]) + ";" + "Timer " + str(z) + "; abgeschaltet ;" + str(timerarray[z][3])
                      log(timerlog ,0)
                      timerarray[0][4] = "" #displaymeldung
                      timerarray[z][0] = "false" #timer1
                      timerarray[z][2] = 0 #timer1start
                      timerarray[z][3] = 0 #timer1ende
                      timerarray[z][1] = "" #timer1user
                      lcd = lcddriver.lcd()
                      lcd.lcd_clear()
                      lcd.lcd_display_string("Warte auf Karte...",1)
                      print "Timer Aus"
 
          if ((timerarray[0][0] == "true") or (timerarray[1][0] == "true") or (timerarray[2][0] == "true") or (timerarray[3][0] == "true")):
                  if (timerarray[0][4] == ""):
                      lcd = lcddriver.lcd()
                      lcd.lcd_clear()
                      print "user1: " + timerarray[0][1] + "user2: " + timerarray[1][1] + "user3: " + timerarray[2][1] + "user4: " + timerarray[3][1]
                      print "timer1ende: "+str(timerarray[0][3])+"timer2ende: "+str(timerarray[1][3])+"timer3ende: "+str(timerarray[2][3])+"timer4ende: "+str(timerarray[3][3])

                      for u in range(0, 4):
                          if (timerarray[u][3] == 0):
                              endezeit[u] = " Aus "
                          else:
                              endezeit[u] = timerarray[u][3].strftime('%H:%M:%S')
                              print "endezeit1: " +str(endezeit[u])

                      lcd.lcd_display_string("S1: "+ str(timerarray[0][1])[:10] + " "+ str(endezeit[0])[:5],1)
                      lcd.lcd_display_string("S2: "+ str(timerarray[1][1])[:10] + " "+ str(endezeit[1])[:5],2)
                      lcd.lcd_display_string("S3: "+ str(timerarray[2][1])[:10] + " "+ str(endezeit[2])[:5],3)
                      lcd.lcd_display_string("S4: "+ str(timerarray[3][1])[:10] + " "+ str(endezeit[3])[:5],4)
                      print "S1: "+str(timerarray[0][1])[:10] + " " + str(endezeit[0])[:8] 
                      print "S2: "+str(timerarray[1][1])[:10] + " " + str(endezeit[1])[:8] 
                      print "S3: "+str(timerarray[2][1])[:10] + " " + str(endezeit[2])[:8] 
                      print "S4: "+str(timerarray[3][1])[:10] + " " + str(endezeit[3])[:8] 
                      print "Displaymeldung gesetzt" 
                      timerarray[0][4] = "Timer True"
#-------------------------------------------------------------------
          # Variablen loeschen
          Checksumme = 0
          ID = ""
          chkrech = ""
          chklesen = " "
          Zeichen = ""

          # Zeichen einlesen
          Zeichen = UART.read() 
          # Uebertragungsstart signalisiert worden?
          if (Zeichen == Startflag):

             # ID zusammen setzen 
             for Counter in range(13):
                 Zeichen = UART.read() 
                 ID = ID + str(Zeichen)

             # Endflag aus dem String loeschen
             ID = ID.replace(Endflag, "" );

             # Checksumme berechnen
             for I in range(0, 9, 2):
                 Checksumme = Checksumme ^ (((int(ID[I], 16)) << 4) + int(ID[I+1], 16))
             Checksummehex = hex(Checksumme)

             # Tag herausfiltern
             Tag = ((int(ID[1], 16)) << 8) + ((int(ID[2], 16)) << 4) + ((int(ID[3], 16)) << 0)
             Tag = hex(Tag)

             # Ausgabe der Daten
             print "------------------------------------------"
             print "Datensatz: ", ID
             print "Tag: ", Tag
             print "ID: ", ID[4:10]
             print "Checksumme: ", Checksummehex
             print "Checksumme Dez: ", Checksumme
             print "Checksumme aus ID (Datezsatz): ", ID[10:12]
             print "Checksumme aus ID (Datezsatz): ", Checksummehex[2:4]

             chkrech = string.upper(Checksummehex[2:4])
             chklesen = string.upper(ID[10:12])

             if ((chkrech == chklesen) and str(ID) != "000000000000"):
                 print "Checksumme ist gleich"
                 print "------------------------------------------"
# ----------------------------------------------------------------------

                 #Raspberry per Karte neustarten
                 if (str(ID) == "32001D763B62"):
                    lcd.lcd_clear()
                    lcd.lcd_display_string("Starte jetzt neu...",1)
                    sleep(1)
                    lcd.lcd_clear()
                    os.system('sudo shutdown -r now')
                 #Kartendaten per Karte neu einlesen
                 if (str(ID) == "32001D763B6"):
                    lcd.lcd_clear()
                    lcd.lcd_display_string("Kartendaten werden",1)
                    lcd.lcd_display_string("neu gelesen",2)
                    sleep(1)
                    kartendateneinlesen

                 #Programm (myrfid) per Karte beenden
                 if (str(ID) == "32001D763B6"):
                    end_read

                 #Variable uid richtig
                 booluid = "false"
                 boolgesperrt = "false"
                 namederkarte = "kein Mitglied"
                 #Pruefen ob die uid der Karte vorhanden bzw registriert ist
                 for arrayuidindex in range(len(arrayname)):
                     if (ID == str(arrayname[arrayuidindex][0])):
                         booluid = "true"
                         namederkarte = arrayname[arrayuidindex][1]
                         boolgesperrt = arrayname[arrayuidindex][2]
                 #Gibt die Pruefung aus
                 print "Karten ID = "+booluid
                 print "Mitglied: "+namederkarte
                 print "Mitglied gesperrt: "+ boolgesperrt

                 #Protokoliert Zugriff in Logdatei

                 vlog = namederkarte + ";" + ID + ";"  + boolgesperrt
                 log(vlog, 1)

                 if (boolgesperrt == "false"):
                     #Prueft ob Karte aus Verein
                     if booluid == "true":
                         #hier den Code wenn Karte aus Verein und Name vorhanden
                         print "timer (namederkarte)" + namederkarte
                         #prüfen ob "die" Karte schon einen timer "hat"
                         if (namederkarte == timerarray[0][1]):
                             timerschalten(0)
                         elif (namederkarte == timerarray[1][1]): #timer2user
                             timerschalten(1)
                         elif (namederkarte == timerarray[2][1]):
                             timerschalten(2)
                         elif (namederkarte == timerarray[3][1]):
                             timerschalten(3)
                         else:#Karte hat keinen timer, Prüfen welche als nächstes frei ist
                             if (timerarray[0][0] == "false"):
                                 timerschalten(0)
                             elif (timerarray[1][0] == "false"):
                                 timerschalten(1)
                             elif (timerarray[2][0] == "false"):
                                 timerschalten(2)
                             elif (timerarray[3][0] == "false"):
                                 timerschalten(3)
                             else:#else wenn alle steckdosen belegt
                                 lcd = lcddriver.lcd()
                                 lcd.lcd_clear()
                                 lcd.lcd_display_string("Alle Steckdosen", 1)
                                 lcd.lcd_display_string("belegt!",2)
                                 lcd.lcd_display_string(namederkarte,3)
                                 lcd.lcd_display_string("3sek...",4)
                                 sleep(1)
                                 lcd.lcd_display_string("2sek...",4)
                                 sleep(1)
                                 lcd.lcd_display_string("1sek...",4)
                                 sleep(1)
                                 lcd.lcd_clear()
                                 if ((timerarray[0][0] == "false") and (timerarray[1][0] == "false") and (timerarray[2][0] == "false") and (timerarray[3][0] == "false")):
                                     lcd.lcd_display_string("Warte auf Karte...",1)
                                 timerarray[0][4] = ""     
                     else:#else wenn die UID der Karte nicht stimmt
                         lcd = lcddriver.lcd()
                         lcd.lcd_clear()
                         lcd.lcd_display_string("Die Karte kommt", 1)
                         lcd.lcd_display_string("nicht aus dem Verein",2)
                         lcd.lcd_display_string(namederkarte,3)
                         lcd.lcd_display_string("3sek...",4)
                         sleep(1)
                         lcd.lcd_display_string("2sek...",4)
                         sleep(1)
                         lcd.lcd_display_string("1sek...",4)
                         sleep(1)
                         lcd.lcd_clear()
                         if ((timerarray[0][0] == "false") and (timerarray[1][0] == "false") and (timerarray[2][0] == "false") and (timerarray[3][0] == "false")):
                             lcd.lcd_display_string("Warte auf Karte...",1)
                         timerarray[0][4] = ""
                 else:
                     #Das Mitglied ist gesperrt
                     lcd = lcddriver.lcd()
                     lcd.lcd_clear()
                     lcd.lcd_display_string(namederkarte, 1)
                     lcd.lcd_display_string("Zugang gesperrt!!!", 2)
                     lcd.lcd_display_string("Rechnung bezahlen!", 3)
                     lcd.lcd_display_string("3sek...",4)
                     sleep(1)
                     lcd.lcd_display_string("2sek...",4)
                     sleep(1)
                     lcd.lcd_display_string("1sek...",4)
                     sleep(1)
                     lcd.lcd_clear()
                     if ((timerarray[0][0] == "false") and (timerarray[1][0] == "false") and (timerarray[2][0] == "false") and (timerarray[3][0] == "false")):
                         lcd.lcd_display_string("Warte auf Karte...",1)
                     timerarray[0][4] = ""

          #als letztes den speicher loeschen und zur sicherheit noch 0.5 sek. warten
          UART.flushInput() 
          sleep(0.2)
except:
     end_read

Display More

Bot · Vor 5 Minuten

Entwicklungshilfe / Tipps / Verbesserungsvorschläge? Schau mal ob du hier fündig wirst!

noisefloor · December 30, 2018 at 5:52 PM

Hallo,

ziemlich viel Code... Ein paar grundlegende Sachen:

Kein Python 2.7 verwenden, sondern Python 3.x. Grund: Python 2.7 ist 2020 EOL
Eingerückt wird bei Python mit vier Leerzeichen. Nicht mit Tabs, nicht mit 5 Leerzeichen oder was auch immer
PEP8 bei der Namensgebung (z.B. Variablennamen) beachten und _aussagekräftige_ Namen nutzen. So was wie "arrayname" als Name für eine Liste (ein Array ist übrigens was anderes in Python...) ist relativ sinnfrei.
Python kennt Bool'sche Werte - die solltest du verwenden und nicht Strings wie "false".
Strings baut man mit der `format` Methode zusammen, nicht mit `+`.
Warum belegst du die Listen so komisch vor, also mir " " (also einem Leerzeichen). Wenn da kein Wert drin stehen soll, dann nimmt man üblicherweise `None`.
Nie nackte `try... except` verwenden, weil damit alles abgefangen wird, auch Programmierfehler. Fehler sollen gezielt abgefangen werden.
Dateien besser mit dem `with` Statement öffnen. Dann hast du die Garantie, dass sie auch geschlossen werden.
Statt Logging selber zu implementieren solltest du das logging-Modul nutzen. a) kann das mehr und b) ist das sicherlich auch robuster und besser getestet als dein Code.
Ab Zeile 166 ist das ganz übler Spaghetti-Code (neigt man als Anfänger zu - kein Vorwurf), der schlecht lesbar und quasi nicht wartbar. Unterteile deinen Code in sinnvolle, kleine Häppchen und packe jede Funktionalität in eine eigene Funktion.

Quote

Mein Script hat in den ersten Tests funktioniert.

Es hat aber definitiv Fehler. An ein paar Stellen referenzierst du z.B. die `end_read` Funktion, führst sie aber nicht aus.

NACHTRAG: wie ist eigentlich dein Plan, wenn der Raspi mal crasht und nicht neu startet? Hat dann niemand mehr Strom?

Gruß, noisefloor

myraspberrystd · December 31, 2018 at 3:32 PM

Hallo noisefloor,

danke für deine Tipps. Einiges habe ich schon versucht umzusetzen.

Allerdings weiß ich nicht ob ich auf Python 3 so einfach wechseln kann. Ich nutzte ja auch Scripts von dem Modulherstellern, da muss ich wohl nochmal etwas lesen, lesen und probieren.

Kannst du mir das mit dem "with" beim Datei öffnen nochmal erklären oder mir einen Link geben? Das benötige ich dann ja "nur" doch beim CSV-Import. Die Log-Dateien erstelle ich jetzt mit dem Logging-Modul.

Zu deinem Nachtrag. Mal schauen wie weit man den Raspberry für solche Fälle optimieren kann. Ansonsten gibt es dann keinen Strom mehr. So würde man zumindest von Fehlern erfahren.

Gruß

Bot · Vor einem Moment

noisefloor · December 31, 2018 at 4:52 PM

Hallo,

zu P3: das einzige externe Modul, dass es nur für P2 geben könnte, ist den LCD-Driver. Wo immer der auch her kommt. Alle anderen Module gibt es für P3. Wenn es fü das LCD kein P3 Modul gibt und kein in Aussicht ist, ist halt die Frage, wie viel das Modul überhaupt taugt...

Zum `with` Statement: Falls du das offizielle Python-Tutorial auf docs.python.org noch nicht durchgearbeitet hast, wäre jetzt eine gute Gelegenheit, das nachzuholen. Das `wtih` Statement ist im Kapitel 7 erklärt.

Gruß, noisefloor

Manul · December 31, 2018 at 6:51 PM

Quote from noisefloor

Das `wtih` Statement

Wir das nicht eher im Pyhton-Tutorial erklärt? (TWSAI)

Participate now!