Comunicazione seriale arduino mega [RISOLTO]

Ciao a tutti, è tutto il pomeriggio che ci provo ma non riesco a trovare una soluzione.
Ho un arduino mega che legge i dati tramite porta seriale da un dispositivo.
Se lo collego alle porte serial 1,2,3 non riesco a leggere i valori.
Se invece lo faccio leggere al pin 10 simulando una seriale con softserial, la lettura avviene in maniera corretta.
Quale differenza ci potrebbe essere tra le due tipologie di seriale?

Grazie saluti Fabio

Tutte le differenze che ci sono nelle inizializzazioni che non ci hai mostrato...

byte in[8]; // buffer di ricezione. che forse non serve, ma per ora....

byte checksum;

#include <SoftwareSerial.h>

#define rxPin 10
#define txPin 11

SoftwareSerial softSerial =  SoftwareSerial(rxPin, txPin);



unsigned long int previousMillis;
int Ph;  //  valore attuale ph
int Pho; // valore precedente ph
int Rx; //  valore attuale Redox
int Rxo; // valore precedente Redox


// parte aggiunte per richiesta in privato
unsigned long int temp_adapt = 1000;
float ph_value_float;
float redox_value_float;
unsigned long int previousMilli_s;  



void setup()
{   softSerial.begin(9600);
    //Serial1.begin(9600);
    Serial.begin(9600);
    Serial.println("Programma di lettura da dispositivo sconosciuto");
    Serial.println("di Nelson StandardOil");
   
}


void loop()
{
    if (millis() - previousMillis >= 1000)
    {
        aggiorna();
        // per stampare
    }

   // if (Serial1.available())//per mega
    if (softSerial.available()) //per arduino1
    {
        // abbiamo qui un carattere in ricezione
        tratta(softSerial.read());
         //tratta(Serial1.read());
        // accetto il carattere in ricezione e lo mando in trattamento
    }

   
    if (millis() - previousMilli_s >= temp_adapt)
    {
        previousMilli_s = millis();
        //Ph
        ph_value_float = Ph / 100.0;
        Serial.println("Ph value");
         Serial.println(ph_value_float);
        // Redox
        redox_value_float = Rx *1.0;
         Serial.println("Redox value");
         Serial.println(redox_value_float);
    }

    // ok la loop è finita qui
}

void aggiorna(void)
{
    // mando in stampa le letture
    previousMillis = millis();
    Serial.print("Valore attuale Ph: ");
    Serial.println(Ph);

    if (Ph != Pho)
    {
        Pho = Ph;
        Serial.print(" Aggiornato rispetto ultima lettura");
    }

    Serial.println();
    Serial.print("Valore attuale Redox: ");
    Serial.println(Rx);

    if (Rx != Rxo)
    {
        Rxo = Rx;
        Serial.print(" Aggiornato rispetto ultima lettura");
    }

    Serial.println();
}






void tratta(char cx)
{
    static byte i = 0;

    
    if (cx == 0x55)
    {
        // uno start resetto tutto
        i = 0;
        checksum = 0x55; // inizializzo anche il conto del checksum
        return;
      
    }
    else
    {
        in[i++] = cx; // lo iesimo carattere viene scritto nel array, e poi i viene incrementato

  
        if (i == 7)
        {
            valida();
            // la valida testa il checksum e se superato interpreta la stringa
        }
        else
        {
            checksum = checksum + cx; // aggiorno il checksum passo a passo
        }
    }
}


void valida()
{
    if (in[6] == checksum)
    {
        
        Ph = in[1] * 256 + in[2]; 
        Rx = in[4] * 256 + in[5] - 2048;
    }
    else
    {
        Serial.println("Checksum errato, controllare trasmissione");
    }
}

ciao in realtà speravo che mi rispondessi perchè il codice lo conosci già.
Fino a poco tempo fa leggeva perfettamente poi, d’un tratto, il problema: legge inizializzando la softserial sul pin 10 e non con serial 1 oppure 2 oppure 3.

Strano…

Grazie Fabio

Devi farci vedere il codice che non funziona e non quello che funziona con la softwareserial.
Ciao Uwe

byte in[8]; // buffer di ricezione. che forse non serve, ma per ora....

byte checksum;






unsigned long int previousMillis;
int Ph;  //  valore attuale ph
int Pho; // valore precedente ph
int Rx; //  valore attuale Redox
int Rxo; // valore precedente Redox



unsigned long int temp_adapt = 1000;
float ph_value_float;
float redox_value_float;
unsigned long int previousMilli_s;  



void setup()
{   
    Serial1.begin(9600); //per arduino mega
    Serial.begin(9600);
    Serial.println("Programma di lettura da dispositivo sconosciuto");
    Serial.println("di Nelson StandardOil");
   
}


void loop()
{
    if (millis() - previousMillis >= 1000)
    {
        aggiorna();
        // per stampare
    }

    if (Serial1.available())//per arduino mega
   
    {
        // abbiamo qui un carattere in ricezione
        
         tratta(Serial1.read());//per arduino mega
        // accetto il carattere in ricezione e lo mando in trattamento
    }

   
    if (millis() - previousMilli_s >= temp_adapt)
    {
        previousMilli_s = millis();
        //Ph
        ph_value_float = Ph / 100.0;
        Serial.println("Ph value");
         Serial.println(ph_value_float);
        // Redox
        redox_value_float = Rx *1.0;
         Serial.println("Redox value");
         Serial.println(redox_value_float);
    }

   
}

void aggiorna(void)
{
    // mando in stampa le letture
    previousMillis = millis();
    Serial.print("Valore attuale Ph: ");
    Serial.println(Ph);

    if (Ph != Pho)
    {
        Pho = Ph;
        Serial.print(" Aggiornato rispetto ultima lettura");
    }

    Serial.println();
    Serial.print("Valore attuale Redox: ");
    Serial.println(Rx);

    if (Rx != Rxo)
    {
        Rxo = Rx;
        Serial.print(" Aggiornato rispetto ultima lettura");
    }

    Serial.println();
}






void tratta(char cx)
{
    static byte i = 0;

    
    if (cx == 0x55)
    {
        // uno start resetto tutto
        i = 0;
        checksum = 0x55; // inizializzo anche il conto del checksum
        return;
      
    }
    else
    {
        in[i++] = cx; // lo iesimo carattere viene scritto nel array, e poi i viene incrementato

  
        if (i == 7)
        {
            valida();
            // la valida testa il checksum e se superato interpreta la stringa
        }
        else
        {
            checksum = checksum + cx; // aggiorno il checksum passo a passo
        }
    }
}


void valida()
{
    if (in[6] == checksum)
    {
        
        Ph = in[1] * 256 + in[2]; 
        Rx = in[4] * 256 + in[5] - 2048;
    }
    else
    {
        Serial.println("Checksum errato, controllare trasmissione");
    }
}

eccolo!

A proposito, com'è andata a finire col calcolo di quella tabella?

Sinceramente sto ancora aspettando che il chimico mi risponda. Nel frattempo questo grave problema mi ha bloccato la prosecuzione del progetto. Queste anomalie apparentemente inspiegabili richiedono ore di test e studio ma il più delle volte non si arriva ad una conclusione.....

qualcuno mi sa spiegare la differenza tra una software serial e le tre seriali del mega?
grazie

Secondo me delle due l'una:
O hai sbagliato a collegarti alle seriali hw
Oppure le hai guastate...
Eppoi scusa...
Tu, piuttosto di fare mezz'ora di lavoro con Excel, che ti avevo spiegato per filo e per segno cosa fare, hai preferito attendere per un mese e mezzo che il lavoro lo facesse un altro?
Buono a sapersi

Posso fare un test software per sapere se le seriali funzionano, non so caricando un codice che scrive su na seriale e legge dal serial monitor?

fafidio:
qualcuno mi sa spiegare la differenza tra una software serial e le tre seriali del mega?
grazie

Il Arduino MEGA ha 4 seriali realizzate in hardware. Il controller deve prendere o scrivere i dati solo in un buffer. della trasmissione/ricezione si ocupa l' hardware.
La software serial é una seriale che il controller emula via software. Il controller lavora per poter leggere o mandare dei dati. Puó ricevere solo una seriale software alla volta e non é piú veloce di 9600 baud..

Visto che il Mega ne ha 4 e 3 non usate é meglio usare quelle hardware.
Ciao Uwe

Grazie Uwe per la risposta.

Posso in qualche modo fare un test se le tre seriali funzionano con un codice?

Ho visto questo esempio ma non so se fa al caso:

void setup() {
  // initialize both serial ports:
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop() {
  // read from port 1, send to port 0:
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
  }

  // read from port 0, send to port 1:
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.write(inByte);
  }
}

Non ho capito come fare a verificare che ci sia comunicazione tra una e l'altra porta....
grazie Fabio

Beh; stai controllando solo 2 seriali hardware ma dovrebbe funzionare.
Ciao Uwe

il bello è che non funziona!!
legge perfettamente dalla seriale simulata ma non legge da ciascuna delle tre seriali hardware.

Vorrei provare a collegare un UNO al Mega via seriale e provo ad inviare un "accendi led" .
Se dall'altro lato sul mega si accende la seriale funziona.....almeno penso che questa sia la prova del 9.

Risultato del test le porte funzionano tutte e tre collegando un arduino uno all'arduino mega:
invio un carattere dal mega all'UNO e mi ritorna una risposta di UNO correttamente.

Escludo che le porte siano danneggiate.

Non capisco quindi perchè su una seriale simulata il dispositivo legge perfettamente e su una hw no.

Qualsiasi idea/consiglio è bene accetta.....
grazie

scusami ma io sono "di coccio" come si dice :slight_smile:

mi pare che tu stia facendo parlare due seriali tra di loro sulla mega, siccome la seriale "standard" è collegata al monitor seriale dell'ide o apri un altro monitor seriale sul pc (esempio con termite) e la colleghi alla seconda seriale della mega o altrimenti come fai per vedere la risposta e per effettuare l'invio di caratteri...

Patrick sembra ma non è così.... :slight_smile:

Ho collegato un dispositivo sconosciuto tramite softserial su un mega e funziona perfettamente.
Se collego lo stesso dispositivo tramite serial1 (hw) o serial2 o serial3 il dispositivo non funziona.
Chi lo sa perchè?

Ho postato i codici con le letture, ma ancora nessuno sa spiegare il motivo....tantomeno io che ho visto il dispositivo che prima funzionava perfettamente sulle seriali hw ed ora solo con seriali simulate.

Non ci capisco più niente.....

Standardoil:
Secondo me delle due l'una:
O hai sbagliato a collegarti alle seriali hw
Oppure le hai guastate...

e aggiungo:
No schemi no capire

Hai provato di cortocicuitare RX con TX sulla MEGA?

Hai provato di invertire RX con TX tra MEGA e scheda non funzionante.

Ciao Uwe

Standardoil:
e aggiungo:
No schemi no capire

Questo è il semplicissimo schema di collegamento tra il dispositivo che trasmette dati su seriale e l’arduino mega che riceve (o almeno dovrebbe).

Provando con una seriale simulata sul pin 10 funziona perfettamente, con una delle tre seriali hw non legge niente.

Confermo che collegando un arduino uno al mega ed inviando dati dall’una all’altra scheda e viceversa le due schede comunicano perfettamente: escludo errori di connessioni e porte danneggiate.

Ciao Fabio