inviare variabili a processing

ciao a tutti,
dal ricevitore rx 433 ricevo dei dati da sensori che associo a variabili di tipo int e float. Vorrei inviare tali valori tramite seriale a Processing e farli associare a altre variabili per poi fare dei calcoli. Non ne riesco a venirne a capo, ho cercato varie informazioni in rete ma non mi riesce.
il dettaglio del problema stà nel prendere la variabile per esempio Int gradi, int gradidec; e trasferirle a procesing e associarle alle rispettive variabili.
Purtroppo il mio inglese è quello che è, qualcuno cortesemente può consigliarmi una pagina web dove prendere spunto per ottenere ciò o magari qualcuno ha la gentile pazienza di scrivermi un esempio sia per arduino e Processing?
Grazie a tutti in anticipo

Per la parte Processing ti puoi rifare alle reference ufficiali qui, è un sito in inglese, ma ti serve solo per capire quali metodi ti offre la classe serial.h.
Discorso simile per Arduino qui.
Prendi spunto dagli esempi contenuti nell'IDE di Arduino sotto la sezione "Communication".
A livello di funzionamento logico il tuo Arduino apre la porta seriale ad una velocità decisa da te chiamata baund e con il metodo write invia i dati suddivisi in singoli byte, quindi per esempio gli interi dovrai trasformarli in array di byte (16552 => 64, 168) mentre dalla parte Processing ti connetterai alla porta seriale di Arduino con il baund rate deciso prima e leggerai i dati byte per byte per poi riassemblarli nei loro formati originali.
Andrebbero fatte ulteriori precisazioni ma per il momento puoi provare ad impostare questo sistema, una volta che sarai riuscito a farlo funzionare si potrà ottimizzare.

Immagina come se a ogni ciclo del codice loop inviassi una struttura di n byte che ha i suoi elementi nei formati predefiniti, ti semplificherà la vita avere la medesima struttura nel applicazione di processing.

Grazie per i suggerimenti, gli darò un’occhiata nella speranza di capirci qualcosa…grazie ancora

qualche passo avanti l’ho fatto, ovvero riesco a spedire una variabile e visualizzarla correttamente su processing, ma non ho capito come fare ad inviarne due e farle associare in modo distinto e separato, ovvere per esempio spedire temperatura e un’altro dato per esempio.

ARDUINO

#include <LiquidCrystal.h>
/*-----collegamenti hardware--------

lcd 2x16

// * LCD RS pin to digital      ---pin8 pin chip 13
// * LCD Enable pin to digital  ---pin7 pin chip 12
// * LCD D4 pin to digital     --- pin 6 pin chip 11
// * LCD D5 pin to digital      --- pin 5 pin chip 6
// * LCD D6 pin to digital      --- pin 4 pin chip 5
// * LCD D7 pin to digital     ---- pin 3 pin chip 4

/**
Questo programma va caricato sul RX e permette di ricevere una stringa che è stata inviata da un altro Arduino
*/
#include <VirtualWire.h>
  int gradi;
  int gradidec;
  byte segno;
float temperatura;
int temp[2]={gradi,gradidec};
  LiquidCrystal lcd(8, 7, 6, 5, 4, 3);  //configurazione collegamenti con la board uno rev 3-pin digital
void setup(){
 lcd.begin(16,2);  //si dichiara di aver utilizzato un lcd 16x2
  lcd.print("temperatura EXT RF"); //copyrght
 lcd.setCursor(6,1);
// lcd.print(",");
  Serial.begin(57600); // Debugging only
// Serial.println("setup");
 vw_set_rx_pin(2);
 // Initialise the IO and ISR
 vw_set_ptt_inverted(true); // Required for DR3100
 vw_setup(2000); // Bits per sec
  
 vw_rx_start(); // Start the receiver PLL running
}
  
void loop()

{
 uint8_t buf[VW_MAX_MESSAGE_LEN];
 uint8_t buflen = VW_MAX_MESSAGE_LEN;
  
 if (vw_get_message(buf, &buflen)) // Non-blocking
 {
 int i;
  
 digitalWrite(13, true); // Flash a light to show received good message
 // Message with a good checksum received, dump it.
// Serial.print("Got: ");
  
 for (i = 0; i < buflen; i++)
 {
//Serial.print(buf[i], DEC);
// Serial.println("");
 gradi=buf[1];
 gradidec=buf[3];
segno=buf[5];
/*
 //prova=prova/10;
     lcd.setCursor(4, 1);  
    lcd.print(gradi);
     lcd.setCursor(6,1);
 lcd.print(",");
    lcd.setCursor(7,1);
    lcd.print(gradidec);
 */
 temperatura=gradi*100;
 temperatura=temperatura+gradidec;
 temperatura=temperatura/100;
      lcd.setCursor(5, 1);  
    lcd.print(temperatura);
    
// Serial.print("Gradi: ");Serial.print(gradi);
// Serial.print("  gradi decimali  "); Serial.println(gradidec);
 if (segno==0){
// Serial.print(" Temperatura  ");Serial.print(gradi);Serial.print(",");Serial.print(gradidec);
lcd.setCursor(3,1);
 lcd.print(" ");
 }
 else{
// Serial.print(" Temperatura - ");Serial.print(gradi);Serial.print(",");Serial.print(gradidec);
 lcd.setCursor(3,1);
 lcd.print("-");
 }
 }
 //Serial.println(gradi);Serial.println(gradidec);
 Serial.println(temperatura);
 digitalWrite(13, false);
 }

}

Processing

// I know that the first port in the serial list on my mac
// is Serial.list()[0].
// On Windows machines, this generally opens COM1.
// Open whatever port is the one you're using.
import processing.serial.*;
Serial myPort;  // Create object from Serial class
String val;     // Data received from the serial port
float gradi;
void setup(){
  size(500,500);
String portName = Serial.list()[0]; //change the 0 to a 1 or 2 etc. to match your port
myPort = new Serial(this, portName, 57600); 
myPort.bufferUntil('\n');

}


void draw() {
  background(#9DEEF7);
//fill background in gray
 fill (227,227,227);
 smooth();
   fill(0);
      textSize(30);
    text(gradi,250,250);
  // Expand array size to the number of bytes you expect
  byte[] inBuffer = new byte[7];
  while (myPort.available() > 0) {
    inBuffer = myPort.readBytes();
    myPort.readBytes(inBuffer);
    if (inBuffer != null) {
      String myString = new String(inBuffer);
      println(myString);
     val=myString; 
    }
   val = trim(val);
gradi = float(val);

  }
  
}

Grazie in anticipo

gironico:
qualche passo avanti l’ho fatto, ovvero riesco a spedire una variabile e visualizzarla correttamente su processing, ma non ho capito come fare ad inviarne due e farle associare in modo distinto e separato, ovvere per esempio spedire temperatura e un’altro dato per esempio.

Allora andiamo piano e con ordine, siamo in un sistema di basso livello, USART, il modulo hardware che ti permette di inviare i dati attraverso quella che in Arduino è definita semplicemente come “Serial”, può inviare da un minimo di 7bit alla volta ad un massimo di 9bit, concentriamoci sul trasferimento di 8bit, standard di Arduino non che equivalente di un byte.
Capisci che se parli in termini di “variabile” dici tutto ma è come se non dicessi niente, parliamo in termini di byte

int a = 76234;//Variabile int che voglio trasferire
byte firstByte = a & 255;//primo byte della variabile int lo ottengo facendo and bit a bit con un byte di tutti 1 cioè  255
byte secondByte = (a >> 8) & 255;//secondo byte, lo ottengo spostando a sinistra di 8 bit il byte e facendo sempre and bit a bit con 255
Serial.write(firstByte);//Invio il primo byte
Serial.write(secondByte);//Invio il secondo byte
byte firstByte = Serial.readByte();
byte secondByte = Serial.readByte();
int a = firstByte | (secondByte << 8);//ricompongo l'intero

Questo è uno pseudo-codice basato sul C che ti dovrebbe far capire come si scompongo e ricompongono gli interi, detto questo spiegaci bene cosa ti blocca.

Ti ringrazio per il tempo che mi hai dedicato, mi hai dato dei suggerimenti che mi hanno portato alla svolta....

cercando sul forum ho letto il consiglio di un utente che diceva di spedire tramite seriale il dato precedo da una lettera per esempio A

Su processing quando leggo il dato mi trovo per esempio A17,64, quindi andando a leggere il primo dato riesco poi ad associarlo ad una variabile, ecco il sorgente di processing che ho riscritto:

// I know that the first port in the serial list on my mac
// is Serial.list()[0].
// On Windows machines, this generally opens COM1.
// Open whatever port is the one you're using.
import processing.serial.*;
Serial myPort;  // Create object from Serial class
//String val;     // Data received from the serial port
//float gradi;
String inString;
int val;
String gradiv;  //temperatura nella vigna
String gradie;  // temperaura esterna
String pressione; // Pressione atmosferica
String altitudine; //altitudine rispetto livello del mare

void setup(){
  size(1280,1024);
String portName = Serial.list()[0]; //change the 0 to a 1 or 2 etc. to match your port
myPort = new Serial(this, portName, 57600); 
myPort.bufferUntil('\n');

}


void draw() {
  
  background(#9DEEF7);
//fill background in gray
 fill (227,227,227);
 smooth();
   fill(0);
   textSize(30);
text("Temperatura Vigneto",500,50);text("°C",1100,50);
text("Pressione Atmosferica",500,100);text("hPa",1130,100);
text("Temperatura Esterna",500,150);text("°C",1130,150);
text("Altitudine (da calcolo)",500,200);text("Mt",1130,200);  
  
//void serialEvent(Serial p) { 
  while (myPort.available() > 0) {
  inString = myPort.readString(); 
  char primo=inString.charAt(0);  // primo carattere
  String cifra=inString.substring(1);  // da secondo carattere in poi
  int val=parseInt(cifra);          // valore da 0-255 o 0-1023, non sò cosa spedisce arduino
  print("primo=");  println(primo); //debug
  print("cifra=");  println(cifra); //debug
  print("val=");    println(val);

  switch(primo) { 
    case ('T'): gradiv=(cifra);

      break;
    case ('P'): pressione=(cifra);
      break;  

      case ('K'): gradie=(cifra);
      break; 
    case ('Z'): altitudine=(cifra);
      break;
  } 
}
 
 if (gradiv !=null){
    text(gradiv,1000,50);
 } 
  if (pressione !=null){
    text(pressione,1000,100);
 } 
   if (gradie !=null){
    text(gradie,1000,150);
 } 
   if (altitudine !=null){
    text(altitudine,1000,200);
 } 
}

 [CODE]

Grazie mille ancora

Lavori ancora a stringhe, ma tu non stai passando stringhe, devi leggere i byte singolarmente myPort.read() restituisce il primo byte presente nel buffer e lo rimuove dal buffer. Il buffer è un sistema di archiviazione di tipo FIFO, il primo elemento che arriva sarà il primo elemento ad essere letto, questo ti garantisce ordine nella ricezione di dati, il primo byte inviato da Arduino sarà il primo che il PC riceverà.
Se Arduino spedisce il byte 0x52 (notare la combinazione 0x che indica che il numero è esadecimale, se hai un po di famigliarità con le notazioni numeriche informatiche saprai che un byte comprende i valori che vanno da 0x00 a 0xFF) da processing lo leggo, so che è il primo byte inviato, quindi io bravo programmatore che so a cosa corrisponde il primo byte inviato so esattamente dove andrà inserito, quindi aspetto il secondo ecc finché non arrivo all’ultimo byte che mi serve per completare la mia struttura di informazioni, a quel punto reinizio dall’inizio se mi aspetto un nuovo ciclo di dati subito.
Ti faccio un esempio di un sistema semplice su cui sto lavorando ultimamente, ho un AVR collegato al PC che attende delle informazioni, sa che il primo byte che riceverà sarà un dato di verifica per essere identificato quindi nel setup lui aspetta questo dato con il classico serial.available(). Finita la verifica entra in modalità impostazioni, si aspetta un singolo byte che gli dica in che modalità avviarsi

while(serial.available() == 0);//Attendo il byte che indicherà la modalità da avviare
switch(serial.read()){//Uso un switch per scegliere una modalità in base al byte ricevuto
    case 0: modeA(); break;
    case 1: modeB(); break;
    case 2: modeC(); break;
}

entrato in una determinata modalità sa che dovrà aspettarsi dati a gruppi di 3 byte quindi ho

void modeA()
{
    byte a = 0;//Preparo le 3 variabili che conterranno i dati da ricevere
    byte b = 0;
    byte c = 0;
    while(1) {//Entro in loop
        while(serial.available() < 3);//Attendo che il modulo USART abbia ricevuto 3 byte
        a = serial.read();//leggo i byte in ordine
        b = serial.read();
        c = serial.read();
        //Effettuo le mie operazioni con i 3 byte ricevuti
    }//E poi di nuovo dall'inizio
}

Come vedi non servono dei marker aggiuntivi come la ‘A’ suggerita, mi è bastato conteggiare i byte, questo discorso si può fare se si usano codici veloci da eseguire che non saturino il buffer di ricezione mandandolo in overflow, questo vale per la maggior parte delle applicazioni, ti basti sapere che alcune delle applicazioni che si usano anche a livelli professionali danno per scontato che il buffer non si saturi data la velocità del sistema e quindi non implementano alcun controllo verso questa tipologia di errori. Poi nel tuo caso è improbabile che Arduino riesca a saturare il buffer di una porta COM di un PC.
Capisco che all’inizio il sistema di “reti” può sembrare complicato e macchinoso ma stai tranquillo dopo la prima implementazione tutto il percorso è in discesa. Magari un giorno arriverai a studiare e capire come funziona a livello fisico il componente che stai usando, l’USART.

hai perfettamente ragione, grazie ancora per il consiglio , in effetti il tuo sistema è più semplice e lineare.....la mosca tira il calcio che può, nella vita faccio il viticoltore, come studi ho fatto elettrtecnica, e da giuigno ho incominciato per gioco a scrivere qualcosa con mikrobasic per i pic. da poco ho scoperto l'ide e processing, ancora ne devo mangiare di pastasciutta..... ci gioco qualche ora dopo cena quando posso....

Non dirlo a me che come studi superiori non ero neanche lontanamente nel campo XD
Si capiva dai commenti che eri legato al mondo della viticoltura :wink:
Arduino offre grandissime semplificazioni nello sviluppo nel campo dell'elettronica programmata, purtroppo come non mi stancherò mai di ripetere troppi pensano che queste semplificazioni possano sopperire a qualsiasi deficienza(giuro non voglio essere cattivo con questo termine) dello sviluppatore, anche Arduino necessita di conoscenze date da esperienza e studio. Sapere scrivere delle applicazioni corrette in C non è indispensabile per sviluppare con l'IDE Arduino, ma di sicuro è necessario per poter sviluppare un buon codice.
Ho scritto un post 15 minuti fa in risposta ad un utente che chiedeva dei consigli per iniziare con Arduino, capisco che molte persone non hanno tempo da dedicare allo studio di come funziona un AVR ma se il settore ti interessa ci metti il tempo che vuoi, ma alla fine padroneggi il sistema Arduino e l'unico limite è la dimensione della memoria flash XD