- LiFePO4 Speicher Test         
Seite 6 von 10 ErsteErste ... 45678 ... LetzteLetzte
Ergebnis 51 bis 60 von 91

Thema: abstandhalten mit 433MHz

  1. #51
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.643
    Anzeige

    Praxistest und DIY Projekte
    Ist doch gut! Es gibt viele solcher Beispiele im Netz.

    MfG

  2. #52
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    76
    Beiträge
    2.180
    diese antennen habe ich getestet:
    Klicke auf die Grafik für eine größere Ansicht

Name:	2020_07_04_antennen.jpg
Hits:	3
Größe:	15,1 KB
ID:	35151

    die kleinste reicht bis ca 70m, die grosse gut 100m, die mittlere ist seltsammerweiase die schlechteste - ca.40m

    und das ist der letzter stand der software:

    AP mit UDP server:
    Code:
    #include <ESP8266WiFi.h>
    #include <WiFiUdp.h>
    
    const int ledPin_rt =  D5;
    const int ledPin_gn =  D6;
    const int ledPin_bl =  D7;
    
    int ledState_rt = LOW;
    int ledState_gn = LOW;
    int ledState_bl = LOW;
    
    long previousMillis_rt = 0;        
    long previousMillis_gn = 0;       
    long previousMillis_bl = 0;
    
    long interval_rt = 100;           
    long interval_gn = 250;
    long interval_bl = 50;
    
    WiFiServer server(80);
    IPAddress IP(192, 168, 4, 15);
    IPAddress mask = (255, 255, 255, 0);
    
    byte ledPin = 2;
    
    // hier die Adresse vom Slave eintragen
    IPAddress remoteIP(192, 168, 4, 114);
    unsigned int remotePort = 4210;  // remote port to listen on
    char befehl[10];
    
    WiFiUDP Udp;
    uint32_t aktMillis;
    uint32_t prevMillis;
    
    boolean ledStatus = false;
    
    void setup()
    {
    
      pinMode(ledPin_rt, OUTPUT);
      pinMode(ledPin_gn, OUTPUT);
      pinMode(ledPin_bl, OUTPUT);
    
      Serial.begin(115200);
    
      WiFi.mode(WIFI_AP);
      WiFi.softAP("Wemos_AP", "Wemos_comm");
      WiFi.softAPConfig(IP, IP, mask);
      server.begin();
      pinMode(ledPin, OUTPUT);
    
      Serial.println();
      Serial.println("accesspoint_bare_01.ino");
      Serial.println("Server started.");
      Serial.print("IP: ");     Serial.println(WiFi.softAPIP());
      Serial.print("MAC:");     Serial.println(WiFi.softAPmacAddress());
    }
    
    void loop()
    {
    
      aktMillis = millis();
      if (aktMillis - prevMillis >= 100)
      {
        prevMillis = aktMillis;
        Serial.print("LED schalten auf ");
        if (ledStatus)
        {
          Serial.println("An");
          befehl[0] = 1;
        }
        else
        {
          Serial.println("Aus");
          befehl[0] = 0;
        }
        Udp.beginPacket(remoteIP, remotePort);
        Udp.write(befehl, 1);
        Udp.endPacket();
        ledStatus = !ledStatus;
      }
    
      WiFiClient client = server.available();
      if (!client) {
        return;
      }
      byte request = client.read();
      Serial.println("********************************");
      Serial.print("From the station: ");
      Serial.println(request);
      client.flush();
    
    }
    
    void blinken (void)
    {
    
      unsigned long currentMillis_rt = millis();  // aktueller Wert rot
      if (currentMillis_rt - previousMillis_rt > interval_rt)
      {
        previousMillis_rt = currentMillis_rt;   // aktuellen Wert speichern
        ledState_rt = ((ledState_rt == LOW) ? HIGH : LOW); // toggeln
        digitalWrite(ledPin_rt, ledState_rt);   // LED ansteuern
      }
    }
    client mit UDP slave:

    Code:
    #include <ESP8266WiFi.h>
    #include <WiFiUdp.h>
    
    const int ledPin_rt =  D5;
    const int ledPin_gn =  D6;
    const int ledPin_bl =  D7;
    
    int ledState_rt = LOW;
    int ledState_gn = LOW;
    int ledState_bl = LOW;
    
    long previousMillis_rt = 0;        
    long previousMillis_gn = 0;       
    long previousMillis_bl = 0;
    
    long interval_rt = 100;           
    long interval_gn = 250;
    long interval_bl = 50;
    
    //Variablen deklarieren
    //######################################
    byte ledPin = 2;         //2           // Interne LED vom ESP 8266 Modul
    byte Taster = 4;                    // GPIO 4 wird mit einem Taster beschaltet
    byte temp, memo = 0;                // Merker für Tasterstatus & Hilfsmerker
    char ssid[] = "Wemos_AP";           // SSID of your AP
    char password[] = "Wemos_comm";         // password of your AP
    
    IPAddress server(192, 168, 4, 15);  // IP address of the AP
    WiFiClient client;
    
    WiFiUDP Udp;
    unsigned int localUdpPort = 4210;  // local port to listen on
    char befehl[10];  // buffer for incoming packets
    boolean ledStatus = false;
    
    
    //Setup
    //######################################
    void setup()
    {
      pinMode(ledPin_rt, OUTPUT);
      pinMode(ledPin_gn, OUTPUT);
      pinMode(ledPin_bl, OUTPUT);
    
    
      Serial.begin(115200);
      pinMode(ledPin, OUTPUT);
      pinMode(Taster, INPUT_PULLUP);
    
      //Inizialisiere WIFI
      //######################################
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);
    
      Serial.println();
      Serial.println("Connection to the AP");
    
      while (WiFi.status() != WL_CONNECTED) {
        Serial.print(".");
        delay(500);
      }
      Serial.println();
      Serial.println("Connected");
      Serial.println("station_bare_01.ino");
      Serial.print("LocalIP:"); Serial.println(WiFi.localIP());
      Serial.println("MAC:" + WiFi.macAddress());
      Serial.print("Gateway:"); Serial.println(WiFi.gatewayIP());
      Serial.print("AP MAC:"); Serial.println(WiFi.BSSIDstr());
    
      Udp.begin(localUdpPort);
      Serial.print(" connected. UDP-Server bereit an IP: ");
      Serial.println(WiFi.localIP());
      Serial.println("UDP-Server bereit.");
    
    }
    
    
    //Daten an AP senden
    //######################################
    void data_to_AP (byte temp) {
      client.connect(server, 80);
      digitalWrite(ledPin, LOW);
      Serial.println("********************************");
      Serial.print("Byte sent to the AP: ");
      Serial.println(temp);
      Serial.println(client.write(temp));
      client.flush();
      digitalWrite(ledPin, HIGH);
      client.stop();
    }
    
    
    //HAUPTPROGRAMM
    //######################################
    void loop()
    {
    
      int packetSize, len;
      // 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(befehl, 10);
        ledStatus = befehl[0]; // erstes Byte 0 oder 1
        if (ledStatus) 
        {
          //digitalWrite(LED, HIGH);
          digitalWrite(ledPin_rt, HIGH);
          Serial.println("LED einschalten");
        }
        else {
          //digitalWrite(LED, LOW);
          digitalWrite(ledPin_rt, LOW);
          Serial.println("LED ausschalten");
        }
      }
      
      /*
      temp = digitalRead(Taster);
    
    
      if (temp == LOW & memo == LOW)
      {
        Serial.print("TASTER: LOW   ");
        Serial.println(temp);
        memo = HIGH;
        data_to_AP(temp);
        Serial.println("********************************");
        Serial.println("********************************");
        Serial.println("");
    
    
      } else if (temp == HIGH & memo == HIGH)
      {
        Serial.print("TASTER: HIGH   ");
        Serial.println(temp);
        memo = LOW;
        data_to_AP(temp);
        Serial.println("********************************");
        Serial.println("********************************");
        Serial.println("");
    
      }
      delay(500);
      */
    }
    
    void blinken (void)
    {
    
      unsigned long currentMillis_rt = millis();  // aktueller Wert rot
      if (currentMillis_rt - previousMillis_rt > interval_rt)
      {
        previousMillis_rt = currentMillis_rt;   // aktuellen Wert speichern
        ledState_rt = ((ledState_rt == LOW) ? HIGH : LOW); // toggeln
        digitalWrite(ledPin_rt, ledState_rt);   // LED ansteuern
      }
    }
    gruß inka

  3. #53
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    76
    Beiträge
    2.180
    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

    mit der korrespondenz in einer richtung mit UDP funktioniert es, die LED wird an- und ausgeschaltet. Für das versenden des echos zurück habe ich diesen
    Code:
    void echo_senden()
    {   
        if (Udp.parsePacket()) 
        {
            // Fetch received message
            int len=Udp.read(udp_buffer,sizeof(udp_buffer)-1);
            udp_buffer[len] = 0;
                    
            // Display the message
            Serial.print(F("Received from "));
            Serial.print(Udp.remoteIP());
            Serial.print(":");
            Serial.print(Udp.remotePort());
            Serial.print(": ");
            Serial.println(udp_buffer);
            
            // Send echo back
            Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
            Udp.print(F("Echo: "));
            Udp.print(udp_buffer); 
            Udp.endPacket();
        }    
    }
    da Du ja schon UDP-erfahrungen hast, kannst Du mir bitte ein wenig auf die sprünge helfen wie das mit der registration des echos auf der gegenseite funktioniert? Da komme ich nicht so recht weiter
    gruß inka

  4. #54
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.643
    Zitat Zitat von inka Beitrag anzeigen
    wie das mit der registration des echos auf der gegenseite funktioniert?
    Wenn das Paket angekommen ist schickst Du es zurück, was Du gemacht hast. Kommt es nicht wieder zurück oder was meinst Du?

    MfG

  5. #55
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    76
    Beiträge
    2.180
    Zitat Zitat von Moppi Beitrag anzeigen
    Wenn das Paket angekommen ist schickst Du es zurück, was Du gemacht hast. Kommt es nicht wieder zurück oder was meinst Du?

    MfG
    ich nehme an, dass das echo verschickt wird, nur weiss ich nicht wie ich es auf der gegenseite feststellen soll ob es auch angekommen ist...
    gruß inka

  6. #56
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.643
    Ich würde denken, genau so, wie sonst auch. Mit .parsePacket()
    Lesen dann mit .read()

    Du hast doch auf dem Client alles dafür angelegt:

    Code:
    WiFiUDP Udp;
    unsigned int localUdpPort = 4210;  // local port to listen on 
    char befehl[10];  // buffer for incoming packets
    
    .read(befehl,sizeof(befehl)-1);


    ???

  7. #57
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    76
    Beiträge
    2.180
    wäre es also so etwas:

    Code:
      int packetSize, len;
      // 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(befehl, 10);
        ledStatus = befehl[0]; // erstes Byte 0 oder 1
        if (ledStatus) 
        {
          //digitalWrite(LED, HIGH);
          digitalWrite(ledPin_rt, HIGH);
          Serial.println("LED einschalten");
        }
        else {
          //digitalWrite(LED, LOW);
          digitalWrite(ledPin_rt, LOW);
          Serial.println("LED ausschalten");
        }
    ist demnach also der empfang eines UDP pakets auf beiden seiten (server und client) gleich?
    gruß inka

  8. #58
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.643
    Wenn Du zum Verschicken des UDP-Paketes WIFIClient verwendest, solltest Du auch damit empfangen können.
    Um das abkürzen, hier ist eine Doku: https://arduino-esp8266.readthedocs....rom-the-server

    interessant wird dann dieser Abschnitt sein:

    Code:
    if (client.available())
      {
        String line = client.readStringUntil('\n');
        Serial.println(line);
      }

    Ich habe das in der Form: Senden und dann wieder Empfangen auf einem nodeMCU, noch nicht ausprobiert. Ich habe bisher nur empfangen und zurückgesendet. Mehr brauchte ich nicht. Für weiteres muss ich mich damit beschäftigen.

    Die Zeile mit: Serial.println(line)
    musst Du nat. ersetzen durch einen Vergleich, ob das Zeichen oder die Zeichen angekommen ist oder sind, das oder die Du gesendet hast.


    MfG

    - - - Aktualisiert - - -

    Allerdings, kann man mit WIFIClient UDP-Pakete verschicken?

    Wozu nutzt Du:

    Code:
    WiFiClient client;
    
    ??

    Ich werde das mal selber ausprobieren. Mal sehen..

    MfG

    - - - Aktualisiert - - -

    ------------------------------------------------------------------------
    Nochmal ein Anlauf.

    Ich habe das eben schnell selbst zusammengwürfelt.
    Ausgehend davon, dass es ein nodeMCU gibt, das als Zugriffspunkt und Server funktioniert und die ankommende Nachricht auch zurückschickt,
    wäre das mein (nicht verifizierter Code), mit dem ich eine Nachricht dort hin schicke und auch anschließend empfange:

    Code:
    void loop() 
    {
      send = 0;
      if (udp.beginPacket(IPAddress(192,168,0,64),50000)==1)
      {
        udp.write("%"); 
        udp.endPacket();
        send=1;
      }
      
      if (send==1 && udp.parsePacket()) {
        // Nachricht abholen
              int len=udp.read(udp_buffer,sizeof(udp_buffer)-1);
              udp_buffer[len] = 0;
              if (strstr(udp_buffer, "%")){
               ....  //alles andere hier, wenn das angekommene Zeichen (können auch mehrere sein) dem Versendeten entspricht   
              }
      }
    Entscheidend ist jetzt nicht, ob der Code so funktioniert oder auch etwas anders. Aber die Reihenfolge:

    Senden der Daten mit:
    - udp.beginPacket
    - udp.write()
    - udp.endPacket()

    Dann warten bis was zurück kommt, mit:

    - if(udp.parsePacket()){...}

    und lesen der Daten mit:

    - udp.read(udp_buffer,sizeof(udp_buffer)-1);
    Geändert von Moppi (05.07.2020 um 10:50 Uhr)

  9. #59
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    76
    Beiträge
    2.180
    thx, Moppi,

    das wesentliche - meldung und rückmeldung in verständlichen und auf dem fahrrad auch "erfahrbaren" signalen - funktioniert nun. hier der AP
    Code:
    #include <ESP8266WiFi.h>
    #include <WiFiUdp.h>
    
    const int ledPin_rt =  D5;
    const int ledPin_gn =  D6;
    const int ledPin_bl =  D7;
    
    int ledState_rt = LOW;
    int ledState_gn = LOW;
    int ledState_bl = LOW;
    
    //int LED_rt = LOW;
    
    long previousMillis_rt = 0;
    long previousMillis_gn = 0;
    long previousMillis_bl = 0;
    
    long interval_rt = 100;
    long interval_gn = 250;
    long interval_bl = 50;
    
    WiFiServer server(80);
    IPAddress IP(192, 168, 4, 15);
    IPAddress mask = (255, 255, 255, 0);
    
    //adresse vom slave
    IPAddress remoteIP(192, 168, 4, 114);
    
    // remote port to listen on
    unsigned int remotePort = 4210;
    
    char befehl[10];
    
    WiFiUDP Udp;
    
    uint32_t aktMillis;
    uint32_t prevMillis;
    
    boolean ledStatus = false;
    
    char udp_buffer[WIFICLIENT_MAX_PACKET_SIZE + 1];
    
    void setup()
    {
    
      pinMode(ledPin_rt, OUTPUT);
      pinMode(ledPin_gn, OUTPUT);
      pinMode(ledPin_bl, OUTPUT);
    
      Serial.begin(115200);
    
      //Inizialisiere WIFI
      WiFi.mode(WIFI_AP);
      WiFi.softAP("fahrrad_echo", "12345678");
      WiFi.softAPConfig(IP, IP, mask);
    
      digitalWrite(ledPin_bl, HIGH);
      delay(500);
    
      server.begin();
    
      Serial.println();
      Serial.println("accesspoint_fahrrad_echo");
      Serial.println("Server started.");
      Serial.print("IP: ");     Serial.println(WiFi.softAPIP());
      Serial.print("MAC:");     Serial.println(WiFi.softAPmacAddress());
    }
    
    void loop()
    {
    
      // schalten der LEDs auf dem client
      aktMillis = millis();
      digitalWrite(ledPin_bl, LOW);
      if (aktMillis - prevMillis >= 500)
      {
        prevMillis = aktMillis;
        Serial.print("LED schalten auf ");
        if (ledStatus)
        {
          Serial.println("An");
          befehl[0] = 1;
        }
        else
        {
          Serial.println("Aus");
          befehl[0] = 0;
        }
        Udp.beginPacket(remoteIP, remotePort);
        Udp.write(befehl, 1);
        Udp.endPacket();
        ledStatus = !ledStatus;
      }
    
      WiFiClient client = server.available();
      if (!client)
      {
        return;
      }
    
      //schalten der LEDs auf dem server (echo empfang)
      byte request = client.read();
      Serial.println("********************************");
      Serial.print("From the station: ");
      Serial.println(request);
      client.flush();
    
      if ((request == 1) || (request == 255))
      {
        digitalWrite(ledPin_rt, LOW);
        digitalWrite(ledPin_gn, LOW);
        delay(100);
        // LED_rt = LOW;
      }
    
      digitalWrite(ledPin_gn, LOW);
      delay(100);
      //LED_rt = LOW;
    
      //if (LED_rt == LOW)
      {
        digitalWrite(ledPin_gn, HIGH);
        digitalWrite(ledPin_rt, LOW);
      }
    }
    
    void rt_blinken (void)
    {
    
      unsigned long currentMillis_rt = millis();  // aktueller Wert rot
      if (currentMillis_rt - previousMillis_rt > interval_rt)
      {
        previousMillis_rt = currentMillis_rt;   // aktuellen Wert speichern
        ledState_rt = ((ledState_rt == LOW) ? HIGH : LOW); // toggeln
        digitalWrite(ledPin_rt, ledState_rt);   // LED ansteuern
      }
    }
    und hier der client
    Code:
    #include <ESP8266WiFi.h>
    #include <WiFiUdp.h>
    
    const int ledPin_rt =  D5;
    const int ledPin_gn =  D6;
    const int ledPin_bl =  D7;
    
    int ledState_rt = LOW;
    int ledState_gn = LOW;
    int ledState_bl = LOW;
    
    long previousMillis_rt = 0;
    long previousMillis_gn = 0;
    long previousMillis_bl = 0;
    
    long interval_rt = 100;
    long interval_gn = 250;
    long interval_bl = 50;
    
    //Variablen deklarieren
    byte echoPin = 4;                    // GPIO 4 wird mit einem "echoPin" beschaltet
    byte temp, memo = 0;                // Merker für echoPin status & Hilfsmerker
    char ssid[] = "fahrrad_echo";           // SSID of your AP
    char password[] = "12345678";         // password of your AP
    
    IPAddress server(192, 168, 4, 15);  // IP address of the AP
    WiFiClient client;
    
    WiFiUDP Udp;
    unsigned int localUdpPort = 4210;  // local port to listen on
    char befehl[10];  // buffer for incoming packets
    boolean ledStatus = false;
    
    char udp_buffer[WIFICLIENT_MAX_PACKET_SIZE + 1];
    
    
    void setup()
    {
      pinMode(ledPin_rt, OUTPUT);
      pinMode(ledPin_gn, OUTPUT);
      pinMode(ledPin_bl, OUTPUT);
    
    
      Serial.begin(115200);
      
      pinMode(echoPin, INPUT_PULLUP);
    
      digitalWrite(ledPin_bl, HIGH);
      delay(500);
      digitalWrite(ledPin_bl, LOW);
      digitalWrite(ledPin_rt, LOW);
    
      //Inizialisiere WIFI
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);
    
      Serial.println();
      Serial.println("Connection to the AP");
    
      while (WiFi.status() != WL_CONNECTED)
      {
        Serial.print(".");
        delay(500);
      }
      Serial.println();
      Serial.println("Connected");
      Serial.println("station_bare_01.ino");
      Serial.print("LocalIP:"); Serial.println(WiFi.localIP());
      Serial.println("MAC:" + WiFi.macAddress());
      Serial.print("Gateway:"); Serial.println(WiFi.gatewayIP());
      Serial.print("AP MAC:"); Serial.println(WiFi.BSSIDstr());
    
    
      //Inizialisiere UDP
      Udp.begin(localUdpPort);
      Serial.print(" connected. UDP-Server bereit an IP: ");
      Serial.println(WiFi.localIP());
      Serial.println("UDP-Server bereit.");
    }
    
    
    //Daten an AP senden
    void data_to_AP (byte temp)
    {
      client.connect(server, 80);
    
      Serial.println("********************************");
      Serial.print("Byte sent to the AP: ");
      Serial.println(temp);
      Serial.println(client.write(temp));
      client.flush();
      client.stop();
    }
    
    
    void loop()
    {
      digitalWrite(ledPin_rt, LOW);
    
      int packetSize, len;
    
      // 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(befehl, 10);
        ledStatus = befehl[0]; // erstes Byte 0 oder 1
        if (ledStatus)
        {
          digitalWrite(ledPin_rt, LOW);
          digitalWrite(ledPin_gn, LOW);
          Serial.println("LED einschalten");
          //LED_rt = LOW;
          taste_druecken();
        }
        else
        {
          digitalWrite(ledPin_rt, LOW);
          digitalWrite(ledPin_gn, LOW);
          Serial.println("LED ausschalten");
          //LED_rt = LOW;
          taste_loslassen();
        }
      }
      
      {
        digitalWrite(ledPin_gn, HIGH);
        digitalWrite(ledPin_rt, LOW);
      }
    }
    
    
    void taste_druecken (void)
    {
      //digitalWrite(ledPin_rt, LOW);
      digitalWrite(echoPin, HIGH);
      temp = digitalRead(echoPin);
      data_to_AP(temp);
      Serial.println(temp);
    }
    
    void taste_loslassen (void)
    {
      //digitalWrite(ledPin_rt, LOW);
      digitalWrite(echoPin, LOW);
      temp = digitalRead(echoPin);
      data_to_AP(temp);
      Serial.println(temp);
    }
    
    void rt_blinken (void)
    {
    
      unsigned long currentMillis_rt = millis();  // aktueller Wert rot
      if (currentMillis_rt - previousMillis_rt > interval_rt)
      {
        previousMillis_rt = currentMillis_rt;   // aktuellen Wert speichern
        ledState_rt = ((ledState_rt == LOW) ? HIGH : LOW); // toggeln
        digitalWrite(ledPin_rt, ledState_rt);   // LED ansteuern
      }
    }
    und das video...
    gruß inka

  10. #60
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.643
    Ich finde sehr verwirrend, dass Du einmal WiFiClient verwendest und einmal UDP. Schickst Du mit WiFiClient Daten hin, um die per UDP zurück zu schicken? Dann würde ich nur UDP verwenden und WiFiClient rauswerfen.

    - - - Aktualisiert - - -

    Habe gerade mal rein geschaut in den anderen Code. In der Tat liest Du Daten per WiFiClient, um sie dann mit anderer Bibliothek per UDP zu verschicken.

Seite 6 von 10 ErsteErste ... 45678 ... LetzteLetzte

Ähnliche Themen

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

Berechtigungen

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

LiTime Speicher und Akkus