Ankündigung

Einklappen
Keine Ankündigung bisher.

Toröffner mit mehr als 100m Reichweite auf Basis von LoraWAN und Chirpstack

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    [Projekte] Toröffner mit mehr als 100m Reichweite auf Basis von LoraWAN und Chirpstack

    Hiermit teile ich gerne mein neuestes Projekt mit euch.

    Vorweg:
    Ich entschuldige mich schon mal für die vielen Rechtschreibfehler, die ich hoffentlich bei den Überarbeitungen alle finden werde
    Falls jemand das Projekt nachbauen möchte würde ich mich über Anregungen / Verbesserungen der Anleitung freuen.
    Sie ist sicher weit weg von perfekt...

    Problem:
    Die Öffnung des Hoftors sowie des Garagentors erfolgte mittels KNX-RF Handsendern der Fa. Gira über Gira KNX RF Gateways.
    Trotz Platzierung des KNX-RF Gateways direkt an der Torsäule mit der Antenne frei nach draußen war die Reichweite bescheiden.
    Da wir an einer Durchgangsstraße hausen kommt es öfter vor dass man den Verkehr hinter sich aufhält weil das Funksignal erst kurz vor dem Tor empfangen wird und dann das Tor ja auch erst noch gemütlich auffahren muss.

    Das ist für alle Nutzer nicht zufriedenstellend und musste abgelöst werden.

    Meine overkill-Lösung dafür: LoraWAN

    Anforderungen:

    Folgende Anforderungen hatte ich an das System gestellt:
    - Reichweite des Funksignals vom Handsender mehr als 100 meter vom fahrenden Auto zum Gateway
    - Unterscheidung der Handsender um verschiedene Funktionen je nach Nutzer auszulösen
    - kompakte Handsender
    - lange Batterielaufzeit der Handsender
    - einfache Erweiterung um weitere Handsender o.ä.
    - Sicherheit (Verschlüsselung)
    - System soll autark sein. Mehr dazu unten..
    - Lora Gateway soll auch für die Community über TTN nutzbar sein.


    Autarkie:
    Üblicherweise senden die Lora Gateways ihre Pakete an eine Cloud.
    Die bekannteste z.B. TTN (The Things Network)

    Autarkie ist bei diesem Anwesen sehr wichtig.
    Es wurden enorm viele Anstrengungen in Notstromversorgung, Redundanzen, Überwachung etc. gesteckt.
    Somit sollte bei einem potentiellen Internetausfall / größeren Stromausfall, etc.. (was auch immer kommen mag) trotzdem möglich sein u.a. das Tor über die Lora Handsender zu bedienen.
    Bei einer Cloudanbindung wäre dies nicht mehr gewährleistet. (Es wäre jedoch um Welten einfacher einzurichten gewesen)
    Somit musste lokal eine Serverstruktur zur Kommunikation für Lora aufgebaut werden.

    Hardware:
    Als Gateway kam ein Lorix One vom Schweizer Hersteller WifX zum Einsatz. https://www.lorixone.io/
    Das Gateway hat mich am meisten überzeugt. Es sollte jedoch ebenso mit den vielen anderen GWs funktionieren.
    z.B. Kerlink, Tektelic, Dragino, Cisco, RAK, und viele mehr.
    Es gibt auch einige Eigenbauprojekte für Raspi, ESP und Co.
    Alles in allem gefiel mir der Lorix am besten. Netzwerkkabel rein und rauf aufs Dach.

    Der Lorix wird per passive PoE (leider kein richtiges PoE) mit dem mitgelieferten Adapter versorgt.
    Somit nur ein Netzwerkkabel für den Lorix nötig.
    Wenn möglich sollte man zur Erzielung der größtmöglichen Reichweite das Gateway außen und möglichst hoch am besten bei freier Sicht montieren.

    Bei uns sieht das nun so aus:

    20220205_142118.jpg
    Den Lorix kann man so wie er ist am Mast montieren oder mit diesem Adapter auch einfach an die Wand oder wie hier an einen L-Stein.

    Handsender:
    Für meinen Geschmack gibt es noch deutlich zu wenig Auswahl an Handsendern für Lora oder sie sind schwer zu finden.
    Ich habe mich für die Milesight WS101 Handsender entschieden.

    WS101-Lorawan-Smart-Button-01.png
    Mit 50 x 50 mm und 18mm dicke würde ich sie noch als Handsender bezeichnen. Habe aktuell nichts kompakteres gesehen. Aber so viel Platz sollte im Auto noch sein.
    Es sind sogar Klebepads dabei. Man könnte sie auch unters Armaturenbrett kleben Bei mir liegt er im Flaschenhalter für schnellen Zugriff.

    Kosten:Nettopreise!!! Ich verlinke hier auf iot-shop.de. Habe meine Sachen von dort schnell und zuverlässig bekommen. Keine bezahlte Werbung...

    Man kann vorallem beim Gateway deutlich sparen denke ich wenn man es selbst baut, oder ein günstigeres kauft.

    Architektur:
    LoraWAN-Architektur.png

    Als lokal laufenden LoraWAN Server Stack habe ich mich für Chirpstack entschieden: https://www.chirpstack.io/
    Hier findet man auch nochmal einen Überblick über die Serverstruktur: https://www.chirpstack.io/project/architecture/

    Chirpstack ist extrem skalierbar und Mandantenfähig. Also eigentlich totaler overkill um damit ein Hoftor zu fahren.
    Aber es erfüllt meine Anforderung an ein von außen unabhängiges System durch hausinternen Betrieb.


    Serverhardware & OS:

    Das ursprüngliche Testsetup wurde auf einem RaspberryPi 3 B+ installiert.
    Für den Produktivbetrieb läuft das ganze nun auf einem Intel NUC7i3.
    Ist aber im Grunde egal. Es sollte auch mit Docker und Co. funktionieren

    Als Betriebssystem läuft Debian 11 auf dem NUC.
    Ubuntu wäre laut Chirpstack auch ok.
    Es gibt auch rpm für RHEL und Co.
    Für Docker gibts wohl auch was: https://hub.docker.com/r/chirpstack/...ateway-bridge/

    Die Grundinstallation von Debian und co. erkläre ich jetzt nicht extra.
    Wir starten mit einem frischen Debian 11 in meinem Fall..

    Ein paar grundlegende Dinge wären auf einem frischen Debian zu empfehlen:

    Code:
    apt install vim htop sudo gnupg net-tools pwgen ntp
    Software:
    Chirpstack Packet Multiplexer:


    Aufgabe: Der Packet Multiplexer empfängt die Pakete vom Gateway (Lorix z.B.) und leitet sie an mehrere Server weiter.
    z.B. einmal auf den Hausinternen Chirpstack und andererseits auch an die TTN Cloud damit die Community das GW nutzen kann.
    Der Multiplexer empfängt auch Pakete von TTN und Co. sowie dem hausinternen Chirpstack und gibt sie ans Gateway weiter. (Downlink)

    Will man sein Gateway nicht im TTN o.ä. verfügbar machen würde man den Paket Multiplexer nicht benötigen.

    Hinzufügen des Chirpstack Repos für Debian:
    Code:
    sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1CE2AFD36DBCCA00
    sudo echo "deb [URL]https://artifacts.chirpstack.io/packages/3.x/deb[/URL] stable main" | sudo tee /etc/apt/sources.list.d/chirpstack.list
    sudo apt update
    Chirpstack Packet Multiplexer installieren und Config Verzeichnis & File erstellen:
    Code:
    apt install chirpstack-packet-multiplexer
    mkdir /etc/chirpstack-packet-multiplexer && touch /etc/chirpstack-packet-multiplexer/chirpstack-packet-multiplexer.toml
    Nun bearbeiten wir die Configdatei mit einem Editor unserer Wahl. z.B: vim
    Code:
    vim /etc/chirpstack-packet-multiplexer/chirpstack-packet-multiplexer.toml
    Beispiele der Configdatei findet man hier: https://github.com/brocaar/chirpstac...t-multiplexer/

    Beispielconfig:
    Code:
    [general]
    # Log level
    #
    # debug=5, info=4, warning=3, error=2, fatal=1, panic=0
    log_level=4
     
     
    [packet_multiplexer]
    # Bind
    #
    # The interface and port on which the packet-multiplexer will bind for receiving
    # data from the packet-forwarder (UDP data).
    bind="0.0.0.0:1700"
     
     
    # Backends
    #
    # The backends to which the packet-multiplexer will forward the
    # packet-forwarder UDP data.
    #
    # Example:
    [[packet_multiplexer.backend]]
    # # Host
    # #
    # # The host:IP of the backend.
    host="eu1.cloud.thethings.network:1700"
    #
    # # Uplink only
    #
    # # This backend is for uplink only. It is not able to send data
    # # back to the gateways.
    uplink_only=false
    #
    # # Gateway IDs
    # #
    # # The Gateway IDs to forward data for.
    # gateway_ids = [
    #   "0101010101010101",
    #   "0202020202020202",
    # ]
    gateway_ids = ["FCC12DFFFFFFF123"]
     
     
    # ------ Local Chirpstack Network Server -------
    #
    [[packet_multiplexer.backend]]
    host="localhost:1800"
    uplink_only=false
    gateway_ids = ["FCC12DFFFFFFF123"]
    Die Gateway ID ist eine eindeutige Nummer vom Gateway. Zu finden u.a. in der WebUI von Lorix.

    Nach anpassen der Config starten wir den Packet Multiplexer und prüfen den Status:
    Code:
    systemctl start chirpstack-packet-multiplexer
    systemctl enable chirpstack-packet-multiplexer
    systemctl status chirpstack-packet-multiplexer
    Lorix One Config:

    In der Weboberfläche vom Lorix wählt man folgenden Forwarder aus:
    - UDP Packet Forwarder
    Und unter Configuration - Global stellt man als server_address: die IP des Hosts auf dem der Chirpstack läuft ein.
    ebenso die Ports.

    Bildschirmfoto_2022-02-19_um_00_12_56.jpg

    Danach speichern und den Forwarder starten bzw. restarten.

    Das Gateway sendet periodisch Heartbeats. Die sollten somit schon am Packet Multiplexer ankommen.

    TTN / TTS Registrierung:

    Nun erstellt man sich einen kostenloser Account unter https://www.thethingsnetwork.org/

    Nach dem Login in der Console kann man unter Gateways -> Add Gateway sein Gateway hinzufügen.
    Dafür braucht man nur die UID des Gateways zu wissen.

    Bildschirmfoto_2022-02-19_um_00_24_23.jpg

    Danach sollte man nach kurzer Zeit schon einige Heartbeats sehen können.

    Bildschirmfoto_2022-02-19_um_00_26_14.jpg

    Chirpstack Gateway Bridge:


    Aufgabe:
    Die Gateway Bridge wandelt die Pakete vom Gateway (die sie über den multiplexer bekommt) in JSON und Protobuf zur weitern Verwendung im Network Server um.
    Die Daten von Gateway Bridge und Network Server werden über einen MQTT Broker ausgetauscht.

    Somit installieren wir als Zwischenschritt nun einen mosquitto Server sofern nicht schon einer im Netzwerk vorhanden ist.

    mosquitto installieren:

    Code:
    apt install mosquitto mosquitto-clients
    
    // create Auth File and first User
    mosquitto_passwd -c /etc/mosquitto/pwfile chirp-gw-bridge
    ENTER PASSWORD
    
    // add following lines to /etc/mosquitto/mosquitto.conf
    listener 1883
    password_file /etc/mosquitto/pwfile
    
    // start and check status
    systemctl start mosquitto
    systemctl enable mosquitto
    systemctl status mosquitto
    offene Ports kann man übrigens u.a. mit folgendem Befehl prüfen:
    Code:
    netstat -tulpen
    Auf den Funktionstest mit mosquitto gehe ich hier nicht ein. Ich habe das Gefühl die Anleitung wird schon lange genug.

    weiter gehts mit der Installation der Gateway Bridge:

    Code:
    apt install chirpstack-gateway-bridge
    vim /etc/chirpstack-gateway-bridge/chirpstack-gateway-bridge.toml
    Beispielconfig:
    Code:
    # This configuration provides a Semtech UDP packet-forwarder backend and
    # integrates with a MQTT broker. Many options and defaults have been omitted
    # for simplicity.
    #
    # See https://www.chirpstack.io/gateway-bridge/install/config/ for a full
    # configuration example and documentation.
     
     
    # Gateway backend configuration.
    [backend]
    # Backend type.
    type="semtech_udp"
     
      # Semtech UDP packet-forwarder backend.
      [backend.semtech_udp]
     
      # ip & Port to bind the UDP listener to
      #
      # Example: 0.0.0.0:1700 to listen on port 1700 for all network interfaces.
      # This is the listener to which the packet-forwarder forwards its data
      # so make sure the 'serv_port_up' and 'serv_port_down' from your
      # packet-forwarder matches this port.
      udp_bind = "0.0.0.0:1800"
      # Achtung !!! Hier Port 1800 da auf Port 1700 schon der Multiplexer läuft...
     
     
    # Integration configuration.
    [integration]
    # Payload marshaler.
    #
    # This defines how the MQTT payloads are encoded. Valid options are:
    # * protobuf:  Protobuf encoding
    # * json:      JSON encoding (easier for debugging, but less compact than 'protobuf')
    marshaler="protobuf"
     
      # MQTT integration configuration.
      [integration.mqtt]
      # Event topic template.
      event_topic_template="gateway/{{ .GatewayID }}/event/{{ .EventType }}"
     
      # Command topic template.
      command_topic_template="gateway/{{ .GatewayID }}/command/#"
     
      # MQTT authentication.
      [integration.mqtt.auth]
      # Type defines the MQTT authentication type to use.
      #
      # Set this to the name of one of the sections below.
      type="generic"
     
        # Generic MQTT authentication.
        [integration.mqtt.auth.generic]
        # MQTT server (e.g. scheme://host:Port where scheme is tcp, ssl or ws)
        server="tcp://127.0.0.1:1883"
     
        # Connect with the given username (optional)
        username="chirp-gw-bridge"
     
        # Connect with the given password (optional)
        password="YOUR-PASSWORD"
    Nun noch die Bridge starten und prüfen:
    Code:
    systemctl start chirpstack-gateway-bridge
    systemctl enable chirpstack-gateway-bridge
    systemctl status chirpstack-gateway-bridge
    Die nächsten Schritte folgen demnächst hier drunter... stay tuned.
    Angehängte Dateien
    Zuletzt geändert von johannes2912; 21.02.2022, 09:44. Grund: 1 Rechtschreibfehler korrigiert.

    #2
    Chirpstack Network Server:

    Aufgabe:
    Der Network Server ist als Zwischenschicht vor dem Application Server zuständig u.a. für die Authentifizierung, Paketplanung und Weiterleitung an den App Server.

    Für Network Server und App Server benötigen wir eine PostgresDB.

    Code:
    apt install postgresql
    systemctl start postgresql
    systemctl enable postgresql
    systemctl status postgresql
    // chek if pg is running:
    pg_isready
    
    // jetzt erstellen wir einen User "chirpstack_ns" und die entsprechende DB dazu.
    sudo -u postgres psql
    
    create role chirpstack_ns with login password 'DB-PASSWORD';
    create database chirpstack_ns with owner chirpstack_ns;
    \q
    
    // Test Connection
    psql -h localhost -U chirpstack_ns -W chirpstack_ns

    Nun erstellen wir noch einen mqtt User für den Net Server:

    Code:
    mosquitto_passwd /etc/mosquitto/pwfile chirp-net-server
    systemctl reload mosquitto
    Nun installieren wir den net Server sowie das benötigte redis:
    Code:
    apt install chirpstack-network-server redis-server
    systemctl start redis
    systemctl enable redis
    systemctl status redis
    
    vim /etc/chirpstack-network-server/chirpstack-network-server.toml
    
    // edit section Postgres:
    dsn="postgres://chirpstack_ns:DB-PASSWORD@localhost/chirpstack_ns?sslmode=disable"
    
    // edit section mqtt:
    
    // add username and password
    
    username="chirp-net-server"
    
    password="PASSWORD"
    
    // edit timezone
    
    timezone="Europe/Berlin"
    
    // Start, enable and check Status
    systemctl start chirpstack-network-server
    systemctl enable chirpstack-network-server
    systemctl status chirpstack-network-server
    Sollten wir die Logs einsehen wollen geht das u.a. mit:
    Code:
    journalctl -f -n 100 -u chirpstack-network-server    <<<--- hier einfach den Dienstnamen verwenden. chirpstack-packet-multiplexer, etc...
    Zuletzt geändert von johannes2912; 19.02.2022, 09:50.

    Kommentar


      #3
      Chirpstack Application Server:

      Aufgabe:
      Übernimmt die Verwaltung der Lora Geräte, User, Mandanten, Applikationen, etc.
      Stellt eine Weboberfläche zur Verfügung zur Konfiguration sowie u.a. eine RESTful API.

      Auch hier benötigen wir wieder einen Postgres User und eine eigene DB:
      Code:
      sudo -u postgres psql
      
      -- create the chirpstack_as user
      create role chirpstack_as with login password 'DB-PASSWORD';
      
      -- create the chirpstack_as database
      create database chirpstack_as with owner chirpstack_as;
      
      -- enable the trigram and hstore extensions
      \c chirpstack_as
      create extension pg_trgm;
      create extension hstore;
      
      -- exit the prompt
      \q
      
      // test connection
      
      psql -h localhost -U chirpstack_as -W chirpstack_as
      Ebenfalls benötigen wir einen mqtt user:
      Code:
      // add mqtt user for App Server
      mosquitto_passwd /etc/mosquitto/pwfile chirp-app-server
      systemctl reload mosquitto
      Nun installieren wir den App Server:

      Code:
      apt-get install chirpstack-application-server
      
      // Edit Config
      vim /etc/chirpstack-application-server/chirpstack-application-server.toml
      
      // edit section postgres:
      dsn="postgres://chirpstack_as:DB-PASSWORD@localhost/chirpstack_as?sslmode=disable"
      
      // edit section mqtt
      // add username and password
      
      username="chirp-app-server"
      password="PASSWORD"
      
      // Update JWT Secret
      
      # JWT secret used for api authentication / authorization
      # You could generate this by executing 'openssl rand -base64 32' for example
      
          jwt_secret="SECRET"
      
       
      systemctl start chirpstack-application-server
      systemctl enable chirpstack-application-server
      systemctl status chirpstack-application-server
      Nun sollten wir unter folgener Adresse ein Webinterface vorfinden:Default Username und Passwort für das WebUI sind: admin / admin

      Im nächsten Schritt beginnen wir mit der Konfiguration im WEBUI.
      Zuletzt geändert von johannes2912; 19.02.2022, 10:00.

      Kommentar


        #4
        Konfiguration WEBUI Application Server

        Da ich nicht auf alle Möglichkeiten und Einstellungen eingehe empfiehlt sich die Doku von Chirpstack:
        https://www.chirpstack.io/applicatio.../applications/

        Ich beschreibe hier nur mal grob die Grundlegenden Einstellungen. Es gibt hier unzählige Variationen.

        Als erstes empfiehlt es sich das Passwort des Admin Users zu ändern.

        Dazu nach erfolgter Anmeldung rechts oben auf Admin -> Change Passwort...

        Hinzufügen des Network Servers

        Im Menü links Network-Servers -> add

        Network-server name *
        Beliebigen Namen zur Identifizierung eures Netwerkservers eingeben. z.B: Localhost

        Network-server server *
        localhost:8000

        Sonstige Einstellungen sind erstmal optional.

        Erstellen eines Gateway Profils

        Im Menü links Gateway-Profiles -> create

        Name des Profils wählen. z.B. Lorix
        Stats interval: 30 sec. <-- Das ist der Interval in dem der Lorix seine Heartbeats / Statistiken sendet
        Enabled Channels: 0,1,2
        Network Server : localhost <-- den soeben erstellten Network Server auswählen.

        Erstellen eines Service Profils

        Im Menü links Service-Profiles -> create

        Name wählen
        Network Server auswählen
        check Add Gateway Metadata

        Rest kann erstmal so bleiben.

        Erstellen eines Geräte-Profils

        Im Menü links Device-Profiles -> create

        Es sollte für jeden Gerätetyp ein eigenes Profil erstellt werden, da die Payload Encoder und Decoder hier hinterlegt werden.

        Beispiel für den Milesight WS101 Handsender:

        Profile Name: Milesight-WS101
        Network server: localhost auswählen
        LoraWAN MAC Version in diesem Fall 1.0.3 <<-- in den technischen Dokumenten des jewiligen Sensors prüfen
        LoraWAN Regional Parameter: A <<-- in den technischen Dokumenten des jewiligen Sensors prüfen
        Default ADR algorithm
        Uplink interval z.B. auf 86000 (24 Stunden) setzen.

        Im Tab Join (OTAA/ABP):
        Device supports OTAA (Over The AIR Activation) auswählen.

        Im Tab Class B:
        check Device supports Class B

        Im Tab Codec:
        Hier werden nun die Decoder definiert. Die Payload vom Handsender wird mittels der Decoder in ein verständliches Format gebracht.

        Payload Codec: Custom JavaScript codec functions
        Decode:
        Code:
        /**
        * Payload Decoder for The Things Network
        *
        * Copyright 2021 Milesight IoT
        *
        * @product WS101
        */
        function Decode(fPort, bytes) {
        var decoded = {};
        
        for (var i = 0; i < bytes.length; ) {
        var channel_id = bytes[i++];
        var channel_type = bytes[i++];
        // BATTERY
        if (channel_id === 0x01 && channel_type === 0x75) {
        decoded.battery = bytes[i];
        i += 1;
        }
        // PRESS STATE
        else if (channel_id === 0xff && channel_type === 0x2e) {
        switch (bytes[i]) {
        case 1:
        decoded.press = "short";
        break;
        case 2:
        decoded.press = "long";
        break;
        case 3:
        decoded.press = "double";
        break;
        default:
        console.log("unsupported");
        }
        i += 1;
        } else {
        break;
        }
        }
        
        return decoded;
        }
        Beispielscripts bekommt man bei guten Herstellern meist mitgeliefert.
        z.B: Milesight: https://github.com/Milesight-IoT/SensorDecoders

        Das Encode Script können wir erst mal default lassen. Das bräuchte man wenn Daten zurück zum Handsender gesendet werden sollen.

        Hinzufügen eines Gateways:

        In Menü links Gateways -> create

        Name eueres Gateways z.B. Lorix
        Beschreibung wählen...
        Die Gateway ID (EUI) eintragen.
        die entsprechenden Profile auswählen.

        Rest kann erstmal so bleiben.

        Erstellen der Applikation:

        Im Menü links Applications -> create

        Name, Beschreibung und Service Profil auswählen.
        z.B. Name Edomi...

        Anschließend können bereits die ersten Geräte gekoppelt werden.
        Zuletzt geändert von johannes2912; 19.02.2022, 10:53.

        Kommentar


          #5
          Handsender koppeln

          Danach die Appikation öffnen und Geräte hinzufügen:

          Bildschirmfoto 2022-02-19 um 10.43.58.png Bildschirmfoto 2022-02-19 um 10.44.58.png

          Das vergeben der Tags ist optinal, kann jedoch später mal nützlich sein.

          Nachdem das Gerät erstellt wurde müssen wir den beim Handsender mitgelieferten Application Key eingeben.

          Bildschirmfoto 2022-02-19 um 10.48.25.png


          Danach sollte man sofern der Handsender bereits läuft einen Join Request und danach einen Join Accept im Tab Device-Data sehen.

          Ist der Handsender gekoppelt können wir fortfahren.

          Die Milesight WS101 können per NFC mit der App Milesight Toolbox konfiguriert werden.
          Hier kann u.a. der Buzzer aktiviert / deaktiviert werden, sowie der App Key geändert werden. uvm..

          Nun sollte man per MQTT schon an die Daten kommen.
          Zuletzt geändert von johannes2912; 19.02.2022, 10:54.

          Kommentar


            #6
            Integration in Edomi

            Für Edomi benötigen wir einen MQTT Subscribe Client sowie einen JSON Extractor.

            Ich verwende hier folgende LBS:
            MQTT Subscribe Client #19001054 http://service.knx-user-forum.de/?co...ad&id=19001054
            JSON Extractor #19001208 http://service.knx-user-forum.de/?co...ad&id=19001208

            Zuerst müssen wir jedoch noch ein mqtt User auf dem Chirpstack Server für Edomi erstellen:
            Code:
            // User Edomi für MQTT erstellen
            mosquitto_passwd /etc/mosquitto/pwfile edomi
            systemctl reload mosquitto
            Danach die LBS herunterladen und in Edomi einlesen.

            Hier nun eine Beispiel Logik für drei Handsender mit Unterscheidung zwischen kurzem, langem und doppeltem Tastendruck.

            Bildschirmfoto 2022-02-19 um 11.04.42.png
            Zuletzt geändert von johannes2912; 19.02.2022, 11:31.

            Kommentar


              #7
              Fazit und sonstiges..

              Das System läuft aktuell seit gut 3 Wochen ohne Probleme.
              Reichweite ist mehr als ausreichend. Ca. 1km an Reichweite können wir hiermit bei uns erzielen.

              Erweiterungen / Verbesserungen

              - Durchgängige Überwachung aller Komponenten vom Gateway bis zu jeder Serverinstanz (prometheus -> https://www.chirpstack.io/network-se...cs/prometheus/
              - Batteriemeldungen auswerten und bei zu gering -> Meldung (Die Handsender senden in einem bestimmten Interval ihren Batteriestand)
              - mqtt / app Server verschlüsselung https / ssl
              - Gatewayredundanz schaffen. Also ein zweites GW platzieren.
              - Serverredundanz schaffen.
              - Rückmeldungen an Handsender implementieren. Einige Handsender haben LEDs die man somit triggern könnte..
              - Andere Sensoren integrieren: z.B. Parksensoren : https://iot-shop.de/shop/product/bo-...arksensor-4265
              Oder GPS Tracker. Das wurde in einem anderen Thread hier schon einmal angesprochen. Wäre sicher auch sehr interessant.
              - Lora D2D (device2device) testen (Es soll wohl eine Möglichkeit geben oder demnächst geben zwei Lora Geräte direkt zu koppeln. Somit wäre theoretisch der ganze Serverstack nicht mehr nötig. Wenn man einen Sender und einen Empfänger (Relais o.ä.) hätte. Habe dazu aber noch nichts überzeugendes gefunden..



              Bitte beachtet dass es unzählige Möglichkeiten gibt das aufzubuen.
              Man kann es über TTN beispielsweise viel einfacher realisieren.
              Meine Lösung ist nur aus Gründen der Unabhängigkeit vom Internet so geworden...

              Viel Spaß beim nachbauen und bei Fragen bitte einfach melden.
              Zuletzt geändert von johannes2912; 19.02.2022, 11:43.

              Kommentar


                #8
                Wow. Sehr coole Idee.
                Ich spiele schon länger mit dem Gedanken einen kleinen Controller mit LoRa ins Auto zu bauen um von weitem die Standheizung einschalten zu können. (z.B. Skipiste im Urlaub, bzw. Lüftung im Sommer).
                In die andere Richtung hatte ich bisher nicht gedacht.
                Cooles Projekt. Wirklich. Das GW ist auch preislich überschaubar.
                Das wird wohl mein Herbst-Projekt....

                Kommentar


                  #9
                  Hallo johannes2912,
                  danke für die super detaillierte Anleitung. Ich habe mir grade den kleinen indoor Gateway geholt zum spielen und wollte deine Konfiguration nachbauen, da ich die lokale Variante inklusive splitting sehr gut finde.

                  Habe bei chirpstack gesehen das es eine Version 4 gibt. Hier scheint es den Multiplexer nicht mehr zu geben. Weißt du was da passiert ist oder ob es hierzu noch eine alternative gibt?

                  Kommentar


                    #10
                    Hallo dirkie
                    vielen Dank für das Lob. Freut mich wenn es dich inspiriert hat.

                    Den Packet Multiplexer bekommst du hier: https://github.com/brocaar/chirpstac...et-multiplexer

                    Du müsstest den multiplexer unabhängig vom Rest installieren können wenn ich mich nicht irre.
                    Er nimmt nur auf einem Port mittels Semtech UDP die Pakete an und schickt sie an ein oder mehrere Ziele weiter.

                    Laut Doku der V4 kann die Chirpstack Gateway Bridge weiterhin Pakete per Semtech UDP erhalten.
                    Von daher sollte es egal sein ob direkt vom Gateway oder via Multiplexer.

                    Ich bin noch auf V3, aber möchte zeitnah auf V4 migrieren.

                    Kommentar


                      #11
                      Das Problem kommt mir bekannt vor ;-)
                      Wir haben es mit einer (selbst entwickelten) App gelöst, die bei Näherung ab einer bestimmten Position ein Signal an die (ohnehin vorhandene) Mobotix-Kamera schickt, die dann wiederum im Edomi eine Sequenz auslöst und nach dem Hoftor auch gleich das richtige Garagentor öffnet und nach kurzer Zeit beide wieder schließt.
                      Ja, man braucht dafür eine Internet-Verbindung, aber das war in den letzten 4 Jahren eigentlich kein echtes Problem. Dafür geht halt im Normalfall alles automatisch und die Reichweite ist unbegrenzt (ich habe auch schon vom Skiurlaub aus das Tor geöffnet).
                      Fallback ist - falls es mal irgendwo klemmt - die klassische Hörmann-Fernbedienung. Dann muss der Verkehr hinter mir halt mal ein paar Sekunden warten.
                      Alles noch ausbaufähig (der Torantrieb hat z.B. noch keine USV), aber dafür war es einigermaßen schnell realisierbar und sogar ohne zusätzliche Hardware-Anschaffung möglich.

                      Kommentar


                        #12
                        Ich traue mich gar nicht zu fragen, aber was spricht gegen die Nutzung des Anruftriggers? Der Garage eine eigene Telefonnummer geben und falls bestimmte Nummern anrufen, geht das Tor auf. Damit bestehen auch keine Grenzen bei der Reichweite.
                        Wem die reine Nummernüberprüfung nicht sicher genug ist, kann bestimmt z. B. über FRITZ!Box, Callthrough und PIN die Sicherheit weiter erhöhen.

                        Autarkie ist dabei natürlich nicht gegeben. Ist der Strom weg, klappt weder das Telefon noch geht das Tor hoch!

                        Gibt es hierfür zu große Sicherheitsbedenken oder was spricht neben fehlender Autarkie gegen eine solche Lösung?

                        Kommentar


                          #13
                          Ich hatte früher bei einem Garagentor eine Lösung via Telefonanruf (allerdings ohne KNX, aber aus Sicht des Fahrers macht das keinen Unterschied).
                          Durch die Positionsbestimmung auf dem Handy geht es jetzt aber vollautomatisch, das ist einfach nochmal ein Stück komfortabler als jedesmal anrufen zu müssen - zumal es auch Situationen gibt, in denen man gerade telefoniert, während man genau jetzt eigentlich das Tor anrufen müsste.
                          Nebenbei fällt bei mir die Telefonie schon häufiger aus als der gesamte Anschluss, nämlich ca. 1x pro Jahr, oder sie "zickt" (Verbindung kommt nicht zustande, man muss nochmal anrufen, ca. alle 3 Monate mal).
                          In der Praxis ist die häufigste "Fehlerquelle", dass ich gerade etwas an der Programmierung ändere und das Projekt im Edomi aktiviere, während jemand das Tor öffnen will... ;-)

                          Kommentar


                            #14
                            Gleichzeitiges Telefonieren spricht natürlich dagegen.

                            Hatte eine solche Situation zum Glück nicht in den letzten Jahren. Wenn, telefoniere ich meistens auf dem beruflichen Handy und das private öffnet die Garage.

                            Kommentar


                              #15
                              Man kann auch mit Android und Tasker eine Geofencingfunktion bauen. Natürlich verknüpft mit der Bluetoothverbindung im Auto. Sonst geht das Tor auf wenn man zu Fuss kommt.

                              Kommentar

                              Lädt...
                              X