Wenn Werte vom Arduino abgerufen werden sollen muß zuerst der richtige COM Port ausgewählt werden und dann kann sich Processing damit verbinden. Für die Abfrage der Werte wird eine kurze Anfrage gesendet und der Arduino gibt den entsprechenden String zurück. Dieser wird in Processing eingelesen und dargestellt.

Hier werden als Beispiel 3 mögliche Strings ausgegeben:
1. Anfrage: n Antwort: Name des Geräts
2. Anfrage: s Antwort: Software Version
3. Anfrage: v Antwort: USB Spannung

Die USB Spannung wird ermittelt wie hier beschrieben. Dazu ist nur eine Brücke vom 3,3V Pin zum A0 Eingang notwendig.

Hier das Arduino Programm

// Arduino USB-Spannung an Processing ausgeben
//
// Matthias Busse 21.3.2017 Version 1.0
 
char wert; // Daten von der seriellen Schnittstelle
float vcc;
 
void setup() {
  Serial.begin(38400); // Baudrate
}
 
void loop() {
  vcc = 3.30 / analogRead(0) * 1023;
  while (Serial.available()) {       // Wenn serielle Daten kommen, dann lesen
    wert = Serial.read();            // Daten in wert speichern
    if (wert== 'n') {                // n: Name ausgeben
      Serial.println("USB Spannung messen");
    }
    if (wert== 's') {                // s: Software Version ausgeben
      Serial.println("Version 1.0");
    }
    if (wert== 'v') {                // v: Spannung ausgeben
      Serial.print(vcc);
      Serial.println(" V");
    }
  }
}

In Processing wird dann folgendes gemacht
Eine COM Port Auswahl mit einfachen Pfeiltasten. Dann kann man sich mit dem COM Port verbinden, die Verbindung wieder trennen oder die Liste der COM Ports neu einlesen. Der aktuelle Status wird im Feld darunter ausgegeben. Dazu wird eine einfache Button Klasse verwendet.

Dann werden die 3 Anfragen nacheinander an den Arduino gesendet und die Antworten im rechten Fenster ausgegeben.

Hier das Processing 3.3 Programm

// COM Schnittstellen Auswahl in der Processing Software und anfragen der USB Spannung vom Arduino.
//
// Die COM Port Listen Auswahl stammt von hier:
// https://startingelectronics.org/software/processing/serial-port-select/
// hoch / runter: wählt den COM Port aus
// verbinden / trennen: belegt den Port und gibt ihn wieder frei
// neu lesen: liest die COM Port Liste neu ein
//
// Immer erst trennen und dann das Programm schliessen oder neu übersetzten
// Wenn sich die COM Ports nicht mehr verbinden lassen weil man zu viel rungespielt hat ;-)
// 1. Processing schliessen und neu starten
// 2. Rechner neu starten
//
// Hardware: Arduino mit einer Drahtbrücke von 3,3V zu A0
//
// Matthias Busse 21.3.2017 Version 1.0                

import processing.serial.*;
Serial serial_port = null;        // die serielle Schnittstelle

Button btn_serial_hoch; // 5 Buttons definieren
Button btn_serial_runter;
Button btn_serial_verbinden;
Button btn_serial_trennen;
Button btn_serial_lesen;
String serial_list; // Liste der seriellen Ports
String wert; // Rückgabewerte
int serial_list_index = 0; // aktuell gewählter Port 
int num_serial_ports = 0; // Anzahl der Ports
int test=0; // Statuszeilen Ausgabe 1-Ja 0-Nein

void setup() {
  size (608, 135); // Fenstergröße
  btn_serial_hoch = new Button("^", 140, 10, 40, 20); // Buttons erstellen
  btn_serial_runter = new Button("v", 140, 50, 40, 20);
  btn_serial_verbinden = new Button("verbinden", 190, 10, 100, 25);
  btn_serial_trennen = new Button("tennen", 190, 45, 100, 25);
  btn_serial_lesen = new Button("neu lesen", 190, 80, 100, 25);
  serial_list = Serial.list()[serial_list_index]; // Liste der COM Ports
  if(test==1) {
    println(Serial.list());
    println(Serial.list().length);
  }
  num_serial_ports = Serial.list().length; // Anzahl der Ports
  surface.setTitle("USB Spannung vom Arduino auslesen.");
}

void mousePressed() {
  if (btn_serial_hoch.MouseIsOver()) { // hoch Button
    if (serial_list_index > 0) {
      serial_list_index--; // Liste nach oben bewegen
      serial_list = Serial.list()[serial_list_index];
    }
  }
  if (btn_serial_runter.MouseIsOver()) { // runter Button
    if (serial_list_index < (num_serial_ports - 1)) {
      serial_list_index++; // Liste nach unten
      serial_list = Serial.list()[serial_list_index];
    }
  }
  if (btn_serial_verbinden.MouseIsOver()) { // verbinden Button
    if (serial_port == null) {
      serial_port = new Serial(this, Serial.list()[serial_list_index], 38400); // verbinden mit dem gewählten Port
    }
  }
  if (btn_serial_trennen.MouseIsOver()) { // Trennen Button
    if (serial_port != null) {
      serial_port.stop(); // Port trennen
      serial_port = null;
    }
  }
  if (btn_serial_lesen.MouseIsOver()) { // lesen Button
    serial_list = Serial.list()[serial_list_index]; // Liste neu ein lesen
    num_serial_ports = Serial.list().length;
  }
}

void draw() {
  fill(255); // weißer Hintergrund
  rect(2,2,300,130); // weißes COM Hintergrund Feld
  rect(305,2,300,130); // weißes Ausgabefeld
  btn_serial_hoch.Draw(); // Buttons zeichen
  btn_serial_runter.Draw();
  btn_serial_verbinden.Draw();
  btn_serial_trennen.Draw();
  btn_serial_lesen.Draw();
  DrawTextBox("COM waehlen", serial_list, 10, 10, 120, 60); // Testbox zeichen
  DrawStatusBox();
}

void DrawStatusBox() { // den aktuellen Status ausgeben
  fill(255); // Box weiß
  rect(10, 100, 120, 20);
  fill(0); // Text schwarz
  textSize(14);
  text("Status:", 15, 80, 110, 20);
  if(serial_port == null) {
    text("getrennt", 15, 100, 110, 20);
  } 
  else {
    text(serial_list, 15, 100, 110, 20); // Schnittstelle eintragen
    DrawOutputBox(); // Ausgaben anfragen
  }
}

void DrawOutputBox() {
// Daten vom Arduino anfragen und ausgeben 
  delay(100); // warten bis die Verbindung hergestellt ist
  if(serial_port != null) {
    if(test==1) println("Port vorhanden");
    fill(0);
    text("Ausgaben vom Arduino", 312,10,200,20);
    text("Name", 312,40,70,20);
    text("Software", 312,70,70,20);
    text("Spannung", 312,100,70,20);
    serial_port.write('n'); // Namen anfragen
    DrawResultBox(390,40);
    serial_port.write('s'); // Software Version anfragen
    DrawResultBox(390,70);
    serial_port.write('v'); // Spannung anfragen
    DrawResultBox(390,100);
    delay(500); // warten bis zu nächsten Anfrage
  }
}

void DrawResultBox(int x0, int y0) {
  delay(100); // nach der Anfrage etwas warten bis die Antwort vorliegt
  if(test==1) println(serial_port.available());
  while ( serial_port.available() > 0) {
    wert = serial_port.readStringUntil('\n'); // Antwort einlesen
    if(test==1) println(wert);
    fill(255); // Feld weiß zeichen
    rect(x0, y0, 205, 20);
    fill(0); // Text schwarz ausgeben
    text(wert, x0+5, y0, 195, 20);
  }
}

void DrawTextBox(String title, String str, int x, int y, int w, int h) {
// Die Com Port Listen Box mit Überschrift und Inhalt ausgeben
  fill(255); // weiß
  rect(x, y, w, h);
  fill(0); // schwarz
  textAlign(LEFT);
  textSize(14);
  text(title, x + 10, y + 10, w - 20, 20);
  fill(255,0,0); // rot
  textSize(12);  
  text(str, x + 10, y + 40, w - 20, h - 10);
  fill(255); // schwarz
}

class Button { // Button class definieren
  String label;
  float x;    // oben links x
  float y;    // oben links y
  float w;    // Breite
  float h;    // Höhe
  Button(String labelB, float xpos, float ypos, float widthB, float heightB) { // constructor
    label = labelB;
    x = xpos;
    y = ypos;
    w = widthB;
    h = heightB;
  }
  void Draw() { // Button zeichen
    fill(218);
    stroke(141);
    rect(x, y, w, h, 10);
    textAlign(CENTER, CENTER);
    fill(0);
    text(label, x + (w / 2), y + (h / 2));
  }
  boolean MouseIsOver() { // Rückgabe true wenn Maus über dem Button ist
    if (mouseX > x && mouseX < (x + w) && mouseY > y && mouseY < (y + h)) {
      return true;
    }
    return false;
  }
}

Das Ausgabe Fenster von Processing unter Windows sieht dann so aus.

Damit kann fortlaufend die USB Spannung vom Arduino überwacht werden.

Das sollte nicht nur unter Windows 32 / 64 Bit laufen, sondern auch unter MAC, Linux und neuerdings sogar auf den Pi.

Verwendet wurde:
Arduino SW 1.8.0
Processing 3.3
Arduino Uno
Drahtbrücke
Windows Rechner

von Matthias Busse