En cierta ocasión en el instituto donde laboro, se me acercaron unos alumnos de la especialidad de electrónica, ellos querían que los asesorara para realizar una práctica donde vincularan la tarjeta MSP430 Launchpad de Texas Instruments Rev. 1.5, con un software de computadora. Como ya era casi final del semestre, estaba un poco atareado, así que el primer software que se me vino a la mente para vincular el Launchpad fue Processing (Processing lo llegué a utilizar, gracias a mi amigo Alex, el cual espero se encuentre muy bien).
Processing es un software libre y de código abierto, el cual sirvió de base para los entornos de desarrollo de Arduino y Energia.
Por otro lado, la tarjeta MSP430 Launchpad es detectada por la computadora como un convertidor de USB a Serie, por lo que en el administrador de dispositivos de Windows, aparece como un puerto COM.
(clic en la imagen para expandir)
Esto nos da mucha ventaja, ya que no necesitamos hacer muchos ajustes para comunicar nuestra tarjeta con Processing, el único ajuste que debemos hacer es colocar los jumpers de la tarjeta MSP430 Launchpad como se muestra a continuación:
(clic en la imagen para expandir)
El software que utilizaremos para programar el Laucnhpad será Energia (si es la primera vez que utilizan el MSP430 Launchpad y el software Energia, pueden consultar en mi otro blog de galfama.blogspot.mx el siguiente enlace donde se muestra como utilizarlos: Enlace).
En este ejemplo se leerá el valor de una entrada analógica de la tarjeta MSP430 Launchpad Rev. 1.5 con el microcontrolador M430G2553 (en la cual se conectará un potenciómetro de 10KΩ), y se enviará el valor correspondiente (previo ajuste de rango) a una computadora usando comunicación serial, y en ésta última se controlará el color de fondo de una figura usando Processing. A continuación se muestra la forma de conectar los componentes:
(clic en la imagen para expandir)
(clic en la imagen para expandir)
Para este ejemplo he utilizado la versión Energia 0101E0012 (03/18/2014), la cual pueden descargar del siguiente link:
A continuación les coloco el código que se ha programado en la tarjeta MSP430 Launchpad con el microcontrolador M430G2553 incluido en el kit de desarrollo:
////////////////////////////////////////////
// Blog: microsysoftware.blogspot.mx //
// País: México //
// Fecha: 22/07/2014 //
////////////////////////////////////////////
// Programa que lee la entrada analógica pin A3 (P1.3) de la tarjeta MSP430 Launchpad Rev. 1.5,
// y envía al valor a una computadora usando
// comunicación serial.
// Hardware Requerido:
// - MSP-EXP430G2 LaunchPad (MSP430G2553)
// - Potenciómetro de 10 kilo-Ohms
// - Cables de conexión
void setup()
{
//Se declara que se utilizará comunicación serial
//a 9600 bauds, por default la transmisión es de 8 bits.
Serial.begin(9600);
}
//Este bloque de código hace un bucle infinito.
void loop()
{
// Se lee la entrada analógica (pin A3),
// y el valor se guarda en una variable de tipo entero
// llamada adc.
int adc = analogRead(A3);
// Con la siguiente instrucción, se hace un ajuste,
// ya que la instrucción analogRead entrega valores
// comprendidos entre 0 y 1023, debido a que el ADC
// del microcontrolador
// tiene una resolución de 10 bits, y con esta instrucción
// la variable adc solo tomará valores entre 0 y 255.
adc = map(adc, 0, 1023, 0, 255);
// Se envía por el puerto serie el valor del adc.
Serial.write(adc);
delay(100); // Ocurre un retardo de 100 ms.
}
A continuación se ha colocado el código que se ha programado en Processing (es una modificación de un código que trae de ejemplo Processing) y el enlace para descargar éste último (en este ejemplo se ha utilizado la versión 2.1 de 32 bits porque la de 64 bits aún no tiene implementado el puerto serie):
http://download.processing.org/processing-2.1.2-windows32.zip
import processing.serial.*; //Se incluye la librería para usar el puerto serie.
Serial puerto; // Se crea un objeto llamado puerto.
int dato; // Variable que recibirá el dato del puerto serie.
void setup()
{
// La siguiente instrucción define las medidas en pixeles de la pantalla
// que se genera con el bloque void draw().
size(400, 400);
// Posteriormente la siguiente instrucción imprime los puertos
// disponibles en nuestra computadora.
println(Serial.list());
// Dependiendo de los puertos disponibles de nuestra computadora
// se enumeran partiendo del 0, y se modifica el valor encerrado entre "[]". Ejemplo:
// Puerto PC Valor
// COM1 --> [0]
// COM3 --> [1]
// COM5 --> [2]
// COM6 --> [3]
String portName = Serial.list()[0];
// Se inicializa el puerto seleccionado
// con una velocidad de 9600 bauds y 8 bits en la comunicación. puerto = new Serial(this, portName, 9600);
}
// Bloque de código que muestra una pantalla con fondo azul y un cuadrado
// en el centro cuyo color de relleno depende del valor de la variable dato.
void draw()
{
if (puerto.available() > 0) // Si hay un dato disponible en el puerto serie.
{
dato = puerto.read(); // Se almacena en la variable dato.
}
background(500); // Hace azul el fondo de la pantalla que se muestra.
textSize(14); // Define el tamaño del texto que se va a mostrar.
text("Valor del ADC="+dato, 50, 25); //Imprime el valor de la variable dato.
fill(dato); // Cambia el color de fondo de la figura central (cuadrado).
rect(50, 50, 300, 300); // Dibuja un cuadrado cuyo color de
// fondo depende del valor de la variable dato.
}
Por último se muestra un video con el funcionamiento del circuito y del programa descrito arriba, además de algunas recomendaciones:
¡Muchas gracias por leer esta nueva entrada!
ALF
