Überblick
Das Board UNO R4 WiFi stellt neben dem Mikrocontroller auch ein ESP32-Modul bereit. Damit können Verbindungen zu WLAN-Netzwerken und anderen Bluetooth-Geräten aufgebaut werden.
Pinbelegung
Quelle: 🔗https://docs.arduino.cc/hardware/uno-r4-wifi (eigene Bearbeitung)
An diese Ein- und Ausgänge können zum Beispiel LEDs, Lautsprecher, Displays, Motoren oder Sensoren angeschlossen werden. Der Mikrocontroller kann alle diese Bauteile steuern, Signale auslesen und aufgrund der gelesenen Daten verschiedene Aktionen auslösen.
- Der Reset-Knopf startet das gerade hochgeladene Programm neu.
- Die digitalen Ein-/Ausgänge liefern im Normalfall ein HIGH (1) oder LOW (0). Eine Ausnahme bilden die mit einem ~ gekennzeichneten Pins. Sie können mit der ⇒Pulsweitenmodulation angesprochen werden.
- Die analogen Eingänge messen die anliegende Spannung. Diese Spannung (5V) wird vom Analog-Digital-Wandler (ADC = Analog Digital Converter) in digitale Werte zwischen 0 und 1023 (10 Bit) umgewandelt.
Die Standardauflösung kann auf 12 Bit (0-4096) oder 14 Bit (0-65355) erhöht werden.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
void setup() { // Auflösung 14 Bit analogReadResolution(14); Serial.begin(9600); } void loop() { // Wert von A0 anzeigen Serial.println(analogRead(A0)); delay(500); } |
- Der ⇒SPI-Bus verwendet die Eingänge D10 CS (Chip Select), D11 COPI (Controller Out Peripherie In), D12 CIPO (Controller In Peripherie Out) und D13 SCK (Serial Clock)
- Die Eingänge SCL und SDA werden über den ⇒I2C-Bus angesteuert.
- QWIIC ist ein zusätzlicher I2C-Bus
Die verbundenen Geräte können mit einem Programm abgefragt werden.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
#include "Wire.h" void setup() { // Wire1 ⇒ QWICC Wire1.begin(); Serial.begin(9600); delay(500); Serial.print("I2C Scanner QWIIC"); } void loop() { byte Fehler, Adresse; int Geraete = 0; Serial.println("Starte Scanvorgang"); for (Adresse = 1; Adresse < 127; Adresse++) { // Übertragung starten Wire1.beginTransmission(Adresse); // wenn die Übertragung beendet wird Fehler = Wire1.endTransmission(); if (Fehler == 0) { Serial.print("I2C Gerät gefunden - Adresse: 0x"); if (Adresse < 16) Serial.print("0"); Serial.print(Adresse, HEX); Serial.println(""); Geraete++; } } if (Geraete == 0) Serial.println("Keine I2C Geräte gefunden\n"); else Serial.println("Scanvorgang abgeschlossen"); delay(5000); } |
- die Pins 0 (RX – Receiver = Empfänger) und 1 (TX -Transmitter = Sender) werden für die Kommunikation mit dem Computer über die USB-Schnittstelle verwendet. Sie können nur dann als digitale Ein- oder Ausgänge verwendet werden, wenn der Arduino über eine externe Stromzufuhr betrieben wird.
Board installieren
- Icon für den Boardverwalter anklicken oder Werkzeuge-> Board -> Boardverwalter
- nach dem UNO R4 Board suchen
- Board installieren
Beim Betriebssystem Linux wirst du aufgefordert anschließend ein Script auszuführen:
Board auswählen
 |  |
| Linux | Windows |
BLE Terminal (iOS)
 |  |
LightBlue (iOS Android)
 |  |  |
| Android zeigt als Name LED schalten | ||
 |  |  |
Der Name des USB-Ports unterscheidet sich je nach dem verwendeten Betriebssystem.
LED-Matrix
Auf dem Board befindet sich zusätzlich eine 12×8 große LED-Matrix.
Die LED-Matrix kann als ⇒zweidimensionales Array definiert werden. Eine 0 markiert eine ausgeschaltete LED, eine 1 zeigt eine leuchtende LED. Diese Schreibweise hat den Vorteil, dass der Aufbau der Matrix sichtbar wird und eine Änderung schnell möglich ist.
Beispiele:
|
1 2 3 4 5 6 7 8 9 10 11 |
byte PfeilRechts[8][12] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 } }; |
|
1 2 3 4 5 6 7 8 9 10 11 |
byte PfeilLinks[8][12] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 } }; |
Das vollständige Programm:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
#include "Arduino_LED_Matrix.h" ArduinoLEDMatrix Matrix; byte PfeilLinks[8][12] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 } }; byte PfeilRechts[8][12] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 } }; void setup() { Matrix.begin(); Matrix.renderBitmap(PfeilLinks, 8, 12); delay(1000); Matrix.renderBitmap(PfeilRechts, 8, 12); } void loop() { // bleibt leer, Programm läuft nur einmal } |
Du kannst aber auch den dazugehörigen 🔗Editor verwenden.
Das vollständige Programm:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
#include "Arduino_LED_Matrix.h" ArduinoLEDMatrix Matrix; const unsigned long PfeilRechts[] = { 0x800, 0xcffeffff, 0xfe00c008, }; const unsigned long PfeilLinks[] = { 0x10030, 0x7fffff7, 0xff300100, }; void setup() { Matrix.begin(); Matrix.loadFrame(PfeilLinks); delay(1000); Matrix.loadFrame(PfeilRechts); } void loop() { // bleibt leer, Programm läuft nur einmal } |
In der Arduino IDE findest du unter Beispiele -> LED_Matrix das Programm MatrixFrameBuffer. Ich habe das Programm als Vorlage genommen und vereinfacht. Das Programm erzeugt zufällige Pixelmuster.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
#include "Arduino_LED_Matrix.h" // Name der Matrix ArduinoLEDMatrix Matrix; #define Reihen 8 #define Spalten 12 int PunktX = 0; int PunktY = 0; // Rahmen definieren, beim Start sind alle Pixel ausgeschaltet byte Rahmen[8][12] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; void setup() { // Matrix starten Matrix.begin(); } void loop() { // Punkte zufällig bestimmen PunktX = random(Spalten); PunktY = random(Reihen); // Pixel zufällig ein- oder ausschalten int Pixelwert = random(2); // Rahmen mit den neuen Werte aktualisieren Rahmen[PunktY][PunktX] = Pixelwert; // Rahmen anzeigen Matrix.renderBitmap(Rahmen, 8, 12); delay(50); } |
Text scrollen
In der Arduino IDE findest du unter Beispiele -> LED_Matrix das Programm TextWithArduinoGraphics. Ich habe das Programm vereinfacht und kommentiert.
Du musst dafür eine zusätzliche Bibliothek installieren.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
#include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" ArduinoLEDMatrix Matrix; void setup() { Matrix.begin(); } void loop() { // Zeichnen starten Matrix.beginDraw(); // Scrollgeschwindigkeit Matrix.textScrollSpeed(50); // Fontgrößen: Font_4x6, Font_5x7 Matrix.textFont(Font_5x7); // beginText(Spalte, Zeile, Farbe) Matrix.beginText(0, 1, 0xFFFFFF); // Text anzeigen Matrix.print(" Text scrollen "); // nach links scrollen Matrix.endText(SCROLL_LEFT); // Ausgabe beenden Matrix.endDraw(); } |
⇒Beispiel: Temperaturmessung und Anzeige der Daten
RTC-Modul
Auf dem Board befindet sich auch ein RTC-Modul (RTC = Real Time Clock). Es ist allerdings nicht über eine Batterie gepuffert, nach dem Ausschalten muss das aktuelle Datum und die Zeit neu gesetzt werden.
Wenn die Batterie gepuffert werden soll, müssen die Pins VRTC+ und VRTC- mit einem Batteriepack oder einer anderen Stromquelle mit maximal 3,3V verbunden werden.
Die Installation einer zusätzlichen Bibliothek ist nicht notwendig.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
#include "RTC.h" void setup() { Serial.begin(9600); RTC.begin(); // aktuelles Datum/Zeit setzen // MESZ: SAVING_TIME_ACTIVE // MEZ: SAVING_TIME_INACTIVE RTCTime Zeit(12, Month::DECEMBER, 2024, 7, 56, 00, DayOfWeek::THURSDAY, SaveLight::SAVING_TIME_INACTIVE); RTC.setTime(Zeit); } void loop() { RTCTime aktuelleZeit; // aktuelle Zeit holen RTC.getTime(aktuelleZeit); // Wochentag als Objekt von DayOfWeek erzeugen DayOfWeek Wochentag = aktuelleZeit.getDayOfWeek(); switch (Wochentag) { case DayOfWeek::SUNDAY: Serial.print("Sonntag "); break; case DayOfWeek::MONDAY: Serial.print("Montag "); break; case DayOfWeek::TUESDAY: Serial.print("Dienstag "); break; case DayOfWeek::WEDNESDAY: Serial.print("Mittwoch "); break; case DayOfWeek::THURSDAY: Serial.print("Donnerstag "); break; case DayOfWeek::FRIDAY: Serial.print("Freitag "); break; case DayOfWeek::SATURDAY: Serial.print("Samstag "); break; } // wenn Tag < 10 führende 0 ergänzen if (aktuelleZeit.getDayOfMonth() < 10) Serial.print("0"); Serial.print(aktuelleZeit.getDayOfMonth()); Serial.print("."); // wenn Monat < 10 führende 0 ergänzen if (Month2int(aktuelleZeit.getMonth()) < 10) Serial.print("0"); Serial.print(Month2int(aktuelleZeit.getMonth())); Serial.print("."); Serial.print(aktuelleZeit.getYear()); Serial.print(" - "); // Uhrzeit Serial.print("Uhrzeit: "); // wenn Stunde < 10 führende 0 ergänzen if (aktuelleZeit.getHour() < 10) Serial.print("0"); Serial.print(aktuelleZeit.getHour()); Serial.print(":"); // wenn Minuten < 10 führende 0 ergänzen if (aktuelleZeit.getMinutes() < 10) Serial.print("0"); Serial.print(aktuelleZeit.getMinutes()); Serial.print(":"); // wenn Sekunden < 10 führende 0 ergänzen if (aktuelleZeit.getSeconds() < 10) Serial.print("0"); Serial.println(aktuelleZeit.getSeconds()); delay(1000); } |
Zeit mit NTP
Benötigte Bibliothek installieren
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
#include "WiFiS3.h" #include "NTP.h" // SSID und Passwort des Routers char Router[] = "Router_SSID"; char Passwort[] = "xxxxxxxx"; WiFiServer WiFiServer(80); WiFiClient WiFiClient; WiFiUDP wifiUdp; NTP ntp(wifiUdp); void setup() { Serial.begin(9600); while (!Serial); delay(1000); // Verbindung aufbauen WiFi.begin(Router, Passwort); while(WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.print("Verbindung aufbauen mit "); Serial.println(Router); // Webserver starten WiFiServer.begin(); /* Zeitzone CEST: Central European Summertime Beginn europäische Sommerzeit letzter Sonntag im März 2 Uhr GMT + 2 Stunden */ ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120); // CET: Central European Time // Beginn Normalzeit letzter Sonntag im Oktober 3 Uhr GMT + 1 Stunde ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60); // ntp starten ntp.begin(); } void loop() { // Zeit aktualisieren ntp.update(); /* Zeit mit formatedTime() anzeigen: %d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden Wochentag anzeigen */ switch (ntp.weekDay()) { case 0: Serial.print("Sonntag"); break; case 1: Serial.print("Montag"); break; case 2: Serial.print("Dienstag"); break; case 3: Serial.print("Mittwoch"); break; case 4: Serial.print("Donnerstag"); break; case 5: Serial.print("Freitag"); break; case 6: Serial.print("Samstag"); break; } Serial.print(", "); Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T")); delay(1000); } |
QWIIC
Auf dem Board befindet sich ein zweiter I2C-Anschluss mit QWIIC-Stecker.
Beispielprogramm ⇒Wetterstation
Bluetooth (BLE)
Das Programm
Zunächst musst du die Bibliothek ArduinoBLE installieren:
Überprüfe, ob die aktuelle Firmware installiert ist: 🔗https://support.arduino.cc/hc/en-us/articles/9670986058780-Update-the-wireless-connectivity-firmware-on-UNO-R4-WiFi
Das Programm schaltet die eingebaute LED:
1 -> einschalten, 0 -> ausschalten:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
#include "ArduinoBLE.h" /* eindeutige UUID bestimmen: https://www.guidgenerator.com/online-guid-generator.aspx https://www.uuidgenerator.net/ BLERead | BLEWrite | BLENotify -> schreiben, lesen, Info */ // Name BLE-Service BLEService LEDSchalten("19b10000-e8f2-537e-4f6c-d104768a1214"); BLEUnsignedCharCharacteristic Auswahl("19b10000-e8f2-537e-4f6c-d104768a1214", BLERead | BLEWrite | BLENotify); void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); delay(1000); // pinMode festlegen pinMode(LED_BUILTIN, OUTPUT); // BLE starten if (!BLE.begin()) Serial.println("Bluetooth-Modul konnte nicht gestartet werden!"); else Serial.println("Bluetooth-Modul erfolgreich gestartet!"); // Name festlegen (wird in der App angezeigt) und den Service (LEDSchalten) zuweisen BLE.setLocalName("LED schalten"); BLE.setAdvertisedService(LEDSchalten); // Auswahl als Platzhalter für den in der App gewählten Wert LEDSchalten.addCharacteristic(Auswahl); // Service LEDSchalten hinzufügen BLE.addService(LEDSchalten); // Startwert für die Kommunikation schreiben Auswahl.writeValue(0); // Zuweisung starten BLE.advertise(); } void loop() { // auf die Verbindung zu Geräten warten BLEDevice Verbindung = BLE.central(); // wenn der R4 WiFi mit einem Gerät verbunden ist ... if (Verbindung) { Serial.println("Verbunden ... "); // solange der Controller mit einem Gerät verbunden ist ... while (Verbindung.connected()) { if (Auswahl.written()) { // LED einschalten if (Auswahl.value() == '1') { Serial.print(char(Auswahl.value())); Serial.println(" -> LED ein"); digitalWrite(LED_BUILTIN, HIGH); } // LED ausschalten if (Auswahl.value() == '0') { Serial.print(char(Auswahl.value())); Serial.println(F(" -> LED aus")); digitalWrite(LED_BUILTIN, LOW); } } } } } |
Smartphone-Apps
BluetoothLE (iOS)
 |  |  |  |
BLE Terminal (iOS)
| |
LightBlue (iOS Android)
| | |
| Android zeigt als Name LED schalten | ||
| | |
Webserver
Beispiel: Das Programm zeigt im Browser 6 unsortierte Zufallszahlen an. Eine Überprüfung auf Dopplungen findet nicht statt.
Im Seriellen Monitor wird die IP des Arduino UNO R4 angezeigt.
Diese Adresse musst du in einem Browser deiner Wahl eingeben
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 |
#include "WiFiS3.h" char Router[] = "Router_SSID"; char Passwort[] = "xxxxxxxx"; // Minimum/Maximum der Zufallszahlen const byte Minimum = 1; const byte Maximum = 49; WiFiServer WiFiServer(80); WiFiClient WiFiClient; void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial) ; delay(500); // WiFi starten WiFi.begin(Router, Passwort); // Verbindung herstellen while (WiFi.status() != WL_CONNECTED) { delay(200); Serial.print("."); } // SSID des Routers anzeigen Serial.println(); Serial.print("Verbunden mit "); Serial.println(WiFi.SSID()); // IP anzeigen Serial.println(WiFi.localIP()); // Webserver starten WiFiServer.begin(); // IP des Servers/des verbunden Computers anzeigen Serial.print("Server: "); Serial.println(WiFi.SSID()); // IP des Arduinos anzeigen Serial.print("IP Adresse Arduino DHCP: "); Serial.println(WiFi.localIP()); // Zufallsgenerator mit dem Signal an A0 starten randomSeed(analogRead(A0)); } void loop() { // auf WiFiClienten warten ... WiFiClient = WiFiServer.available(); if (WiFiClient) { // Seite aufbauen wenn SeiteAufbauen true ist boolean SeiteAufbauen = true; // solange der WiFiClient verbunden ist ... while (WiFiClient.connected()) { if (WiFiClient.available()) { // Anforderung vom WiFiClienten lesen ... char Zeichen = WiFiClient.read(); // wenn als Zeichen neue Zeile (\n) übergeben wird // SeiteAufbauen true ist -> Seite anzeigen if (Zeichen == '\n' && SeiteAufbauen) { /* HTML-Seite aufbauen die folgenden Anweisungen müssen mit print oder println gesendet werden println "verschönert" den Quelltext (erzeugt einen Zeilenumbruch im Quelltext) */ WiFiClient.println("HTTP/1.1 200 OK"); WiFiClient.println("Content-type:text/html"); // Leerzeile zwingend erforderlich WiFiClient.println(); WiFiClient.println("<!doctype html>"); WiFiClient.println("<html>"); WiFiClient.println("<body>"); // <h2> Überschrift H2 WiFiClient.println("<h2>Zufallszahlen</h2>"); // <hr> horizontale Linie WiFiClient.println("<hr>"); // Zufallszahlen anzeigen for (int i = 0; i < 6; i++) { int Zahl = random(Minimum, Maximum); WiFiClient.println(Zahl); WiFiClient.println(" "); } WiFiClient.print("<hr>"); // IPs anzeigen WiFiClient.print("Eigene IP-Adresse: "); WiFiClient.print(WiFiClient.remoteIP()); WiFiClient.print("</b>"); WiFiClient.print("<br>IP-Adresse Arduino: "); WiFiClient.print(WiFi.localIP()); WiFiClient.println("</body>"); WiFiClient.println("</html>"); // HTTP-Antwort endet mit neuer Zeile WiFiClient.println(); // Seite vollständig geladen -> loop verlassen break; } // neue Zeile -> SeiteAufbauen auf true setzen if (Zeichen == '\n') SeiteAufbauen = true; // die aktuelle Zeile enthält ein Zeichen else if (Zeichen != '\r') SeiteAufbauen = false; } } delay(1); WiFiClient.stop(); } } |
Quellen
Letzte Aktualisierung: