Conexión de una pantalla Nextion con Arduino Ejemplo 1

Encender y apagar un Led

En este ejemplo se describe como se conecta la pantalla Nextion al puerto serie de una placa Arduino de manera que se pueda controlar el encendido y apagado de un Led.

 

Diagrama de montaje

En este montaje se ha conectado un Led en el terminal 2 de la placa Arduino con una resistencia de 470 ohm que puede ser también de 330 ohm o 220 ohm. En la conexión de la alimentación den la pantalla es muy  importante no invertir los terminales de alimentación que es muy probable dañar la pantalla de esta manera.

Los terminales de comunicación serial se conectan de forma cruzada, es decir TX-RX y RX-TX tal como se muestra en la siguiente figura.

 

En la siguiente figura se muestra la parte inferior de la pantalla, donde claramente se pueden identificar los terminales de conexión.

 

 

En la parte inferior de la pantalla están indicados los terminales sobre la placa impresa de esta. La siguiente tabla ilustra las conexiones realizadas en el montaje.

 

Tabla de conexiones.

Arduino	Dispositivo
Terminal 2	Led - 470 ohm
Terminal RX	Pantalla TX - Cable amarillo
Terminal TX	Pantalla RX - Cable azul
Terminal 5V	Pantalla 5V - Cable rojo
Terminal GND	Pantalla GND - Cable negro

Gráficos empleados en la pantalla

Para este ejemplo solo se emplea un botón, las siguientes imágenes corresponden a los estados de encendido y apagado.

 

 

 

 

 

Configuración de la pantalla

En el botón de ON se emplearon los eventos de presionar botón y soltar botón para cambiar de pagina y enviar el carácter "1" por el puerto serie. Las instrucciones empleadas se observan en las siguientes figuras.

 

Para la acción de presionar se ejecuta la instrucción de enviar el carácter 1 con la instrucción prints "1",1

 

 

Para la acción de soltar se ejecuta la instrucción de cambiar de pagina con la instrucción page 1

 

En el botón de OFF se emplearon los eventos de presionar botón y soltar botón para cambiar de pagina y enviar el carácter "0" por el puerto serie. Las instrucciones empleadas se observan en las siguientes figuras.

 Para la acción de presionar se ejecuta la instrucción de enviar el carácter 0 con la instrucción prints "0",1

 Para la acción de soltar se ejecuta la instrucción de cambiar de pagina con la instrucción page 0

 

Código de la placa Arduino

El programa realizado no emplea ninguna librería por lo que puede emplearse como base para la realización de otros programas en plataformas microcontroladas o microprocesadas como la Raspberry Pi.

En el video presentado al inicio de esta publicación se explica en mas detalle el funcionamiento del código y la prueba realizada en el monitor serie.

char dato;
void setup() {
  Serial.begin(9600);
  pinMode(2,OUTPUT);
}
void loop() {
  if (Serial.available() > 0) {
    dato = Serial.read();
    Serial.println(dato);
    if (dato == '1') {
      digitalWrite(2, HIGH);
    }
    if (dato == '0') {
      digitalWrite(2, LOW);
    }
  }
}

 

Internet de las cosas con la placa NodeMCU y Ubidots

 IOT con la NodeMCU y Ubidots

Una manera rápida de introducirse al mondo del internet de las cosas es por medio de una pagina que nos provea el servicio de captura y visualización de datos, en este tutorial se ha elegido Ubidots por se una plataforma fácil de configurar y que provee una plantilla de código para trabajar con las placas basadas en el Soc ESP8266 o ESP32.

Protocolo MQTT

MQTT es un protocolo abierto el cual posibilita la comunicación entre sí y continua de dos o más

dispositivos enfocado directamente en la conectividad M2M (Machine-to-Machine) que opera con una 

arquitectura publicación-suscripción tal como se ve en la siguiente figura.Para el ejemplo a desarrollar

el cliente que publica es la placa Node MCU, el broker sera Ubidots y la visualización sera por medio

del dash board de Ubidots.

 

MQTT utiliza el paradigma de publicación-suscripción que refiere a que cualquiera de los clientes

puede suscribirse a determinados tópicos o temas y de esta misma manera cualquiera podrá publicar.

Placa NodeMCU

Para poder trabajar con la plataforma NodeMCU ESP8266 en el IDE de Arduino, es necesario

instalar el compilador para las plataformas basadas en el microcontrolador ESP8266, el siguiente

video muestra como se hace la configuración del IDE y la programación de prueba en la placa.

 

 

 

Broker MQTT Ubidots

Ubidots es una iniciativa colombiana para la elaboración de sistemas basados en el internet 

de las cosas.

Ubidots logró convertir su emprendimiento de servicios de monitoreo remoto en una startups que

recibió el apoyo de Mass Challenge - una de las mayores aceleradoras de empresas emergentes del

mundo-, logró levantar un millón de dólares de inversión entre Medellín y Silicon Valley y lanzó

un producto que hoy se usa en más de 160 empresas en todo el mundo. Ubidots ha logrado 

posicionarse al punto de tener una comunidad de más de 40.000 desarrolladores y presencia en países

como Argentina, Brasil, EE. UU., Inglaterra, Israel, Australia.

(https://www.rutanmedellin.org//es/tendencias/item/ubidots-la-startup-local-que-conecta-datos-de-todo-el-mundo)

El circuito de prueba empleado se indica en la siguiente figura, es importante indicar que las placas

basadas en el ESP8266 trabajan a 3.3 voltios.

El montaje también puede realizarse con la placa WeMos D1 o Mini. 

El video que esta a continuación indica el procedimiento para conectar la Placa NodeMCU con

Ubidots.

El código de prueba se deja a continuación, en el video muestra como se configura TOKEN y la 

red WiFi

/****************************************
* Include Libraries
****************************************/
#include "UbidotsESPMQTT.h"
/****************************************
* Define Constants
****************************************/
#define TOKEN " " // Your Ubidots TOKEN
#define WIFINAME " " //Your SSID
#define WIFIPASS " " // Your Wifi Pass
Ubidots client(TOKEN);
/****************************************
* Auxiliar Functions
****************************************/
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Mensaje recibido [");
Serial.print(topic);
Serial.print("] ");
for (int i=0;i<length;i++) {
Serial.print((char)payload[i]);
}
Serial.println();
}
/****************************************
* Main Functions
****************************************/
void setup() {
// put your setup code here, to run once:
//client.ubidotsSetBroker("industrial.api.ubidots.com"); // Sets the broker properly for the industrial account
client.setDebug(true); // Pass a true or false bool value to activate debug messages
Serial.begin(115200);
client.wifiConnection(WIFINAME, WIFIPASS);
client.begin(callback);
}
int i=0;
void loop() {
//put your main code here, to run repeatedly:
if(!client.connected()){
client.reconnect();
}
if(i<100){
float value1 = analogRead(A0);//Lectura analogo
client.add("var_pot01", value1);//El cliente agrega una variable
client.ubidotsPublish("prueba");//Colocar el nombre de dipositivo
client.loop();
i++;
delay(2000);
}
} 

 

 

 

 

 

Robot seguidor de linea en Tinkercad Circuits

Robot seguidor de linea en Tinkercad

Circuito empleando empleando interruptores Dip Switch

Una forma de simular el comportamiento digital de los fotosensores empleados en lo seguidores de linea es el emplear interruptores. En este ejemplo se emplean 3 interruptores de un Dip Switch.

 

Seguidor de linea en Tinkercad

Circuito empleando empleando el Ambient Light Sensor

El Ambient Light Sensor es un fototransistor similar al que se emplean en los robot seguidores de linea, asi que se puede emplear para simular un sensor como puede ser el popular CNY70.

Seguidor de linea en tinkercad

 Los leds azules que aparecen en el montaje solo están solo para ilustrar las conexiones que se realizarían con el cny70.
En la siguiente figura se muestra el detalle de la conexión del sensor con  la identificación de los terminales de los dispositivos

Detalle de conexión del sensor

Programa básico de prueba

Este programa lee y almacena el estado binario de los tres sensores. El estado binario es mostrado por el terminal serial.
En este ejemplo no se operan los motores.

#define MOTORDE 2
#define MOTORIZ 3
#define SENSORIZ 4
#define SENSORCE 5
#define SENSORDE 6
bool SI,SC,SD;
void setup(){
  pinMode(MOTORDE, OUTPUT);
  pinMode(MOTORIZ, OUTPUT);
  pinMode(SENSORIZ, INPUT);
  pinMode(SENSORCE, INPUT);
  pinMode(SENSORDE, INPUT);
  Serial.begin(9600);
}

void loop(){
  SI=digitalRead(SENSORIZ);
  SC=digitalRead(SENSORCE);
  SD=digitalRead(SENSORDE);
  Serial.print("Sensor Izquierdo = ");
  Serial.println(SI);
  Serial.print("Sensor Central = ");
  Serial.println(SC);
  Serial.print("Sensor Derecho = ");
  Serial.println(SD);
}

Integrar Java Swing en Processing

Integración de Java Swing en Processing

Estructura básica

Este ejemplo de código implementa la creación del panel en el cual se agregaran los controles de la aplicación en Processing. En la siguiente figura se muestra las ventanas resultantes para este ejemplo, la tradicional ventana correspondiente al lienzo o sketch de Processing y otra correspondiente al aplicativo Java con Swing.

A partir de esta plantilla básica se procede a desarrollar la aplicación agregando botones, sliders, etc.

Ventanas estructura básica.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
MyPanel controlPanel= new MyPanel();
 void setup() {
  JFrame frame = new JFrame("Ejemplo Frame");
  frame.setContentPane(controlPanel);
  frame.pack();
  frame.setVisible(true);
}
void draw() {
}
public class MyPanel extends JPanel {
    public MyPanel() {
       setPreferredSize(new Dimension(200, 400));
       setLayout(null);
   }
}

Agregando Botones

Este ejemplo de código implementa agrega un botón y el evento de click para este botón.
En el ejemplo el botón se llama boton01 pero puede tener cualquier otro nombre, pero se sugiere que para distinguir varios botones en la aplicación estos tengan en su nombre una numeración.
el método boton01.setBounds(0, 0, 200, 25); sirve para indicar la posición y tamaño del botón en el panel, su formato es el siguiente setBounds(x,y,ancho,alto) donde las coordenadas x,y corresponden a la esquina superior izquierda y ancho, alto a las dimensiones del botón.
Para agregar el evento de click se emplea el método y en este se indica como se llama la clase que implementa el método boton01.addActionListener(new ClickBoton01()); para detectar el evento de click en este botón. Para este ejemplo al clase se llama ClickBoton01 pero el nombre puede ser cualquiera, es importante indicar que por lo general cada botón tiene su propio evento de click indicado con un nombre que lo diferencia de los demás.

 

Creación de un botón.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
MyPanel controlPanel= new MyPanel();
 void setup() {
  JFrame frame = new JFrame("Ejemplo Frame");
  MyPanel controlPanel= new MyPanel();
  frame.setContentPane(controlPanel);
  frame.pack();
  frame.setVisible(true);
}
void draw() {
}
public class MyPanel extends JPanel {
  private JButton boton01;
  public MyPanel() {
    setPreferredSize(new Dimension(200, 400));
    setLayout(null);
    boton01 = new JButton ("Presionar");
    boton01.setBounds(0, 0, 200, 25);
    add(boton01);
    boton01.addActionListener(new ClickBoton01());
  }
}
class ClickBoton01 implements ActionListener{
  public void actionPerformed(ActionEvent e){
    JButton b = (JButton)e.getSource();
    b.setLabel("Presionado");
  }
} 

Cambiar el Color de Fondo del Sketch al Presionar un Botón

Este ejemplo permite cambiar el color de fondo de blanco a negro y viceversa al presionar un único botón, para esto se agrega una variable de tipo booleano que cambia de estado cada vez que se presiona el botón.

Botón para cambiar color de fondo

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
MyPanel controlPanel= new MyPanel();
boolean banderaBoton01 = true;
void setup() {
  JFrame frame = new JFrame("Ejemplo Frame");

  frame.setContentPane(controlPanel);
  frame.pack();
  frame.setVisible(true);
  size(400,400);
}
void draw() {
  if (banderaBoton01) {
    background(255);//Blanco
  } else {
    background(0);//Falso
  }
}
public class MyPanel extends JPanel {
  private JButton boton01;
  public MyPanel() {//Metodo constructor
    setPreferredSize(new Dimension(200, 400));
    setLayout(null);
    boton01 = new JButton ("Blanco");
    boton01.setBounds(0, 0, 200, 25);
    add(boton01);
    boton01.addActionListener(new ClickBoton01());
  }
}
class ClickBoton01 implements ActionListener {
  public void actionPerformed(ActionEvent e) {
    JButton b = (JButton)e.getSource();
    banderaBoton01=!banderaBoton01;//Cambia de estado al negarse a si misma
    if (banderaBoton01) {
      b.setLabel("Blanco");
    } else {
      b.setLabel("Negro");
    }
   
  }
}

Cambiar el Color del panel y el botón

Los objetos de Swing como los botones y paneles tienen propiedades de color que se pueden cambiar con el metodo setBackground() .
Los colores que se pueden seleccionar directamente son: Color.lightGray Color.gray Color.darkGray Color.blue Color.cyan Color.green Color.yellow Color.magenta Color.orange Color.pink Color.red Color.white Color.black
Para agregar un color empleando el formato RGB empleamos la objeto Color que en este ejemplo se utilizo  de la siguiente manera para cunado se presiona el botón b.setBackground(new Color( 128, 0, 32 ));

Panel gris y botón amarillo

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
MyPanel controlPanel= new MyPanel();
 void setup() {
  JFrame frame = new JFrame("Ejemplo Frame");
  frame.setContentPane(controlPanel);
  frame.pack();
  frame.setVisible(true);
}
void draw() {
}
public class MyPanel extends JPanel {
  private JButton boton01;
  public MyPanel() {
    setPreferredSize(new Dimension(200, 400));
    setLayout(null);
    setBackground(Color.gray);//Color del panel
    boton01 = new JButton ("Presionar");
    boton01.setBounds(0, 0, 200, 25);
    boton01.setBackground(Color.yellow);//Color del boton
    add(boton01);
    boton01.addActionListener(new ClickBoton01());
  }
}
class ClickBoton01 implements ActionListener {
  public void actionPerformed(ActionEvent e) {
    JButton b = (JButton)e.getSource();
    b.setLabel("Presionado");
    b.setBackground(new Color( 128, 0, 32 ));
  }
} 

Cambiar valores de los controles desde la función  draw()

Las propiedades de los objetos pueden ser cambiados desde la función draw(), en este ejemplo se visualiza el tiempo transcurrido en milisegundo en una etiqueta JLabel esto se hace con la siguiente isntruccion donde se modifica la propiedad del texto controlPanel.texto01.setText(str(millis())); donde el metodo setText cambia el texto que es de tipo string. Para convertir el valor entero de la funcion millis() se emplea la funcion srt() que convierte un dato tipo int o float a una cadena de caracteres string
 

Mostrar tiempo en milisegundos

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
boolean baderaCrono = false;
MyPanel controlPanel= new MyPanel();
void setup() {
  JFrame frame = new JFrame("Cronometro");
  frame.setContentPane(controlPanel);
  frame.pack();
  frame.setVisible(true);
}
void draw() {
  if (baderaCrono) {
    controlPanel.texto01.setText(str(millis()));
  }
}
public class MyPanel extends JPanel {
  private JButton boton01;
  private JLabel texto01;
  public MyPanel() {
    setPreferredSize(new Dimension(200, 400));
    setLayout(null);
    boton01 = new JButton ("Cronometrar");
    boton01.setBounds(0, 0, 200, 25);
    add(boton01);
    boton01.addActionListener(new ClickBoton01());
    texto01= new JLabel("0");
    texto01.setBounds(0, 25, 200, 25);
    texto01.setForeground(Color.blue);
    add(texto01);
  }
}
class ClickBoton01 implements ActionListener {
  public void actionPerformed(ActionEvent e) {
    JButton b = (JButton)e.getSource();
    baderaCrono=!baderaCrono;
    if (baderaCrono) {
      b.setLabel("Pausar");
    } else {
      b.setLabel("Cronometrar");
    }
  }
}

Conversion de una cadena a un numero entero en Processing

Conversión De Una Cadena De Caracteres Enviada Por El Puerto Serie A Un Número Entero En Processing

Los datos enviados por el puerto serie corresponden a un código que representa caracteres alfanuméricos, este código empleado se llama ASCII y es un estándar empleado para el envió y recepción de datos.

Muchos de los datos enviados son numéricos pero representados en ASCII por lo cual es necesario una conversion del conjunto de datos o cadena recibida a su valor numérico decimal correspondiente.

En este ejemplo se envía una cadena de caracteres desde un microcontrolador por el puerto serie, la cadena tiene los caracteres de salto de linea y retorno de carro.

Caracteres no imprimibles presentes en la cadena

Caracter Nulo '\0' es el terminador de una cadena su código ASCII es el 0 también se representa con la palabra reservada null

Caracter New Line '\n' es el salto de linea su codigo ASCII es el 10

Caracter Back Space '\b' es el terminador de una cadena su codigo ASCII es el 8

Caracter Carriage Return '\r' retorno de carro su codigo ASCII es el 13

Pinguino o Arduino envía un retorno de carro '\r' y un salto de linea '\n' cuando se emplea la instruction Serial.println()

Pinguino o Arduino con la instrucción Serial.print() no envía los caracteres especiales de salto de linea y retorno de carro

Referencia

• Conexión de Arduino con Processing
• Codigo ASCII
• Libro de Processing en español
• Processing guia de instrucciones
• Botones y condicionales en processing

Código Pinguino o Arduino

void setup() {

  Serial.begin(9600);

}

void loop() {

  Serial.println("123");

}

Código Processing

import processing.serial.*;//libreria de comunicacion serial

Serial miPuerto;//Objeto puerto

String strNombrePuerto;//Cadena de caracteres para almacenar el nombre del puerto a emplear en la comunicacion

String strDatoRecibido="";//Cadena de caracteres para almacenar el dato enviado por el microcontrolador

String strDato="";

int intDatoRecibido;

void setup() {

  size(200, 200);

  println("Puertos disponible: "+Serial.list());//muestra el listado de los puertos disponibles para comunicacion serial

  strNombrePuerto=Serial.list()[0];//Nombre del puerto 0 del listado de puertos seriales disponibles

  println(strNombrePuerto);//Muestra el nobre del puerto 0 en consola

  miPuerto=new Serial(this, strNombrePuerto, 9600);//configuracion del puerto a 9600 baudios

}

void draw() {

  if ( miPuerto.available() > 0) { //Verifica que hay un nuevo dato 

    strDatoRecibido = miPuerto.readStringUntil('\n');//almacena hasta encontrar el caracter de salto de linea

  }

  if (strDatoRecibido.length()==5) {//la cadena enviada por el microcontrolador tiene 5 caracters tres digitos mas salto de linea y retorno de carro

    strDatoRecibido = trim(strDatoRecibido);//elimina los caracteres especiales de la cadena como retorno de carro y salto de linea

    println("tamaño "+strDatoRecibido.length());//El tamaño a mostrar debe ser 3 ya que elimino el retorno de carro y salto de linea

    println("cadena "+strDatoRecibido);//Muestra la cadena recibida

    intDatoRecibido=Integer.parseInt(strDatoRecibido);//Convierte la cadena recibida a un valor entero

    println("entero "+intDatoRecibido);//Muestra el valor entero

  }

  println("Cantidad de datos en el buffer: "+miPuerto.available());//Muestra cuantos datos hay en el buffer

  miPuerto.clear();//limpia el buffer de recepcion de datos seriales

}

Comunicacion serial asincrona en Arduino

COMUNICACIÓN SERIAL ASÍNCRONA ENTRE DOS TARJETAS ARDUINO

Este ejemplo básico realiza la comunicación entre un Arduino que hace de emisor y otro de receptor

En este ejemplo se emplea la función Serial.write() para enviar un numero entero que puede ser cualquier valor entre 0 a 255, es decir el dato de 1 Byte

En el receptor se declara una variable entera para almacenar el valor leído por medio de la función Serial.read() la variable de almacenamiento también puede ser de tipo char pero en este caso se tendrá en cuenta el valor equivalente en código ASCII para realizar la comparación, por ejemplo las equivalencias en las estructuras condicionales serian:

• if(Dato==48) equivale a if(Dato=='0') si Dato es de tipo char en lugar de int

En este ejemplo se debe de tener en cuenta que la lectura de datos se realiza dos veces mas rápido de lo que se hace el envío gracias a funciones de retardo realizadas tanto en el receptor como en el emisor.

Ejemplo Realizado En 123D Circuits 

En este ejemplo se conectan dos tarjetas un que envía la que tiene la conexión en TX y otra que recibe la que tiene la conexión en RX.

Conexión Serial Básica

• Enlace del circuito en 123D Circuits

Código de Arduino que transmite:

int Dato;
void setup(){
  Serial.begin(9600);
  pinMode(13,OUTPUT);//Led que trae incorporado la tarjeta Arduino
}

void loop(){
  if (Serial.available() > 0) {//Verifica que hay datos en el buffer de recepcion
    Dato = Serial.read();//Lee dato
    Serial.print("Dato Recibido = ");//Muestra que dato fue leido en el Serial Monitor
    Serial.println(Dato);
    if(Dato==48){
      digitalWrite(13,LOW);//Apaga Led
    }
    if(Dato==49){
      digitalWrite(13,HIGH);//Enciende Led
    }
    delay(100);//Retardo entre lecturas de datos
  }
}

Código de Arduino que recibe:

int Dato;
void setup(){
  Serial.begin(9600);
  pinMode(13,OUTPUT);//Led que trae incorporado la tarjeta Arduino
}

void loop(){
  if (Serial.available() > 0) {//Verifica que hay datos en el buffer de recepcion
    Dato = Serial.read();//Lee dato
    Serial.print("Dato Recibido = ");//Muestra que dato fue leido en el Serial Monitor
    Serial.println(Dato);
    if(Dato==48){
      digitalWrite(13,LOW);//Apaga Led
    }
    if(Dato==49){
      digitalWrite(13,HIGH);//Enciende Led
    }
    delay(100);//Retardo entre lecturas de datos
  }
} 

Menu con pantalla LCD

EJEMPLO DE UN MENÚ DE NAVEGACIÓN EMPLEANDO PANTALLA LCD

Los menús son una forma ordenada de ejecución de un programa que permita configurar y seleccionar diferentes procesos.

En este ejemplo se configura y se ejecuta el encendido y apagado de un led, los parámetros a configurar son:

• El retardo de encendido que puede ir de 100 a 1000 milisegundos
• El numero de veces que se ejecutar el ciclo de encendido y apagado del LED

Se emplearan 4 pulsadores para poder navegar en el menú y configurar los parámetros.
Hay dos ejemplos de código, uno realizado con switch - case donde cada caso es una opción del menú. El otro ejemplo emplea estructuras cíclicas while donde un cada ciclo while contiene una opción de menú.

Menú Encendido y Apagado De Un Led

• Enlace del circuito y código empleando switch - case.
• Enlace del circuito y código empleando while.
  

Comunicacion serial con Processing y Arduino

Lectura De Datos Seriales Desde Processing

Elaboración básica de un programa en Processing para leer datos enviados desde un microcontrolador, en este ejemplo Arduino.
En este ejemplo solo se hace lectura de datos tipo entero desde Processing.

Instrucciones Empleadas Para La Comunicación

import processing.serial.* : Importa la librería para la comunicación, esta librería ya esta incluida en processing.

Serial MiPuerto: Instancia o declara un objeto que se empleara para el manejo del puerto serial.

Serial.list() : Da un listado de los puertos seriales disponibles en el computador, sirve para determinar en que posición del listado esta el puerto que se empleara en la comunicación

new Serial(this, ListaPuertos[0], 9600): Inicializa el objeto puerto serial, en este ejemplo el puerto que esta en la posición 0 del listado a una velocidad de comunicación de 9600 baudios.

MiPuerto.read() : Instrucción para la lectura de datos enviados por el puerto serial, la lectura se hace del buffer o pila que almacena los datos enviados. El buffer o pila puede almacenar muchos datos que son leídos uno a uno.

MiPuerto.clear() : Limpia el buffer o pila que almacena los datos seriales recibidos, es útil para una lectura inmediata del dato enviado por el microcontrolado a costa de la perdida de datos.

Más informacion se puede consultar en:

•  Información de SparkFun

Código en Processing

import processing.serial.*;
String ListaPuertos[];
Serial MiPuerto;
int DatoLeido;
float VoltajeLeido;
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
}
void draw() {
  DatoLeido=MiPuerto.read();
  println("Dato = "+DatoLeido);
  VoltajeLeido=(float(DatoLeido))*0.019607843;
  println("Voltaje = "+VoltajeLeido);
  MiPuerto.clear();
}  

Envío de una cadena de caracteres desde Arduino

Processing tiene la clase String que permite hacer manejo de cadena de caracteres lo que facilita el envío y recepción de estas por medio del puerto serial.

En el siguiente ejemplo el envío de la cadena se hace desde la tarjeta Arduino y la recepción se hace en Processing.

La cadena ser recibe desde processing con la instrucción

CadenaRecibida = MiPuerto.readStringUntil('\n');

El metodo readStringUntil indica que se hace la lectura hasta que encontrar un salto de linea que se indica con  '\n'  en Arduino se emplea la instrucción

 
Serial.println("Hola Mundo");

Para enviar una cadena de caracteres con salto de linea

Código de Arduino

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

void loop(){
  Serial.println("Hola Mundo");
  delay(100);
} 

Código de Processing

import processing.serial.*;
String ListaPuertos[];
String CadenaRecibida;
Serial MiPuerto;
int DatoLeido;
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
}

void draw(){
  if ( myPort.available() > 0){
    CadenaRecibida = MiPuerto.readStringUntil('\n');
  } 
  println(CadenaRecibida);

}

Envío de un dato desde Processing a Arduino

En este caso se emplea la instrucción MiPuerto.write() para enviar una dato de byte que puede ser un valor entero o carácter.

En este ejemplo se envía el carácter '1' o su equivalente entero en ASCII que es 49 para encender un led de la tarjeta Arduino.

Código de Arduino

char Dato; 

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

void loop() {
   if (Serial.available()){
     Dato = Serial.read();
   }
   if (val == '1') { 
     digitalWrite(ledPin, HIGH);
   } else {
     digitalWrite(ledPin, LOW);
   }
   delay(10);
}  

Código de Processing

import processing.serial.*;
String ListaPuertos[];
String CadenaRecibida;
Serial MiPuerto;
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
}

void draw() {
  if (mousePressed == true){                          
    myPort.write('1');
  }else {                           
    myPort.write('0');
  }   
}

Envío y recepción Processing a Arduino

En este caso se hace tanto envío como recepción de datos entre las dos plataformas.

Se hace el uso de la función establecerComunicacion para garantizar que se ha establecido la comunicación entre las dos plataformas. 

Código de Arduino

char Dato;

boolean EstableComunicacion; 

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

   establecerComunicacion();

   EstadoLed=false; 

   EstableComunicacion =false;

 }

void loop()
{
  if (Serial.available() > 0) { 
    Dato = Serial.read();
    if(val == '1'){
       ledState = !ledState; //Cambia de estado
       digitalWrite(13, ledState); 
    }
    delay(100);
  } else {
    Serial.println("Listo para recibir");
    delay(50);
   }
}

void establecerComunicacion() {
  while (Serial.available() <= 0) {
    Serial.println("A");//Envia el caracter A procurando establecer comunicacion 
    delay(300);
  }
} 

Código de Processing

import processing.serial.*;
String ListaPuertos[];
String CadenaRecibida;
Serial MiPuerto;

boolean EstableComunicacion = false; 

void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
 MiPuerto.bufferUntil('\n');//Envia el evento hasta detectar un fin de linea
}
void draw() {

 //Nada de momento

}

void serialEvent( Serial myPort) {
  CadenaRecibida = myPort.readStringUntil('\n');
  if (CadenaRecibida != null) {//Verifica que la cadena no este vacia
    CadenaRecibida = trim(CadenaRecibida);//Elimina espacios y saltos de linea de cadena
    println(CadenaRecibida);//Muestra en la consola la cadena recibida
    if (EstableComunicacion == false) {//Si no se ha establecido por primera vez la comunicacion
      if (CadenaRecibida.equals("A")) {//Si la cadena recibida es la letra A
        MiPuerto.clear();//Limpia buffer
        EstableComunicacion = true;//Indica que se estableció comunicacion
        MiPuerto.write("A");//Envia el caracter A la la tarjeta Arduino
        println("Se estableció comunicacion");//Muestra en la consola que ya hay comunicacion
      }
    } else {//Ya hay comunicacion con la tarjeta
      println(CadenaRecibida);//Muestra en consola la cadena recibida
      if (mousePressed == true) {//Si el raton es presionado                           
        MiPuerto.write('1');//Envia el caracter 1        
        println("1");//Muestra en consola que se envio el 1
      }
      MiPuerto.write("A");//Envia el caracter A procurando establecer comunicacion
    }
  }
}