I recently purchased an Arduino Mega 2560 because I felt that my I/Os were limited on my Duemilanove. I did not realize that the StandardFirmata does not work with the Mega, rendering the additional pins 22-53 unusable unless I write my own protocol, from my understanding.
Previously, I loaded the StandardFirmata on the Duemilanove and hooked up a series of rotary encoders and a joystick on pins 1-12 to control a Processing sketch that I am working on. This worked fine until I reached a point when I wanted to add more rotary encoders and a button, but with no more digital pins available, I decided to purchase a Mega.
Now I'm at a bit of a loss as to how to read and write to the Mega from my Processing sketch. I browsed the web and found a few threads explaining how the StandardFirmata is not compatible with the Mega, and that the pin mapping of the Mega differs from that of the Duemilanove. I found the Mega pin chart, but I don't know if I need to write my own protocol in Arduino to handle my I/O, or if there is a way to read and write to a Mega directly in Processing. Again, there aren't many examples or substantial libraries that accomplish this from what I found.
Forgive me for asking this for what may seem like the thousandth time, but I am very new to the world of Arduino. To be clear, here are my questions. First, what are the options for more than 12 digital I/O pins with Arduino, or how is it possible with the Mega? Second, if I proceed with the Mega, what's a simple example of a digitalRead(), digitalWrite(), or otherwise on pins 22-53?
I simply need Processing to turn pins on and off and to read digital pins. I'm not dealing with anything analog or interrupts at the moment. The Arduino doesn't do anything on it's own. I'm simply making a video game controller of sorts to control Processing directly.
In Processing, I define the pins as integers, and then run those through the arduino.digitalRead(pin#) method in draw() to detect changes and interaction with the knobs, buttons, and joystick. I haven't modified any pin mapping between Arduino and Processing, but I'm simply wondering how it's done. For instance, if I'm running a simple push-button LED light script in Processing, and my button is grounded and plugged in to pin #22, how do I get Processing to read it?
If Processing were to send something like "<R,14>", the Arduino could run code like this:
#define SOP '<'
#define EOP '>'
bool started = false;
bool ended = false;
char inData[80];
byte index;
void setup()
{
Serial.begin(57600);
// Other stuff...
}
void loop()
{
// Read all serial data available, as fast as possible
while(Serial.available() > 0)
{
char inChar = Serial.read();
if(inChar == SOP)
{
index = 0;
inData[index] = '\0';
started = true;
ended = false;
}
else if(inChar == EOP)
{
ended = true;
break;
}
else
{
if(index < 79)
{
inData[index] = inChar;
index++;
inData[index] = '\0';
}
}
}
// We are here either because all pending serial
// data has been read OR because an end of
// packet marker arrived. Which is it?
if(started && ended)
{
// The end of packet marker arrived. Process the packet
// Reset for the next packet
started = false;
ended = false;
index = 0;
inData[index] = '\0';
}
}
Where it says "Process the packet", inData would contain "R,14". The strtok() function could get the two tokens, "R" and "14", and convert the second one to an int. Then, it could read pin 14, and send a response.
You could have other commands, like "<W,35,0>" to write a 0 to pin 35, or "<M,22,I>" to set the mode of pin 22 to INPUT. Defining a protocol is relatively simple. Implementing it isn't all that challenging, either, for simple things.
If the encoder generates a lot of pulse close together, so that you need to use interrupts to deal with all the pulses, then reading the encoder value requires another command, and the value that was returned might be old before the transmission was complete.
That gives me somewhere to start, although I'm still having issues because my Processing sketch is massive. Let's use the basic code below as a simple example instead. How do I detect a button push on pin 22 and have Processing call "runThisMethod();"? From what you are describing, it sounds like all of my reads and writes are handled on the Arduino side of things, when in reality, I want to call methods within my Processing sketch as changes are made to what's hooked up to the Arduino board. Maybe my initial description was unclear, and if so, I apologize. StandardFirmata works perfectly on the Mega with my inputs for 1-12, but I feel like I need to modify the code to account for the remaining pins.
-Dahm
PROCESSING CODE
Simple pushbutton script:
import processing.serial.*;
import cc.arduino.*;
Arduino arduino;
int button = 22; //Ideally I want this to be digital pin 22 on the Mega
int ledPin = 13;
int buttonState = 1;
void setup()
{
size(400, 400);
arduino = new Arduino(this, Arduino.list()[0], 57600);
//Button init
arduino.pinMode(button, Arduino.INPUT);
arduino.digitalWrite(button, Arduino.HIGH);
//LED init
arduino.pinMode(ledPin, Arduino.OUTPUT);
}
void draw()
{
// read the state of the pushbutton value:
buttonState = arduino.digitalRead(button);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == Arduino.LOW)
{
// turn LED on:
arduino.digitalWrite(ledPin, Arduino.HIGH);
runThisMethod();
}
else
{
// turn LED off:
arduino.digitalWrite(ledPin, Arduino.LOW);
}
}
Of course the script wouldn't work... it was a crude example showing what I might expect a portion of the Processing code to execute. This seems to be the crux of my issue. I don't know how to ask the question any other way. With what code is this possible?
How do I use Processing to read a signal on pin X (22, in this hypothetical) that isn't already in the StandardFirmata? Again, I think this involves PaulS's suggestion of writing my own protocol for the Mega. How this interfaces with Processing is critical because that is where the events occur. If this is possible all in Processing, that's fine too.
How do I use Processing to read a signal on pin X (22, in this hypothetical) that isn't already in the StandardFirmata?
Simple. Ditch the reliance on Firmata. Develop your own functions in Processing and on the Arduino to send and receive commands that match your protocol.
Here's what I have so far. The light turns on and off with a button on pin 22! $)
Have a look at the sends on the Arduino side of things and tell me what the best practice is for writing changes to serial for Processing to read. Is it best to choose arbitrary numbers or strings in Arduino and then redefine them locally as I'm doing?
The println sending my turnCount variable to the Processing console text area doesn't seem to update every full turn. Maybe there are some tweaks to the code that can fix this.
