due lm35 comandano un servomotore

alla riga   17 trovo:#define PhotoSensor     A0
alla riga   20 trovo:#define sensorefiamma A0 PIN A7   (che francamente non capisco cosa significa)
alla riga 153 trovo:int sensorPin = A0;

la riga 17 è uno dei tre lm35 quindi sono A0 A1 A2 ed è corretto
la riga 20 è il sensore fiamma quindi A0 era come riportato nel programma originale, ma nel mio caso diventa A7 perchè A0 è occupato dal lm35.
mentre la riga 153 con la riga 17 appartengono al programma che ho copiato.
Quindi si potrebbe fare a meno della riga 153 e rinominare tutti i sensorpin con il photosensor.

riga273:     pinMode(4, OUTPUT);                 //Led Allarme (Rosso)
riga 276     pinMode(LampRed3, OUTPUT);    //LED ROSSO  (Allarm) -> riga9 =pin 4

questi erano gli altri comandi che avevo già notato.
Questo è un esempio che mi fà un pò rabbia perchè ogniuno usa un modo diverso per sviluppare il programma.
Io all'inizio ho fatto un pò di fatica a capire, perchè questi esempi non usano un linguaggio standard, quando ho confrontato due programmi che fanno la stessa cosa, mi sono accorto che questa differenza dopotutto facevano la stessa cosa.

Dato che ci siamo con il discorso delle parentesi mi è sorto una curiosità.
Tutti i programmi utili che ho voluto integrare in questo programma hanno un setup, e i vari setup mettendoli in questo mio progetto li ho racchiusi nelle graffe per una ricerca maggiore, qui cambia qualcosa? E' ovvio che qui c'è anche il comando per il setup del servo

void setup() {

  myservo.attach(9);  // attaches servo al pin 9
  {
    Serial.begin (9600);
    lcd.begin(16, 2);
    lcd.backlight();
    lcd.print (" Buongiorno");
    delay (1500);
    lcd.createChar(0, DomenicoChar);
    lcd.setCursor(4, 1); //posizionamento (colonna,riga)
    lcd.write((uint8_t)0);
    lcd.setCursor(5, 1);
    lcd.print("omenico");
    delay (2000);

    //Setup RTC DS3231
    lcd.clear ();
    setSyncProvider(RTC.get);
    lcd.clear ();
    if (timeStatus() != timeSet)
      lcd.print (" orologio non");
    else
      lcd.print(" orologio");
    lcd.setCursor (0, 1);
    lcd.print  (" sincronizzato");
    delay (1500);
    temperaturaRTC = RTC.temperature();
  }
  //Setup sensore fiamma
  {
    lcd.begin(16, 2);
    pinMode(analogInputA8, INPUT);
    pinMode(flame_din, INPUT);
    pinMode(15, OUTPUT);
    pinMode(22, OUTPUT);
    pinMode(flame_ain, INPUT);
    pinMode (BUZZER, OUTPUT);
    pinMode(rel, OUTPUT);         //relè
    digitalWrite(rel, LOW);      //relè 2

  }

Praticamente non ho voluto smuovere i vari setup perchè c'è il comando:

 lcd.begin(16, 2);

riportato molte volte, e per non interferire con il tutto li ho lasciati così.

Quindi le domande sono:

Questo comando è sufficiente scriverlo una sola volta?
Cosa succede se lascio le graffe in questo modo?
Se nel caso sono da rimuoverli possono lasciarli integri in questo modo?

p.s.
I comandi dei relè li devo correggere in questo momento.

le funzioni nel linguaggio c++ (che è quello usato in arduinese :slight_smile: ) come anche in C standard

prevedono:
assegnazioneDelTipoDiParametroDiRitornoDellaFunzione nomeDellaFunzione(TipoParametro nomeParametro) {
corpoDellaFunzione
...
...
}

praticamente per esempio nella funzione setup trovi:

void setup() {
...
...
}

dove void significa che non restituisce nessun valore al termine
setup è il nome della funzione
() le parentesi non contengono nulla perchè non richiede parametri
{ graffa aperta = inizio funzione
} graffa chiusa = fine funzione

ci sono ovviamente altri comandi che prevedono apertura e chiusura delle graffe
come ad esempio
if () {
} else {
}

for(){
}

swich (){
}

ma nel tuo caso non stai usando nessuno di questi e quindi

void setup() {

  myservo.attach(9);  // attaches servo al pin 9
  {
    Serial.begin (9600);
    lcd.begin(16, 2);

anche se praticamente viene ignorata dal compilatore in effetti è un errore
è meglio se le elimini anche perchè anche qui fanno confusione
ricordati comunque di levarle a coppie perchè se ne dimentichi una ti si incasina tutto :wink:

lcd.begin(parametri)

questa riga inizializza, attiva, fa funzionare (diciamo così) il tuo lcd, è come quando giri la chiave per accendere il motore, non è che lo fai ad ogni cambio marcia :smiley: quando è partito, è partito!
idem per Serial.begin() e per tutti gli altri begin() che potrai trovare

sul fatto che puoi trovare dei programmi scritti in un modo o in un altro, è normale e abbastanza personale, ogniuno scrive come vuole :slight_smile:

ovvio che se io trovo un programma dove c'è scritto

if (digitalRead(4)) {
   int x=analogRead(A0);
   if (x< 100) {
       digitalWrite(5,HIGH);
   }
}

ti sfido a capire cosa fa (non le singole istruzioni, ma la logica)
mentre se scrivo

if (PulsanteAvvioPremuto) {
   int luminosita = AnalogRead(pinFotodiodo);
   if (luminosita < 100) {
      digitalWrite(luceDelleScale,HIGH);
   }
}

è molto più comprensibile no?
ovviamente in testa al programma avrai messo o i define:

#define PulsanteAvvioPremuto 4
#define pinFotodiodo A0
#define luceDelleScale 5

oppure

const byte PulsanteAvvioPremuto=4;  
const byte pinFotodiodo=A0;
const byte luceDelleScale=5;

ma non entrambi anche se qui almeno il nome è lo stesso :wink:

Ok, ho inquadrato di più il tutto, effettivamente se al posto della x e/o funzione viene quasi scritto ciò che si vuole fare è molto più semplice.

Tornando al progetto ho risolto il problema dell' lm35, che quando entrambi superano la soglia dei 22 gradi partisse il servomotore. Non ho fatto altro che spostare le righe nel loop, pratricamente ho avvicinato le due righe che leggono i valori. Lo vedo strano.

Per quanto riguarda il servomotore non ho capito cosa dava fastidio nel menù che interferiva con il pin9, come ho già detto ho provato a fare la prova del nove con gli esempi per far funzionare solo il servomotore al pin9, in questo modo funzionava tranquillamente, con il menù nò. Ho provato anche a creare una posizione nel menù dedicato solo al servomotore, anche qui non ho trovato la soluzione fino a quando ho semplicemente cambiato il pin da 9 a 24 e finalmente funziona.

Adesso devo vedere perchè durante lo scorrimento del menù si è creato dello spazio, faccio un esempio, supponiamo che sul display durante lo scorrimento del menù visualizzo dei numeri e quello che vedo è questo:
1/2/3/4/5/6/7/8/9/../../../../10/11/12 ecc..
Dopo tutto nel menù non ci sono state modifiche particolari. Come mai? Mi chiedo se è una questione del passaggio della nona posizione alla decima?

non ne ho idea....
vedere programma prego :wink:

void OraData() {
  indiceset = 0;
  indiceset = digitalRead (butP);
  if (indiceset == 1)
  { delay (1000);
    acquisiscidati ();
  }
  tempocorrente = millis();
  if ((tempocorrente - tempoprec ) > 1000)
  {
    tempoprec = tempocorrente;
    esponidati();
  }
}

//Ciclo funzione Test Batteria
void TestBattRTC() {

  delay(100); //aspetto(100 millisecondi);
  valore = analogRead (A3); //Leggo il valore analogico alla porta A3 e lo metto dentro "valore"
  lcd.setCursor(0, 0);
  lcd.print("Test RTC");
  lcd.setCursor(0, 1);
  lcd.print("Battery  %");
  lcd.setCursor(11, 1);
  lcd.print ((valore * 100) / 614);
  delay(500);

  //comando Rel Ventola
  {
    reading = analogRead(sensorPin2);
    delay(5);
    reading = analogRead(sensorPin2);
    int celsius = reading / 2;
    delay(500);
    if (celsius > 25) {
      //modificare la temperatura desiderata,
      //inserire > se attivo superiore a 28C°
      //e < se attivo inferiore a 25C°
      delay(1000);
      digitalWrite(Rel, HIGH);
      digitalWrite(LampGreen4, HIGH);
    } else {
      digitalWrite(Rel, LOW);
      digitalWrite(LampGreen4, LOW);
    }

  }
}

Questi sono i due loop del menù, quando passo dalla posizione dell'orologio a quella successiva si creano degli spazi vuoti sul display. Stà da dire che "esponidati" è un void che và prima del setup. Lo devo aggiungere?

continuo a non capire....

in ogni caso sei tu che imposti la posizione prima di scrivere
con
lcd.setcursor(x,y)
e qui ti posizioni sulla riga 0 e scrivi
Test RTC
poi sulla riga di sotto
Battery % e il valore del calcolo
di più nin zo :smiley:

In pratica quando sono nella 9a posizione vedo l'ora, poi premo il pulsante per passare alla 10a posizione e sul display non compare niente fino a quando non premo 4 o 5 volte il pulsante di scorrimento, poi finalmente passa alla 10a dove vedo la carica della batteria.
Questo mi succede sia quando scorro il menù verso l'alto che verso il basso. Il menù è composto da 18 o 19 posizioni, ma solo tra il 9 e il 10 accade questo.
Mi chiedo se è un problema che passa dall'unità alla decina?

Nel frattempo non ho trovato un modo per far funzionare il buzzer una volta soltanto in un loop e non continuo ogni 2sec., in pratica quello che vorrei fare è questo; solo nel momento in cui si apre/chiude la botola il buzzer deve emettere un suono e basta. Ho trovato qualche esempio, ma sembrerebbe un pò complicato, e non sò se complicarmi ancora di più se sul servomotore gli monto un interruttore ottico, che al passaggio della linguetta a x del servo interrompe il fascio dell'infrarosso e mi faccia funzionare un loop specifico per il buzzer.

Che mi dici Patrick_M? Qualche idea?

Ok, per il momento mi potrebbe anche stare bene il fatto che si creano degli spazi vuoti durante uno scorrimento di un menù, avendo un display 16x2 che ad ogni pressione del pulsante per lo scorrimento verso l'alto o il basso, mi visualizza le singole funzioni.
Il progetto a cui mi stò dedicando è su una base di arduino menù messo a disposizione sul sito: PROGETTI E TUTORIAL 2 - PROGETTI ARDUINO
su cui ho applicato diverse modifiche ampliando e aggiungendo altri scheck, tale da arrivare ad un menù di 19 opzioni anzichè 4 come da progetto base.

Di qui in seguito vorrei descrivere il problema servo che ho riscontrato ( a seguito di un primo che ho bruciato sg90 ingranaggi in plastica). Forse non avrò fatto la scoperta dell'America, ma questo è una cosa che ho voluto rendermi conto personalmente e vedere se lo potevo risolvere anche se il servo è costato pochi euro.
Ne ho acquistati due mg90s (ingranaggi in metallo) con problematiche diverse ma uno in comune, e vi spiego.

Vibrazione su servo al raggiungimento della posizione: aprendolo ci sono tre assi, il primo è il motore elettrico, il secondo è la trasmissione e il terzo asse non è altro che un potenziometro dove l'ingranaggio finale (quello che fuoriesce e dove noi diamo la posizione) è fisso sul potenziometro, e ha anche un finecorsa nella parte inferiore.
Il problema era quello che si sentiva vibrare anche se aveva raggiunto il valore massimo mentre poi alla posizione 0 non tornava come dovrebbe. Quindi cosa è successo? E' successo che l'ingranaggio non era ben fisso all'asse del potenziometro, quindi l'ingranaggio era arrivato al finecorsa ma il potenziometro no. Quando noi diamo il comando di una gradazione lo diamo al potenziometro, il motore inizia a muoversi, gli ingranaggi girano e l'ultimo ingranaggio finale regola il potenziometro e al raggiungimento del valore impostato ferma il motore. Ma se questo raggiungimento non avviene il motore continua a girare.

La soluzione è stato di portare il potenziometro a 0, montare gli ingranaggi ma facendo attenzione all'ultimo dove c'è il finecorsa. Metterlo in posizione dove il finecorsa arriva al minimo (0°) però prima di fissarlo bisognerebbe mettere una goccia di colla in modo che non si sposti più dall'alberino.

Montato il tutto il servo ha ripreso a funzionare, ora però devo cercare di non dare più il massimo dei gradi (180°) ma di limitarmi a 179°.

Mentre per il secondo servo, sempre dello stesso modello, è bastato una decina di comandi per farlo sfasare dandogli sempre il comando da 0° a 180°, inizialmente era avvenuto la stessa cosa come il primo servo, solo che in più il fine corsa si è sbricciolato, e l'asta andava oltre i gradi impostati. Questo è sempre perchè il potenziometro non era ben fisso all'ingranaggio con il finecorsa.
Quindi due servo nuovi che durante le prime prove funzionavano e poi senza un preciso motivo non funzionavano come dovevano, mi hanno fatto perdere un bel pò di tempo e di calma, poi dopo ho visto il problema e risolto.

Ho voluto descrivere questa mia esperienza chissà possa essere utile ad altri, non è detto che un servo economico non vale niente, ma dietro a certi piccoli accorgimenti posso essere paragonati ache a quelli più costosi.