Errore nello sketch, non riesco a trovarlo

Ciao a tutti, ho un problema nel mio sketch.
Ho creato delle funzioni, una delle quali ha dei "case" che accendono o spengono i relè.
Il problema è che, quando invio da seriale il comando per accendere il relè, devo inviare anche tre o quattro volte quel comando per accendere o spegnere il relè, ma questo prima non accadeva. Ho inserito altre funzioni, la lettura di temperatura ogni 4 secondi (non ho usato il delay, ma la funzione millis) e l' altra funzione che invia lo stato di 12 ingressi digitali al cambio di stato di uno di essi.
Potete vedere se ho omesso qualche cosa importante riguardo alla seriale?

se elimino gli stati digitali e quelli relativi alle 8 sonde temperatura, la ricezione dei comandi seriali funziona magnificamente.
Grazie comunque

errore_scketch.rar (1.69 KB)

non vorrei dire una fesseria, ma mi sembra che hai un problema di tempistiche.
se ogni 4 secondi vai a fare il controllo della sonda di temperatura e invii qualcosa ad ogni cambio stato, puo essere che in quegli istanti il micro non sia in ascolto e quindi non prende il comando che gli stai inviando.per questo sei costretto a spedire più volte lo stesso comando...per trovare l'istante giusto in cui il micro è in ascolto

Immaginavo che il problema fosse quello...non si tratta di troppe istruzioni, ma di un delay che, quando presente, non permette ad arduino di ricevere i comandi seriali. Avresti una soluzione?

Certo .... puoi usare la funzione mills(); come nell'esempio presente nell'ide di arduino sotto Digitale: Blink senza delay

Non ho usato il delay, è per questo che non capisco l' errore.
Ho eliminato la parte delle sonde temperatura e l' errore è sempre presente.
Ho eliminato anche la parte degli ingressi e il problema è risolto quindi, so chi è la causa.
Questo è lo sketch degli ingressi che inviano lo stato alla variazione di stato:

void INGRESSI_DIGITALI() {
  flag = false;

  for (i = 0; i < sizeof(digitalpin); i++) {
    buttonStatus = digitalRead(digitalpin[i]);
    if (lastStatus[i] != buttonStatus) {
      delay(60);
      buttonStatus = digitalRead(digitalpin[i]);
      if (lastStatus[i] != buttonStatus) {
        lastStatus[i] = buttonStatus;        
        flag = true;
      }
    }
  }
  if (flag) {
    Serial.print("D");
    for (i = 0; i < sizeof(digitalpin); i++) Serial.print(!lastStatus[i]); // notare che ora stampa lo stato NEGATO così HIGH 0 LOW 1
    Serial.print("F");

  }
}

Il delay 60 è una sorta di anti rimbalzo, ma non è quello perchè anche se lo rimuovo, non succede niente. Vorrei capire perché queste istruzioni impediscono il corretto flusso dei dati in ricezione da seriale

purtroppo sono un newbie e non so risponderti con certezza a questo.
quello che mi viene da pensare è:
Mentre tu cerchi di mandare un comando ad arduino via seriale, lui ti sta inviando qualcosa ??
Penso che il problema possa risiedere li.

Assolutamente no, io in realtà ricevo solo se c'è una variazione di ingresso e ogni 4 secondi ricevo tutti i valori delle temperature, ma non è quello il problema perchè la seriale è quasi sempre libera. Ho anche una istruzione che invia i valori del tastierino numerico, ma quelli vengono inviati solamente se premuti. Ci vorrebbe il grande Guglielmo, ma non l' ho più visto :slight_smile:
Io ti ringrazio comunque per l' aiuto, spero che qualcun' altro possa darmi la soluzione.

  1. Non è detto che questo sia l'errore però vedo che hai dichiarato:
byte digitalpin[] = { 30,31,32,33,34,35,36,37,38,39,40,41,};

Quella virgola al fondo. Aggiunge un 13° elemento non inizializzato o forse a 0. Essendo numeri di pin se il vettore è azzerato li c'e' 0 e quindi leggi dal pin 0 che è utilizzato dalla comunicazione seriale.

  1. nella loop() hai due routine che leggono da seriale, USCITE() e SERIALE(). Non ho capito perchè.

  2. mi piacerebbe sapere perchè questa mania di riempire il codice di spazi inutili e portare a capo tutte ste righe, manco fossimo negli anni 80 con monitor 80x40

byte lastStatus[] = { 
  HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH
};

Perchè sti spazi? Non mi dire per la leggibilità, per favore :astonished:

Grazie per la svista, ma quella virgola non mi ha dato problemi.
Sto sviluppando un Software plc per la mia interfaccia Hardware e viste le richieste, ho creato una piena compatibilità con arduino.
In pratica dal Mio Software disegni lo schema elettrico e in emulazione si attivano le uscite di arduino se abilitate.
Funziona tutto perfettamente, sia i valori di temperatura con i cronotermostati Software emulati nel mio sistema e sia gli ingressi ed uscite digitali, solo che mi sono accorto che le istruzioni riguardo all' acquisizione dei valori analogici, mi impediscono la ricezione degli out inviati da seriale verso arduino o altra interfaccia con lo stesso protocollo. Non ho mai studiato C++, tutto quello che ho appreso è stato da questo sito quindi, scusatemi se lo sketch non è conforme ad uno standard preciso ed ordinato.
Cosa intendi per spazi? caratteri a capo oppure spazi tra un carattere e l' altro?
Potresti indicarmi cosa potrei migliorare oppure perchè ho questo problema con la ricezione dei valori seriali?
Comunque grazie per il tuo aiuto :slight_smile:

giohomer:
non vorrei dire una fesseria, ma mi sembra che hai un problema di tempistiche.
se ogni 4 secondi vai a fare il controllo della sonda di temperatura e invii qualcosa ad ogni cambio stato, puo essere che in quegli istanti il micro non sia in ascolto e quindi non prende il comando che gli stai inviando. .......

Senza cattiveria, ma ... purtroppo la stai dicendo ... :grin:

La ricezione da seriale è gestita tramite interrupt ed è anche bufferizzata. La delay() non è in grado di bloccare un interrupt che avviene regolarmente e che permette ai caratteri della seriale di essere memorizzati nel buffer.

Unico problema che si può avere nei casi di delay() è che, se nel periodo di delay() si ricevono più caratteri di quanti il buffer sia in grado di memorizzare (... se ben ricordo 64 char) ... si perdono ... :slight_smile:

Guglielmo

Ciao Guglielmo, finalmente :slight_smile:
Questo concetto me lo avevi spiegato te su un vecchio post. Il problema purtroppo è che quel dato inviato, non arriva e viene perduto ma non so perchè . Se invio per esempio un tot di caratteri es: "AAAAAAA" allora lo prende ma se invio un solo carattere "A" è più le volte che non viene accettato. (Utilizzo i case per accendere/spegnere i relè quindi, il carattere "A" è utilizzato per accendere il relè 1 mentre "a" per spegnerlo) Lo sketch è ancora da finalizzare e quindi ci saranno altri caratteri usati, ma il senso è quello)
Questo problema è presente solo con le istruzioni riferite agli ingessi digitali e quelli delle temperature analogiche.
Cosa succede per non accettare quel comando seriale?

Ho dato una piccola sistemata al tuo codice :

#include <Keypad.h> //LIBRERIA TASTIERINI 4X3

const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns

//definisci i simboli dei tasti tastierino
char hexaKeys[ROWS][COLS] = {
   {'1','2','3','A'},
   {'4','5','6','B'},
   {'7','8','9','C'},
   {'*','0','#','D'}
};

byte rowPins[ROWS] = {5, 4, 3, 2}; //connessione dei pin RIGHE del tastierino
byte colPins[COLS] = {9, 8, 7, 6}; //connessione dei pin COLONNE del tastierino

//Inizializza l' istanza class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

byte digitalpin[] = {30,31,32,33,34,35,36,37,38,39,40,41};
byte lastStatus[] = {HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH};
byte flag;
byte i;
byte buttonStatus;
long previousMillis = 0, interval = 4000;

//------------LM 35
float temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8;
float tempPin1 = 0;
float tempPin2 = 1;
float tempPin3 = 2;
float tempPin4 = 3;
float tempPin5 = 4;
float tempPin6 = 5;
float tempPin7 = 6;
float tempPin8 = 7;

void setup() {
   Serial.begin(115200);
   pinMode(RELE1, OUTPUT);
   pinMode(RELE2, OUTPUT);
   pinMode(RELE3, OUTPUT);
   pinMode(RELE4, OUTPUT);
   for(i = 0; i < sizeof(digitalpin); i++) //Setta a pullup tutti gli ingressi digitali attraverso il ciclo for 
   {
      pinMode(digitalpin[i], INPUT_PULLUP);
   }
}


void loop (){

   //---------------------------------------------------

   TASTIERINO();         // è il nome della funzione che invia i valori dei pulsanti tastierini (pin 2 --> pin 8)
   USCITE();             // è il nome della funzione che invia i valori dei pulsanti tastierini (pin 2 --> pin 8)
   INGRESSI_DIGITALI();  // è il nome della funzione che invia i valori dei pulsanti tastierini (pin A12 --> pin A15)
   TEMPERATURE_LM35();   // è il nome della funzione che invia i valori delle sonde LM35 (pin A0 --> pin A7)
   SERIALE();            // è il nome della funzione che invia i valori degli ingressi diditali (pin 30 --> pin 42)
   //---------------------------------------------------

}

const short RELE1 = 42;
const short RELE2 = 43;
const short RELE3 = 44;
const short RELE4 = 45;

//---------------------------------------------------



void SERIALE() {
   if (Serial.available()) {
      byte command = Serial.read(); //leggo il primo byte
      switch (command) {
      
         case '_' : // RICEZIONE COMANDO PER L' INVIO STATO TUTTI INGRESSI DIGITALI
            Serial.print("D");
            for (i = 0; i < sizeof(digitalpin); i++) Serial.print(!lastStatus[i]); // notare che ora stampa lo stato NEGATO così HIGH 0 LOW 1
            Serial.print("F");
            break;
            
      }
   }
}

//////////////////////////////////    TASTIERINO NUMERICO   ////////////////////////////////

void TASTIERINO() {
   char customKey = customKeypad.getKey();
   if (customKey){
      Serial.print("K");
      Serial.print(customKey);
      Serial.print("F");
   }
}

//-----------------------------------------------------------------

void INGRESSI_DIGITALI() {
   flag = false;

   for (i = 0; i < sizeof(digitalpin); i++) {
      buttonStatus = digitalRead(digitalpin[i]);
      if (lastStatus[i] != buttonStatus) {
         delay(60);
         buttonStatus = digitalRead(digitalpin[i]);
         if (lastStatus[i] != buttonStatus) {
            lastStatus[i] = buttonStatus;        
            flag = true;
         }
      }
   }
   if (flag) {
      Serial.print("D");
      for (i = 0; i < sizeof(digitalpin); i++) Serial.print(!lastStatus[i]); // notare che ora stampa lo stato NEGATO così HIGH 0 LOW 1
      Serial.print("F");
   }
}

//-----------------------------------------------------------------

void TEMPERATURE_LM35() {
   { 
      unsigned long currentMillis = millis();
      if(currentMillis - previousMillis > interval) 
      { 
         previousMillis = currentMillis;   // qui dentro esegui ogni tot di tempo impostato da interval
         temp1 = analogRead(tempPin1);
         temp2 = analogRead(tempPin2);
         temp3 = analogRead(tempPin3) ;
         temp4 = analogRead(tempPin4);
         temp5 = analogRead(tempPin5);
         temp6 = analogRead(tempPin6);
         temp7 = analogRead(tempPin7);
         temp8 = analogRead(tempPin8);

         temp1 = temp1 * 0.48828125 ;
         temp2 = temp2 * 0.48828125;
         temp3 = temp3 * 0.48828125;
         temp4 = temp4 * 0.48828125;
         temp5 = temp5 * 0.48828125;
         temp6 = temp6 * 0.48828125;
         temp7 = temp7 * 0.48828125;
         temp8 = temp8 * 0.48828125;

         Serial.print("T");
         Serial.print(","); 
         Serial.print(temp1);
         Serial.print(","); 
         Serial.print(temp2);
         Serial.print(","); 
         Serial.print(temp3);
         Serial.print(","); 
         Serial.print(temp4);
         Serial.print(","); 
         Serial.print(temp5);
         Serial.print(","); 
         Serial.print(temp6);
         Serial.print(","); 
         Serial.print(temp7);
         Serial.print(","); 
         Serial.print(temp8);
         Serial.print("F"); 
      } // delay(1000);
   }
}

//-----------------------------------------------------------------

void USCITE() {
   if (Serial.available())
   {
      switch (Serial.read()) {
      case '+':	
         digitalWrite (RELE1, HIGH); 
         break; 
      case '-': 
         digitalWrite (RELE1, LOW);	
         break; 
      case 'B':	
         digitalWrite (RELE2, HIGH); 
         break; 
      case 'b': 
         digitalWrite (RELE2, LOW);	
         break; 
      case 'C':	
         digitalWrite (RELE3, HIGH); 
         break; 
      case 'c': 
         digitalWrite (RELE3, LOW);	
         break; 
         Serial.flush();
      }
   }
}

... come noterai ho dovuto commentare nella setup() i pinMode() visto che RELE1, RELE2, RELE3 e RELE4 ... non li hai definiti e chiaramente il compilatore da errore. A te definirli.

Il problema che riscontri sulla lettura dalla seriale è dovuto al fatto che ... nel loop() tu richiami due routines che ENTRAMBE leggono la seriale (funzione SERIALE e funzione USCITE) ed entrambe quindi tolgono il carattere che leggono dal buffer in ingresso. Se un certo carattere che tu digiti è letto prima dall'una che dall'altra ... chiaramente succedono cose diverse ...

Devi unificare la lettura della seriale e l'interpretazione dei comandi o non ne esci ... :wink:

Guglielmo

Finalmente, adesso ho chiaro il problema.
Quindi, come dovrei gestire la seriale.
Mi rendo conto che non è semplice perchè anche se non conosco il C++ per fare una cosa fatta bene sul mio Software, la logica mi ha portato a realizzare un buffer dove vengono ricevute tutte le string e mano a mano vengono prese e , se ritenute valide, destinate a varie funzioni cancellandole oppure, se non valide, buttate via.
Purtroppo ci sono arrivato alogica perchè puo capitare di riceve tante istruzioni insieme e senza un buffer in ricezione, si rischia di perdere qualche dato. Purtoppo in C++ non ho idea di come gestire questi dati.
Dovrei rivedere le istruzioni degli ingressi digitali e quelle delle uscite? spero di no :frowning:

nid69ita:
2. nella loop() hai due routine che leggono da seriale, USCITE() e SERIALE(). Non ho capito perchè.

:roll_eyes: :roll_eyes:

quella seriale serve per ricevere tutti gli stati dei 12 ingressi digitali attraverso il comando"_"
Mentre "SERIALE" serve per gli out di arduino (ON/OFF) attivabili sempre attraverso la ricezione di comandi seriali.

Ma non è li il problema..credo. Forse dovrei mettere dentro una variabile i valori ricevuti e non presi direttamente dalla lettura della seriale? non impiccatemi se ho detto una fesseria

edstarink:
Finalmente, adesso ho chiaro il problema.
Quindi, come dovrei gestire la seriale.

Semplicemente riunendo in un unica funzione quello cle quelle due funzioni fanno e ...

#include <Keypad.h> //LIBRERIA TASTIERINI 4X3

const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns

const short RELE1 = 42;
const short RELE2 = 43;
const short RELE3 = 44;
const short RELE4 = 45;

//definisci i simboli dei tasti tastierino
char hexaKeys[ROWS][COLS] = {
   {'1','2','3','A'},
   {'4','5','6','B'},
   {'7','8','9','C'},
   {'*','0','#','D'}
};

byte rowPins[ROWS] = {5, 4, 3, 2}; //connessione dei pin RIGHE del tastierino
byte colPins[COLS] = {9, 8, 7, 6}; //connessione dei pin COLONNE del tastierino

//Inizializza l' istanza class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

byte digitalpin[] = {30,31,32,33,34,35,36,37,38,39,40,41};
byte lastStatus[] = {HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH};
byte flag;
byte i;
byte buttonStatus;
long previousMillis = 0, interval = 4000;

//------------LM 35
float temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8;
float tempPin1 = 0;
float tempPin2 = 1;
float tempPin3 = 2;
float tempPin4 = 3;
float tempPin5 = 4;
float tempPin6 = 5;
float tempPin7 = 6;
float tempPin8 = 7;

void setup() {
   Serial.begin(115200);
   pinMode(RELE1, OUTPUT);
   pinMode(RELE2, OUTPUT);
   pinMode(RELE3, OUTPUT);
   pinMode(RELE4, OUTPUT);
   for(i = 0; i < sizeof(digitalpin); i++) //Setta a pullup tutti gli ingressi digitali attraverso il ciclo for 
   {
      pinMode(digitalpin[i], INPUT_PULLUP);
   }
}

void loop (){
   //---------------------------------------------------
   TASTIERINO();         // è il nome della funzione che invia i valori dei pulsanti tastierini (pin 2 --> pin 8)
   INGRESSI_DIGITALI();  // è il nome della funzione che invia i valori dei pulsanti tastierini (pin A12 --> pin A15)
   TEMPERATURE_LM35();   // è il nome della funzione che invia i valori delle sonde LM35 (pin A0 --> pin A7)
   SERIALE();            // è il nome della funzione che invia i valori degli ingressi diditali (pin 30 --> pin 42)
   //---------------------------------------------------
}

//---------------------------------------------------

void SERIALE() {
   if (Serial.available()) {
      byte command = Serial.read(); //leggo il primo byte
      switch (command) {
      
         case '_' : // RICEZIONE COMANDO PER L' INVIO STATO TUTTI INGRESSI DIGITALI
            Serial.print("D");
            for (i = 0; i < sizeof(digitalpin); i++) Serial.print(!lastStatus[i]); // notare che ora stampa lo stato NEGATO così HIGH 0 LOW 1
            Serial.print("F");
            break;
            
	 case '+':	
	    digitalWrite (RELE1, HIGH); 
	    break; 
	         
	 case '-': 
	    digitalWrite (RELE1, LOW);	
	    break; 
	         
	 case 'B':	
	    digitalWrite (RELE2, HIGH); 
	    break; 
	         
	 case 'b': 
	    digitalWrite (RELE2, LOW);	
	    break; 
	         
	 case 'C':	
	    digitalWrite (RELE3, HIGH); 
	    break; 

         case 'c': 
	    digitalWrite (RELE3, LOW);	
	    break; 
	         
      }
   }
}

//////////////////////////////////    TASTIERINO NUMERICO   ////////////////////////////////

void TASTIERINO() {
   char customKey = customKeypad.getKey();
   if (customKey){
      Serial.print("K");
      Serial.print(customKey);
      Serial.print("F");
   }
}

//-----------------------------------------------------------------

void INGRESSI_DIGITALI() {
   flag = false;

   for (i = 0; i < sizeof(digitalpin); i++) {
      buttonStatus = digitalRead(digitalpin[i]);
      if (lastStatus[i] != buttonStatus) {
         delay(60);
         buttonStatus = digitalRead(digitalpin[i]);
         if (lastStatus[i] != buttonStatus) {
            lastStatus[i] = buttonStatus;        
            flag = true;
         }
      }
   }
   if (flag) {
      Serial.print("D");
      for (i = 0; i < sizeof(digitalpin); i++) Serial.print(!lastStatus[i]); // notare che ora stampa lo stato NEGATO così HIGH 0 LOW 1
      Serial.print("F");
   }
}

//-----------------------------------------------------------------

void TEMPERATURE_LM35() {
   { 
      unsigned long currentMillis = millis();
      if(currentMillis - previousMillis > interval) 
      { 
         previousMillis = currentMillis;   // qui dentro esegui ogni tot di tempo impostato da interval
         temp1 = analogRead(tempPin1);
         temp2 = analogRead(tempPin2);
         temp3 = analogRead(tempPin3) ;
         temp4 = analogRead(tempPin4);
         temp5 = analogRead(tempPin5);
         temp6 = analogRead(tempPin6);
         temp7 = analogRead(tempPin7);
         temp8 = analogRead(tempPin8);

         temp1 = temp1 * 0.48828125 ;
         temp2 = temp2 * 0.48828125;
         temp3 = temp3 * 0.48828125;
         temp4 = temp4 * 0.48828125;
         temp5 = temp5 * 0.48828125;
         temp6 = temp6 * 0.48828125;
         temp7 = temp7 * 0.48828125;
         temp8 = temp8 * 0.48828125;

         Serial.print("T");
         Serial.print(","); 
         Serial.print(temp1);
         Serial.print(","); 
         Serial.print(temp2);
         Serial.print(","); 
         Serial.print(temp3);
         Serial.print(","); 
         Serial.print(temp4);
         Serial.print(","); 
         Serial.print(temp5);
         Serial.print(","); 
         Serial.print(temp6);
         Serial.print(","); 
         Serial.print(temp7);
         Serial.print(","); 
         Serial.print(temp8);
         Serial.print("F"); 
      } // delay(1000);
   }
}

... ho eliminato USCITE() e raggruppato tutto in SERIALE() :wink:

Guglielmo

edstarink:
quella seriale serve per ricevere tutti gli stati dei 12 ingressi digitali attraverso il comando"_"
Mentre "SERIALE" serve per gli out di arduino (ON/OFF) attivabili sempre attraverso la ricezione di comandi seriali.

Ma mica perché devi fare cose diverse devono stare in funzioni diverse ... :astonished:

Hai un'unica funzione che legge la seriale e, in funzione del carattere ricevuto decide cosa fare ...
... dal fare delle stampe ad attivare dei relè a leggere degli input ... ecc. ecc.

Ogni carattere attiverà un "case" differente e verrà processato come cosa a se stante ... :wink:

Guglielmo

Non ho parole, non solo mi hai fatto capire dove ho sbagliato, ma mi hai anche risolto il problema.
Per quanto riguarda la mia esperienza personale su questo sito, e su qualsiasi altro sito, sei stato il migliore.
Non ho parole. Il 90% di quello ho scritto è frutto del tuo aiuto. Nei credits del mio Software ci sarai anche tu come collaboratore alla parte arduino. Su C++ sono una schiappa, sempre comunque frutto del fai da te, ma me la cavo meglio con altri linguaggi. Realizzare un plc con simulazione Software/Hardware con una interfaccia Hardware creata appositamente è un risultato. Peccato che non abbia mai studiato programmazione, e questo mi comporta rallentamenti e lacune.
Comunque Guglielmo io credo che tu sia una simulazione Software che risponde a comando, una persona fisica che possa dare aiuto in questo modo la vedo impossibile trovarla...per la pazienza, capacità e immediatezza. Sei un GRANDE e ti stimo moltissimo :slight_smile:

edstarink:
Comunque Guglielmo io credo che tu sia una simulazione Software che risponde a comando, una persona fisica che possa dare aiuto in questo modo la vedo impossibile trovarla...per la pazienza, capacità e immediatezza. Sei un GRANDE e ti stimo moltissimo :slight_smile:

Grazie ... così arrossisco ... :blush: :blush: :blush:

Per la verità la cosa te l'aveva segnalata anche Nid ... io te l'ho solo più dettagliata e spiegato perché accadesse ... :wink:

SI, finché sono questi programmi (... piuttosto semplici :wink: ) ... riesco ancora a fare una "simulazione a mente" ... e ci mancherebbe ... sono ... appena 40 anni che mi ci diverto e ... mi preoccuperebbe il contrario XD XD XD

Vedrai che piano piano, facendo esperienza, verrà sempre più naturale anche a te ... :wink:

Buona continuazione !!!

Guglielmo

Sono io che ho frainteso, lui giustamente ha dato per scontato che non serviva creare due istruzioni che si occupano di fare la stessa cosa, io gli ho dato la spiegazione di cosa fanno quelle due funzioni. :roll_eyes:
è come chiedere perchè per muoversi da un posto al' altro bisogna usare due macchine ad una persona che non ha ancora chiaro che dentro una macchina ci possono stare due persone. Naturalmente la risposta idiota è quella:
Perchè dobbiamo essere in due ad andare in quel posto"
Perdonatemi, ma studiare c++ da soli non è semplice perchè se scrivi una istruzione in modo errato ma che da un risultato, se non hai nessuno che la controlla e ti dice che puo andare bene ma ti darà problemi con altre situazioni, diventa difficile. Nei Forum non si trova tutto altrimenti basterebbe un pc, una connessione ad internet per diventare tutti ingegneri programmatori :slight_smile:
Grazie ancora Guglielmo e a tutti quelli che mi hanno dato aiuto.