Nociones básicas de Microcontroladores: Sistema mínimo para el PIC16F84A (Parte 2 de 2).

Esta es la continuación de la entrada anterior, en esta entrada se mostrará el proceso para crear un archivo con extensión *.C en el compilador de la empresa CCS, algunas instrucciones básicas, así como la compilación de las mismas y su posterior programación en el PIC16F84A.

Primero, el programa a implementar será el encender/apagar cada segundo un LED, colocado en el pin RA0 del microcontrolador. Para ello tenemos el siguiente diagrama de flujo:

Clic en la imagen para expandir.

El código del programa se muestra a continuación:

//////////////////////////////
//PROGRAMA QUE HACE PARPADEAR/
//UN LED CONECTADO EN RA0   //
//////////////////////////////
//AUTOR: ALFA               //
//PAÍS:  MEXICO             //
//BLOG:  galfama.blogspot.mx//
//FECHA: 13/04/2013         //
//////////////////////////////

//SE DECLARA EL PIC A UTILIZAR.
#INCLUDE <16F84A.H>
//SE DECLARA EL CRISTAL A UTILIZAR.
#USE DELAY(CLOCK=4000000) //4MHz
//SE DECLARAN LOS FUSIBLES DEL PIC.
/*
XT = OSCILADOR DE CRISTAL DE CUARZO.
NOWDT = NO SE UTILIZARÁ 
        EL WATCH DOG TIMER.
PUT = SE USARÁ EL POWER UP TIMER.
NOPROTECT = NO SE PROTEGERÁ EL
           CÓDIGO CONTRA LECTURA.
*/
#FUSES XT,NOWDT,PUT,NOPROTECT

//SE DECLARAN LAS VARIABLES,
//PARA ESTE CASO NO HAY VARIABLES.

//SE DECLARA LA FUNCIÓN PRINCIPAL.
VOID MAIN (VOID)
{
//SE DECLARA TODO EL PUERTO A Y B
//COMO SALIDA.
SET_TRIS_A(0B00000);

SET_TRIS_B(0B00000000);
//SE HACE UN BUCLE INFINITO
//PARA QUE EL PROGRAMA SE
//REPITA.
   WHILE(TRUE)
   {
//SE ENCIENDE EL LED
   OUTPUT_HIGH(PIN_A0);
//HAY UN RETARDO DE 1 SEG.
   DELAY_MS(1000);
//SE APAGA EL LED.
   OUTPUT_LOW(PIN_A0);
//HAY OTRO RETARDO DE 1 SEG.
   DELAY_MS(1000);
   }
}

Y por último, dejo un video donde se explica todo el proceso para grabar el código en el PIC16F84A.










 Muchas gracias por leer esta nueva entrada.



 ALF

Nociones básicas de Microcontroladores: Sistema mínimo para el PIC16F84A (Parte 1 de 2).

A lo largo del aprendizaje de la electrónica, hemos escuchado alguna vez la palabra microcontrolador. Éstos pequeños circuitos integrados están incorporados en módems, no break, termómetros digitales, etc., y han venido a revolucionar el mundo de la electrónica. Ya que a ellos podemos conectar sensores de temperatura, presión, relevadores, actuadores, motores, etc.

Existen varios fabricantes de microcontroladores: Atmel, Texas Instruments, Freescale, Microchip, por citar algunos de ellos. Éste último es fabricante de los famosos PIC.

En esta entrada, he decidido utilizar el PIC16F84A de Microchip, por su facilidad para conseguirlo en las tiendas de componentes electrónicos, además por su precio, considero está al alcance de nuestro bolsillo.

Bien, el PIC16F84A posee las siguientes características:

Parámetro	Descripción
Tipo de Memoria de Programa	Flash
Memoria de Programa (KB)	1.75
Velocidad del CPU (MIPS)	5
Memoria RAM (Bytes)	68
Memoria EEPROM (Bytes)	64
Temporizadores	1 de 8-bit
Rango de Temperatura (°C)	-40 a 85
Voltaje de Operación (V)	2 a 6(típico 5V)
Número de pines	18

El diagrama de bloques interno del PIC, se muestra a continuación (traducido al español):

Clic sobre la imagen para expandir.

Como se observa en el diagrama, el PIC16F84A contiene un pequeño microprocesador:

Clic en la imagen para expandir.

Ya que un PIC está considerado como una pequeña computadora con puertos de E/S, memoria RAM, ROM, etc. Básicamente la diferencia entre un microcontrolador y un microprocesador es:

Microcontrolador: Se utiliza para construir sistemas electrónicos que funcionan en "tiempo real".

Microprocesador: Se utiliza para procesar una enorme cantidad de datos.

Para utilizar por primera vez el PIC16F84A, se construirá un circuito denominado "sistema mínimo", con el cual se implementará un primer programa desarrollado en el compilador C, de la empresa CCS. A continuación se muestra el diagrama del sistema mínimo a implementar y la lista de materiales del mismo:

- 1 C.I. PIC16F84A.
- 1 Diodo 1N4148.
- 2 Capacitores cerámicos de 22 pF.
- 1 resistor de 10KOhms 1/2 W.
- 1 resistor de 220 Ohms 1/2 W.
- 1 Cristal de cuarzo de 4MHz.
- 1 LED color rojo (o de cualquier otro color).
- 1 Push-Button Normalmente Abierto (NA).
- 5 pines tipo espadines
- Cable

Clic en la imagen para expandir.

La mayoría de las instrucciones del microcontrolador se ejecutan en un ciclo de máquina, este ciclo está dado por el cristal de cuarzo de 4 MHz, y un divisor de frecuencia entre 4 que posee el PIC, esto quiere decir que las instrucciones en el microcontrolador estarán dadas por la fórmula:

Es por eso que, si utilizamos un cristal de 4MHz, la frecuencia real de operación será de 1MHz, por lo que cada instrucción en lenguaje ensamblador (ASM), le demorará 1 microsegundo en ser ejecutada. Aunque utilizaremos lenguaje C, para programar el microcontrolador, también el compilador CCS, nos da la opción de mezclar C y ASM.

Nota: El PIC16F84A-04 trabaja con una frecuencia máxima de 4 MHz, el PIC16F84A-20 funciona con una frecuencia máxima de 20 MHz.

Los capacitores de 22 pF, se utilizan para dar estabilidad a la frecuencia del cristal de cuarzo.

El PIC posee un pin de reset, dicho pin "resetea" el programa que se está ejecutando en el microcontrolador, para ello se ha colocado un push-button normalmente abierto en este pin, con una resistencia de 10 KOhms, denonimada resistencia pull-up.

Por otra parte, en el circuito, se ha colocado una serie de pines denominados Puerto ICSP (In Circuit Serial Programming), éstos pines nos permitirán en circuitos posteriores, programar el PIC16F84A sin la necesidad de retirarlo de la tablilla de experimentación o circuito impreso. El diodo 1N4148, ayuda para que, al programar por los pines ICSP el microcontrolador, no se energice todo el circuito y dañemos nuestro programador (cuando se conectan pantallas LCD, relevadores, sensores, actuadores, etc.).

A continuación se muestra el circuito construido en una tablilla de experimentación o protoboard:

Clic en la imagen para expandir.

Ahora, después de construir el circuito, para programar el PIC, se utilizará un "quemador" o programador de PIC's. En México se puede adquirir en Mercado Libre, el MASTER-PROG, que se muestra a continuación.

Clic en la imagen para expandir.

En la segunda parte de esta entrada del blog, se explicarán los pasos para programar el PIC, y se cargará en el circuito de prueba un programa de ejemplo, usando el compilador C CCS y el MASTER-PROG.

¡Muchas gracias por leer esta nueva entrada!

ALF

Control de LEDs del MSP430 Launchpad mediante bluetooth y Android

Aún recuerdo los dolores de cabeza, que me causó el aprender a usar la comunicación serial en los microcontroladores PIC, pero ahora, no digo que soy un experto en ello, pero algo me defiendo :-D. 

En la entrada anterior se dió una breve introducción a la tarjeta de desarrollo MSP430 Launchpad de Texas Instruments. En esta ocasión, se explicará el cómo controlar los LEDs (pines P1.0 y P1.6) que trae dicha tarjeta, usando el módulo serial bluetooth HC-05 montado en una base y un teléfono con Android (Para este caso se usará el Motorola MB511 o FlipOut).

Primero identificamos las terminales RX y TX del microcontrolador a utilizar, para este caso es el MSP430G2553, que de acuerdo con las hojas de datos son los pines 3 y 4:

Y en la tarjeta MSP430 son los pines P1.1(RX) y P1.2(TX), Nota: en Fritzing los pines vienen etiquetados con las terminales del dispositivo a conectar.

Después hacemos las siguientes conexiones (no es necesario mover los jumpers del MSP430):

Clic en la imagen para expandir.

Aquí se muestra una imagen del circuito físico:

Clic en la imagen para expandir.

A continuación dejo el código fuente, que deberán cargar a la tarjeta MSP430 Launchpad usando el software Energia (como se muestra en la publicación anterior):

//////////////////////////////////////
//  Creado por: ALFA                //
//  País: México                    //
//  Página WEB: galfama.blogspot.mx //
//  Fecha: 19/02/2013               //
//////////////////////////////////////

/*  Descripción

Programa que controla el encendido/apagado de los LEDs 
(verde, rojo) usando el módulo serial bluetooth modelo HC-05, 
implementado en el MSP430 Launchpad de Texas Instruments, con el
microcontrolador MSP430G2553 a una frecuencia de reloj de de 16MHz.

Los comandos a recibir son: El 1 -enciende LED rojo, 2 -apaga LED rojo,
3 -enciende LED verde, 4 apaga -LED verde, otro caracter apaga ambos LEDs.

Nota: Para el envío de datos por bluetooth entre el dispositivo
y la tarjeta se utiliza el programa para Android BlueTerm.

*/

// Se inicializa el puerto serie a 9600 bauds
// Y la variable "valor" de tipo caracter.
// Así como los pines de los LEDs (verde, rojo), se definen como salidas.

char valor=0;

void setup()
{
  Serial.begin(9600);
  pinMode (RED_LED, OUTPUT);
  pinMode (GREEN_LED, OUTPUT);
  digitalWrite(RED_LED, LOW);//Inicialmente se apagan los LEDs.
  digitalWrite(GREEN_LED, LOW);
}

void loop()  //Bucle infinito
{
  if (Serial.available())//Si hay una caracter en el buffer serial
                         //el programa entra aquí.
 { 
  valor = Serial.read();// Se lee el valor numérico en el puerto serie.
  
  if (valor == '1')//Si el valor es 1.
  {
    digitalWrite(RED_LED, HIGH);  //Se enciende el led rojo.
    Serial.print("Led rojo encendido\r\n");//Se envía el mensaje por el puerto serie,
  }                                        //un retorno y salto de línea.
  
  else if (valor == '2')
  {
    digitalWrite(RED_LED, LOW);  //Se apaga el led rojo.
    Serial.print("Led rojo apagado\r\n");
  }
 
  else if (valor == '3')
  {
    digitalWrite(GREEN_LED, HIGH);  //Se enciende el led verde.
    Serial.print("Led verde encendido\r\n");
  }
  
  else if (valor == '4')
  {
    digitalWrite(GREEN_LED, LOW);  //Se apaga el led verde.
    Serial.print("Led verde apagado\r\n");
  }
  
  else// Si se envía un caracter distinto de 1 - 4, los leds se apagan.
  {
    digitalWrite(RED_LED, LOW);  //Se apaga el led rojo.
    digitalWrite(GREEN_LED, LOW);//Se apaga el led verde.
    Serial.print("Ambos leds apagados\r\n");
  }  
 }
}

Ahora lo que sigue es la instalación del software en el teléfono móvil con Android, para ello descargamos el BlueTerm de la tienda Google Play del siguiente enlace:

https://play.google.com/store/apps/details?id=es.pymasde.blueterm&feature=search_result#?t=W251bGwsMSwyLDEsImVzLnB5bWFzZGUuYmx1ZXRlcm0iXQ..

O usando el siguiente código QR (puedes usar el QRDroid para decodificarlo):

Después de haber instalado el BlueTerm (no lo abran aún), primero tenemos que vincular el módulo bluetooth HC-05 con el teléfono celular; para ello primero habilitamos el bluetooth y luego vamos a Configuración --> Redes inalámbricas y redes --> Configuración de Bluetooth.

Una vez allí seleccionamos la opción 1. Buscar dispositivos, una vez que aparezca el módulo HC-05 en la lista de dispositivos, 2. Lo seleccionamos y escogemos la opción "vincular", posteriormente cuando aparezca el recuadro que pide la contraseña, introducimos 1234 (que es la contraseña por defecto, que traen la mayoría de los módulos de este tipo).

¡Listo!, una vez que hemos vinculado el módulo con el teléfono ahora sí ejecutamos el BlueTerm. Y en las Preferencias podemos cambiar el color de fondo, el tamaño de la letra, etc. (Por defecto viene fondo azul, letras blancas, tamaño 8).

Texto blaco - fondo negro, tamaño de letra 20.

Ahora para enviar caracteres al módulo buetooth, seleccionamos la opción Conectarse a un dispositivo, una vez allí seleccionamos en HC-05 y listo, ya podremos enviar los caracteres 1,2,3,4 para encender/apagar los LEDs de la tarjeta MSP430 Launchpad.

A continuación dejo un video del funcionamiento del circuito:

Por último, dejo una aportación de código al blog, hecha por mi paisano Ángel Jacinto (muchas gracias). El siguiente código (el cuál está publicado, tal cual fue recibido) es un poco menos extenso que el original publicado en esta entrada, y permite encender/apagar de manera independiente los LED's  de la tarjeta MSP430 Launchpad, enviando 1 o 2 desde el teléfono celular:

//////////////////////////
// Autor: Ángel Jacinto //
// País: México         //
// Fecha: 24/05/2013    //
//////////////////////////

char valor=0;
boolean estado1, estado2; //Estado que ocuparemos, estan en boleano para poner falso o verdadero

void setup()
{
  Serial.begin(9600);
  pinMode (P1_0, OUTPUT); //LED ROJO de igual manera puede quedarse con LED_GREEN Y RED
  pinMode (P1_6, OUTPUT); //LED VERDE
  digitalWrite(P1_0, LOW);//Inicialmente se apagan los LEDs.
  digitalWrite(P1_6, LOW);
  estado1 = true; // Se inicializan como verdadero o encendido
  estado2 = true;
}

void loop()  //Bucle infinito
{
  if (Serial.available())//Si hay una caracter en el buffer serial
                         //el programa entra aquí.
 { 
  valor = Serial.read();// Se lee el valor numérico en el puerto serie.
  
  if (valor == '1')//Si el valor es 1.
  {
    digitalWrite(P1_0, estado1);  //Se enciende el led rojo.
    Serial.print("Led rojo encendido\r\n");//Se envía el mensaje por el puerto serie,
    estado1 = !estado1; //Aqui se cambia el valor del estado 1
  }                                        //un retorno de carro y salto de línea.
  
  else if (valor == '2')
  {
    digitalWrite(P1_6, estado2);  //Se enciende el led verde.
    Serial.print("Led verde encendido\r\n");
    estado2 = !estado2;
  }
  
  else// Si se envía un caracter distinto de 1 - 4, los leds se apagan.
  {
    digitalWrite(P1_0, LOW);  //Se apaga el led rojo.
    digitalWrite(P1_6, LOW);//Se apaga el led verde.
    Serial.print("Ambos leds apagados\r\n");
  }  
 }
}

¡Muchas gracias por leer esta nueva entrada!

ALF

MSP430 Launchpad: El "Arduino UNO" de Texas Instruments

En el mundo de los microcontroladores, existen una variedad de fabricantes, citando algunos de ellos: Microchip y sus famosos PICs, ATMEL y sus ATMEGA, entre otros, que se incluyen en las conocidas tarjetas Arduino, también Freescale, Texas Instruments, etc., por mencionar algunos, éste último fabricante sacó al mercado desde hace un buen tiempo atrás sus microcontroladores de la familia MSP430, en conjunto, desarrolló una tarjeta de evaluación de los mismos para que el consumidor pudiese probar estos microcontroladores.

Ésta tarjeta se denomina MSP430 Launchpad, y puede ser adquirida en la eStore de Texas Instruments por la cantidad de $4.3 USD, con el envío internacional incluido en el precio (Al menos a México, necesitan probar si a su país también llega sin cobrar envío), para adquirirla hay que registrarse en la página y pueden realizar el pago con tarjeta de crédito o débito.

El MSP430 Launchpad incluye:

- La tarjeta de desarrollo Launchpad.
- Un microcontrolador MSP430G2452IN20: 8 kB Flash, 256 B RAM, 16 GPIO, WDT, etc.
- Un microcontrolador MSP430G2553IN20: 16 kB Flash, 512 B RAM, 16 GPIO, WDT, etc.
- Cable Mini USB.
- Guía de Incio.
- 2 Conectores de 10 pines c/u tipo hembra.
- Micro cristal de cuarzo de 32.768 kHz (no es muy indispensable, pueden o no soldarlo a la placa).
- 2 Stickers con el logotipo del MSP430 Launchpad.

Esta tarjeta puede ser programada con el siguiente software:

- Code Composer Studio.
- IAR Embedded Workbench.
- MSPGCC.
- Energia.

Sólo por citar algunos.

Para mi gusto, me agrada el software Energia, ya que está basado en el entorno de programación Arduino y puede ser instalado en Windows, Linux o Mac OSX.

Les dejo el link o el código QR donde pueden descargar el software:

http://energia.nu/download/

Y en este otro link y código QR, donde encontrarán los pasos para la instalación de drivers del Launchpad y del software Energia:

http://energia.nu/start/

Algunas ventajas del MSP430 Launchpad con respecto a Arduino son:

- Su precio, $4.3 USD. (Nota: Actualmente TI lo vende en $9.99 USD)
- La gama de C.I. que soporta (la gama MSP430G2X5X).
- Al igual que Arduino, también posee Shields, pero en este caso se denominan BoosterPacks

Por último dejo dos videos:

El primero muestra como cargar un código de ejemplo en la tarjeta MSP430 Launchpad.

En este segundo video se muestra un código de ejemplo implementado por su servidor, para encender y apagar de manera gradual y alternada, los dos LEDs que trae la tarjeta Lauchpad.

Aquí dejo el código del programa para que lo implementen:

/*
Enciende y apaga los leds en el puerto 1, pin 0 y 6 del Micro MSP2553, genera un pulso cuadrado aproximado de 60 Hz para los LEDs.
 */
int t1 = 16;
int toff = 0;

void setup() 
{                
  // Se inicializan las salidas digitales.
  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
}

void loop() //Bucle Infinito
{
 while(t1 > 0)
  {
    t1 = 16 - toff;
    for(int i=0; i<=3; i++)
    {
     digitalWrite(RED_LED, HIGH); // RED_LED ON
     digitalWrite(GREEN_LED, LOW);// GREEN_LED OFF
     delay(t1);  //Retardo de encendido RED_LED / apagado GREEN_LED
     digitalWrite(RED_LED, LOW);  // RED_LED OFF
     digitalWrite(GREEN_LED, HIGH);// GREEN_LED ON
     delay (toff);
    }
    toff = toff + 1;
  }
  t1 = 16;
  toff = 0;
  
 while(t1 > 0)
  {
    t1 = 16 - toff;
    for(int i=0; i<=3; i++)
    {
     digitalWrite(RED_LED, LOW); // RED_LED OFF
     digitalWrite(GREEN_LED, HIGH);// GREEN_LED ON
     delay(t1); //Retardo de encendido GREEN_LED / apagado RED_LED
     digitalWrite(RED_LED, HIGH);  // RED_LED ON
     digitalWrite(GREEN_LED, LOW);// GREEN_LED OFF
     delay (toff);
    }
    toff = toff + 1;
  }
  t1 = 16;
  toff = 0;
}

¡Muchas gracias por leer esta nueva entrada!

ALF