Microchip PIC: PWM + ADC + MOTOR + PIC12F683

En este capítulo, vamos a mostrar como configurar el módulo CAPTURE/COMPARE/PWM (CCP) en modo PWM, y para ello, hemos escogido al microcontrolador PIC12F683.

La idea de este programa es leer la señal analógica ofrecida por un potenciómetro y dependiendo de dicho valor, actualizar la anchura de pulso del PWM. Y para verlo de manera visual, hemos elegido el ejemplo clásico por excelencia, controlar la velocidad de un motor mediante la anchura de pulso PWM.


Pero antes de enseñar el firmware, vamos a pararnos brevemente en el funcionamiento del módulo CCP en su configuración de PWM. Para empezar, prestaremos especial atención al documento: Mid-Range Reference Manual, en el apartado:   14. Compare/Capture/PWM (CCP), concretamente en el subapartado 14.5  PWM Mode, donde viene explicado el funcionamiento de éste módulo.

Hay un dicho que dice que vale más una imagen que mil palabras, pues bien, dentro de dicho subapartado, nos encontraremos con la siguiente imagen:

Pues bien, en esta imagen, se explica los elementos necesarios que intervienen cuando queremos configurar el módulo CCP en modo PWM. Pero antes de seguir, ¿qué es PWM?

Sencillo, dichas siglas vienen del inglés: Pulse-Width Modulation (modulación de anchura de pulso), dicho en cristiano, con éste módulo podremos cambiar la anchura de un pulso a una frecuencia determinada, donde dicho pulso, estará presente en un pin de nuestro microcontrolador.


Por lo tanto, lo primero que deberemos determinar es la frecuencia/periodo a la que queremos trabajar, para ello, disponemos de la siguiente expresión:

PWM_Periodo = ( PR2 + 1 )·4·T_OSC·( TMR2 Prescale Value )

Donde:

· PR2	≡	Carga del Timer 2
· T_OSC	≡	Periodo del reloj principal
· TMR2 Prescale Value	≡	Prescale del Timer 2

Por ejemplo, imaginemos que queremos un periodo de 1ms ( 1 kHz ), el reloj principal es de 8 MHz y el TMR2 Prescale va a ser de 16, calculemos el valor de carga del Timer 2 para que satisfaga dichas condiciones:


( 1000 )^( -1 )  = ( PR2  + 1 )·4·[  ( 8·10^6  )^( -1 )  ]·( 16 )
Despejamos:


· PR2 = 124


En estos momentos, ya tendremos configurado nuestro PWM a una frecuencia de 1 kHz.



Otro de los datos que necesitamos configurar va a ser la anchura del pulso, para ello, disponemos de la siguiente expresión:

Anchura del Pulso = ( CCPR1L:CCP1CON< 5:4 > )·T_OSC·( TMR2 Prescale Value )

Donde:

· CCPR1L:CCP1CON< 5:4 >	≡	Carga del registro CCP para determinar la anchura del pulso
· T_OSC	≡	Periodo del reloj principal
· TMR2 Prescale Value	≡	Prescale del Timer 2

¿Qué quiere decir: CCPR1L:CCP1CON< 5:4 >? Pues es simple, teóricamente disponemos de 10-bits para el módulo CCP:

· CCPR1L dispone de 8-bits.
· CCP1CON< 5:4 >, dos bits más, concretamente el bit 5 y 4 del registro CCP1CON.

Siguiendo con el ejemplo anterior, tenemos configurado un pulso a una frecuencia de 1 kHz, vamos a calcular que valor cargar para que la anchura del pulso sea la mitad, es decir al 50%:


[ ( 1000 )^( -1 ) ]/2  = ( CCPR1L:CCP1CON< 5:4 > )·[  ( 8·10^6  )^( -1 )  ]·( 16 )

Despejamos:


· CCPR1L:CCP1CON< 5:4 > = 250 ( 0xFA, 0b11111010 )


Por lo tanto, si queremos una anchura de pulso del 50% a una frecuencia de 1 kHz, deberemos cargar los registros tal y como se muestra a continuación:


· CCP1CON < 4 > = 0b0 
· CCP1CON < 5 > = 0b1


Al haberse usado los dos bits menos significativos, el resultado que tenemos es el siguiente:  0b111110 ( 0x3E ), y dicho valor se cargará al registro que nos queda:


· CCPR1L = 0x3E


En este momento, ya tenemos una anchura de pulso al 50%, ¿y qué quiere decir esto? Pues que en un ciclo de 1 kHz, la mitad estará en alta y la otra mitad en baja.



Y el último dato que nos queda por saber es la resolución, no siempre vamos a tener disponibles los 10-bits del módulo CCP, esto dependerá de a qué frecuencia queremos que funcione nuestro PWM, para saber la resolución, disponemos de la siguiente expresión:

Resolución = [ ln ( 4·( PR2 + 1 ) ) ]/ln ( 2 ) bits

Y siguiendo con nuestro ejemplo, vamos a calcular nuestra resolución:



· Resolución = [ ln ( 4·( 124 + 1 ) ) ]/ln ( 2 ) ≈ 8.97 = 8 bits


A la configuración deseada, tenemos una resolución de PWM de 8-bits.



Y ya sin más dilación, vamos a presentar nuestro programa, éste consistirá en leer por el pin GP4/AN3 la señal analógica procedente de un potenciómetro que, dependiendo de su valor, actualizará la anchura de pulso del módulo PWM, esto se verá reflejado en la velocidad de un motor conectado al pin GP2/COUT.

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

· PIC12F683: 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 1 KΩ: Se conectará al pin GP4/COUT ( señal PWM ) y a la base del transistor NPN.

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

· Potenciómetro: Del menor valor posible, en nuestro caso, hemos usado uno de 1 kΩ, que irá conectado al pin GP4/AN3.

· Motor: Un motor DC, en nuestro caso hemos usado uno obtenido de una antigua impresora.



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

/**
* @file     main.c
* @author   Manuel Caballero
* @date     3/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 el módulo CCP en
 *             modo PWM.
 *
 *             En este caso, el programa consiste en leer una señal analógica
 *             mediante el módulo ADC 10-bits, y dependiendo de su valor,
 *             la señal PWM cambiará haciendo que un motor gire a más o menos
 *             velocidad.
 *
 *             Se usará el módulo Timer1, 16-bits, para gestionar tanto la
 *             lectura del módulo ADC 10-bits como actuaizar el PWM.
 *
 *
 *  \author    Manuel Caballero
 *  \version   0.0
 *  \date      3/3/2015
 *  \pre       Este firmware está probado para el PIC12F683.
 *
 *  \pre       MPLAB X IDE v2.30.
 *  \pre       Compiler XC8 v1.33.
 */
void main( void ) {

   conf_CLK    ();     // Configura Relojes
   conf_ADC10  ();     // Configura ADC10
   conf_PWM    ();     // Configura PWM ( módulo CCP )
   conf_TA1    ();     // Configura Timer1

        
   INTCONbits.PEIE     =   1;      // Peripheral Interrupt Enable
   ei  ();                         // enable interrupts
    
   while ( 1 );        // Todo se realiza en las interrupciones
}

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: PIC12F683  + ADC10 + MOTOR + PWM
Compilador XC8	Compilador CCS
C	C
PIC12F683: PWM + MOTOR  PIC12F683: PWM + MOTOR	PIC12F683: PWM + MOTOR PIC12F683: PWM + MOTOR

---

· 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.

· NOTA 2: Se incluye la simulación en PROTEUS del programa. La versión entregada de PROTEUS es v7.10 SP0.

Microchip PIC: UART + XBEE + LEDs

En este capítulo, vamos a mostrar como configurar el módulo Addressable Universal Synchronous 
Asynchronous Receiver Transmitter en modo UART, y para ello, hemos escogido al microcontrolador PIC16F88.

La idea de este programa es hacer parpadear cambiar el estado de dos LEDs, uno conectado al pin RB3 ( LED rojo ) y el otro al pin RB4 ( LED verde ) del microcontrolador PIC16F88 dependiendo del comando recibido por la UART ( en este caso, por el pin RX, pin RB2 ).

En este ejemplo, no se va a transmitir nada, solo recibir.

Lo primero que hay que hacer, es saber a que velocidad va el reloj principal, en este caso, el microcontrolador escogido, posee un oscilador interno configurable y en nuestro ejemplo, vamos a ponerlo a la máxima velocidad, 8 MHz.

Y bien, para la configuración de la UART en modo asíncrono ( full-duplex, la transmisión y recepción son independientes ) vamos a poner la lupa en como calcular el Baudrate de la UART.

Según el documento: Mid-Range Reference Manual, en el subapartado: 11.1 AUSART Baud Rate Generator (BRG), nos explica como obtenerlo e incluso algunos valores teóricos para un conjunto de frecuencias de reloj.

Vamos a explicarlo de forma breve, lo primero que debemos saber es que para configurar el Baudrate del módulo UART (en modo ASÍNCRONO ), tenemos dos opciones:

· Baja Velocidad: Para entrar en modo baja velocidad, deberemos poner a cero el bit BRGH del registro TXSTA. y la expresión para calcular el Baudrate es la siguiente:

BaudRate = f_OSC/( 64·( X + 1 ) )

Donde:

· BaudRate	≡	Velocidad de comunicación del módulo UART
· f_OSC	≡	Frecuencia del oscilador principal
· X	≡	Carga del registro SPBRG

Tanto los valores BaudRate como f_OSC son conocidos de antemano, lo que nos interesa es saber el valor de X, así que, despejando obtenemos lo siguiente:

X = [ f_OSC/( 64·BaudRate ) ] - 1

Un ejemplo práctico, tenemos el reloj principal a 8 MHz y queremos un BaudRate de 9600, vamos a calcular con que valor debemos cargar al registro SPBRG:


X = [ f_OSC/( 64·BaudRate ) ] - 1 = [ 8·10^6/( 64·9600 ) ] - 1 ≈ 12.020833 = 12

Como podemos observar, el valor no es exacto, esto quiere decir que tendremos un error, vamos a calcular el error que cometeremos en esta configuración:

· BaudRate Deseado	=	9600
· BaudRate Real	=	8·10^6/( 64·( 12 + 1 ) ) ≈ 9615.38 = 9615

Por lo tanto, el error cometido será el siguiente:

%Error = [ ( BaudRate Real - BaudRate Deseado )/BaudRate Deseado ]·100 = ( 9615 - 9600 )/9600 ≈ 0.16%

· Alta Velocidad: Para entrar en modo alta velocidad, deberemos poner a uno el bit BRGH del registro TXSTA. y la expresión para calcular el Baudrate es la siguiente:

BaudRate = f_OSC/( 16·( X + 1 ) )

Donde:

· BaudRate	≡	Velocidad de comunicación del módulo UART
· f_OSC	≡	Frecuencia del oscilador principal
· X	≡	Carga del registro SPBRG

Al igual que pasaba en el modo baja velocidad, los valores BaudRate como f_OSC son conocidos de antemano, lo que nos interesa es saber el valor de X, así que, despejando obtenemos lo siguiente:

X = [ f_OSC/( 16·BaudRate ) ] - 1

Pongamos el mismo ejemplo que antes: el reloj principal a 8 MHz y queremos un BaudRate de 9600, vamos a calcular con que valor debemos cargar al registro SPBRG:


X = [ f_OSC/( 16·BaudRate ) ] - 1 = [ 8·10^6/( 16·9600 ) ] - 1 ≈ 51.083333 = 51

Como podemos observar, el valor no es exacto, esto quiere decir que tendremos un error, vamos a calcular el error que cometeremos en esta configuración:

· BaudRate Deseado	=	9600
· BaudRate Real	=	8·10^6/( 16·( 51 + 1 ) ) ≈ 9615.38 = 9615

Por lo tanto, el error cometido será el siguiente:

%Error = [ ( BaudRate Real - BaudRate Deseado )/BaudRate Deseado ]·100 = ( 9615 - 9600 )/9600 ≈ 0.16%

Bien, llegados a este punto, ya sabemos calcular el BaudRate para nuestro módulo UART, solo decir un par de cosas más, la primera: Microchip recomienda el uso de Alta Velocidad para la obtención del BaudRate.

Y la segunda, hay que prestar especial atención al registro SPBRG, dicho registro, como ya sabemos, es el encargado de almacenar el valor X calculado para el BaudRate, pero es un registro de 8-bits. ¿Qué quiere decir esto? Pues si nuestro valor calculado X sea mayor a 256, el BaudRate que queremos generar NO es posible.

Por lo que la única opción que nos queda es comprobar tanto en Alta Velocidad como en Baja Velocidad si el valor X es menor a 256. En caso contrario, deberemos cambiar o la frecuencia del reloj o el BaudRate.



Y ya sin más dilación, vamos a presentar nuestro programa, éste consistirá en cambiar el estado de dos LEDs dependiendo del valor enviado por la UART, y para hacerlo más vistoso, lo vamos a hacer de forma inalámbrica, con un par de módulos XBee.

Así que en nuestro ordenador tendremos un módulo XBee ( será el Coordinador ) y en nuestro protoboard tendremos al PIC16F88 con sus LEDs y otro módulo XBee ( será End Device ) conectado al pin Rx de la UART.

En este ejemplo, no vamos a transmitir nada, así que solo nos interesa el pin de recepción de datos Rx.

El PIC16F88 tiene un reloj interno configurable, en nuestro caso, vamos a ponerlo a la máxima velocidad, a 8 MHz, y para el BaudRate, será a 9600 en Alta Velocidad ( tal y como recomienda Microchip ).

Por lo tanto BRGH = 1 ( registro TXSTA ), así que la carga del registro SPBRG = 51 ( el cómo obtener dicho valor, se puede ver anteriormente ). En el momento que se reciba un dato por la UART ( pin Rx ), se producirá una interrupción donde se leerá el dato y se procederá al cambio del estado del LED correspondiente.



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

· PIC16F88: Microcontrolador para este programa.

· Protoboard: Donde insertaremos nuestros componentes.

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

· Módulos XBee: Un par de ellos, en este caso, el módulo XBee es el modelo: XB24-ZB.

· 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.

· Resistor 220 Ω: Un par de resistores que irá en serie al LED y conectado al pin RB3 y RB4 para limitar la corriente.

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

· LEDs: Un par de ellos, en nuestro caso uno rojo y el otro verde.



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

/**
* @file      main.c
* @author    Manuel Caballero
* @date      26/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 < xc.h >
#include < stdint.h >
#include "variables.h"
#include "functions.h"
#include "interrupts.h"

/**
 *  \brief     void main( void )
 *  \details   Este programa consiste en encender un LED rojo o un LED verde
 *             por medio del módulo UART.
 *
 *             Todas las acciones se realizarán en el servicio de interrupción
 *             de la UART.
 *
 *             Este programa se ha probado con un par de módulos XBee modelo
 *             XBee XB24-ZB ( uno Coordinator y el otro End Device ).
 * 
 *
 *  \author    Manuel Caballero
 *  \version   0.0
 *  \date      26/2/2015
 *  \pre       Este firmware está probado para el PIC16F88.
 *  \pre       El LED rojo estará conectado al pin RB3
 *             ( un resistor de 220 Ohms en serie ).
 *  \pre       El LED verde estará conectado al pin RB4
 *             ( un resistor de 220 Ohms en serie ).
 *
 *  \pre       MPLAB X IDE v2.30.
 *  \pre       Compiler XC8 v1.33.
 */
void main( void ) {

   conf_CLK    ();     // Configura Relojes
   conf_IO     ();     // Configura Pins
   conf_UART   ();     // Configura UART

   ei  ();             // enable interrupts
    
   while ( 1 );        // espera dato procedente de 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 (XC8 y CCS) para que lo podáis descargar y probar:

Microchip PIC: PIC16F88 + LEDs + UART + XBee
Compilador XC8	Compilador CCS
C	C
PIC16F88: UART + XBee  PIC16F88: UART + XBee	PIC16F88: UART + XBee PIC16F88: UART + XBee

Podéis encontrar el código completo en nuestro repositorio GitHub

·

AqueronteBlog GitHub.

---

· 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.

· NOTA 2: Se incluye la simulación en PROTEUS del programa. La versión entregada de PROTEUS es v7.10 SP0.

Microchip PIC: LED + Timer0

Para empezar esta entrega de programas usando los microcontroladores PIC de la empresa Microchip, hemos decidido dedicarle nuestro particular homenaje a un clásico, el PIC16F84A.

Y como no, vamos a realizar el ejemplo clásico por excelencia, el típico "Hola mundo" que traducido en el mundo de los sistemas embebidos, sería el hacer parpadear un LED. Pero este capítulo tiene el propósito de mostrar como usar el periférico interno del PIC llamado Timer0, en nuestro caso, lo configuraremos como temporizador.

Por lo tanto, el ejemplo consistiría en configurar el Timer0 como temporizador y que al desbordarse genere una interrupción. En dicha interrupción, se cambiará el estado del LED.

Antes que mostrar el código, vamos a explicar muy brevemente la mecánica del Timer0 configurado como temporizador. Bien, dicho timer es de 8-bit y para generar tiempos sigue la siguiente expresión:

Tiempo = 4·( 1/f_Timer0_OSC )·( 256 - TMR0 )·Prescaler

Donde:

· Tiempo	≡	Tiempo que se desea generar
· f_Timer0_OSC	≡	Frecuencia del Timer0
· TMR0	≡	Carga del registro
· Prescaler	≡	Escala para la frecuencia del Timer0

Llegados a este punto, vamos a profundizar un poco más en la expresión del Timer0, ya que creo que merece la pena, por ejemplo, ¿cuál es el tiempo máximo que podemos generar?

La respuesta a esta cuestión será de vital importancia cada vez que trabajemos con el Timer0, vamos a contestarla. Pero para tal fin, vamos a considerar que dicha frecuencia es fija y se conecta a la frecuencia del reloj principal.


· ¿Cuál es el tiempo máximo que podemos generar?

En este caso, el máximo tiempo que podemos generar con el Timer0 será cuando se den las siguientes condiciones:

· TMR0	=	0	( valor mínimo )
· Prescaler	=	256	( valor máximo )

Vamos a considerar la frecuencia del Timer0 de 4 MHz ( simplemente para facilitar los cálculos ).


Comprobamos:


Tiempo = 4·( 1/( 4·10^6 ) )·( 256 - 0 )·256 = 65.536 ms

Con las características anteriormente mencionadas, obtendríamos un tiempo de 65.536 ms.

Por lo tanto, en caso de que esté habilitada el servicio de interrupción del Timer0, esto significa que se producirá una interrupción cada, aproximadamente 65.536 ms.

En caso de necesitar retardos mayores tenemos dos opciones:

1.- Utilizar una variable contador. Por ejemplo, imaginemos que queremos obtener un retardo de 1 segundo usando el Timer0. Como ya hemos visto, no se puede obtener de manera directa, por lo que emplearemos una variable contador.

Para tal fin, se programará el Timer0 a un tiempo conocido y permitido, por ejemplo, a 50 ms, así que para obtener un segundo, simplemente tenemos que hacer lo siguiente:

1s = Variable_Contador·50ms

Despejamos:

· Variable_Contador = 1s/50ms = 20

Como podemos comprobar, cuando la Variable_Contador llegue a 20, significa que habrá transcurrido 1s.


2.- Utilizar una frecuencia del Timer0 más baja posible. Otra forma de obtener tiempos más altos es usar la frecuencia del Timer0 lo más baja posible. Esto lo podemos hacer por dos vías:

2.1. Frecuencia Timer0 interna: Esto significa que la frecuencia del Timer0 es la misma que la del reloj principal de sistema.

Esto tiene un inconveniente, y es que todo el sistema también tendrá una frecuencia más baja y por ende, las instrucciones se procesarán más lentamente, por otro lado, es beneficioso en términos de bajo consumo.

2.2. Frecuencia del Timer0 externa. Usar una fuente de reloj externa lo más bajo posible por los pines indicados para tal fin.

Por ejemplo, digamos que la frecuencia del Timer0 es de 32 kHz, vamos a calcular el tiempo máximo que podemos generar:


Tiempo = 4·( 1/( 32·10^3 ) )·( 256 - 0 )·256 = 8.192 s

Como se puede observar, si la frecuencia del Timer0 es de 32 kHz, podremos alcanzar tiempos hasta, aproximadamente 8.192 segundos.


Y bueno, vamos a entrar ya en faena, la idea de este programa es hacer parpadear un LED conectado al pin RB3 del microcontrolador PIC16F84A cada aproximadamente 0.5s. El reloj del microcontrolador es de 4 MHz.


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

· PIC16F84A: Microcontrolador para este programa.

· Protoboard: Donde insertaremos nuestros componentes.

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

· Cristal 4 MHz: Necesario para la frecuencia del reloj principal y fuente del reloj del Timer0.

· Condensador 16 - 68 pF: Un par para estabilizar la señal del cristal.

· Resistor 220 Ω: Un resistor que irá en serie al LED y conectado al pin RB3 para limitar la corriente.

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


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

/**
* @file        main.c
* @author      Manuel Caballero
* @date        25/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 < xc.h >
#include < stdint.h >
#include "variables.h"
#include "functions.h"
#include "interrupts.h"

/**
 *  \brief     void main( void )
 *  \details   Este programa consiste en hacer parpadear un LED cada,
 *             aproximadamente 0.5 s.
 *
 *             Para tal fin, se usará el Timer 0.
 *
 *
 *  \author    Manuel Caballero
 *  \version   0.0
 *  \date      25/2/2015
 *  \pre       Este firmware está probado para el PIC16F84A.
 *  \pre       El LED estará conectado al pin RB3
 *             ( un resistor de 220 Ohms en serie ).
 *  \pre       El reloj externo es de 4 MHz.
 *
 *  \pre       MPLAB X IDE v2.30.
 *  \pre       Compiler XC8 v1.33.
 */
void main( void ) {

  conf_IO    ();    // Configura Pins
  conf_TA0   ();    // Configura Timer0

  ei  ();           // enable interrupts
    
  while ( 1 );      // Espera a que se produzca interrupción Timer0
}

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: PIC16F84A + LED + Timer0
Compilador XC8	Compilador CCS
C	C
PIC16F84A: LED + Timer0  PIC16F84A: LED + Timer0	PIC16F84A: LED + Timer0 PIC16F84A: LED + Timer0

Podéis encontrar el código completo en nuestro repositorio GitHub

·

AqueronteBlog GitHub.

---

· 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.

· NOTA 2: Se incluye la simulación en PROTEUS del programa. La versión entregada de PROTEUS es v7.10 SP0.

MSP430: IAR & Proteus

En esta entrada explicaremos los fundamentos esenciales para poder simular nuestros programas realizados con el compilador IAR Kickstart y el programa de electrónica de la casa Labcenter llamado Proteus.

Este tutorial está basado en la versión de Proteus 7.7 SP2 que desgraciadamente no dispone de nuestros micros: MSP430G2231 y MSP430G2211 (esperemos que en futuras versiones los incorporen). Pero bueno, no es un gran problema ya que disponemos de un micro muy similar al nuestro: MSP430F2011.

Más o menos podremos simular los aspectos más superficiales con dicho microcontrolador que trae Proteus incorporado sin modificar nada de nuestro código.

El primer problema que nos encontramos es que al compilar un proyecto (o archivo) en IAR, no nos devuelve como salida un fichero válido para que se pueda usar en Proteus. Nuestra misión será indicarle a IAR que a parte de la salida convencional (para poder ser empleada en nuestra tarjeta de desarrollo o dispositivo físico) nos devuelva un archivo con formato Intel-HEX.

¿Y cómo se hace esto? Muy fácil, cuando tengamos un proyecto abierto, en el menú de herramientas: Project --> Options...

Nos saldrá una ventana de configuración, donde en la parte de la izquierda debemos seleccionar Linker y en la parte derecha, Extra Output, y configurar de tal manera que quede cómo la de la imagen:

Donde Nombre_Proyecto será el nombre que queremos indicarle a nuestro proyecto, pues bien, si compilamos, IAR nos dará como salida el archivo para programar en el dispositivo real y el archivo de extensión .hex el cual usaremos para simular en Proteus.

Y así de fácil es obtener dos ficheros de salida, uno para programar a nuestro dispositivo físico y el otro lo emplearemos para las simulaciones en Proteus.

Proteus

La presente entrada está dedicada al programa de simulación electrónica llamado Proteus.

Dicho programa es una herramienta software que nos permitirá abarcar todas las fases que se requieren para la confección de un proyecto, tales cómo: el Diseño, la Simulación, la Depuración y la realización del PCB.

La empresa que está detrás de Proteus es Labcenter Electronics.

Compañía inglesa fundada en el año 1988 por John Jameson.

Este software se ha hecho mundialmente conocido (y expandido) sobre todo por ser unos de los primeros que incorporaban entre sus funciones, la simulación de MCU, es decir, de microprocesadores y microcontroladores, siendo éste último, la gran baza de este programa, ya que, hoy en día, es capaz de simular microcontroladores de varios fabricantes (Microchip, Atmel, Motorola, etc) como veremos más adelante en sus especificaciones.

El programa en sí, se puede dividir en cuatro grupos según su utilidad:

• ISIS: Ésta será la herramienta para la confección de nuestros diseños electrónicos. Viene identificado por el siguiente icono:

• ARES: Es la herramienta la cual una vez tengamos diseñado nuestro circuito, pasaremos a confeccionar el circuito impreso (PCB). Viene identificado por el siguiente icono:

• ProSPICE: Todas las copias de Poteus viene incluída con esta herramienta, la cual se encarga de la simulación del diseño electrónico creado, ésta herramienta está basada en Berkeley SPICE3F5. Al estar incluída, no se identifica con ningún programa externo, simplemente hay que abrir el ISIS y diseñar nuestro circuito, para posteriormente simularlo.

Hasta aquí, se podría decir que éstas son las partes principales de este programa, normalmente, se le añade otra cualidad más:

• VSM: Es la herramienta encargada de la simulación de MCU, ya sean microprocesadores o microcontroladores. ésta herramienta, es la que a dotado de gran fama a este simulador electrónico. Con ella, podremos simular microcontroladores de las familias PIC, dsPIC, 8051, AVR, ARM, HC11, etc, sin necesidad de tener una placa de desarrollo o montar físicamente nuestro diseño. Sobre todo es de gran utilidad ya que Proteus dispone de multitudes de periféricos para nuestras simulaciones: Periféricos.
  

Ahora viene la pregunta del millón, ¿es gratuito? Pues no, eso sí, nos permiten descargarnos una versión DEMO o mejor dicho, hay dos tipos de versiones DEMO que nos ofrecen.

Una, es la demo de la versión actual del programa la cual, está muy limitada, ya que no podremos guardar, imprimir o diseñar nuestros diseños con microcontroladores, eso sí, podremos cargar en el disño de ejemplo que trae consigo la demo nuestros códigos para la simulación. En realidad, esta versión, sólo es de utilidad para ver el potencial que presentaría Proteus en su versión completa. El enlace de descarga es el siguiente: Proteus Demo.

La otra demo es más que interesante, es la llamada Proteus Lite, y sí, es gratuita, ésta es la versión shareware de Proteus, especialmente destinada para estudiantes y aficionados (en definitiva, es una primera toma de contacto con el software), eso sí, también puede servir para usos comerciales ya que no se prohíbe.

Las limitaciones son bastantes, tantos en simulación como en la creación del PCB, esta versión tiene un enlace aparte del Proteus Profesional: Proteus Lite.

Es interesante registrarse ya que así nos proporcionarán mas funcionalidades para esta versión demo.

En definitiva, éste software es de gran utilidad, y por ello, se usará en más de una ocasión en Aqueronte para acompañar las simulaciones que se realicen y se expongan en el blog.