Archiv verlassen und diese Seite im Standarddesign anzeigen : abstandhalten mit 433MHz
hallo allerseits,
diese hardware habe ich:
35080 oder auch diese:
35081
es soll eine kombination aus einem sender und empfänger geben, davon zwei stück...
Aufgaben:
- abstand "regeln" zwischen 50 und 200m (sind nur hausnummern), beim überschreiten der maximalen entfernung soll eine grüne, blinkende LED von einer roten ersetzt werden
- laden des lipo akku über die USB buchse
- evtl. ein emergency knopf, der auf der anderen seite ein notfall signalisiert
als ein sender und empfänger als eigenständige module hatte ich es schon, es geht mir hier um die zwei gleiwertige gegenstellen, geht das überhaupt mit der identischen frequenz?
piggituX
16.06.2020, 18:26
Hi,
da ich gerade an einer 433 Mhz Verbindung arbeite, kann ich schon mal sagen die obere Kombi ist leider murks, ich habe mir eine 433 Mhz Mp3 Klingel gebaut und die Verbindung geht immer verloren, also ist nicht konstant.... dann habe ich mir RBX6 Empfänger geholt die funktionieren besser (also Sender ist ok, aber Empfänger sollte ein RBX6 ,RBX8, usw sein). Ardunio nano + 433 Mhz + dfmini player und dazu nen Ardunio nano + 433 Mhz Sender mit Taster.
am Ende musst du halt schauen, auf was welcher Signale der Receiver reagieren soll. ich hoffe für meinen fall das mehrere empfänger auf den Sender hören, hab mich dazu aber noch nicht genau belesen.
Rabenauge
17.06.2020, 07:02
Wie willst du mit ner Funkstrecke einen Abstand ermitteln?
Mit _einem_ Sender und einem Empfänger kannst du maximal die Entfernung detektieren, bei der das Signal abbricht (oder nich mehr lesbar ankommt).
Das funktioniert, aber auch nicht auf ne feste Entfernung- weil sich Funkwellen je nach Örtlichkeit weit oder eben nicht so weit ausbreiten.
Aber schon nen Mindestabstand wirst du damit nicht hinkiegen.
eigentlich dachte ich daran das signal analog auszuwerten. Ist es denn so konstant bis zum abbruch? Fallen Dir alternativen ein? Die entfernungszahlen waren nur als anhaltspunkt gedacht, es geht im wesentlichen darum einen kontakt zwischen zwei radfahrern aufrecht zu erhalten - oder eben nicht...
EDIT: angenommen bei einem abstand von 200m würde die toleranz bei einem signalabbruch bei +/- 20m völlig ausreichend sein...
ich würde ganz anders vorgehen, nur als unverbindlicher Hinweis:
Funkverbidung über LoRa,
beide Stationen haben ein eigenes GPS,
beide senden ihre GPS-Position wechselweise an die jew. andere Station.
Entfernung = Differenz der geometrischen Koordinaten-Punkte (Haversine Algorithmus).
#define d2r (M_PI / 180.0)
//calculate haversine distance for linear distance
double dist( double lat1, double lat2, double long1, double long2 )
{
double dlong = (long2 - long1) * d2r;
double dlat = (lat2 - lat1) * d2r;
double a = pow(sin(dlat/2.0), 2) + cos(lat1*d2r) * cos(lat2*d2r) * pow(sin(dlong/2.0), 2);
double c = 2 * atan2(sqrt(a), sqrt(1-a));
double d = 6371 * c;
return d;
}
edit: kann man stark vereinfachen für kurze Entfernungen per einfacher 2D-Trigonometrie
Mit GPS-Distanzberechnungen habe ich schon gearbeitet (aber nur über BT-Module), mit Lora bisher selber noch keine Erfahrung.
ich würde ganz anders vorgehen, nur als unverbindlicher Hinweis:
Funkverbidung über LoRa, beide Stationen haben ein eigenes GPS,
beide senden ihre GPS-Position wechselweise an die jew. andere Station.
Entfernung = Differenz der geometrischen Koordinaten-Punkte (Haversine Algorithmus).
man kennst sich inzwischen ein bischen :-)
Du meinst bestimmt das hier:
https://www.antratek.de/dragino-lora-gps-shield-868mhz?gclid=CjwKCAjw_qb3BRAVEiwAvwq6VucwpXAaJx3Nj icjGVWBXTZm5yAT9hSTPriPZxhSga9haM8pl7D94xoCLUoQAvD _BwE
und nicht das hier:
https://www.ebay.de/itm/433-LoRa-SX1278-Mini-Range-RF-Wireless-Transceiver-Module-SX1276-5Km-For-Arduino-/183690843608
wenn 1, dann sprengt das definitiv die mittel die mir dafür zur verfügung stehen...
Mir reicht es völlig, wenn meine frau, die meistens vorne weg fährt irgendwann mal merkt - da blinkt was rot - ich hab meinen mann verloren - aber keine vollbremsung...
Es ist egal ob sie es 50 meter früher oder später merkt :-)
jein, ich würde einen esp32 mit on-board Lora nehmen
edit:
so etwas ähnliches, gibt es sicher inzwischen auch noch billiger:
https://www.ebay.de/itm/ESP32-LoRa-IOT-868MHz-915MHz-SX1276-OLED-Module-Wifi-Bluetooth-Development-Board/263840693823?hash=item3d6e217e3f:g:UzsAAOSwm1dd6H9 C
https://www.ebay.de/itm/SX1276-868MHz-915MHz-ESP32-LoRa-Bluetooth-WIFI-Kit-IOT-Entwicklung-Tafel-A2TD/174291017952?hash=item28948de0e0:g:BUcAAOSwMQBaHDg Z
Mir reicht es völlig, wenn meine frau, die meistens vorne weg fährt irgendwann mal merkt - da blinkt was rot
Man könnte dann auch was ganz Einfaches versuchen:
2x nodeMCU ESP-12E bspw.
Das eine nodeMCU stellt einen Server/Zugriffspunkt zur Verfügung und das zweite meldet sich daran an.
nodeMCUs haben eine Reichweite vermutlich 4 bis 10m im Freien. Wenn es auch nur ~4m wären, dann würde zwischen beide Fahrer ein drittes Rad dazwischen passen oder ein Auto, dann würde der Vordermann bemerken, dass der Hintermann nicht mehr direkt an einem dran ist. Wären es 10 bis 20m Reichweite im Freien, wäre das auch brauchbar. 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.
Mit Funk würde das ähnlich funktionieren. Nur muss der Funk in der Reichweite begrenzt bzw. bekannt sein.
Hier ein Beispiel mit 433MHz: https://funduino.de/nr-03-433mhz-funkverbindung
Dort steht: Reichweite einige Meter, kann über Antennengröße variiert werden.
MfG
Man könnte dann auch was ganz Einfaches versuchen:
2x nodeMCU ESP-12E bspw.
Das eine nodeMCU stellt einen Server/Zugriffspunkt zur Verfügung und das zweite meldet sich daran an.
nodeMCUs haben eine Reichweite vermutlich 4 bis 10m im Freien.
das reicht von der entfernung her nicht, da kann man zur not auch noch laut schreien oder klingeln, es müssten schon um die 100m sein..
Mit Funk würde das ähnlich funktionieren. Nur muss der Funk in der Reichweite begrenzt bzw. bekannt sein.
Hier ein Beispiel mit 433MHz: https://funduino.de/nr-03-433mhz-funkverbindung
Dort steht: Reichweite einige Meter, kann über Antennengröße variiert werden.
genau die seite habe ich auch gefunden, die sketches kann man sicher an meine vorstellungen anpassen :-) , da steht auch dass man die reichweite über die spannung vergrössern kann, da bin ich aber von der grösse her schon an die lipos mit ihren 3,7V festgelegt...
Wie ist es eigentlich mit dem laden der akkus? Die differenz 3.7 zu 5V - macht es was, oder kann man die einfach wie verbundene gefässe "zusammenbinden"? Sicher nicht die sauberste methode, aber einfach. Die akkus müssen ja auch nicht jahrzehnte halten...
Zellen kannst Du auch in Reihe schalten, nur besser beim Aufladen nicht. Kannst Du noch so ein Teil (LM 1085 IT-ADJ (https://www.reichelt.de/ldo-spannungsregler-einstellbar-1-25-27-5-v-3-a-to-220-3-lm-1085-it-adj-p187586.html?&trstct=pos_12&nbc=1)) dazu nehmen, dann kannst Du die Spannung einstellen. Vielleicht gleich dann einen 3s-LiPo nehmen. Habe aber auch keine Angabe gefunden, welchen Strom das Sendemodul benötigt (wegen dem Akku). Hast Du mal gemessen?
entschuldige Moppi, aber das ist doch alles viel zu kompliziert. Hier der akku mit ladegerät:
35084
am ladegerät-ausgang liegt die USB spannung an, im stecker ist noch eine LED die leuchtet, wenn ein akku dran ist und erlischt wenn der akku aufgeladen ist...
Die 433mhz module sind für eine spannung von 2,5 bis 12V konzipiert und verbrauchen 3,5mA. Der akku hat 380mAh, will heissen, der ist nach ca. 100h leer. Alles was ich wollte, ist das ladegerät weglassen. Am 5V USB-netzteil über die mini-USB buchse des nano anschliessen, 3h laden und wieder 100h anwenden...
Wenn Du nur einen 1-Zellen-LiPo-Ladeanschluss hast, kannst Du nur 1 Zelle laden. Nur hast Du doch schon gesagt, dass Du nur 3.7V dann hast. Wie hoch ist denn die Reichweite damit und wie hoch, wenn Du eine 20cm-Antenne dran machst? Wenn Du denkst, die eine Zelle hält so lange, dann nimm einen DC/DC-Wandler, den kannst Du auch auf eine Spannung einstellen, muss nur größere Spannung ausgeben können, als am Eingang vorhanden ist. Weiß aber nicht, ob die Wandler das Funkmodul stören. Wenn Du die Zellen einzeln lädst, dann nimm Zwei in Reihe, in der Schaltung und laden tust Du sie einzeln. Tut mir leid, mehr fällt mir nicht ein.
MfG
Wenn Du nur einen 1-Zellen-LiPo-Ladeanschluss hast, kannst Du nur 1 Zelle laden. Nur hast Du doch schon gesagt, dass Du nur 3.7V dann hast. Wie hoch ist denn die Reichweite damit und wie hoch, wenn Du eine 20cm-Antenne dran machst das weiss ich ja noch gar nicht, bin erst beim aufbauen...
piggituX
17.06.2020, 22:02
HI,
andere Idee über 2 WEMOS D1 Mini Pro und dann Server / Client Kombi und die SignalStärke als Grundlage nehmen ?
habe hier mal ein Testaufbau gemacht,
wollte ich für nen anderes Projekt nutzen für WLAN APs zur Positionsbestimmung.
35086 35087
andere Idee über 2 WEMOS D1 Mini Pro und dann Server / Client Kombi und die SignalStärke als Grundlage nehmen ?
das sieht erstmal gut aus, allerdings weiss ich nicht so recht wie ich da meine idee mit der blinkenden grün/rot LED realisieren könnte?
Webserver/client ist doch eher etwas für eine anzeige im smartphone, oder? Oder eine OLED anzeige wie auf Deinen bildern zu sehen ist... Beides ist beim radfahren eher ungünstig (weil zu klein), das habe ich schon beim notgedrungenem ersatz für den "tretsignal"-sensor bei meinem e-bike festgestellt...
Das analoge auswetren des empfangssignals lässt mich auch ein bischen ratlos zurück, abgesehen davon, das das modul offensichtlich nur einen analog pin (A0) hat? Hast Du da evtl. einen link mit code beispielen in der richtung?
piggituX
18.06.2020, 17:54
OLED diente in dem Bild nur als InfoScreen, ich schaue mal ob ich was zusammengetipselt bekomme.
nicht zu viel aufwand treiben, ich schaue mir erstmal die beispiele der ESP8266WiFi lib...
piggituX
18.06.2020, 22:20
alles gut, ich brauch es ja eh für mich :)
so wenn die Familie zur Ruhe kommt, hab ich schnell mal nen Video gedreht.
http://piggitux.ignorelist.com:8085/IMG_6722.MOV
WEMOS D1 Mini + OLED + RGB LED vom Prinzip wäre das ja ne Idee, frage ist nur wie weit du mit der WLAN Verbindung kommst, ich werde mal den AP auf ein RC Car schnallen und mein Sohn damit was wegfahren lassen ;)
Rote LED - kein Connect
Grüne LED - Connect in Range
Blaue LED - Connect und out of Range
WEMOS D1 Mini + OLED + RGB LED vom Prinzip wäre das ja ne Idee, frage ist nur wie weit du mit der WLAN Verbindung kommst, ich werde mal den AP auf ein RC Car schnallen und mein Sohn damit was wegfahren lassen ;)
Rote LED - kein Connect
Grüne LED - Connect in Range
Blaue LED - Connect und out of Range
das ist nicht nur eine idee, das sieht wirklich gut aus! Das war jetzt mit der internen antenne, nehme ich an...
piggituX
19.06.2020, 10:49
ja korrekt, für diesen Test hatte ich einen WEMOS D1 Mini mit fester interner Antenne benutzt, ich werde den Test aber nochmal mit 2 anderen WEMOS D1 Minis mit einer externen Antenne durchführen, so wie das Eingangsbild mit dem LIPO , das ist einer wo man eine externe Antenne dranpömpeln kann.
z.B.
https://de.banggood.com/Geekcreit-D1-Mini-Pro-16-Module-ESP8266-Series-WiFi-Wireless-Antenna-p-1144951.html (https://de.banggood.com/Geekcreit-D1-Mini-Pro-16-Module-ESP8266-Series-WiFi-Wireless-Antenna-p-1144951.html)
https://de.banggood.com/D1-mini-V2_2_0-WIFI-Internet-Development-Board-Based-ESP8266-4MB-FLASH-ESP-12S-Chip-p-1143874.html
das reicht von der entfernung her nicht, da kann man zur not auch noch laut schreien oder klingeln, es müssten schon um die 100m sein..
Das war das Problem bei den nodeMCU und ändert sich mit einem WEMOS MINI D1 vermutlich nicht.
Was die Reichweite anbelangt habe ich noch was gefunden:
ESP12 ohne externe Antenne schafft knapp 10m durch zwei Wände, draussen (https://www.mikrocontroller.net/topic/366833#4130614) sind es so um die 30-40m mit noch akzeptabler Signalstärke. (https://www.mikrocontroller.net/topic/366833#4130614)
Also wird es wohl eine zusätzliche Antenne brauchen.
Hatte auch was gefunden, die Reichweite zu erhöhen: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/pimp-my-mini
MfG
im video kann man (ich?) erkennen, dass es sich bei der RGB-led um eine mit einer gemeinsamer kathode handelt. Kann man auch eine mit einer gemeinsamer anode verwenden?
- - - Aktualisiert - - -
Hatte auch was gefunden, die Reichweite zu erhöhen: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/pimp-my-mini
ja, hatte ich auch gesehen, da wird die externe antenne in eine aufgedruckte interne antenne reingelötet...
hätte auch die antennen für ein test, warte nocht auf die wemos module...
Ich vermute intuitiv, >100m ist grenzwertig. Vielleicht kommst Du zuverlässig auf 50m. Aber mal abwarten...
piggituX
19.06.2020, 19:15
Hi, wie gesagt ich teste nochmal mit externen Antennen, muss mir noch nen 2. wemos zusammenloeten (Steckerleisten) mache ich heute abend und morgen kommt dann der feldversuch 😂
piggituX
21.06.2020, 22:03
so hat doch was gedauert, laut meinen Test sind 100m drin. länger ist meine Strasse leider nicht, aber es war eine gerade Strecke ohne was dazwischen. Nachbarn schauten schon schief, als ich da rumrannte und die LED die Farbe wechselte. ;D, der Sender stand auf dem Dach meines Auto, mit dem, 3,7 V Lipo dran. den Empfänger habe ich mit nem MicroUSB auf 5V bedient.
Datendurchsatz ist bei diesem Test egal bzw. irrelevant, weil ich nur die bestehende Verbindung getestet habe, auch ein Reconnect hat geklappt nach einem Reset, aber dazu musste ich was dichter sein, glaub es war bei 70-80m .
das klingt ja super! Ich hatte es schon gehofft und die gehäuse dafür angefangen zu drucken... jetzt geht's weiter...
danke für deine hilfe :-)
der Sender stand auf dem Dach meines Auto, mit dem, 3,7 V Lipo dran. den Empfänger habe ich mit nem MicroUSB auf 5V bedient.
die 3.7V vom lipo waren an den 3.3V oder 5V?
auch ein Reconnect hat geklappt nach einem Reset, aber dazu musste ich was dichter sein, glaub es war bei 70-80m . würden die beiden module automatisch nach dem unterschreiten der "abbruch"-entfernung wieder kontakt aufnehmen, oder braucht es da einen reset?
piggituX
23.06.2020, 18:28
die 3.7V vom lipo waren an den 3.3V oder 5V?
hi am WEMOS Battery Shield, daher denke ich am 3.3V . müsste man mal nachlesen.
würden die beiden module automatisch nach dem unterschreiten der "abbruch"-entfernung wieder kontakt aufnehmen, oder braucht es da einen reset?
ja das machen Sie automatisch, ist ja eine Sache der Programmierung.
das sind jetzt meine allerersten erfahrungen mit einem wemos D1 mini pro, deshalb schon im voraus sorry für dumme fragen: beim einschalten, egal ob der lipo an den 3.3 oder 5V dran ist, leuchtet nur eine blaue LED kurz auf, dann ist nix mehr...
ist das ok so?
die erste stufe ist geschafft:
elektronik und mechanik ist montiert:
35136 35137 35138
und hier (https://youtu.be/nOpr5ZDRJ1M) kann man sehen, wie die LED blinkt - erstmal mit "blink ohne delay". Bis hierhin war es eigentlich easy - bekanntes terrain, jetzt wird es mit server, client html und co. wahrscheinlich anders...
piggituX
24.06.2020, 16:51
sieht doch schon mal gut aus :D die brücke hattest du umgelötet auf dem WEMOS D1 ?
so sah mein Aufbau aus
http://piggitux.ignorelist.com:8085/IMG_6736.jpg
die brücke zu der externen antenne? ja...
piggituX
24.06.2020, 17:33
dann bin ich mal auf deine Tests gespannt, wie weit du kommst
naja, jetzt erstmal das zweite gehäuse drucken, zusammenbauen und sich mit den beispielen der wifi lib beschäftigen... wird schon ein paar tage dauern...
Wo sollte ich da mit der auswertung der wifi-signalstärke ansetzen? ich blick da noch nicht so richtig durch - wifi server und client sagen mir schon ein bischen was, aber letzetndlich weiss ich nicht viel davon...
Ich wollte eigentlich auch, dass die anzeige der verlorenen verbindung auf beiden seiten gemerkt wird - geht das überhaupt?
Rabenauge
25.06.2020, 06:29
Das ist recht simpel:
https://www.arduino.cc/en/Reference/WiFiRSSI
Das Ergebnis kannst du aufdröseln und an ne RGB-Led (ich würd da ne WS2812 nehmen) schicken, und fertig.
(https://www.arduino.cc/en/Reference/WiFiRSSI)
piggituX
25.06.2020, 20:15
genauso hab ich es gemacht. ich habe festgstellt wenn du 31DB hast, dann ist die Verbindung getrennt worden.
void loop() { rssi = WiFi.RSSI(); // eg. -63
// Draw the RSSI eg. -63db
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(20,2);
display.print(rssi);
display.println("dB");
display.display();
// miniature bitmap display
display.drawBitmap(54, 0, wlan100_10, 10, 10, 1);
display.display();
if (rssi = 31) {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
}
else {
digitalWrite(RED_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
}
delay(1000); // Adjust this to change graph speed
}
hi,
danke erstmal für die tipps :-)
ich bin jetzt weitergekommen, mechanisch und elektronisch sind die beiden module fertig, der code sieht so aus:
client
#include <ESP8266WiFi.h> // Include the Wi-Fi library
const int ledPin_rt = D5;
const int ledPin_gn = D6;
const int ledPin_bl = D7;
uint8_t schalter = LOW;
int ledState_rt = LOW; // LED-Status
int ledState_gn = LOW;
int ledState_bl = LOW;
const char* ssid = "fahrrad-echo-server";
const char* password = "12345678";
void setup()
{
pinMode(ledPin_rt, OUTPUT);
pinMode(ledPin_gn, OUTPUT);
pinMode(ledPin_bl, OUTPUT);
digitalWrite (ledPin_rt, HIGH);
schalter = HIGH;
Serial.begin(115200);
Serial.println("code ---- /home/georg/Arduino/fahr_rad/entfernung_messen/2020_06_28/fahrrad_echo_client_1");
Serial.println('\n');
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
Serial.print("Connecting to ");
Serial.print(ssid); Serial.println(" ...");
int i = 0;
while (WiFi.status() != WL_CONNECTED)
{ // Wait for the Wi-Fi to connect
delay(1000);
Serial.print(++i); Serial.print(' ');
}
Serial.println('\n');
Serial.println("Connection established!");
Serial.print("IP address:\t");
Serial.println(WiFi.localIP());
}
void loop()
{
/*
if ((schalter == HIGH)) // && (WiFi.softAPgetStationNum() == 0))
{
WiFi.begin(ssid, password);
digitalWrite (ledPin_rt, LOW);
digitalWrite (ledPin_gn, HIGH);
schalter = LOW;
}
else if ((schalter == LOW) && (WiFi.softAPgetStationNum() == 1))
{
WiFi.disconnect();
digitalWrite (ledPin_gn, LOW);
digitalWrite (ledPin_rt, HIGH);
schalter = HIGH;
}
*/
}
server
#include <ESP8266WiFi.h>
const int ledPin_rt = D5;
const int ledPin_gn = D6;
const int ledPin_bl = D7;
uint8_t schalter = LOW;
int ledState_rt = LOW; // LED-Status
int ledState_gn = LOW;
int ledState_bl = LOW;
void setup()
{
pinMode(ledPin_rt, OUTPUT);
pinMode(ledPin_gn, OUTPUT);
pinMode(ledPin_bl, OUTPUT);
digitalWrite (ledPin_rt, HIGH);
schalter = HIGH;
Serial.begin(115200);
Serial.println("code ---- /home/georg/Arduino/fahr_rad/entfernung_messen/2020_06_28/fahrrad_echo_server_1");
Serial.println();
Serial.print("Konfiguriere soft-AP ... ");
boolean result = WiFi.softAP("fahrrad-echo-server", "12345678");
Serial.print("Verbindung wurde ");
if (result == false)
{
Serial.println("NICHT ");
}
Serial.print("erfolgreich aufgebaut!");
}
void loop()
{
boolean result = WiFi.softAP("fahrrad-echo-server", "12345678");
if ((schalter == HIGH) && (WiFi.softAPgetStationNum() == true))
{
//boolean result = WiFi.softAP("fahrrad-echo-server", "12345678");
digitalWrite (ledPin_rt, LOW);
digitalWrite (ledPin_gn, HIGH);
schalter = LOW;
}
//else if (WiFi.softAPgetStationNum() == LOW)
// else
else if ((schalter == HIGH) && (WiFi.softAPgetStationNum() == false))
{
// client.stop();
digitalWrite (ledPin_gn, LOW);
digitalWrite (ledPin_rt, HIGH);
schalter = HIGH;
}
Serial.printf("Anzahl der Verbundenen Geräte= %d\n", WiFi.softAPgetStationNum());
delay(3000);
}
ich versuche das abbrechen der verbindung mit dem registrieren von verbundenen geräten zu realisieren ( WiFi.softAPgetStationNum() ) , habe dabei allerdings ein problem. Die verbindung wird ja ziemlich abruppt beendet, und der server merkt es nicht :-(...
Welche möglichkeit habe ich in diesem fall die verbindung vom server aus zu beenden, bzw. den abbruch quasi zu legalisieren? Hab schon einiges probiert, es klappt nicht. Bei einer verbindung mit einem smartphone wird der abbruch der wifi-verbindung korrekt erkannt, auch wenn ich das wlan einfach abschalte findet ein reconnect statt, bei den modulen, bzw. meinem code klappt es nicht :-(
ich habe noch vergessen zu erwähnen, dass beim verwenden dieser zeilen beim server
uint8_t rssi = WiFi.RSSI();
Serial.println (rssi);
nur "31" ausgegeben wird. Egal, ob das "client"-modul eingeschaltet ist, oder nicht. Die module liegen dicht beienander...
Habe dann nach ursachen gesucht, keine finden können, deshalb der versuch mit dem zählen der verbundenen geräte...
Wo könnte ich da ein problem haben?
EDIT:
ok, RSSI wird am client detektiert, da läuft es, reagiert auf veränderungen der entfernung...
die letzten tests waren überaus erfolgreich! Das signal, dass den "abbruch" der verbindung signalisieren soll, kommt nach 130 schritten, geschätzt also nach 100 metern...
Eigentlich ist das projekt nun abgeschlossen, allerdings ist es nur eine rudimentäre grundfunktion, mehr kommt noch, vielleicht auch noch die eine oder andere frage...
Rabenauge
30.06.2020, 19:29
Halt uns doch bitte trotzdem mal auf dem Laufenden.
Z.B interessiert mich bennend, unter welchen Bedinungen du so eine Reichweite schaffst- und unter welchen nicht.
Erfahrungsgemäss hat da nämlich Funk so seine Tücken: je nach Standort (und anderen Bedingungen) komme ich mit meinem Amateurfunkgerät problemlos 70-80 km weit, oder auch nur 2.
piggituX
30.06.2020, 19:55
schön schön :) freut mich das es so funktioniert wie gedacht, auf zu neuen Projekten
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?
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
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...
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
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?
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 (https://de.wikipedia.org/wiki/Ping_(Datenübertragung)).
MfG
ok, danke für den link...
habe heute den ersten test auf dem rad durchgeführt
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...
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 (https://www.arduinolibraries.info/libraries/esp8266-ping)
MfG
- - - Aktualisiert - - -
Hier hatten wir das Thema UDP schon mal: https://www.roboternetz.de/community/threads/72671-NodeMCU-UDP-Paket-senden-deepsleep?highlight=udp+esp8266+nodemcu
Hier noch mal ein anderes Tutorial zu UDP: https://www.nikolaus-lueneburg.de/2015/01/arduino-udp-kommunikation/
ich hab das hier gefunden:
server
// 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
#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(insideThermom eter), 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 :-)
Ist doch gut! Es gibt viele solcher Beispiele im Netz.
MfG
diese antennen habe ich getestet:
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:
#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:
#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
}
}
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
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 :-(
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
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:
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:
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.io/en/latest/esp8266wifi/client-examples.html#read-reply-from-the-server
interessant wird dann dieser Abschnitt sein:
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:
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:
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
#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 (https://youtu.be/JES-Q01bllo)...
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.
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.
Hier eine Übersicht mit Beschreibung für die UDP-Klasse (https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/udp-class.html).
MfG
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...
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
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). beides kein problem, ich wollte radfahren und nicht mit dem WEMOS nebenher noch ein AKW betreiben...
Dafür muss man wissen, wonach man sucht, deshalb ist selbst das manchmal nicht so einfach gemacht eben, da Du keine codebeispiele brauchst, hat das wort dafür in der suche gefehlt und Du hast einen link mit erklärungen ohne codebeispiele geschickt. Nicht sinnvoll...
Mag sein, dass Du noch Codebeispiele brauchst. Aber so viel Zeit habe ich momentan leider nicht, das in funktionierende Beispiele zu fassen. Ich fand es super, dass es eine Erklärung der Klasse und Methoden gibt, mit Beschreibung. Das ist die Essenz, die man benötigt. Den Code drumrum schreibt man normal ja selber. Für Assembler sind dann immer die Hardwarebeschreibungen wichtig, mit den Ports, wie ist der Zugriff, 8 Bit oder 16 Bit, vielleicht 32 Bit? Wie sind die Bytes/Worte aufgebaut (welches Bit hat welche Bedeutung). C++ ist ja schon eine Hochsprache, damit geht es einfacher. Hmmm...
Mag sein, dass Du noch Codebeispiele brauchst. Aber so viel Zeit habe ich momentan leider nicht, das in funktionierende Beispiele zu fassen. Ich fand es super, dass es eine Erklärung der Klasse und Methoden gibt, mit Beschreibung. Hmmm...
genau Hmmm...
Ich werde immer beispiele brauchen - das zum einen. Zum anderen, Du weisst ja - so omnipresent Du hier bist, dass ich der erste bin, der schreit - mach ja nicht zu viel aufwand... So viel zu Deiner zeit...
Aber vielleicht nicht andere in ihren fähigkeiten zu suchen zu unterschätzen. Habe bisher alles gefunden, was ich gebraucht habe. Das es dann auf der eine seite wifi ist und auf der anderen UDP? Wenn juckts?
ich war heute im sportgeschäft und habe ein zelt ausgesucht. ich unterschätze dich nicht, deswegen ja die links. ich dachte d bekommst das hin. aber vielleicht ja überschätzt.
spätestens jetzt wäre der zeitpunkt da um diese sinnfreie diskussion zu beenden.
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
09.07.2020, 17:21
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
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
stimmt, und der Topic-Titel ist hier auch völlig verwirrend, denn da geht es ja um 433 MHz, das wäre z.B. die LoRa-Frequenz.
In dem Fall, dass man komplett die technische Basis ändert (WiFi >= 2.4GHz) , hätte man ein neues Topic eröffnen sollen, denn so geht in dem Sammelsurium alles wie Kraut und Rüben durcheinander, und das ist ziemlich unzumutbar für andere Forums-Leser.
@admins:
Kann man bitte mal den Titel ändern oder das Topic splitten?
@admins:
Kann man bitte mal den Titel ändern oder das Topic splitten?
wäre auch in meinem sinn - angefangen hat es ja mit den 433mhz teilen... - es wurden WEMOS daraus - so ist manchmal das leben...
ich sehe wahrscheinlich wieder die bäume wegen dem wald nicht. Oder umgekehrt....
Wie kann ich in einer IF-anweisung danach fragen ob beim digital.read etwas angekommen ist? Welcher wert da ankam ist egal, ich möchte nur den unterschied zwischen "nichts angekommen" und "irgendwas angekommen" abfragen. Geht das überhaupt? Bitte helft mir aus dem wald...
Für Dich vermutlich am verständlichsten:
if (digitalRead(inPin)==HIGH) {
....
}
oder
if (digitalRead(inPin)==1) {
....
}
oder
if (digitalRead(inPin)) {
....
}
Wie kann ich in einer IF-anweisung danach fragen ob beim digital.read etwas angekommen ist?
Gar nicht. digital.read liefert den Zustand eines Pins. Und ein Pin hat immer einen Zustand, es "kommt" also immer etwas an.
MfG Klebwax
Gar nicht. digital.read liefert den Zustand eines Pins. Und ein Pin hat immer einen Zustand, es "kommt" also immer etwas an.
MfG Klebwax
ok, danke, ich sitz wahrscheinlich schon zu lange vor der kiste...
wie sieht es bei client.read(); aus? das, was da ankommt (oder auch nicht) wird einer variablen zugewiesen:
request = client.read();
wenn da nichts ankam, wird die variable den ihr vorher zugewiesenen zustand "0" behalten?
wie sieht es bei client.read(); aus? das, was da ankommt (oder auch nicht) wird einer variablen zugewiesen:
request = client.read();
client.read() liefert immer etwas. Wenn die Funktion als void definiert wäre, dann würde sie nie etwas liefern, der Compiler wüsste das und würde einen Fehler melden. Und request kann seinen vorigen Zustand nicht behalten, es muß den Wert annehmen, den read liefert. Das sagt das "=", der Zuweisungsoperator. Findet man in request den vorigen Wert, dann hat read ihn geliefert.
MfG Klebwax
Wenn man wissen will, ob bei der Klasse "Client" etwas angekommen ist, nutzt man .available(). Diese Methode gibt die Anzahl Bytes zurück, die verfügbar ist.
Beispiel:
if(client.available()){
char c = client.read();
Serial.print(c);
}
danke erstmal für die vorschläge für die auswertung der client.read funktion. Leider funktioniert das, was ich vorhatte - so nicht...
aber von anfang an:
- die kopplung von client und master mit den "WEMOS-D1_mini-teilen" funktioniert gut, die entfernung bei der die verbindung abbricht liegt auf gerader und unverbauter strecke bei ca. 150m, was absolut meinen vorstellungen entspricht.
- beim abbiegen zwischen häusern ist es etwas weniger, also um die 100m, ist aber ok...
- das signalisieren des abbruch (grünes blinken geht in rotes blinken über) funktioniert beim slave auch gut, beim master allerdings nicht...
Das höchste der gefühle was ich erreiche, ist, dass das grüne blinken aufhört, ich schaff es einfach nicht, den punkt im code zu knacken, an dem ich das so sensieren kann, dass es ins rote blinken übergeht...
Wie gesagt ist für die nutzung kein muss, wäre aber schon schöner...
wer schaut sich das bitte an?
hier der mastercode:
// https://www.arduinoforum.de/arduino-Thread-ESP8266-Daten-%C3%BCbertragen
// https://www.arduinoforum.de/arduino-Thread-2-ESP8266-miteinander-kommunizieren-lassen?page=2
// LOLIN(WEMOS)D1 mini pro
#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 = 500;
//long interval_gn = 200;
//long interval_bl = 50;
WiFiServer server(80);
IPAddress IP(192, 168, 4, 15);
IPAddress mask = (255, 255, 255, 0);
//adresse slave
IPAddress remoteIP(192, 168, 4, 114);
// überwachter port
unsigned int remotePort = 4210;
char befehl[10];
WiFiUDP Udp;
uint32_t aktMillis;
uint32_t prevMillis;
int8_t request = 0;
int8_t rt_blink;
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);
Serial.println("code ---- /home/georg/Arduino/fahr_rad/entfernung_messen/WEMOS_mit_UDP/WEMOS_AP_mit_UDP_master_1");
//Inizialisiere WIFI
WiFi.mode(WIFI_AP);
WiFi.softAP("fahrrad_echo", "12345678");
WiFi.softAPConfig(IP, IP, mask);
digitalWrite(ledPin_bl, HIGH);
delay(500);
digitalWrite(ledPin_bl, LOW);
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()
{
digitalWrite(ledPin_gn, LOW);
//rt_blinken();
// schalten der LEDs auf dem client
aktMillis = millis();
if (aktMillis - prevMillis >= 200)
{
prevMillis = aktMillis;
Serial.print("LED schalten auf ");
if (ledStatus)
{
Serial.println("An");
befehl[0] = 1;
// digitalWrite(ledPin_rt, LOW);
}
else
{
Serial.println("Aus");
befehl[0] = 0;
// digitalWrite(ledPin_rt, HIGH);
}
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)
request = client.read();
Serial.println("********************************");
Serial.print("From the station: ");
Serial.println(request);
client.flush();
if ((request != -1) || (rt_blink == 0))
{
digitalWrite(ledPin_gn, LOW);
//digitalWrite(ledPin_rt, LOW);
delay(200);
digitalWrite(ledPin_gn, HIGH);
//digitalWrite(ledPin_rt, LOW);
delay(200);
//request = 0;
}
}
void rt_blinken (void)
{
unsigned long currentMillis_rt = millis(); // aktueller Wert rot
if (currentMillis_rt - previousMillis_rt > 200)
{
previousMillis_rt = currentMillis_rt; // aktuellen Wert speichern
ledState_rt = ((ledState_rt == LOW) ? HIGH : LOW); // toggeln
digitalWrite(ledPin_rt, ledState_rt); // LED ansteuern
//rt_blink = 0;
}
}
ich habe ein bisschen weitergemacht, es sieht auch gut aus, auch ein bisschen anders:
35322
ursprünglich waren es zwei projekte (und zwei boxen)
- eine einrichtung, die den abstand zweier räder zueinander misst und eine überschreitung optisch, per LED, die rot blinkt, signalisiert
- eine zusätzlich steuerung für das eigene e-bike. Die ursprüngliche steuerung ist aufgrund eines ausgefallenen sensors (und kein ersatz weit und breit) unbrauchbar geworden und das hier
35323
sollte abhilfe schaffen. Bedienung per smartphone-app, also mit/durch berühren von sensitiven flächen auf dem display. Währen der fahrt manchmal schon problematisch :-)
Deshalb die "weiterentwicklung" zu einer gemeinsamen box mit 4tasten bedienung. Es ist eine folientastetur, druckpunkt nicht vorhanden, also auch die frage - gedrückt, oder nicht?
Ich würde gerne eine rückmeldung haben. Akustisch wäre der gag, aber da kann ich gleich alexa nehmen :-), nein, ein leichtes vibrieren beim tastendruck würde reichen...
hat schon jemand sowas realisiert?
Rabenauge
24.11.2020, 20:17
So kleine Rüttelmotoren gibt es ja.
Aber: merkt man das beim radfahren wirklich?
Ich kenne die Pirnaschen Strassen ja- das rüttelt sowieso ununterbrochen.....und man braucht auch bestimmt nen kleinen Treiber für den Motor.
Wieso nicht ne LED, die aufblinkt, wenn der Druck erkannt wurde?
also der motor, den ich hier habe (danke für den tipp) läuft direkt mit einer batterie von 1,5V, ohne treiber. An und ausschalten...
Eine LED, die blinkt habe ich schon dran, die soll signalisieren, dass man den kontakt zum partnerrad verloren hat. Ob man das blinken sofort oder ein paar minuten später entdeckt, ist nicht so kritisch, man muss halt evtl. etwas länger warten, oder ein stück weiter zurückradeln :-( , alo unkritisch...
Wenn ich aber an der steuerung schalte, möchte ich sofort wissen ob der schaltvorgang erfolgreich war, oder nicht. Ein einmaliges blink der LED reicht da nicht, das muss schon haptisch sein..
Ich hab mir überlegt, ich hab ja ohnehin mein fitnesstracker am handgelenk, den kann man vom smartphone auch suchen, dann vibriert er. Und in der radelektronik habe ich ja wlan und bluetooth, vielleich ergibt sich da was...
Rabenauge
25.11.2020, 17:37
ich meinte schon, dass dann ein Lämpchen aufleuchtet, wenn ein Tastendruck erkannt wird.
Mehr als ne zusätzliche LED (samt Schutzwiderstand) brauchste da nicht..sowas hat man eh rumschwirren.
Das kann man dann so entprellen, dass ein Druck erst beim Loslassen gezählt wird.
Dann geht die Lampe aus, wenn man den Finger vom Taster nimmt, und _dann_ wird der Druck auch verarbeitet.
Das dürfte sogar im Gelände noch halbwegs funktionieren (oder auf eueren Strassen da unten).
was ich meine ist, dass es nicht immer möglich und sicher genug ist, auf das kästchen runterzuschauen, man weiss ja wo es ist und die tasten sind so angeordnet und voneinander getrennt, dass man sie auch im dunkeln, blind findet... Dann müsste ein signal kommen welches ohne hinzuschauen spürbar/registrierbar ist...
Ich versuchs mal mit dem mini vibrator, vielleich vibriert das ganze kästchen :-)
021aet04
26.11.2020, 15:38
Wie wäre es mit einem Piezosummer, die werden ja häufig für soetwas verwendet.
MfG Hannes
oberallgeier
26.11.2020, 15:51
was ich meine ist, dass es nicht immer möglich und sicher genug ist, auf das kästchen runterzuschauen ..Und ne farbige LED, die LED direkt als Taster ? Das hatte mal Andree-HB gebaut (https://www.roboternetz.de/community/threads/40685-Kleine-Spielerei-beleuchteter-Taster) . Wär das was ?
das problem ist ja während der fahrt den blick von der fahrtrichtung für länger weg zu nehmen. Und das erfordert auch eine blinkende LED... Ich habe es jetzt mit diesem kleinen teil gelöst
35330
die rückmeldung erfolgt gut fühlbar durch vibration des gehäuses...
35329
man sieht auch, dass sich das kästchen langsam aber sicher füllt :-)
Rabenauge
30.11.2020, 18:04
Stimmt- interessante Dinge erspähe ich da....ist das ne 8mm-RGB-Led?
Du weisst, dass es die auch mit WS2812-Platine hinten dran gibt?
Würde einige Kabelei ersparen....die braucht dann nur Stromversorgung und _eine_ Leitung.
Und spart gleich zwei Pins ein...
nein, wusste ich nicht... - allerdings ist es eine flache LED, die man nur von der frontseite vernünftig sehen kann - ich brauche die seitenansicht...
Ich beabsichtige ohnehin ein "redesign" - mit einem WEMOS-ESP32 (der hat auch BT on board), dann brauche ich nur noch die LED, den schalter, 3.7V akku und keine step-up für 6V für den HC05. Die restlichen teile kommen alle zusammen auf eine leiterplatte, damit entfällt auch viel an freiluftverdrahtung...
Rabenauge
01.12.2020, 17:44
Die im Anhang hab ich mal irgendwo "garnichtmalteuer" gekauft.
8mm Durchmesser (die LED) und eben busfähig.
Die haben alle Ein-und Ausgang...
Die zwei da hängen zusammen, weil ich die alle so als Streifen bekommen hatte- muss man auseinander brechen.
Ansteuerung funktioniert sowohl über Fastled als auch mit der Neopixel-Lib.
Das Abstrahlverhalten ist typisch Rundkappe: im Grunde leuchtet die ganze Kappe auf...allerdings sind die nicht so hell wie eine 5050, auf die man direkt draufguckt (am Tage aber trotzdem noch einigermassen zu sehn-) in der prallen Sonne hab ichs allerdings nie probiert.
Die Kappe ist halt nich klar, sondern milchig.
In Aktion kann ich sie dir leider nicht zeigen-die einzige, die ich momentan im aktiven Dienst hab, ist in meinem Lightpaint-Schwert, und dort ist sie abgedeckt, also kaum zu sehen.
Powered by vBulletin® Version 4.2.5 Copyright ©2025 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.