-         
Seite 5 von 6 ErsteErste ... 3456 LetzteLetzte
Ergebnis 41 bis 50 von 58

Thema: abstandhalten mit 433MHz

  1. #41
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.12.2010
    Ort
    NRW
    Beiträge
    210
    Anzeige

    schön schön freut mich das es so funktioniert wie gedacht, auf zu neuen Projekten
    cYa pig

  2. #42
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.794
    die testergebnisse gibt's hier immer wieder mal, jetzt sind wir eher mit den e-bikes unterwegs als im winter

    was mich jetzt beschäftigt, ist die bisher nur einseitige benachrichtigung. Eigentlich ist es ja nur der client, der eine neue wie auch eine abgebrochne verbindung signalisiert:

    - beim server geht das RSSI ja nicht, weil es ja mehrere clients geben kann, die eine verbindung haben - das vermute ich als grund für das nicht funktionieren
    - auch mit dem zählen der verbindungen beim server (die funktion (WiFi.softAPgetStationNum() ), da wird eine neue verbindung recht schnell bemerkt und signalisiert, bei einer abgebrochnen verbindung dauert es elend lange, bis die meldung kommt, da ist man mit dem rad leicht 300/400 meter gefahren. Das übersteigt die (meine) toleranzgrenze beim weiten...

    Das sind die zwei möglichkeiten, die ich bisher ausprobiert habe, was gibt's noch? Geht da was nur mit dem webserver und einer "normalen" zeichenübertragung?
    gruß inka

  3. #43
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.974
    Blog-Einträge
    15
    Du könntest versuchen, die Laufzeit eines Signals zu messen. Zum Server hinschicken, der schickt es direkt zurück und Du ermittelst, wie lange das gedauert hat. Vielleicht ist das brauchbarer. Das Signal/Zeichen kann auch vom Server kommen, der Client schickt es zurück und Du ermittelst die Laufzeit auf dem Server.

    MfG

  4. #44
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.794
    Zitat Zitat von Moppi Beitrag anzeigen
    Du könntest versuchen, die Laufzeit eines Signals zu messen. Zum Server hinschicken, der schickt es direkt zurück und Du ermittelst, wie lange das gedauert hat. Vielleicht ist das brauchbarer. Das Signal/Zeichen kann auch vom Server kommen, der Client schickt es zurück und Du ermittelst die Laufzeit auf dem Server.

    MfG

    ok, dann kenne ich die laufzeit - was mache ich dann damit? Oder meinst du eine unendlich lange laufzeit ist ein zeichen für eine abgebrochene verbindung?
    Auf dem client habe ich ereignisse, die ich direkt in signale der RGB led umwandeln kann, die werden dann auf dem clientmodul ausgewertet und eben in die optischen signale umgewandelt...
    Eine solche möglichkeit auf dem server, die ebenfalls eine direkte umwandlung in optische signale der RGB led ermöglicht fehlt mir. Die Suche ich...
    Mit dem zeichen senden dachte ich eher daran, dass der client irgendein vereinbartes zeichen in vereinbarten intervallen an den server sendet. Bleibt diese sendung aus, heisst es verbindungsabbruch und RGB-led des servermoduls geht auf rot...
    gruß inka

  5. #45
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.974
    Blog-Einträge
    15
    Zitat Zitat von Moppi Beitrag anzeigen
    Muss man nur von einem nodeMCU ab und an was schicken, reißt die Verbindung ab, fallen die Nachrichten aus und der Server weiß, dass die Reichweite überschritten wurde.
    Ein Versuch ist es aber auch wert, zu schauen, ob mit abnehmender Signalstärke die Laufzeit länger wird. Normal soll es so sein. Und ob man das sinnvoll verwerten kann. So erkennst Du auch, welche Zeit für ein Timeout geeignet ist.


    MfG

  6. #46
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.794
    wie meinst du das mit dem timeout? in meiner letzten codeversion wird nun beim client die signalstärke ausgewertet und beim server die anzahl der clientverbindungen. das ist erstmal ausreichend, bis mir noch was anderes einfällt...

    Edit: ich glaube ich weiss jetzt, wie das gemeint ist:
    Messen und vergleichen wie sich die dauer auf dem signaleweg mit wachsender entfernung verändert und dann festlegen, zu welchem zeitpunkt (timeout) die verbindung als zu gross angesehen werden kann...
    Ganz schön aufwendig, hauptsächlich die verifizierung, oder?
    Geändert von inka (01.07.2020 um 18:50 Uhr)
    gruß inka

  7. #47
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.974
    Blog-Einträge
    15
    Du musst doch nur was verschicken. Davor erfasst Du die Mikrosekunden und danach, wenn das Echo zurückgekommen ist.
    So was wird für verschiedene Zwecke benutzt. Hier mal ein Überblick bei Wikipedia.

    MfG

  8. #48
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.794
    ok, danke für den link...

    habe heute den ersten test auf dem rad durchgeführt

    Klicke auf die Grafik für eine größere Ansicht

Name:	2020_07_02_server_modul.jpg
Hits:	7
Größe:	56,8 KB
ID:	35146

    vom prinzip her alles gut, abbruch wird nach ca. 100m erkant und auch signalisiert, auch ein reconnect findet statt. Allerdings sind die reaktionen auf beiden rädern zu träge, da muss was anderes her - zeichen senden und zeiten messen. Bin gespannt, wie ich das hinkriege...
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken 2020_07_02_server_modul.jpg  
    gruß inka

  9. #49
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.974
    Blog-Einträge
    15
    Da ich etwas Zeit hatte, habe ich gesucht, wie man TCP/IP-Pakete verschickt. Habe aber noch nichts ordentliches gefunden. Vom Prinzip her könnte man auch UDP-Datenpakete schicken. Habe aber selbst noch nie geschaut, wie zuverlässig das ist. Weil bei UDP ist mit Paketverlusten zu rechnen, bzw. dass Pakete in einer anderen Reihenfolge ankommen, als sie verschickt wurden. Aber ich denke, man sollte das einfach damit versuchen. Wenn wird nur ein Paket verschickt und man wartet auf das Echo von der Gegenseite. Bleibt nur in Versuchen herauszufinden, wie verlässlich und damit brauchbar das ist.
    Ansonsten habe ich eine Bibliothek gefunden, die man sich mal anschauen könnte: ESP8266-Ping

    MfG

    - - - Aktualisiert - - -

    Hier hatten wir das Thema UDP schon mal: https://www.roboternetz.de/community...sp8266+nodemcu

    Hier noch mal ein anderes Tutorial zu UDP: https://www.nikolaus-lueneburg.de/20...kommunikation/
    Geändert von Moppi (03.07.2020 um 08:12 Uhr)

  10. #50
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.794
    ich hab das hier gefunden:

    server
    Code:
    // https://www.arduinoforum.de/arduino-Thread-Nodemcu-wie-benutzen?page=4
    
    #include <ESP8266WiFi.h>
    #include <WiFiUdp.h>
    /*
        Befehlsprotokoll
      1.Byte Befehl   2. bis ... Daten  Sender  Inhalt
      0x01            keine             1       Anforderung Temperatur
      0x11            4 Byte (float)    2       Antwort Temperatur
      0x02            1 Byte (0 oder 1) 1       Setze LED Aus = 0 / EIN = 1
      0x03            keine             1       Abfrage Status der LED
      0x12            1 Byte            2       Sende Status der LED (Antwort auf 0x02 und 0x03)
      0xFF            keine             2       unbekannter Befehl
    */
    
    // <= 31 Zeichen
    char *ssid = "nodemcu_test";
    // >= 8 oder <= 63 Zeichen oder NULL
    char *password = "geheim123";
    
    IPAddress remoteIP(192,168,4,2);
    WiFiUDP Udp;
    unsigned int port = 4210;  // local and remote port to listen on
    char incomingPacket[10];  // buffer for incoming packets (255)
    char befehl[10];
    
    uint32_t aktMillis;
    uint32_t prevMillis;
    
    typedef struct aufgabe {
      uint32_t prevMillis;
      uint32_t intervall;
    };
    
    #define ANZAHL_AUFGABEN 3
    aufgabe aufgaben[ANZAHL_AUFGABEN] = {{0L,5000L}, {0L, 7000L}, {0L, 10000L}};
    boolean gesendet = false;
    int aktuelleAufgabe = -1;
    boolean ledStatus = false;
    
    void checkAufgaben() {
    int len = 1;  
      // da ist noch was unterwegs
      if (gesendet) return;
      if (0 == WiFi.softAPgetStationNum()) {
        // keine Station angemeldet
        // prevMillis auf aktMillis setzen damit die Zeiten nicht schon abgelaufen sind
        for(byte i=0; i < ANZAHL_AUFGABEN; i++) {
          aufgaben[i].prevMillis = aktMillis;
        }
      }
      else {
        for(byte i=0; i<ANZAHL_AUFGABEN; i++) {
          if (aktMillis - aufgaben[i].prevMillis >= aufgaben[i].intervall) {
            aufgaben[i].prevMillis = aktMillis;
            aktuelleAufgabe = i;
            switch (i) {
               case 0:
                   befehl[0] = 0x01;
                   Serial.println("Aufgabe Temperatur");
                  
                   break;
               case 1:
                   befehl[0] = 0x02;
                   befehl[1] = !ledStatus;
                   len++;
                   Serial.println("Aufgabe LED schalten");
                   break;    
               case 2:
                   befehl[0] = 0x03;
                   Serial.println("Aufgabe LED Status");
                   break;
            }
            Udp.beginPacket(remoteIP, port);
            Udp.write(befehl, len);
            Udp.endPacket();
            gesendet = true;
            break;
          }
        }
      }
    }
    
    void setup()
    {
      Serial.begin(115200);
      Serial.println();
    
      Serial.print("Setting soft-AP ... ");
      boolean result = WiFi.softAP(ssid, password);
      if(result == true)
      {
        Serial.println("Ready");
        Udp.begin(port);
        Serial.print("UDP-Server bereit an Port ");
        Serial.println(port);
    
      }
      else
      {
        Serial.println("Failed!");
      }
    }
    
    void auswerten(int len) {
    byte befehl;
    float temp;
    boolean status;
      befehl = incomingPacket[0];
      gesendet = false;
      // Bytefolge ausgeben
      Serial.print("Incomming: ");
      for(byte i = 0; i<len;i++) {
        Serial.print(incomingPacket[i],HEX); Serial.print(" ");
      }
      Serial.println();
      switch (befehl) {
          case 0x11:
            memcpy(&temp,incomingPacket+1,sizeof(temp));
            Serial.print("Temperatur: "); Serial.println(temp);
            break;
          case 0x12:
            status = incomingPacket[1];
            Serial.print("LED Status: "); Serial.println(status);
            ledStatus = status;
            break;
          case 0xFF:
            Serial.println("Unbekannter Befehl");
            break;
          default:
            Serial.println("Unbekannte Antwort");
      }
    }
    
    void loop() {
    int packetSize, len;
      aktMillis = millis();
      if (aktMillis - prevMillis >= 3000) {
        prevMillis = aktMillis;
        Serial.printf("Stations connected = %d\n", WiFi.softAPgetStationNum());
      }
      checkAufgaben();
      // UDP
      packetSize = Udp.parsePacket();
      // Da ist was da
      if (packetSize) {
        Serial.print("Empfangen "); Serial.print(packetSize);
        Serial.print(" von IP "); Serial.print(Udp.remoteIP());
        Serial.print(" Port "); Serial.println(Udp.remotePort());
        len = Udp.read(incomingPacket, 255);
        auswerten(len);
      }
    }
    client
    Code:
    #include <OneWire.h>
    
    //#include <DallasTemperature.h>
    //  https://www.arduinoforum.de/arduino-Thread-Nodemcu-wie-benutzen?page=4
    
    // NodeMCU 2 mit LED an D7 und DS18B20 an D1
    // Als UDP-Server, der vom NodeMCU 1 seine Befehle bekommt
    /*
        Befehlsprotokoll
      1.Byte Befehl   2. bis ... Daten  Sender  Inhalt
      0x01            keine             1       Anforderung Temperatur
      0x11            4 Byte (float)    2       Antwort Temperatur
      0x02            1 Byte (0 oder 1) 1       Setze LED Aus = 0 / EIN = 1
      0x03            keine             1       Abfrage Status der LED
      0x12            1 Byte            2       Sende Status der LED (Antwort auf 0x02 und 0x03)
      0xFF            keine             2       unbekannter Befehl
    */
    
    /*
      NodeMCU-DallasDS18B20
      Notwendig ist die angepasste Dallas-Lib:
       Download hier: https://github.com/milesburton/Arduino-Temperature-Control-Library
       Eine eventuell vorhandene DallasTemperature-Lib sollte gelöscht werden, damit oben
       genannte von der IDE verwendet wird
    */
    #include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird
    //https://github.com/milesburton/Arduino-Temperature-Control-Library
    #include <Base64.h>
    #include <OneWire.h>
    // für UDP-Server
    #include <ESP8266WiFi.h>
    #include <WiFiUdp.h>
    
    #define ONE_WIRE_BUS D1  //Bestimmt Port an dem der Sensor angeschlossen ist
    #define LED D7
    
    OneWire oneWire(ONE_WIRE_BUS);
    DallasTemperature sensors(&oneWire);
    DeviceAddress insideThermometer;
    
    // 10 Sekunden Messintervall Temperatur
    #define INTERVALL 10000
    // 1 Sekunde Wartezeit auf die Messergebnisse
    #define WAIT 1000
    
    uint32_t requestMillis;
    uint32_t aktMillis;
    uint32_t prevMillis = INTERVALL;
    boolean isRequested = false;
    float temp = 0.0;
    
    WiFiUDP Udp;
    unsigned int localUdpPort = 4210;  // local port to listen on
    char incomingPacket[255];  // buffer for incoming packets
    char antwort[10];
    boolean ledStatus = false;
    // das bitte ändern
    char *ssid = "nodemcu_test";
    char *password = "geheim123";
    
    // Auswerten UDP-Befehl und Antwortdaten vorbereiten
    // return: Länge der Antwort
    int AntwortBilden(int len) {
      byte befehl;
      // Bytefolge ausgeben
      Serial.print("Incomming: ");
      for(byte i = 0; i<len;i++) {
        Serial.print(incomingPacket[i],HEX); Serial.print(" ");
      }
      Serial.println();
    
      int alaenge = 1; // mindestens das Befehlsbyte
      befehl = incomingPacket[0];
      switch (befehl) {
        case 0x1:
          antwort[0] = 0x11;
          memcpy(antwort + 1, &temp, sizeof(temp));
          alaenge += sizeof(temp);
          break;
        case 0x2:
          ledStatus = incomingPacket[1];
          if (ledStatus) {
            digitalWrite(LED, HIGH);
          }
          else {
            digitalWrite(LED, LOW);
          }
        // hier kommt kein Break, da die Antwort die gleiche ist
        case 0x3:
          antwort[0] = 0x12;
          antwort[1] = ledStatus;
          alaenge += 1;
          break;
        default:
          antwort[0] = 0xFF;
      }
      return alaenge;
    }
    
    
    
    // function to print a device address
    void printAddress(DeviceAddress deviceAddress)
    {
      for (uint8_t i = 0; i < 8; i++)
      {
        if (deviceAddress[i] < 16) Serial.print("0");
        Serial.print(deviceAddress[i], HEX);
      }
    }
    
    void initializeSensor() {
      Serial.println("Dallas Temperature IC Control Library Demo");
      // locate devices on the bus
      Serial.print("Locating devices...");
      sensors.begin();
      Serial.print("Found ");
      Serial.print(sensors.getDeviceCount(), DEC);
      Serial.println(" devices.");
    
      // report parasite power requirements
      Serial.print("Parasite power is: ");
      if (sensors.isParasitePowerMode()) Serial.println("ON");
      else Serial.println("OFF");
      if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
      Serial.print("Device 0 Address: ");
      printAddress(insideThermometer);
      Serial.println();
    
      // set the resolution to 12 bit (Each Dallas/Maxim device is capable of several different resolutions)
      sensors.setResolution(insideThermometer, 12);
    
      Serial.print("Device 0 Resolution: ");
      Serial.println(sensors.getResolution(insideThermometer), DEC);
    
      // requestTemperatures() blockiert nicht, bis die Messung fertig ist
      sensors.setWaitForConversion(false);
      Serial.print("Wait for conversation: ");
      Serial.println(sensors.getWaitForConversion());
    }
    
    void requestTemp() {
      // Messung ist schon angefordert
      if (isRequested) return;
      // Serial.print("Requesting temperatures...");
      sensors.requestTemperatures(); // Send the command to get temperatures
      requestMillis = millis();
      isRequested = true;
      //Serial.println("DONE");
    }
    
    // function to get (and print) the temperature for a device
    void printTemperature(DeviceAddress deviceAddress) {
      // keine Messung gestartet
      if (!isRequested) return;
      if (millis() - requestMillis >= WAIT) {
        prevMillis = aktMillis;
        float tempC = sensors.getTempC(deviceAddress);
        temp = tempC;
        Serial.print("Temp C: ");
        Serial.print(tempC);
        Serial.print(" localIP: ");
        Serial.println(WiFi.localIP());
        isRequested = false;
      }
    }
    
    void setup() {
      Serial.begin(115200);
      Serial.println("Start");
      digitalWrite(LED, LOW);
      pinMode(LED, OUTPUT);
      initializeSensor();
    
      Serial.print("Connecting to "); Serial.println(ssid);
      WiFi.begin(ssid, password);
      while (WiFi.status() != WL_CONNECTED)
      {
        delay(500);
        Serial.print(".");
      }
      Serial.println(" connected");
      Udp.begin(localUdpPort);
      Serial.print("UDP-Server bereit an IP: ");
      Serial.print(WiFi.localIP());
      Serial.print(" Port: ");
      Serial.println(localUdpPort);
    }
    
    void loop() {
    int packetSize, len, alen;
    
      aktMillis = millis();
      // call sensors.requestTemperatures() to issue a global temperature
      // request to all devices on the bus
      if (aktMillis - prevMillis >= INTERVALL) {
        requestTemp();
      }
      // It responds almost immediately. Let's print out the data
      printTemperature(insideThermometer); // Use a simple function to print out the data
    
      // UDP
      packetSize = Udp.parsePacket();
      // Da ist was da
      if (packetSize) {
        Serial.print("Empfangen "); Serial.print(packetSize);
        Serial.print(" von IP "); Serial.print(Udp.remoteIP());
        Serial.print(" Port "); Serial.println(Udp.remotePort());
        len = Udp.read(incomingPacket, 255);
        /*
           Wenn mit Zeichenketten gearbeitet wird - machen wir hier nicht
          if (len > 0) {
           incomingPacket[len] = 0;
           Serial.print("Inhalt: "); Serial.println(incomingPacket);
          }
        */
        alen = AntwortBilden(len);
        Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
        Udp.write(antwort, alen);
        Udp.endPacket();
      }
    }
    nachdem ich die lib's nachinstalliert habe (das thermometer brauche ich nachher sicher nicht ), aber immerhin verbinden sich beide ohne zu murren und es gibt auch gegenseitige meldungen. Muss ich noch studieren
    gruß inka

Seite 5 von 6 ErsteErste ... 3456 LetzteLetzte

Ähnliche Themen

  1. 433MHz Funkmodule bei Pollin
    Von toemchen im Forum Elektronik
    Antworten: 97
    Letzter Beitrag: 24.05.2009, 20:43
  2. antenne 433MHz Easyradio
    Von nobody1900 im Forum Elektronik
    Antworten: 1
    Letzter Beitrag: 30.01.2007, 12:46
  3. 433MHz Übertragung
    Von Muecke im Forum Elektronik
    Antworten: 2
    Letzter Beitrag: 28.12.2006, 20:01
  4. 433Mhz Verstärker
    Von BastelWastel im Forum Elektronik
    Antworten: 6
    Letzter Beitrag: 16.09.2006, 21:35
  5. Problem mit Abstandhalten zur Wand
    Von semicolon im Forum C - Programmierung (GCC u.a.)
    Antworten: 8
    Letzter Beitrag: 12.07.2006, 21:08

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •