monitor seriale arduino

Salve a tutti, sono un ragazzo alle prime armi con il linguaggio wiring di Arduino (in realtà con i linguaggi di programmazione in generale). Sto cercando di far partire un braccio robotico che vorrei portare all'esame di maturità, come driver per i motori DC con encoder ho usato un scheda doppio ponte H l298N, un arduino mega per il controllo del tutto.

" A = Serial.read();
Serial.print("valore A: ");
Serial.println(A, DEC);" Dato che ho utilizzato una funzione Switch per dividere il mio sketch in casi,

grazie a queste righe di codice avrei potuto scrivere sul monitor seriale il numero del mio caso (da 1 a 4 con scritta di default nel caso si mandasse un'altra cifra) per farlo partire, non capisco come mai nel monitor seriale continua ad arrivare il valore "-1" senza che io lo inserisca. Confesso che facendo un cortocircuito ho fatto saltare i ponti H ma li ho già sostituiti, non credo di aver bruciato la mega 2560 perchè sembra funzionare. Ciao e grazie in anticipo :slight_smile:

Non vedendo il tuo sketch, posso solo immaginare che tu prima di fare Serial.read() debba verificare se ci sono dati sulla seriale e leggere solo se "Serial.available()" ti dà un valore maggiore di zero (è il numero di caratteri presenti nel buffer, in attesa che tu li legga).
Come da reference:

        if (Serial.available() > 0) {
                // read the incoming byte:
                incomingByte = Serial.read();

                // say what you got:
                Serial.print("I received: ");
                Serial.println(incomingByte, DEC);
        }

Se invece già lo facevi, posta l'intero sketch (ricorda di metterlo dentro ai tag [ code ]) e vediamo.

Ciao non ho ben capito cosa intendi, essendo io davvero terra terra a livello di competenze nella programmazione, il mio sketch infatti è stato creato grazie anche all'aiuto del mio professore.

[
#define UnoPinA 22
#define UnoPinB 23
#define Unoen 2
#define Unoin1 24
#define Unoin2 25
#define UnoPinFC 26
#define DuePinA 27
#define DuePinB 28
#define Dueen 4
#define Duein1 29
#define Duein2 30
#define pinza 500
#define TrePinA 31
#define TrePinB 32
#define Treen 6
#define Trein1 33
#define Trein2 34
#define TrePinFC 35
#define QuaPinA 36
#define QuaPinB 37
#define Quaen 8
#define Quain1 38
#define Quain2 39
#define QuaPinFC 40
#define CinPinA 41
#define CinPinB 42
#define Cinen 10
#define Cinin1 43
#define Cinin2 44
#define CinPinFCA 45
#define CinPinFCI 46
#define SeiPinA 47
#define SeiPinB 48
#define Seien 12
#define Seiin1 49
#define Seiin2 50
#define SeiPinFCA 51
#define SeiPinFCI 52
int A;
int muno = 0;
int mdue = 0;
int mtre = 0;
int mqua = 0;
int mcin = 0;
int msei = 0;
int Mgom = 0;
void setup() {  //sistemare i pinmode, finecorsa come input
  pinMode(UnoPinA, INPUT);
  pinMode(UnoPinB, INPUT);
  pinMode(Unoen, OUTPUT);
  pinMode(Unoin1, OUTPUT);
  pinMode(Unoin2, OUTPUT);
  pinMode(UnoPinFC, INPUT);
  pinMode(DuePinA, INPUT);
  pinMode(DuePinB, INPUT);
  pinMode(Dueen, OUTPUT);
  pinMode(Duein1, OUTPUT);
  pinMode(Duein2, OUTPUT);
  pinMode(TrePinA, INPUT);
  pinMode(TrePinB, INPUT);
  pinMode(Treen, OUTPUT);
  pinMode(Trein1, OUTPUT);
  pinMode(Trein2, OUTPUT);
  pinMode(TrePinFC, INPUT);
  pinMode(QuaPinA, INPUT);
  pinMode(QuaPinB, INPUT);
  pinMode(Quaen, OUTPUT);
  pinMode(Quain1, OUTPUT);
  pinMode(Quain2, OUTPUT);
  pinMode(QuaPinFC, INPUT);
  pinMode(CinPinA, INPUT);
  pinMode(CinPinB, INPUT);
  pinMode(Cinen, OUTPUT);
  pinMode(Cinin1, OUTPUT);
  pinMode(Cinin2, OUTPUT);
  pinMode(CinPinFCA, INPUT);
  pinMode(CinPinFCI, INPUT);
  pinMode(SeiPinA, INPUT);
  pinMode(SeiPinB, INPUT);
  pinMode(Seien, OUTPUT);
  pinMode(Seiin1, OUTPUT);
  pinMode(Seiin2, OUTPUT);
  pinMode(SeiPinFCA, INPUT);
  pinMode(SeiPinFCI, INPUT);

  Serial.begin(9600);
}

int LetturaValori(int a, int PINa, int PINb) {    //pin dei canali A e B
  if (digitalRead(PINa) == HIGH) {
    if (digitalRead(PINb) == LOW) {
      a++;
    } else 
    {
      a--;
    }
  } else {
    if (digitalRead(PINb) == LOW) {
      a--;
    } else {
      a++;
    }
  }
  return a;
}
//motor driver avanti
void MDA(int En, int in1, int in2) {
  int speed = 200;
  analogWrite(En, speed);
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}
//motor driver fermo
void MDF(int En, int in1, int in2) {
  analogWrite(En, 0);
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
}
//motor driver indietro
void MDI(int En, int in1, int in2) {
  int speed = 200;
  analogWrite(En, speed);
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
}

int FunzioneFinecorsa(int PinFC) 
{  // non ha senso fare una funzione che è solo una digitalRead, tanto vale user digitalRead :-)
  digitalRead(PinFC);     // in ogni caso non va void prova con int o bool
}


void loop() {

  A = Serial.read();
  Serial.print("valore A: ");
  Serial.println(A, DEC);
  switch (A) {
    case '1':
      mdue = 0;       // METTI LE RIENTRANZE NEL CODICE ALTRIMENTI E' INCOMPRENSIBILE
      muno = 0;
      mtre = 0;
      MDA(Dueen, Duein1, Duein2); //RC
      MDA(Unoen, Unoin1, Unoin2); //LC
      while (FunzioneFinecorsa(UnoPinFC) == LOW)   //finecorsa leftcount
        if (mdue <= pinza)
        {
          LetturaValori(mdue, 27, 28);
          LetturaValori(muno, 22, 23);
        }
        else
          LetturaValori(muno, 22, 23);            // qui forse c'è un blocco di istruzioni
      MDF(Unoen, Unoin1, Unoin2); //LC         // o deve fare solo la prima LetturaValori
      MDF(Dueen, Duein1, Duein2); //RC
      MDI(Unoen, Unoin1, Unoin2); //LC
      MDI(Dueen, Duein1, Duein2); //RC

      while (muno != 0)
        if (mdue != 0) {
          LetturaValori(mdue, 27, 28);
          LetturaValori (muno, 22, 23);
        }
        else
          LetturaValori(muno, 22, 23);
          
      MDF(Dueen, Duein1, Duein2); //RC
      MDF(Unoen, Unoin1, Unoin2); //LC
      MDA(Treen, Trein1, Trein2); //MTRE
      
      while (FunzioneFinecorsa(TrePinFC) == LOW) //finecorsa mtre
        LetturaValori(mtre, 31, 32);
      MDF(Treen, Trein1, Trein2); //MTRE
      MDI(Treen, Trein1, Trein2); //MTRE
      while (mtre != 0)
        LetturaValori(mtre, 31, 32);
      MDF(Treen, Trein1, Trein2);
      break;

    case '2':

      mqua = 0;
      MDA(Quaen, Quain1, Quain2); //MQUA
      while (FunzioneFinecorsa(QuaPinFC) == LOW)      //finecorsa mqua
        LetturaValori(mqua, 36, 37);
      MDF(Quaen, Quain1, Quain2); //MQUA
      MDI(Quaen, Quain1, Quain2);  //MQUA
      while (mqua != 0)
        LetturaValori(mqua, 36, 37);
      MDF(Quaen, Quain1, Quain2);  //MQUA
      break;

    case '3':

      mcin = 0;
      msei = 0;
      MDA(Cinen, Cinin1, Cinin2); //MCIN
      MDA(Seien, Seiin1, Seiin2); //MSEI
      while (FunzioneFinecorsa(CinPinFCA) == LOW)  //finecorsa avanti mcin
        if (FunzioneFinecorsa(SeiPinFCA) == LOW) {   //finecorsa avanti msei
          LetturaValori(mcin, 41, 42);
        }
      MDF(Seien, Seiin1, Seiin2); //MSEI
      MDF(Cinen, Cinin1, Cinin2); //MCIN
      MDI(Seien, Seiin1, Seiin2); //MSEI
      MDI(Cinen, Cinin1, Cinin2); //MCIN
      while (FunzioneFinecorsa(CinPinFCI) == LOW)      //finecorsa indietro mcin
        if (FunzioneFinecorsa(SeiPinFCI) == LOW)      //finecorsa indietro msei
          LetturaValori (mcin, 41, 42);
      MDF(Cinen, Cinin1, Cinin2); //MCIN
      MDF(Seien, Seiin1, Seiin2); //MSEI
      break;

    case '4':
      mqua = 0;
      mdue = 0;
      MDA(Quaen, Quain1, Quain2);  //MQUA
      while (FunzioneFinecorsa(QuaPinFC) == LOW) 
      { //finecorsa mqua
        LetturaValori(mqua, 36, 37);
      }
 
      MDF(Quaen, Quain1, Quain2);  //MQUA
      MDI(Quaen, Quain1, Quain2);  //MQUA
      while (mqua != 0)
        LetturaValori(mqua, 36, 37);

      MDF(Quaen, Quain1, Quain2);   //MQUA
      MDA(Dueen, Duein1, Duein2);   //RC
      MDA(Quaen, Quain1, Quain2);   //MQUA
      while (mqua <= Mgom) 
      {
        LetturaValori(mqua, 36, 37);
        if (mdue <= pinza)
          mdue++;
      }
      MDF(Dueen, Duein1, Duein2);    //RC
      MDF(Quaen, Quain1, Quain2);    //MQUA
      break;

    default: 
      Serial.println("Errore, metti un numero compreso tra 1 e 4");

  }// <=========== chiude switch
}  // chiude void loop/code]



spero tu mi riesca ad aiutare, grazie in anticipo :)

... Essendo tu davvero terra terra ti consiglio di partire da qualcosa di mooooooolto più semplice: led e pulsante. Poi impari le cose man mano, alla velocità giusta. Questo é un consiglio strano, lo so, ma che NON vuol dire "rinunia", ma " rimanda", e la differenza é abissale.

Comunque conisci già #define, non sei messo così male

Hai perfettamente ragione Silente, infatti ho iniziato proprio perchè mi piace e vorrei mettermi avanti per ingegneria l'anno prossimo, il fatto è che questo progetto dovrei portarlo all'esame di maturità tra un paio di settimane

Allecava:
Ciao non ho ben capito cosa intendi, essendo io davvero terra terra a livello di competenze nella programmazione

Beh intendo questo:

void loop() {

  A = Serial.read();
  Serial.print("valore A: ");
  Serial.println(A, DEC);
  switch (A) {

Qui leggi sempre la seriale, anche quando non ci sono caratteri (considera che il loop viene eseguityo MIGLIAIA di volte al secondo!).

Non entro nel resto del codice (anche perché lo vedo abbastanza "denso" diciamo...) ma quantomeno dovresti mettere una if() prima di tutto ossia fare:

void loop() {
  if (Serial.available() > 0) {
    A = Serial.read();
    Serial.print("valore A: ");
    Serial.println(A, DEC);
    switch (A) {
  ...eccetera

Hai perfettamente ragione Silente, infatti ho iniziato proprio perchè mi piace e vorrei mettermi avanti per ingegneria l'anno prossimo

Questo è lodevole...

il mio sketch infatti è stato creato grazie anche all'aiuto del mio professore.
il fatto è che questo progetto dovrei portarlo all'esame di maturità tra un paio di settimane

Fammi capire.. Il tuo professore ti fa portare all'esame di maturità un progetto del quale non conosci né il linguaggio usato né il suo funzionamento né le basi di Arduino, con un codice scritto da LUI che non comprendi? Boh, non mi pare una cosa normale...
Comunque se il tuo professore è sufficientemente abile in programmazione, fattelo correggere da lui, scusa.

Silente:
Comunque conisci già #define, non sei messo così male

Non lui, il suo prof direi...
Ma comunque quella marea di #define non so bene cosa facciano ma non è che siano propriamente "belli", visto che sembrano 6 gruppi di 6 valori mi danno l'impressione che un array di struct sarebbe stato meglio (e più semplice anche da gestire), una cosa tipo:

typedef struct
 {
     byte PinA;
     byte PinB;
     byte en;
     byte in1;
     byte in2;
     byte PinFC;
 }  config;

config pin[6] = { { ...qui i valori...} };

Mah non so che pensare di sto prof...