Beiträge von deviloper

Evtl. wäre auch https://github.com/patsys/desfire-python/ etwas. Müsste man für DoorPi ne App und darin ein File mit speziellen Inhalt auf der Karte ablegen. Wäre halt direkt in Python.

Ist dass das Event aus https://github.com/motom001/Do…oorpi/status/webserver.py Zeile 41? Das scheint er zu feuern, wenn nicht der von dir angegebene Port als Webserver genutzt wird. Unterscheiden die sich bei dir zwischen produktiv und normal?

Sehe gerade das es auch mit PJSIP (pjsua) geht. Auch wenn die Bibliothek ebenfalls eingestellt wurde ... Mit https://www.pjsip.org/python/pjsua.htm#Lib create_player und dann noch mit dem Sound Device connecten. Dann macht es ggf. auch Sinn, dass in der Basisklasse zu definieren.

Hab gerade gesehen, dass da in pjsua_lib bereits ein Player definiert ist. Also letztlich kann man's von da kopieren. (PjSIP scheint keinen eigenen Wählton zu erzeugen, DoorPi erzeugt den selbst falls dieses SIPPhone ausgewählt ist ... praktisch das was man sonst zum Abspielen einer wav machen würde).

Über linphone.Core sollte es eine Funktion

play_local() geben (https://pythonhosted.org/linphone/api_reference.html). Ist bisher aber nicht implementiert - glaube ich.

https://github.com/motom001/Do…hone/AbstractBaseClass.py da müsstest du die Funktion anlegen, dann in from_linphone ableiten und zusätzlich eine entsprechende Action anlegen.

Eine solche Anleitung war vorher auch nicht unter dem von dir genannten Link hinterlegt. Da ging es bloß um die Installation (die ich deswegen nochmal im Forum unter Installationsprozess aufgeschrieben hab, da ich die auch vermisst hab). Wenn du konkrete Fragen stellst, bekomst du aber auch Antworten. Ansonsten hilft es evtl. die Projekte anderer Nutzer anzugucken oder in den Quellcode zu schauen. Für GPIO brauchst du das Keyboard "gpio" (from_gpio.py). Das du das nutzen willst, definierst du in der doorpi.ini bzw. der Konfigurationsdatei. ... aber darauf achten, dass die Eingänge eines Pis nicht fürchterlich robust sind (ggf. zB. also einen Optocouple davor etc.)

Insgesamt sind es aber sehr variable Möglichkeiten, wie man was mit dem (Door)Pi macht, sodass eine generelle "Aufbauanleitung" wohl nicht existiert.

Zitat

kein SIP und beispielsweise nur Fritzbox mit Fritzfon, dann benötigst Du einen mjpeg_streamer

mjpegstreamer ist eine der Möglichkeiten zusätzlich einen Video-Stream zu erzeugen. Hat aber so direkt nicht viel mit dem DoorPi zu tun. Da gibt's auch noch andere, ggf. effizientere Möglichkeiten.

Zitat

willst Du beides, musst Du darauf achten, dass derm jpeg_stream vor Anrufaufbau gestoppt wird, da Linphone sonst keine Video aufbaut, da das Device schon vom Streamer belegt ist.

Stimmt. take_snapshot sollte auch nicht ohne weiteres klappen, da mjpeg streamer den video-device blockt. Habe, weil die meisten Video Stream Lösungen den blocken mal eine abgewandelte Variante von take_snapshot gepostet, die sich per OpenCV den Stream schnappt und davon ein Frame als Bild speichert. Falls es nur um ein einzelnes Bild geht.

Zitat

möchtest Du über SIP auch Video, kommst Du an einer Asterisk Installation nicht vorbei

Das kommt doch auch drauf an was er als SIP-Server nutzt? Nutz selbst keine Fritzbox, sodass ich nicht weiß ob die mit VideoCalls klar kommt aber es gibt ja auch andere Anlagen

Wenn ich dich richtig verstehe, hast du das Bild unabhängig vom DoorPi über den MJPG-Streamer zur Verfügung gestellt?

motom001: Wie sieht es denn aktuell aus. Setzt du dich in nächster Zeit nochmal dran? Momentan ist es ja nicht so einfach etwas zum neuen DoorPi beizutragen bzw. fehlt dabei evtl. auch eine etwas nähere Erleuterung was noch gemacht werden muss (damit mal die Basis steht) und wie grob die Struktur hinter dem ganzen sein soll und wo man das ganze hinpacken kann, damit es mehreren Leuten zum Test zur verfügung steht. Das System ist ja (zum Glück) bisher recht offen und dadurch auch individuell gewesen, sodass nicht jeder zwangsweise alle Hardware zum Test da hat.
Im 1. Post in dem Thread steht ja auch was von nem linphone-Einsatz. Wenn ichs richtig gelesen habe hat linphone in der libLinphone die Schnittstelle zu Python fallen lassen.

Der Stand von https://github.com/motom001/DoorPi/tree/DoorPi3?files=1 ist ja nicht der, den du hier in den Screenshots gezeigt hast.

Was spricht denn eigtl für einen kompletten Neustart? Die config auf JSON umstellen, sollte ja gehen. Die Plugins stoßen ja auch nicht wirklich an die Grenzen deiner momentanen Umsetzung. Reicht es nicht auf Python 3 umzustellen?

Software ... da gibt's doch ein paar.

du kannst dir mit https://github.com/umlaeute/v4l2loopback ein virtual video device erzeugen und das streamen.

DoorPi tätigt halt, wenn du es auslöst, einen (Video-)Anruf. Wenn du während dessen nur den Stream sehen willst, ist der weg über linphone ggf. der richtige. Willst du unabhängig deine Kamera haben, musst du es auch unabhängig streamen. Hier nehmen ja einige den mjpeg streamer. Und dann gibst du in der App auf deinem Smartphone (einer geeigneten ...) dann den SIP-Server an, wo sie sich als Telefon registriert und zusätzlich die Adresse deiner Streams, die sie dir dann anzeigt.

Zu deinem Log: SIP Videocall

Im Trace: Nach allem was mit Video zu tun hat oder als Fehler/Warnung gekennzeichnet ist.

Zum Stream: kommt drauf an was du vor hast. Bin mir auch nicht sicher in wie weit die verwendete linphone4raspberry Lib das drin hat, aber falls es drüber funktioniert sollte linphone das Videosignal eigtl selbst mitsenden.

Ansonsten kannst du auch einen rtsp Stream odg. selbst erzeugen und den unabhängig vom Linphone (z.B. falls garkeiner geklingelt hat und du entsprechend garkeinen "Anruf" hast) nutzen/anzeigen.

Okay und was wirft DoorPi aus, wenn du es im Trace-Modus startest? Du scheinst ja die Kamera noch für einen anderen Stream zu verwenden? (http://tuerpi:9000/stream_simple.html). Das geht normal nicht.

Wie streamst du denn? Müsstest beim DoorPi ja dann auch angeben, falls du es mit dem Audiostream mit senden willst.

M4ce1 meinte jetzt, dass es ggf. schöner wäre nur bei Bedarf den Sensor zu aktivieren. Wenn ich motom001 Struktur richtig verstehe, wäre das eher eine Aktion statt ein Keyboard?

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import logging
logger = logging.getLogger(__name__)
logger.debug("%s loaded", __name__)

from pyfingerprint.pyfingerprint import PyFingerprint
import time
from doorpi.action.base import SingleAction
import doorpi

def destroy_await_fingerprint():
    doorpi.DoorPi().event_handler.unregister_source(__name__, True)

def await_fingerprint(timeout):
    logger.debug("awaiting fingerprint")
    
    ## Einstellungen aus config lesen. Abschnitt [Fingerprint]
    section_name = 'Fingerprint'
    port = doorpi.DoorPi().config.get(section_name, 'port', "/dev/ttyUSB0")
    baudrate = doorpi.DoorPi().config.get_int(section_name, 'baudrate', 57600)
    sensoraddr = doorpi.DoorPi().config.get(section_name, 'address', 0xFFFFFFFF)
    password = doorpi.DoorPi().config.get(section_name, 'password', 0x00000000)
    security = doorpi.DoorPi().config.get_int(section_name, 'security', 80)
           
    ## Sensor initialisieren
    sensor = PyFingerprint(port, baudrate, sensoraddr, password)
    if (sensor.verifyPassword() == False):
        logging.warning('The given fingerprint sensor password is wrong!')
        return

    ## TRACE: Ausgabe ob und wenn ja wie viele Fingerabdrucke registriert sind.
    logging.debug('Currently used templates: ' + str(sensor.getTemplateCount()) + '/' + str(sensor.getStorageCapacity()))
    
    try:
        ## Timeout festlegen.
        endtime = time.time() + timeout

        ## Warten bis ein Finger erkannt wurde. Falls zwischendurch timeout erreicht wird - Abbruch
        while (sensor.readImage() == False):
            if (time.time() > endtime) return
            pass
     
        ## Characteristics aus dem gelesenen Fingerabdruck auslesen und hinterlegen
        sensor.convertImage(0x01)
        ## Datenbank nach diesen Characteristics durchsuchen
        result = sensor.searchTemplate()
        positionNumber = result[0]
        accuracyScore = result[1]
        ## Input-Pin entsprechend der gefundenen Position aktivieren
        logger.debug('Found template at position #' + str(positionNumber))
        logger.debug('The accuracy score is: ' + str(accuracyScore))
                
        ## Finger entweder garnicht oder nicht exakt genug erkannt.
        if (positionNumber == -1) or (accuracyScore < security):
            ## Finger unbekannt - Event auslösen
            doorpi.DoorPi().event_handler('OnFingerFoundUnknown', __name__)
        else:
            ## Finger bekannt - Event auslösen
            doorpi.DoorPi().event_handler('OnFingerFoundKnown', __name__)
    except Exception as ex:
        logger.exception(ex)


def get(parameters):
    parameter_list = parameters.split(',')
    if len(parameter_list) is not 1: return None

    ## Spezielle Handler für (Un-)bekannte Finger registrieren
    doorpi.DoorPi().event_handler.register_event('OnFingerFoundUnknown', __name__)
    doorpi.DoorPi().event_handler.register_event('OnFingerFoundKnown', __name__)
    doorpi.DoorPi().event_handler.register_action('OnShutdown', AwaitFingerprintDestroyAction(destroy_await_fingerprint))

    timeout = parameter_list[0]

    return AwaitFingerprintAction(await_fingerprint, timeout = timeout)

class AwaitFingerprintAction(SingleAction):
    pass
class AwaitFingerprintDestroyAction(SingleAction):
    pass

So wäre eine Beispielimplementierung dann als Action. Das dann aber anstelle von dem Keyboard, da ich die Events recycled habe.

[Fingerprint]
port =
baudrate = 
address =
password = 
security = 

[EVENT_OnFingerFoundKnown]
10 = out:Tueroffnen

[EVENT_OnFingerFoundUnknown]
10 = speak,"HEY GEH WEG!"

Die Parameter sind alle optional, da defaults im Skript hinterlegt sind.

Ausgelöst wird das ganze z.B.: (timeout 30 Sekunden)

10 = await_fingerprint:30

Danke fürs korrigieren. Python ist echt ne komische Sprache :O Komm eigtl von C++, da braucht es sowas nicht. Und diese 'undefinierten' Scopes.. (bzw. durchs einrücken... )

Klingt gut wobei ich gar nicht weiß ob motom001 pull requests noch zulässt.

M4ce1 testet das Keyboard gerade auch.

Beim Code müsste man nochmal überlegen, ob die Zuweisung des last-key evtl nur erfolgen soll, falls es ein zutreffender Finger ist und nicht generell bei jedem Finger.

Wo ist denn da die Verbindung zum DoorPi?

Die von dir verwendete Bibliothek ist als "deprected" gekennzeichnet (https://github.com/adafruit/Adafruit_Python_DHT)

import Adafruit_DHT
import time
import serial

ser = serial.Serial(port='/dev/ttyUSB0', baudrate = 9600, parity = serial.PARITY_NONE, stopbits = serial.STOPBITS_ONE, bytesize = serial.EIGHTBITS, timeout = 1)

#Sensortyp und GPIO festlegen
sensor = Adafruit_DHT.DHT22
gpio = 4

while True:
    # Daten auslesen
    humidity, temperature = Adafruit_DHT.read_retry(sensor, gpio)

    # Ausgabe
    if humidity is not None and temperature is not None:
        output = '"Temperatur: {0:0.1f}*C Luftfeuchtigkeit: {1:0.1f}%"'.format(temperature, humidity)
        EndCom = "\xff\xff\xff"
        ser.write('temperatur.txt='+ output + EndCom)

Wahrscheinlich suchst du sowas? Kenne mich mit Nextion noch weniger als mit Python aus aber zum einen machte deine Schleife an der Stelle nicht so viel Sinn, es sei denn du willst immer die selben Werte da stehen haben. Dann solltest du deinen formatierten String auch zum Nextion schicken und nicht nur ausgeben (print) ...

Ich hab es im Beitrag hinzugefügt.

Das Keyboard verhält sich wie das für PN532/RM6300. Es läuft in einer Endlosschleife, bis DoorPi beendet wurde. Darin wird immer wieder auf einen neuen Finger gewartet.

Wenn eine Finger gefunden wurde, wird nach diesem unter den Registrierten gesucht. Ist er dort vorhanden und eindeutig als dieser identifiziert (Variable security) wird zunächst OnFoundKnown ausgelöst und dann, falls registriert, für diesen Finger hinterlegte Events (OnKeyDown/Up/Press ) ausgelöst. Die Pin-Nummer ist hierbei jetzt die Position des Fingerabdrucks in der (auf dem Sensor) hinterlegten Datenbank. (Die in der pyFingerprint enthaltene https://github.com/bastianrasc…xamples/example_search.py kann dir die ausgeben)

Und dann in der Config

[keyboards]
fpreader = fingerprint

[fpreader_keyboard]
port = /dev/ttyUSB0
#address = 0xFFFFFFFF
#password = 0x00000000
security = 80
    
[fpreader_InputPins]
1 = sleep:0
2 = sleep:0
 
# Auf einzelnen Fingerabdruck erweitertet reagieren
[EVENT_OnKeyPressed_fpreader.1] 
10 = out:Tueroeffner,1,0,3
20 = mailto:hansi@t-online.de,"Hansi ist da", "Hallo"

# Event, dass bei jedem erkannten Tag auslöst
[EVENT_OnFingerFoundKnown]
10 = out:Tueroeffner,1,0,3

Ok kannst du evtl. mal den Inhalt aus dem Log 1 zu 1 kopieren?

Ich hab ja schon keine Ahnung von Python aber du scheinbar auch nicht

Füge doch mal in der Zeile 41 in der mailto.py folgendes ein:

server.set_debuglevel(1)

Dann solltest du schonmal genauere Fehlermeldungen bekommen.

Ansonsten einfach mal ne Python-Konsole öffnen und darin mal folgendes ausführen:

import smtplib 
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText 

server = smtplib.SMTP('smtp.2und2.de', 587) 
server.setdebuglevel(1)         
server.ehlo()
server.starttls()
server.login('bla@online.de', 'xxxxxxx') 
         
msg = MIMEMultipart()
msg['From'] = 'bla@online.de' 
msg['To'] = 'aio@online.de'   
msg['Subject'] = 'Betreff' 
msg.attach(MIMEText('Inhalt der eMail', 'plain'))
server.sendmail('bla@online.de', 'aio@online.de', msg.as_string())
server.quit()

Dabei dürfte dir dann auch eine Fehlermeldung entgegen kommen. Wie gesagt entspricht der Aufruf weiterhin dem in der Dokumentation...

Dass DoorPi auf Python 2.7 stehen geblieben ist wurde ja mehrfach schon thematisiert. Du kannst dich ja an motom001 wenden, falls du die Portierung hinbekommst bzw soll die Grundstruktur ja geändert werden.

Habs euch mal grob mit der pyFingerprint-Library zusammengesetzt. Ich habe aber selbst weder einen der unterstützten Sensoren noch hab ich es getestet. Kann also sein, dass da Syntax und/oder andere Fehler drin sind.

1. pyFingerprint - Library installieren: https://github.com/bastianrasc…fingerprint/#installation

2. Fingerabdrücke registieren: https://github.com/bastianrasc…t/#how-to-use-the-library 

3. /usr/local/lib/python2.7/dist-packages/doorpi/keyboard/from_fingerprint.py anlegen und folgenden Inhalt einfügen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import logging
logger = logging.getLogger(__name__)
logger.debug("%s loaded", __name__)

import threading
import time
from pyfingerprint.pyfingerprint import PyFingerprint

from doorpi.keyboard.AbstractBaseClass import KeyboardAbstractBaseClass, HIGH_LEVEL, LOW_LEVEL
import doorpi

def get(**kwargs): return Fingerprint(**kwargs)
class Fingerprint(KeyboardAbstractBaseClass):
    name = 'Fingerprint Reader'

    def readFingerprint(self):
        logger.debug("readFingerprint() started")
        while not self._shutdown:
            try:
                ## Warten bis ein Finger erkannt wurde. Falls zwischendurch DoorPi beendet wird (multithreading!) - Abbruch. 
                while (self.__sensor.readImage() == False):
                    if (self._shutdown) return
                    pass
     
                ## Characteristics aus dem gelesenen Fingerabdruck auslesen und hinterlegen
                self.__sensor.convertImage(0x01)
                ## Datenbank nach diesen Characteristics durchsuchen
                result = self.__sensor.searchTemplate()
                positionNumber = result[0]
                accuracyScore = result[1]
                ## Input-Pin entsprechend der gefundenen Position aktivieren
                self.last_key = positionNumber
                self.last_key_time = time.time()
                logger.debug('Found template at position #' + str(positionNumber))
                logger.debug('The accuracy score is: ' + str(accuracyScore))
                
                ## Finger entweder garnicht oder nicht exakt genug erkannt.
                if (positionNumber == -1) or (accuracyScore < self.__security):
                    ## Finger unbekannt - Event auslösen
                    doorpi.DoorPi().event_handler('OnFingerFoundUnknown', __name__)
                else:
                    ## Finger bekannt - Event auslösen
                    doorpi.DoorPi().event_handler('OnFingerFoundKnown', __name__)
                    ## Dem Finger zugeordnete Events auslösen
                    if (self.last_key in self._InputPins):
                        self._fire_OnKeyDown(self.last_key, __name__)
                        self._fire_OnKeyPressed(self.last_key, __name__)
                        self._fire_OnKeyUp(self.last_key, __name__)
            except Exception as ex:
                logger.exception(ex)

    def __init__(self, input_pins, keyboard_name, conf_pre, conf_post, *args, **kwargs):
        logger.debug("__init__ (input_pins = %s)", input_pins)
        self.keyboard_name = keyboard_name
        self._InputPins = map(int, input_pins)

        self.last_key = ""
        self.last_key_time = 0
 
        ## Spezielle Handler für (Un-)bekannte Finger registrieren
        doorpi.DoorPi().event_handler.register_event('OnFingerFoundUnknown', __name__)
        doorpi.DoorPi().event_handler.register_event('OnFingerFoundKnown', __name__)

        ## Config-Einträge lesen, falls dort vorhanden.
        section_name = conf_pre + 'keyboard' + conf_post
        self.__port = doorpi.DoorPi().config.get(section_name, 'port', "/dev/ttyAMA0")
        self.__baudrate = doorpi.DoorPi().config.get_int(section_name, 'baudrate', 57600)
        self.__sensoraddr = doorpi.DoorPi().config.get(section_name, 'address', 0xFFFFFFFF)
        self.__password = doorpi.DoorPi().config.get(section_name, 'password', 0x00000000)
        self.__security = doorpi.DoorPi().config.get_int(section_name, 'security', 70)
        
        ## Sensor initialisieren
        self.__sensor = PyFingerprint(self.__port, self.__baudrate, self.__sensoraddr, self.__password)
        if (self.__sensor.verifyPassword() == False):
            logging.warning('The given fingerprint sensor password is wrong!')
        
        logging.debug('Currently used templates: ' + str(self.__sensor.getTemplateCount()) + '/' + str(self.__sensor.getStorageCapacity()))
        ## Events für hinterlegte InputPins registrieren (damit diese auch ausgelöst werden)
        for input_pin in self._InputPins:
            self._register_EVENTS_for_pin(input_pin, __name__)

        ## Thread für den eigtl Lesevorgang starten
        self._shutdown = False
        self._thread = threading.Thread(target = self.readFingerprint)
        self._thread.daemon = True
        self._thread.start()
        self.register_destroy_action()

    def destroy(self):
        if self.is_destroyed: return
        self._shutdown = True
        doorpi.DoorPi().event_handler.unregister_source(__name__, True)
        self.__destroyed = True

    def status_input(self, tag):
        return (tag == self.last_key)

    def set_output(self, pin, value, log_output = True):
        return False

Wäre eigtl sinnvoller ein eigenes Topic dafür aufzumachen, weil ich denke, dass das mehr ein Problem deiner Parameter/Config ist. Ich hab es nicht ausprobiert aber mal in die entsprechende Action geschaut - https://github.com/motom001/Do…n/SingleActions/mailto.py. Wie sieht deine Config aus? Hast du den smtp-Server genauer definiert?

https://docs.python.org/2/library/smtplib.html ist die Doc der verwendeten Bibliothek. Da siehst du, dass der Aufruf in DoorPi durchaus noch richtig ist:

 SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options])

und der Fehler eher bei deinem SMTP-Server oder deiner entsprechenden DoorPi-Config liegt. Aus letzterer werden folgende Werte ausgelesen (falls ein dritte Wert in der Funktion steht ist dass der Standardwert):

smtp_host = doorpi.DoorPi().config.get('SMTP', 'server', 'smtp.gmail.com')
smtp_port = doorpi.DoorPi().config.get_int('SMTP', 'port', 465)
smtp_user = doorpi.DoorPi().config.get('SMTP', 'username')
smtp_password = doorpi.DoorPi().config.get('SMTP', 'password')
smtp_from = doorpi.DoorPi().config.get('SMTP', 'from')
smtp_use_tls = doorpi.DoorPi().config.get_boolean('SMTP', 'use_tls', False)
smtp_use_ssl = doorpi.DoorPi().config.get_boolean('SMTP', 'use_ssl', True)
smtp_need_login = doorpi.DoorPi().config.get_boolean('SMTP', 'need_login', True)

In deiner DoorPi-Config sollte der SMTP-Server entsprechend definiert sein. (Hab es mal am Beispiel T-Online ausgefüllt, weil deine Mail daher stammte ...):

[SMTP]
server = securesmtp.t-online.de
port = 995
username = hansimaus
password = Hansi12345
from = hansi@t-online.de
# Die zwei folgenden kannst du weglassen (Std.-Wert)
use_ssl = True 
need_login = True

Hallo zusammen,

Leider bekomme ich mit dem v4l2 Treiber immer den Fehler ENOSPC. Kabel ist korrekt montiert. OV5647 ist der Sensor. Es greift kein Prozess auf die Camera zu (zumindest wird mir keiner angezeigt). vcgencmd get_camera gibt mir 1 und 1 zurück. Der GPU mem ist mittlerweile auf 512, nachdem 256 auch nicht funktionierte. Firmware und Software sind aktuell. Bin etwas ratlos. Habt ihr Ideen was ich evtl. noch verändern könnte?