abstandhalten mit 433MHz

[Moppi]

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

[inka]

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?

[Moppi]

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

[inka]

ok, danke für den link...

habe heute den ersten test auf dem rad durchgeführt



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

[Moppi]

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/

[inka]

thx, Moppi,

das wesentliche - meldung und rückmeldung in verständlichen und auf dem fahrrad auch "erfahrbaren" signalen - funktioniert nun. hier der AP

#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

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

[Moppi]

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.