Com Seriale , Arduino Uno & Processing

Buonasera a tutti, stò cercando (con somma fatica) di far comunicare Arduino con Processing, inizialmente trasferendo un semplice byte.

Inoltre, considerando le differenze di range del singolo byte da Arduino a Processing, come potrei trasferire un numero intero sulla seriale? Lavorando sui byte H, byte L ?

Di seguito il codice…

Grazie a tutti :grin:

PROCESSING

/**
 * Simple Write. 
 * 
 * Check if the mouse is over a rectangle and writes the status to the serial port. 
 * This example works with the Wiring / Arduino program that follows below.
 */


import processing.serial.*;

//************ PARAMETRI DA IMPOSTARE ********************

// 1 - Dimensione Finestra

final int W=600;
final int H=600;

// 2 - Periodo di aggiornamento del grafico  
final int T = 1000;


long time=0;  // Supporto per l'uso della millis()

byte inNum=0;



//********* VARIABILI DATA

boolean firstContact = false;        // Whether we've heard from the microcontroller
Serial myPort;  // Create object from Serial class




void setup() 
{
   // I know that the first port in the serial list on my mac
  // is always my  FTDI adaptor, so I open Serial.list()[0].
  // On Windows machines, this generally opens COM1.
  // Open whatever port is the one you're using.
   // Print a list of the serial ports, for debugging purposes:
  printArray(Serial.list());

  String portName = Serial.list()[5];            // OCCHIO A QUESTO, CONTROLLA L'INDICE
  myPort = new Serial(this, portName, 9600);
  myPort.bufferUntil('\n');
  
  size(W, H);
 
  // Setting del background e riempimento della finestra
  //background(255);
  //fill(#FFFFFF);
  
  // Creo il frame per aggiornare i tempi senza ridisegnare il grafico

  
  // Stabilisco un contatto con arduino..
  while(!firstContact){
     println("Attendo ping da Arduino..");
     if(myPort.available()<=0){         
     }else{
       print("Ping ricevuto..Restituisco H = ");
       println(H);
       myPort.clear();          // pulisco la seriale
       firstContact = true;     // metto a TRUE il flag di prima connessione
       myPort.write(H);       // pingo indietro e fornisco l'altezza della finestra per la mapping
       
    }
  }
}


void loop(){
  // Disegno il rettangolo in alto a destra per lo zoom
  if((millis()-time)>T){
    
    println("Request...");
    myPort.write("A");
    delay(50);
    while(myPort.available()<=0){print("");
    }
    println(" ");
    print("Numero : ");
    inNum = byte(myPort.read());
    print(inNum);
    myPort.clear();
    time = millis();
    
    }
     
}

ARDUINO

//  Serial Call and Response
//  by Tom Igoe
//  Language: Wiring/Arduino
  
//  This program sends an ASCII A (byte of value 65) on startup
//  and repeats that until it gets some data in.
//  Then it waits for a byte in the serial port, and 
//  sends three sensor values whenever it gets a byte in.
  
//  Thanks to Greg Shakar for the improvements
  
//  Created 26 Sept. 2005
//  Updated 18 April 2008

int const PotPin = 5;
int inByte = 0;         // incoming serial byte
int Signal=0;          // Segnale originale
int mSignal=0;         // Segnale Mappato
boolean firstContact = false;

void setup()
{
  // start serial port at 9600 bps:
  Serial.begin(9600);
  establishContact();  // send a byte to establish contact until Processing responds 
}

void loop()
{
  // ********** Una volta che il contatto è stato stabilito invio, se richiesti, i dati a processing
  
  // Processing stà chiedendo dei dati, glieli fornisco...
  if (Serial.available() > 0) {
    
    Serial.flush();
    
    if(!firstContact){
      int hWindow = Serial.read();
      firstContact = true;
    }else{
    
    //Signal = analogRead(PotPin);
    //mSignal = map(Signal,0,1023,0,hWindow);
    mSignal=50;
    Serial.print(mSignal);
    delay(50);
    //Serial.write("\0");
   }
  }
}

void establishContact() {
  
 //*********** Inizia la comunicazione, cercando di stabilire un contatto.
 while (Serial.available() <= 0) {
      Serial.write('R');   // send a capital R
      delay(300);
  }
}





/**                            PROCESSING SKETCH 
 * Serial Call-Response 
 * by Tom Igoe. 
 * 
 * Sends a byte out the serial port, and reads 3 bytes in. 
 * Sets foregound color, xpos, and ypos of a circle onstage
 * using the values returned from the serial port. 
 * Thanks to Daniel Shiffman  and Greg Shakar for the improvements.
 * 
 * Note: This sketch assumes that the device on the other end of the serial
 * port is going to send a single byte of value 65 (ASCII A) on startup.
 * The sketch waits for that byte, then sends an ASCII A whenever
 * it wants more data. 
 */
 
/*
import processing.serial.*;

int bgcolor;			     // Background color
int fgcolor;			     // Fill color
Serial myPort;                       // The serial port
int[] serialInArray = new int[3];    // Where we'll put what we receive
int serialCount = 0;                 // A count of how many bytes we receive
int xpos, ypos;		             // Starting position of the ball
boolean firstContact = false;        // Whether we've heard from the microcontroller

void setup() {
  size(256, 256);  // Stage size
  noStroke();      // No border on the next thing drawn

  // Set the starting position of the ball (middle of the stage)
  xpos = width/2;
  ypos = height/2;

  // Print a list of the serial ports, for debugging purposes:
  printArray(Serial.list());

  // I know that the first port in the serial list on my mac
  // is always my  FTDI adaptor, so I open Serial.list()[0].
  // On Windows machines, this generally opens COM1.
  // Open whatever port is the one you're using.
  String portName = Serial.list()[0];
  myPort = new Serial(this, portName, 9600);
}

void draw() {
  background(bgcolor);
  fill(fgcolor);
  // Draw the shape
  ellipse(xpos, ypos, 20, 20);
}

void serialEvent(Serial myPort) {
  // read a byte from the serial port:
  int inByte = myPort.read();
  // if this is the first byte received, and it's an A,
  // clear the serial buffer and note that you've
  // had first contact from the microcontroller. 
  // Otherwise, add the incoming byte to the array:
  if (firstContact == false) {
    if (inByte == 'A') { 
      myPort.clear();          // clear the serial port buffer
      firstContact = true;     // you've had first contact from the microcontroller
      myPort.write('A');       // ask for more
    } 
  } 
  else {
    // Add the latest byte from the serial port to array:
    serialInArray[serialCount] = inByte;
    serialCount++;

    // If we have 3 bytes:
    if (serialCount > 2 ) {
      xpos = serialInArray[0];
      ypos = serialInArray[1];
      fgcolor = serialInArray[2];

      // print the values (for debugging purposes only):
      println(xpos + "\t" + ypos + "\t" + fgcolor);

      // Send a capital A to request new sensor readings:
      myPort.write('A');
      // Reset serialCount:
      serialCount = 0;
    }
  }
}


*/

Ti sconsiglio di trasferire cifre come byte o interi. Tu ad esempio leggi until '\n', ma se devi spedire il valore 10 ? Il carattere \n non è magico, è un valore tra 0-255 e vale 10. Meglio convertire in testo e spedire le singole cifre. Le varie cifre saranno sempre comprese tra '0' e '9' (ovvero tra 48 e 57) e non ci possono essere "dubbi".

EDIT: e questo non spedisce il byte 50, ma '5' e poi '0' ovvero la print spedisce in modalità testo:

mSignal=50;
Serial.print(mSignal);

Sisi, come li invia era chiaro. Ad ogni modo, penso userò la libreria Firmata...penso che per quello che devo fare (campionare da pin di arduino) possa andare bene, inoltre mi evita un po' di noie... Grazie mille Nid!