Arduino

4.Communication
These examples include code that allows the Arduino to talk to Processing sketches running on the
computer. For more information or to download Processing, see processing.org. There are also
Max/MSP patches that can communicate with each Arduino sketch as well. For more on Max/MSP
see Cycling 74. For Pd patches that can communicate with these sketches, see Scott Fitzgerald's
examples.
 ReadASCIIString: Parse a comma-separated string of ints to fade an LED.
 ASCII Table: Demonstrates Arduino's advanced serial output functions.
 Dimmer: Move the mouse to change the brightness of an LED.
 Graph: Send data to the computer and graph it in Processing.
 Physical Pixel: Turn a LED on and off by sending data to your Arduino from Processing or
Max/MSP.
 Virtual Color Mixer: Send multiple variables from Arduino to your computer and read them in
Processing or Max/MSP.
 Serial Call Response: Send multiple variables using a call-and-response (handshaking)
method.
 Serial Call Response ASCII : Send multiple variables using a call-and-response (handshaking)
method, and ASCII-encode the values before sending.
 SerialEvent: Demonstrates the use of SerialEvent().
 Serial input (Switch (case) Statement) : How to take different actions based on characters
received by the serial port.
 MIDI: Send MIDI note messages serially.
 MultiSerialMega: Use two of the serial ports available on the Arduino Mega.

Ing. Ronald N. Kopp Pá gina 1

Arduino
22. ReadASCIIString: Analiza una cadena de enteros separados por coma para atenuar un LED

Este bosquejo utiliza la función Serial.parseInt() para localizar valores separados por un carácter no
alfanumérico. A menudo, las personas utilizan una coma para indicar diferentes piezas de
información (este formato se conoce comúnmente como valores separados por comas), pero otros
caracteres como un espacio o un guion también se usan. Los valores se analizan en enteros y se
utilizan para determinar el color de un LED RGB. Vamos a usar el monitor serial para enviar cadenas
como "5,220,70" al Arduino para cambiar la luz del LED.

Hardware Required
 Arduino Board
 Breadboard
 Hookup wire
 Common anode RGB LED
 Three 220-ohm resistors

Circuit

Tendremos cinco cables para hacer el circuito anterior. Conectemos un cable rojo a una de las filas
largas verticales del protoborad y conectemos el otro extremo al pin de 5V de la placa Arduino.

Luego colocamos un LED RGB en el protoboard. Previamente comprobamos la hoja de datos

específica del LED para verificar los pines. Conectamos la línea de tensión al ánodo común en el LED.
Ing. Ronald N. Kopp Pá gina 2
Arduino
Y con los cables restantes, conecte el cátodo rojo al pin 3, el cátodo verde al pin 5, y el cátodo azul al
pin 6 en serie con las resistencias.

Los LEDs RGB con un ánodo común comparten un pin de alimentación común. En lugar de convertir
un pin a un nivel alto para iluminar el LED, se necesita convertir un nivel BAJO al pin, para crear una
diferencia de voltaje a través del diodo. Así que, si envíanos 255 a través analogWrite() apagará el
LED, mientras que un valor de 0 lo encenderá al máximo de su brillo. En el siguiente código, vamos a
usar un poco de matemáticas del lado Arduino, para que podamos enviar valores que se
correspondan con el brillo esperado. Esencialmente, en lugar de utilizar analogWrite(pin, brillo), se le
llamará analogWrite(pin, 255-brillo).

Ing. Ronald N. Kopp Pá gina 3

Arduino
Code
Primero configuraremos algunas variables globales para que los pines del LED puedan conectarse.
Esto hará que sea más fácil de diferenciar cuál es el rojo, verde y azul en la parte principal de nuestro
programa:
const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

En el setup(), comenzaremos la comunicación serial a 9600 bits de datos por segundo entre Arduino
y el ordenador con la línea:
Serial.begin(9600);

También en la configuración, tendremos que configurar los pines como salidas:

 pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
 pinMode(bluePin, OUTPUT);

A continuación, declararemos algunas variables locales para almacenar la información del monitor
serial. Esto será el brillo de los LEDs. Utilizando Serial.parseInt() para separar los datos por comas, y
de esta manera leer la información de nuestras variables:
int red = Serial.parseInt();
int green = Serial.parseInt();
int blue = Serial.parseInt();

Nombre Serial.parseInt()
Descripción Serial.parseInt() lee la información del monitor serial y devuelve el primer número
entero (de tipo long) válido a partir de la posición actual. Los caracteres iniciales que
no son enteros (o el signo menos) son ignorados. Serial.parseInt() termina cuando se
encuentra el primer carácter que no es un dígito.
Sintaxis Serial.parseInt()

Una vez que hemos leídos los datos de las variables, comprobamos que el carácter es un salto de
línea, para continuar:
if (Serial.read() == '\n') { // if (Serial.read() == -1) {

Con el uso constrain(), puede mantenerse los valores en un rango aceptable para el control PWM. De
esta manera, si el valor esta fuera del rango PWM (0-255), se limita a un valor válido. Restando a 255
este valor, obtendremos un valor apropiado para ser usado con un LED de ánodo común. Como se
explicó anteriormente, estos LEDs se iluminan cuando hay una diferencia de voltaje entre el ánodo y
el pin conectado al Arduino:
     red = 255 - constrain(red, 0, 255);
     green = 255 - constrain(green, 0, 255);
     blue = 255 - constrain(blue, 0, 255);

Ing. Ronald N. Kopp Pá gina 4

Arduino
Ahora que hemos dimensionado los valores de PWM, utilizaremos analogWrite() para cambiar el
color del LED. Debido a que restamos su valor de 255 en el paso anterior:
     analogWrite(redPin, red);
     analogWrite(greenPin, green);
     analogWrite(bluePin, blue);

Enviamos el valor de cada LED de nuevo al monitor serial en una cadena de valores HEX:
     Serial.print(red, HEX);
     Serial.print(green, HEX);
     Serial.println(blue, HEX);

Por último, cerramos la llave de las sentencias if, while, y el bucle principal:
    }
  }
}

Una vez que hayamos programado el Arduino, abrimos nuestro monitor serial. Asegurándonos de
que hemos elegido enviar una nueva línea de caracteres al enviar un mensaje. Introducimos valores
entre 0-255 para que alumbren en el siguiente formato: Rojo, Verde, Azul. Una vez que hayamos
enviado los valores al Arduino, el LED conectado encenderá el color especificado, y nosotros
recibiremos los valores HEX en el monitor serial.

// pin de las patas del LED:

const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

void setup() {
 Serial.begin(9600); // comenzamos la comunicación serial

// configuramos a los pines como salidas:

 pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
 pinMode(bluePin, OUTPUT);
}

void loop() {
 while (Serial.available() > 0) { // mientras haya algo en el serial disponible, lo leemos

   int red = Serial.parseInt(); // buscamos el siguiente entero valido en el flujo

// entrante de datos del puerto serial
   int green = Serial.parseInt(); // lo hacemos de nuevo
   int blue = Serial.parseInt(); // lo hacemos de nuevo

Ing. Ronald N. Kopp Pá gina 5

Arduino

   if (Serial.read() == '\n') { // buscamos una nueva línea. Sí es así, eso indicara
// el final de nuestra sentencia

// restringimos los valores de 0 a 255 e invertimos dicho valor

// "255 -constrain(color, 0, 255);" debido a que estamos usando un LED de cátodo común
     red = 255 - constrain(red, 0, 255);
     green = 255 - constrain(green, 0, 255);
     blue = 255 - constrain(blue, 0, 255);

// iluminamos la pata roja, verde y azul de los LEDs:

     analogWrite(redPin, red);
     analogWrite(greenPin, green);
     analogWrite(bluePin, blue);

// imprimimos los tres números en una cadena como hexadecimal:

     Serial.print(red, HEX);
     Serial.print(green, HEX);
     Serial.println(blue, HEX);
   }
 }
}

if (Serial.read() == '\n') {

Ing. Ronald N. Kopp Pá gina 6

Arduino

Ing. Ronald N. Kopp Pá gina 7

Arduino
23. ASCII Table: Demuestra funciones avanzada del Arduino para la salida del puerto serial.

Este bosquejo demuestra las funciones avanzadas de impresión del puerto serial, mediante la
generación de una tabla de caracteres y sus valores ASCII en decimal, hexadecimal, octal y binario.

Hardware Required
 Arduino Board

Circuit

Tener en cuenta que el Arduino debe estar conectado a la computadora

Ing. Ronald N. Kopp Pá gina 8

Arduino
ASCII significa Código Estándar Americano para el Intercambio de Información. Los ordenadores sólo
pueden entender los números, por lo que un código ASCII es la representación numérica de un
carácter como 'a' o '@' o una acción de algún tipo.

TABLA ASCII

TABLA ASCII EXTENDIDA

Ing. Ronald N. Kopp Pá gina 9

Arduino
Código

void setup() {
 Serial.begin(9600); //comenzamos la comunicación serial y
// esperamos por la apertura del puerto serial:
 while (!Serial) {
   ; // espera por el puerto serial para conectar
 }
 
 Serial.println("ASCII Table ~ Character Map"); // imprimimos el titulo con un salto de línea al final
}

int thisByte = 33; // el primer carácter visible ASCII '!' es el número 33:

// También podemos escribir el carácter ASCII entre comillas simples.

// Por ejemplo. '!' que es lo mismo que 33, por lo que también podríamos utilizar esta forma:
// Int thisByte = '!';

void loop() {
// escribimos el valor inalterado, es decir, la versión binaria pura del Byte en el monitor serial
// El monitor serie interpreta todos los bytes como ASCII, por lo que el 33, se mostrará como '!'
  Serial.write(thisByte);    

 Serial.print(", dec: ");

 Serial.print(thisByte); // imprimimos el valor como una cifra decimal en código ASCII (base 10)
// la base decimal es el formato predeterminado
// para Serial.print() y Serial.println(),
// Por lo que no se necesita ningún modificador
 

// pero nosotros podríamos enunciar el modificador para el sistema decimal, si lo quisiéramos

// esto sería:
// Serial.print(thisByte, DEC);  

 Serial.print(", hex: ");

  Serial.print(thisByte, HEX); // imprimimos el valor en hexadecimal (base 16):

 Serial.print(", oct: ");

Serial.print(thisByte, OCT); // imprimimos el valor en octal (base 8);

 Serial.print(", bin: ");

 Serial.println(thisByte, BIN); // imprimimos el valor en binario (base 2)
// y también hacemos un salto de línea con println:

Ing. Ronald N. Kopp Pá gina 10

Arduino

 if(thisByte == 126) {      // sí imprime el último carácter visible '~' o 126 se detiene
while(true) { // este bucle, ya que se recorre por siempre, y no hace nada
    continue;
   } // podríamos haber utilizado también (thisByte == '~') {
 }

 thisByte++; // pasamos al siguiente carácter

}

cuando utilizo la palabra continue dentro de un bucle lo que viene a continuación se ignora
while(true) → se va cumplir siempre
while(false) →no se va a cumplir nunca

Ing. Ronald N. Kopp Pá gina 11

Arduino

24. Dimmer: Mover el mouse para cambiar el brillo de un LED.

Este ejemplo muestra cómo enviar datos desde un ordenador personal a una placa Arduino para
controlar el brillo de un LED. Los datos se envían en bytes individuales, cada uno de los cuales se
extiende entre un valor de 0 a 255. Arduino lee estos bytes y los utiliza para ajustar el brillo del LED.

Podemos enviar bytes al Arduino desde cualquier software que pueda acceder al puerto serie del
ordenador. Por ejemplos Processing y Max/MSP version 5 los cuales se muestran a continuación.

Hardware Required
 Arduino Board
 LED
 220 ohm resistor

Software Required
 Processing or
 Max/MSP version 5

Circuit
Conectemos un LED al pin 9. Para ello usemos una resistencia de 220 o 330 Ohm en serie con el LED.

Ing. Ronald N. Kopp Pá gina 12

Arduino

Schematic

Ing. Ronald N. Kopp Pá gina 13

Arduino

Code

const int ledPin = 9; //pin al que el LED está conectado

void setup() {
 Serial.begin(9600); // comenzamos la comunicación serial:
 pinMode(ledPin, OUTPUT); // configuramos el ledPin como una salida:
}

void loop() {
 byte brightness;   // declaramos la variable brightness como un tipo de dato byte

 if (Serial.available()) {    // comprobamos si los datos han sido enviados desde la PC y

// leemos el byte más reciente (que será desde 0 a 255)
   brightness = Serial.read();
  
   analogWrite(ledPin, brightness); // establecemos el brillos del LED
 }
}

Nombre byte
Ejemplo byte a;         // Declara la variable "a" de tipo byte
a = 23;         // Asigna a "a" el valor 23
byte b = 128;   // Declara la variable "b" y le asigna el valor 128
byte c = a + b; // Declara la variable "c" y le asigna la suma de "a" y "b”
Descripción Tipo de datos para bytes, 8 bits de información que almacena valores numéricos de
0 a 255. Bytes son un tipo de dato conveniente para enviar información hacia y
desde el puerto serial y para representar letras en un formato más simple que el tipo
de dato char
Sintaxis byte Var
byte Var = Valor
Parámetros Var Nombre de la variable representando el valor
Valor Un número entre 0 y 255

Mediante el programa processing hacemos un rectángulo de 256 x 150, con un degrade entre blanco
y negro en dirección del eje X. Entonces al mover el mause sobre éste rectángulo enviamos bytes a la
placa Arduino para cambiar el brillo del LED. El código en prosessing es el siguiente:

Ing. Ronald N. Kopp Pá gina 14

Arduino

import processing.serial.*; //cargamos la librería serial de processing

 Serial port;    //
 
 void setup() {
 size(256, 150); // determina el ancho y alto de la pantalla
 
 println("Available serial ports:");
 println(Serial.list()); // muestra todos los puertos seriales disponibles

// El parámetro Serial.list () [0] utiliza el primer puerto disponible a partir de 0
// Cambiemos esto al puerto correspondiente de la placa Arduino si lo conocemos,
// en nuestro caso "COM3" (sino puede utilizar otro por ej. el COM1).
// El parámetro 9600 es la velocidad de comunicación, 
// esta tiene que corresponder con el valor usado en Serial.begin() 
// anteriormente en nuestro boceto Arduino.
// port = new Serial(this, Serial.list()[0], 9600);
// como nosotros conocemos el puerto y la velocidad de comunicación, la línea anterior cambia a:
port = new Serial(this, "COM3", 9600); // abrimos el puerto Serial
 }
 
 void draw() {
 for (int i = 0; i < 256; i++) {  // dibujamos un degradado de negro a blanco
 stroke(i); // configura el color para dibujar líneas y bordes alrededor de una figura
 line(i, 0, i, 150); // dibuja una línea entre dos puntos en la pantalla (x1, y1, x2, y2)
 }
 
 port.write(mouseX); // escribimos la posición X actual del ratón, en puerto serie, como un solo byte

 }

Processing librerías
PDF Export
Create PDF files. These vector graphics files can be scaled to any size and printed at high resolutions

Serial
Send data between Processing and external hardware through serial communication (RS-232)

Video
Read images from a camera, play movie files, and create movies

Ing. Ronald N. Kopp Pá gina 15

Arduino

Network
Send and receive data over the Internet through simple clients and servers

DXF Export
Create DXF files to save geometry for loading into other programs. It works with triangle-based
graphics including polygons, boxes, and spheres

Sound
Playback audio files, audio input, synthesize sound, and effects

1 byte = 8 bits = 00010100 = 256 combinaciones posibles = -128 a 127 (sale de dividir 256/2 y
considera el cero
Tipo de dato: byte tamaño = 8 bits
Tipo de dato: short tamaño = 16 bits
Tipo de dato: int tamaño = 32 bits
Tipo de dato: long tamaño = 64 bits

Ing. Ronald N. Kopp Pá gina 16

Arduino

Ing. Ronald N. Kopp Pá gina 17

Arduino

25. Graph: Enviar datos al ordenador y representarla gráficamente en Processing.

Este ejemplo muestra cómo enviar un byte de datos desde el Arduino a un ordenador personal y
representar gráficamente el resultado. A esto se lo llama comunicación serie, porque la conexión
entre el Arduino y el ordenador se realiza por el puerto serie, a pesar de que en realidad se utiliza un
cable USB.

Se puede utilizar el monitor serial Arduino para ver los datos enviados, o puede ser leído por
Processing (ver el código de abajo), Flash, PD, Max / MSP, etc.

Hardware Required
 Arduino Board
 Analog Sensor (potentiometer, photocell, FSR, etc.)

Software Required
 Processing or
 Max/MSP version 5

Circuit
Conectamos un potenciómetro u otro sensor analógico a la entrada analógica 0.

Ing. Ronald N. Kopp Pá gina 18

Arduino

Schematic

Ing. Ronald N. Kopp Pá gina 19

Arduino

Code

void setup() {
 Serial.begin(9600); // comenzamos la comunicación serial:
}

void loop() {

 Serial.println(analogRead(A0));  // Envíanos el valor de la entrada analógica

// esperamos un rato para la conversión analógica a digital y
// para estabilizar el sistema después de la última lectura
 delay(2);
}

Ing. Ronald N. Kopp Pá gina 20

Arduino

import processing.serial.*;
Serial port;

 Serial myPort; // inicializamos el puerto serie

 int xPos = 1; // posición horizontal de la gráfica al comenzar
 
void setup () {
  size(400, 300); // configuramos el ancho y alto de la pantalla
  println(Serial.list()); // listamos todos los puertos series disponibles
  myPort = new Serial(this, "COM3", 9600); // abrimos el puerto que estamos usando para el Arduino
  myPort.bufferUntil('\n');   // no generar un serialEvent() a menos que tengamos
// una nueva línea de caracteres
  background(0); // configuramos el color del fondo:
 }
 
void draw () {
  // ejecutamos todo lo que pasa a partir de la entrada de datos a través del serialEvent()
 }
 
void serialEvent (Serial myPort) {
 String inString = myPort.readStringUntil('\n'); // obtenemos los datos en una cadena de ASCII
  if (inString != null) { // recortamos cualquier espacio en blanco
   inString = trim(inString);
  float inByte = float(inString);  // lo convertimos a un float
  inByte = map(inByte, 0, 1023, 0, height); // y lo mapeamos a una altura en la pantalla
  stroke(127,34,255); // dibujamos la línea
  line(xPos, height, xPos, height - inByte); // el eje “Y” positivo va hacia abajo y el “X” a la derecha
 
  if (xPos >= width) { // sí estamos en el borde de la pantalla, que regrese de nuevo al comienzo
  xPos = 0;
  background(0);
  }
  else {  // de otra forma incrementamos la posición horizontal
  xPos++;
  }
  }
}

Ing. Ronald N. Kopp Pá gina 21

Arduino
line(30, 20, 85, 20);
stroke(126);
line(85, 20, 85, 75);
line(30, 20, 85, 75);
stroke(255);
line(85, 75, 30, 75);

stroke(89,151,126);

Ing. Ronald N. Kopp Pá gina 22

Arduino
26. Physical Pixel: cambiar un LED de encendido a apagado mediante el envío de datos a nuestro
Arduino procedentes de Prossesing o Max / MSP.

En este ejemplo se utiliza la placa Arduino para recibir datos desde el ordenador. La placa Arduino se
encenderá el LED cuando recibe el carácter 'H', y se apagará el LED cuando recibe el carácter 'L'.

Los datos pueden ser enviados desde el monitor Arduino serie, u otro programa como Processing
(ver código de abajo), Flash (a través de un proxy de serie-net), PD, o Max

Hardware Required
 Arduino Board
 Analog Sensor (potentiometer, photocell, FSR, etc.)

Software Required
 Processing or
 Max/MSP version 5

Circuit
Conectar un LED al pin 13. La pata más larga, o ánodo, va al pin 13. La pata más corta, o cátodo, va a
tierra. También se puede utilizar el built-in LED en la mayoría de las placas Arduino.

Ing. Ronald N. Kopp Pá gina 23

Arduino
Schematic

Ing. Ronald N. Kopp Pá gina 24

Arduino
Code

const int ledPin = 13; // el pin al cual el LED está conectado

int incomingByte; // variable para leer los datos que entran al serial

void setup() {
// comenzamos la comunicación serial:
Serial.begin(9600);

// configuramos el LED pin como una salida:

pinMode(ledPin, OUTPUT);
}

void loop() {
// vemos si hay datos entrando en el puerto serial:
if (Serial.available() > 0) {

// leemos el byte en el buffer serial:

incomingByte = Serial.read();

// si es una H mayúscula (ASCII 72), enciende el LED:

if (incomingByte == 'H') {
digitalWrite(ledPin, HIGH);
}

// si se trata de una L (ASCII 76) apaga el LED:

if (incomingByte == 'L') {
digitalWrite(ledPin, LOW);
}
}
}

Código en processing
Cuando se pasa el ratón sobre el cuadrado central, el LED en el pin 13 debe encenderse y apagarse

import processing.serial.*;

float boxX;
float boxY;
int boxSize = 20;
boolean mouseOverBox = false;

Serial port;

Ing. Ronald N. Kopp Pá gina 25

Arduino

void setup() {
size(200, 200); // tamaño de la pantalla
boxX = width/2.0;
boxY = height/2.0;
rectMode(RADIUS); //configura el rectMode en Radio, es decir que el tamaño de la caja será el doble

// listamos todos los puertos series disponibles

println(Serial.list());
// abrirmos el puerto que estamos usando.
port = new Serial(this, "COM3", 9600);
}

void draw()
{
background(0);
// dibujamos la caja
rect(boxX, boxY, boxSize, boxSize);

// comprobamos si el cursor esta sobre la caja

if (mouseX > boxX-boxSize && mouseX < boxX+boxSize &&
mouseY > boxY-boxSize && mouseY < boxY+boxSize) {
mouseOverBox = true;

// dibujamos una línea alrededor de la caja y cambiamos su color:

stroke(255); // configura el color para dibujar líneas y bordes alrededor de una figura
fill(153); // configura el color utilizado para llenar una figura

// enviar una 'H' para indicar que el mause esta sobre le cuadrado:
port.write('H');
}
else { // de otro modo, o sea al no estar el cursor sobre la caja
// devolver la caja a su estado inactivo:
stroke(153);
fill(153);

// envíar una 'L' para apagar el LED:

port.write('L');
mouseOverBox = false;
}
}

Ing. Ronald N. Kopp Pá gina 26

Arduino

Ing. Ronald N. Kopp Pá gina 27

Arduino
27. Virtual Color Mixer: enviar múltiples variables desde el Arduino al ordenador y leerlo en
Processing o Max/MSP.

Este ejemplo muestra cómo enviar múltiples valores de la placa Arduino al ordenador. Las lecturas de
los tres potenciómetros se utilizan para establecer los componentes rojo, verde y azul del color de
fondo de un boceto en Processing o Max/MSP

Hardware Required
 Arduino Board
 (3) Analog Sensors (potentiometer, photocell, FSR, etc.)
 (3) 10K ohm resistors
 breadboard
 hook-up wire

Software Required
 Processing or
 Max/MSP version 5

Circuit
Conectamos los sensores analógicos a los pines analógicos de entrada 0, 1 y 2.

Este circuito utiliza tres subcircuitos divisores de tensión para generar tensiones analógicas a partir
de los sensores de fuerza resistivos. Un divisor de tensión tiene dos resistencias en serie, dividiendo
la tensión de forma proporcional a sus valores.

Ing. Ronald N. Kopp Pá gina 28

Arduino
Schematic

Ing. Ronald N. Kopp Pá gina 29

Arduino
Code
Los valores de los sensores se envían desde el Arduino al ordenador como números decimales
codificados en ASCII. Esto significa que cada número se envía utilizando los caracteres ASCII dede "0"
al "9". Para el valor "234", por ejemplo, se envían tres bytes: ASCII "2" (valor binario 50), ASCII "3"
(valor binario 51), y ASCII "4" (valor binario 52).

const int redPin = A0; // sensor para controlar el color rojo

const int greenPin = A1; // sensor para controlar el color verde
const int bluePin = A2; // sensor para controlar el color azul

void setup()
{
Serial.begin(9600);
}

void loop()
{
Serial.print(analogRead(redPin));
Serial.print(",");
Serial.print(analogRead(greenPin));
Serial.print(",");
Serial.println(analogRead(bluePin));
}

import processing.serial.*;

float redValue = 0; // valor rojo

float greenValue = 0; // valor verde
float blueValue = 0; // valor azul

Serial myPort;

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

// lista todos los puertos series disponibles

println(Serial.list());
// abro el puerto que estamos usando.
myPort = new Serial(this, "COM3", 9600);

// no generar un serialEvent() a menos que tengamos un nueva línea de caracteres:

Ing. Ronald N. Kopp Pá gina 30

Arduino

myPort.bufferUntil('\n');
}

void draw() {
// configuramos el color del fondo con los valores:
background(redValue, greenValue, blueValue);
}

void serialEvent(Serial myPort) {

// obtenemos una cadena de ASCII:
String inString = myPort.readStringUntil('\n');

if (inString != null) {
// recortamos cualquier espacio en blanco:
inString = trim(inString);

 // Dividimos la cadena en las comas y

// convertimos la resultantes sub-cadenas en un array de enteros
float[] colors = float(split(inString, ","));

// si el array tiene por lo menos tres elementos, sabemos que está completo
// y podemos poner los números en la variables de color
if (colors.length >=3) {

// mapeamos a un rango entre 0-255:

redValue = map(colors[0], 0, 1023, 0, 255);
greenValue = map(colors[1], 0, 1023, 0, 255);
blueValue = map(colors[2], 0, 1023, 0, 255);
}
}
}

Ing. Ronald N. Kopp Pá gina 31

Arduino

Ing. Ronald N. Kopp Pá gina 32

Arduino
28. Serial Call Response: enviar múltiples variables usando el método de llamada y respuesta
(apretón de manos).

Este ejemplo demuestra la comunicación multi-byte de la placa Arduino con el ordenador mediante
el método de llamada y respuesta (apretón de manos).

Este bosquejo envía un ASCII A (byte de valor 65) en el inicio y repite esto hasta que recibe una
respuesta del puerto serie de la computadora. Luego se envía tres valores de los sensores como
bytes individuales, y se espera otra respuesta de la computadora.

Podemos utilizar el monitor serial Arduino para ver los datos enviados, o puede ser leído por
Processing (ver código de abajo), Flash, PD, Max / MSP (ver siguiente ejemplo), etc.

Hardware Required
 Arduino Board
 (2) analog sensors (potentiometer, photocell, FSR, etc.)
 (1) momentary switch/button
 (3) 10K ohm resistors
 breadboard
 hook-up wire

Software Required
 Processing or
 Max/MSP version 5

Circuit
Conectamos los sensores analógicos a los pines de entrada analógico 0 y 1, con resistencias de 10K
ohmios, que se utilizan como divisores de tensión. Conectemos un pulsador o interruptor al pin
digital de E/S 2, con una resistencia 10 Kohm como referencia a tierra.

Ing. Ronald N. Kopp Pá gina 33

Arduino
Schematic

Ing. Ronald N. Kopp Pá gina 34

Arduino
Code

int firstSensor = 0; // primer sensor analógico

int secondSensor = 0; // segundo sensor analógico
int thirdSensor = 0; // sensor digital
int inByte = 0; // byte serial entrante

void setup()
{
// comenzamos comunicación a través del puerto serial a 9600 bps:
Serial.begin(9600);
while (!Serial) {
; // esperar a que el puerto serial esté conectado
}

pinMode(2, INPUT); // inicializamos el pin 2 como una entrada

establishContact(); // enviar un byte para establecer contacto hasta que el receptor responda
}

void loop()
{

// si conseguimos un byte valido leer entradas analógicas:

if (Serial.available() > 0) {

// obetenemos el byte entrante:

inByte = Serial.read();

// leer la primera entrada analógica, dividir por 4 para hacer un rango 0-255:
firstSensor = analogRead(A0)/4;

// retardo de 10ms para dejar que el ADC se recupere:

delay(10);

// leer la segunda entrada analógica, dividir por 4 para hacer un rango 0-255:
secondSensor = analogRead(A1)/4;

// leer el pulsador y mapearlo de 0-255

thirdSensor = map(digitalRead(2), 0, 1, 0, 255);

// enviar valores de los sensores:

Serial.write(firstSensor);
Serial.write(secondSensor);
Serial.write(thirdSensor);
}

Ing. Ronald N. Kopp Pá gina 35

Arduino

void establishContact() {
while (Serial.available() <= 0) {
Serial.print('A'); // enviar la A mayúscula
delay(300);
}
}

import processing.serial.*;

int bgcolor; // color de fondo

int fgcolor; // color de relleno
Serial myPort; // el puerto serial
int[] serialInArray = new int[3]; // donde vamos a poner lo que recibimos
int serialCount = 0; // un recuento de la cantidad de bytes que recibimos
int xpos, ypos; // posición inicial de la pelota
boolean firstContact = false; // si hemos hecho contacto con el microcontroller

void setup() {
size(256, 256); // tamaño del escenario
noStroke(); // no dibujar el borde en el próximo dibujo

// configurar la posición inicial de la pelota (centro del escenario)

xpos = width/2;
ypos = height/2;

// listamos todos los puertos series disponibles

println(Serial.list());
// abrimos el puerto que estamos usando para el arduino.
myPort = new Serial(this, "COM3", 9600);
}

void draw() {
background(bgcolor);
fill(fgcolor);
// dibujamos la figura, una elipse
ellipse(xpos, ypos, 20, 20);
}

void serialEvent(Serial myPort) {

// leer un byte desde el puerto serie:
int inByte = myPort.read();

Ing. Ronald N. Kopp Pá gina 36

Arduino

// Si este es el primer byte recibido, y es un A,

// Borrar el serial búfer y tener en cuenta que hemos tenido
// primer contacto desde el microcontrolador.
// En caso contrario, agregar el byte de entrada a la matriz:
if (firstContact == false) {
if (inByte == 'A') {
myPort.clear(); // borrar el buffer del puerto serial
firstContact = true; // hemos tenido el primer contacto del microcontrolador
myPort.write('A'); // pedir más
}
}
else {
// Añadir el último byte del puerto serie al array:
serialInArray[serialCount] = inByte;
serialCount++;

// Si tenemos 3 bytes:
if (serialCount > 2 ) {
xpos = serialInArray[0];
ypos = serialInArray[1];
fgcolor = serialInArray[2];

// Imprimir los valores (sólo con fines de depuración):

println(xpos + "\t" + ypos + "\t" + fgcolor);

// Imprimir los valores (sólo con fines de depuración):

myPort.write('A');
// Resetea serialCount:
serialCount = 0;
}
}
}

Ing. Ronald N. Kopp Pá gina 37

Arduino
Sin apretar el pulsador

Apretando el pulsador

Ing. Ronald N. Kopp Pá gina 38

Arduino
Apretando el pulsador y moviendo uno de los potenciómetros

Con uno potenciómetro muevo la pelota en el eje X, con el otro potenciómetro lo muevo en el eje Y;
y con el pulsador veo la pelota.

Ing. Ronald N. Kopp Pá gina 39

Arduino
29. Serial Call Response ASCII: enviar múltiples variables usando el método de llamada y respuesta
(apretón de manos). Y codificar los valores en ASCII antes de enviarlos

Este ejemplo demuestra la comunicación basada en cadena (String), entre la placa Arduino y el
ordenador utilizando el método de respuesta y llamada (apretón de manos).

El boceto envía una cadena ASCII en el comienzo y lo reitera hasta que se obtenga una respuesta en
el puerto serie de la computadora. Luego se envía tres valores de los sensores como números ASCII-
codificado, separados por comas y terminadas por un salto de línea y retorno de carro, y se espera
otra respuesta del equipo.

Podemos utilizar el monitor serial del Arduino para ver los datos enviados, o puede ser leído por
Procesamiento (ver código de abajo), Flash, PD, Max / MSP (ver siguiente ejemplo), etc. El ejemplo a
continuación separa el String en las comas y convertir la cadena en un número otra vez.

Comparemos este ejemplo con el ejemplo Serial Call Response. Son similares, en tanto que utilizan
un método de establecimiento de comunicación, pero éste codifica las lecturas del sensor como
cadenas, mientras que el otro los envía como valores binarios. Al enviar como cadenas ASCII
codificados toma más bytes, significa que podemos enviar fácilmente valores mayores que 255 de la
lectura de cada sensor. También es más fácil de leer en un programa de terminal serie.

Hardware Required
 Arduino Board
 (2) analog sensors (potentiometer, photocell, FSR, etc.)
 (1) momentary switch/button
 (3) 10K ohm resistors
 breadboard
 hook-up wire

Software Required
 Processing or
 Max/MSP version 5

Ing. Ronald N. Kopp Pá gina 40

Arduino
Circuit
Conectamos los sensores analógicos a los pines de entrada analógico 0 y 1, con resistencias de 10K
ohmios, que se utilizan como divisores de tensión. Conectemos un pulsador o interruptor al pin
digital de E/S 2, con una resistencia 10 Kohm como referencia a tierra.

Ing. Ronald N. Kopp Pá gina 41

Arduino
Schematic

Ing. Ronald N. Kopp Pá gina 42

Arduino
Code

int firstSensor = 0; // primer sensor analógico

int secondSensor = 0; // segundo sensor analógico
int thirdSensor = 0; // sensor digital
int inByte = 0; // byte serial entrante

void setup()
{
// comenzamos comunicación a través del puerto serial a 9600 bps:
Serial.begin(9600);
while (!Serial) {
; // esperar a que el puerto serial esté conectado
}

pinMode(2, INPUT); // inicializamos el pin 2 como una entrada

establishContact(); // enviar un byte para establecer contacto hasta que el receptor responda
}

void loop()
{

// si conseguimos un byte valido leer entradas analógicas:

if (Serial.available() > 0) {

// obetenemos el byte entrante:

inByte = Serial.read();

// leer la primera entrada analógica:

firstSensor = analogRead(A0);

// leer la segunda entrada analógica:

secondSensor = analogRead(A1);

// leer el pulsador y mapearlo de 0-255

thirdSensor = map(digitalRead(2), 0, 1, 0, 255);

// enviar valores de los sensores:

Serial.print(firstSensor);
Serial.print(",");
Serial.print(secondSensor);
Serial.print(",");
Serial.println(thirdSensor);
}
}

Ing. Ronald N. Kopp Pá gina 43

Arduino

void establishContact() {
while (Serial.available() <= 0) {
Serial.println("0,0,0"); // enviar un string inicial
delay(300);
}
}

Un string lo debo escribir entre comillas doble ("0,0,0"). eso significa que es un tipo de dato cadena
seria un conjunto de caracteres que conformar una palabra
Los char lo debo escribir entre comilla simple ('A')

Nombre String
Ejemplo // declara s1 con un string inicial
String s1 = String("string numero uno");
byte bytes[20]; // arreglo de bytes
char array[20]; // arreglo de caracteres

void setup() {
Serial.begin(9600);
// Enciende el LED de la tarjeta Wiring
pinMode(WLED, OUTPUT);
digitalWrite(WLED, HIGH);

// s2 contiene "10000"
String s2 = String(10000);
Serial.println("s2 contiene: " + s2);

// s3 contiene "567000"
String s3 = String(567000, DEC);
Serial.println("s3 contiene: " + s3);

// s4 contiene "string numero cuatro"

String s4 = "string numero cuatro";
Serial.println("s4 contiene: " + s4);

// use el operador + para adicionar un string

s4 += " mas otra parte";
// use el operador + cuando imprime en el serial
Serial.println("ahora s4 contiene: " + s4);

// tomar el caracter en la posicion 5

char c = s4.charAt(5);
Serial.print("c contiene: ");
Serial.println(c); // imprime 'g'

Ing. Ronald N. Kopp Pá gina 44

Arduino
// s5 contiene "string numero uno"
String s5 = String("string numero uno");

int cmp = s1.compareTo(s5); // compara s1 y s5

if (cmp == 0) {
Serial.println("s1 y s5 son iguales"); // imprime igual
} else {
Serial.println("s1 y s5 son direfentes");
}

// controla si s5 termina en "uno"

if (s5.endsWith("uno"))
// imprime "s5 termina con "uno""
Serial.println("s5 termina con "uno"");

if (s1.equals(s5)) // controla si s1 es igual a s5

Serial.println("s1 y s5 son iguales"); // imprime igual

// s6 contiene "string numero uno"

String s6 = String("string numero uno");
// controla si s5 y s6 son iguales ignorando la diferencia entre mayusculas y
minusculas
if (s5.equalsIgnoreCase(s6))
// imprime igual
Serial.println("s6 y s5 son iguales ignorando mayusculas y minusculas");

Serial.print("indice del caracter R en s6 es:");

Serial.println(s6.indexOf('R'), DEC); // imprime -1

Serial.print("index of char R on s6 from index 13 is: ");

// imprime -1, no encontrado
Serial.println(s6.indexOf('R', 13), DEC);

String s7 = s6.substring(7, 14);

Serial.println("s7 es: "+s7); // imprime "numero"

Serial.print("indice del string "numero" en s6 es: ");

Serial.println(s6.indexOf(s7), DEC); // imprime 7

Serial.print("ultimo indice del caracter 'n' en s6 es:");

Serial.println(s6.lastIndexOf('n'), DEC); // imprime 15

Serial.print("la longitud de s6 es: ");

Serial.println(s6.length(), DEC); // imprime 17

// asigna el caracter en el indice 15 como 'N'

s6.setCharAt(15, 'N');

Ing. Ronald N. Kopp Pá gina 45

Arduino
// omprime "string numero uNo"
Serial.println("s6 es: "+s6);

// controla si s6 empieza con "string"

if (s6.startsWith("string"))
// s6 empieza con el string "string"
Serial.println("s6 empieza con "string"");

// imprime "string numero uno"

s6.toLowerCase();
Serial.println("s6 en minusculas es: "+s6);

// imprime "STRING NUMERO UNO"

s6.toUpperCase();
Serial.println("s6 en mayusculas es: "+s6);

s6.concat(" mas espacio al final "); // concatena un string

// imprime "STRING NUMERO UNO mas espacio al final "
Serial.println("s6 es: "+s6);

// imprime "STRING NUMERO UNO mas espacio al final"

s6.trim();
Serial.println("trim de s6 es: "+s6);

// imprime "STRING NUMERO UNO mas espaci5 al final"

s6.replace('o', '5');
Serial.println("s6 es: "+s6);

// toma el arreglo bytes y lo convierte en un arreglo de bytes

s6.getBytes(bytes, 20);
Serial.print("arreglo bytes es: ");
for (int i=0; i<20; i++) {
// imprime "S T R I N G N U M E R O U N O m"
Serial.write(bytes[i]);
Serial.print(" ");
}
Serial.println();
Serial.print("arreglo array es: ");
s6.toCharArray(array, 20);
Serial.println(array); // imprime "STRING NUMERO UNO m"
}

void loop() {

}
Descripción Un string es una cadena de caracteres. La clase String incluye métodos para examinar
caracteres individuales, comparar strings, buscar strings, extraer partes de un string, y

Ing. Ronald N. Kopp Pá gina 46

Arduino
para convertir un string entero de mayúsculas a minúsculas. Los Strings son siempre
definidos dentro de comillas dobles ("Abc") y los caracteres son siempre definidos
dentro de comillas simples ('A').

Note que la clase de Wiring String tiene diferencias con la clase String de processing o
Java. La principal diferencia es que algunos métodos modifican el string actual en vez
de devolver una copia modificada de él.
Métodos charAt() Devuelve el carácter en un índice especificado
compareTo() Compara dos strings lexicográficamente
concat() Concatena el argumento String especificado
endsWith() Devuelve true si el string actual termina con el string de entrada
equals() Compara un string con un string especificado
equalsIgnoreCase( Compara un string con un string especificado, ignorando
) mayúsculas y minúsculas
indexOf() Devuelve el valor del índice de la primera aparición de un
carácter o un string en un string de entrada
lastIndexOf() Devuelve el valor del índice de la última aparición de un carácter
o un string en un string de entrada
length() Devuelve el número de caracteres en un string
setCharAt() Cambia un carácter especificado en el índice especificado
startsWith() Devuelve true si el string actual empieza con el string de entrada
Substring() Devuelve un nuevo string que es parte del string de entrada
toLowerCase() Convierte todos los caracteres a minúsculas
toUpperCase() Convierte todos los caracteres a mayúsculas
toInt() Devuelve la representación numérica de un string
trim() Devuelve una copia de un string, destacando y rastreando
espacios en blanco omitidos
getBytes() Devuelve un arreglo de bytes conteniendo los caracteres de un
String como bytes
toCharArray() Devuelve el contenido de un String especificado como un
arreglo de caracteres
replace() Remplaza todas las apariciones de un caracter en un string con
el caracter espeficado
Sintaxis String(data)
String(data, base)
Parámetros Data byte[], char[]: Arreglo de bytes para ser decodificado en
caracteres o arreglo de caracteres para ser convinados en un
string, int, long: conversión de string de un valor especificado,
String: string para ser copiado en un string creado
Base DEC, HEX, OCT o BIN (exclusivo para datos int o long)

Nombre char
Ejemplo char m; // Declara la variable "m" de tipo char
m = 'A'; // Asigna a "m" el valor "A"
int n = '&'; // Declara la variable "n" y le asigna el valor "&"
Descripción Tipo de datos para caracteres, símbolos tipográficos como A, d, y $.

Ing. Ronald N. Kopp Pá gina 47

Arduino
Un char almacena letras y símbolos en el formato ASCII. Cada char es un byte (8 bits)
en longitud y se distingue por estar entre comillas sencillas. El tipo char tiene signo
por lo que codifica números de -128 a 127
Sintaxis char var
char var = valor
Parámetros Var Nombre de la variable referenciando el valor
Valor Cualquier caracter

import processing.serial.*;

Serial myPort; // el puerto serial

float bgcolor; // color de fondo

float fgcolor; // color de relleno
float xpos, ypos; // posición inicial de la pelota

void setup() {
size(640, 480); // tamaño del escenario

// listamos todos los puertos series disponibles

println(Serial.list());
// abrimos el puerto que estamos usando para el arduino.
myPort = new Serial(this, "COM3", 9600);

// leemos los bytes en un búfer hasta que obtenemos un avance de línea (ASCII 10):
myPort.bufferUntil('\n');

// dibujamos con los borde lisos:

smooth();
}

void draw() {
background(bgcolor);
fill(fgcolor);

// dibujamos la figura, una elipse

ellipse(xpos, ypos, 20, 20);
}

void serialEvent(Serial myPort) {

// leemos el buffer del puerto serial:
String myString = myPort.readStringUntil('\n');
Ing. Ronald N. Kopp Pá gina 48
Arduino

// si no tenemos ningún bytes de manera que la línea avance, cortamos el string:

myString = trim(myString);

// dividimos la cadena en las comas

// y convertimos las secciones en enteros:
int sensors[] = int(split(myString, ','));

// imprimimos los valores que tenemos:

for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
print("Sensor " + sensorNum + ": " + sensors[sensorNum] + "\t");
}

// y añadimos un salto de línea después de que se imprimen todos los valores de los sensores:
println();

if (sensors.length > 1) {
xpos = map(sensors[0], 0,1023,0,width);
ypos = map(sensors[1], 0,1023,0,height);
fgcolor = sensors[2];
}
// enviamos un byte para pedir más datos:
myPort.write("A");
}

30. SerialEvent: demostración de la función SerialEvent()

SerialEvent () se lo llama/ejecuta después de un loop (), cuando una nueva serie de datos llega desde
el buffer del puerto serial, este método lo añade a una cadena(string).

Ing. Ronald N. Kopp Pá gina 49

Arduino
Hardware Required
 Arduino Board

Circuit

Code

String inputString = ""; // hacemos una String (cadena) para contener los datos de entrada
boolean stringComplete = false; // creamos un variable booleana stringComplete

Ing. Ronald N. Kopp Pá gina 50

Arduino

void setup() {
// inicializamos el puerto serial:
Serial.begin(9600);
// reservamos 200 bytes para el inputString:
inputString.reserve(200);
}

void loop() {
// imprimimos el String cando llega una nueva línea:
if (stringComplete) { // stringComplete puede ser true o false, si es true ejecutara la orden
Serial.println(inputString);
// borramos el string:
inputString = "";
stringComplete = false;
}
}

/*
El SerialEvent se produce cada vez que un nuevo dato viene a través de la conexión serial RX del
hardware. Esta rutina se ejecuta entre cada bucle, por lo que el uso de un delay en el interior del
bucle, puede retrasar la respuesta */

void serialEvent() {
while (Serial.available()) {
// obtenemos el nuevo byte inChar desde el serial:
char inChar = (char)Serial.read();
// lo agregamos en el inputString:
inputString += inChar;
// si el carácter de entrada es una nueva line, establecemos un indicador
// entonces el bucle principal puede hacer algo ya que el if(stringComplete) será true:
if (inChar == '\n') {
stringComplete = true;
}
}
}

31. Serial input (Switch (case) Statement): Cómo tomar diferentes acciones basadas en caracteres
recibidos por el puerto serie.

Una sentencia if nos permite elegir entre dos opciones discretas, verdadero o falso. Cuando hay más
de dos opciones, se pueden utilizar múltiples sentencias if, o se puede utilizar la sentencia switch.
Switch nos permite elegir entre varias opciones discretas.

Ing. Ronald N. Kopp Pá gina 51

Arduino

Este tutorial muestra cómo utilizar el comando Switch para encender uno de varios LEDs basados en
un byte de datos recibidos por el puerto serie. El sketch atiende la entrada del puerto serie, y se
enciende un LED diferente para cada caracter a, b, c, d, e.

Hardware Required
 Arduino Board
 (5) LEDs
 (5) 220 ohm resistors
 breadboard
 hook-up wire

Circuit
Cinco LEDs están asociadas a los pines digitales 2, 3, 4, 5, y 6 en serie a través de una resistencia de
220 ohmios.

Para hacer este trabajo, nuestro Arduino debe estar conectado al ordenador. Abrimos el Monitor
serial, y enviar los caracteres a, b, c, d.

Schematic

Ing. Ronald N. Kopp Pá gina 52

Arduino

Code

Ing. Ronald N. Kopp Pá gina 53

Arduino

void setup() {
// inicializamos la comunicación serial:
Serial.begin(9600);
// inicializamos los pines del LED como salidas:
for (int thisPin = 2; thisPin < 7; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}

void loop() {
// leemos los datos del serial, y lo cargamos en la variable inByte:
if (Serial.available() > 0) {
int inByte = Serial.read();

    // Haremos algo diferente en función del carácter recibido.

    // La sentencia switch espera valores de números individuales para cada caso;
    // En este ejemplo, sin embargo, debemos utilizar comilla simples para decirle
    // al controlador que obtenga el valor ASCII del carácter.
// Por ejemplo 'a' = 97, 'b' = 98, y así sucesivamente:

switch (inByte) {
case 'a':
digitalWrite(2, HIGH);
break;
case 'b':
digitalWrite(3, HIGH);
break;
case 'c':
digitalWrite(4, HIGH);
break;
case 'd':
digitalWrite(5, HIGH);
break;
case 'e':
digitalWrite(6, HIGH);
break;
default:
// apagar todos los LEDs:
for (int thisPin = 2; thisPin < 7; thisPin++) {
digitalWrite(thisPin, LOW);
}
}
}
}

Nombre case

Ing. Ronald N. Kopp Pá gina 54

Arduino
Ejemplo char letter = 'B';

switch (letter) {
case 'A':
Serial.println("Alpha"); // No se ejecuta
break;
case 'B':
Serial.println("Bravo"); // Imprime Bravo
break;
default:
Serial.println("Zulu"); // No se ejecuta
break;
}
Descripción Denota las etiquetas principales a ser evaluadas con el parámetro en la
estructura switch()
Sintaxis case etiqueta: declaración
Parámetros Etiqueta byte, char, o int
Declaración una o más instrucciones válidas

Nombre break
Ejemplo char letter = 'B';

switch (letter) {
case 'A':
Serial.println("Alpha"); // No se ejecuta
break;
case 'B':
Serial.println("Bravo"); // Imprime Bravo
break;
default:
Serial.println("Zulu"); // No se ejecuta
break;
}
Descripción Finaliza la ejecución de estructuras como switch(), for(), o while() y continua a la
siguiente instrucción
Sintaxis break

Nombre switch()
Ejemplo int num = 1;

switch (num) {
case 0:
Serial.println("Zero"); // No se ejecuta
break;
case 1:
Serial.println("One"); // Imprime "One"
break;

Ing. Ronald N. Kopp Pá gina 55

Arduino
}
---------------------------------------------------------------------------------------------------

char letter = 'N';

switch (letter) {
case 'A':
Serial.println("Alpha"); // No se ejecuta
break;
case 'B':
Serial.println("Bravo"); // No se ejecuta
break;
default: // Ejecuci&oacute;n por defecto si la etiqueta case
Serial.println("None"); // no coincide con los par&aacute;metros de switch
break;
}
----------------------------------------------------------------------------------------------------

// Removiendo un "break" permite preguntar

// por m&aacute;s de uno a la vez

char letter = 'b';

switch (letter) {
case 'a':
case 'A':
Serial.println("Alpha"); // No se ejecuta
break;
case 'b':
case 'B':
Serial.println("Bravo"); // Imprime "Bravo"
break;
}
Descripción Trabaja como una estructura if else, pero switch es más conveniente cuando
necesitamos seleccionar entre tres o más alternativas. Los controles del programa
saltan al caso con el mismo valor como expresión. Todas las declaraciones en el
switch son ejecutadas hasta que son redireccionadas por un break. Solo datos
primitivos que puedan ser convertidos en enteros (byte, char y int) pueden ser
usados como parámetro expresión. El default es opcional.
Sintaxis switch (expresión)
{
case etiqueta:
declaraciones
case etiqueta: // Opcional
declaraciones // Opcional
default: // Opcional
declaraciones // Opcional

Ing. Ronald N. Kopp Pá gina 56

Arduino
}
Parámetros Etiqueta byte, char, o int
Declaración byte, char, o int

Nombre default
Ejemplo char letter = 'F';

switch (letter) {
case 'A':
Serial.println("Alpha"); // No se ejecuta
break;
case 'B':
Serial.println("Bravo"); // No se ejecuta
break;
default:
Serial.println("Zulu"); // Imprime Zulu
break;
}
Descripción Palabra reservada para definir la condición por defecto de un switch(). Si ninguna de
las etiquetas de los casos corresponde con el parámetro del switch(), se ejecutan las
instrucciones después del default. La estructura Switch no requiere un defaul.
Sintaxis default: declaración
Parámetros Declaración una o más instrucciones válidas a ser ejecutada

Ing. Ronald N. Kopp Pá gina 57

 Arduino

32. MIDI: Envíar mensajes de notas MIDI a través del puerto serial.

Este tutorial muestra como ejecutar notas MIDI desde un Arduino.

MIDI, the Musical Instrument Digital Interface, es un protocolo útil para sintetizadores, secuenciadores
de control y otros dispositivos musicales. Los dispositivos MIDI son generalmente agrupados en dos
grandes clases: los controladores (es decir, dispositivos que generan señales MIDI basado en las
acciones humanas) y sintetizadores (incluyendo samplers, secuenciadores, y otros). Estos últimos toman
datos en MIDI y crean el sonido, la luz, o algún otro efecto.

MIDI es un protocolo serie que opera a 31.250 bits por segundo. El puerto serie incorporado en el
Arduino puede enviar datos a esta velocidad.

Los MIDI Bytes se dividen en dos tipos: bytes de comando y bytes de datos. Bytes de comando son
siempre 128 o mayor, o 0x80 a 0xFF en hexadecimal. Bytes de datos son siempre menor que 127, o
0x00 a 0x7F en hexadecimal. Los bytes de comandos incluyen cosas sobre la nota, que no toque la nota,
etc. Los Bytes de datos incluyen cosas como el tono de la nota que debe tocar, la velocidad, o el
volumen de la nota, etc. Para más detalles, consultemos las especificaciones de MIDI, de uno de las
muchas guías de protocolo MIDI en la Web.

Los datos MIDI se suele anotar en hexadecimal porque los bancos e instrumentos MIDI se agrupan en
grupos de 16.

Hardware Required
 Arduino UNO
 (1) MIDI jack
 (1) 220 ohm resistor
 hook-up wire
 MIDI enabled device (optional, for testing)

Todos los conectores MIDI son hembra, por definición de la especificación MIDI. Aquí se ve como
conectar el conector al Arduino

Ing. Ronald N. Kopp Pá gina 58

 Arduino

Circuit
 Arduino digital pin 1 connected to MIDI jack pin 5
 MIDI jack pin 2 connected to ground
 MIDI jack pin 4 connected to +5V through 220-ohm resistor

Schematic

Ing. Ronald N. Kopp Pá gina 59

 Arduino

Code

void setup() {
// Configuramos la velocidad de transmisión MIDI:
Serial.begin(31250);
}

void loop() {
// tocar notas desde F#-0 (0x1E) a F#-5 (0x5A):
for (int note = 0x1E; note < 0x5A; note ++) {
//Nota en el canal 1 (0x90), algún valor de (note), velocidad media (0x45):
noteOn(0x90, note, 0x45);
delay(100);

// Nota que corresponde al canal 1 (0x90),

// algún valor de (note) [tiene que ver con la frecuencia],
/*
velocidad (como es 0 es un silencio) (0x00) [tiene que ver con el volumen de esa nota, parecido a
tocar mas fuerte o mas débil la tecla del piano]:
*/

Ing. Ronald N. Kopp Pá gina 60

 Arduino

noteOn(0x90, note, 0x00);

delay(100);
}
}

// reproducir una nota MIDI note. No comprobar que cmd (byte de comandos) es mayor que 127, o
que los valores de los datos son menores a 127:
void noteOn(int cmd, int pitch, int velocity) {
Serial.write(cmd);
Serial.write(pitch);
Serial.write(velocity);
}

noteOn(0x90, note, 0x45)

0x90: corresponde al canal 1

note: El valor de tono (picth) determina la frecuencia de la nota que se desea reproducir. este valor va
de 0 a 127, con la nota media C está representada por el valor de 60.

velocidad 0x45: En sintetizadores básicos, el valor de velocidad sólo se utiliza para determinar la fuerza
con la que se reproduce la nota, el único efecto de ser una nota que es más fuerte o más suave en el
volumen. este valor va de 0 a 127

Ing. Ronald N. Kopp Pá gina 61

Arduino

Ing. Ronald N. Kopp Pá gina 62

 Arduino

F#-0 (0x1E)

F#-0 es en el piano la tecla 30 por lo tanto convirtiendo a hexadecimal queda 1E:

Ing. Ronald N. Kopp Pá gina 63

 Arduino

33. MultiSerialMega: Uso de los dos puertos seriales disponibles en Arduino Mega.

A veces, un puerto serial no es suficiente! Al tratar de comunicarse con múltiples dispositivos seriales
activos, es posible que al mismo tiempo que envío información quiera recibir de nuevo información en
la ventana serial, tener algunos puertos adicionales RX / TX pueden ser algo muy útil. En este ejemplo se
hace uso de uno de los 3 puertos seriales auxiliares de Arduino Mega, se realiza el enrutamiento de los
datos entrantes leídos en esta conexión directa a través de la línea principal TX, y, a su vez, a la ventana
principal del monitor serial para que puedamos visualizado.

línea principal TX: se refiere a la conexión usb

Hardware Required
 (1) Arduino Mega Board
 (1) serial enabled device (a Xbee Radio, Bluetooth module, or RFID reader, or another Arduino,
for instance).

Circuit
Después de comprobar la hoja de datos de cualquier dispositivo serie activo, que elijamos utilizar para
este ejemplo, asegurémonos de que esta correctamente conectado y alimentado. Posteriormente
conectemos el pin RX y los pines TX de nuestro dispositivo a los pines TX y RX del Arduino Mega, como
se muestra en el esquema de abajo.

Asegurémonos de que nuestro Mega está conectado al ordenador, a través de USB, para permitir la
comunicación en serial.

Ing. Ronald N. Kopp Pá gina 64

 Arduino

Schematic

Ing. Ronald N. Kopp Pá gina 65

Arduino

Code

Ing. Ronald N. Kopp Pá gina 66

Arduino

void setup() {
// inicializamos ambos puertos seriales:
Serial.begin(9600);
Serial1.begin(9600);
}

void loop() {
// leemos desde el puerto 1 y lo enviamos al puerto 0:
if (Serial1.available()) {
int inByte = Serial1.read();
Serial.write(inByte);
}

// leemos desde el puerto 0 y lo enviamos al puerto 1:

if (Serial.available()) {
int inByte = Serial.read();
Serial1.write(inByte);
}
}

Ing. Ronald N. Kopp Pá gina 67