Progetto Serra Automatica

Ho problemi con quello che definisci con FC_PRESS_LEVEL, cioè sarebbe lo stato dei finecorsa assegnato all'inizio come byte stato_fc = 1 ; o devo creare una nuova variabile

È un nome di comodo (fine post #32). Se non usi un nome di comodo scrivi direttamente il valore che ti interessa.

per esempio intendi così

else if (processo == 3  &&  digitalRead(fcD) == 0) {
   stato_fc != 0;
   fermaMotore();
   stato_fc = 0;
   processo = 4;
  }

Si, anche se non so cosa sia e a cosa serva la variabile 'stato_fc'.

Qui è dove sono arrivato e sembra funzionante

const int MotoreAV = 10;
const int MotoreIN = 11;
const int fcS = 13;
const int fcD = 12;
unsigned long tempo = 0;
byte processo = 0;
byte comandoMotore = 0;


void fermaMotore() {
  pinMode(MotoreAV, LOW);
  pinMode(MotoreIN, LOW);
}
void motoreAvanti() {
  pinMode(MotoreAV, HIGH);
}
void motoreIndietro() {
  pinMode(MotoreIN, HIGH);
}

void setup() {

  pinMode(MotoreAV, OUTPUT);
  fermaMotore();
  pinMode(MotoreIN, OUTPUT);
  fermaMotore();
  pinMode(fcS, INPUT_PULLUP);
  pinMode(fcD, INPUT_PULLUP);
}


void loop() {

  if (processo == 0) {
    fermaMotore();
    processo = 1;
  }
  else if (processo == 1  &&  millis() - tempo >= 3000) {
    
  if (digitalRead(fcS) == 0) {
      processo = 2;
    }
    tempo = millis();
    motoreIndietro();
    processo = 5;
  }
  else if (processo == 2  &&  comandoMotore == 1) {
    motoreAvanti();
    processo = 3;
  }
  else if (processo == 3  &&  digitalRead(fcD) ==0) {
    fermaMotore();
    processo = 4;
  }

  else if (processo == 4  &&  millis() - tempo >= 3000) {
    tempo = millis();
    motoreIndietro();
    processo = 5;
  }
  
  else if (processo == 5  &&  digitalRead(fcS) == 0) {
    fermaMotore();
    processo = 2;
  }
  
}

e qui e tutto insieme

#include <HygrometerSensor.h>
#include <Adafruit_Sensor.h>

const int MotoreAV = 22;
const int MotoreIN = 24;
const int fcS = 28;
const int fcD = 26;
const int Pompa = 9;
const int Ventola = 10;
int Sensore1 = A0;
int Sensore2 = A1;
int sensorValue = 1020;
int sensorValue1 = 1020;
unsigned long tempo = 0;
unsigned long pausa = 0;
unsigned long pausadht = 0;
byte verifica = 0;
byte processo = 0;
byte comandoMotore = 0;
int lettura = Sensore1;
int lettura1 = Sensore2;

//DHT11 Sensor:
#include "DHT.h"
#define DHTPIN 12     // Sensore collegato al PIN 12
#define DHTTYPE DHT11   // DHT 11
DHT dht(DHTPIN, DHTTYPE);

//I2C LCD:
#include <Wire.h> // Libreria WIRE
#include <LiquidCrystal_I2C.h> // Libreria LCD I2C

// LCD I2C address
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

void fermaMotore() {
  pinMode(MotoreAV, LOW);
  pinMode(MotoreIN, LOW);
}
void motoreAvanti() {
  pinMode(MotoreAV, HIGH);
}
void motoreIndietro() {
  pinMode(MotoreIN, HIGH);
}
void avviaPompa() {
  digitalWrite(Pompa, LOW);
}
void fermaPompa() {
  digitalWrite(Pompa, HIGH);
}

void setup() {
  Serial.begin(9600);
  lcd.begin(20, 4);
  Serial.println("Serra Automatica");
  pinMode(MotoreAV, OUTPUT);
  fermaMotore();
  pinMode(MotoreIN, OUTPUT);
  fermaMotore();
  pinMode(fcS, INPUT_PULLUP);
  pinMode(fcD, INPUT_PULLUP);
  pinMode(Pompa, OUTPUT);
  fermaPompa();
  pinMode(Ventola, OUTPUT);
  pinMode(Sensore1, INPUT);
  pinMode(Sensore2, INPUT);
  // Avvio sensore DHT11
  dht.begin();
}

void loop() {
  if (millis() - pausa >= 5000) {
    lettura = analogRead(Sensore1);
    sensorValue = map (lettura, 1008, 319, 0, 100); // converto il valore analogico in percentuale
    Serial.print("Umidità  terra 1 : ");
    Serial.print(sensorValue);
    Serial.println ("%"); //Stampa a schermo il valore

    lettura1 = analogRead(Sensore2);
    sensorValue1 = map (lettura1, 1010, 215, 0, 100); // converto il valore analogico in percentuale
    Serial.print("Umidità  terra 2 : ");
    Serial.print(sensorValue1);
    Serial.println ("%"); //Stampa a schermo il valore
    pausa = millis();
  }
  if (verifica == 0
      &&  lettura >= 775  &&  lettura1 >= 775) {      // condizione di avvio
    tempo = millis();                              // salva tempo attuale
    avviaPompa();                                  // accende pompa
    verifica = 1;                                // passa a situazione 1
  }
  else if (verifica == 1  &&  millis() - tempo >= 10000) { // se passati 10s
    tempo = millis();// salva tempo attuale
    comandoMotore = 1;
  }
  if (processo == 0) {
    fermaMotore();
    processo = 1;
  }
  else if (processo == 1  &&  millis() - tempo >= 3000) {

    if (digitalRead(fcS) == 0) {
      processo = 2;
    }
    tempo = millis();
    motoreIndietro();
    processo = 5;
  }
  else if (processo == 2  &&  comandoMotore == 1) {
    motoreAvanti();
    processo = 3;
  }
  else if (processo == 3  &&  digitalRead(fcD) == 0) {
    fermaMotore();
    tempo = millis();
    processo = 4;
  }

  else if (processo == 4  &&  millis() - tempo >= 3000) {
    tempo = millis();
    motoreIndietro();
    processo = 5;
  }

  else if (processo == 5  &&  digitalRead(fcS) == 0) {
    fermaMotore();
    fermaPompa();
    processo = 2;
  }

  // Lettura umidità e temperatura del sensore DHT11n
  if (comandoMotore = 0) {
    int h = dht.readHumidity();
    int t = dht.readTemperature();
    // Misura la temperatura e se maggiore di ... gradi attiva relè per accendere la ventola
    if (t >= 25 ) {
      digitalWrite (Ventola, LOW); // Attiva Relè 2
    } else {
      digitalWrite (Ventola, HIGH); // Spegni Relè 2
    }
    if (millis() - pausadht >= 60000) {
      Serial.print("Temp: ");
      Serial.print(t);
      Serial.print("C, Umid: ");
      Serial.print(h);
      Serial.println("%");
      pausadht = millis();
    }

    // impostare cursore sulla prima riga:
    lcd.setCursor(0, 0);
    lcd.print("Temperatura: ");
    lcd.print(t);
    lcd.print("C");

    // imposta cursore sulla seconda riga:
    lcd.setCursor(0, 1);
    lcd.print("Umidita' Aria: ");
    lcd.print(h);
    lcd.print("%");

    // imposta il cursore sulla terza riga:
    lcd.setCursor(0, 2);
    lcd.print("Umid..Terra 1: ");
    lcd.print(sensorValue);
    lcd.print("%");

    // imposta il cursore sulla quarta riga:
    lcd.setCursor(0, 3);
    lcd.print("Umid..Terra 2: ");
    lcd.print(sensorValue1);
    lcd.print("%");
  }
}

testandolo va bene ma non capisco perchè con una lettura inferiore a quella impostata dai due Igrometri mi si attiva la funzione motoreAvanti(). se faccio il reset a Arduino tutto ok ho solo il relè della ventola acceso anche se non ho collegato il dht11

[u]Errori nel post #44[/u]

La logica del caso 1, come l'hai scritta, significa questo: se finecorsaS chiuso processo=2, poi comunque motore indietro e processo=5

Mentre invece la logica voluta è: se finecorsaS chiuso processo=2, altrimenti motore indietro e processo=5

In pratica il motore cerca sempre di partire indietro anche se il finecorsa è già premuto.


Poi i tempi, come avevo raccomandato...

Nel caso 1 da quale momento stiamo misurando il tempo? Nel caso 4 da quale momento stiamo misurando il tempo?

NOTA: "Da quale momento" significa quando è l'ultima volta che abbiamo caricato la variabile tempo con un valore?


Poi in questo codice vedo:

void fermaMotore() {
    pinMode(MotoreAV, LOW);
    pinMode(MotoreIN, LOW);
}

Mentre in quello del post #36 vedo:

void fermaMotore() {
  pinMode(MotoreAV, HIGH);
  pinMode(MotoreIN, HIGH);
}

Quindi... hai cambiato hardware e adesso i relé si comandano al contrario?

E poi, perché pinMode :o invece dei digitalWrite che stiamo usando dal post #35?????????


[u]Errori nel post #45[/u]

Prima di tutto, usare la stessa variabile 'tempo' per due logiche diverse.

A cosa serve assegnare 1020 alle variabili sensorValue?

A cosa serve assegnare Sensore1/2 alle variabili lettura?

Perché Sensore1/2 che rappresentano di pin non sono state dichiarate const come tutte le altre variabili che rappresentano dei pin?

La lettura degli igrometri è correttamente temporizzata ogni 5 secondi, ma l'aggiornamento su LCD di questi valori è messo da tutt'altra parte.

La lettura del DHT (e l'aggiornamento LCD) non è temporizzata ma subordinata solo a comandoMotore==0 (con errore nella condizione come è scritta).

Non vedo alcun punto in cui comandoMotore ritorna a zero, anzi, la condizione:

verifica == 1  &&  millis() - tempo >= 10000

continua ad essere vera per cui il motore parte continuamente.

Parte seconda

Scomporre tutto in piccole funzioni a se stanti, decidendo quali variabili servono a una per comandare l’altra, ridurrebbe molto la confusione.

In allegato un esempio di come potrebbe essere scomposto.

NOTE: le uniche variabili globali rimaste sono quelle che portano informazioni da una logica all’altra:

‘comandoMotore’ viene impostata da ‘logicaPompa’ e resettata da ‘logicaMotore’ (così logicaPompa sa anche quando il motore si ferma). ‘lettura’ e ‘lettura1’ vengono impostate da ‘letturaIgrometri’ e lette da ‘logicaPompa’.

Le variabili strettamente personali di ogni logica sono state dichiarate come static all’interno delle funzioni (questa è l’unica novità grossa che permette di usare gli stessi nomi in ogni funzione, quindi per comodità ho chiamato tutte le variabili tempo ‘t’ e quelle di stato ‘s’).

Per chiarezza leggo i finecorsa in un solo punto all’inizio della ‘logicaMotore’ e uso poi le variabili booleane nelle condizioni.

Altre variabili locali, che servono solo dentro le funzioni (come ‘sensorVal’), sono dichiarate nelle funzioni stesse.

I valori sull’LCD vengono aggiornati solo nel momento in cui si fa la misura, la funzione ‘letturaIgrometri’ aggiorna i valori di umidità terreno, la funzione ‘letturaUmTemp’ quelli dell’aria.

Il loop principale si è ridotto a quattro righe, che diventeranno cinque quando aggiungerai la ‘logicaTrasmissione’.

Tutto questo sono DUE punti karma :grinning: :grinning: :grinning: :stuck_out_tongue: :stuck_out_tongue: :stuck_out_tongue:

cicciozuc_serra.ino (7.84 KB)

Due Karma non basterebbero per questo capolavoro,grazie @Claudio_FF, ma perchè appena il finecorsa destro è 1 non attende tre secondi per avviare il motoreIndietro()..

Non ho tutte le librerie e non posso compilare. Nel caso 3 avevo scritto:

   else if (s == 3  &&  fcD_Chiuso)
    {
        fermaMotore();
        tempo = millis();
        s = 4;
    }

...ma la variabile 'tempo' non esiste più, quindi doveva esserci un errore alla compilazione che indicava esattamente quel punto.

Quindi la domanda è: veniva fuori quell'errore?

Possono esserci altri errori, ma basta seguire le istruzioni passo per passo.

Funziona molto bene, ho aggiunto anche la trasmittente tra avviaPompa(), motoreAvanti(), motoreIndietro(), e mi invia i dati in un’altro Arduino…Penso che questo progetto è stato completato e quando lo installo definitivo cercherò di distanziare la scheda con il modulo relè non vorrei avere brutte sorprese di disturbi… grazie @Claudio

#include <SoftwareSerial.h>
SoftwareSerial mySerial(2, 3); //RX, TX
#include <HygrometerSensor.h>
#include <Adafruit_Sensor.h>

// nomi di comodo pin
const int MotoreAV = 22;
const int MotoreIN = 24;
const int fcS = 28;
const int fcD = 26;
const int Pompa = 9;
const int Ventola = 10;
const int Sensore1 = A0;
const int Sensore2 = A1;

// variabili globali per informazioni scambiate tra funzioni
byte comandoMotore = 0;
unsigned long tempo = 0;
int lettura;
int lettura1;

//DHT11 Sensor:
#include "DHT.h"
#define DHTPIN 12     // Sensore collegato al PIN 12
#define DHTTYPE DHT11   // DHT 11
DHT dht(DHTPIN, DHTTYPE);

//I2C LCD:
#include <Wire.h> // Libreria WIRE
#include <LiquidCrystal_I2C.h> // Libreria LCD I2C

// LCD I2C address
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
//--------------------------------------------------------------------
void fermaMotore() {
  pinMode(MotoreAV, LOW);
  pinMode(MotoreIN, LOW);
}
void motoreAvanti() {
  pinMode(MotoreAV, HIGH);
}
void motoreIndietro() {
  pinMode(MotoreIN, HIGH);
}
void avviaPompa() {
  digitalWrite(Pompa, LOW);
}
void fermaPompa() {
  digitalWrite(Pompa, HIGH);
}
void avviaVentola() {
  digitalWrite(Ventola, LOW);
}
void fermaVentola() {
  digitalWrite(Ventola, HIGH);
}
//--------------------------------------------------------------------
void letturaIgrometri()
{
  static unsigned long t = 0;
  if (millis() - t >= 5000) {
    lettura = analogRead(Sensore1);
    int sensorValue = map (lettura, 1008, 319, 0, 100); // converto il valore analogico in percentuale
    Serial.print("Umidità  terra 1 : ");
    Serial.print(sensorValue);
    Serial.println ("%"); //Stampa a schermo il valore

    // imposta il cursore sulla terza riga:
    lcd.setCursor(0, 2);
    lcd.print("Umid..Terra 1: ");
    lcd.print(sensorValue);
    lcd.print("%");

    lettura1 = analogRead(Sensore2);
    sensorValue = map (lettura1, 1010, 215, 0, 100); // converto il valore analogico in percentuale
    Serial.print("Umidità  terra 2 : ");
    Serial.print(sensorValue);
    Serial.println ("%"); //Stampa a schermo il valore

    // imposta il cursore sulla quarta riga:
    lcd.setCursor(0, 3);
    lcd.print("Umid..Terra 2: ");
    lcd.print(sensorValue);
    lcd.print("%");

    t = millis();
  }
}
//--------------------------------------------------------------------
void letturaUmTemp()
{
  static unsigned long t = 0;
  // Lettura umidità e temperatura del sensore DHT11n
  if (millis() - t >= 60000  && comandoMotore == 0) {

    int hum = dht.readHumidity();
    int temp = dht.readTemperature();

    // Misura la temperatura e se maggiore di ...
    // gradi attiva relè per accendere la ventola
    if (temp >= 25 ) avviaVentola();
    else             fermaVentola();

    Serial.print("Temp: ");
    Serial.print(temp);
    Serial.print("C, Umid: ");
    Serial.print(hum);
    Serial.println("%");

    // impostare cursore sulla prima riga:
    lcd.setCursor(0, 0);
    lcd.print("Temperatura: ");
    lcd.print(temp);
    lcd.print("C");

    // imposta cursore sulla seconda riga:
    lcd.setCursor(0, 1);
    lcd.print("Umidita' Aria: ");
    lcd.print(hum);
    lcd.print("%");

    t = millis();
  }
}
//--------------------------------------------------------------------
void logicaPompa()
{
  static unsigned long t = 0;
  static byte s = 0;
  if (s == 0  &&  lettura >= 775  &&  lettura1 >= 775)
  {
    t = millis();
    avviaPompa();
    mySerial.println("w1234");
    s = 1;
  }
  else if (s == 1  &&  millis() - t >= 10000) // se passati 10s
  {
    comandoMotore = 1;
    s = 2;
  }
  else if (s == 2  &&  comandoMotore == 0) // attende motore spento
  {
    fermaPompa();
    s = 0;
  }
}
//--------------------------------------------------------------------
void logicaMotore()
{
  static unsigned long t = 0;
  static byte s = 0;
  boolean fcS_Chiuso = (digitalRead(fcS) == LOW);
  boolean fcD_Chiuso = (digitalRead(fcD) == LOW);

  if (s == 0)
  {
    fermaMotore();
    s = 1;
  }
  else if (s == 1  &&  millis() - t >= 3000)
  {
    if (fcS_Chiuso)  s = 2;
    else
    {
      motoreIndietro();
      s = 5;
    }
  }
  else if (s == 2  &&  comandoMotore == 1)
  {
    motoreAvanti();
    mySerial.println("w1234");
    s = 3;
  }
  else if (s == 3  &&  fcD_Chiuso)
  {
    fermaMotore();
    t = millis();
    s = 4;
  }
  else if (s == 4  &&  millis() - t >= 3000)
  {
   
    motoreIndietro();
    mySerial.println("w1234");
    s = 5;
  }
  else if (s == 5  &&  fcS_Chiuso)
  {
    fermaMotore();
    comandoMotore = 0;
    s = 2;
  }
}
//--------------------------------------------------------------------
void setup()
{
  Serial.begin(9600);
  mySerial.begin(9600);
  lcd.begin(20, 4);
  dht.begin();
  Serial.println("Serra Automatica");
  pinMode(MotoreAV, OUTPUT);
  pinMode(MotoreIN, OUTPUT);
  fermaMotore();
  pinMode(Pompa, OUTPUT);
  fermaPompa();
  pinMode(Ventola, OUTPUT);
  fermaVentola();
  pinMode(Sensore1, INPUT);
  pinMode(Sensore2, INPUT);
  pinMode(fcS, INPUT_PULLUP);
  pinMode(fcD, INPUT_PULLUP);
}
//--------------------------------------------------------------------
void loop() {
  letturaIgrometri();
  letturaUmTemp();
  logicaPompa();
  logicaMotore();
}
//--------------------------------------------------------------------

cicciozuc: Funziona molto bene

...ma per puro caso...

Infatti dal post #44 hai iniziato a comandare il motore in questo modo:

void fermaMotore() {
    pinMode(MotoreAV, LOW);
    pinMode(MotoreIN, LOW);
}

...che nel progetto in questione è sbagliatissimo (e a colpo d'occhio non lo avevo visto). Ripeto, funziona per puro caso solo perché con quel pinMode i pin vengono portati in alta impedenza e i relé si spengono, ma non è garantito che si accendano. Bastava copiare dalle altre funzioni già scritte... se fino al quel momento abbiamo usato correttamente digitalWrite per accendere e spegnere i relé, perché fare diversamente? (ho aggiornato il mio codice per togliere questo errore)

Spero che il tutto alla fine serva come spunto di studio un po' più approfondito... ok essere nuovi alla materia, ma in queste cose serve un po' più di precisione e meno tentativi alla cieca.

Inoltre in un progetto "vero" ritengo indispensabile aggiungere come minimo le sicurezze di cui ho scritto a fine post #38, ci deve essere una situazione di guasto in cui tutto viene fermato e segnalato via radio.

Per quanto riguarda i disturbi bisogna vedere se erano dovuti a malfunzionamenti hardware (collegamento masse ecc), oppure alla captazione di disturbi da parte degli ingressi che vengono scambiati per segnali utili, oppure all'errata interazione tra i vari moduli (che ora non dovrebbe esserci più, e a proposito come si vede il tutto può girare benissimo su un solo ArduinoUNO o su un minuscolo ProMini).

Avevo dichiarato quei pin LOW perchè con lo sketch che avevo fatto prima del post#44 i due relè motore si spegnevano e se mettevo HIGH rimanevano accesi, errore mio.
Per le sicurezze motore hai ragione sarebbe giusto per precauzione inserirli, se un finecorsa si guasterbbe il carrello a cui è collegato il motore si bloccherebbe all’estremità dei lati della serra e farebbe surriscaldare il motore logorando pure il meccanismo del carrello… inserirò anche dei fusibili ai connettori del motore…
Se rimanebbero accesi invece motoreAvanti() e motoreIndietro() non dovrebbero creare alcun corto credo, ho collegato seguendo lo schema suggerito dal buon caro (@Brunello) …

invertitore_rele.jpg

Per la Trasmittente non penso ci sia bisogno di creare un comando o una variabile a parte, ho dichiarato nel setup il mySerial.Begin(9600) e dove voglio che mi invia una segnale aggiungo il mySerial.println(“w1234”); e ottengo la lettura della Trasmittente nel seriale della Ricevente.

Sempre sulla Ricevente è da un pò che ci lavoro per ricevere dei nomi al posto dei numeri preceduti e visualizzati dopo la lettera " w " basterebbe inviarmi lo stato che compie il Motore durante il suo ciclo Start - Avanti - Stop - Indietro - Stop . Se creo queste variabili SicurezzaMotore potrebbe solo inviarmi i guasti verificati…

Ho fatto girare il tuo aggiornamento fatto al File su una ArduinoUno perchè questo hardware è compatibile come IDE co il mio telefono per caricare gli sketch, dove verrà installato ho a disposizione solo questo sistema… i due Sensori, il DHT, LCD 20x4 e la Trasmittente HC-12 li alimento da una fonte esterna, un normale alimentatore per bread con i 5v mettendo la massa in comune…

Arrivando alla fine dicendoti grazie… grazie per consigli che mi hai dato, da questo prendero spunto per comprendere a programmare in maniera diversa… Altri due karma te li meriti per la tua buona volontà dimostrata fino in questo momento…

cicciozuc: inserirò anche dei fusibili ai connettori del motore..

Ottimo, e di tipo ritardato, altrimenti lo spunto li fa saltare ad ogni partenza.

invece motoreAvanti() e motoreIndietro() non dovrebbero creare alcun corto

No, infatti, con quello schema le alimentazioni non vanno mai in corto (sempre che non si saldino tra loro i contatti dei relé).

Per la Trasmittente non penso ci sia bisogno di creare un comando o una variabile a parte

Vero, non dovendo trasmettere continuamente basta una trasmissione ad ogni evento.

grazie per consigli che mi hai dato e da questo prendero spunto

E io prendo spunto per l'HC-12 :) La mia attuale sede di lavoro è a soli 350m in linea d'aria da casa mia, ed essendo all'ultimo piano la vedo anche a vista... forse ci arrivo :D

350m li fà sicuro, io ho provato a circa 900mt e leggeva il segnale,il costruttore ne dichiara 1800mt…
ho notato però che l’antenna della trasmittente deve stare fuori all’aria aperta per inviarmi il segnale, prima di questo tenevo l’antenna della Trasmittente dentro lo stanzino dove si trova l’HC-12 e le varie schede per gestire la serra e pur avendo muri non troppo spessi la Ricevente non leggeva il segnale… Quando ho messo l’antenna fuori ho risolto avendo la Ricevente dentro casa mia a circa 100mt con muri spessi…

Grazie a (@Brunello22) che mi ha fornito il programma della Ricevente ho messo anche un LCD e mi legge i valori ricevuti nel Seriale, però questo sketch è stato creato per leggere i numeri inviati dalla Trasmittente e non basta modificare una sola riga ma l’intero sketch per leggere i nomi che vorrei mi inviasse la Trasmittente…Te lo allego per farti un’idea…

HC-12_Ricevente.ino (1.89 KB)

Sono riuscito a creare una lettura_Guasti(); che mi trasmette tramite seriale se i due finecorsa sono chiusi (“guasto FnC.”) e se motoreAvanti() e motoreIndietro() rimangono accesi insieme (“guasto Motore.”) …
più avanti aggiungerò altre situazioni di guasto… Sulla ricevente ho la lettura impostata in lettura_Guasti(); solo che ottengo anche numeri indesiderati… La ricevente è un esempio di sketch della libreria HC-12…

Cè qualcuno che riesce a capire come mai sulla ricevente mi porto dietro questi numeri??

cicciozuc_serra_trasmittente.ino (8.7 KB)

recevente hc-12.ino (1.2 KB)

cicciozuc: come mai sulla ricevente mi porto dietro questi numeri??

Forse sono segnali spuri ricevuti via radio. Compaiono random anche quando non trasmetti niente?

No, sulla ricevente non ho random se la trasmittente non invia nulla....Penso sulla ricevente bisognare creare un condizione di verifica del messaggio trasmesso. Se la lettura ricevuta è uguale a ("guasto FnC") allora stampo la lettura, altrimenti qualsiasi altro byte ricevo non stampo nulla...

Non bisogna usare:

Serial.print(char(HC12.read()));

ma Serial.write

Come ipotesi eh, visto che «questi numeri» sono segretissimi e non ce li vuoi far vedere :smiling_imp:

@(Claudio_FF) io non tengo nulla di segreto, pensavo che vedere i numeri non aveva importanza...

a parte questo ho trovato uno sketch in questo sito dove fatto girare sulla ricevente mi stampa solo la lettura ricevuta senza che si porti dietro caratteri o numeri indesiderati, l'esempio usato è il secondo del sito....

Quello che ricevo con lo sketch postato prima è :

6427 RF: Guasto Motore
14229 RF: Guasto Fine Corsa
170969 RF: Guasto Motore
177471 RF: Guasto Fine Corsa

e così via.... cambiano solo le somme dei numeri...

Adesso usando lo sketch di quel sito come ho detto ricevo solo la lettura, peccato che la stessa lettura viene letta una sola volta a meno chè non resetto arduino...cmq su questo ci sto lavorando sù