io attualmente utilizzo un esp01 per ricevere un comando da adafruit, il quale lo rigira via seriale ad arduino per eseguire i vari swich.
questi comandi sono lettere o numeri singoli tipo: 1 3 A G che una volta che arrivano ad arduino letti in formato decimale vanno ad attivare il determinato swich.
il problema è che a volte gli prende il matto e mi avvia gli swich per qualche secondo senza motivo.
pesavo che "complicandogli" la riga di comando il problema potrebbe risolversi, o no? tipo scrivendo "apertura tapparella" "spegnimento luce"
sinceramente non so cosa succede in quegli istanti.
si scusa.. dimenticanza mia: (dal codice arduino ho tolto un bel po di CASE altrimenti superavo i caratteri massimi, comunque la parte di controllo cè tutta
codice esp:
#include <ESP8266WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
#define intervallo 120000 //tempo tra 2 letture di segnale wifi in millisecondi (MODIFICABILE A PIACIMENTO)
char* ricevuto = "";
int risposta = 0;
int segnale;
char inviato = 0;
unsigned long tempinterval; //intervallo tra 2 letture di segnale wifi
/************************* WiFi Access Point *********************************/
#define WLAN_SSID "*****"
#define WLAN_PASS "******"
/************************* Adafruit.io Setup *********************************/
#define AIO_SERVER "io.adafruit.com"
#define AIO_SERVERPORT 1883 // use 8883 for SSL
#define AIO_USERNAME "**********"
#define AIO_KEY "***************"
/************ Global State (you don't need to change this!) ******************/
// Create an ESP8266 WiFiClient class to connect to the MQTT server.
WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
/****************************** Feeds ***************************************/
// impostazioni feed in ricezione o trasmissione
Adafruit_MQTT_Subscribe DomoticaCentrale = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/domotica_centrale");
Adafruit_MQTT_Publish StatoConnessione = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/stato-connessione");
Adafruit_MQTT_Publish SegnaleWifi = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/segnale-wifi");
/*************************** Sketch Code ************************************/
void MQTT_connect();
void setup() {
Serial.begin(9600);
delay(10);
WiFi.begin(WLAN_SSID, WLAN_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
// Serial.println("WiFi connected");
// Serial.println("IP address: "); Serial.println(WiFi.localIP());
// Setup MQTT subscription for onoff feed.
mqtt.subscribe(&DomoticaCentrale);
}
uint32_t x = 0;
void loop() {
if (millis() > (tempinterval + intervallo)) { //lettura segnale ogni TOT millisecondi impostati nel setup
long rssi = WiFi.RSSI();
segnale = int (rssi);
// Serial.print (segnale);
SegnaleWifi.publish(segnale);
tempinterval = millis();
}
if (WiFi.status() != WL_CONNECTED) {
delay(500);
}
MQTT_connect();
Adafruit_MQTT_Subscribe *subscription;
while ((subscription = mqtt.readSubscription(5000))) {
if (subscription == &DomoticaCentrale) {
ricevuto = ((char*)DomoticaCentrale.lastread);
Serial.print(ricevuto);
}
}
if (! mqtt.ping()) {
mqtt.disconnect();
}
}
// Function to connect and reconnect as necessary to the MQTT server.
// Should be called in the loop function and it will take care if connecting.
void MQTT_connect() {
int8_t ret;
// Stop if already connected.
if (mqtt.connected()) {
return;
}
// Serial.print("Connecting to MQTT... ");
uint8_t retries = 3;
while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
// Serial.println(mqtt.connectErrorString(ret));
//Serial.println("Retrying MQTT connection in 5 seconds...");
mqtt.disconnect();
delay(5000); // wait 5 seconds
retries--;
if (retries == 0) {
// basically die and wait for WDT to reset me
while (1);
}
}
StatoConnessione.publish("Domotica Connessa");
}
//arduino nano ricevitore con casi
/*
caso n. movimento codice RF codice Google
caso 1 chiusura totale 5772418 1
caso 2 apertura totale 5772417 2
caso 3 chiusura cucina 408786 3
caso 4 apertura cucina 408792 4
caso 5 chiusura camera 410002 5
caso 6 apertura camera 410008 6
caso 7 chiusura ripostiglio 15250082 7
caso 8 apertura ripostiglio 15250081 8
caso 17 apertura cucina/camera 408787 A
caso 18 chiusura cucina/camera 408791 B
caso 19 acc/spegn led cucina 3312897 C
stop K
caso 20 luce 50 camera 12729608 D
caso 21 luce 100 camera 12729607 E
*/
#include <SoftwareSerial.h> //libreria seriale secondaria
#include <RCSwitch.h> //libreria rf433
#define SOFTRX 3 //pin ricevitore seriale secondario
#define SOFTTX 4 //pin trasmettitore seriale secondario
int pulsal = 6; //pulsante salita manuale
int puldis = 7; //pulsante discesa manuale
int comando = 0; //cifra per comandi
int programmazione; //cifra usata per programmazione
char statoriposo = 30; //cifra che non corrisponde a nessun caso per fermare i cicli
int tempomov = 22000; //durata movimento tapparelle
int tempomezzomov = 13000; //durata movimento tapparelle
int tempoprog = 1000; //durata pressione in programmazione
unsigned long iniziomov;
int flags = 0;
int flagd = 0;
RCSwitch mySwitch = RCSwitch();
SoftwareSerial Serialint(SOFTRX, SOFTTX); //seriale secondaria
//AltSoftSerial Serialrisc(RISCRX, RISCTX); //seriale terziaria
void setup() {
pinMode(SOFTTX, OUTPUT);
pinMode(SOFTRX, INPUT);
pinMode(pulsal, INPUT_PULLUP);
pinMode(puldis, INPUT_PULLUP);
mySwitch.enableTransmit(10); //trasmettitore collegato al pin 10
Serialint.begin(9600); //seriale con modulo wifi
Serial.begin(9600);
// Serial.println("Pronto a ricevere da Google");
}
void loop() {
if (Serial.available()) { // Controllo se vi è qualche comando sul seriale PC
programmazione = (Serial.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
Serial.println (programmazione);
delay (15);
}
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
// Serial.println(comando); //lo scrivo anche nel seriale pc per controllare
}
//comando pulsante salita manuale
if ((digitalRead(pulsal) == LOW) and (flags == 0) )
{
flags = 1;
// Serial.println ("comando salita manuale");
}
if ((digitalRead(pulsal) == HIGH) and (flags == 1))
{
comando = 2;
flags = 0;
// Serial.println ("inizio salita manuale");
delay (500);
}
//comando pulsante discesa manuale
if ((digitalRead(puldis) == LOW) and (flagd == 0) )
{
flagd = 1;
// Serial.println ("comando discesa manuale");
}
if ((digitalRead(puldis) == HIGH) and (flagd == 1))
{
comando = 1;
flagd = 0;
// Serial.println ("inizio discesa manuale");
delay (500);
}
//------------------------------------------------
switch (comando) {
case 1: //chiusura totale
// Serial.println("inizio chiusura totale");
iniziomov = millis();
while ((millis() - iniziomov < (unsigned long)tempomov) && (comando == 1)) {
mySwitch.send(5772418, 24);
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp per bloccare il movimento
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
}
if ((digitalRead(puldis) == LOW) or (digitalRead(pulsal) == LOW)) //blocco movimento
{
comando = statoriposo;
// Serial.println("pressione pulsante arresto");
delay (1000);
break;
}
// Serial.println("chiusura totale");
}
comando = statoriposo;
break;
case 2: //apertura totale
// Serial.println("inizio apertura totale");
iniziomov = millis();
while ((millis() - iniziomov < (unsigned long)tempomov) && (comando == 2)) {
mySwitch.send(5772417, 24);
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp per bloccare il movimento
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
}
if ((digitalRead(puldis) == LOW) or (digitalRead(pulsal) == LOW)) //blocco movimento
{
comando = statoriposo;
// Serial.println("pressione pulsante arresto");
delay (1000);
break;
}
// Serial.println("apertura totale");
}
comando = statoriposo;
break;
case 3: //chiusura cucina
// Serial.println("inizio chiusura cucina");
iniziomov = millis();
while ((millis() - iniziomov < (unsigned long)tempomov) && (comando == 3)) {
mySwitch.send(408786, 24);
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp per bloccare il movimento
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
}
// Serial.println("chiusura cucina");
}
comando = statoriposo;
break;
case 8: //apertura ripostiglio
// Serial.println("inizio apertura ripostiglio");
iniziomov = millis();
while ((millis() - iniziomov < (unsigned long)tempomov) && (comando == 8)) {
mySwitch.send(15250081, 24);
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp per bloccare il movimento
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
}
// Serial.println("apertura ripostiglio");
}
comando = statoriposo;
break;
case 17: //apertura totale/parziale ripostiglio
// Serial.println("inizio apertura parziale");
iniziomov = millis();
while ((millis() - iniziomov < (unsigned long)tempomov) && (comando == 17)) { //apertura totale cucina/camera
mySwitch.send(408787, 24);
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp per bloccare il movimento
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
}
// Serial.print("apertura parziale 1");
}
delay (700);
iniziomov = millis();
while ((millis() - iniziomov < (unsigned long)tempomezzomov) && (comando == 17)) { //mezza apertura ripostiglio
mySwitch.send(15250081, 24);
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp per bloccare il movimento
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
}
//Serial.println("apertura parziale 2");
}
comando = statoriposo;
break;
//------------------------------------------------
}
ORSO2001:
il problema si presenta per un case specifico o va a caso?
Và a caso facendo movimenti da circa un secondo.
Però pensando a cosa potrebbe essere, mi sono ricordato che quando facevo le prime prove a pc con l'esp per collegarlo ad Adafruit, una o due volte mi aveva stampato a seriale "lost package" o qualcosa del genere.
Quindi con il mio codice così com'è, se arriva questo "lost package" me lo rigira a seriale e Arduino legge una lettera alla volta eseguendo qualcosa, o sbaglio?
Una singola lettera è un pò poco, una frase troppo.
Un protocollo fatto in casa, semplice: spedisci un carattere di inizio trasmissione, il comando e un fine trasmissione. Esempio #C@ dove C è il comando
nid69ita:
Una singola lettera è un pò poco, una frase troppo.
Un protocollo fatto in casa, semplice: spedisci un carattere di inizio trasmissione, il comando e un fine trasmissione. Esempio #C@ dove C è il comando
Quei simboli per filtrare eventuali parole strane?
Quindi io da Adafruit invio #C@, l'esp me lo rigira ad Arduino e poi lui deve estrapolare solo la c (che poi convertita in decimale mi avvia il CASE)?
come dice nid69ita, e come ti chiedevo io, si deve sempre implementare un controllo su quello che passi...il più semplice è carattere di inizio, comando, carattere di fine...però così non hai il controllo se il comando ricevuto è esattamente quello che hai inviato...ci vorrebbe un qualche controllo...di solito un checksum od un CRC....e per completare il tutto il ricevente deve far sapere a chi ha inviato che il tutto è andato a buon fine o meno...quindi anche qui una stringa di ritorno con controlli del caso.
ORSO2001:
come dice nid69ita, e come ti chiedevo io, si deve sempre implementare un controllo su quello che passi...il più semplice è carattere di inizio, comando, carattere di fine...però così non hai il controllo se il comando ricevuto è esattamente quello che hai inviato...ci vorrebbe un qualche controllo...di solito un checksum od un CRC....e per completare il tutto il ricevente deve far sapere a chi ha inviato che il tutto è andato a buon fine o meno...quindi anche qui una stringa di ritorno con controlli del caso.
Sarebbe l ideale ma così penso si complichi parecchio il codice. O almeno è fuori dalle mie conoscenze
acuplush:
Sarebbe l ideale ma così penso si complichi parecchio il codice. O almeno è fuori dalle mie conoscenze
Già racchiudere il dato tra i due delimitatori riduce la possibilità di ricevere per errore stringhe combacianti, ma non abbiamo sicurezza sulla correttezza del dato racchiuso tra essi. Se non si vuole implementare un vero controllo errori si può anche ripetere il dato due o tre volte, tipo #CCC@, che alla fine è il controllo errori più semplice.
acuplush:
il problema è che a volte gli prende il matto e mi avvia gli swich per qualche secondo senza motivo.
pesavo che "complicandogli" la riga di comando il problema potrebbe risolversi, o no? tipo scrivendo "apertura tapparella" "spegnimento luce"
Puoi anche fare così, magari togliendo gli spazi.
Se però vuoi anche evitare che un comando spedito corretto arrivi corrotto e quindi non eseguito dovresti anche aggiungere una risposta da parte di Arduino.
per ridurre i problemi al minimo ho deciso di lavorare solo con l'esp e senza arduino, ho modificato leggermente il codice per farlo funzionare tutto da lì con il criterio che usavo io, ma ora come faccio a fare quello che dite voi? ovvero:
se ricevo #AAA@ e le tre lettere sono uguali, pesca una lettera ed esegui lo switch. così sarebbe la logica, no?
così nell'eventualità arrivino altri messaggi tipo il famoso "lost package" non esegue nulla
//------------------------------------------------
Adafruit_MQTT_Subscribe *subscription;
while ((subscription = mqtt.readSubscription(5000))) {
if (subscription == &DomoticaCentrale) {
ricevuto = ((char*)DomoticaCentrale.lastread);
comando = (ricevuto, DEC);
//Serial.print(comando);
}
}
//------------------------------------------------
switch (comando) {
case 1: //chiusura totale
acuplush:
Và a caso facendo movimenti da circa un secondo.
Uhm io prima di iniziare ad implementare cose sul protocollo cercherei di capire meglio se siano errori di trasmissione/ricezione o cosa altro. Ad esempio non potresti mostrare su un'altra seriale (o su un LCD quantomeno se non hai una seriale disponibile) i caratteri/byte ricevuti, per capire se le cause di questi movimenti anomali sono proprio "cose sporche" per problemi di cablaggio o comunicazione, o altro?
docdoc:
Uhm io prima di iniziare ad implementare cose sul protocollo cercherei di capire meglio se siano errori di trasmissione/ricezione o cosa altro. Ad esempio non potresti mostrare su un'altra seriale (o su un LCD quantomeno se non hai una seriale disponibile) i caratteri/byte ricevuti, per capire se le cause di questi movimenti anomali sono proprio "cose sporche" per problemi di cablaggio o comunicazione, o altro?
Un LCD non mi è possibile metterlo, dovrei girare su seriale i valori che riceve arduino e lasciarlo collegato al pc.
Con la fortuna che ho non ci sarà nessun problema nel tempo di monitoraggio
acuplush:
e lasciarlo collegato al pc.
Con la fortuna che ho non ci sarà nessun problema nel tempo di monitoraggio
Non serve parlare di fortuna... se si tratta di disturbi di origine elettrica il solo fatto di lasciarlo collegato ad un PC può alterare le condizioni e impedire ai disturbi di manifestarsi (o, al contrario, li potrebbe aumentare).
Per quanto riguarda la lettura non saprei, non so cosa produce quella libreria. Se 'ricevuto' è una stringa allora basta verificare che la prima posizione sia '#', l'ultima '@' e che in mezzo ci siano tre byte identici.
acuplush:
Un LCD non mi è possibile metterlo, dovrei girare su seriale i valori che riceve arduino e lasciarlo collegato al pc.
Con la fortuna che ho non ci sarà nessun problema nel tempo di monitoraggio
Beh tentare non nuoce. Quantomeno lo farei prima di sbattersi a cambiare il protocollo, perché come dico sempre, bisogna cercare PRIMA di capire il problema, e POI in base a questo dare una eventuale soluzione/contromisura.
Fare il contrario va bene se per pura fortuna hai azzeccato la contromisura, ma nella maggior parte dei casi stai introducendo una ulteriore variabilità o fonte di regressioni. O, per bene che ti vada, hai "solo" sprecato del tempo a fare una cosa inutile.
Se dovesse risultare un problema di trasmissione, magari capire se dipende da cablaggi, cavi o interferenze e quindi roba da risolvere lato hardware. Se non fosse possibile per qualche ragione, allora bisogna implementare qualche semplice protocollo di correzione errori. Possibilmente con handshake ACK/NAK, se il destinatario rileva un errore (es. tramite semplice checksum o altro, di metodi ce ne sono svariati).
ho lasciato da ieri sera il pc a monitorare il seriale e sono comparse le anomalie.
premessa:
l'esp mi rigira su seriale tutto quello che riceve dal canale prestabilito del server mqtt tramite questo comando:
Adafruit_MQTT_Subscribe *subscription;
while ((subscription = mqtt.readSubscription(5000))) {
if (subscription == &DomoticaCentrale) {
ricevuto = ((char*)DomoticaCentrale.lastread);
Serial.print(ricevuto);
}
}
arduino riceve da seriale e attiva gli swich in base al codice ricevuto (il -48 l'ho messo per risolvere un problema di conversioni dei caratteri... so che è una porcheria ma ha funzionato )
if (Serialint.available()) { // Controllo se vi è qualche comando in arrivo dall'esp
comando = (Serialint.read() - 48); //Metto nella variabile comando quanto ricevuto dalla seriale
delay (15);
#ifdef DEBUG
Serial.print("ricevuto da ESP ");
Serial.println(comando); //lo scrivo anche nel seriale pc per controllare
#endif
}
il risultato ottenuto mi ha composto varie parole tipo reset , soft , end , ffffd , ctx: , cont ecc... ed ovviamente qualche lettera mi attiva gli swich
metto una piccola parte per farvi capire:
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP 35
ricevuto da ESP 63
ricevuto da ESP 54
ricevuto da ESP 68
ricevuto da ESP -16
ricevuto da ESP 39
ricevuto da ESP 20
com 20
com 20
com 20
ricevuto da ESP 36
ricevuto da ESP -16
ricevuto da ESP 66
ricevuto da ESP 53
ricevuto da ESP 67
ricevuto da ESP 53
ricevuto da ESP 68
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP 51
ricevuto da ESP 68
ricevuto da ESP 72
ricevuto da ESP 10
ricevuto da ESP -16
ricevuto da ESP 51
ricevuto da ESP 63
ricevuto da ESP 62
ricevuto da ESP 68
ricevuto da ESP -16
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP 67
ricevuto da ESP 64
ricevuto da ESP 10
ricevuto da ESP -16
ricevuto da ESP 3
inizio chiusura cucina
com 3
chiusura cucina
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 52
ricevuto da ESP 9
ricevuto da ESP 0
ricevuto da ESP -16
ricevuto da ESP 53
ricevuto da ESP 62
ricevuto da ESP 52
ricevuto da ESP 10
ricevuto da ESP -16
ricevuto da ESP 3
inizio chiusura cucina
com 3
chiusura cucina
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 52
ricevuto da ESP 0
ricevuto da ESP -16
ricevuto da ESP 63
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 67
ricevuto da ESP 53
ricevuto da ESP -38
ricevuto da ESP 4
inizio apertura cucina
com 4
apertura cucina
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 0
ricevuto da ESP 0
ricevuto da ESP 34
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP 35
ricevuto da ESP 63
ricevuto da ESP 54
ricevuto da ESP 68
ricevuto da ESP -16
ricevuto da ESP 39
ricevuto da ESP 20
com 20
com 20
com 20
ricevuto da ESP 36
ricevuto da ESP -16
ricevuto da ESP 66
ricevuto da ESP 53
ricevuto da ESP 67
ricevuto da ESP 53
ricevuto da ESP 68
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP 51
ricevuto da ESP 68
ricevuto da ESP 72
ricevuto da ESP 10
ricevuto da ESP -16
ricevuto da ESP 51
ricevuto da ESP 63
ricevuto da ESP 62
ricevuto da ESP 68
ricevuto da ESP -16
ricevuto da ESP -35
ricevuto da ESP -38
ricevuto da ESP 67
ricevuto da ESP 64
ricevuto da ESP 10
ricevuto da ESP -16
ricevuto da ESP 3
inizio chiusura cucina
com 3
chiusura cucina
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 54
ricevuto da ESP 52
ricevuto da ESP 9
ricevuto da ESP 0
ricevuto da ESP -16
ricevuto da ESP 53
ricevuto da ESP 62
ricevuto da ESP 52
ricevuto da ESP 10
ricevuto da ESP -16
ricevuto da ESP 3
Claudio_FF:
Non serve parlare di fortuna... se si tratta di disturbi di origine elettrica il solo fatto di lasciarlo collegato ad un PC può alterare le condizioni e impedire ai disturbi di manifestarsi (o, al contrario, li potrebbe aumentare).
Per quanto riguarda la lettura non saprei, non so cosa produce quella libreria. Se 'ricevuto' è una stringa allora basta verificare che la prima posizione sia '#', l'ultima '@' e che in mezzo ci siano tre byte identici.
ciao, per cercare di risolvere il problema ho deciso di applicare il tuo suggerimento, ma non riesco a capire come convertire i caratteri che ricevo dal server in "string" per poi inviarla ad arduino.
così com'è configurato ora se io invio dal server una parola con più di un carattere tipo 12 o ON, sul seriale di arduino arrivano "separare" ovvero lui mi attiva prima il comando relativo a 1, poi 2, o O e poi N
spero di aver reso l'idea di quello che succede,quindi presumo che nell'ESP devo convertire in "string" in modo che arduino la riceva e poi fare il controllo che dici tu,giusto?
