abstandhalten mit 433MHz

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

[inka]

ich weiss nicht wieviel ich von dem code überhaupt verstanden habe.
Tatsache ist:
- beide teile sind in einem wlan (vielleicht deshalb wifi client/server?)
- verbindungen, bzw. signalwege die ich brauche um den kontakt zwischen den beiden modulen zu bestätigen - oder eben den abbruch - müssten eigentlich über UDP laufen...
aus meinem ersten satz müsste schon sehr deutlich hervorgehen, dass ich nichts ändern werde, weil ich eben nicht weiss was.

[Moppi]

Hier eine Übersicht mit Beschreibung für die UDP-Klasse.

MfG

[inka]

danke für den link...

Zusatz zu meinem gestrigen post:

Ich war gestern vielleicht etwas unhöflich, sorry. Habe trotzdem nicht vor den code zu ändern, der code ist nicht selbstzweck und muss m.e. nach nicht perfekt sein - er erfüllt den zweck, nämlich die abstandsüberwachung zwischen zwei sich bewegenden objekten zu realisieren...
Und - manchmal ist echte hilfe mehr als die. sog. hilfe zu selbsthilfe - googeln kann ich auch...

[Moppi]

Musst Du selber wissen, ob Du das so beibehältst. Client ist eben normalerweise für HTTP-Geschichten gedacht. Das Schlimmste was passieren kann ist, dass Du zum einen unnötig viel Code im Speicher hast, dass Du unnötig viele Daten verschickst, weil evtl. ein HTTP-Header mitgeschickt wird (das habe ich aber nicht überprüft).

googeln kann ich auch

Dafür muss man wissen, wonach man sucht, deshalb ist selbst das manchmal nicht so einfach gemacht.

MfG

[inka]

gestern habe ich noch weitere tests durchgeführt:

- nur mit den grossen antennen sind die gewollten 100m+ zu erreichen
- bei direkter sicht sind es auch schon mal 130m
- wenn eines der module "abbiegt" und hinter einem haus verschwindet, hören beide module unmittelbar zu blinken auf und gehen auf dauersignal
- bei erneuter annäherung findet ein automatisches reconnect bei ca. 90m statt, auch wenn eines der module noch nicht direkt sichtbar ist

alles in allem bin ich zufrieden mit dem erreichten...

[Rabenauge]

2.4GHz ist insgesamt ziemlich ungeeignet für grössere Entfernungen.
Die Hersteller von RC-Modellfernsteuerungen (die dann ohne weiteres mehr als nen Km überbrücken können) arbeiten da mit allen möglichen Tricks, damit das klappt.

Was aber bleibt: schon ein lausiger Baum kann die Verbindung komplett unterbrechen.
2cm Wasser über der Antenne auch.
Die Ausbreitungsbedingungen solcher kurzen Funkwellen sind einfach mies, daran ist nichts zu ändern.
Vermutlich brauchst du deswegen die grösseren Antennen, damits überhaupt gescheit klappt.
Ich hab neulich im Job ein Funk-Überwachungskamera-System aufgebaut, die Gurken schafften nicht mal 15m im Freien bei direkter Sichtverbindung. Bei den Dingern waren auch noch die Antennenanschlüsse linksrum, damit man die ja nich einfach austauschen kann *grummel