10 cosas que necesitas saber para utilizar Arduino desde Java

10 cosas que necesitas saber para utilizar Arduino desde Java


febrero 24, 2014Antony García González







Arduino, una poderosa plataforma de hardware libre, ideal para poyectos de electrónica que van desde el encendido de un LED hasta un complejo sistema de domótica para controlar una casa entera. Java, uno de los lenguajes de programación más extendidos del mundo. ¿Podemos utilizar Arduino desde Java? ¡Por supuesto!


Veamos 10 aspectos que necesitamos comprender para crear proyectos de alto nivel combinando estas dos grandes tecnologías.
1. No se puede programar Arduino utilizando el lenguaje Java


Arduino y Java son dos entes independientes. Arduino es una plataforma de hardware libre con su propio lenguaje, mientras que Java es un lenguaje de programación de alto nivel. Java necesita para su ejecución la Máquina Virtual de Java, la cual, hasta ahora no puede ser ejecutada desde Arduino.


Sin embargo esto no significa que no podamos crear programas en Java que le envíen instrucciones a Arduino entregándonos el control de circuitos electrónicos desde una interfaz en la computadora.

2. Arduino se comunica con la computadora por medio de Comunicación Serial





Uno de los primeros aportes que escribí para este blog fue como establecer comunicación entre la computadora y Arduino por medio de comunicación serial.





Esta es la forma más sencilla de comunicación que existe entre Arduino y la computadora, ya que aprovecha el puerto USB por medio de un convertidor USB-Serie.


Resulta que para poder comunicar nuestras aplicaciones en Java con Arduino debemos aprovechar la comunicación serial, lo cual es perfectamente posible si se implementan las librerías adecuadas.

3. Para permitirle a Java establecer comunicación con el Puerto Serie se requiere instalar los drivers de la librería RXTX


La librería RXTX es una compilación de código que le permite a los programadores en Java establecer comunicación con el Puerto Serie. Alguna vez escribí un post que hace referencia a los requisitos para comunicar Arduino con Java.


Desde dicho post es posible descargar los Archivos JAR para 32 y 64 bits (Windows) que se deben importar a los proyectos Java para hacer posible lo que deseamos hacer. Algunas personas presentan problemas a la hora de instalar estos archivos en sus computadoras, por lo que en algún momento decidí crear un post exclusivo para resolver estas dificultades.




4. Usar la librería RXTX es un poco difícil… ya existe una librería especial para Arduino en Java


La librería Arduino para Java es una compilación de código que facilita mucho la comunicación Arduino-Java, Java-Arduino.


Es posible lograr esta comunicación utilizando la librería RXTX, como mostré en uno de mis aportes. Sin embargo, si hacemos un análisis comparativo entre lo que se requiere con una u otra librería, nos damos cuenta que la diferencia es muy marcada. Yo diseñé la librería Arduino para Java a partir de la RXTX creando algunos métodos que comprimen los comandos que se requieren para establecer una conexión, enviar y recibir datos.


Para poder lograr esta comunicación, es necesario importar ambas librerías, la Arduino y la RXTX ya que la primera depende de la segunda.

5. Al crear un programa en Java y establecer comunicación con Arduino, se está remplazando el Monitor Serial por una interfaz gráfica





Cuando se crea un programa en Arduino que requiera de la intervención del usuario por medio del Monitor Serial lo que hacemos es enviarle caracteres, sean letras o números. Estos caracteres se leen en Arduino, se interpretan y devuelven un resultado, si es necesario.


Un ejemplo de esto es cuando encendemos un LED desde el teclado de la computadora. En dicho código se lee un caracter. Si el caracter recibido es un 1, se enciende un LED. De lo contrario, se apaga.


Para lograr el mismo resultado con un programa en Java, pues se crea una interfaz con dos botones, uno para encender y otro para apagar. Cuando se presiona el botón de encender, se le indica a Java que envíe un “1” a Arduino. La librería Arduino cuenta con un método, SendData(), con el cual es posible hacer esto. En el botón de apagado, se envía un “0” o cualquier otro caracter. Al presionar cualquiera de los dos botones, estamos emulando lo que haríamos con el Monitor Serial, enviando un 1 o un 0 para encender o apagar.


¿La ventaja de las interfaces? Tenemos botones gráficos estilizados, lo que hace nuestros proyectos más interesantes, interactivos y profesionales. Un ejemplo de esto lo mostré en el post Arduino y Java: Encendiendo LEDs desde un programa en nuestra PC.

6. Para cada tipo de comunicación existen métodos especiales


Se pueden dar tres tipos de situaciones…
Cuando se necesita transmitir datos de Java a Arduino
Cuando se necesita transmitir datos de Arduino a Java
Cuando se necesita enviar y recibir datos entre Arduino y Java


Para esto, la librería Arduino para Java posee tres tipos de conexiones: ArduinoRX(),solamente para recibir datos en Java. ArduinoTX(), solamente para transmitir datos en JavaArtuinoRXTX(), para transmitir y recibir datos en Java


Los tres métodos tienen parámetros que se deben establecer a la hora de utilizarlos. En todos hay que establecer el puerto COM al que está conectado Arduino (ejemplo: “COM6”), el baudRate (que debe ser igual al establecido en el Serial.begin() en Arduino), un timeOut (tiempo de espera entre el inicio de la conexión y el envío/recepción de datos) y en algunos casos un SerialPortEventListener para detectar cuando se han enviado datos de Arduino a Java.

7. Java se da cuenta cada vez que Arduino le envía datos


Cuando es necesario enviar datos de Arduino a Java, se utiliza un SerialPortEventListener, el cual requiere de la implementación de un método abstracto, SerialEvent().


El SerialEvent() se ejecuta cada vez que se recibe un dato en el Puerto Serie. Los datos en el Puerto Serie se reciben caracter por caracter, lo que significaría un problema ya que si enviamos un mensaje de texto, recibiremos el mensaje letra a letra. Usando el métodoReceiveData() obtenemos estos caracteres. Sin embargo, también existe el métodoMessageAvailable() que devuelve un valor true cuando se haya finalizado la recepción de cualquier mensaje enviado desde Arduino con el método Serial.println().


Cuando el método MessageAvailable() devuelve un valor true, entonces se recibe el mensaje con PrintMessage(). El mensaje será recibido como un String y podrá ser usado como desee el usuario dentro de Java.

8. En Java es posible graficar los datos que leemos en los sensores conectados a Arduino





Existe la librería JFreeCharts. Podemos crear una interfaz que recibe, procesa y grafica los datos en tiempo real, como ya mostramos en el post “gráficas de sensores en tiempo real con Arduino, Java y JFreeChart“.

9. Las interfaces gráficas en Java le agregan versatilidad a los proyectos en Arduino











Los elementos de programación de alto nivel disponibles en Java permite manipular las interfaces electrónicas con mayor versatilidad, como se muestra en los siguientes aportes:
Java + Arduino: Encendiendo un LED RGB desde un programa en nuestra PC
Arduino + Java: Enviando mensajes a pantalla LCD desde Java con Arduino
Arduino+Java: Ejemplo de LED Blink con Java Threads
Arduino+Java: LED de frecuencia variable con Java Threads
Arduino+Java: Graficando datos de sensor ultrasonico HC-SR04
Arduino + Java: Variar los colores de un LED RGB con PWM
Arduino+Java: Variar resistencia de circuito eléctrico desde programa en Java
Arduino+Java: Controlando motores de corriente directa desde la computadora
10. Utilizar Arduino desde Java: El límite es el infinito


Las posibilidades que nos brinda la programación en Java para interactuar con Arduino son infinitas. Está en cada quien desarrollar sus capacidades en programación y electrónica para empezar a crear proyectos más y más exigentes. Los contenidos que hay en este blog se han tratado de confeccionar de la manera más atinada para asegurar que los conceptos que deseamos transmitir lleguen a nuestros lectores de manera clara, precisa y concisa.


Espero que esta información sea de utilidad para ustedes. Saludos
Java: El gran compañero de Arduino
enero 28, 2013Antony García González


Java es un lenguaje de programación desarrollado por James Gosling de Sun Microsystems, que posteriormente sería adquirido por Oracle. Fue publicado en 1995 y desde entonces se ha colocado en la lista de los lenguajes más utilizados en el mundo entero. Su sintaxis se deriva del lenguaje C/C++, por lo que si usted sabe programar en C no tendrá problemas en hacer una transición a Java.

En lo personal soy un gran fanático de Java y he aprendido mucho de este lenguaje en los 20 meses que llevo programando en él. Java ofrece múltiples ventajas si lo comparamos con otros lenguajes, entre ellas la posibilidad de correr en casi cualquier tipo de plataforma que tenga instalada la Máquina Virtual de Java que es el componente principal que se necesita para poder utilizar aplicaciones escritas en Java.

Con este lenguaje de programación podemos hacer cualquier tipo de aplicación de escritorio o bien applets orientados a Internet. Hay quienes desarrollan aplicaciones para celulares y otros dispositivos portátiles. Nosotros utilizaremos Java para realizar proyectos con Arduino.

Dentro del lenguaje Java, que es un lenguaje de programación orientada a objetos podemos encontrar librerías que nos permiten comunicarnos con el Puerto Serie de nuestra computadora, por lo que es posible para nosotros utilizar dichas librerías y establecer comunicación con Arduino.

Si usted es programador no tendrá ningún problema con adaptarse a Java. Sin embargo si sus conocimientos de programación son pocos o escasos, yo les proporcionaré los métodos y las herramientas necesarias para que usted pueda realizar sus proyectos con Arduino y Java.

Para programar en java necesitamos:



Máquina virtual de Java

Kit de Derarrollo Java (Java Development Kit)

NetBeans IDE

Descargamos estos 3 programas y los instalamos en nuestra computadora. Se debe instalar en el orden en los cuales los he escrito arriba.


Cuando hallamos terminado tendremos el NetBeans IDE instalado en nuestra computadora. Dicho programa es una plataforma de desarrollo para software Java. En NetBeans es donde se crean las aplicaciones. Nos proporciona todas las herramientas necesarias para que podamos crear software a partir de 0.

Existen otras plataformas de desarrollo, como Eclipse, sin embargo mi conocimiento me permite sugerir a todos los principiantes y a los que ya poseen conocimientos que el mejor IDE para desarrollar en Java es NetBeans.

Yo me inicié en Java en julio del año 2011 utilizando NetBeans IDE. Recibí mucha ayuda de alguien que es considerado un experto en Java y en el uso de NetBeans. Es panameño, pertenece a la Universidad Tecnológica de Panamá y puede ser encontrado en el Centro Tecnológico Universitario Tecnológico de Azuero en la Facultad de Ingeniería en Sistemas. Es miembro de NetBeans Dream Team, una excelente persona y alguien que no dudará en ayudar a cualquiera que lo necesite y esté interesado en iniciarse en Java. Su nombre esAristides Villarreal Bravo. Les recomiendo que visiten su blog AVBravo. El está constantemente publicando material acerca de Java, con tutoriales ilustrados y mucha información de interés.

Ahora veamos como luce NetBeans IDE:



NetBeans ofrece una interfaz amigable para el usuario, lo que hace posible que sea muy fácil crear nuestra primera aplicación en Java.

En mi próximo post estaré publicando como crear una sencilla aplicación “Hola Mundo” en Java.
Función ArduinoConnection(): Comunicar Arduino con Java
enero 31, 2013Antony García González


Para poder comunicar una aplicación en Java con Arduino se necesita declarar las siguientes variables:



1
2
3
4
5
private OutputStream Output = null;
SerialPort serialPort;
private final String PORT_NAME = "COM3";
private static final int TIME_OUT = 2000;
private static final int DATA_RATE = 9600;


Estas variables funcionan de la siguiente forma:

Output: Es un OutputStream que se utiliza para enviar datos Utilizando el puerto Serie.

serialPort: Con esta variable iniciamos el Puerto Serie.

PORT_NAME: El nombre del puerto COM. En mi caso es COM 3 para Arduino Mega y COM 6 para Arduino Nano que son los 2 microcontroladores que tengo bajo mi poder.

TIME_OUT y DATA_RATE: son variables que utiliza el Puerto Serie para su funcionamiento. Generalmente se utilizan los valores 2000 y 9600, respectivamente.

Ahora veamos la función que llamaremos ArduinoConection:






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public void ArduinoConnection() {

CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {
portId = currPortId;
break;
}
}

if (portId == null) {

System.exit(ERROR);
return;
}

try {

serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);

serialPort.setSerialPortParams(DATA_RATE,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);

Output = serialPort.getOutputStream();

} catch (Exception e) {

System.exit(ERROR);
}

}




Si copiamos esta función en el código de cualquier programa que estemos construyendo en Java, podremos enviarle datos a Arduino.

Una última función, EnviarDatos, será la función que recibirá los parámetros que desemos enviar.





1
2
3
4
5
6
7
8
9
10
private void EnviarDatos(String data) {

try {
Output.write(data.getBytes());

} catch (IOException e) {

System.exit(ERROR);
}
}





Con las variables declaradas en el inicio de un programa en Java, junto con estos 2 métodos podremos hacer miles de cosas interesantes con Arduino.
Comunicación Serial: Enviando datos de Arduino a Java
febrero 13, 2013Antony García González

La información suministrada en este post es considerada por mi persona como obsoleta debido a que fue publicada antes de mi librería Arduino para Java. Recomiendo visitar el siguiente post donde se explica el uso de la misma y donde es muy fácil comunicar Arduino con Java y vice versa.


***

Hola amigos. En las últimas semanas he estado escribiendo mucho acerca de Arduino, de Java y de como podemos utilizar ambas plataformas para realizar grandes proyectos. Empecé escribiendo como establecer Comunicación Serial con Arduino. Luego escribí como enviar datos de Java a Arduino a través de los métodos ArduinoConnection() yEnviarDatos().

Ahora es tiempo de aprender como recibir datos en Java desde Arduino. Para ello utilizaremos un método similar a EnviarDatos(): RecibirDatos().

Para poder utilizar este método necesitamos modificar nuestra funciónArduinoConnection() y declarar algunas variables.

Los datos que enviamos de Arduino a Java se envían a través de una variableOutputStream llamada Output. Ahora declararemos una variable del tipo InputStreamllamada Input.

private InputStream Input;


Resumiendo, las variables que necesitamos utilizar para comunicar Arduino y Java, y vice versa, son las siguientes:



1
2
3
4
5
6
private OutputStream Output = null;
private InputStream Input = null;
SerialPort serialPort;
private final String PORT_NAME = "COM3";
private static final int TIME_OUT = 2000;
private static final int DATA_RATE = 9600;






Ahora necesitamos inicializar la variable Input. Esto se hace en la función ArduinoConnection() donde ya existe una línea que inicializa la variable Output.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public void ArduinoConnection() {

CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {
portId = currPortId;
break;
}
}

if (portId == null) {

System.exit(ERROR);
return;
}

try {

serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);

serialPort.setSerialPortParams(DATA_RATE,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);

Output = serialPort.getOutputStream(); //Se prepara a Output //para enviar datos
Input = serialPort.getInputStream(); //Se prepara input para //recibir datos

serialPort.addEventListener(this); //Se agrega un Event //Listener
serialPort.notifyOnDataAvailable(true); //Se indica que se //notifique al usuario cuando sea que halla datos disponibles en //el puerto serie
} catch (Exception e) {

System.exit(ERROR);
}

}




Como vemos, se prepara a la variable Input de la misma manera que a la variable Output. Hemos agregado 2 líneas más a nuestra función ArduinoConnection():



1
2
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);





Esto permite que se genere un evento cada vez que Arduino envíe datos a Java. Para poder que esto funcione es necesario que implementemos la interfaz SerialPortEventListener de la misma manera que implementamos la interfaz Runnable cuando utilizamos los Java Threads.



Por último necesitamos agregar un método en donde se establezca las acciones que se harán cuando ocurra un SerialPortEvent.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public synchronized void serialEvent(SerialPortEvent oEvent) {
if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
int datos;
datos = RecibirDatos(); //Se invoca la función RecibirDatos()

//Esta función devolverá un valor entero en formato ASCII.
System.out.println((char)datos); //Se imprime en el mensaje

//haciendo la conversión de ASCII a nuestro alfabeto.
} catch (Exception e) {
System.err.println(e.toString());
}
}
}




Por último agregamos RecibirDatos():



1
2
3
4
5
private int RecibirDatos() throws IOException {
int Output = 0;
Output = Input.read();
return Output;
}


Con estas variables y estos métodos podemos lograr lo que queremos. Ahora es tiempo de probar si funciona o no.

Yo agregué los elementos necesarios al ejemplo Blink que ya hicimos:

Ahora vamos a Arduino y escribimos lo siguiente:



1
2
3
4
5
6
7
8
9
10
int count=0;
void setup(){
Serial.begin(9600);
}

void loop(){
Serial.print(count);
count++;
delay(1000);
}




Con estos cambios estamos listos para ver como trabaja nuestro código. Lo que haremos es enviar el valor de una variable, en este caso, count, de Arduino a Java, con la salvedad de que cada segundo se aumentará el valor de count en 1 unidad.

Utilizamos Serial.print para enviar el mensaje. Si utilizamos println enviaremos el mensaje con un salto de renglón. Si utilizamos Serial.write, entonces no enviaremos el mensaje en ASCII sino como bits. El problema con esto es que es un bus de 8 bits, por lo que no podremos enviar valores más arriba del 255, ya que 2 elevado a la octava potencia es 256 y el bus solo admite 8 bits, del 0 al 255.

Aquí vemos la demostración:

https://youtu.be/K_ifGhgt09k
Arduino + Java: Encender un LED desde un programa en la PC
agosto 13, 2013Antony García González


***Este post fue originalmente publicado el 31 de enero de 2013, pero lo estoy re posteando ya que esta vez utilizaré la librería Arduino para Java que yo mismo diseñé y que no fue incluida en la publicación original

En este artículo voy a mostrar como encender un LED desde un programa en la PC hecho con el lenguaje de programación Java, utilizando Netbeans IDE.

Uno de los principios de la Robótica es lograr que un dispositivo electrónico sea controlado por el usuario a través de una computadora. Con Arduino podemos controlar circuitos utilizando aplicaciones escritas en cualquier lenguaje de programación que soporte comunicación serial. Para efectos de este post, concentraremos nuestros esfuerzos en lograr que un circuito sencillo, como lo es un LED y una resistencia puedan ser conmutados desde nuestra computadora, utilizando una interfaz en Java y nuestro microcontrolador Arduino. En mis anteriores aportes me he enfocado en explicar como crear una sencilla aplicación en Java, con un botón y un jLabel. También vimos como trabajan las funciones en Java. Para poder enviar y recibir información a través del puerto serie con Java se necesita instalar las librerías RXTX. Por último, toda aplicación debe contar con la Librería Arduino para Java. Con toda esta información somos capaces de lograr nuestro acometido. Empezemos. Primero abrimos Netbeans y creamos un proyecto llamado ArduinoSwitch. Insertamos un jFrame y colocamos 2 botones: Encender y Apagar.

Necesitamos renombrar los nombres de los botones. Los llamaremos jButtonEncender yjButtonApagar. Ahora al botón de Apagar le vamos a quitar la opción “enabled” en las propiedades del control. Esto lo que hará es que al iniciar el programa no se pueda presionar el botón de apagado mientras el LED esté apagado. Si ejecutamos el programa, la interfaz es la siguiente: Ahora vamos a programar. Lo primero que debemos hacer es agregar las librerías RXTX yArduino a nuestro programa. Abrimos el código fuente e instanciamos la librería Arduino. Le damos clic al ícono amarillo de la izquierda y seleccionamos la primera opción. Esto logrará que se elimine el error. En el método principal se inicializa la conexión con Arduino. Como solo vamos a encender y apagar, se usa ArduinoTX. Los parámetros que colocaremos son los siguientes: PORT NAME: Nombre del puerto donde está conectado Arduino (por ejemplo, COM24, COM25, COM 25, etc). TIME OUT:Tiempo de espera entre el inicio de la ejecución y el envío de comandos. Se utiliza 2000 por default. DATARATE: El baud rate de la comunicación serial. Normalmente se usa 9600. Agregamos los parámetros que estemos usando en nuestro proyecto y metemos todo en una estructura Try-Catch. Con esto hemos terminado la conexión con Arduino. Necesitamos programar los botones. Lo que haremos será que cuando presionamos el botón de encender, este se desactive y solo quede activo el botón de apagar. Le damos doble clic al botón “Encender” en la interfaz de diseño e insertamos la programación. Al presionar encender, se desactivará el botón y cambiará el color a gris. Se activara el botón apagar y cambiará a dorado. Usaremos la clase Color para los colores, los cuales necesitamos introducir en formato RGB. Así luce la programación: El comando que va a encender el LED en Arduino será un “1” el cual enviaremos utilizando la función Arduino.SendData().

En el botón apagar se copia el mismo código pero se le hacen algunas ligeras modificaciones.Hemos terminado la programación en Java. Ahora solo hay que subir el código a nuestro Arduino para que todo nos funcione bien. Primero el esquemático:


Nótese que el cátodo (positivo) del LED está en el pin 13 y el cátodo en GND (verificar los electrodos dentro del propio LED). Ahora la programación:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int input;

void setup(){

pinMode(13, OUTPUT); // Declaramos que utilizaremos el pin 13 como salida

Serial.begin(9600);
}

void loop(){
if (Serial.available()>0){

input=Serial.read();

if (input==’1′){

digitalWrite(13, HIGH); //Si el valor de input es 1, se enciende el led

}

else

{

digitalWrite(13, LOW); //Si el valor de input es diferente de 1, se apaga el LED

}

}
}


Con esto estamos listos para ejecutar. En el siguiente video (el que publiqué en la versión original, viejo y sin mucha calidad) se muestra la pequeña interfaz que hemos hecho funcionando con un LED. Los archivos de este proyecto se encuentran disponibles en el siguiente enlace:http://docs.google.com/file/d/0B0hsUkhqWH97a1BDUU02MlB4WXM Espero que toda la información suministrada sea de su completo agrado. Saludos.






Como podemos observar los datos se envían 1 a 1, es decir, caracter a caracter.

Espero sus comentarios. Saludos.



5 pasos a seguir para encender un LED en Arduino desde Java
enero 21, 2015Antony García González


La siguiente entrada pretende ser una sencilla guía para encender un LED en Arduino desde Java. Se proporcionan los archivos e instrucciones necesarias para lograr esto.

En este blog nos hemos caracterizado por postear muchos contenidos acerca del uso de Arduino y Java. Hay un sinnúmero de ejemplos a disposición del usuario con mucha documentación al respecto. Contamos con nuestra propia API, la librería PanamaHitek_Arduino.

En esta entrada me gustaría mostrarle al usuario lo sencillo que es encender LED en Arduino desde Java. Quiero aclarar que en vez de un LED podríamos encender un motor, una lámpara de corriente alterna o cualquier otro dispositivo si contamos con la electrónica apropiada. Por lo pronto usaremos un LED.

Paso 1 – Descargar el software ArduinoSwitch

El ArduinoSwitch es un software diseñado por nosotros en Panama Hitek para que trabaje como una pequeña interfaz para el control de un LED en Arduino. Puede ser utilizado para manejar otro tipo de cargas, pero en esta ocasión como ya he expresado en la introducción de este post, usaremos un LED.

Podemos descargar este software desde nuestro repositorio en GitHub.






Hacemos clic en Source Code (zip) y descargamos un archivo comprimido con los ficheros que necesitaremos. También necesitamos descargar el fichero ArduinoSwitch v1.0.0.jar

Paso 2 – Descomprimimos el archivo ZIP

Vamos a la carpeta donde descargamos nuestros fichero y lo descomprimimos.






Dentro veremos 3 carpetas, una con el Diagrama Electrónico, una con el código Arduino y otra con el código Java.

Paso 3 – Armamos el circuito

Vamos a la carpeta Diagramas Electrónicos y veremos una imagen donde se indica cómo se debe armar el circuito. Para este caso es muy sencillo, basta apenas con conectar un LED al pin 13 de Arduino.





Es necesario que tomen en cuenta que el LED es un diodo y se debe conectar de forma apropiada, con el cátodo a GND y el ánodo al pin 13. Basta con mirar en el interior del LED, donde el terminal más grueso es el cátodo (GND).

Nuestra conexión nos debe quedar así:





Paso 4 – Programamos nuestro Arduino

Vamos a la carpeta Arduino y veremos un fichero llamado ArduinoSwitch.ino. Lo abrimos y lo subimos a nuestra placa Arduino.

A continuación el código contenido dentro del Archivo:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*
-------------------------
| Arduino Switch v1.0.0 | Diseñado por Antony García González, del Panama Hitek Creative Team
-------------------------
Una sencilla aplicación para el encendido de un LED con Arduino y Java. El LED se conecta al pin 13 del Arduino
y desde una interface con dos botones en Java se cambia el estado del LED.

http://github.com/PanamaHitek/ArduinoSwitch
Un video con este ejemplo funcionando está disponible en la siguiente dirección:
http://www.youtube.com/watch?v=9youHjA_fWA
*/

int input;

void setup() {
pinMode(13, OUTPUT); // Declaramos que utilizaremos el pin 13 como salida
Serial.begin(9600); //Se inicia la comunicación serie
}

void loop() {
if (Serial.available() > 0) {

input = Serial.read();

if (input == '1') {

digitalWrite(13, HIGH); //Si el valor de input es 1, se enciende el LED

}
else
{

digitalWrite(13, LOW); //Si el valor de input es diferente de 1, se apaga el LED

}

}
}


Este es el mismo código que hemos usado en otros aportes como:


Comunicación Serial con Arduino: Encender luces desde el teclado de nuestra computadora


Arduino + Java: Encender un LED desde un programa en la PC

Se puede probar el código abriendo el monitor serie y enviando un 1 o un 0, para encender o apagar el LED. Debemos recordar que el código que usaremos en Java no afecta la programación del Arduno, sino que representa una simple interfaz de comunicación entre el usuario y el puerto serie. Si desea saber sobre esto, le recomiendo el siguiente post:
10 cosas que necesitas saber para utilizar Arduino desde Java

Estamos listos para el último paso.

Paso 5 – Ejecutamos el ArduinoSwitch

Ejecutamos el fichero ArduinoSwitch v1.0.0.jar y nos debe aparecer la siguiente interfaz:





Si tenemos nuestro Arduino conectado, le damos clic al botón de refresh y nos aparecerá los puertos COM disponibles. Nos conectamos al puerto donde está nuestro Arduino.

Al conectarnos se habilitará las opciones de Encender y Apagar.





Como podrán imaginar, al presionar en Encender el LED encenderá. Al presionar en Apagar, se apagará. Si le damos clic en Desconectar, finalizamos la conexión con Arduino. A continuación un par de videos mostrando el software en acción, uno utilizando un LED y el otro con un lámpara de corriente alterna (110VAC, 50 watt):

https://youtu.be/mbvZ5GVXPYY
https://youtu.be/DSZLIBTxvZU




Como vemos es sumamente sencillo hacer uso de este software y lograr el encendido de un simple LED a través de software.

Eso es todo por ahora. Saludos.