abstandhalten mit 433MHz

Ist doch gut! Es gibt viele solcher Beispiele im Netz.

MfG

diese antennen habe ich getestet:
Anhang 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
  }
}

---

Zitat:

---

Zitat von Moppi

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 :-(

Zitat:

---

Zitat von inka

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

Zitat:

---

Zitat von Moppi

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...

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);


???

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?

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);

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...

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.