`//Imports
import processing.serial.*;
import controlP5.*;
import java.util.*;

//Variable Declarations
ControlP5 lstPortList;
ControlP5 lstBaud;
String tport;
int tbaud;
Serial myPort;      // The serial port
int whichKey = -1;  // Variable to hold keystoke values
int inByte = -1;    // Incoming serial data
int Indexport =0;
int Indexbaud =1;

///Setup/////
void setup() {
  size(400, 400);
  // create a font with the third font available to the system:
  PFont myFont = createFont(PFont.list()[2], 14);
  textFont(myFont);

  // List all the available serial ports:
  // printArray(Serial.list());

  lstPortList = new ControlP5(this);
  String[] portNames =Serial.list();
  lstPortList.addScrollableList("Port")
    .setPosition(10, 10)
      .setSize(100, 100)
        .setBarHeight(20)
          .setItemHeight(20)
            .addItems(portNames)
              .setFont(createFont("Arial", 13))
                .setColorForeground(color(40, 128))
                  .setValue(Indexport);

  lstBaud = new ControlP5(this);
  List BaudList = Arrays.asList("4800", "9600", "19200", "38400", "57600", "115200");
  lstBaud.addScrollableList("Baud")
    .setPosition(200, 10)
      .setSize(100, 100)
        .setBarHeight(20)
          .setItemHeight(20)
            .addItems(BaudList)
              .setFont(createFont("Arial", 13))
                .setColorForeground(color(40, 128))
                  .setValue(Indexbaud);
  tport= port(Indexport);//lstPortList.get(ScrollableList.class, "port").getItem(Indexport).get("text");
  tbaud= baud(Indexbaud); //lstBaud.get(ScrollableList.class, "port").getItem(Indexbaud).get("text");
  myPort = new Serial(this, tport, tbaud );
}

void draw() { 

  background(0);
  text("Last Received: " + inByte, 10, 130);
  text("Last Sent: " + whichKey, 10, 100);
}

void serialEvent(Serial myPort) {
  inByte = myPort.read();
}

void keyPressed() {
  // Send the keystroke out:
  myPort.write(key);
  whichKey = key;
}

String port(int n) {
  return lstPortList.get(ScrollableList.class, "Port").getItem(n).get("text");  
}
int baud(int n) {
  return lstBaud.get(ScrollableList.class, "Baud").getItem(n).get("text");  
}`

Thanks

import java.awt.Robot;
import java.awt.AWTException;
Robot robby;
void setup()
{

//robot setup
   try
    {
      robby = new Robot();
    }
    catch (AWTException e)
    {
      println("Robot class not supported by your system!");
      exit();      
    }
  robby.mouseMove(screenResX/2, screenResY/2); //test line to move cursor
}

Error, disabling serialEvent() for COM17 null

I cant figure out how to resolve this intermittency... hope you can help

the relevant part of the processing sketch:

void setup()
{
  size(displayWidth, displayHeight);
  smooth();
 setSerialPort("COM17");

  //robot setup
  try
  {
    robby = new Robot();
  }
  catch (AWTException e)
  {
    println("Robot class not supported by your system!");
    exit();
  }
  robby.mouseMove(screenResX/2, screenResY/2); //test line to move cursor
}

void serialEvent(Serial p) 
{
  String incoming = p.readString();
  if (printSerial) {
    //println(incoming);
  }

  if ((incoming.length() > 8))
  {
    String[] list = split(incoming, " ");
    if ( (list.length > 0) && (list[0].equals("Orientation:")) ) 
    {
      leftClick = float(list[5]);
      rightClick = float(list[4]);
      roll  = float(list[3]); 
      pitch = float(list[2]); // Pitch = Y 
      yaw   = float(list[1]); // yawLeftRight
    }
  }
}

// Set serial port to desired value.
void setSerialPort(String portName) {
  // Close the port if it's currently open.
  if (port != null) {
    port.stop();
  }
  try {
    // Open port.
    port = new Serial(this, portName, 115200);
    port.bufferUntil('\n');
    // Persist port in configuration.
    saveStrings(serialConfigFile, new String[] { portName });
  }
  catch (RuntimeException ex) {
    // Swallow error if port can't be opened, keep port closed.
    port = null;
  }
}

HERE IS THE FULL ARDUINO CODE:

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>

/** 
   History
   =======
   2015/MAR/03  - First release (KTOWN)
*/

/** Set the delay between fresh samples */
#define BNO055_SAMPLERATE_DELAY_MS (100)

Adafruit_BNO055 bno = Adafruit_BNO055(55);


void displaySensorDetails(void)
{
  sensor_t sensor;
  bno.getSensor(&sensor);
  Serial.println("------------------------------------");
  Serial.print  ("Sensor:       "); Serial.println(sensor.name);
  Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
  Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
  Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" xxx");
  Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" xxx");
  Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" xxx");
  Serial.println("------------------------------------");
  Serial.println("");
  delay(500);
}

void setup(void)
{
  Serial.begin(115200);
  pinMode(5, INPUT_PULLUP);
  pinMode(6, INPUT_PULLUP);

  /** Initialise the sensor */
  if(!bno.begin())
  {
    /** There was a problem detecting the BNO055 ... check your connections */
    Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }

  delay(1000);

  /** Use external crystal for better accuracy */
  bno.setExtCrystalUse(true);
}


void loop(void)
{
  int rightClick = digitalRead(6);
  int leftClick = digitalRead(5);
  /** Get a new sensor event */
  sensors_event_t event;
  bno.getEvent(&event);

  /** The processing sketch expects data as roll, pitch, heading */
  Serial.print(F("Orientation: "));
  Serial.print((float)event.orientation.x);
  Serial.print(F(" "));
  Serial.print((float)event.orientation.y);
  Serial.print(F(" "));
  Serial.print((float)event.orientation.z);
  Serial.print(F(" "));

  Serial.print((float)rightClick);
  Serial.print(F(" "));
  Serial.print((float)leftClick);
  Serial.println(F(""));

  delay(BNO055_SAMPLERATE_DELAY_MS);
}

What part of the code is incompatible / what has to be changed to make it work?

Thanks!

    /******************************************************************************
    Heart_Rate_Display.ino
    Demo Program for AD8232 Heart Rate sensor.
    Casey Kuhns @ SparkFun Electronics
    6/27/2014
    https://github.com/sparkfun/AD8232_Heart_Rate_Monitor

    The AD8232 Heart Rate sensor is a low cost EKG/ECG sensor.  This example shows
    how to create an ECG with real time display.  The display is using Processing.
    This sketch is based heavily on the Graphing Tutorial provided in the Arduino
    IDE. http://www.arduino.cc/en/Tutorial/Graph

    Resources:
    This program requires a Processing sketch to view the data in real time.

    Development environment specifics:
        IDE: Arduino 1.0.5
        Hardware Platform: Arduino Pro 3.3V/8MHz
        AD8232 Heart Monitor Version: 1.0

    This code is beerware. If you see me (or any other SparkFun employee) at the
    local pub, and you've found our code helpful, please buy us a round!

    Distributed as-is; no warranty is given.
    ******************************************************************************/

    import processing.serial.*;

    Serial myPort;        // The serial port
    int xPos = 1;         // horizontal position of the graph
    float height_old = 0;
    float height_new = 0;
    float inByte = 0;


    void setup () {
      // set the window size:
      size(1000, 400);        

      // List all the available serial ports
      println(Serial.list());
      // Open whatever port is the one you're using.
      myPort = new Serial(this, Serial.list()[2], 9600);
      // don't generate a serialEvent() unless you get a newline character:
      myPort.bufferUntil('\n');
      // set inital background:
      background(0xff);
    }


    void draw () {
      // everything happens in the serialEvent()
    }


    void serialEvent (Serial myPort) {
      // get the ASCII string:
      String inString = myPort.readStringUntil('\n');

      if (inString != null) {
        // trim off any whitespace:
        inString = trim(inString);

        // If leads off detection is true notify with blue line
        if (inString.equals("!")) { 
          stroke(0, 0, 0xff); //Set stroke to blue ( R, G, B)
          inByte = 512;  // middle of the ADC range (Flat Line)
        }
        // If the data is good let it through
        else {
          stroke(0xff, 0, 0); //Set stroke to red ( R, G, B)
          inByte = float(inString); 
         }

         //Map and draw the line for new data point
         inByte = map(inByte, 0, 1023, 0, height);
         height_new = height - inByte; 
         line(xPos - 1, height_old, xPos, height_new);
         height_old = height_new;

          // at the edge of the screen, go back to the beginning:
          if (xPos >= width) {
            xPos = 0;
            background(0xff);
          } 
          else {
            // increment the horizontal position:
            xPos++;
          }

      }
    }

Using a string of values coming in via serial, how can I tell processing to use these consider each number as the value for a pixel in order to create a black & white image?

Here's the code that I have so far... any suggestions/examples would be great!

PImage img;

import processing.serial.Serial;

static final int PORT_INDEX = 0, BAUDS = 9600;
String myString;

void setup() {
  noLoop();
  final String[] ports = Serial.list();
  printArray(ports);
  new Serial(this, ports[3], BAUDS).bufferUntil(ENTER);
}



void draw() {
  // show values coming in via Serial
  // e.g.: 0,0,0,0,0,0,0,0,0,0,255,255,255,255,255...
  //print("Received data: ");
  println(myString);


  // Use the values from serial to build a BLACK & WHITE image
  // image has a size of 20x20 pixels
  // pixel values --> 0 represents black; 255 represents white
  PImage img = createImage(20, 20, ALPHA);      // create a "placeholder" with the correct size
  img.loadPixels();

  // fill the placeholder with white pixels
  for (int i = 0; i < img.pixels.length; i++) {
    img.pixels[i] = color(255);
  }
  img.updatePixels();
  image(img, 17, 17);


  // use values from myString to populate the image pixels
  //  ????

}



void serialEvent(final Serial s) {
  myString = s.readString().trim();
  redraw = true;
}

I was wondering If there's a way for processing to count signal position and display a calculated minute average of signals. For example 25 signals in 10 seconds multiplied by 6 to get signals per minute.

Example signal would be

The processing code i'm using is taken from an example about a heartrate sensor.

How would I go about making the code detect a signal like this and count it once it goes over a certain treshold?

import processing.serial.*;

Serial myPort; // The serial port
int xPos = 1; // horizontal position of the graph
float oldHeartrateHeight = 0; // for storing the previous reading

void setup () {
  // set the window size:
  size(600, 400);
  frameRate(25);

  // List available serial ports.
  println(Serial.list());

  // Setup which serial port to use.
  // This line might change for different computers.
  myPort = new Serial(this, Serial.list()[1], 9600);

  // set inital background:
  background(0);
}

void draw () {
}

void serialEvent (Serial myPort) {
  // read the string from the serial port.
  String inString = myPort.readStringUntil('\n');

  if (inString != null) {
    // trim off any whitespace:
    inString = trim(inString);
    // convert to an int
    println(inString);
    int currentHeartrate = int(inString);

    // draw the Heartrate BPM Graph.
    float heartrateHeight = map(currentHeartrate, 0, 1023, 0, height);
    stroke(0,255,0);
    line(xPos - 1, height - oldHeartrateHeight, xPos, height - heartrateHeight);
    oldHeartrateHeight = heartrateHeight;
    // at the edge of the screen, go back to the beginning:
    if (xPos >= width) {
      xPos = 0;
      background(0);
    } else {
      // increment the horizontal position:
      xPos++;
    }
  }
}

Processing code...

PFont jpFont, ebFont; 
int iLED=0, iCount=0, iData=0; 
import processing.serial.*; 
Serial rrSerial;

void setup()
{
  size(1000,500); 
  jpFont=loadFont("Tahoma-48.vlw"); 
  ebFont=loadFont("Tahoma-Bold-48.vlw"); 
  println(Serial.list()[2]);
  rrSerial=new Serial(this, Serial.list()[2],9600);
  rrSerial.write(0x83);
}

void draw()
{
   background(100);

   fill(255,0,0); 
   stroke(0); 
   strokeWeight(10); 
   ellipse(width/2-350,height/2+100,200,200); 

   fill(0,255,0); 
   stroke(0); 
   strokeWeight(10); 
   ellipse(width/2-125,height/2+100,200,200); 

   fill(0,0,255); 
   stroke(0); 
   strokeWeight(10); 
   ellipse(width/2+100,height/2+100,200,200); 

   fill(247,142,12); 
   stroke(0); 
   strokeWeight(10); 
   ellipse(width/2+325,height/2+100,200,200);  

   if(iLED==1) 
   {
     textFont(ebFont); 
     textSize(75); 
     fill(#F7F70C); 
     text(""+iCount,125,375); 
   }

   if(iLED==2) 
   {
     textFont(ebFont); 
     textSize(75);
     fill(#F7F70C); 
     text(""+iCount,350,375);  
   }

  if(iLED==3) 
  {
     textFont(ebFont); 
     textSize(75); 
     fill(#F7F70C); 
     text(""+iCount,575,375); 
  } 

   if(iLED==4) 
   {
     textFont(ebFont); 
     textSize(75); 
     fill(#F7F70C); 
     text(""+iCount,800,375); 
   }

   iData=iLED<<4|iCount&0x0F; 
}

void keyPressed()
{
   if(keyCode==RIGHT&&iLED<5) 
   {
     iLED++; 
     iCount=0; 
     if(iLED==5)iLED=0; 
   }

   if(keyCode==LEFT&&iLED>0) 
   {
     iLED--; 
     iCount=0; 
     if(iLED==0)iLED=5; 
   }

   if(keyCode==UP&&iCount<10) 
   {
     iCount++; 
     if(iCount==10)iCount=0;      
   }

   if(keyCode==DOWN&&iCount>-1) 
   {
     iCount--; 
     if(iCount==-1)iCount=9; 
   }

   if(key==ENTER)rrSerial.write(iData); 

   if(key=='q')exit(); 
}

Now Arduino...

boolean bToggle=0;
int iButton;

void setup() 
{
  Serial.begin(9600); 
  pinMode(3,OUTPUT); 
  pinMode(5,OUTPUT); 
  pinMode(9,OUTPUT); 
  pinMode(11,INPUT); 
  digitalWrite(3,LOW); 
  digitalWrite(5,LOW); 
  digitalWrite(9,LOW); 
  digitalWrite(11,HIGH); 
}

void loop() 
{
  if(Serial.available()>0)
  {
    int iInput=Serial.read(); 
    int iWhich_Led=iInput>>4;
    int iFlash_Count=iInput&0x0f;

    if(iWhich_Led==1)LED_burst(3,iFlash_Count); 

    if(iWhich_Led==2)LED_burst(5,iFlash_Count); 

    if(iWhich_Led==3)LED_burst(9,iFlash_Count); 

    if(iWhich_Led==4)LED_sequence(iFlash_Count); 
  }

  iButton=digitalRead(11); 

  if(iButton==0) 
  {
    while(digitalRead(11)==0); 
    bToggle=!bToggle; 
  }

  if(bToggle==1) 
  {
    digitalWrite(3,LOW); 
    digitalWrite(5,LOW); 
    digitalWrite(9,LOW); 
  }
}

void LED_burst(int iLED,int iCount) 
{
  for(int iX=0;iX<iCount;iX++) 
  {
    digitalWrite(iLED,HIGH); 
    delay(100); 
    digitalWrite(iLED,LOW); 
    delay(100);
  }
}

void LED_sequence(int iCountx) 
{
  for(int iY=0;iY<iCountx;iY++)
  {
    digitalWrite(3,HIGH); 
    delay(50); 
    digitalWrite(3,LOW); 
    delay(50); 
    digitalWrite(5,HIGH); 
    delay(50); 
    digitalWrite(5,LOW); 
    delay(50); 
    digitalWrite(9,HIGH); 
    delay(50); 
    digitalWrite(9,LOW); 
    delay(50); 
  }
}

i can't use the example in the reference since it uses an immage. Really i tried to use it but without good results. any idea? maybe i miss a library that could help me?

`import processing.serial.*; //Importing serial library import ddf.minim.*; //Importing minim library. Minim is the library we are using for sound-related activities, such as record and playback.

Serial myPort;

Minim minim;

AudioPlayer song; AudioPlayer song2; AudioPlayer song3;

AudioInput in; AudioRecorder recorder;

int countname; //change the name int name = 000000; int startGain = 0;

void newFile() {
countname = (name + 1); recorder = minim.createRecorder(in, "Rec" + countname + ".wav", true); }

void setup() { size(120, 120);

//println(Serial.list()); myPort = new Serial(this, Serial.list()[0], 9600); myPort.bufferUntil('\n');

minim = new Minim(this);

in = minim.getLineIn(Minim.STEREO, 2048); newFile();//go to change file name

song = minim.loadFile("beyonce.mp3"); song2 = minim.loadFile("dajam.wav"); song3 = minim.loadFile("Rec1.wav"); }

void draw() { background(0); stroke(255);

if ( recorder.isRecording() ) { text("Currently recording...", 5, 15); ellipse(60,60,55,55); fill(255,0,0); } else { text(" Not recording.", 5, 15); ellipse(60,60,55,55); fill(0,255,0); } }

void serialEvent (Serial myPort) { String inString = myPort.readStringUntil('\n');

if (inString != null) { inString = trim (inString);

float inByte = float(inString); 
println(inByte);

if (inByte == 1){
  song.loop();
  song2.loop();
  song3.loop();
  song.rewind();
  song2.rewind();
  song3.rewind();
}

if (inByte == 0){
  song.pause();
  song2.pause();
  song3.pause();
  song.rewind();
  song2.rewind();
  song3.rewind();
}

if (inByte == 2){ if ( recorder.isRecording() ) {
recorder.endRecord();

  name++; 
  recorder.save();
  println("Done saving.");
  println(name);
  }
  else 
  {
  newFile();
  recorder.beginRecord();
  }
}

if (inByte == 3){ song.setGain(startGain++ * 2); song2.setGain(startGain++ * 2); song3.setGain(startGain++ * 2); }

if (inByte == 4){
 song.setGain(startGain-- * 2);
 song2.setGain(startGain-- * 2);
 song3.setGain(startGain-- * 2);
}

} }

void stop() { // always close Minim audio classes when you are done with them in.close(); minim.stop();

super.stop(); }`

I've used it before to trigger sounds. Which was fine triggering them within method where the bytes are read.

I am trying to make it now spin an arrow.

I have setup a function for 'spinning an arrow' which I then can use in 'draw', however, I don't know how to make a statement saying inByte read in 'void serialEvent(Serial myPort)' should trigger 'spin();' in 'void draw()'. Hope it makes sense and please please help me.

import processing.serial.*;
import ddf.minim.*;
Minim minim;
AudioPlayer player;
int loopcount;

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
  minim = new Minim(this);



  printArray(Serial.list());


  String portName = Serial.list()[0];
  //myPort = new Serial(this, "/dev/cu.usbmodem1510721", 9600);
  myPort = new Serial(this, "/dev/cu.HC-05-DevB", 9600);
}

void draw() {
  background(bgcolor);
  fill(fgcolor);
  // Draw the shape
}

void serialEvent(Serial myPort) {

  int inByte = myPort.read();

  if (firstContact == false) {
    if (inByte == 'A') { 
      player = minim.loadFile("drumgroove_3.wav");
       player.loop();
      // ask for more
    }

    if (inByte == 'F'){
      player = minim.loadFile("sound_7.mp3");
 player.play();
  }

     if(inByte == 'B'){
player = minim.loadFile("sound_2.mp3");
player.play();
}
    if (inByte == 'C'){
      player = minim.loadFile("sound_6_converted.wav");
      player.loop(2);
      loopcount = 3;
    }

    if (inByte == 'D'){
      player = minim.loadFile("sound_4.mp3");
      player.play();
    }

    if (inByte == 'E'){
      player = minim.loadFile("sound_5.mp3");
      player.play();
    }


}
}

In arduino i send a single byte using Serial.write(); In processing I receive using Serial.read();

Problems:

1) looks like that i have a problem of comunication because i reveice much more bytes than i wait. Baudrate is the same and the port is correct.

2) There must be something that i miss because i am forced to use an int to store the value of Serial.read(), why can't i use a byte?

3) i have also problems in working on this byte using the normal | & and ^ operations, same problem as point 2, why am i fprced to use an int to use them? Them are bitwise operations and i would like to use bytes not int!

4) how can i use directly binary data? For example in arduino i use 'B101010' but here seems that i can use only hex

Here is our processing code:

import processing.serial.*;
//import cc.arduino.*;
//println(Arduino.list());
 String val;
Serial myPort;

float Distance1 = 0, Distance2 = 0;
float LocationX=0; // Assumed location of an object (X,Y)
float LocationY=0;
float SRF1_x=300;  // location of SRF1 (x,y)
float SRF1_y=100;
float SRF2_x=500;  // location of SRF2 (x,y)
float SRF2_y=100;
float AngularRes=PI/180*10; //   Angle change step size
int xPos = 1;      // horizontal position of the graph

void setup()
{
  size(1000, 700);
  String portName = Serial.list()[0]; //change the 0 to a 1 or 2 etc. to match your port
myPort = new Serial(this, portName, 9600); 
  background(200);
  smooth();
  myPort.bufferUntil('\n');
  DrawGrid();
}

void draw()
{
      if( myPort.available() > 0) 
      {  // If data is available,
        val = myPort.readStringUntil('\n');  
      }
  println(val);
     FindLocation();
//     background(300, 300, 300);
     fill(300);
     ellipse(SRF1_x,SRF1_y,25,25); // location of SRF1
     fill(100);
     ellipse(SRF2_x,SRF2_y,25,25); // location of SRF2
     fill(400);
     ellipse(LocationX,LocationY,10,10); // actual location of an object


}

void serialEvent(Serial myPort)
{
  String str = myPort.readStringUntil('\n');
  if (str != null )
  {
      str = trim(str); //remove whitespace around our values
      float  DistanceArr[]=float (split(str, ','));
      Distance1= map( DistanceArr[0], 0, 540, 0, 3000); // map distance of SRF1 to another range
      Distance2= map( DistanceArr[1], 0, 540, 0, 3000); // map distance of SRF2 to another range
  }
}

void FindLocation(){
     float MinimumDist = 50000;
     float x_CL_SRF1, y_CL_SRF1, x_CL_SRF2, y_CL_SRF2,Cal_MinimumDist; // x-y coordinates along two circles
     for (float theta1 = 0; theta1 < PI; theta1 = theta1+AngularRes) {
         x_CL_SRF1=SRF1_x +Distance1*cos(theta1);   // get x-y coordinates along circle for SRF1
         y_CL_SRF1=SRF1_y +Distance1*sin(theta1);
         ellipse(x_CL_SRF1,y_CL_SRF1,10,10);
         for (float theta2 = 0; theta2 < PI; theta2 = theta2+AngularRes) {
              x_CL_SRF2=SRF2_x +Distance2*cos(theta2);  // get x-y coordinates along circle for SRF2
              y_CL_SRF2=SRF2_y +Distance2*sin(theta2);
              ellipse(x_CL_SRF2,y_CL_SRF2,10,10);
              Cal_MinimumDist=sqrt(sq(x_CL_SRF1- x_CL_SRF2)+sq(y_CL_SRF1- y_CL_SRF2));
              if (Cal_MinimumDist<MinimumDist){
                  MinimumDist=Cal_MinimumDist;
                  LocationX=x_CL_SRF1;
                  LocationY=y_CL_SRF1;
               }

         }
    }     
}

void DrawGrid() {
    for (int i = 0; i < 700; i = i+100) {
        line(0, i, 990, i);
        }

        for (int i = 0; i < 1000; i = i+100) {
             line(i, 0, i, 690 );
        }
}

Here is the arduino code: /* * * rosserial srf02 Ultrasonic Ranger Example * * This example is calibrated for the srf02 Ultrasonic Ranger. * * By Poh Hou Shun 24 September 2015 */

//#include <Sonar_srf02.h> //srf02 specific library
#include <Wire.h>
//#include <ros.h>
//#include <std_msgs/Float32.h>


//Set up the ros node and publisher
//std_msgs::Float32 sonar_msg;
//ros::Publisher pub_sonar("sonar", &sonar_msg);
//ros::NodeHandle nh;

//Sonar_srf02 MySonar; //create MySonar object

#define COMMANDREGISTER 0x00
#define RESULTREGISTER  0x02

#define CENTIMETERS 0x51
// use 0x50 for inches
// use 0x51 for centimeters
// use 0x52 for ping microseconds

#define NO_OF_SENSORS 2

int SEQUENCE[] = {115, 116};

int reading = 0;
String stringData;

void setup()
{

  Wire.begin();                // join i2c bus (address optional for master)
  Serial.begin(9600);          // start serial communication at 9600bps

  //nh.initNode();
  //nh.advertise(pub_sonar);

}


long publisher_timer;

void loop()
{

  if (millis() > publisher_timer || 1) {

    for (int i = 0; i < NO_OF_SENSORS; i++) {
      takeData(SEQUENCE[i]);
    }

    // step 2: wait for readings to happen
    delay(70);                   // datasheet suggests at least 65 milliseconds

    readData(SEQUENCE[0]);

    stringData = String(reading);
    Serial.print(reading);

    for (int i = 1; i < NO_OF_SENSORS; i++) {
      readData(SEQUENCE[i]);
      stringData = ' ' + String(reading);
      Serial.print(' ');
      Serial.print(reading);    
    }

    //stringData = stringData + '\0';

    //sonar_msg.data = stringData;
    //pub_sonar.publish(&sonar_msg);

    publisher_timer = millis() + 4000; //publish once a second
    //Serial.println(sensorReading);
    Serial.println('\0');

  }

  //Serial.println(stringData);   // print the reading
  //nh.spinOnce();

}

void takeData(int address) {

  // step 1: instruct sensor to read echoes
  Wire.beginTransmission(address); // transmit to device #112 (0x70)

  // the address specified in the datasheet is 224 (0xE0)
  // but i2c adressing uses the high 7 bits so it's 112
  Wire.write(byte(COMMANDREGISTER));      // sets register pointer to the command register (0x00)
  Wire.write(byte(CENTIMETERS));      // command sensor to measure in "centimeters" (0x51)

  Wire.endTransmission();      // stop transmitting

}

void readData(int address) {

  // step 3: instruct sensor to return a particular echo reading
  Wire.beginTransmission(address); // transmit to device #112
  Wire.write(byte(RESULTREGISTER));      // sets register pointer to echo #1 register (0x02)
  Wire.endTransmission();      // stop transmitting

  // step 4: request reading from sensor
  Wire.requestFrom(address, 2);    // request 2 bytes from slave device #112

  // step 5: receive reading from sensor
  if (2 <= Wire.available()) { // if two bytes were received
    reading = Wire.read();  // receive high byte (overwrites previous reading)
    reading = reading << 8;    // shift high byte to be high 8 bits
    reading |= Wire.read(); // receive low byte as lower 8 bits
  }

  delay(250);
  //Serial.println(reading);

}

The code looks like this:

// Based on examples from Arduino's Graphing Tutorial and OscP5 documentation import processing.serial.*; Serial myPort; // The serial port int xPos = 1; // horizontal position of the graph float oldHeartrateHeight = 0; // for storing the previous reading

void setup () {
// set the window size:
size(600, 400);
frameRate(25);

// List available serial ports.
println(Serial.list());

// Setup which serial port to use.
// This line might change for different computers.
myPort = new Serial(this, Serial.list()[1], 9600);

// set inital background:
background(0);
}

void draw () {
}

void serialEvent (Serial myPort) {
// read the string from the serial port.
String inString = myPort.readStringUntil('\n');

if (inString != null) {
// trim off any whitespace:
inString = trim(inString);
// convert to an int
println(inString);
int currentHeartrate = int(inString);

// draw the Heartrate BPM Graph.
float heartrateHeight = map(currentHeartrate, 0, 1023, 0, height);
stroke(0,255,0);
line(xPos - 1, height - oldHeartrateHeight, xPos, height - heartrateHeight);
oldHeartrateHeight = heartrateHeight;
// at the edge of the screen, go back to the beginning:
if (xPos >= width) {
xPos = 0;
background(0);
} else {
// increment the horizontal position:
xPos++;

}
}
}

I'm working on a raspberry and when I run it, I everytime have this error in the console: (but the sketch run even though)

EGLDisplayUtil.EGLDisplays: Shutdown (open: 1)
EGLDisplayUtil: Open EGL Display Connections: 1
EGLDisplayUtil: Open[0]: 0x1: EGLDisplayRef[0x1: refCnt 2]

Do you know what does it mean and how I can solve it? The sketch read the values of the arduino (plugged on the raspberry) where a proximity sensor is plugged and when we put an object above the sensor the first video change and another one is launched. I also have another problem: When the sketch is running, the videos are slow down. And I remove everything that relate to the arduino and the sensor in processing, the videos are fine.

So is somebody can help me for this, it drives me crazy, and I didn't found a thing on our friend Google... Thanks so much :)

Here my code:

    ////////////////////////////////////////////
    ////////////////////////////////// LIBRARIES
    ////////////////////////////////////////////

    import processing.serial.*;
    import processing.video.*;





    /////////////////////////////////////////////////
    ////////////////////////////////// INITIALIZATION
    /////////////////////////////////////////////////

    Movie mymovie;
    Movie mymovie2;





    ////////////////////////////////////////////
    ////////////////////////////////// VARIABLES
    ////////////////////////////////////////////

    int lf = 10;    // Linefeed in ASCII
    String myString = null;
    Serial myPort;  // The serial port
    int sensorValue = 0; //value of the sensore
    int x = 100; //the sensor will be triggered when this value is reached. Modify it to change when the videos will switch




    /////////////////////////////////////////////
    ////////////////////////////////// VOID SETUP
    /////////////////////////////////////////////

    void setup() {
      //frameRate(50);
      fullScreen();
      //size(1280, 1024, P3D);
      // List all the available serial ports
      printArray(Serial.list());
      // Open the port you are using at the rate you want:
      myPort = new Serial(this, Serial.list()[1], 9600);
      myPort.clear();
      // Throw out the first reading, in case we started reading 
      // in the middle of a string from the sender.
      myString = myPort.readStringUntil(lf);
      myString = null;
      //load the video
      mymovie = new Movie(this, "VIDEO_1_v06bis.mov"); //Modify the line in quotation marks to change the videos. (put it inside the "data" folder
      mymovie2 = new Movie(this, "VIDEO_2_v02.mov");
      //set the videos for a continuous loop
      mymovie.loop();
      mymovie2.loop();
    }




    ////////////////////////////////////////////
    ////////////////////////////////// VOID DRAW
    ////////////////////////////////////////////

    void draw() {
      //image(mymovie, 0, 0); //display the video in a continuous loop
      // to trigger the sensor
      // check if there is something new on the serial port
      while (myPort.available() > 0) {
        // store the data in myString 
        myString = myPort.readStringUntil(lf);
        // check if we really have something
        if (myString != null) {
          myString = myString.trim(); // let's remove whitespace characters
          // if we have at least one character...
          if (myString.length() > 0) {
            println(myString); // print out the data we just received
            // if we received a number (e.g. 123) store it in sensorValue, we sill use this to change the background color. 
            try {
              sensorValue = Integer.parseInt(myString);
            } 
            catch(Exception e) {
            }
          }
        }
      }


      ///////////SENSOR TRIGGERED
      ///////////////////////////

      if (x < sensorValue) {
        mymovie.jump(0);
        //background(mymovie2);
        image(mymovie2, mouseX, mouseY);
        //mymovie2.pause();
      } else {
        //mymovie2.play();
        //mymovie.jump(0);
      }


      ///////////SENSOR NOT TRIGGERED
      ///////////////////////////////

      if (x > sensorValue) {
        mymovie2.jump(0);
        //background(mymovie);
        image(mymovie, mouseX, mouseY);
        //mymovie.pause();
      } else {
        //mymovie.play();
      }
    }



    //////////////////////////////////////////////
    ////////////////////////////////// VOID CUSTOM
    //////////////////////////////////////////////

    void movieEvent(Movie mymovie) {
      mymovie.read(); //read the video
      mymovie2.read();
    }

The hardware is made of an arduino which semd through serial this kind of data:

100:20:20

Where the first number is the time in microseconds when the pulse is high, the second low, and the last is the duty cycle.

Processing read everything correct from arduino

My problem is in drawing it. I tried with lines and points but i m not able to draw it correct

I was following the following tutorial on making a Pulse Sensor: https://www.youtube.com/watch?v=psTa5ZrqAyo

I was able to see output from a scope. I can therefore conclude output is being sent to the Arduino.

The code provided does not draw any pulse in Processing 3. I added a few lines, they are:

noFill();
stroke(0,255,0);
strokeWeight(4);

On lines 40-42. The rest is original code from the tutorial.

It is as follows:

    // Based on examples from Arduino's Graphing Tutorial and OscP5 documentation
    import processing.serial.*;
    Serial myPort; // The serial port
    int xPos = 1; // horizontal position of the graph
    float oldHeartrateHeight = 0; // for storing the previous reading


    void setup () {
    // set the window size:
    size(600, 400);
    frameRate(25);

    // List available serial ports.
    println(Serial.list());

    // Setup which serial port to use.
    // This line might change for different computers.
    myPort = new Serial(this, Serial.list()[0], 9600);

    // set inital background:
    background(0);
    }

    void draw () {
    }

    void serialEvent (Serial myPort) {
    // read the string from the serial port.
    String inString = myPort.readStringUntil('\n');

    if (inString != null) {
    // trim off any whitespace:
    inString = trim(inString);
    // convert to an int
    println();
    int currentHeartrate = int(inString);

    // draw the Heartrate BPM Graph.
    float heartrateHeight = map(currentHeartrate, 0, 1023, 0, height);
    noFill();
    stroke(0,255,0);
    strokeWeight(4);
    line(xPos - 1, height - oldHeartrateHeight, xPos, height - heartrateHeight);
    oldHeartrateHeight = heartrateHeight;
    // at the edge of the screen, go back to the beginning:
    if (xPos >= width) {
    xPos = 0;
    background(0);
    } else {
    // increment the horizontal position:
    xPos++;

    }
    }
    }

Any ideas what lines I need to append to get the output to display?

Any help is much appreciated, thanks in advance.

I've managed to get the tweets read out through Processing and I've also got Arduino sending values to Serial. The values I'm sending are simple integers of '1' and '2', but Processing picks these Serial values up as longer numbers. For example, when a '1' is sent from Arduino, Processing reads (and prints) this as '491310'.

Because the value of the int cannot exceed 255, any if statement I write in Processing to recognise '491310' doesn't work. Ideally, I'd like '1' to be sent from Arduino and for it to be read as '1' by Processing

Any help would be greatly appreciated. Absolute novice here. Thanks.

PROCESSING CODE:

import twitter4j.util.*;
import twitter4j.*;
import twitter4j.management.*;
import twitter4j.api.*;
import twitter4j.conf.*;
import twitter4j.json.*;
import twitter4j.auth.*;

import guru.ttslib.*;
import processing.serial.*;

java.util.List statuses = null;


TTS tts;
Serial myPort;

int sensor = 0;

void setup() {
  tts = new TTS();

  myPort = new Serial(this, Serial.list()[0], 9600);

  ConfigurationBuilder cb = new ConfigurationBuilder();

  cb.setOAuthConsumerKey("XXXX");
  cb.setOAuthConsumerSecret("XXXX");
  cb.setOAuthAccessToken("XXXX");
  cb.setOAuthAccessTokenSecret("XXXX");

  Twitter twitter = new TwitterFactory(cb.build()).getInstance();

  String userName ="@BBC";
  int numTweets = 19;
  String[] twArray = new String[numTweets];

  try {
    statuses = twitter.getUserTimeline(userName);
  }
  catch(TwitterException e) {
     e.printStackTrace();
  }
}

void serialEvent (Serial myPort) {
  int inByte = myPort.read();
  sensor = inByte;
  print(sensor);
}

void draw() {
  if (statuses != null) {
    for (int i=0; i<statuses.size(); i++) {
      Status status = (Status)statuses.get(i);

      if (sensor == 491310) {
        println(status.getUser().getName() + ": " + status.getText());
        tts.speak(status.getUser().getName() + ": " + status.getText());
      }
    }
  }
}

I'm currently trying to send some data from Arduino to Processing, so I can save it in a file. To be more specific, there are two variables (frequency of a blinking LED and respective LED number) which should be saved in tabular form.

Hereby the following Processing code is used:

import processing.data.Table;
import processing.serial.*;


Serial myPort;
Table dataTable; //table to store my values.

int lf = 10;
String Arduinostring = null;
float values;

String fileName;
void setup()
{
  String portName = Serial.list()[0]; 
  myPort = new Serial(this, portName, 9600); //the port I'm using to listen to the serial port

  dataTable = new Table();
  dataTable.addColumn("id"); 


  //columns for values
  dataTable.addColumn("Data");
}

  void draw() {
    while (myPort.available() > 0) {
      Arduinostring = myPort.readStringUntil(lf);
      if (Arduinostring != null) {
          print(Arduinostring);  // Prints String
          values=float(Arduinostring);  // Converts and prints float
          println(values);
      }
    TableRow newRow = dataTable.addRow(); //add a row for this new reading
    newRow.setInt("id", dataTable.lastRowIndex());//record a unique identifier (the row's index)

    //record information. 
    newRow.setFloat("Data", values);   
    }

    saveTable(dataTable, "data/new.csv"); // save it to computer.

}

My intention here is to get my data into the table (and into my file). I managed to receive the required data (frequency, LED number), but this data isn't saved in my file. The mentioned file is created by the way and at least has the right ID for each Row.

What I simply do not understand is that he can't save it though the received data should be converted to float with the command num=float(myString), shouldn't it?

Many thanks in advance for any help!

You'll see reference to multiple sensors, I am only trying to plot the sensor "moisture" for now.

/This sketch is frankensteined from the SerialCall Response example with arduino and 
//this guy's sketch(code in description of video) - http://pastebin.com/kSrU3nVH

import processing.serial.*;

int moisture;  //the only sensor I'm currently trying to plot 
float inByte;
int second; //sensors that ar![]()e not yet plotted but printed in the Console
int third;  // " "
int fourth; // " "

Serial myPort;                       // The serial port
int[] serialInArray = new int[4];    // Where we'll put what we receive
int serialCount = 0;                 // A count of how many bytes we receive
PFont  g_font;
boolean firstContact = false;        // Whether we've heard from the microcontroller

int[] yValues;
int w;

//SETUP
void setup() {
  size(1280, 720);  // Stage size

  g_font = loadFont("ArialMT-20.vlw");
  textFont(g_font, 20);

  w = 640; //width of our plot
  strokeWeight(1);
  smooth(); // or noSmooth();
  yValues = new int[w];

  println(Serial.list());
  String portName = Serial.list()[1];
  myPort = new Serial(this, portName, 9600);
}

void draw() { 
  String inString = myPort.readStringUntil('\n');

  if (inString != null) {
    inString = trim(inString);
    inByte = float(inString);

    moisture = int(map(inByte, 0, 255, 360, 25));
    //setting the boundry for the graph line, inside box EXCEPT IT DOESNT WORK
  }

  //This should be down here, but works inside the if statement.
  //moisture = int(map(inByte, 0, 255, 360, 25));

  //Background and box for graph
  background(55);
  rect(25, 25, 615, 335);
  fill(255);
  //LEGEND
  strokeWeight(1.5);
  stroke(255, 0, 0);     
  line(20, 420, 35, 420);
  stroke(0, 255, 0);     
  line(20, 440, 35, 440);
  stroke(0, 0, 255);     
  line(20, 460, 35, 460);
  stroke(255, 255, 0);   
  line(20, 480, 35, 480);

  fill(0, 0, 0);
  text("Moisture", 40, 430);
  text("Analog A1", 40, 450);
  text("Analog A2", 40, 470);
  text("Analog A3", 40, 490);

  //ACTUAL PLOTTED LINE
  for (int i = 1; i < w; i++) {
    yValues[i-1] = yValues[i];
  }
  yValues[w-1] = moisture; 
  //}

  stroke(120, 200, 0);
  line(w, moisture, 0, moisture);
  strokeWeight(3);


  //This controls the horizontal "TICKER LINE"
  for (int i=1; i<w; i++) {
    //stroke (rgb)
    stroke(220, 75, yValues[i]);
    //point folar x, float y
    point(i, yValues[i]);
    rect(0, 25, 50, 335);
    fill(255);
  }
}

void serialEvent(Serial myPort) {
  // read a byte from the serial port:
  int inByte = myPort.read();

  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 > 3) {
      moisture = serialInArray[0];
      second = serialInArray[1];
      third = serialInArray[2];
      fourth = serialInArray[3];

      // print the values (for debugging purposes only):
      println(moisture + "\t" + second + "\t" + third + "\t" + fourth);

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

/*ARDUINO UNO CODE
 int firstSensor = 0;    // first analog sensor
 int secondSensor = 0;   // second analog sensor
 int thirdSensor = 0;    // digital sensor
 int fourthSensor = 0; //turning this into a fluxuating value
 int inByte = 0;         // incoming serial byte

 void setup()
 {
 // start serial port at 9600 bps:
 Serial.begin(9600);


 pinMode(2, INPUT);   // digital sensor is on digital pin 2
 establishContact();  // send a byte to establish contact until receiver responds
 }

 void loop()

 {

 // if we get a valid byte, read analog ins:
 if (Serial.available() > 0) {
 // get incoming byte:
 inByte = Serial.read();
 // read first analog input, divide by 4 to make the range 0-255:
 firstSensor = analogRead(A0);
 // delay 10ms to let the ADC recover:
 delay(10);
 // read second analog input, divide by 4 to make the range 0-255:
 secondSensor = analogRead(A1) / 4;
 // read  switch, map it to 0 or 255L
 thirdSensor = map(digitalRead(A2), 0, 1, 0, 255);
 // send sensor values:
 fourthSensor = analogRead(A3) / 4; //new sensor I added
 Serial.write(firstSensor);
 Serial.write(secondSensor);
 Serial.write(thirdSensor);
 Serial.write(fourthSensor);

 }
 }

 void establishContact() {
 while (Serial.available() <= 0) {
 Serial.print('A');   // send a capital A
 delay(300);

 }
 }
 */![Screen Shot 2016-08-18 at 11.45.51 PM](https://forum.processing.org/two/uploads/imageupload/608/2KIEZIROU05C.jpg "Screen Shot 2016-08-18 at 11.45.51 PM")

ARDUINO

include <Ultrasonic.h>

define echoPin 13 //Pino 13 recebe o pulso do echo

define trigPin 12 //Pino 12 envia o pulso para gerar o echo

define echoPin2 4 //Pino 4 recebe o pulso do echo

define trigPin2 5 //Pino 5 envia o pulso para gerar o echo

//iniciando a função e passando os pinos Ultrasonic ultrasonic(12,13); Ultrasonic ultrasonic2(4,5);

void setup() { Serial.begin(9600); //inicia a porta serial pinMode(echoPin, INPUT); // define o pino 13 como entrada (recebe) pinMode(trigPin, OUTPUT); // define o pino 12 como saida (envia) pinMode(echoPin2, INPUT); // define o pino 4 como entrada (recebe) pinMode(trigPin2, OUTPUT); // define o pino 5 como saida (envia) }

void loop() { //seta o pino 12 com um pulso baixo "LOW" ou desligado ou ainda 0 digitalWrite(trigPin, LOW); // delay de 2 microssegundos delayMicroseconds(2); //seta o pino 12 com pulso alto "HIGH" ou ligado ou ainda 1 digitalWrite(trigPin, HIGH); //delay de 10 microssegundos delayMicroseconds(10); //seta o pino 12 com pulso baixo novamente digitalWrite(trigPin, LOW); // função Ranging, faz a conversão do tempo de //resposta do echo em centimetros, e armazena //na variavel distancia float duration = pulseIn(echoPin,HIGH);
//Esse calculo é baseado em s = v . t, lembrando que o tempo vem dobrado
//porque é o tempo de ida e volta do ultrassom
float distancia = duration /29 / 2 ; //seta o pino 12 com um pulso baixo "LOW" ou desligado ou ainda 0 digitalWrite(trigPin2, LOW); // delay de 2 microssegundos delayMicroseconds(2); //seta o pino 5 com pulso alto "HIGH" ou ligado ou ainda 1 digitalWrite(trigPin2, HIGH); //delay de 10 microssegundos delayMicroseconds(10); //seta o pino 5 com pulso baixo novamente digitalWrite(trigPin2, LOW); // função Ranging, faz a conversão do tempo de //resposta do echo em centimetros, e armazena //na variavel distancia float duration2 = pulseIn(echoPin2,HIGH);
//Esse calculo é baseado em s = v . t, lembrando que o tempo vem dobrado
//porque é o tempo de ida e volta do ultrassom
float distancia2 = duration2 /29 / 2 ;

Serial.println("pé da frente"); Serial.println(distancia); Serial.println("pé de tras"); Serial.println(distancia2); delay(1000); //espera 1 segundo para fazer a leitura novamente }

PROCESSING

// Example by Tom Igoe

import processing.serial.*;

Serial myPort; // The serial port PFont myFont; // The display font String distancia; String distancia2;// Input string from serial port int lf = 10; ; // ASCII linefeed

void setup() { size(500,500); // You'll need to make this font with the Create Font Tool //myFont = loadFont("ArialMS-18.vlw"); //textFont(myFont, 18); // List all the available serial ports: printArray(Serial.list());

myPort = new Serial(this, Serial.list()[0], 9600); myPort.bufferUntil(lf); }

void draw() { background(0); text("Pé de trás: " + distancia, 10,50); text("Pé de trás: " + distancia2, 10,150);

}

void serialEvent(Serial p) { distancia = p.readString(); }

I am trying to get an ultrasound sensor to read the distance of a person. —When the person is far it should trigger a movie to play. —When the person is at mid distance camera should activate and should film him. When the person is near to the sensor, there should be again a movie being played. At the point the code was reading the distances properly but when the camera was added the distance sensor didn't work anymore or it didn't give me the values anymore, only the camera appears to be activated, but it doesn't show any picture. At use there are a MacBookPro, Build-in Camera, Arduino Uno, Ultrasound sensor and Processing... I am including the code maybe a soul can shed a light!

Thanks so much in advance, Ana

import processing.serial.*; import processing.video.*;

Movie movie_1; Movie movie_2; Capture cam;

int distance; Serial myPort; // The serial port String comPortString; int output = 0;

void setup() { // Serial stuff // List all the available serial ports printArray(Serial.list()); // Open the port you are using at the rate you want: myPort = new Serial(this, Serial.list()[2], 9600);

// Movie stuff frameRate(30); size(200, 200); movie_1 = new Movie(this, "01_CloseUp.mov"); movie_2 = new Movie(this, "01_CloseUp.mov");

// Camera stuff String[] cameras = Capture.list();

if (cameras.length == 0) { println("There are no cameras available for capture."); exit(); } else { println("Available cameras:"); for (int i = 0; i < cameras.length; i++) { println(cameras[i]); }

// The camera can be initialized directly using an 
// element from the array returned by list():
cam = new Capture(this, cameras[0]);
cam.start();     

}
} // With this void starts the camera to be detected void draw() {

if (output == 0) { image(movie_1, mouseX, mouseY); } else if (output == 1) { if (cam.available() == true) { cam.read(); } image(cam, 0, 0); } else if (output == 2) { image(movie_2, mouseX, mouseY); } }

void serialEvent(Serial cPort) { comPortString = cPort.readStringUntil('\n'); if(comPortString != null) { comPortString=trim(comPortString);

// Use the distance received by the Arduino to modify the lines distance = int(map(Integer.parseInt(comPortString),1,200,1,height)); println(distance);

// Values from 100 to 5000 if (distance < 1000) { // Play video 2 (dancing) output = 2; } else if (distance < 2500) { // Play video feed from camera (person) output = 1; } else { // Play video 1 (dancer sitting) output = 0; } }

}

my current code below.

import processing.serial.*;

import themidibus.*; 

MidiBus myBus; 

Serial myPort;        
int xPos = 1;         
float inByte = 0;

void setup () {
  MidiBus.list();
  // set the window size:
  size(900, 400);

  println(Serial.list());
  myBus = new MidiBus(this, 1, 3); 

  myPort = new Serial(this, Serial.list()[1], 115200);

  myPort.bufferUntil('\n');

  background(0);
}

void draw () {
  // draw the line:
  stroke(127, 34, 255);
  line(xPos, height, xPos, height - inByte);

  // at the edge of the screen, go back to the beginning:
  if (xPos >= width) {
    xPos = 0;
    background(255,255,255);
  } else {
    // increment the horizontal position:
    xPos++;
  }
}

void serialEvent (Serial myPort) {
  // get the ASCII string:
  String inString = myPort.readStringUntil('\n');

  if (inString != null) {
    // trim off any whitespace:
    inString = trim(inString);
    // convert to an int and map to the screen height:
    inByte = int(inString);

    println(inByte);
    int a = 56;
    inByte = map(inByte, 0, 1023, 0, 127);
    int test = int(inByte);
    if(inByte > 2){
      myBus.sendNoteOn(1, 38, test); // Send a Midi noteOn
      delay(1);
      inByte--;
      myBus.sendNoteOff(1, 38, test); // Send a Midi nodeOff
    }
  }
}

int x;// assigned to A0 input
int y;// assigned to A1 input
int z; //assigned to D0 input
int votes[3]={0,0,0};

void setup() {
  // initialize the serial communication
  Serial.begin(9600);

  while(!Serial);
}

void loop() {
  // first we need to read the values from the BUTTONS

  x = digitalRead(A0);

  y = digitalRead(A1);

  z = digitalRead(0);

  if(digitalRead(A0) == HIGH) 
    {
    Serial.print("cat1 ");                  
    Serial.print(votes[0]=votes[0]+1);
    Serial.print("\n");
    }
   else if(digitalRead(A1) == HIGH)
    {
    Serial.print("cat2 ");
    Serial.print(votes[1]=votes[1]+1);
      Serial.print("\n");
    }
   else if(digitalRead(0) == HIGH) 
    {
    Serial.print("cat3 ");
    Serial.print(votes[2]=votes[2]+1);
    Serial.print("\n");
    }
    delay(200);
}

I would like the counter to increment every time the button is pressed and display in processing as a bar graph. Whenever the button is pressed, the bar graph goes up by some amount. In this case I want one of the three lines (associated to three buttons) to draw, if pressed.

The processing code is below:

import processing.serial.*;

// Serial Port variables
Serial myPort;
String buff = "";
String buff1 = "";
String buff2 = "";
int index = 0;
int NEWLINE = 10;
// Store the last 256 values from the sensors so we can draw them.
int[] valuesx = new int[256];
int[] valuesy = new int[256];
int[] valuesz = new int[256];

void setup()
{ 
  // set size of the window 
  size(512, 512);
  // turn on anti-aliasing, this makes things look smoother 
  smooth();

  println(Serial.list()); // use this to determine which serial port is your Arduino
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

// draw() happens every frame of the sketch. This is where all the calculations are made.
// When draw() is finished executing, it executes again, over and over.
void draw() {
  // set the background to purple
  background(87, 36, 124);
  // set stroke weight(thickness of the line) to 5 pixels
  strokeWeight(5);

  for (int i = 0; i < 255; i++) {

    stroke(247, i);
    // draw the line (x1, y1, x2, y2)
    line(1, valuesx[i], 1, valuesx[i + 1]);
    line(5, valuesy[i], 5, valuesy[i + 1]);
    line(10, valuesz[i], 10, valuesz[i + 1]);
  }

  // Check the Serial port for incoming data
  while (myPort.available () > 0) {
    // if there is data waiting...
    // execute serialEvent() function. Look below to see how SerialEvent works.
    serialEvent(myPort.read());
  }
}

// serialEvent controls how incoming serial data from the Arduino module is handled
void serialEvent(int serial)
{
  if (serial != NEWLINE) {
    // Store all the characters on the line.
    buff += char(serial);
  } 
  else {
    // The end of each line is marked by two characters, a carriage
    // return and a newline.  We're here because we've gotten a newline,
    // but we still need to strip off the carriage return.
    buff = buff.substring(0, buff.length()-1);
    index = buff.indexOf(",");
    buff1 = buff.substring(0, index);
    buff2 = buff.substring(index+1, buff.length());

    // Parse the String into an integer.  We divide by 4 because
    // analog inputs go from 0 to 1023 while colors in Processing
    // only go from 0 to 255.
    int x = Integer.parseInt(buff1)/2;
    int y = Integer.parseInt(buff2)/2;

    // Clear the value of "buff"
    buff = "";

    // Shift over the existing values to make room for the new one.
    for (int i = 0; i < 255; i++)
    {
      valuesx[i] = valuesx[i + 1];
      valuesy[i] = valuesy[i + 1];
    }

    // Add the received value to the array.
    valuesx[255] = x;
    valuesy[255] = y;
  }
}

Unfortunately, here's the error that I get when I press a button.

I'm wondering how to go about debugging this. Is it the wrong port (Serial.list(this)[0]) that is doing this? or something else? I'm not sure how to debug why the app's crashing. I just recently started using Processing 0251 for Android. Even just the line "println(Serial.list(this));" triggers the app to shut down.

Thanks in advance!

I used this link to help getting set up:

Processing code in Android mode:

import com.yourinventit.processing.android.serial.*;

Serial SerialPort;
boolean Toggle;

void setup()    
{fullScreen();
background(255,0,0);
  println(Serial.list(this)); //this line alone makes the app crash even if i dont have any other code
  SerialPort = new Serial(this, Serial.list(this)[0], 9600);
}

void draw()
{
}

void mousePressed() {    
  Toggle = !Toggle;
    // while (SerialPort.available() > 0) {
  SerialPort.write( Toggle?"1":"0");
    // }
}

Arduino Code:

    #define NUMBER_OF_CHANNELS 8
    #define PINLED1 13
    volatile char lastReceivedCharFromSerialIn = '\0';

    void setup() {
      pinMode(PINLED1, OUTPUT);
      Serial.begin(9600);    
    }

    void loop() {
      digitalWrite( PINLED1, lastReceivedCharFromSerialIn == '1');
    }

    void serialEvent() {
      while (Serial.available()) {
        // get the new byte:
        lastReceivedCharFromSerialIn = (char)Serial.read(); 
      }
    }

I just installed LUBUNTU 16-04 with a running arduino IDE. No problem.

Now I would like to install processing3. I have it running.

But my adxl345 read out in pitch-roll give the above mentioned error.

Already looked on the internet for possible solutions s.a. i must be mention of the group etc.

Al I treid nothing works.

Situation arduino for linux and processing3

linux prog is LUBUNTU 16-04 and linux32 4.4.0.22

Who has the solution. Help is very much apriciated.

Kind regards,

ilioSS

btw arduino uses ttyUSB0 serial port

Now the question is why a get small picture whatever i put in size() i get the same small picture and with this program DARKER the pixel is closer the object is. AND NOW the main question is how to invert grayscale , cause i want darker pixel farther.

Sorry for so many words and thank u.

This is the code in processing.

import processing.serial.*;

float pcolor = 0; // point color value
float xVal = 0;  // x value
float yVal = 0;  // y value

Serial myPort;

void setup() {

  size(400,200);

  printArray(Serial.list()); 

  myPort = new Serial(this, Serial.list()[0], 57600);

  myPort.bufferUntil('\n');   
  background(0);
}

void draw() {
  stroke(pcolor);    
  point(xVal,yVal);
}

void serialEvent(Serial myPort) {

  String inString = myPort.readStringUntil('\n');  

  if (inString !=null) {
    inString = trim(inString);    

    float[] colors = float(split(inString, ","));    

    if (colors.length >=3) {       
      xVal = colors[0];          
      yVal = colors[1];
      pcolor = map(colors[2], 0, 400, 0,255);
    }
  }
}

(Code in comments)

static class SerialPortReader implements SerialPortEventListener {

    public void serialEvent(SerialPortEvent event) {
        startLoop = millis(); 
        ...
        ...
        long endLoop = millis();                    
        println("Looptime = "+(endLoop - startLoop));

    }// End of serialEvent  
}// End of SerialPortReader 

I'm not static friendly :)) ;)

` import processing.serial.*;

float x,y;

void setup() {

size(800,800);

Serial arduino = new Serial(this, "COM3", 250000);

arduino.bufferUntil('\n');

}

void draw()

{

}

void serialEvent(Serial p) {

String rawString = p.readStringUntil('\n');

if (rawString != null) {

rawString = rawString.trim();

try{

String[] values = split(rawString,",");

int serialX = int(values[0]);

int serialY = int(values[1]);    

x = map(serialY,0,640,0,width);

y = map(serialX,0,480,0,height);

/* maybe something like

if (values[0]!=0)

{

fill ellipse(x,y,10,10); }

*/

}catch(Exception e){

println("Error parsing string from Serial:");

e.printStackTrace();

}

}

}

`