Guten Abend Zusammen,
ich würde gerne an einem vorhanden ESP8266 mit ESPEasy einen ATmega328P oder ähnlich anschließen.
> Natürlich wäre I2C und ne Porterweiterung möglich...
Ich würde gerne mehrere Analogeingänge haben und den ESP entlasten was die Steuerung von Schrittmotoren oder ähnlichem angeht.
Jemand ggf. ne Anleitung oder nen Tipp wie sich das realisieren lässt???
Danke und einen schönen Abend
Gear
Hallo Gear,
ich denke, das geht mit ESPEasy ohne Anpassen der Software nicht. Du brauchst einen Sketch, der auf dem Atmega328P läuft und dann noch die ESPEasy Erweiterung. Aber ich lasse mich gerne eines Besseren belehren.
Gruß PeMue
Ich hatte gehofft, dass man das irgendwie via Rx und Tx machen kann, da man in ESPEasy ja seriell etwas senden kann und sicherlich auch Befehle oder ähnliche empfangen kann.
Also so war mein Gedanke.
Du kannst den ESP als serial WiFi Bridge nutzen. Keine Ahnung ob das mit ESPEasy geht, mit Esplink geht es.
Stimmt, da gab es glaub ein Plugin für eine Art Serieller Server, muss ich mir heute Abend mal anschauen, danke.
Zitat von: sbiermann am 07 März 2019, 06:26:15
Du kannst den ESP als serial WiFi Bridge nutzen. Keine Ahnung ob das mit ESPEasy geht, mit Esplink geht es.
Das geht auch mit ESPEasy, die serial bridge ist drin. Für den Atmega328P brauchst Du aber noch einen Sketch, der das macht, was Du willst.
Gruß Peter
Ich gehe mal davon aus, dass ich den Sketch für den mega selber schreiben kann?
Werde mir die Tage mal nen Mega bestellen und das ganze testen.
Zitat von: Gear am 09 März 2019, 18:11:20
Ich gehe mal davon aus, dass ich den Sketch für den mega selber schreiben kann?
Das musst Du wissen, einfach mal probieren, dann geht das vermutlich schon.
Was ich aber nicht verstehe: Du hast einen ESP8266 mit deutlich mehr Rechenleistung und Du brauchst einen "schwächeren" Prozessor zur Entlastung. Weshalb? Warum packst Du den Sketch nicht einfach auf den ESP8266?
Gruß Peter
Ich nutze der einfachheit ESPEasy auf dem ESP8266, dieser ist auf einer selbstentworfenen Platine.
Hier könnte ich zwar per I2C oder den Rx/Tx Anschlüssen noch erweiterungen anbringen.
Ich würde gerne Schrittmotoren anschließen und brauche mehr Analogeingänge, der ESP hat nur einen Analogeingang, weitere sind aus Preislicher sicht teurer als nen Mega.
Zudem habe ich von ESPEasy schon 11 der 12 Tasks in nutzung, also ist per I2C nicht mehr ganz so extrem viel zu machen, bis auf ausgänge die direkt vai FHEM geschaltet werden.
Ein weiterer ESP wäre nicht das Problem, liegen genug bei mir rum, nur sind hier wieder die Analogeingänge das Problem. =)
So, die Arduinos sind da.
Nun stellt sich mir die Frage, wie kann ich nen Sketch flashen?
Habe den Nano per USB Anschluss am PC, den Port ausgewählt.
Mega328P und den richtigen COM-Port ausgewählt, wenn ich dann einen Sketch flashen will, dann kommt folgende Fehlermeldung:
Der Sketch verwendet 928 Bytes (3%) des Programmspeicherplatzes. Das Maximum sind 30720 Bytes.
Globale Variablen verwenden 9 Bytes (0%) des dynamischen Speichers, 2039 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x3e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x3e
Problem beim Hochladen auf das Board. Hilfestellung dazu unter http://www.arduino.cc/en/Guide/Troubleshooting#upload.
Die Rx-LED leuchtet kurz ein zwei mal auf, dann nach kurzem kommt dann die Fehlermeldung.
Welchen Programmer muss ich wählen, wenn ich das via USB direkt mache?
Es soll laut Bewertungen und Händler ein Bootloader drauf sein.
Der Benötigte Treiber ist auch installiert, der PC wurde danach neugestartet.
Hast Du Sketch -> Hochladen oder Sketch -> Hochladen mit Programmer hochladen gewählt?
Mit Bootloader müsstest Du Sketch hochladen wählen, Dein Log sagt, dass Du mit Programmer hochladen gewählt hast.
Gruß Peter
Edit:
Hier https://www.arduino.cc/en/Guide/Troubleshooting#upload gibt es noch Hilfestellung. Ich kompiliere die Sketche und lade sie mit avrdude hoch.
Ich hab immer nur auf den Pfeil gedrückt, so wurde das in den Videos immer gezeigt und so hab ich das dann versucht.
werde heute Abend mal versuchen, dass so wie du es sagt zu versuchen.
Danke schonmal :)
Einen schönen Tag :D
So, habs probiert, wenn ich auf Hochladen drücke, dann bekomme ich folgende Fehlermeldung:
Der Sketch verwendet 928 Bytes (3%) des Programmspeicherplatzes. Das Maximum sind 30720 Bytes.
Globale Variablen verwenden 9 Bytes (0%) des dynamischen Speichers, 2039 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x9e
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x9e
Problem beim Hochladen auf das Board. Hilfestellung dazu unter http://www.arduino.cc/en/Guide/Troubleshooting#upload.
Hab es mit drei Boards versucht.
Die "L" LED blinkt langsam bei allen Boards.
Hast Du den passenden (USB) Treiber geladen? Wird die richtige COM Schnittstelle angezeigt (ggf. Terminalprogramm nehmen)?
Es gibt Boards, die haben den Arduino, andere haben der Optiboot und wieder andere haben keinen Bootloader drauf.
Hast Du einen Programmer?
Gruß Peter
Also ich muss zu anfang mal sagen, was das Thema angeht bin ich ein Noob und kenne mich fast nicht aus.
An und für sich kann ich Programmieren und dergleichen, aber Arduino ist komplettes Neuland für mich.
Also der USB Treiber ist installiert, der COM-Port wird angezeigt, im Geräte Manager ist auch alles mit dem Port Ok.
Ich habe einen Programmer "FTDI232" den ich für die ESP's nutze.
Laut Händler sollte der Bootloader drauf sein.
Zitat von: Gear am 28 März 2019, 19:44:23
Ich habe einen Programmer "FTDI232" den ich für die ESP's nutze.
Das ist nur ein USB2seriell Wandler, der ESP8266 kann über die serielle Schnittstelle programmiert werden. Ein Atmega Programmer heißt USBASP oder USBtiny.
Jetzt muss ich ehrlicherweise mal ein bisschen nachdenken, wie man überprüft, ob ein Bootloader drauf ist ;).
Gruß Peter
Okey, gut ^^
Ich habe glaub noch einen Parallel Programmer der auf nem Board ist für nen Atmel at89s8253.
> Aber ich weiß nicht wo das Board ist... =/
Soweit ich das verstanden habe, wenn die "L" LED langsam blinkt, dann soll der Bootloader drauf sein, wenn sie schnell blinkt, dann soll keiner drauf sein.
> Ob das stimmt, is ne gut Frage.
schau mal hier:
https://blog.matthiasbock.net/2016/08/31/arduino-nano-klon-ide-tauglich-machen/
Sieht Deinem Problem recht ähnlich.
Gruß Peter
Ja, sieht meinem Problem recht ähnlich.
Nun sehe ich das aber so, ich brauche nen funktionierenden Arduino um über diesen die Nano's zu programmieren?
Naja, den habe ich nicht... =O
Ich hab noch nen "CC Debugger" rumliegen, mit dem hab ich den ZigBee USB-Stick geflashed, würde der auch gehen?!
Zitat von: Gear am 28 März 2019, 20:48:16
Ich hab noch nen "CC Debugger" rumliegen, mit dem hab ich den ZigBee USB-Stick geflashed, würde der auch gehen?!
Nein, ich glaube eher nicht. Aber sowas wie hier (falls Du einen Raspberry Pi hast):
https://www.torsten-traenkner.de/linux/raspberry/arduino.php
Gruß Peter
Uhh, das bietet sich doch an!!
Da hat der alte RPi endlich mal wieder nen Einsatz. =D
Werde ich mir morgen mal anschauen, Danke!!!!
Viel Grüße und einen schönen Abend / Gute Nacht
Gear
Ok, ich habe herausgefunden, warum es nicht ging....
Man muss folgendes auswählen: "ATmega328P (Old Bootloader)"
Hab das gerade mal getestet, da der alte PI so langsam ist.. =D
Zitat von: Gear am 28 März 2019, 21:35:51
Man muss Folgendes auswählen: "ATmega328P (Old Bootloader)"
Das kannte ich noch nicht, siehe auch Bild.
Gruß Peter
Genau das meinte ich. =D
Also ist doch nen BootLoader drauf, nur eben der "alte".
Funktioniert so auch problemlos.
So, habe die Kommunikation am laufen.
Nun habe ich mal zum Testen ESP8266 seriell mit dem Arduino Nano verbunden und die Kommunikation getestet.
Der ESP mit ESPEasy sagt alle 5 Minuten:
GetData
Der Nano sagt dann in 3 Nachrichten die Werte der Analog Eingänge A0 - A2:
"TaskValueSet,1,4,"+ String(analogRead(A0)*(5.0/1023.0))
Das ganze läuft für eine gewisse Zeit, irgendwann kommt beim ESp dann nichts mehr an, nach einem Neustart geht es dann wieder.
Wenn ich keinen Analogwert nehme, sondern en Fixe Zahl, dann geht es auch weiterhin.
Der Arduino IDE COM Monitor zeigt zwar an, dass eine Zeile kommt, aber kein Wert.
Wenn ich hier einfach nur ein "T" übertrage, dann läuft es weiter.
Also ich habe einen kleinen Test Durchgeführt, Folgender Code auf den Nano:
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.print("TaskValueSet,1,1,"+ String(analogRead(A0)*(5.0/1023.0)));
delay(1000);
}
> Den ESP nicht angeschlossen, läuft über 1h.
> Der Code mit nur Tx des Nano zum Rx des ESP, gleiches Ergebnis.
> ESP und Nano für gegenseitige Kommunikation nach wenigen Minuten (ca. 5 Min) keine Werte mehr.
Eine verringerung der Übertragungsrate ändert nichts.
Wenn ich den einfach nur ein "T" übertrage, dann läuft es auch über 1h.
kann es sein, dass der Befehl zu lang ist?
Ode rmache ich etwas falsch?
Wieviel Volt ? Analog?
BTW. Wird dieser Thread hier Ellen lang, das was du dir da vorgenommen hast, setzt so extremst viel an Basiswissen voraus. Und lass mich raten, von Elektrotechnik im allgemeinen hast du auch kaum Erfahrungen?
Ich mache hier dich und versuche weiter, bis ich den Grund gefunden habe, warum nach einer gewissen Zeit keine Daten mehr übertragen werden.
Danke an @PeMue für die Hilfe.
Und zu dem Post von @DasQ
> Der Eingang ist mit nem Poti auf 50% gesetzt, also 2,5V.
> Ich habe den Analogeingang genutzt um eben einfach nen Eigang zu nutzen um das zu testen.
> Ich bin Elektroniker für Geräte und Systeme.
> Ich habe bisher nur mit dem AT89S8253 gearbeitet und in Assembler programmiert.
>> Ich kann zudem auch diverse andere Programmiersprachen.
> Mit Elektronik habe ich Erfahrungen, nur habe ich bis dato noch nicht etwas in dieser Art Programmiert und ich habe leider im Netz auch nichts gefunden mit ähnlicher Problematik.
Ich wünsche euch ein schönes Wochenende.
Also die Kommunikation zwischen esp und Arduino, ist sehr gut im Internet beschrieben. Je nachdem was man will findet man fix und fertige howtos.
Auch sind so Anleitungen zum esp Flashen mehr als genug im Netz.
Da verwunderst mich doch sehr, das du da nichts gefunden hast und lies mir nur den Schluss, du bist nicht firm mit dem Rest.
Aber nochmals zu dem analog, ich mein gelesen zu haben im espeasy Forum oder Wiki, das der analog Eingang in espeasy nur maximal 1volt stabil verträgt, extremst störanfällig und ungenau ist.
https://www.letscontrolit.com/wiki/index.php/Analog
Ich frag über den analogeingang den Batterie stand, von mein ultralowcurrent deepsleep esp's.
Und da ermittel ich aus 10 Messungen den Durchschnittswert um ein halbwechs brauchbares ergebniss zu kommen.
Ich hoff das hilft dir weiter ;)
Ich nutze den Analogeingang des Nano mit 5V, soweit ich das gelesen habe, kann der das.
Zudem zeigt er mir auch die Spannung relativ genau an.
Der Eingang des ESP8266 kann nur 1V.
Den nutze ich im Regelfall um mir die 3,3V anzeigen zu lassen und bei Batterie Geräten die Akkuspannung.
Ist relativ genau, meist stimmt die 3. Stelle nicht, der Rest schon, bei mir zumindest.
Das die Komunikation gut beschrieben ist im Internet stimmt, genau wie das mit dem flashen.
Den ESP kann ich ja problemlos flashen, ich hatte Probleme mit dem Nano.......
Der ESP läuft mit ESPEasy problemlos, der Nano sendet nur nach einer gewissen Zeit leere Nachrichten.
Ich habe ja viel gegoogelt, bin dann aber durch die Probleme mit dem Nano nicht weitergekommen, somit hatte ich hier um Rat gesucht, da ich explizit keine lösung gefunden habe und auch den Grund nicht veratanden habe, waeum der auf einmal nurnoch leere Nachrichten versendet.
Wenn ich nur den Tx des Nano am Rx des ESP habe, dann habe ich keine Probleme bei der Übertragung.
Sobald aber eine Kommunikation in beide Richtungen besteht, dann kommen nach kürzester Zeit nurnoch leere Nachrichten.
So zudem kommen aber nur dann leere Nachrichten, wenn er Variablen mit senden soll.
Wenn ich einen vollen String nehme, kein Problem, sobald ich eben eine Variable mit in den String schreibe, dann besteht eben mein Problem.
Ich hoffe ich kommte das so halbwegs rüberbringen, wo mein Priblem liegt.
Habe ich das echt so uneindeutig geschrieben, dass man denkt, dass ich Probleme mim ESP habe?!?
zu meiner schande muss ich gestehen, dass ich zu ungenau gelesen hab und grundsätzlich misstrauisch bin, was die fähigkeiten des gegenübers anbelangt.
hast mal ein schema wie du des ganze angeschlossen hast? mir würde ja ne einfach handskizze abfotografiert mit`m handy reichen. (willst es schöner geht das ganz einfach, mit "http://fritzing.org/home/")
hast du RX und TX direkt angeschlossen oder ist da irgendwas dazwischen? pegelanpassung? stabilisierung?
http://deloarts.com/de/hardware/logic-level-shifter/
Ich habe das so gemacht, wie in dem Link von dir unter "Uni-Direktional" steht.
Tx des ESP auf Rx des Nano
Tx des Nano über die Widerstände 1k zum Rx des ESP und 2k zu GND.
Hab auch gelesen, es solle ohne gehen, aber da ich nicht sixher bestimmen konnte welche Spannung aus dem Tx des Nano kommt, bin ich von 5V ausgegangen.
Ich hoffe das reicht dir, bin noch auf Arbeit.
Also im Grunde funktioniert die Kommunikation zwischen ESP und Nano problemlos.
Habe gestern noch mal getestet.
Wenn der Nano 3x etwas schickt alle 60sec mit einer warte zeit zwischen den Befehlen von 1sec dann wird genau der String in den ich eine Variable mit einbinde nach einiger Zeit nurnoch eine leere Zeile.
Also folgende 3 Strings sende ich.
Serial.print("T") ;
Serial.print("TaskValueSet,1,1,123") ;
Serial.print("TaskValueSet,1,2,"+ String(analogRead(A0)*(5.0/1023.0)));
Hierbei ist es egal ob ich nen Analogeneingang nehme, eine zuvor deklarierte int Variable mit einer Zahl oder einen string, sobald eine Variable ins Spiel kommt, kommt nurnoch eine leere Zeile, aber das nicht von anfang an.
Und das ganze aber auch nur dann wenn vom ESP der Tx auf den Rx des Nanos geht, ohne dass ich hier irgendetwas sende.
Also die Kommunikation bleibt bestehen, aber der Print mit der Variable wird nur als leere Zeile gesendet.
Zitat von: Gear am 02 April 2019, 12:22:23
Hierbei ist es egal ob ich nen Analogeneingang nehme, eine zuvor deklarierte int Variable mit einer Zahl oder einen string, sobald eine Variable ins Spiel kommt, kommt nurnoch eine leere Zeile, aber das nicht von anfang an.
INT kann nie STRING sein
Müsst mich schon sehr täuschen wenn's anders ist.
Zeig mal bitte das Sketch
Vor deinem ersten Post hier, da ist das Sketch, bzw der Code, nur dass ich eben bei meinem Aktuellen Sketch zusätzlich noch wie beschrieben warten und die anderen befehle drin hab.
Ich kann den aktuellen Sketch heute Abend zeigen, bin noch auf Arbeit.
Und wenn du schaust wandel icj den Int in nen String um mit string() ansonsten würde er mir ne Fehlermeldung bringen und garnichts hochladen. :)
Ich hab das in meinem Post nicht erwähnt, dachte anhand meines Stings den ich sende ist das ersichtlich, sry.
So, das aktuelle Sketch.
void setup() {
Serial.begin(115200);
}
// the loop function runs over and over again forever
void loop() {
Serial.print("T\n");
delay(1000);
Serial.println("TaskValueSet,1,2,115");
delay(1000);
Serial.println("TaskValueSet,1,4,"+ String(analogRead(A0)*(5.0/1023.0)));
delay(60000);
}
Also, wenn mir das passieren würde, wäre meine Reaktion nach etwa zehn verschiedenen ESP-/nano-/Nextion-Installationen:
1. Entweder Hardwaredefekt
2. kalte Löstelle oder
3. Spannungsprobleme (d.h. weniger als 5V etc.)
Am häufigsten hatte ich 3. beobachtet, weil ich nie auf die Stromversorgung besonderen Wert gelegt hatte. Glücklicherweise ist das leicht zu überprüfen.
Einmal hatte ich 2., und das nervt extrem. Inzwischen fotografiere ich, was ich löte.
1. geht dann schnell zu testen, wenn man (von mehreren Herstellern!) die gleichen Produkte vorrätig hat.
Gesendet von iPad mit Tapatalk Pro
So, habe jetzt noch mal ein Paar Wemos D1 getestet.
Das Ergebnis mit folgendem Sketch:
long randNumber;
void setup() {
Serial.begin(115200);
}
// the loop function runs over and over again forever
void loop() {
randNumber = random(300);
Serial.println("TaskValueSet,1,1,"+ String(random(100)));
delay(100);
Serial.println("TaskValueSet,1,2,"+ String(randNumber));
delay(100);
Serial.println("TaskValueSet,1,3,0815");
delay(100);
Serial.println("TaskValueSet,1,4,"+ String(analogRead(A0)*(5.0/1023.0)));
delay(100);
}
21:50:49.811 -> TaskValueSet,1,1,19
21:50:49.914 -> TaskValueSet,1,2,122
21:50:50.016 -> TaskValueSet,1,3,0815
21:50:50.118 -> TaskValueSet,1,4,2.90
21:50:51.207 ->
21:50:51.310 ->
21:50:51.415 -> TaskValueSet,1,3,0815
21:50:51.518 ->
21:50:52.613 ->
21:50:52.716 ->
Man kann sehen, dass der Fix Wert mit "0815" am Ende noch übertragen wird.
Spannung liegt bei 4,91V / 3,24V beim Nano 3,17V beim ESP.
Das gleiche Ergebnis bei anderen Übertragungsraten oder bei längeren Pausen.
Kalte Lötstelle würde ich mal ausschließen, habe alles nachgeschaut unterm Mikroskop.
Hardwaredefekt würde ich auch ausschließen, da ich aus unterschiedlichen Bestellungen die Wemos verwendet habe.
Bei den 5V, gut, die Spannungen sind nachgemessen.
Da es ja weiterläuft mit dem Fixwert, würde ich hier mal die genannten Fehlerquellen ausschließen.
> Könnte es ggf. am alten Bootloader liegen?
Danke für eure Hilfe. =)
Zitat von: Gear am 02 April 2019, 22:02:06
> Könnte es ggf. am alten Bootloader liegen?
Würde ich eher ausschließen, da der nur dazu da ist, das Programm über die serielle Schnittstelle zu übertragen und danach nicht mehr verwendet wird.
Gruß Peter
kannst du mal die spannung während der übertragung messen?
Guten Morgen,
Wenn es um die Versorgungsspannung geht, die geht auf 4,86V runter.
Oder geht es um die 3,3V?
Gibt es einen besonderen Grund, warum du die Teile nicht teilweise einfach ohne "ln" raushaust und auf die "Verstringung" verzichtest?
Würde auf ein Speicherproblem auf dem Arduino tippen, deswegen kann der irgendwann nur noch das schreiben, was er schon kennt?
Ich kenne soetwas eig nur als ln für Kommunikation.
Naja, wenn ich einfach eine String Variable nehme, in die ich immer das gleiche reinschreibe oder die ich nur einmal deklariere und einmalig etwas reinschreibe, hier passiert das gleiche.
Ich will später eben die Werte der Analogeingänge des Arduino direkt über MQTT cmd an FHEM senden.
Bei der umsetzung bin ich auf folgendes Problem getroffen, darum einfach simpel zum testen.
Ich kann aber auch einfach nur einen bzw den glwichen String senden, hier passiert das gleiche.
Sobald eine Variable dazu kommt.
Ich werde wenn es bei mir heute Abend noch zwischenrein passt mal schauen, was passiert wenn ich den Tx des Arduino vom ESP trenne.
Hatte bei versuchen am WE keie leeren Zeilen gehabt.
Ich werde es auch mal ohne ln versuchen.
Naja wie soll ich das denn umsetzen, wenn ich es ohne Verstingung mache?
also wenn ich das hier so seh, trampelst du auf allem rum was ich mal so gelernt hab. kann sein das sich inzwischen einiges getan hat, mein letztes arduino sketch ist scho ein paar tage her. aber ich seh bei dir keine deklaration!
auch trampelst du auf den datentypen rum wie es dir passt, mal ganz davon abgesehn, das ich bis auf primitive serialausgabe noch kein echtes programm gesehn hab.
wie sowas aussehen könnte entnimmst du nem sketch von mir aus 2015 in dem ich mein garagentor damals per RFID öffnen konnte.
#include <SPI.h>
#include <MFRC522.h>
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);
int wert1 = 0; // wert "analog" volt vom esp8266 an A03
int wert2 = 0; // wert digital positionsschalter
int wert3 = 0; // wert für digital schalter signal
int z1 = 0; // zaehler1 auf 0 setzten
int out_D02 = 2; // output Relais (torsignal öffnen schliessen)
int out_D03 = 3; // output Beep
int in_D04 = 4; // input Tor Position
int in_D05 = 5; // input Taster manueller Betrieb
int in_A03 = 3; // input HIGH Signl vom ESP8266
int impuls = 200; // variable für tor impuls
void setup()
{
Serial.begin(9600);
SPI.begin();
mfrc522.PCD_Init();
pinMode (out_D02, OUTPUT);
pinMode (out_D03, OUTPUT);
pinMode (in_D04, INPUT);
pinMode (in_D04, INPUT);
pinMode (in_A03, INPUT);
digitalWrite (out_D02, LOW);
}
void loop()
{
//Tor öffnen über Wlan
wert1 = analogRead(in_A03); // liest Analog pin A03 und übergibt an variable wert1
if (wert1 > 500 )
{
Serial.println("Open via wlan");
// Warnton 5 Peep bevor tor geöffnet wird
int peep = 0;
do {
digitalWrite (out_D03, HIGH);
delay (500);
digitalWrite (out_D03, LOW);
delay(500);
peep++;
} while (peep < 5);
delay(1500);
digitalWrite (out_D02, HIGH);
delay (impuls);
digitalWrite (out_D02, LOW);
}
// RFID lesen
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
// RFID ergebniss an variable uebergeben
long code=0;
for (byte i = 0; i < mfrc522.uid.size; i++)
{
code=((code+mfrc522.uid.uidByte[i])*10);
}
// RFID ueberpruefung
if (code==832390 or code==153890 or code==1255260 or code==435790 or code==430790 or code==439790 or code==435790 or code==430790 or code==466620 or code==1398390)
{
z1++;
}
// Tor öffnen über RFID
if (z1 > 0 )
{
Serial.println("Open via RFID");
// Warnton 3 Peep bevor tor geöffnet wird
int peep = 0;
do {
digitalWrite (out_D03, HIGH);
delay (100);
digitalWrite (out_D03, LOW);
delay(100);
peep++;
} while (peep < 3);
delay(3000);
digitalWrite (out_D02, HIGH);
delay (impuls);
digitalWrite (out_D02, LOW);
}
}
nicht schön, soll ja auch nur als beispiel herhalten (wenn einer dennoch intresse dran hat, kann ich auch gern mal die finale version zeigen)
Grundsätzlich würde ich DasQ mal darin zustimmen, dass etwas vertiefteres Grundlagenwissen hilfreich wäre.
Wichtig: String-Inhalte sind unglaublich "teuer", die sollte man auf einem kleinen Microcontroller möglichst vermeiden, und wenn, dann ggf. versuchen, die ins EEPRM zu schreiben (Stichwort: "F()").
Für's testen erst mal (ungetestet, nur auf Basis der hier geposteten loop()):
void loop() {
randNumber = random(300);
Serial.print("TaskValueSet,1,1,");
Serial.println(random(100));
delay(100);
Serial.print("TaskValueSet,1,2,");
Serial.println(randNumber);
delay(100);
Serial.println("TaskValueSet,1,3,0815");
delay(100);
float analogreading = analogRead(A0)*(5.0/1023.0));
Serial.print("TaskValueSet,1,4,");
Serial.println(analogreading);
delay(100);
}
Ansonsten: Wenn du häufig dasselbe nacheinander tust, solltest du Schleifen verwenden, Ergebnisse (oder zu lesende PINs) in ein Array schreiben usw.... Das ohne zu machen, ist bei 2 Werten (Code von DasQ) eben noch ok, aber ansonsten dringend zu empfehlen (du willst mittelfristig ja einige Analogwerte auslesen).
Guten Abend Zusammen,
so zu der Aussage hin, dass der Nano hier schlap machen würde bei sovielen Strings per Serial rauszuhauen, bzw das int zu string umwandeln vermeidet werden sollte oder ähnliches.
Der Nano läuft jetzt seit ca 2,5h und schickt permanent die Daten raus, so wie in meinem Beispiel Sketch.
> Ich habe einfach mal Rx und Tx abgesteckt, nun gibt es keine Probleme beim senden.
Zu der Sache mit dem 0815 Sketch, ja, das ist in diesem Fall so gewollt.
Ich möchte erstmal die Möglichkeiten austesten, bevor ich mir die Mühe mache und etwas programmiere.
Ich werde mich am WE mal dran setzen und schauen, warum das probleme verursacht, wenn es mit dem ESP verbunden ist.
Und nun zu einem meiner Vorhaben, wenn es jmd interessiert.
Ich habe eine "Pflanzen-Ecke" in meinem Wohnzimmer unter dem Dachfenster, leider passiert es oft, dass ich vergesse diese zu giesen oder mal für bis zu vier Wochen nicht zuhause bin.
Diese Ecke besteht aus 5 unterschiedlichen Behältnissen, in jedem Behältnis soll ein Feuchtigkeitsmesser rein der Analog den Zusand gibt.
Desweiteren habe ich darunter einen Wasserbehälter der 20L Wasser fassen kann, der Füllstand soll auch ausgewertet werden.
Es soll durch 5 Kleine Wasserpumpen das jeweilige Behältnis gegossen werden.
Der ESP Ist hinter der Mediawand und steuert die LEDs (RGB+W+W), 12 Relais und 2 Strommesser (Da mein Server und Workstation dort in der Ecke stehen)
Nun wollte ich nicht noch einen ESP im Netzwerk haben und für so eine Simple Aufgabe dann einen ESP + ein paar ADC ist mir dann doch zu teuer. (Habe ein paar Nanos für 1,27€ im Sale geordert).
Der Ablauf soll so sein, dass der ESP alle x Minuten dem Nano sagt, "GetInfo", daraufhin sendet der Nano ggf. alle Daten in einem JSON String der selbst gebaut wird die Daten an den ESP per cmd publish wird dieser per MQTT weitergeleitet und FHEM wertet aus und veranlässt ggf. eine Pumpe für x Sekunden das jeweilige Behältnis zu bewässern.
Und wenn der Wasserstand unter x Liter fällt, dann bekomme ich ne Nachricht via Telegram und es werden keine Pumpen mehr angeschaltet, damit diese nicht leerlaufen und ggf kaputt gehen können.
Also das wäre eine der Pläne.
könntest einfach mal ein ordentlichen sketch versuchen?
wie gesagt du deklarierst nix, du machst da irgendwas und wunderst dich das es nicht geht.
https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/
ZitatExample Code
The code reads the voltage on analogPin and displays it.
int analogPin = A3; // potentiometer wiper (middle terminal) connected to analog pin 3
// outside leads to ground and +5V
int val = 0; // variable to store the value read
void setup() {
Serial.begin(9600); // setup serial
}
void loop() {
val = analogRead(analogPin); // read the input pin
Serial.println(val); // debug value
}
Wie gesagt, ich setze mich an deisem WE dran, habe nun ein "richtiges" Sketch geschreiben.
Aber gut ich nehme das vorgeschlagene Sketch.
Der ESp hat die Baudrate 9600 genau wie auf dem Nano.
Kommunikation ESP > Nano geht, das habe ich mit meinem Sketch getestet.
Kommunikation Nano > ESP geht nicht, weder bei meinem, noch bei dem Sketch aus der Ref.
Zitat von: Gear am 02 April 2019, 12:22:23
Ich habe das so gemacht, wie in dem Link von dir unter "Uni-Direktional" steht.
Tx des ESP auf Rx des Nano
Tx des Nano über die Widerstände 1k zum Rx des ESP und 2k zu GND.
Du weißt was Uni-Direktional heißt?
Zitat von: Gear am 02 April 2019, 12:22:23
Ich habe das so gemacht, wie in dem Link von dir unter "Uni-Direktional" steht.
Tx des ESP auf Rx des Nano
Tx des Nano über die Widerstände 1k zum Rx des ESP und 2k zu GND.
Uni-Direktional == Kommunikation nur in eine Richtung.
Das war aber auch nur auf das Schaltbild bezogen...
> Da du ja einen Schaltplan wolltest, wie ich es angeschlossen habe.
Jedoch steht auf der verlinkten Seite auch das diese Anschlussweise in beide Richtungen geht, da der Nano 3,3V (die auch aus dem Tx des ESP kommen) dies als Logisch "EINS" ansieht, und über dewn Spannungsteiler 1k und 2k der Pegel angepasst wird, so dass der Rx des ESP die 5V nicht sieht.
Ich habe es mittlerweile zum laufen bekommen, danke für die Hilfe.