Arduini UNO Steuerung über WLAN und Analogwertverarbeitung parallel möglich?

Hallo zusammen,

bei der Realisierung eines Projekts sollen mithilfe eines Arduinos (ARDUINO UNO REV2 WIFI) parallel Analogwerte von Sensoren ausgelesen werden und der Arduino über WLAN angesteuert werden. Dabei hat sich folgendes Problem ergeben:

Sobald ein Objekt durch den Arduino über den Webserver an/oder ausgeschalten wird hört die Analogwertverarbeitung auf, es werden von den benutzten Sensoren also keine weiteren Werte mehr ausgelesen.

Kennt jemand dafür eine softwarebasierte Lösung? Oder hat jemand schon mal über ein Arduino parallel über WLAN gesteurert und Analogwerte auslesen lassen und könnte sein Vorgehen/Code schildern?

Vielen Dank!

el_hannah:
bei der Realisierung eines Projekts sollen mithilfe eines Arduinos (ARDUINO UNO REV2 WIFI) parallel Analogwerte von Sensoren ausgelesen werden und der Arduino über WLAN angesteuert werden. Dabei hat sich folgendes Problem ergeben:

Sobald ein Objekt durch den Arduino über den Webserver an/oder ausgeschalten wird hört die Analogwertverarbeitung auf, es werden von den benutzten Sensoren also keine weiteren Werte mehr ausgelesen.

Kennt jemand dafür eine softwarebasierte Lösung? Oder hat jemand schon mal über ein Arduino parallel über WLAN gesteurert und Analogwerte auslesen lassen und könnte sein Vorgehen/Code schildern?

Da solltest du schon mal ausführliche Informationen über Hard- und Software posten.

Ohne genaue Infos fehlt uns die Grundlage auf die eine Hilfe aufbauen kann.

Ein Tipp, keine delays verwenden, sondern die Funktion millis, wie im BlinkWithoutDelay.

Meine Glaskugel ist leider im Moment wegen Trübheit in Reparatur, weshalb ich grad nicht bis zu deinem Monitor sehen kann. Meisterkurs für hellsehen ohne glaskugel noch nicht abgeschlossen.
Wahrscheinlich liegt der fehler in zeile 42, bei Zeichen 13.

LG Stefan

Deltaflyer:
in zeile 42, bei Zeichen 13.

42 (Antwort)

(deleted)

@el_hannah
Prinzipiell sind keine Einschränkungen bekannt.

Du könntest aber einen Fehler im Sketch haben der die Analogverwaltung ausgeschaltet/ausgeblender/ nicht mehr angesprungen oder aufgerufen.
Könnte aber auch ein RAM-Speicherproblem sein (Du brauchst mehr als der Arduino hat). Die Auswirkungen sind manchmal sehr kurios, irrwitzig und unberechenbar.

Könntest Du uns den Sketch geben der Dir dieses Problem gibt.
Hardware nehme ich mal an daß es diese ist: ARDUINO UNO WiFi REV2 | Arduino Official Store

Grüße Uwe

Hier mal der Code:

//***********************************************************************************************
//DECLARATIONS

#include <SPI.h>
#include <WiFiNINA.h>
#include "arduino_secrets.h" 
///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = SECRET_SSID;        // your network SSID (name)
char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
int keyIndex = 0;                // your network key Index number (needed only for WEP)

int led =  LED_BUILTIN;
int status = WL_IDLE_STATUS;

WiFiServer server(80);

//***********************************************************************************************
//SETUP

void setup() {
 //Initialize serial and wait for port to open:
 Serial.begin(9600);
 while (!Serial) {
   ; // wait for serial port to connect. Needed for native USB port only
 }

 Serial.println("Access Point Web Server");

 pinMode(led, OUTPUT);      // set the LED pin mode

 // check for the WiFi module:
 if (WiFi.status() == WL_NO_MODULE) {
   Serial.println("Communication with WiFi module failed!");
   // don't continue
   while (true);
 }

 String fv = WiFi.firmwareVersion();
 if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
   Serial.println("Please upgrade the firmware");
 }

 // by default the local IP address of will be 192.168.4.1
 // you can override it with the following:
 // WiFi.config(IPAddress(10, 0, 0, 1));

 // print the network name (SSID);
 Serial.print("Creating access point named: ");
 Serial.println(ssid);

 // Create open network. Change this line if you want to create an WEP network:
 status = WiFi.beginAP(ssid, pass);
 if (status != WL_AP_LISTENING) {
   Serial.println("Creating access point failed");
   // don't continue
   while (true);
 }

 // wait 10 seconds for connection:
 delay(10000);

 // start the web server on port 80
 server.begin();

 // you're connected now, so print out the status
 printWiFiStatus();
}

//***********************************************************************************************
//MAIN

void loop() {
 // compare the previous status to the current status
 if (status != WiFi.status()) {
   // it has changed update the variable
   status = WiFi.status();

   if (status == WL_AP_CONNECTED) {
     // a device has connected to the AP
     Serial.println("Device connected to AP");
   } else {
     // a device has disconnected from the AP, and we are back in listening mode
     Serial.println("Device disconnected from AP");
   }
 }
 
WiFiClient client = server.available(); // Check ob Client verbunden ist
 if (!client) return;
 unsigned long ultimeout = millis()+250; // warten bis Daten rein kommen
 while(!client.available() && (millis()<ultimeout) ) {
   delay(1);
 }
 if(millis()>ultimeout) return; 
 String sRequest = client.readStringUntil('\r');
 client.flush();
 if(sRequest=="") client.stop();
 String sPath="",sParam="", sCmd="";
 String sGetstart="GET ";
 int iStart,iEndSpace,iEndQuest;
 iStart = sRequest.indexOf(sGetstart);
 if (iStart>=0){
   iStart+=+sGetstart.length();
   iEndSpace = sRequest.indexOf(" ",iStart);
   iEndQuest = sRequest.indexOf("?",iStart);
   if(iEndSpace>0) { // Sind da Parameter ?
     if(iEndQuest>0) {
       sPath  = sRequest.substring(iStart,iEndQuest); // Parameter vorhanden
       sParam = sRequest.substring(iEndQuest,iEndSpace);
     }
     else {
       sPath  = sRequest.substring(iStart,iEndSpace); // keine Parameter
     }
   }
 }
 if(sParam.length()>0) {
   int iEqu=sParam.indexOf("=");
   if(iEqu>=0) sCmd = sParam.substring(iEqu+1,sParam.length());
 }
 String sResponse,sHeader;
 if(sPath!="/") { // 404 Fehler
   sResponse="<html><head><title>404 Not Found</title></head><body><h1>Not Found</h1><p>The requested URL was not found on this server.</p></body></html>";
   sHeader  = "HTTP/1.1 404 Not found\r\n";
   sHeader += "Content-Length: ";
   sHeader += sResponse.length();
   sHeader += "\r\n";
   sHeader += "Content-Type: text/html\r\n";
   sHeader += "Connection: close\r\n";
   sHeader += "\r\n";
 }
 else { // Seite ausgeben
  
   sResponse  = "<html><head><title>NKG-Projekt 2020 Aquaponik</title></head><body>";
   sResponse += "<font color=\"#000000\"><body bgcolor=\"#FFFFFF\">";
   sResponse += "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=yes\">";
   sResponse += "<h1>NKG-Projekt 2020 Aquaponik</h1>";
   sResponse += "LED Ein- und Ausschalten.
";
   sResponse += "<FONT SIZE=+1>";
   sResponse += "<p>LED <a href=\"?pin=LEDEIN\"><button>einschalten</button></a>&nbsp;<a href=\"?pin=LEDAUS\"><button>ausschalten</button></a></p>";
   if (sCmd.length()>0) {
     
     if(sCmd.indexOf("LEDEIN")>=0) { // LED einschalten
       digitalWrite(led, HIGH);
     }
     if(sCmd.indexOf("LEDAUS")>=0){ // LED ausschalten
       digitalWrite(led, LOW);
     }
   } 
   
   sResponse += "von Patrick Scheck
";
   sResponse += "</body></html>";
   sHeader  = "HTTP/1.1 200 OK\r\n";
   sHeader += "Content-Length: ";
   sHeader += sResponse.length();
   sHeader += "\r\n";
   sHeader += "Content-Type: text/html\r\n";
   sHeader += "Connection: close\r\n";
   sHeader += "\r\n";
 }
 client.print(sHeader);
 client.print(sResponse);
 client.stop();
}

void printWiFiStatus() {
 // print the SSID of the network you're attached to:
 Serial.print("SSID: ");
 Serial.println(WiFi.SSID());

 // print your WiFi shield's IP address:
 IPAddress ip = WiFi.localIP();
 Serial.print("IP Address: ");
 Serial.println(ip);

 // print where to go in a browser:
 Serial.print("To see this page in action, open a browser to http://");
 Serial.println(ip);

}

Das LED ein/ausschalten soll über den Webserver ablaufen (per Knopfdruck), aber nach Ein/Ausschalten sollten immer noch analogwerte weiter ausgelesen werden, was aber dato nicht funktioniert.

Ich kann in deinem Sketch leider nicht erkennen, wo du den analogen Pin definiert hast und diesen auch zum einlesen von irgend etwas verwendest.
Evtl. hast du den ja vergessen ?

Und wo in Deinem geposteten Sketch werden jetzt die analogen Sensoren ausgelesen, wo sind die angeschlossen?
ich finde da nirgends eine Stelle, wo das geschieht. Oder übersehe ich es schlichtweg?

LG Stefan

edit: Hotsystems gedanken und finger waren schneller.

Okay, hilft euch das weiter?

Code:

int RED = 3;
int brightness = 0;
int DELAY = 10;
#define Lichtsensor A0
#define Lichtsensor A1
#define C02-Sensor A2
#define C02-Sensor A3
#define Temperaturfuelher A4
#define Temperaturfuelher A5
#include <multi_channel_relay.h>

/**
channle: 4 3 2 1
state: 0b0000 → 0x00 (all off)
state: 0b1111 → 0x0f (all on)
*/

Multi_Channel_Relay relay;

//SETUP

void setup() {

//beginn der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);

for (brightness = 0; brightness < 255; brightness ++) {
analogWrite(RED, brightness);
delay(DELAY);
}
analogWrite(RED, 255);

DEBUG_PRINT.begin(9600);
while (!DEBUG_PRINT);

// Setze I2C-Adresse
relay.begin(0x11);

/* Starte Relais-Check */
DEBUG_PRINT.println(“Channel 1 on”);
relay.turn_on_channel(1);
delay(500);
DEBUG_PRINT.println(“Channel 2 on”);
relay.turn_off_channel(1);
relay.turn_on_channel(2);
delay(500);
DEBUG_PRINT.println(“Channel 3 on”);
relay.turn_off_channel(2);
relay.turn_on_channel(3);
delay(500);
DEBUG_PRINT.println(“Channel 4 on”);
relay.turn_off_channel(3);
relay.turn_on_channel(4);
delay(500);
relay.turn_off_channel(4);

relay.channelCtrl(CHANNLE1_BIT |
CHANNLE2_BIT |
CHANNLE3_BIT |
CHANNLE4_BIT);
DEBUG_PRINT.print("Turn all channels on, State: ");
DEBUG_PRINT.println(relay.getChannelState(), BIN);

delay(2000);

relay.channelCtrl(CHANNLE1_BIT |
CHANNLE3_BIT);
DEBUG_PRINT.print("Turn 1 3 channels on, State: ");
DEBUG_PRINT.println(relay.getChannelState(), BIN);

delay(2000);

relay.channelCtrl(CHANNLE2_BIT |
CHANNLE4_BIT);
DEBUG_PRINT.print("Turn 2 4 channels on, State: ");
DEBUG_PRINT.println(relay.getChannelState(), BIN);

delay(2000);

relay.channelCtrl(0);
DEBUG_PRINT.print("Turn off all channels, State: ");
DEBUG_PRINT.println(relay.getChannelState(), BIN);

delay(2000);

void loop() {

// Liest den Analogen eingang A0 aus (Werte zwischen 0 und 1023)
int analogValue0 = analogRead(A0);

Serial.print("Analog reading = ");
Serial.print(analogValue0); // rohdaten

// Einteilung der Helligkeitswerte (Werte zwischen 0 und 800)
if (analogValue0 < 0) {
Serial.println(" - Dark");
analogWrite(RED, 255 );
} else if (analogValue0 < 50) {
Serial.println(" - Dark");
analogWrite(RED, 239);
} else if (analogValue0 < 100) {
Serial.println(" - Dim");
analogWrite(RED, 224);
} else if (analogValue0 < 150) {
Serial.println(" - Dim");
analogWrite(RED, 208);
} else if (analogValue0 < 200) {
Serial.println(" - Dim");
analogWrite(RED, 192);
} else if (analogValue0 < 250) {
Serial.println(" - Light");
analogWrite(RED, 176);
} else if (analogValue0 < 300) {
Serial.println(" - Light");
analogWrite(RED, 160);
} else if (analogValue0 < 350) {
Serial.println(" - Bright");
analogWrite(RED, 144);
} else if (analogValue0 < 400) {
Serial.println(" - Bright");
analogWrite(RED, 128);
} else if (analogValue0 < 450) {
Serial.println(" - Bright");
analogWrite(RED, 112);
} else if (analogValue0 < 500) {
Serial.println(" - Bright");
analogWrite(RED, 96);
} else if (analogValue0 < 550) {
Serial.println(" - Bright");
analogWrite(RED, 80);
} else if (analogValue0 < 650) {
Serial.println(" - Bright");
analogWrite(RED, 64);
} else if (analogValue0 < 700) {
Serial.println(" - Bright");
analogWrite(RED, 48);
} else if (analogValue0 < 700) {
Serial.println(" - Very Bright");
analogWrite(RED, 32);
} else if (analogValue0 < 700) {
Serial.println(" - Very Bright");
analogWrite(RED, 16);
} else {
Serial.println(" - Very bright");
analogWrite(RED, 0);
}

delay(1000);

// Liest den Analogen eingang A0 aus (Werte zwischen 0 und 1023)
int analogValue1 = analogRead(A1);

Serial.print("Analog reading = ");
Serial.print(analogValue1); // rohdaten

// Einteilung der Helligkeitswerte (Werte zwischen 0 und 800)
if (analogValue1 < 10) {
Serial.println(" - Dark");
} else if (analogValue1 < 250) {
Serial.println(" - Dim");
} else if (analogValue1 < 500) {
Serial.println(" - Light");
} else if (analogValue1 < 750) {
Serial.println(" - Bright");
} else {
Serial.println(" - Very bright");
}

delay(1000);

// Liest den Analogen eingang A2 aus (Werte zwischen 0 und 1023)
int analogValue2 = analogRead(A2);

Serial.print("Analog reading = ");
Serial.print(analogValue2); // rohdaten

// Einteilung der C02-Werte (Werte zwischen 0 und 5000)
if (analogValue2 < 100) {
Serial.println(" - Very Low");
} else if (analogValue2 < 200) {
Serial.println(" - Very Low");
} else if (analogValue2 < 400) {
Serial.println(" - Low");
} else if (analogValue2 < 600) {
Serial.println(" - Low");
} else if (analogValue2 < 800) {
Serial.println(" - Mid");
} else if (analogValue2 < 1000) {
Serial.println(" - Mid");
} else if (analogValue2 < 1200) {
Serial.println(" - High");
} else if (analogValue2 < 1400) {
Serial.println(" - High");
} else if (analogValue2 < 1600) {
Serial.println(" - Very High");
} else if (analogValue2 < 1800) {
Serial.println(" - Very High");
} else {
Serial.println(" - Very bright");
}

delay(1000);

// Liest den Analogen eingang A3 aus (Werte zwischen 0 und 1023)
int analogValue3 = analogRead(A3);

Serial.print("Analog reading = ");
Serial.print(analogValue3); // rohdaten

// Einteilung der C02-Werte (Werte zwischen 0 und 5000)
if (analogValue3 < 100) {
Serial.println(" - Very Low");
} else if (analogValue3 < 200) {
Serial.println(" - Very Low");
} else if (analogValue3 < 400) {
Serial.println(" - Low");
} else if (analogValue3 < 600) {
Serial.println(" - Low");
} else if (analogValue3 < 800) {
Serial.println(" - Mid");
} else if (analogValue3 < 1000) {
Serial.println(" - Mid");
} else if (analogValue3 < 1200) {
Serial.println(" - High");
} else if (analogValue3 < 1400) {
Serial.println(" - High");
} else if (analogValue3 < 1600) {
Serial.println(" - Very High");
} else if (analogValue3 < 1800) {
Serial.println(" - Very High");
} else {
Serial.println(" - Very bright");
}

delay(1000);

// Liest den Analogen eingang A4 aus (Werte zwischen 0 und 1023)
int analogValue4 = analogRead(A4);

Serial.print("Analog reading = ");
Serial.print(analogValue4); // rohdaten

// Einteilung der Temperaturwerte (Werte zwischen 0 und 100)
if (analogValue4 < 16) {
Serial.println(" - Very Low");
} else if (analogValue4 < 18) {
Serial.println(" - Low");
} else if (analogValue4 < 20) {
Serial.println(" - Mid");
} else if (analogValue4 < 22) {
Serial.println(" - Mid");
} else if (analogValue4 < 24) {
Serial.println(" - High");
} else if (analogValue4 < 26) {
Serial.println(" - High");
} else if (analogValue4 < 28) {
Serial.println(" - Very High");
} else if (analogValue4 < 30) {
Serial.println(" - Very High");
} else if (analogValue4 < 32) {
Serial.println(" - Overheat");
} else if (analogValue4 < 34) {
Serial.println(" - Overheat");
} else {
Serial.println(" - Overheat");
}

delay(1000);

// Liest den Analogen eingang A5 aus (Werte zwischen 0 und 1023)
int analogValue5 = analogRead(A5);

Serial.print("Analog reading = ");
Serial.print(analogValue5); // rohdaten

// Einteilung der Temperaturwerte (Werte zwischen 0 und 100)
if (analogValue5 < 16) {
Serial.println(" - Very Low");
} else if (analogValue5 < 18) {
Serial.println(" - Low");
} else if (analogValue5 < 20) {
Serial.println(" - Mid");
} else if (analogValue5 < 22) {
Serial.println(" - Mid");
} else if (analogValue5 < 24) {
Serial.println(" - High");
} else if (analogValue5 < 26) {
Serial.println(" - High");
} else if (analogValue5 < 28) {
Serial.println(" - Very High");
} else if (analogValue5 < 30) {
Serial.println(" - Very High");
} else if (analogValue5 < 32) {
Serial.println(" - Overheat");
} else if (analogValue5 < 34) {
Serial.println(" - Overheat");
} else {
Serial.println(" - Overheat");
}

delay(1000);
}
//***********************************************************************************************

Das wichtige für mich ist jetzt erstmal, ob analogwertverarbeitung und WLAN Steuerung am Arduino parallel überhaupt funktioniert, hat damit jemand schon Erfahrungen gemacht?
Und wie wird das im Programmcode sichergestellt, dass die Analogwertverarbeitung weiterläuft? mit “interupt”?

Verwende bitte Code-Tags, so ist dein Bandwurm-Code nicht zu lesen.

(deleted)

Zudem fehlt in dem jetzigen Code die Webserver-Anbindung.
Wo dürfen wir uns die denken ?

Ein Tipp, sieh dir mal die Beispiele von Fips an, evtl. hilft dir das weiter.

Hi el_hanah,

die Bedinnung

if (analogValue0 < 0) {
   Serial.println(" - Dark");
   analogWrite(RED, 255 )
}

wird niemals wahr , und damit RED nie auf 255, da AnalogRead(), das du ja in anlaogValue0 einliest, keine Werte kleiner als 0 zurückgibt. der Werte-Bereich von AnalogRead() bewegt sich von 0 bis 1023.

LG Stefan