next topic »

[on:]

Ciao a tutti

Con questa mia domanda spero di non attirami le ire di nessuno ma sono due giorni che non riesco a trovare il bandolo della matassa.
Vi racconto il mio 'problema'..............

ho una variabile chiamata calcRos calcolata tramite una formuletta da due segnali variabili 0-5 V su pin3 e pin5, fin qui la cosa funziona regolarmente, in un primo esperimento leggo tutto su di un LCD senza problemi, al variare dei due segnali varia la visualizzazione sull'LCD.

Adesso viene il problema................

dopo avere visualizzato i parametri vorrei tramite la variabile calcRos e dei cicli di 'if else' oppure degli 'switch' inserire a gradini delle uscite, la mia idea "sbagliata" è una serie di

Code:

{      
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1))); // dovrebbe ricalcolare !!!
    if (calcRos > 1.5){
      digitalWrite(led2, HIGH);
      delay (500);
    }
  }  
  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led3, HIGH);
      delay (500);
    }
  }

  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led4, HIGH);
      delay (500);
    }
  }

il problema è che non aggiorna il valore della variabile calcRos fino alla fine del loop, invece a me servirebbe che durante il ritardo lui aggiornasse automaticamente il valore della variabile.
Sono due giorni che cerco in rete una soluzione alla mia domanda senza riuscirci, spero in un vostro aiuto.

Grazie

Campa1957

edit by mod: per favore includi il codice usando gli appositi tag

[Reply #1 on:]

quando fai una dealy() è come se congelassi arduino, tranne che per gli interrupt (ma per ora lasciamoli stare).

Quello che devi fare è fare in modo che il codice non si fermi mai. Quindi niente delay.
Però hai la millis(), che ritorna il numero di millisecondi passati dall'ultimo reset dell'arduino; quindi il tuo if, oltre che a valutare il valore di calcRos, dovrà anche valutare che il tempo trascorso dall'ultimo aggiornamento sia abbastanza.

[Reply #2 on:]

Non capisco il Tuo problema. Quella parte di sketch che hai dato fa 3 volte la stessa cosa su 3 LED diversi ma sempre con gli stessi valori iniziali. Se la condizione é vera per un LED li accendi tutti.
Spiegaci meglio e dacci lo sketch completo.

Ciao Uwe

[Reply #3 on:]

Mi spego meglio
il ritardo è stato inserito per avere il tempo fra una accensione e l'altra di abbassare il valore della variabile, mediante un trimmer, e bloccare l'attivazione delle uscite.
Ma non funziona !!!
In pratica ogni step inserito, saranno induttanze e condensatori, andrà ad influire sul valore della variabile calcRos, per cui ogni inserimento ho bisogno di ricalcolare il valore della variabile e poi evetualmente inerire un'altro gradino.

Inserisco di seguito tutto il listato:

Code:

/*
***********************
 Accorda0501a PROVA USCITE
 ***********************
 */

#define NUMREADINGS0 5  // 10 valori da leggere
#define NUMREADINGS1 5  // 10 valori da leggere
#define inputPin0 3 // Sensore collegato al pin analogico 3 POT. RIFLESSA
#define inputPin1 5 // Sensore collegato al pin analogico 5 POT. DIRETTA
// #include <LiquidCrystal.h>   // INCLUDE LA LIBRERIA
int readings0[NUMREADINGS0];  // Letture dal input analogico
int readings1[NUMREADINGS1];  // Letture dal input analogico
int index0 = 0;  // Indice della lettura0 corrente
int index1 = 0;  // Indice della lettura1 corrente
int total0 = 0;  // Totale letture0
int total1 = 0;  // Totale letture1
int salto0 = 0;  // seleziona cosa fare salto0 variabile il cui valore indica dove swicciare
float  average0 = 0;  // Media0 RIFLESSA, int non visualizza decimali, float visualizza due decimali
float average1 = 0;  // Media1 DIRETTA, int non visualizza decimali, float visualizza due decimali
float average0old = 0;  // Media0old RIFLESSA
float average1old = 0;  // Media1old DIRETTA
float calcRos = 0;  // Ros calcolato
float calcRosOld = 0;
float calcPot =0;  // Potenza calcolata
float calcPotOld =0;
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);   // INIZIALIZZA LA LIBRERIA LCD
int led1 = 13;  // SELEZIONA PIN 13
int led2 = 12;  // SELEZIONA PIN 12
int led3 = 11;  // SELEZIONA PIN 11
int led4 = 10;  // SELEZIONA PIN 10
int led5 = 9;  // SELEZIONA PIN 9
int led6 = 8;  // SELEZIONA PIN 8



void setup()
{
  {
    pinMode (13, OUTPUT);
    pinMode (12, OUTPUT);
    pinMode (11, OUTPUT);
    pinMode (10, OUTPUT);
    pinMode (9, OUTPUT);
    pinMode (8, OUTPUT);    
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    digitalWrite(led3, LOW);
    digitalWrite(led4, LOW);
    digitalWrite(led5, LOW);
    digitalWrite(led6, LOW);    
  }

  for (int i = 0; i < NUMREADINGS0; i++){
    readings0[i] = 0;  //Mette tutti 0 nell'array
  }

  for (int a = 0; a < NUMREADINGS1; a++) {
    readings1[a] = 0;  //Mette tutti 0 nell'array    
  }
}

void loop()
{
  {
    total0 -= readings0[index0];  //Sottrae l'ultima lettura
    readings0[index0] = analogRead(inputPin0);  //Legge i valori provenienti dal sensore e li salva nell'array
    total0 += readings0[index0];  //Aggiunge la lettura al totale
    index0 = (index0 + 1);  //Incrementa l'indice
  }
  if (index0 >= NUMREADINGS0) {
    index0 = 0;  //Alla fine dell'array resetta l'indice a 0
    average0 = total0 / NUMREADINGS0;  // Calcola la media DELLA RIFLESSA
  }
  {
    total1 -= readings1[index1];  //Sottrae l'ultima lettura
    readings1[index1] = analogRead(inputPin1);  //Legge i valori provenienti dal sensore ??? e li salva nell'array
    total1 += readings1[index1];  //Aggiunge la lettura al totale
    index1 = (index1 + 1);  //Incrementa l'indice
  }
  if (index1 >= NUMREADINGS1) {
    index1 = 0;  // Alla fine dell'array resetta l'indice a 0
    average1 = total1 / NUMREADINGS1;  // Calcola la media DELLA DIRETTA
  }
  // CALCOLA IL ROS !!!
  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
  }
  // CALCOLO POTENZA F.S. 50W 1023/50=20.46
  {
    calcPot = (average1 / 20.46);
  }
  {
  if(calcRos>1.5) salto0=salto0+1;
  // else salto0=0;
  
  }
  switch (salto0)
  {
  // Inserisco primo scalino ind
  case 1:
  digitalWrite(led1, HIGH);
  if(calcRos>1.5) salto0=salto0+1;
  delay (500);
  break;
  
  // Inserisco secondo scalino ind
  case 2:
  digitalWrite(led2, HIGH);
  delay (500);
  break;
  
  // 000
  case 0:
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  digitalWrite(led5, LOW);
  digitalWrite(led6, LOW);  
  delay (100);
  break;
  
  }
  }
  
  
  
  
  /*
  
  {
    calcRosOld = calcRos;
  }
  {
    if(calcRos > 1.5){
      digitalWrite(led1, HIGH);
      delay (500);
    }
  }
  {      
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led2, HIGH);
      delay (500);
    }
  }  
  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led3, HIGH);
      delay (500);
    }
  }

  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led4, HIGH);
      delay (500);
    }
  }

  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led5, HIGH);
      delay (500);
    }
  }
  {
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
    if (calcRos > 1.5){
      digitalWrite(led6, HIGH);
      delay (500);

    }
  }
  
}

*/

grazie

Campa1957

[Reply #4 on:]

usa i tag [ code] per contenere il codice, pulsantino # sopra le faccine. se no così è illeggibile

comunque come già detto, devi togliere le delay e sostituirle prendendo spunto dall'esempio blink without delay

[Reply #5 on:]

Grazie ai vostri suggerimenti sono riuscito a far funzionare il primo step del mio giochino, adesso il mio problema è riuscire una volta inserito uno step verificare che il valore di calcRos sia diminuito e non aumentato in seguito all'inserimento stesso.
In caso di diminuzione devo andare avanti, se è aumentato devo disabilitare l'ultimo step e saltare ad un altro cilco di inserimenti diverso dal precedente.

Un grazie anticipato

Andrea

Code:

/*
****************************
 Accorda0503ccc PROVA USCITE 6
 ****************************
 */

#define NUMREADINGS0 10  // 10 valori da leggere
#define NUMREADINGS1 10  // 10 valori da leggere
#define inputPin0 3 // Sensore collegato al pin analogico 3 POT. RIFLESSA filo verde
#define inputPin1 5 // Sensore collegato al pin analogico 5 POT. DIRETTA filo blu
// #include <LiquidCrystal.h>   // INCLUDE LA LIBRERIA
int readings0[NUMREADINGS0];  // Letture da input analogico
int readings1[NUMREADINGS1];  // Letture da input analogico
int index0 = 0;  // Indice della lettura0 corrente
int index1 = 0;  // Indice della lettura1 corrente
int total0 = 0;  // Totale letture0
int total1 = 0;  // Totale letture1
int salto0 = 0;  // seleziona cosa fare salto0 variabile il cui valore indica dove swicciare x ind
int salto1 = 0;  // seleziona cosa fare salto0 variabile il cui valore indica dove swicciare x cap
float average0 = 0;  // Media0 RIFLESSA, int non visualizza decimali, float visualizza due decimali
float average1 = 0;  // Media1 DIRETTA, int non visualizza decimali, float visualizza due decimali
float average0old = 0;  // Media0old RIFLESSA
float average1old = 0;  // Media1old DIRETTA
float calcRos = 0;  // Ros calcolato
float calcRosOld = 0;
float calcPot =0;  // Potenza calcolata
float calcPotOld =0;
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);   // INIZIALIZZA LA LIBRERIA LCD
int led1 = 13;  // SELEZIONA PIN 13
int led2 = 12;  // SELEZIONA PIN 12
int led3 = 11;  // SELEZIONA PIN 11
int led4 = 10;  // SELEZIONA PIN 10
int led5 = 9;  // SELEZIONA PIN 9
int led6 = 8;  // SELEZIONA PIN 8
int led7 = 7;  // SELEZIONA PIN 7
int led8 = 6;  // SELEZIONA PIN 6
int led9 = 5;  // SELEZIONA PIN 5
int led10 = 4;  // SELEZIONA PIN 4
int led11 = 3;  // SELEZIONA PIN 3
int led12 = 2;  // SELEZIONA PIN 2
int led13 = 1;  // SELEZIONA PIN 1
int led14 = 0;  // SELEZIONA PIN 0
long previousMillis = 0; // ********************
long interval = 1000;  // **********************
int giroInd = 0; // giro induttivo
int giroCap = 0; // giro capacitivo

void setup()
{
  {
    pinMode (13, OUTPUT);
    pinMode (12, OUTPUT);
    pinMode (11, OUTPUT);
    pinMode (10, OUTPUT);
    pinMode (9, OUTPUT);
    pinMode (8, OUTPUT);  
    pinMode (7, OUTPUT);
    pinMode (6, OUTPUT);
    pinMode (5, OUTPUT);
    pinMode (4, OUTPUT);
    pinMode (3, OUTPUT);
    pinMode (2, OUTPUT);
    pinMode (1, OUTPUT);
    pinMode (0, OUTPUT);
  }
  for (int i = 0; i < NUMREADINGS0; i++){
    readings0[i] = 0;  //Mette tutti 0 nell'array
  }

  for (int a = 0; a < NUMREADINGS1; a++) {
    readings1[a] = 0;  //Mette tutti 0 nell'array    
  }
}
void loop()
{
  {
    total0 -= readings0[index0];  //Sottrae l'ultima lettura
    readings0[index0] = analogRead(inputPin0);  //Legge i valori provenienti dal sensore e li salva nell'array
    total0 += readings0[index0];  //Aggiunge la lettura al totale
    index0 = (index0 + 1);  //Incrementa l'indice
  }
  if (index0 >= NUMREADINGS0) {
    index0 = 0;  //Alla fine dell'array resetta l'indice a 0
    average0 = total0 / NUMREADINGS0;  // Calcola la media DELLA RIFLESSA
  }
  {
    total1 -= readings1[index1];  //Sottrae l'ultima lettura
    readings1[index1] = analogRead(inputPin1);  //Legge i valori provenienti dal sensore ??? e li salva nell'array
    total1 += readings1[index1];  //Aggiunge la lettura al totale
    index1 = (index1 + 1);  // Incrementa l'indice
  }
  if (index1 >= NUMREADINGS1) {
    index1 = 0;  // Alla fine dell'array resetta l'indice a 0
    average1 = total1 / NUMREADINGS1;  // Calcola la media DELLA DIRETTA
  }
  {
    // CALCOLO ROS
    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
 }
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;

    {
      if(calcRos>=1.5) salto0++;
    }

    calcRosOld = calcRos;

    switch (salto0)   {
    case 1: // Inserisco primo scalino ind
      digitalWrite(led1, HIGH);
      break;      
    case 2: // Inserisco scalino 2 ind
      digitalWrite(led2, HIGH);
      break;
    case 3: // Inserisco scalino 3 ind
      digitalWrite(led3, HIGH);
      break;      
    case 4: // Inserisco scalino 4 ind
      digitalWrite(led4, HIGH);
      break;
    case 5: // Inserisco scalino 5 ind
      digitalWrite(led5, HIGH);
      break;      
    case 6: // Inserisco scalino 6 ind
      digitalWrite(led6, HIGH);
      break;

      // 000
    case 0:
      digitalWrite(led1, LOW);
      digitalWrite(led2, LOW);
      digitalWrite(led3, LOW);
      digitalWrite(led4, LOW);
      digitalWrite(led5, LOW);
      digitalWrite(led6, LOW);  
      break;

    }
  }
}

[Reply #6 on:]

Non ho seguito la logica del programma, ma mi pare evidente che hai bisogno di
capire qualcosa di più sul C/C++, in particolare il blocchi e scope.

I blocchi servono per delimitare una porzione di codice. I delimitatori sono {}, ciò che è contenuto dentro le parentesi graffe
è un blocco di codice.
I blocchi sono funzionalità indipendenti, non strettamente legate ad altre parole chiave, quindi un blocco di codice
può apparire nel modo in cui lo usi tu, ma ha una finalità specifica che nel tuo caso non risulta evidente dal codice.

La necessità di ricorrere ad un blocco di codice a se stante deve essere presente altrimenti chi legge il codice
potrebbe fare assunzioni errate.

L'unica necessità di ricorrere ad un blocco a se stante che mi viene in mente è quella in cui devi manipolare degli
oggetti transitori o usare degli oggetti transitori di dimensioni grandi che operano su dei dati globali. In questo caso
creare un blocco di codice mi da la possibilità di creare oggetti corposi (di grandi dimensioni) lasciare che questi manipolino le informazioni
e lasciare al blocco l'onere di distruggere gli oggetti ingombranti che ho creato dentro il blocco, difatti tutto quello che creo dentro un
blocco di code cessa di esistere al termine del blocco di codice, cioè dopo la chiusura del blocco con "}".

Un blocco può anche essere rischiesto dalla sintassi, es una funzione è delimitata obbligatoriamente da un blocco di codice, pertanto
le variabili create dentro le funzioni esistono solo al suo interno, quindi si dice che sono locali. Sono locali perchè è la caratteristica del blocco 
di codice e non perché si tratta di una funzione.

I blocchi possono essere opzionali quando legati ad alcune parole chiave, vedi if, for, while ecc.

Code:

if (app.state() == FINISH)
    app.next();

Come si vede non è necessario usare le graffe per delimitare il blocco dopo la if, perchè si tratta di una sola istruzione. Invece il blocco è necessario nel secondo
esempio:

Code:

if (ch == 'x' || ch == 'X') {
    switchOffMotor();
    lcd.print("motor off);
}

Se non usassi il blocco l'istruzione lcd.print() verrebbe eseguita indipendentemente dalla condizione testata dalla if.

La forma di if else che necessità di blocchi è la seguente:

Code:

if (condizione)
{                    // apre il blocco
    1 linea
    2 linea
    n linea
} else {          // chiude il blocco e apre un altro blocco "else"
    codice
    codice
    ....
}

Altra forma prevede al posto di else, l'istruzione composta else if (condizione)

Code:

if (ch == 'x')
{

     codice
     codice
     .......

} else if (ch == 'y') {

     codice
     codice
     codice

} else if (ch == 'z') {

    codice
    codice
    codice
 
}

Quindi se non hai buoni motivi per isolare del codice all'interno di un blocco non usarlo e inutile e fuorviante.

Ciao.

[Reply #7 on:]

Ciao,

purtroppo la mia conoscenza del C/C++ tende a 0 !!!

però mi piacerebbe realizzare un progettino che mi gira in testa da anni, spero con tanto aiuto, con qualche pezzo di programma reuperato in rete, e tanto smanettamento mio, di riuscire a mettere insieme  

Quello che vorrei riuscire a fare adesso è verificare subito dopo aver portato a livello alto led? se il valore di calcRos è aumentato oppure diminuito? se è diminuito ma sempre maggiore di un certo valore prefissato continuare ad inserire step nel caso fosse aumentato invece disabilitare l'uscita e fare altre cose,  questa verifica andrebbe fatta ogni volta che viene portata a livello alto una uscita.

Di seguito lo spezzone di codice..........

Code:

 
{
      if(calcRos>=1.5) saltoind++;
    }

    calcRosOld = calcRos;

    switch (saltoind)   {
    case 1: // Inserisco primo scalino ind
      digitalWrite(led1, HIGH);
      break;      
    case 2: // Inserisco scalino 2 ind
      digitalWrite(led2, HIGH);
      break;
    case 3: // Inserisco scalino 3 ind
      digitalWrite(led3, HIGH);
      break;      

Campa1957

[Reply #8 on:]

quindi in teoria:

1. calcola il valore
2. in base al valore accendi/spegni i led
3. aspetta un tot
4. ricomincia al punto 1.

dal tuo spezzone, hai il punto 1. e parte del 2.; solo la parte accensione, manca la parte spegnimento

se poi il tuo spezzone è nel loop() o in un ciclo allora hai anche il punto 4.

manca il punto 3. ad occhio, e da completare il punto 2.