Camino a la Programación en JAVA

Pues como el título de esta entrada indica, me he propuesto a darle una oportunidad al lenguaje de programación JAVA, ¿Por qué? Pues sencillamente, la idea de que sea multiplataforma, es decir, independiente del sistema operativo que uno use, me atrae bastante, ya que solo tenemos que preocuparnos de tener instalada la máquina virtual de JAVA en nuestro sistema operativo y con esto, nuestro programa debería funcionar sin dar muchos problemas.

Ahora bien, mis desarrollos informáticos van orientados al obtener lecturas procedentes de sistemas embebidos, es por ello que se necesitará usar periféricos tales como el Puerto Serie o el USB.

Y JAVA para esto, cojea un poco, ya que no tiene librerías propias, así que deberemos recurrir a librerías externas, en nuestro caso, vamos a hablar sobre la librería que controla el Puerto Serie.

Si hacéis una búsqueda en Internet, podréis encontrar multitud de librerías ( algunas gratuitas, otras no ) para tal menester, en mi caso he escogido la siguiente: RXTX ( gratuitas ).

Y mi decisión ha sido esa ya que tiene muy buenos comentarios y la gente no se suele quejar mucho de su manejo. Ahora bien, para usarla, deberemos instalarla primero de manera manual. Y los pasos a seguir serán los siguientes:



· PASO 1. El primer paso, es identificar de que arquitectura es nuestro sistema operativo: 32-bits o 64-bits. Ésto es muy importante ya que en caso de instalar la librería distinta a nuestra arquitectura, nuestro programa no funcionará.

Por lo tanto, el primer paso sería descargar las librerías asociadas a nuestro sistema operativo, las de 32 o 64-bits.



· PASO 2. Una vez tengamos la librería descargada en nuestro ordenador referente a la arquitectura de nuestro sistema operativo, descomprimamos y deberíamos tener tres archivos:

El primer archivo es el llamado: RXTXcomm.jar ( ARCHIVO 1 ) y es independiente del sistema operativo que tengamos instalado en nuestro ordenador.

Los siguientes archivos dependerán del sistema operativo que tengamos instalado:


· WINDOWS: Tendremos dos librerías:

· Librería de nombre ( ARCHIVO 3 ): rxtxParallel.dll.
· Librería de nombre ( ARCHIVO 2 ): rxtxSerial.dll.


· LINUX: Tendremos dos librerías:

· Librería de nombre ( ARCHIVO 3 ): librxtxParallel.so.
· Librería de nombre ( ARCHIVO 2 ): librxtxSerial.so.


· MAC: Tendremos una librería:

· Librería de nombre ( ARCHIVO 2 ): librxtxSerial.jnilib.


· SOLARIS: Tendremos dos librerías:

· Librería de nombre ( ARCHIVO 2 ): librxtxSerial.so.
· Librería de nombre ( ARCHIVO 3 ): librxtxSerial-2.1-7.so.

· PASO 3. Una vez identificados los tres archivos necesarios ( en ciertos sistemas operativos solo serán dos archivos ), deberemos instalarlos en nuestro equipo de manera manual.

Antes que nada, tenemos que asegurarnos que tenemos instalado JAVA ( máquina virtual ) en nuestros equipos, en caso contrario, se deberá descargar e instalar antes de proceder. Para descargar la máquina virtual de JAVA, está disponible en el siguiente enlace: Máquina virtual JAVA.


· NOTA: Los pasos que se describen a continuación serán descritos para sistemas operativos WINDOWS, pero para otros sistema operativos, la metodología es igual.


· Primer archivo ( ARCHIVO 1 ): El archivo RXTXcomm.jar deberá ser instalado en la siguiente ruta ( copiar/cortar y pegar ):


· Arquitectura de 32-bits: C:\Program Files (x86)\Java\XXXX\lib\ext
· Arquitectura de 64-bits: C:\Program Files\Java\XXXX\lib\ext


Dónde:

· XXXX: Será la versión de vuestra máquina virtual JAVA, la nomenclatura será del siguiente tipo: jre1.8.0_45, en caso de tener más de una versión, se recomienda que se traslade el archivo RXTXcomm.jar a todas las versiones instaladas.


· Segundo ( ARCHIVO 2 ) y Tercer archivo ( ARCHIVO 3 ): Deberán ser instalados en la siguiente ruta ( copiar/cortar y pegar )


· Arquitectura de 32-bits: C:\Program Files (x86)\Java\XXXX\bin
· Arquitectura de 64-bits: C:\Program Files\Java\XXXX\bin


Dónde:

· XXXX: Será la versión de vuestra máquina virtual JAVA, la nomenclatura será del siguiente tipo: jre1.8.0_45, en caso de tener más de una versión, se recomienda que se trasladen los archivos a todas las versiones instaladas.



Y una vez hecho los pasos indicados, ya se podrá trabajar con el puerto serie sin problema ninguno, ya sea para desarrollar software o para ejecutarlos.

---

En estos momentos, dichas librerías se han utilizado en los siguientes sistemas operativos de forma satisfactoria:

SISTEMA OPERATIVO	ARQUITECTURA	ESTADO
· Windows 8.1	64-bits	Funciona CORRECTAMENTE
· Windows XP	32-bits	Funciona CORRECTAMENTE

· NOTA 1: En la medida de que se prueben otros sistemas operativos y diferentes arquitecturas, la tabla anterior se actualizará convenientemente.

· NOTA 2: En el caso de que tengáis otro sistema operativo y hayas instalado las librerías correctamente, tal y como se indica en este capítulo, os agradecería que me dijerais si el software funciona o no, para actualizar la tabla anterior y ser de ayuda a otros usuarios.

Microchip PIC: Buzzer Pasivo Zumbador + Beep + PIC18LF4550

En este capítulo no vamos a explicar ningún módulo interno del microcontrolador de la familia PIC, sino que vamos a usar un dispositivo externo y aplicar los conocimientos ya expuestos. En este caso, vamos a mostrar como trabajar con un Zumbador o Buzzer PASIVO.

Un zumbador o buzzer es un dispositivo externo que emite sonidos, no podremos reproducir música por ejemplo, solo tonos. Ahora bien, existen dos tipos de buzzer:


· Buzzer ACTIVO: Esta clase de zumbador, emite sonido cuando lo conectamos directamente a la fuente de alimentación.

· Buzzer PASIVO: En cambio, esta clase de zumbador, solo emite sonido si lo excitamos mediante un tren de pulsos.


El ejemplo que vamos a presentar aquí, consiste en un Buzzer PASIVO, y el programa que vamos a desarrollar consistirá en hacer sonar tres Beep, cada tres segundos.


Bien, el microcontrolador elegido en esta ocasión es el PIC18LF4550, y usaremos el módulo interno Timer1 para que supervise dos acciones:


· Acción 1: Generar retraso de tres segundos.

· Acción 2: Generar tres Beep.


En realidad, configuraremos el módulo Timer1 en modo timer de 16-bits y que produzca una interrupción cada, aproximadamente 50 ms, usaremos una variable contador para ajustar los tres segundos deseados. Una vez haya transcurrido los tres segundos, empezaremos a emitir los tres beep.


El resto del tiempo, el microcontrolador PIC18LF4550 estará en modo IDLE ( bajo consumo ).

El material que vamos a necesitar y su función, es la que se muestra a continuación:

· PIC18LF4550: Microcontrolador para este programa.

· Protoboard: Donde insertaremos nuestros componentes.

· PICKIT 3: Programador y depurador necesario para programar el código.

· Transistor NPN: Un transistor NPN de propósito general, en nuestro caso C9013.

· Resistor 220 Ω: Se conectará al pin RD2 ( tres de pulsos ) y a la base del transistor NPN.

· Resistor 4.7 kΩ: Un resistor que irá conectado entre los pines #MCLR y VDD.

· Buzzer Pasivo: Un zumbador del tipo PASIVO que irá conectado su pin positivo a la fuente de alimentación y el pin negativo al pin colector del transistor.


El firmware es el que se muestra a continuación:

/**
* @file      main.c
* @author    Manuel Caballero
* @date      14/3/2015
* @brief     Archivo principal.
* \copyright
*      AqueronteBlog@gmail.com
*
* Este archivo es propiedad intelectual del blog Aqueronte,
* cuya direccion web, es la siguiente:
*
*   http://unbarquero.blogspot.com/
*
* Se permite cualquier modificacion del archivo siempre y cuando
* se mantenga la autoria del autor.
*/
#include < xc.h >
#include < stdint.h >
#include "variables.h"
#include "functions.h"
#include "interrupts.h"

/**
 *  \brief     void main( void )
 *  \details   Este programa consiste en mostrar como funciona un Buzzer o
 *             zumbador PASIVO.
 *
 *             En este caso, el programa consiste en hacer sonar el buzzer PASIVO
 *             mediante tres Beep breves cada aproximadamente, 3 segundos.
 *
 *             Se usará el módulo Timer1, 16-bits, para gestionar tanto el
 *             tiempo 3 segundos deseado como los tres Beep del buzzer PASIVO.
 *
 *             El microcontrolador estará en modo bajo consumo Idle hasta que
 *             no se produzca una interrupción del Timer1.
 *
 *
 *  \author    Manuel Caballero
 *  \version   0.0
 *  \date      14/3/2015
 *  \pre       Este firmware está probado para el PIC18LF4550.
 *
 *  \pre       MPLAB X IDE v2.35.
 *  \pre       Compiler XC8 v1.33.
 */
void main( void ) {

   uint8_t var3seg     =   0;  /**< Variable contador que junto al Timer1 nos permite contabilizar 3 s */
   uint8_t var3beep    =   0;  /**< Variable contador que junto al Timer1 nos permite realizar tres Beep */


   conf_CLK    ();     // Configura Relojes
   conf_IO     ();     // Configura I/O
   conf_TA1    ();     // Configura Timer1

    
   INTCONbits.PEIE     =   1;    // Peripheral Interrupt Enable
   ei  ();                       // enable interrupts


   do{
     SLEEP();                    // uC modo IDLE

     if ( var3seg == 60 && var3beep < 6 )
     {
     // Tres Beep cada 3 segundos
       LATDbits.LD2        =   ~LATDbits.LD2;
       var3beep++;
     }
     else
     {
       if ( var3beep > 5 )
       {
       // Reset variables ( vuelta a empezar! )
         var3beep    =   0;
         var3seg     =   0;
       }

       var3seg++;
     }

   } while ( 1 );
}

Como vemos, el ejemplo es bastante simple, se recomienda bajar los archivos disponibles más abajo para indagar entre sus librerías y leer sus funciones de manera más detallada.

Un vídeo que demuestra lo explicado anteriormente se presenta a continuación:

---

Os pongo a vuestra disposición el programa en lenguaje C (XC8 y CCS) para que lo podáis descargar y probar:

Microchip PIC: PIC18LF4550  + Zumbador Pasivo + Beep
Compilador XC8	Compilador CCS
C	C
PIC18LF4550: Buzzer Pasivo + Beep  PIC18LF4550: Buzzer Pasivo + Beep	PIC18LF4550: Buzzer Pasivo + Beep PIC18LF4550: Buzzer Pasivo + Beep

---

· NOTA 1: Lo comentarios están en formato doxygen. Aunque no se entrega dicha documentación ya que el MPLAB X no tiene ningún pulgin capaz de trabajar con dicho formato.

MSP430: nRF24L01+

En este capítulo, vamos a trabajar con el dispositivo externo nRF24L01+ de la empresa Nordic Semiconductor. Dicho dispositivo es un trasnciver, es decir, un dispositivo que puede actuar tanto de receptor como de transmisor de paquetes/datos de forma inalámbrica y cuya comunicación con un microcontrolador es mediante el bus SPI.

La ventaja de este dispositivo, es principalmente su precio (bastante reducido para las prestaciones que ofrece) y que no requiere de muchos componentes externos para funcionar. En el mercado, se pueden encontrar bastantes placas de desarrollo con las que trabajar con el nRF24L01+, en nuestro caso, se ha escogido la que se muestra a continuación:

DISPOSITIVO nRF24L01+

Las principales características del dispositivo nRF24L01+ son las que se muestran a continuación:

CARACTERÍSTICAS nRF24L01+
· Banda 2.4GHz ISM.		· 6 data pipe MultiCeiver.
· Hasta 2Mbps de transmisión de datos.		· 11.3mA TX a 0dBm output power.
· Modos de bajo consumo disponibles.		· 12.3mA RX a 2Mbps air data rate.

Como ya se ha comentado, la manera de comunicarse con el nRF24L01+ es mediante el bus SPI, pero dicho dispositivo incluye un pin más llamado #IRQ que es bastante útil en vistas al ahorro de energía, ya que dicho pin se activará entre otras señales disponibles, cuando se haya transmitido un paquete o cuando se reciba un paquete, de esta manera, podremos disponer nuestro microcontrolador en estado de bajo consumo.

Otras funciones interesantes y a destacar del nRF24L01+ son:

• ACK Automático: Dicho de otra forma, si se activa dicha función, cada vez que enviemos un paquete y se ha transmitido correctamente y recibido por el receptor, éste le enviará al transmisor un ACK, que podremos leer desde el registro STATUS del dispositivo. En otras palabras, es una herramienta de garantía de que nuestro paquete enviado ha sido recibido por el receptor.

• Reenvío de paquetes: Si por cualquier motivo, el paquete que queremos enviar no ha sido posible su envío, podemos configurar el dispositivo nRF24L01+ de manera que pueda intentar su reenvío hasta en 15 ocasiones.

Para ver toda la documentación disponible sobre éste dispositivo, el siguiente enlace es el apartado que la empresa Nordic tiene sobre su producto: nRF24L01+.


Y bien, después de una breve introducción del dispositivo nF24L01+, vamos a ponernos a trabajar. Para ello, necesitaremos dos MSP430 Launchpad y en este caso, usaremos el microcontrolador MSP430G2553. Dicho microcontrolador dispone del periférico interno USCI SPI Mode encargado de controlar el bus SPI de manera automática mediante hardware.

El programa que vamos a emplear para tal propósito, consistirá en obtener una lectura del sensor interno de temperatura del microcontrolador cada tres segundos, y una vez obtenida la temperatura, enviarla de forma inalámbrica por medio del dispositivo nRF24L01+.

Como vamos a tener dos placas Launchpad funcionando, uno será el transmisor (leerá la temperatura interna y la enviará por el dispositivo nRF24L01+) y la otra será el receptor (recogerá el paquete recibido por el dispositivo nRF24L01+ y dicho paquete lo mandará al PC mediante la UART).

Tanto el transmisor como el receptor estarán en modo bajo consumo, en este caso, el transmisor estará en el modo LPM3 y el receptor LPM4.


Para el receptor, el envío de paquetes se usará el conversor USB <---> RS-232 que vamos a usar, es uno externo, concretamente el CP2102 (enlace del fabricante).

El material que vamos a necesitar y su función, es la que se muestra a continuación:

· MSP430 Launchpad: Evidentemente, nuestra placa de desarrollo con el microcontrolador MSP430G2553 (dos placas, una será el transmisor y otra el receptor).

· Módulo B75937: Conversor USB <---> RS-232 externo basado en el dispositivo CP2102.

· Interfaz Gráfica: Software que se ejecuta en un ordenador con sistema operativo Windows con al menos, la versión.NET Framework 4.0. Dicha interfaz gráfica se puede descargar más adelante junto al Firmware.

· nRF24L01+: Dispositivo externo capaz de establecer comunicación inalámbrica. Necesitaremos dos de ellos.


En este caso, habrá dos códigos fuentes, uno para el transmisor y otro para el receptor, os pondré aquí el código del receptor y más abajo, en el área de las descargas, podréis obtener ambos firmwares como las librerías necesarias para controlar el dispositivo nRF24L01+:

/**
* @file     main.c
* @author   Manuel Caballero
* @date     17/2/2015
* @brief    Archivo principal.
* \copyright
*
*         AqueronteBlog@gmail.com
*
* Este archivo es propiedad intelectual del blog Aqueronte,
* cuya direccion web, es la siguiente:
*
*  http://unbarquero.blogspot.com/
*
* Se permite cualquier modificacion del archivo siempre y cuando
* se mantenga la autoria del autor.
*/

#include < msp430.h >
#include < stdint.h >
#include "variables.h"
#include "funciones.h"
#include "interrupciones.h"
#include "NRF24L01.h"



/**
 *  \brief     void main( void )
 *  \details   Este programa consiste en leer datos de forma inalámbrica usando el dispositivo
 *          nRF24L01+.
 *
 *          Una vez lea dichos datos, se mandarán por la UART activándo el LED1 ( LED Rojo de
 *          la Launchpad ).
 *
 *          El microcontrolador estará en modo bajo consumo ( LPM4 ) y no despertará hasta que el
 *          dispositivo nRF24L01+ indique que ha recibido datos para leer.
 *
 *
 *  \author    Manuel Caballero
 *  \version   0.0
 *  \date      17/2/2015
 *  \pre       El código presente es SOLO para el RECEPTOR.
 *  \pre       El dispositivo nRF24L01+ se conecta al periférico USCI_B0 en modo SPI del microcontrolador.
 *  \pre       Asegurarse de que el LED1 ( LED Rojo ) está conectado al pin P1.0.
 *  \pre       Asegurarse de que que concuerden las siguientes señales:
 *
 *       - CE   ( nRF24L01+ ): P2.0
 *       - CSN  ( nRF24L01+ ): P2.1
 *       - #IRQ ( nRF24L01+ ): P2.2
 *
 *  \pre       Code Composer Studio, Version: 6.0.1.00040.
 *  \pre       C Compiler, MSP430 GCC GNU v4.9.1.
 */
void main( void )
{
  conf_WDT      ();         // Configura WDT del sistema
  conf_CLK      ();         // Configura CLK del sistema
  conf_IO       ();         // Configura Entradas/Salidas
  conf_SPI_B0   ();         // Configura USCI_B0 --> SPI
  conf_UART     ();         // Configura Uart

  nRF24L01_init ();     // Configura nRF24L01+


  __enable_interrupt();     // Interrupciones ON.


  while(1)
  {
     LPM4;

     P1OUT   |= BIT0;      // LED1 ON

     pBuff   =  nRF24L01_WriteRead (R_REGISTER, R_RX_PAYLOAD, 0, 2); // Lectura del nRF24L01+ ( 2-Bytes )
     nRF24L01_reset ();               // Reset a flags ( registro STATUS )

     TX_Buff  = 1;
     IE2     |=  UCA0TXIE;  // Interrupción Tx ON ( empieza a enviar paquetes por la UART )
  }
}

Como vemos, el ejemplo es bastante simple, se recomienda bajar los archivos disponibles más abajo para indagar entre sus librerías y leer sus funciones de manera más detallada.

Un vídeo que demuestra lo explicado anteriormente se presenta a continuación:

---

Os pongo a vuestra disposición el programa en lenguaje C (IAR y MSPGCC) para que lo podáis descargar y probar:

MSP430: nRF24L01+ & UART
Compilador IAR	Compilador MSPGCC
C	C
MSP430: nRF24L01+  MSP430: nRF24L01+	MSP430: nRF24L01+ MSP430: nRF24L01+

---

· NOTA 1: En caso de que en el Software empleado  no reconozca ningún puerto COM, es síntoma de que no se tiene los drivers necesarios del dispositivo CP2102, por lo que se deberán instalar para un uso correcto, ya que el ordenador no lo reconoce.

· NOTA 2: En este capítulo se han usado imágenes de terceros recogidas de Internet.

· NOTA 3: Ahora, en el archivo a descargar, a parte del programa con todas las librerías necesarias empleadas para este programa, se han añadido toda la documentación en formato doxygen.

MSP430: UART

Una de las funciones principales del uso de microcontroladores es la de poder representar datos o información de manera visual y para ello, uno de los buses o protocolos de comunicación más usado es el serial RS-232, que nos permite comunicarnos, entre otros periféricos, con ordenadores.

Y el módulo que se encarga de trabajar con el protocolo serie RS-232 es el llamado UART. El protocolo serie RS-232 es un bus muy sencillo de implementar y fiable, por ello, está bastante extendido en la industria, existiendo multitud de dispositivos: de temperatura, GPS, humedad relativa, acelerómetros, etc, que su comunicación está implementada por este bus.

Es por ello que, existen una multitud de microcontroladores que contengan uno o varios módulos internos que se encarguen de implementar el bus serie RS-232, llamado UART.

El propósito de este capítulo es ilustrar, mediante ejemplos, como se configura y se trabaja con la UART en la conexión con aquellos dispositivos que comparten dicho protocolo.

Y como se ha comentado al inicio de este capítulo, una de las principales aplicaciones de los microcontroladores es la representación de información, por ejemplo con ordenadores, pero a día de hoy, otro protocolo de comunicaciones se ha establecido con fuerza, es el llamado USB, y dicho periférico, le ha ganado terreno al RS-232, a tal punto que es difícil encontrar ordenadores portátiles con un módulo RS-232 instalado.

Pero a diferencia del USB, el RS-232 es un protocolo muy fácil de implementar y por ello, todavía sigue con vida y es bastante usado, como ya hemos explicado anteriormente, es por ello que existen conversores USB <---> RS-232 que nos facilitan la vida.

Dichos conversores, son dispositivos electrónicos relativamente baratos cuya función es poder conectar nuestro microcontrolador (mediante su módulo UART) con un ordenador a través del puerto USB.

En la siguiente tabla, se podrá entrar en detalle, mediante ejemplos, de la configuración que hemos estado hablando en este capítulo.

MSP430: MÓDULO UART
1. UART 1.	Conexión con ordenador. Conversor: TUSB3410 (Launchpad).
2. UART 2.	Conexión con ordenador. Conversor: CP2102.

---

· NOTA: Al ser el protocolo serie RS-232 muy fácil de implementar (por ejemplo, con Timers), en este capítulo se tiene en cuenta aquellos microcontroladores que tienen como periférico o módulo interno la UART de manera física.

MSP430: LDR + Led

Esta entrada tiene el propósito de demostrar el fácil uso de los dispositivos fotorresistores descritos en el capítulo: MSP430: LDR.

Vamos a trabajar sobre la placa MSP430 Launchpad y en este caso, usaremos el microcontrolador MSP430G2231.

Y el programa de demostración que vamos a emplear consiste en encender un led en caso de oscuridad.

El material que vamos a necesitar y su función es la que se muestra a continuación:

· MSP430 Launchpad: Evidentemente, nuestra placa de desarrollo con el microcontrolador MSP430G2231.
· LDR: En este caso se ha escogido uno cuya características son: R(Luz) = 5 kΩ, R(Oscuridad) = 500 kΩ.
· Resistor: Un resistor cuya resistencia es de 10 kΩ.

La configuración (circuitería externa) que vamos a adoptar con el LDR es la siguiente:

Circuito con Fotorresistor (LDR): Divisor de Tensión

· ↑↑↑Luz --> ↓↓↓LDR (~ Ω)  --> ↑↑↑Vo ~ Vcc · ↓↓↓Luz --> ↑↑↑LDR (~ MΩ) --> ↓↓↓Vo

Obtenemos la expresión de V_o (divisor de tensión):

· V_o = [R₁/(R₁ + R(LDR))]·V_cc

En nuestro caso, el valor de las incógnitas fijas son:

· R₁ = 10 kΩ.
· V_cc ≈ 3.6 V (Alimentación de la propia placa Launchpad).

Y el valor variable depende de la incidencia de luz del LDR, cuyas características nominales son:

· R(Día) ≈ 5 kΩ.
· R(Oscuro) ≈ 500 kΩ.

Por lo tanto, el valor de tensión de salida (V_o) dependerá de la resistencia por LDR de tal manera:

· V_o(Día) = [10/(10 + 5]·3.6 = 2.4 V
· V_o(Oscuro) = [10/(10 + 500]·3.6 ≈ 0.07 V

Esto quiere decir que, dependiendo de la luz que incida en el LDR, el valor de la tensión de salida (V_o) variará entre [0.07, 2.4] V.

¿Qué quiere decir éste intervalo? Pues que desde oscuridad (0.07 V) hasta día (2.4 V) existen, si asumimos números enteros, tres niveles:

· Nivel 0: Estado oscuridad, V_o = 0 V.
· Nivel 1: Estado intermedio, V_o = 1 V.
· Nivel 2: Estado en día, V_o = 2 V.

Evidentemente, con la configuración que hemos adoptado nos limita mucho las posibilidades de monitorizar la luminosidad donde se encuentra el LDR, pero para este caso, nos sirve y es suficiente; asumimos que tanto el nivel 0 como el 1 son oscuridad y que, simplemente el nivel 2 es de día.

Asumiendo dichas consideraciones, el programa en que se basa este capítulo, encenderá un led cuando estemos en el nivel 0 o 1, y en caso contrario, cuando estemos en el nivel 2, lo apagará.

La lectura de la tensión V_o se hará cada, aproximadamente 0.25 segundos mientras que el resto del tiempo, el microcontrolador estará en modo ahorro de energía LMP3 (todo apagado menos el reloj ACLK), y solo se saldrá de dicho estado, para monitorizar la tensión V_o y decidir si encender el led o no.

Para una explicación más detallada, se recomienda que se lean los comentarios del programa que está más abajo para disposición del usuario su descarga.

El código del programa principal, es el siguiente:

/*----------------------------------------------------------------------
    AqueronteBlog@gmail.com            
                                                      
Este archivo es propiedad intelectual del blog Aqueronte,  
cuya dirección web, es la siguiente:                       
                                                       
  http://unbarquero.blogspot.com/           
                                                       
Se permite cualquier modificación del archivo siempre y cuando
se mantenga la autoría del autor.                          
                                                      
----------------------------------------------------------------------
                                                       
Filename:     main.c                              
Date:         24-December-12                                
File Version: vs0.0                                     
Compiler:     IAR 5.51.3 [Kickstart]   

Author:       Manuel Caballero                           
Company:      Hades                          
                       
----------------------------------------------------------------------
                                                      
Notes:  En este programa vamos a mostrar como trabajar con el 
        dispositivo LDR (fotorresistor) para monitorizar la
        luminosidad en la que está ubicado.

        En nuestro programa, se obtendrá el valor de la tensión de 
        salida del circuito exterior donde está el LDR y se
        decidirá si enciende un led o no dependiendo de la luminosidad.

        La velocidad de lectura y toma de decisión es de,
        aproximadamente 0.25 segundo.
        Como dato adicional, el microcontrolador estará en modo ahorro
        de consumo LPM3 hasta la nueva lectura.
*/

#include "io430.h"
#include "variables.h"
#include "funciones.c"

void main( void )
{  
   conf_WDT ();      // Configura WDT del sistema
   conf_CLK ();      // Configura CLK del sistema                                              
   conf_IO ();       // Configura Entradas/Salidas
   conf_ADC10 ();    // Configura ADC 10
   conf_TimerA ();   // Configura TimerA
  
   __enable_interrupt();  // Enable interrupts.
  
   while(1)
   {    
    LPM3;      // LPM3 with interrupts enabled
    
    if (IntDegC < 2)
      P1OUT |= BIT0;
    else
      P1OUT &= ~BIT0;
   }
}

Como vemos, el ejemplo es bastante simple, se recomienda bajar los archivos disponibles más abajo para indagar entre sus librerías y leer sus funciones de manera más detallada.

Un vídeo que demuestra lo explicado anteriormente se presenta a continuación:

---

Os pongo a vuestra disposición el programa en lenguaje C (IAR y MSPGCC) para que lo podáis descargar y probar:

MSP430: LDR + Led
Compilador IAR	Compilador MSPGCC
C	C
MSP430: LDR + Led MSP430: LDR + Led MSP430: LDR + Led	MSP430: LDR + Led MSP430: LDR + Led MSP430: LDR + Led

---

Como se ha podido ver en el transcurso de este capítulo, es fácil el uso de los dispositivos LDR y bastante útil para monitorizar la luminosidad donde esté instalado.

MSP430: LDR

En esta entrada vamos a trabajar con el dispositivo resistivo dependiente de la luz llamado: LDR (Light-Dependent Resistor), también llamado: fotorresistores.

Su apariencia y su símbolo eléctrico es el que se muestra a continuación:

Fotorresistor (LDR)
Apariencia real	Símbolo eléctrico

La característica principal de estos dispositivos es que si se incide luz, su resistencia baja (alrededor de las decenas de ohmios); en caso contrario, a la carencia de luz, se incrementa su resistencia (alrededor de los mega ohmios).

Y es ésta característica la que hace a estos dispositivos bastante atractivos para controlar la luminosidad ambiente de un espacio determinado, aparte de su facilidad de uso.

Como viene siendo costumbre, trabajamos con estos dispositivos mediante un sistema controlado, en nuestro caso, un microcontrolador. Es por ello que, en la siguiente tabla, se muestra los dos tipos de configuración (con elementos externos) más habituales.

Circuito con Fotorresistor (LDR): Divisor de Tensión
· ↑↑↑Luz --> ↓↓↓LDR (~ Ω)  --> ↓↓↓Vo · ↓↓↓Luz --> ↑↑↑LDR (~ MΩ) --> ↑↑↑Vo ~ Vcc	· ↑↑↑Luz --> ↓↓↓LDR (~ Ω)  --> ↑↑↑Vo ~ Vcc · ↓↓↓Luz --> ↑↑↑LDR (~ MΩ) --> ↓↓↓Vo

¿Qué significan ambos circuitos anteriormente expuestos? Pues son simples divisores de tensión, dónde conociendo de antemano, el valor de la resistencia de uno de ellos y la tensión de alimentación, el que varía, es el LDR dependiendo de la luz que le incide.

Y esto es útil y fácil de monitorizar mediante un microcontrolador a través del módulo conversor analógico-digital (ADC).

---

Para poner en práctica los conceptos y el control de este tipo de dispositivo, os dejo un ejemplo:

Ejemplo: MSP430 + LDR
1. Programa	Monitorizar la luz ambiente.

---

El capítulo presente ha intentado ser una muy breve introducción de los dispositivos fotorresistores para mostrar su utilidad, principio de funcionamiento y sobre todo, fácil uso.

MSP430: Shift Register + HD44780

En esta entrada vamos a exponer otro ejemplo del uso de los registros de desplazamiento a la hora de ahorrar patitas a nuestro microcontrolador, por lo que estará dentro del capítulo siguiente: MSP430: Registro de Desplazamiento.

Vamos a trabajar sobre la placa MSP430 Launchpad y seguiremos usando el microcontrolador MSP430G2231.

La finalidad principal de este programa será el controlar una pantalla LCD Hitachi HD44780 (LM016L) con solo tres patitas del microcontrolador (recordad que para el manejo y control de este tipo de pantallas, al menos son necesarias seis patitas del microcontrolador).

Y la información que mostraremos en la pantalla será la temperatura interna del microcontrolador (en nuestro caso, el micro MSP430G2231 tiene incorporado un sensor de temperatura interno).

Quizás el programa no suele seguir el estilo y facilidad de como es costumbre en este blog, ya que no se recalque o se de más énfasis al objeto principal que no es más que comprobar que mediante un registro de desplazamiento podemos controlar una pantalla LCD.

Pero bueno, así podemos hacernos una idea de que la incorporación de un dispositivo como el que estamos tratando en este capítulo, es de bastante utilidad a la hora de diseñar nuestros propios proyectos.

El material que vamos a necesitar y su función es la que se muestra a continuación:

· MSP430 Launchpad: Evidentemente, nuestra placa de desarrollo con el microcontrolador MSP430G2231.
· CD74HCT164: Registro de desplazamiento serie-paralelo.
· Pantalla LCD Hitachi HD44780: Pantalla LCD con el controlador equivalente al Hitachi HD44780 (LM016L).

El funcionamiento del programa en sí es simple, mostrar la temperatura interna del microcontrolador MSP430G2231 mediante su sensor de temperatura interna cada medio segundo aproximadamente.

Para ello, deberemos configurar el sensor de temperatura interna y bueno, al trabajar con una familia de microcontroladores de bajo consumo, buscaremos la manera que éste consuma lo menos posible: Configuraremos el reloj auxiliar ACLK a VLCLK (~12 kHz) y que despierte al microcontrolador cada, aproximadamente medio segundo en su estado de ahorro de energía LPM3, lea la temperatura del sensor interno y la muestre por pantalla.

Es cierto que quizás, el control del sensor de temperatura interna de nuestro microcontrolador deba ser descrito con más detalle, pero si lo hacemos en esta entrada puede que nos desviemos de nuestro propósito principal, y es ni más ni menos que, comprobar que mediante los registros de desplazamiento podemos ahorrar patitas de nuestro microcontrolador.

Así que aplazamos el capítulo del sensor interno de temperatura a su propio apartado (se hará lo antes posible).

Aún así, para una explicación más detallada, se recomienda que se lean los comentarios del programa que está más abajo para disposición del usuario su descarga.

El código del programa principal, es el siguiente:

/*----------------------------------------------------------------------
    AqueronteBlog@gmail.com            
                                                      
Este archivo es propiedad intelectual del blog Aqueronte,  
cuya dirección web, es la siguiente:                       
                                                       
  http://unbarquero.blogspot.com/           
                                                       
Se permite cualquier modificación del archivo siempre y cuando
se mantenga la autoría del autor.                          
                                                      
----------------------------------------------------------------------
                                                       
Filename:     main.c                              
Date:         13-December-12                                
File Version: vs0.0                                     
Compiler:     IAR 5.50.1 [Kickstart]   

Author:       Manuel Caballero                           
Company:      Hades                          
                       
----------------------------------------------------------------------
                                                      
Notes:    En este programa vamos a mostrar como trabajar con el 
          dispositivo registro de desplazamiento (CD74HCT164)
          tipo serie-paralelo, donde veremos que simplemente con tres 
          patitas del microcontrolador, son capaces de 
          controlar la pantalla LCD Hitachi HD44780 (LM016L).

          En nuestro programa, se mostrará la temperatura leída del
          sensor de temperatura interno del propio microcontrolador.

          La velocidad de lectura y actualización del dato mostrado por
          la pantalla es de, aproximadamente medio segundo.
          Como dato adicional, el microcontrolador estará en modo ahorro
          de consumo LPM3 hasta la nueva lectura.
*/

#include "io430.h"
#include "variables.h"
#include "funciones.c"

void main( void )
{  
  conf_WDT ();       // Configura WDT del sistema
  conf_CLK ();       // Configura CLK del sistema                                              
  conf_IO ();        // Configura Entradas/Salidas
  conf_ADC10 ();     // Configura ADC 10
  conf_TimerA ();    // Configura TimerA
  
  LCD_INI (ONE_Line_5x7, NoShift_Increment);  // Inicializa LCD
  LCD_Control (DisON_CurOFF_BliOFF);
  
  __enable_interrupt();                       // Enable interrupts.
  
  while(1)
  {    
    LPM3;                            // LPM3 with interrupts enabled
    
    IntDegC = INT_To_BCD (IntDegC);
      
    LCD_Control (ClearDisplay);
    LCD_printf ("Temp uC: ");
    BCD_to_LCD(IntDegC);             // Dato de la temp por pantalla
      
    LCD_putc(' ');
    LCD_putc(0xDF);                  // Símbolo Grado: º
    LCD_putc('C');
  }
}

Como vemos, el ejemplo es bastante simple, se recomienda bajar los archivos disponibles más abajo para indagar entre sus librerías y leer sus funciones de manera más detallada.

Un vídeo que demuestra lo explicado anteriormente se presenta a continuación:

---

Os pongo a vuestra disposición el programa en lenguaje C (IAR y MSPGCC) para que lo podáis descargar y probar:

MSP430: Shift Register + HD44780
Compilador IAR	Compilador MSPGCC
C	C
MSP430: Shift Register + LCD MSP430: Shift Register + LCD MSP430: Shift Register + LCD	MSP430: Shift Register + LCD  MSP430: Shift Register + LCD  MSP430: Shift Register + LCD

---

Como se ha podido ver en el transcurso de este capítulo, es fácil y muy útil trabajar y saber controlar los dispositivos llamados registros de desplazamiento a la hora de ahorrar patitas de nuestro microcontrolador y aprovechar de camino, poner a éste en modo ahorro de energía.

Como dato final, hay que especificar que como bien se ve en el vídeo, la temperatura ambiente difiere, aproximadamente 10 grados de lo que lee el sensor de temperatura interno del microcontrolador, aparte de que en las hojas de características, tanto de la familia como del propio microcontrolador, dicen que la tolerancia es bastante grande, hay que tener en cuenta que el sensor mide la temperatura del microcontrolador (dentro), no de la superficie.

Otros microcontroladores de la misma familia tienen datos en memoria donde podemos acceder para calibrar nuestro sensor de temperatura interno respecto a la temperatura ambiente.

Aún así, siguiendo los consejos de la hoja de características del componente, una buena calibración deberá ser precedida y controlada por medios externos, por ejemplo, otro sensor de temperatura externo.

MSP430: Shift Register + Led Bar

Como de costumbre, vamos a intentar demostrar las explicaciones dadas en este blog mediante ejemplos ilustrativos. En este caso, nos referimos al control del dispositivo registro de desplazamiento (shift register) descrita en el siguiente capítulo: MSP430: Registro de Desplazamiento.

Vamos a trabajar sobre la placa MSP430 Launchpad y en este caso, usaremos el microcontrolador MSP430G2231.

Y para ser fiel a nuestra metodología, vamos a exponer un ejemplo sencillo donde abordará el problema principal (control y manipulación del dispositivo registro de desplazamiento) y además, otras cuestiones útiles tales como, bajo consumo, empleo de interrupciones, etc.

El material que vamos a necesitar y su función es la que se muestra a continuación:

· MSP430 Launchpad: Evidentemente, nuestra placa de desarrollo con el microcontrolador MSP430G2231.
· CD74HCT164: Registro de desplazamiento serie-paralelo.
· 8 Leds: En este caso, emplearemos una barra de leds (no leds sueltos, aunque se pueden usar igualmente).

El funcionamiento es simple, tendremos dos formas de iluminar los 8 leds a tres intervalos de tiempo establecidas:

· Inicial: Cada, aproximadamente 50 ms, los leds se intercambian su iluminación.
· Intermedia: Cada, aproximadamente 366.67 ms, los leds se intercambian su iluminación.
· Final:  Cada, aproximadamente 1 s, los leds se intercambian su iluminación.

Y la manera de cambiar dicha frecuencia de cambio de iluminación de los leds es mediante el pulsador conectado a la patita P1.3.

Pero esto no es todo, el programa muestra como poner o sumir al microcontrolador en el modo ahorro de energía LMP3 (todo apagado menos el reloj ACLK), y solo se saldrá de dicho estado, para cambiar el estado de los leds o a cada pulsación del pulsador para cambiar la frecuencia de cambio de los mismos.

Para una explicación más detallada, se recomienda que se lean los comentarios del programa que está más abajo para disposición del usuario su descarga.

El código del programa principal, es el siguiente:

//*----------------------------------------------------------------------
    AqueronteBlog@gmail.com            
                                                      
Este archivo es propiedad intelectual del blog Aqueronte,  
cuya dirección web, es la siguiente:                       
                                                       
  http://unbarquero.blogspot.com/           
                                                       
Se permite cualquier modificación del archivo siempre y cuando
se mantenga la autoría del autor.                          
                                                      
----------------------------------------------------------------------
                                                       
Filename:      main.c                              
Date:          10-December-12                                
File Version:  vs0.0                                     
Compiler:      IAR 5.50.1 [Kickstart]   

Author:        Manuel Caballero                           
Company:       Hades                          
                       
----------------------------------------------------------------------
                                                      
Notes:   En este programa vamos a mostrar como trabajar con el 
         dispositivo registro de desplazamiento (CD74HCT164)
         tipo serie-paralelo, donde veremos que simplemente con dos 
         patitas del microcontrolador, son capaces de 
         controlar 8 patitas de salida.

         En nuestro programa, dichas salidas irán conectadas a una barra
         de leds que iremos encendiendo alternativamente (un led si, 
         otro no).

         La velocidad de secuencia de encendido irá controlada mediante 
         un pulsador, y ésta será desde los 50ms hasta el segundo.
         Como dato adicional, el microcontrolador estará en modo ahorro
         de consumo LPM3 hasta que se deba cambiar el estado de los leds
         o la frecuencia del cambio.
*/

#include "io430.h"
#include "variables.h"
#include "funciones.c"

void main( void )
{  
   conf_WDT ();          // Configura WDT del sistema
   conf_CLK ();          // Configura CLK del sistema                                              
   conf_IO ();           // Configura Entradas/Salidas
   conf_TimerA ();       // Configura Timer A 
  
   __enable_interrupt(); // Interrupt enable
  
   do{

     ShiftRegister(ledOn);
  
     LPM3;               // Enter LPM3 w/interrupt              
              
   }while(1);
}

Como vemos, el ejemplo es bastante simple, se recomienda bajar los archivos disponibles más abajo para indagar entre sus librerías y leer sus funciones de manera más detallada.

Un vídeo que demuestra lo explicado anteriormente se presenta a continuación:

---

Os pongo a vuestra disposición el programa en lenguaje C (IAR y MSPGCC) para que lo podáis descargar y probar:

MSP430: CD74HCT164 + 8 Leds
Compilador IAR	Compilador MSPGCC
C	C
MSP430: CD74HCT164 + 8 LEDS MSP430: CD74HCT164 + 8 LEDS MSP430: CD74HCT164 + 8 LEDS	MSP430: CD74HCT164 + 8 LEDS MSP430: CD74HCT164 + 8 LEDS MSP430: CD74HCT164 + 8 LEDS

---

Como se ha podido ver en el transcurso de este capítulo, es fácil y muy útil trabajar y saber controlar los dispositivos llamados registros de desplazamiento a la hora de ahorrar patitas de nuestro microcontrolador y aprovechar de camino, poner a éste en modo ahorro de energía.