Processing GUI with Arduino sketch run together

Projects Networking, Protocols, and Devices
1

Hello everyone,

I am building a 7DoF robot with servos and steppers. I wrote an Arduino sketch to move the motors and a GUI on Processing to control them with sliders.

I believe I am supposed to run both sketches together but im facing the following problem with the USB Port:

I first upload the Arduino sketch through Port COM4. Then when I try to run the Processing sketch It says error "Port busy".

Instead if I run the Processing sketch with Arduino IDE closed, it works but then After opening Arduino IDE (to use serial monitor to check Serial prints so i know if theres any communication), the Serial Monitor cant connect to Arduino for the same reason: "Port busy".

What exactly am I supposed to do?

This is the Arduino sketch:

#include <AccelStepper.h>
#include <Servo.h>

// Stepper NEMA17 controlled through CNC Shield V3 with DRV8825 drivers (1/16 microstepping)
AccelStepper stepper1(AccelStepper::DRIVER, 2, 5);  // X module on shield
AccelStepper stepper2(AccelStepper::DRIVER, 3, 6);  // Y module on shield
AccelStepper stepper3(AccelStepper::DRIVER, 4, 7);  // Z module on shield
AccelStepper stepper4(AccelStepper::DRIVER, 12, 13);  // A module on shield

Servo needleServo;  // Servo360 to move Needle
Servo ServoX;       // Servo360 to move x axis
Servo ServoY;       // Servo360 to move y axis

int servospeedforward = 100;
int servospeedbackward = 80;
float servorevpersecond = 3;

void setup() {
  Serial.begin(115200);
  
  // Config Stepper speed and acceleration
  stepper1.setMaxSpeed(200);
  stepper1.setAcceleration(100);
  stepper2.setMaxSpeed(200);
  stepper2.setAcceleration(100);
  stepper3.setMaxSpeed(200);
  stepper3.setAcceleration(100);
  stepper4.setMaxSpeed(200);
  stepper4.setAcceleration(100);
  
  needleServo.attach(9);  // Attach Servo to pin 9 (Needle control)
  ServoX.attach(10);  // Attach Servo to pin 10 (X axis control)
  ServoY.attach(11);  // Attach Servo to pin 11 (Y axis control)
}

void loop() {

  if (Serial.available() > 0) {
    String data = Serial.readStringUntil('\n');
    int j1 = data.substring(0, data.indexOf(',')).toInt();
    data = data.substring(data.indexOf(',') + 1);
    int j2 = data.substring(0, data.indexOf(',')).toInt();
    data = data.substring(data.indexOf(',') + 1);
    int j3 = data.substring(0, data.indexOf(',')).toInt();
    data = data.substring(data.indexOf(',') + 1);
    int z = data.substring(0, data.indexOf(',')).toInt();
    data = data.substring(data.indexOf(',') + 1);
    int needle = data.substring(0, data.indexOf(',') + 1).toInt();
    data = data.substring(data.indexOf(',') + 1);
    int servoXVal = data.substring(0, data.indexOf(',')).toInt();
    data = data.substring(data.indexOf(',') + 1);
    int servoYVal = data.toInt();
    Serial.println(j1);

    // Set Stepper target angle and move them
    stepper1.moveTo(j1);
    stepper2.moveTo(j2);
    stepper3.moveTo(j3);
    stepper4.moveTo(z);
   
    stepper1.run();
    stepper2.run();
    stepper3.run();
    stepper4.run();

  // Servo [mm] to [ms] (of running) conversion
  float needle_ms = ((abs(needle) / 4) / servorevpersecond) * 1000;         // 4 = screw lead = 4mm per revolution
  float servoXVal_ms = ((abs(servoXVal) / 4) / servorevpersecond) * 1000; 
  float servoYVal_ms = ((abs(servoYVal) / 4) / servorevpersecond) * 1000; 


  // Move servo motors
    if (needle > 0) {
      needleServo.write(servospeedforward);    // run forward
      Serial.println("servo needle running forward");
      delay(needle_ms);
      needleServo.write(90);                    // stop
    }  
    if (needle < 0) {
      needleServo.write(servospeedbackward);    // run backward
      Serial.println("servo needle running backwards");
      delay(needle_ms);
      needleServo.write(90);                    // stop
    }

    if (servoXVal > 0) {
      ServoX.write(servospeedforward);    // run forward
      Serial.println("servo X running forward");
      delay(servoXVal_ms);
      ServoX.write(90);                    // stop
    }  
    if (servoXVal < 0) {
      ServoX.write(servospeedbackward);    // run backward
      Serial.println("servo X running backward");
      delay(servoXVal_ms);
      ServoX.write(90);                    // stop
    }

    if (servoYVal > 0) {
      ServoY.write(servospeedforward);    // run forward
      Serial.println("servo Y running forward");
      delay(servoYVal_ms);
      ServoY.write(90);                    // stop
    }  
    if (servoYVal < 0) {
      ServoY.write(servospeedbackward);    // run backward
      Serial.println("servo Y running backward");
      delay(servoYVal_ms);
      ServoY.write(90);                    // stop
    }

  }
}

This Is the Processing sketch:

import processing.serial.*;
import controlP5.*;

Serial myPort;
ControlP5 cp5;

int j1Slider = 0;
int j2Slider = 0;
int j3Slider = 0;
int zSlider = 0;
int needleValue = 0;
int xSlider = 0; 
int ySlider = 0; 


int slider1Previous = 0;
int slider2Previous = 0;
int slider3Previous = 0;
int sliderzPrevious = 0;
int needleValuePrevious = 0;
int sliderxPrevious = 0;
int slideryPrevious = 0;

float q1_offset = 100;  //[mm]
float q1, q4;           //[mm]      
float q0, q2, q3;       //[deg]
float a1 = 52.5;        //[mm]
float a2 = 80;
float a3 = 104;
float j1, j2, j3, x, y, z, n;
float rhoP;
float xP = 0;
float yP = 0;
float zP = 0;

String data;

void setup() {
  size(960, 800);
  myPort = new Serial(this, "COM4", 115200); 
  
  cp5 = new ControlP5(this);
  PFont pfont = createFont("Arial", 25, true);
  ControlFont font = new ControlFont(pfont, 22);

  // Joint1 control
  cp5.addSlider("j1Slider")
    .setPosition(110, 190)
    .setSize(270, 30)
    .setRange(-75, 75)       // [deg]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("J1");

  // Joint2 control
  cp5.addSlider("j2Slider")
    .setPosition(110, 315)
    .setSize(270, 30)  
    .setRange(0, 60)      // [deg]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("J2");

  // Joint3 control
  cp5.addSlider("j3Slider")
    .setPosition(110, 440)
    .setSize(270, 30)
    .setRange(-45, 45)      // [deg]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("J3");

  // Z axis control
  cp5.addSlider("zSlider")
    .setPosition(110, 565)
    .setSize(270, 30)
    .setRange(0, 170)         // [mm]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("Z");

  // Needle control
  cp5.addSlider("needleValue")
    .setPosition(110, 690)
    .setSize(270, 30)
    .setRange(0, 40)         // [mm]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("Needle");
    
  // X axis control
  cp5.addSlider("xSlider")
    .setPosition(500, 565)
    .setSize(270, 30)
    .setRange(-50, 50)       // [mm]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("X");
    
  // Y axis control
  cp5.addSlider("ySlider")
    .setPosition(500, 690)
    .setSize(270, 30)
    .setRange(-50, 50)       // [mm]
    .setColorLabel(#3269c2)
    .setFont(font)
    .setCaptionLabel("Y");
}

void draw() { 
  background(#F2F2F2);
  textSize(26);
  fill(33);
  text("Venipuncture Robot Control", 260, 60); 
  textSize(22);
  text("Joint 1", 35, 250);
  text("Joint 2", 35, 375);
  text("Joint 3", 35, 500);
  text("Axis Z", 35, 625);
  text("Needle", 35, 750);
  text("Axis X", 35, 875);
  text("Axis Y", 35, 1000);

  fill(33);
  textSize(32);
  text("X: " + nf(xP, 0, 2), 500, 290);
  text("Y: " + nf(yP, 0, 2), 650, 290);
  text("Z: " + nf(zP, 0, 2), 800, 290);

  updateData();
  
  if (slider1Previous != j1Slider || slider2Previous != j2Slider || slider3Previous != j3Slider || sliderzPrevious != zSlider || needleValuePrevious != needleValue || sliderxPrevious != xSlider || slideryPrevious != ySlider) {
    j1 = round(cp5.getController("j1Slider").getValue());
    j2 = round(cp5.getController("j2Slider").getValue());
    j3 = round(cp5.getController("j3Slider").getValue());
    z = round(cp5.getController("zSlider").getValue());
    n = round(cp5.getController("needleValue").getValue());
    x = round(cp5.getController("xSlider").getValue());
    y = round(cp5.getController("ySlider").getValue());
        
    forwardKinematics();
    myPort.write(data);            // Send data to Arduino
  }

  slider1Previous = j1Slider;
  slider2Previous = j2Slider;
  slider3Previous = j3Slider;
  sliderzPrevious = zSlider;
  needleValuePrevious = needleValue;
  sliderxPrevious = xSlider;
  slideryPrevious = ySlider;
}

void forwardKinematics() {
  q0 = j1;
  if (q0 < 0) {
    q0 = q0 + 360;
  }
  q1 = z;
  q2 = j2 - 45;
  if (q2 < 0) {
    q2 = q2 + 360;
  }
  q3 = 180 - j3 + j2;
  q4 = needleValue;
  rhoP = a2*cos(q2) + (a3+q4)*cos(q3);
  zP = q1_offset + q1 - a1 + a2*sin(q2) + (a3+q4)*sin(q3);
  xP = rhoP*cos(q0) + x;
  yP = rhoP*sin(q0) + y;
  
}

void updateData() {
  data = String.format("%d,%d,%d,%d,%d,%d,%d\n", (j1Slider-slider1Previous), (j2Slider-slider2Previous), (j3Slider-slider3Previous), (zSlider-sliderzPrevious), (needleValue-needleValuePrevious), (xSlider-sliderxPrevious), (ySlider-slideryPrevious));
}
2

it depends what you mean by "together "
two (or more) programs cannot access the same serial COM port concurrently
e.g. assuming Processing is not running

  1. you can run the Arduino IDE connect to the COM port to upload code and if required for initial testing run the serial monitor
  2. to run Processing close the serial monitor then Processing can open the COM port
  3. when you wish to upload code again Processing will have to disconnect from the COM port (you may have to close Processing?)
3

Thank you for your answer.

This is good for me but It means those lines of code "serial.print" are useless since to run the motors I have to move the sliders on Processing

Anyway not a big problem excerpt for an harder debugging

4

If you are debugging, you can send the same "string" using the Serial Monitor that your processing code sends. You would have to make sure line endings are turned on in Serial Monitor and provide the actual #s yourself.

5

No, the Processing sketch will take the port. Once the Arduino sketch is uploaded, the Arduino IDE is done.
The point of the Processing sketch is to give you a prettier, more user friendly way of exchanging data between the user and the Arduino than the bare bones Arduino Serial Monitor.

6

You need a function in Processing like this:

void serialEvent (Serial myPort) {

  String inString = myPort.readStringUntil('\n');
  if (inString != null) {
    inString = trim(inString);
    idling = false; // just my variable, ignore
    test = 0; // also mine, you don't need this
    val = 0; // or this and so on
    simMode = true; // might be a Classified just scanned

    if (inString.equals("intruder")) { // you do need something like this
      background(0); // reset background quick before...
      state = 670; .. changing state in void draw()
      simMode = false;
      teamSize = 0;
    }
  }
}

Note that there's no need to call that Processing function in void draw(). It just needs to live outside of void draw() somewhere.
Notice that I actually did stuff in the Serial function, too. In fact, this is truncated by about 700 or so more if/else statements as it is a great wedge to nudge everything else in void draw() to pay attention to what Arduino just sent it.
In this way, what happens in the Serial function can drive a Processing state machine, which makes it easier to make clear cut, non overlapping changes to what's on screen.

Arduino was responsible for scanning RFID cards and based on the card, send some text to Processing to pull up graphics, sound and other unique character data.
Arduino would also listen in for keys typed on the computer while Processing was running, where individual chars would drive Arduino sketch states (locked or not against user interaction in Processing)
Arduino code relevant part:

  if (Serial.available() > 0) {

    char in = Serial.read();
    if ((in == 'e') || (in == 'E')) {
      locked = true;
    }
    else if ((in == 'a') || (in == 'A')) {
      locked = false;
    }
  }
  switch (locked) {
    case false:
      if ( ! mfrc522.PICC_IsNewCardPresent())
      {
        return;
      }
      // Select one of the cards
      if ( ! mfrc522.PICC_ReadCardSerial())
      {
        return;
      }
      String content = "";
      // byte letter;
      // original version
      // for (byte i = 0; i < mfrc522.uid.size; i++)
      // new version for sticker tags, trim off identical first couple of digits
      for (byte i = 0; i < mfrc522.uid.size - 2; i++)
      {
        Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? "0" : "");
        Serial.print(mfrc522.uid.uidByte[i], HEX);
        content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
        content.concat(String(mfrc522.uid.uidByte[i], HEX));
      }
      Serial.println();
      content.toUpperCase();
      if ((lastv == true) && (content.substring(1) != lastString)) {
        veh = true;
      }
      // 1982 (16)
      if (content.substring(7, 2) == "91635") // 04916353B7
      {
        Serial.println(F("bre")); // breaker
      }

Note this line in Arduino:

 Serial.println(F("bre")); // breaker

The F macro is not needed (but a good idea to save Arduino RAM) but note that I use Serial.println();, because in Processing,

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

the \n is newline, or the "ln" part of Serial.println.

7

I don't use Processing but other technologies to build GUIs
the GUI receives the Serial.print() output and can deal with it in various ways, e.g. in C#/Java output the text to a TextBox object, plot a graph, save it to a file, transmit to another program using TCP/IP, etc or even discard it

8

Hello, thank you for your advice.

I am trying to implement a similar function but Just for debugging.

I tried this:

void serialEvent (Serial myPort) {
   String inString = myPort.readStringUntil('\n');
   if (inString != null) {
      print(inString);
   }
}

The function is designer to Just print in the Processing console what would be printed in the Arduino Serial Monitor. I placed this code at the end of the Processing code I posted on post #1
Is this ok? The only question I have is what kind of object is "myPort"? I tried with:
String myPort = "COM4";
but obviously It says there Is no function readStringUntil.

How should I define myPort?
Is everything else ok?

9

You already defined a myPort here:

You need only refer to it when you call your function:

   serialEvent (Serial myPort) 
   ...

...but with the "readStringUntil(..)", whenwever it is called it will stall your program while it waits to read line.

10

Stall means a matter of milliseconds or much more?

11

Much more:

Each time it is polled, it will wait for a whole second. (by default)

12

Note that this example is in Java mode. I don't know if that works for you. Should be a similar way of doing things if you're using something else in Processing.

Here's the whole thing as I have it in that sketch. The way you have it, explicitly declaring what COM port you have should work the same, but for completion's sake as I had it...

import processing.serial.*;

Serial myPort;

String[] com = {"COM2", "COM3", "COM4",
  "COM5", "COM6", "COM7", "COM8", "COM9", "COM10", "COM11",
  "COM12", "COM13", "COM14", "COM15", "COM16", "COM17", "COM18",
  "COM19", "COM20", "COM21", "COM22", "COM23", "COM24", "COM25", "COM26"}; // should be one of these...

void setup(){
connect(1, 24, 200);  // so you don't need to know COM number of whatever PC you're using
}

// let's cycle through COM 2-26 inclusive and grab the right COM port.
  boolean connect(int portNumber, int numCom, int limit) {
  background (0, 14, 255);
  int tries = 0;
  while (tries < limit) {
    try {
      printArray (Serial.list()[portNumber]);
      myPort = new Serial(this, com[numCom], 115200);
    }
    catch(Exception e) {
      System.err.println("Retrying " + "Port " + com[numCom] );
     // numCom -= 1;
      numCom += 1;
      tries++;
      if (numCom < 0) { // prevent ArrayIndexOutOfBoundsException
        numCom = 24;
      }
      else if (numCom > 24){ // prevent ArrayIndexOutOfBoundsException
       numCom = 0; 
      }
      if (tries % 25 == 0) {
        portNumber += 1;
        if (portNumber > 4) {
          portNumber = 0;
        }
      }
      delay(200);
      continue;
    }
    break;
  }
  if (tries < limit) {     
      println("Connected in " + str(tries + 1) + " tries.");
      background(0, 255, 0);
      delay(200);
      background(0);
      return true;
    } else {
      System.err.println("Connection failed.");
      return false;
    }
  }

I don't know, is it ok? If you wanted something nicer looking, that's the whole point of Processing. As I said, pretty much my whole sketch occurs in that Serial function as it uses a brief String sent from Arduino to drive the state of the Processing sketch, which calls .jpg files, hyperlinks, other draw type stuff in void draw().

Note again that this is in Processing 4, Java mode. I can't say whether this will work for you, I'm just a hobbyist and this is how I do it.

I never see what's printed in the Processing console since I use the whole screen by using this (after definitions and just before void setup())

void settings() {
  fullScreen(P3D);
}
13

I have got a tutorial in progress to show how to communicate in both directions with an Arduino and processing. The trick is to never use the Arduino's serial monitor.

Tutorial - sending multi variable messages between Processing to Arduino

Using the Processing Language is a great way of providing a custom graphics interface to your Arduino project, while not requiring the complex code, limited display size and large memory, of providing this on the Arduino itself. The Processing language version used here is Version 4.x. Earlier versions might not work.

While there is an example of simple single byte transfer shown in the examples folder of Processing, this is of limited use, and tends to lead a beginner down the wrong path. Used as a basis of real world control requires more than this because of two problems.

  1. The first in splitting numbers into individual byte.
  2. Ensuring these individual bytes are synchronised in the receiving Arduino.

The way round this is to send a whole multivariable message as a comer separated list in one string message. This does require the receiving Arduino has then to parse this list to recover the variables. This tutorial shows you how to do this.

Needless to say the list of variables sent by Processing must match the list variables the Arduino is expecting.

Two way Communication
One of the problems with the conventional use of the serial monitor to see what is going on in your Arduino during development, is you can't use the Serial.print commands to debug you code on the Arduino. This is because Processing is busy using the port to send messages. But by using this code there is no need to use the normal serial monitor. This is because any print statement from the Arduino is displayed on Processing's console window.

Most Processing examples involving serial communications start with saying something like "I know on my system that the port I am after is always on the the first port." This is lazy and will not work in most real installations where there can be many devices connected to the computer, and where those devices change over time. Especially when you use different Arduinos or alternate USB connection leads, like an RS232 USB cable.

The solution to this problem is to know the name of the serial port you wish to connect with, rather than its position in a list. and to search for this port. If it is not found then the first port is chosen, which when using a Mac is the wrong option. If you don't know the names of the port you are looking for you can copy it from the list of ports shown when this code starts up.

About Processing
Processing is a language based on Java, both use a C like syntax, so superficially it looks like the C you use to program the Arduino. However, the structure of the code is different. It has the setup function just like the Arduino, but the loop function is replaced by a 'draw' function. This is executed at the beginning of a frame of the display. You can set this to how many frames a second you want and then if the drawing of the screen takes too long it drops to the frames per second it can get.

There are a number of on screen controls that can be updated automatically without any need to anything in the "draw" function. This is basically how this demo code works. There are two types of control here. One is a "knob", a click + drag action in the vertical direction changes the display on the screen. The other type of control here uses the "bang" control, that generates an event when clicked on. There is a 4 by 4 matrix of these "bang" buttons used here.

Other sorts of controllers with an example of their use can be found in the examples window under the menu path "Contributed Libraries --> ControlP5 --> controllers. These include buttons, radio buttons, check boxes, colorPicker, dropdown lists, and sliders.

These controls need initialising in the setup function with all their options specified. They also require a function with the same name as the controller where the values of the controller can be extracted when ever one changes.

About Processing code in this demonstration
This follows the normal layout of a C program, with the 'import' command replacing the #include used in the Arduino along with any variables required for defining the things in the 'import' command.

This is followed by the global variables definitions, and then onto the 'setup' function.
This defines the size of the window on the screen, the command to use anti-aliased when drawing, and the command not to draw an outline to graphics.

Then we move onto the defining of the 'Knob' controller with all its options. Then we do the same thing for the bang controllers. This is done with a pair of nested 'for' loops. Each controller has an ID number associated with it as well as a name. We use this ID number to determine what servo number is sent to the Arduino.

Next we try and connected to our specified serial port name. What ever the outcome the chosen connection is displayed in Processing's console window. It is important to have the same baud rate specified here as you set in the Arduino's 'Serial.began() call.

The 'draw' function just draws the background, but it is important to call it as all the control functions are triggered from this.

The 'bang' controller needs to use the 'controlEvent' function, but 'Knob' events will also be passed to this function, and they are not needed here. So at the start of the 'controlEvent' function, we check for the 'Knob' event and simply return. Then the 'bang' controller names are checked, one at a time, in a 'for' loop and when we find the one that caused the event we pass the ID number of that 'bang' to a function that sends out message to the Arduino.

Finally there is a function that is called automatically when a "Carriage Return" byte is received from the Arduino. That means the message from the Arduino is only seen when a 'Serial.printnl(' is sent.

Customising
The initial value the 'Knob' is set to is 90˚. This matches the initial position set by the Arduino code. This can be changed by altering this line:-
int knobValue = 90; // initial value

The Arduino documentation recommends to use only values from 0 to 180˚. Many Servos will do more than this. So you can change this line to suit your needs.
int maxAngle = 180; // change as required

Also some servos require negative angles, again if this is the case or you want to restrict the angle so as not to go to 0˚, you can change this line
int minAngle = 0; // change as required

You can customise other things as well like the colour of the controls and how it behaves by changing the code in the 'setup' function.

The Arduino Code
The code in this example for the Arduino is for servos attached to the Arduino board using the Servo.h library. The number of servos you can control with this library is dependent on what sort of Arduino you have. The Arduino Uno is "only" capable of generating signals to control up to 12 servos, this changes to 48 on the Arduino Mega. While On the Arduino Due you can control up to 60 servos.

Do not attempt to power any servos direct from the 5V pin of the Arduino. You need an external power supply, with its ground (or negative output) connected to the Arduino ground. This should be capable of supplying about 1A per servo to handle the surge currents from the motors. However, this can be reduced because the Processing code only moves one servo at a time. You can fit less than 16 servos if you like.

In the code example the Servos are connected to pins:-
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
These correspond to S0 -> S11 in the graphic 'bang' controls in the Processing code.

The code uses string and not String variables (capital S) these are two different things and in an Arduino environment the use of 'String' can cause memory problems. So this code uses the:-
Serial.readBytesUntil(13, incoming, bufferSize);
method to read in strings with the CR (13) control being used to indicate the end of a message. Many beginners use the:-
Serial.readString(); method but this is a big mistake as it first of all creates a 'String' variable and second that it takes at least a second to read in because it waits until the serial port 'times out', which by default is a second and results in very slow communication.

It then sends the received message back to Processing for you to check during the debugging phase. Normally you would comment these two lines out once the messaging is working. It then uses the 'parseData' function to split each comer separated data out of the message and convert it into an integer and store it in the 'messagePrams' array.

Then, again for development, the extracted parameters are sent back to processing with the 'showParsedData' function. Again you might want to comment out this call once development is completed.

I have not shown how to handle floating point numbers, because basically most physical applications in the Arduino do not need them. When the do then they only require a limited number of decimal points. This is best done my multiplying the parameter you send from Processing, by say 100, and then dividing it by 100 when you extract it from the 'messagePrams' array and into the float value you want to use.

Finally, in the 'loop' function, a call is made to 'driveServos()' function. This simply checks to see if you are trying to drive a servo greater than the number you set (in this case 12) and the writes the angle to the servo.

To communicate from Arduino to Processing:-

/*
 * Sketch to get multi parameter messages from Processing
 * Do not open any serial or plotting monitors in the Arduino IDE
 * Any Serial.print messages will be sent to the Processing console
 * 
 * The number of variables sent, should match the numbers expected here.
 * 
 * the code here is for servos attached to the Arduino board. 
 * A Uno can only handle 12 servos so only S0 to S11 will work from processing
 * do not attempt to power any servos direct from the 5V pin of the Arduino
 * you need an external power supply capable of about 1A per servo.
 * 
 * by Mike Cook April 2023
 * In the public domain
 */

#include <Servo.h> 

Servo myservo[12];  // create servo object to control a servo 
 
int initVal = 90;  // initial angle to set the servos
byte servoPin[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};  // define what pins the servos are on

const int numberOfPrams = 2 ; // number of int values in one message
int messagePrams [numberOfPrams]; // place to hold values in the message
const int bufferSize = 20;
char incoming[bufferSize];  // buffer to hold message

void setup() {
  for(int i =0; i<12; i++){
    myservo[i].attach(servoPin[i]);  // attaches the servo on pin 2 to the servo object
    myservo[i].write(initVal);  // positions the servos to the same point
    // consider inserting a delay here if your power supply has trouble supplying enough curret
  }
  Serial.begin(57600); // to match the processing sketch
  delay(100); // let the serial port get up and running
}

void loop() {
  if(Serial.available() != 0)  { // got something to read
     Serial.readBytesUntil(13, incoming, bufferSize);
     // echo message to the processing console when uncommented
     Serial.print("received message from Processing ");
     Serial.println(incoming);
     parseData();
     showParsedData(); // comment out to hide what was extracted from the message
     // now do something with the received parameter values.
     driveServos();
  }
}

void parseData() {
    // split the data into its parts   
  char * strtokIndx; // this is used by strtok() as an index
  
  strtokIndx = strtok(incoming,",");      // get the first part - the string
  strcpy(incoming, strtokIndx); // copy data from processing 

  messagePrams[0] = atoi(strtokIndx);
  for(int i = 1; i < numberOfPrams ; i++){ // read the rest of the numbers in the message
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    messagePrams[i] = atoi(strtokIndx);     // convert this part to an integer
  } 
  /*
   // When sending float values as well they must be after the int values 
  strtokIndx = strtok(NULL, ","); 
  floatMessagePrams[0] = atof(strtokIndx);     // convert this part to a float
  */
}

void showParsedData() { // echo the results back to Processing
 for(int i = 0; i < numberOfPrams ; i++){
   Serial.print("Parameter ");
   Serial.print(i);
   Serial.print(" value is ");
   Serial.println( messagePrams[i] );
 } 
}
void driveServos(){
  // the code here is for servos attached to the Arduino board. 
  // do not attempt to power any servos direct from the 5V pin of the Arduino
  // you need an external power supply capable of about 1A per servo.
  // you can fit less than 16 servos if you like
  if( messagePrams[0] < 12){ // if less than the number of servos fitted
      myservo[messagePrams[0]].write(messagePrams[1]);
  }
}

Now how to use processing. This is what the interface looks like

Processing User Interface
Processing User Interface602×405 20 KB

The Processing Code:-

/**
 * Written for Processing V4.x
 * On mouse click
 * if the mouse is over a blue rectangle
 *     write the rectangle, number, and an angle number
 *     as a message to the serial port of an Arduino 
 *  For this demo code I show the control of 16 servos
 *  
 * This is demo code showing how to send multi parameter integer strings
 * from Processing to an Arduino. It is encouraged that you write your own code
 * to suit your own needs.
 *
 * By Mike Cook April 2023 - code is in the public domain
 */ 
 
import controlP5.*;
ControlP5 cp5;  // for the knob
ControlP5 cp6;  // for the bangs
Knob angle;    // the name of the Knob control to use

import processing.serial.*;
Serial port; // Create object from Serial class
String connectTo = "/dev/cu.usbmodem14201";  // the name of the serial port to use
Serial[] myPorts = new Serial[2]; // setup a list of ports Processing can see

int myColorBackground = color(0,0,0);
int knobValue = 90;  // initial value
int maxAngle = 180; // change as required
int minAngle = 0;   // change as required

void setup() {
  size(300, 180);
  smooth();
  noStroke();
  
  cp5 = new ControlP5(this);  
  angle = cp5.addKnob("angle")
               .setColorLabel(0)
               .setRange(minAngle,maxAngle)
               .setValue(knobValue)
               .setPosition(180,35)
               .setRadius(50) // size of the knob
               //.snapToTickMarks(true) // uncomment for snap
               .setNumberOfTickMarks(abs(maxAngle - minAngle) / 10) // just put a number in here if you are happy with that.
               .setTickMarkLength(4)
               .setColorForeground(color(255))
               .setColorBackground(color(0, 160, 100))
               .setColorActive(color(255,255,0))              
               .setDragDirection(Knob.VERTICAL) // direction for click + drag to change reading
               ;
  int bangID = 0;             
  cp6 = new ControlP5(this);
  for(int j=0; j<4; j++){
  for (int i=0; i<4; i++) {
    bangID = (j * 4) + i;
    cp6.addBang("s"+bangID)
       .setPosition(10+i*40, (40 * j) + 10)
       .setSize(25, 25) // size of the bang controls
       .setId(bangID)
       ;
    }
  }
// try and open the port named in the "connectTo" variable  
int portNumber = 99;
    String [] ports;
    printArray(Serial.list()); // comment out to skip showing list of all serial devices
    ports = Serial.list();
      for(int j = 0; j< ports.length; j++) { // go through all ports looking for ours
         if(connectTo.equals(Serial.list()[j])) portNumber = j;         
    } 
    if(portNumber == 99) portNumber = 0; // if we haven't found our port then connect to the first one
    String portName = Serial.list()[portNumber]; 
    println("Connected to "+portName);
    port = new Serial(this, portName, 57600); // must be the same as the receiving processor 
    port.bufferUntil(13);  // call serialEvent every Carriage Return 'CR'  
}

void draw() {
background(128);
}

void angle(int theValue){
    //println("an angle event "+theValue);
  knobValue = theValue; 
}
 
public void controlEvent(ControlEvent theEvent) {
  //print("the event is "+theEvent);
  if(theEvent.getController().getName().equals("angle") ){
    return;  // exit as we don't want to respond to knob events
  }
  // as there are only two controllers generating events so this must be a bang event
  // look to see which one generated the event
  for (int i=0; i< 16; i++) {
    if (theEvent.getController().getName().equals("s"+i)) {
      sendMessage(theEvent.getController().getId());     
     }
    }
}

void sendMessage(int number){
      port.write(str(number)); // Servo number (bang event)
      // repeat these next two lines for sending more data in the string.
      port.write(0x2C); // ASCII for comma ","
      port.write(str(knobValue)); // servo position
      // now end it with this
      port.write(0); // end of string marker
      port.write(13); // end of message marker  
}

// look for stuff from the Arduino so we can print it
void serialEvent(Serial port) {  // this gets called when something is received on the serial port
    String received = port.readString() ;  
    print(received + " -->from Arduino  ");
}

It is a lot to sort out but I hope it does, it has in the past.

2 Likes
14

:+1:

I must study it one day because I have not yet been able to make useful use of cp5 and usually give up after a few attempts to use it :slightly_frowning_face:

15

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.