Ciao a tutti,
Sto riscontrando un problema con il mio progetto Arduino in cui sto utilizzando un modulo WiFi (WiFiNINA) per connettermi a un server e inviare richieste HTTP.
Ecco i dettagli della mia configurazione e i problemi che sto affrontando:
Configurazione:
Scheda: Arduino MKR WiFi 1010
Modulo WiFi: WiFiNINA
Server: Un server locale XAMPP con indirizzo IP 192.168.1.106, in ascolto sulla porta 80.
Problemi riscontrati:
- Connessione al server con WiFiClient:
Quando tento di connettermi al server utilizzando Client.connect(), la connessione credo fallisca senza fornire dettagli utili su cosa potrebbe andare storto. Tuttavia, posso accedere correttamente al server sia dallo smartphone che dal PC (passando con il get), quindi il server e "l'endpoint" sembrano funzionare come previsto.
Per togliermi il dubbio ho provato a pingare il server da Arduino.
Ping al server:
Ho provato a eseguire il ping del server utilizzando WiFi.ping(serverIP), ma il processo sembra bloccarsi e non fornisce alcun risultato utile. L'IDE di Arduino rimane bloccato al passaggio del ping e non riesco a ottenere alcun debug.
Mi scuso per eventuali errori gravi; Sto usando Arduino solo da pochi giorni.
#include <ArduinoBLE.h>
#include <WiFiNINA.h>
// Configurazione Wi-Fi
const char* ssid = "TP-Link_7E32";
const char* password = "77199232";
//const char* ssid = "Server";
//const char* password = "123456789";
// Definisci l'indirizzo IP come un oggetto IPAddress
IPAddress serverIP(192, 168, 1, 106); // IP del server
const char* serverUrl = "192.168.1.106";
const int serverPort = 80;
// Pin del LED wifi fisso connesso lampeggia non connesso
const int ledPin = 12;
// UUID di interesse
const String targetUUID = "0000000100-0000-0100-0000-0100000001";
// Pin del relè
const int relayPin = 7;
bool relayActive = false;
unsigned long relayStartTime = 0;
// Soglia RSSI (dBm) - Ignora beacon con RSSI maggiore di questa soglia
const int rssiThreshold = -40;
// Pin del sensore a ultrasuoni
const int trigPin = 0;
const int echoPin = 1;
// Soglia di distanza per avviare la scansione (in cm)
const float distanceThreshold = 150.0; // 1.5 metri = 150 cm
bool scanning = false;
unsigned long scanStartTime = 0;
WiFiClient client;
void setup() {
Serial.begin(9600);
while (!Serial);
// Configurazione del pin del LED
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, LOW); // LED Spento inizialmente
pinMode(relayPin, OUTPUT);
digitalWrite(relayPin, LOW);
// Configurazione del sensore a ultrasuoni
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
// Connessione al Wi-Fi
Serial.println("Connessione al Wi-Fi...");
WiFi.begin(ssid, password);
int attempts = 0;
while (WiFi.status() != WL_CONNECTED && attempts < 20) {
delay(500);
Serial.print(".");
attempts++;
}
if (WiFi.status() == WL_CONNECTED) {
Serial.println("Connesso al Wi-Fi!");
} else {
Serial.println("Connessione al Wi-Fi fallita.");
while (1); // Fermo il programma in caso di fallimento
}
// Avvio BLE
if (!BLE.begin()) {
Serial.println("Avvio del modulo BLE non riuscito!");
while (1);
}
}
void loop() {
// Misura la distanza con il sensore a ultrasuoni
float distance = measureDistance();
Serial.print("Distanza misurata: ");
Serial.print(distance);
Serial.println(" cm");
// Logica di scansione
if (distance <= distanceThreshold) {
// Avvia la scansione BLE se non è già in corso
if (!scanning) {
Serial.println("Inizio scansione BLE...");
BLE.scan();
scanning = true;
scanStartTime = millis();
}
if (scanning) {
BLEDevice peripheral = BLE.available();
if (peripheral) {
int rssi = peripheral.rssi();
Serial.print("RSSI del beacon: ");
Serial.println(rssi);
// Ignora beacon con RSSI sopra la soglia
if (rssi > rssiThreshold) {
Serial.println("Beacon ignorato (RSSI troppo alto).");
return; // Non elaborare questo beacon
}
Serial.print("Dispositivo BLE rilevato: ");
Serial.println(peripheral.address());
if (peripheral.hasAdvertisedServiceUuid()) {
// Estrazione dati dal beacon
uint8_t advData[31];
int length = peripheral.advertisementData(advData, sizeof(advData));
if (length > 0) {
String uuid = formatUUID(advData);
String major = String((advData[27] << 8) | advData[26], HEX);
String minor = String((advData[29] << 8) | advData[28], HEX);
Serial.print("UUID: ");
Serial.println(uuid);
Serial.print("Major: ");
Serial.println(major);
Serial.print("Minor: ");
Serial.println(minor);
// Controllo dell'UUID
if (uuid.startsWith(targetUUID)) {
Serial.println("Beacon con UUID appartenente al gruppo trovato. Controllo nel database...");
scanning = false; // Interrompe la scansione
// Verifica la presenza del beacon nel database
if (checkBeaconWithServer(uuid, major, minor)) {
Serial.println("Beacon presente nel DB. Attivazione varco...");
digitalWrite(relayPin, HIGH);
relayActive = true;
relayStartTime = millis();
} else {
Serial.println("Beacon non presente nel database, accesso negato.");
}
} else {
Serial.println("Beacon con UUID non appartenente al gruppo.");
}
} else {
Serial.println("Dati beacon vuoti o non validi.");
}
} else {
Serial.println("Questo dispositivo BLE non pubblica un UUID di servizio.");
}
} else {
Serial.println("Nessun dispositivo BLE trovato.");
}
}
} else {
// Interrompe la scansione se l'oggetto esce dalla soglia di distanza
if (scanning) {
Serial.println("Scansione BLE interrotta, beacon troppo distante.");
scanning = false;
}
}
if (relayActive && millis() - relayStartTime >= 3000) {
Serial.println("Disattivazione del relè.");
digitalWrite(relayPin, LOW);
relayActive = false;
}
// Attende 500 millisecondi prima di effettuare una nuova misura
delay(500);
}
float measureDistance() {
long duration;
float distance;
// Pulisce il pin TRIG
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Genera un impulso di 10 microsecondi sul pin TRIG
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Legge la durata dell'impulso di ritorno dal pin ECHO
duration = pulseIn(echoPin, HIGH);
// Calcola la distanza in cm
distance = (duration / 2.0) * 0.0344;
return distance;
}
String formatUUID(uint8_t* advData) {
String uuid = "";
for (int i = 9; i < 25; i++) {
uuid += String(advData[i] >> 4, HEX);
uuid += String(advData[i] & 0x0F, HEX);
if (i == 13 || i == 15 || i == 17 || i == 19) uuid += "-";
}
uuid.toUpperCase();
return uuid;
}
bool checkBeaconWithServer(String uuid, String major, String minor) {
String path = String("/endp.php?uuid=") + uuid + "&major=" + major + "&minor=" + minor;
Serial.println("Richiesta: " + path);
// Definisci l'indirizzo IP del server
IPAddress serverIP(192, 168, 1, 106);
// Esegui il ping
int pingResult = WiFi.ping(serverIP);
// Gestisci il risultato del ping
switch (pingResult) {
case WL_SUCCESS:
Serial.print("SUCCESS! RTT = ");
Serial.print(pingResult);
Serial.println(" ms");
break;
case WL_PING_DEST_UNREACHABLE:
Serial.println("FAILED! Destination unreachable.");
return false;
case WL_PING_TIMEOUT:
Serial.println("FAILED! Ping timeout.");
return false;
case WL_PING_UNKNOWN_HOST:
Serial.println("FAILED! Unknown host.");
return false;
case WL_PING_ERROR:
Serial.println("FAILED! Ping error.");
return false;
default:
Serial.println("FAILED! Unknown error.");
return false;
}
// Tentativo di connessione al server
Serial.println("Tentativo di connessione a: " + serverIP.toString() + ":" + String(serverPort));
if (client.connect(serverUrl, serverPort)) {
Serial.println("Connessione riuscita!"); // Debug: conferma connessione
// Invia la richiesta HTTP
client.println("GET " + path + " HTTP/1.1");
client.println("Host: 192.168.1.106");
client.println("Connection: close");
client.println(); // Righe vuote per terminare le intestazioni della richiesta
// Attende la risposta dal server
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 10000) { // Timeout di 10 secondi
Serial.println("Tempo di attesa scaduto. Connessione interrotta.");
client.stop();
return false;
}
delay(100); // Evita di bloccare la CPU
}
// Leggi la risposta del server
String response = "";
while (client.available()) {
char c = client.read();
response += c;
}
// Mostra la risposta ricevuta
Serial.print("Risposta dal server: ");
Serial.println(response);
// Controlla se la risposta contiene "OK"
if (response.indexOf("OK") >= 0) {
Serial.println("Beacon confermato nel database.");
client.stop();
return true;
} else {
Serial.println("Beacon non confermato nel database.");
client.stop();
return false;
}
} else {
Serial.println("Connessione al server fallita.");
return false;
}
}
serial monitor output:
14:28:47.755 -> Distanza misurata: 5.25 cm
14:28:47.755 -> Nessun dispositivo BLE trovato.
14:28:48.258 -> Distanza misurata: 5.25 cm
14:28:48.258 -> RSSI del beacon: -88
14:28:48.258 -> Dispositivo BLE rilevato: 84:c6:92:df:14:9f
14:28:48.258 -> UUID: 0000000100-0000-0100-0000-0100000001
14:28:48.258 -> Major: 1
14:28:48.258 -> Minor: c501
14:28:48.258 -> Beacon con UUID appartenente al gruppo trovato. Controllo nel database...
14:28:48.258 -> Richiesta: /endp.php?uuid=0000000100-0000-0100-0000-0100000001&major=1&minor=c501
------------------------------firmware check--------------------------
14:45:18.824 -> WiFiNINA firmware check.
14:45:18.824 ->
14:45:19.559 -> Firmware version installed: 1.5.0
14:45:19.559 -> Latest firmware version available : 1.5.0
14:45:19.559 ->
14:45:19.559 -> Check result: PASSED
Ulteriori prove: nel file httpd.conf di apache ho listen 80, se da terminale faccio ping/tracert/curl funziona, ho controllato i log access e errore di apache e niente, compaiono solo le richieste http fatte da browser o smartphone. Non so più dove sbattere la testa, spero qualcuno più bravo di me possa aiutarmi a risolvere il problema.