utilizzare gli input letti da usb

[linowp]

immagino per un attimo che il codice di arduino sia il seguente:

const int greenLEDPin = 9;
const int redLEDPin = 11;
const int blueLEDPin = 10;


const int redSensorPIN = A0;
const int greenSensorPIN = A1;
const int blueSensorPIN = A2;


int redValue = 0;
int greenValue = 0;
int blueValue = 0;


int redSensorValue = 0;
int greenSensorValue = 0;
int blueSensorValue = 0;


void setup() {
// put your setup code here, to run once:
Serial.begin(9600);


pinMode(greenLEDPin,OUTPUT);
pinMode(redLEDPin,OUTPUT);
pinMode(blueLEDPin,OUTPUT);
}


void loop() {
// put your main code here, to run repeatedly:
redSensorValue = analogRead(redSensorPIN);
delay(5);
greenSensorValue = analogRead(greenSensorPIN);
delay(5);
blueSensorValue = analogRead(blueSensorPIN);

redValue = redSensorValue/4;
greenValue = greenSensorValue/4;
blueValue = blueSensorValue/4;

}

posso intervenire in java utilizzando i valori di queste variabili?

[andbin]

ipotizzo che nel codice arduino non abbia previsto una stampa dei valori delle variabili

Quello che quel codice Arduino invia sulla seriale è la "stampa" di quelle 6 variabili! Solo che il formato è un po' "rozzo" per i motivi detti prima.

posso trasportami in java da usb (collegata ad ardunio) le variabili e gli annessi valori per poterli gestire in modo indipendente?Invece di un input da tastiera voglio un input dato dal valore di luminosità della variabile derivante da arduino,è possibile?

Pur accettando quel formato (brrrr...) a te lato Java arriva una "linea" (terminata dal newline, che non c'è nella stringa perché readLine() di BufferedReader lo toglie). E quindi basterebbe analizzare la stringa con tutti i metodi a disposizione per le stringhe.
Fare una espressione regolare che estrae quei 6 dati è il meno (te lo posso anche scrivere io o altri).

Il punto è quello che ho detto, hai nella riga due pezzi di informazioni non correlati tra di loro.

Volendo farti vedere ciò che è correlato, guarda questo output che ho colorato:

Raw Sensor Values Red: 919 Green: 913 Blue: 881
Mapped Sensor Values Red: 229/t Green: 228 Blue: 220Raw Sensor Values Red: 919 Green: 914 Blue: 882
Mapped Sensor Values Red: 229/t Green: 228 Blue: 220Raw Sensor Values Red: 919 Green: 913 Blue: 882
Mapped Sensor Values Red: 229/t Green: 228 Blue: 220Raw Sensor Values Red: 920 Green: 914 Blue: 882

In ogni riga hai un pezzo di informazione precedente e un pezzo della successiva.

[linowp]

ho capito perfettamente cosa vuoi dire. La mia domanda è un'altra:siccome nel caso reale che a me serve posso solo recuperare i sorgenti arduino (e lì non è prevista una stampa dei valori) posso in qualche modo operare con le variabili arduino in java?

[andbin]

(e lì non è prevista una stampa dei valori) posso in qualche modo operare con le variabili arduino in java?

NO. Se non è il codice Arduino che ti manda quei dati sulla seriale (o tramite altro es. Ethernet/Wi-Fi) in un qualche formato ragionevole (magari meglio di quello lì un po' rozzo) ... non vedo come un PC possa "sapere" cosa succede sulla scheda.

[linowp]

const int greenLEDPin = 9;
const int redLEDPin = 11;
const int blueLEDPin = 10;


const int redSensorPIN = A0;
const int greenSensorPIN = A1;
const int blueSensorPIN = A2;


int redValue = 0;
int greenValue = 0;
int blueValue = 0;


int redSensorValue = 0;
int greenSensorValue = 0;
int blueSensorValue = 0;


void setup() {
// put your setup code here, to run once:
Serial.begin(9600);


pinMode(greenLEDPin,OUTPUT);
pinMode(redLEDPin,OUTPUT);
pinMode(blueLEDPin,OUTPUT);
}


void loop() {
// put your main code here, to run repeatedly:
redSensorValue = analogRead(redSensorPIN);
delay(5);
greenSensorValue = analogRead(greenSensorPIN);
delay(5);
blueSensorValue = analogRead(blueSensorPIN);

redValue = redSensorValue/4;
greenValue = greenSensorValue/4;
blueValue = blueSensorValue/4;

analogWrite(redLEDPin, redValue);
analogWrite(greenLEDPin, greenValue);
analogWrite(blueLEDPin, blueValue);
}



con un codice del genere io non posso mai intervenire da java?

[linowp]

So che ti sto scoccia di parecchio,me ne rendo conto. In ogni caso potresti postarmi come aggiustare i codici da me postati e come scrivere il codice che prende in input quelle righe stampate?te ne sarei veramente grato

[andbin]

void loop() {
  // put your main code here, to run repeatedly:
  redSensorValue = analogRead(redSensorPIN);
  delay(5);
  greenSensorValue = analogRead(greenSensorPIN);
  delay(5);
  blueSensorValue = analogRead(blueSensorPIN);

  redValue = redSensorValue/4;
  greenValue = greenSensorValue/4;
  blueValue = blueSensorValue/4;

  analogWrite(redLEDPin, redValue);
  analogWrite(greenLEDPin, greenValue);
  analogWrite(blueLEDPin, blueValue);
}

con un codice del genere io non posso mai intervenire da java?

No, non puoi. Un PC o un qualunque dispositivo esterno ad Arduino, non saprebbe (e non può saperne) nulla di quelle variabili. Serve una periferica di comunicazione (seriale, Bluetooth, Ethernet/Wi-Fi o altro che sia usabile da Arduino E da PC) e serve anche un formato dei dati "ragionevole".

Se al fondo del loop() che ho quotato ci fosse:

  // ..... resto
  analogWrite(blueLEDPin, blueValue);
  
  Serial.print(F("Raw RGB:"));
  Serial.print(redSensorValue);
  Serial.print(F("/"));
  Serial.print(greenSensorValue);
  Serial.print(F("/"));
  Serial.print(blueSensorValue);
  Serial.print(F(";Mapped RGB:"));
  Serial.print(redValue);
  Serial.print(F("/"));
  Serial.print(greenValue);
  Serial.print(F("/"));
  Serial.println(blueValue);
}

(ho usato F() perché come dice la documentazione di Arduino: You can pass flash-memory based strings to Serial.print() by wrapping them with F(). Siccome quelle sono stringhe "fisse", le possiamo mettere nella Flash invece che in SRAM che è molto limitata)

Sarebbe MOLTO più sensato (oltre che compatto) perché avresti righe coerenti del tipo:

Raw RGB:XXX/XXX/XXX;Mapped RGB:XXX/XXX/XXX

(XXX un valore)

Sarebbe ancora intelleggibile per un "umano" ma anche facilmente parsabile programmaticamente.

potresti postarmi come aggiustare i codici da me postati e come scrivere il codice che prende in input quelle righe stampate?

Possibile lo è, come già detto prima. Ma con quel formato iniziale che avevi mostrato è più difficile. Perché nella riga hai informazioni scorrelate e quindi se vuoi avere raw+mapped correlati insieme dovresti decodificare la riga interpretando separatamente le due parti e poi tenere "memoria" dei "raw" precedenti per poi accoppiarli ai mapped successivi nella riga dopo.

Si fa .... non è che è impossibile ... ma è contorto. Non ho tempo ora ma se domani ho tempo posso provare a scrivere qualche riga, anche solo per darti una idea.

[linowp]

Ti ringrazio per questo primo aggiusto del codice in arduino!Comunque a me basterebbe gestire anche uno solo di quei sei valori della singola stringa (sono correlati...i primi tre valori mostrano come si divide la luce che arriva in intensità di rosso,blu e verde...i secondi tre valori sono dati dividendo i primi tre per 4).Io nel frattempo ho aggiustato il codice arduino come da te suggerito e te ne sarei grato se potresti anche suggerirmi qualche riga di codice per gestire i dati dalla stringa...ti ringrazio già per le info che mi hai dato!

[andbin]

Se l'output fornito da Arduino fosse come l'ho messo io nel precedente post, allora lato Java ecco un esempio di quello che puoi fare.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ProvaLinea {
    private static Pattern linePattern = Pattern.compile("Raw RGB:(\\d+)/(\\d+)/(\\d+);Mapped RGB:(\\d+)/(\\d+)/(\\d+)");

    public static void main(String[] args) {
        String linea = "Raw RGB:919/913/881;Mapped RGB:229/228/220";

        Matcher matcher = linePattern.matcher(linea);
        if (matcher.matches()) {
            int rawRed = Integer.parseInt(matcher.group(1));
            int rawGreen = Integer.parseInt(matcher.group(2));
            int rawBlue = Integer.parseInt(matcher.group(3));
            int mappedRed = Integer.parseInt(matcher.group(4));
            int mappedGreen = Integer.parseInt(matcher.group(5));
            int mappedBlue = Integer.parseInt(matcher.group(6));

            // ......
        } else {
            // la linea è "malformata", è un errore ......
        }
    }
}

Chiaramente è solo un esempio con una stringa specifica, dovrai adattarlo. La regular expression viene compilata una volta sola in quel linePattern che vedi.

Da una linea che ricevi, si crea il Matcher e se matches() dà true, vuol dire che la linea ha esattamente quel formato. Il che non è male perché hai anche una sorta di "validazione" completa del formato della linea.
A quel punto matches() ha estratto i vari "gruppi" (nella regex sono quelli tra ( ) che racchiudono la sequenza di cifre decimali) come stringhe, che vanno parsate per ottenere degli int. Quindi con gli int fai quello che vuoi.

Ripeto, questo è solo un esempio costruito al volo su un caso di linea specifica.