domingo, 24 de marzo de 2013

Lectura de Inputs en un pic

En los post anteriores estuvimos usando el bit 0 del puerto B del PIC16F88 para encender y apagar un led cada 500 ms. Esto quiere decir que usamos ese bit como salida. Ahora les mostraré como utilizar un bit en modo entrada de datos digital utilizando un botón de tipo "push".

Cuando un pin de nuestro PIC (ej.: RB4) se utiliza como entrada, lo que debemos hacer es conectarlo a +5 Volts mediante 2 resistencias de 1k (R1) y 10k (R2) en ese orden. Entre estas 2 resistencias colocamos el botón (S1) conectado al negativo de nuestra fuente.

Imagen 1 - Diagrama de conexión de una entrada

Imagen 2 - Switch (S1) contectado entre las resistencias y los 0Volts


El efecto que provoca es que el Input siempre esté en estado alto (HIGH o 1). Cuando se presiona el botón (S1) los 5V se dirigen a GND lo que provoca que el input esté en estado bajo (LOW o 0).

Ejemplo 1:

Para nuestro primer ejemplo vamos a hacer lo siguiente:

Si el botón está pulsado (RB4 = 0), prender el led,
Sino, mantenerlo apagado.

Utilizaremos el bit 4 del puerto B tal como aparece en la figura anterior.

#define LED     PORTBbits.RB0 // El Led se encuentra conectado en RB0
#define posLED  0             // Posición en la que se encuentra el Led

#define BUTTON  PORTBbits.RB4 // El botón se encuentra conectado en RB4
#define posBUTTON   4         // Posición en la que se encuentra el botón

void main(void)
{
    // Configura el oscilador
    ConfigureOscillator();

    // Configura un 0 en la posición que le corresponde al LED
    // y un 1 a todas las demás.
    // 0 = Salida, 1 = entrada
    TRISB = ~(1 << posLED) | (1 << posBUTTON);
    // La línea anterior es equivalente a
    // TRISB = 0b11111110;

    // Inicializo el led apagado
    LED = 0;

    // Bucle principal
    while(true) {
        // Enciende el led sólo si está presionado el botón
        LED = BUTTON ? 0 : 1;
    }
}

En el bucle principal hacemos que el valor del LED sea igual al 0 si BUTTON (RB4) es HIGH, sino 0.

Código completo del ejemplo 1

Ejemplo un poco más complicado:


En este ejemplo vamos a probar lo siguiente: Cuando se presione el botón, si el LED estaba apagado, encenderlo, si el LED estaba encendido, apagarlo.

Para esto podríamos reemplazar el bucle principal del ejemplo anterior por lo siguiente:

// Bucle principal
while(true) {
     while(BUTTON == 1) {
     }
     LED = 1;

     while(BUTTON == 0) {
     }
     LED = 0;
}

Si probamos compilarlo y pasarlo a nuestro PIC, este código funciona correctamente, sin embargo lo hará de manera errática. A veces nos hará caso y a veces parecerá que el LED se apaga y se prende muy rápidamente.

Este comportamiento se debe al "rebote" eléctrico que hace el botón al presionarse. Para explicarlo de forma simple, el código dentro del bucle principal se ejecuta muy rápidamente, a razón de millones de instrucciones por segundo mientras que el movimiento del dedo empujando el botón es muy lento lo que provoca que este toque la superficie y rebote hasta estabilizarse pasando de alto a bajo en cuestión de microsegundos.

Para evitar esto debemos manejar este rebote mediante un contador. En este ejemplo haremos que un botón esté presionado sólo si se mantiene apretado durante 10ms.

uint8_t contadorDeRebotes;      // Cuenta los rebotes de un input

// Bucle principal
for(;;) {
     // Espera hasta que el botón esté presionado unos 10 ms como mínimo
     for(contadorDeRebotes = 0 ; contadorDeRebotes < 10 ; contadorDeRebotes++) {
          __delay_ms(1);
          if(BUTTON == 1)
               contadorDeRebotes = 0;
     }

     LED ^= 1;   // Hace un XOR entre el valor actual y 1
                 // Con esto obtiene el valor contrario.

     // Espera hasta que el botón esté levantado unos 10 ms como mínimo
     for(contadorDeRebotes = 0 ; contadorDeRebotes < 10 ; contadorDeRebotes++) {
          __delay_ms(1);
          if(BUTTON == 0)
               contadorDeRebotes = 0;
     }
}

Ahora sí, nuestro código funciona como esperamos.

Una mejora que le podemos hacer al código es utilizar lo que se llama "shadow register". Esto es una variable auxiliar que mantiene en todo momento el estado de un registro. Lo que permite es que en lugar de leer el estado que tiene un bit de un puerto (que en ciertos casos puede leerse de forma incorrecta si está pasando de un estado a otro), leamos un valor previamente guardado cuyo valor no cambiará a menos que se lo especifiquemos.

Con un shadow register el ejemplo quedaría así:

uint8_t contadorDeRebotes;      // Cuenta los rebotes de un input
uint8_t shadowPortB = 0;        // Shadow copy del puerto B

// Bucle principal
for(;;) {
     // Espera hasta que el botón esté presionado unos 10 ms como mínimo
     for(contadorDeRebotes = 0 ; contadorDeRebotes < 10 ; contadorDeRebotes++) {
          __delay_ms(1);
          if(BUTTON == 1)
               contadorDeRebotes = 0;
     }

     shadowPortB ^= 1 << posLED; // Hace un XOR entre el valor actual y 1
                                 // sobre el shadow register
     PORTB = shadowPortB;        // Copia el valor del registro al puerto B

     // Espera hasta que el botón esté levantado unos 10 ms como mínimo
     for(contadorDeRebotes = 0 ; contadorDeRebotes < 10 ; contadorDeRebotes++) {
          __delay_ms(1);
          if(BUTTON == 0)
               contadorDeRebotes = 0;
     }
}

Código completo del ejemplo 2

Bueno, espero que se hayan entendido estos ejemplos básicos. El código con los ejemplos está en mi repositorio de GitHub :

Fuentes:
http://www.gooligum.com.au/tutorials/midrange/PIC_Mid_C_1.pdf

Enviar datos a la PC mediante USART

En este post voy a utilizar el puerto USART de mi PIC16F88 para enviar datos a la pc cada 500 ms. Utilizando el proyecto que prende o apaga un led ahora además voy a enviar a la pc el valor de una variable que se incrementa cada cierta cantidad de tiempo.

Proyectos relacionados:



Lo primero que tenemos que hacer es configurar el puerto USART de nuestro pic para que envíe datos a una determinada velocidad. La misma va a depender de la velocidad del clock que estemos usando.

En mi caso voy a utilizar un cristal de 20Mhz. En la documentación de nuestro pic veremos que combinaciones podemos utilizar:

Primero tenemos que elegir el valor del parámetro BRGH ( "0" Baja velocidad  -  "1" Alta velocidad)

Tabla 1 - Datasheet PIC16F88

Dependiendo del valor que elijamos en BRGH iremos a la tabla que corresponda. Según la recomendación del manual, es preferible elegir el valor "1" ya que en la mayoría de los casos da un menor error en los cálculos:

Tabla 2 - Datasheet PIC16F88

Ahora lo que tenemos que hacer es para un determinado valor de KBauds seleccionar el valor SPBRG que le corresponda.

Por ejemplo, para 20Mhz y 19200 Baud el valor de SPBRG es 64 con un error de +0.16 para BRGH=1, (Si hubiese elegido BRGH=0 el error sería de +1.72)

La configuración en C es la siguiente:

// Habilita la conexión serial
// Habilitar uart

TXSTAbits.TX9 = 0;  //  Transmisión de 8-bit
TXSTAbits.SYNC = 0; // Modo asincrónico
TXSTAbits.BRGH = 1; // BRGH en alta velocidad

RCSTAbits.RX9 = 0;  // Recepción de 8-bit
RCSTAbits.SPEN = 1; // Puerto serial habilitado
// (configura RB2/SDO/RX/DT y RB5/SS/TX/CK pins como puerto serial)

SPBRG = 64;       // 19200 baud

TXSTAbits.TXEN = 1; // Habilita la transmisión de datos
RCSTAbits.CREN = 1; // Habilita la recepción de datos
RCIE = 1;           // Habilita las interrupciones por recibo de datos

__delay_ms(80); // Delay que permite que se estabilice la configuración y las interrupciones antes de comenzar a trabajar



Aparte de esto debemos agregar el siguiente código para que se limpie la interrupción de recepción de datos:

/*
* Vector de interrupciones
*/
static void interrupt isr(void) {
    // Limpia la interrupción de recepción de data
    if(RCIF && RCIE) {
        RCIF = 0;
    }
}

Si no hacemos esto, lo que sucede es que no recibiremos nada en la consola de la PC.

El siguiente código es necesario para poder utilizar las funciones como printf, getch, putch, etc para escribir y leer variables tal cómo se haría en una aplicación de consola.

/*
* Rutina necesaria para que funcione correctamente el printf.
* Escribe un caracter en el puerto serial.
*/
void putch(unsigned char data) {
  /* output one byte */
  while(!TXIF)     /* set when register is empty */
    continue;
  TXREG = data;
}

/**
* Obtiene un caracter desde el puerto serial.
* @return
*/
unsigned char getch() {
     /* retrieve one byte */
     while(!RCIF)     /* set when register is not empty */
          continue;
     return RCREG;
}

/**
* Obtiene un caracter desde el puerto serial y lo retransmite.
* @return
*/
unsigned char getche(void) {
     unsigned char c;
     putch(c = getch());
     return c;
}

Ahora lo que nos resta es llenar el cuerpo de la aplicación:

int contador = 0;

// Bucle principal
while(true) {

     LED = 1;    // Setea en estado alto (High) el LED

     __delay_ms(500); // Se queda esperando 500 milisegundos

     printf("contador: %d\r\n", contador++);
     LED = 0;    // Setea en estado bajo (Low) el LED

     __delay_ms(500);

     printf("contador: %d\r\n", contador++);

}

Lo que hace este código es bastante fácil de entender. 

1) Crea una variable de tipo integer llamada "contador"

2) Enciende el LED cómo se mostró en los anteriores posts y espera 500ms para apagarlo.

3) El método printf recibe una cadena de texto + parámetros. 
  • la expresión "%d" indica que debe recibir un parámetro de tipo entero (número) para formatearlo como cadena de caracteres. 
  • El "\r\n" hace un Enter en la consola. 
  • contador++ incrementa la variable

Una vez que compilamos el proyecto y lo pasamos con el AN1310, seleccionamos la opción "Run application firmware" y veremos que aparecerá la información en pantalla:


Imagen 1 - An1310 recibiendo datos cada 500ms
En mi caso estoy enviando un contador bastante simple pero haciéndo algunos cambios en el código podemos informar el valor de alguna entrada. Por ejemplo, podríamos informar que se presionó un botón o que recibimos información de algún sensor.

Hoy no hay video porque estoy afónico!

El código completo lo encontrarán en mi repositorio en GitHub: PIC16F88_06_USART.

Saludos!

Fuente:
Datasheet PIC16F88

martes, 26 de febrero de 2013

Bootloader AN1310 - Video

Hola!,

En esta entrada voy a subir mi primer video tutorial que hice para que vean lo fácil que es cargar los programas al PIC teniendo un bootloader.

Este post extiende al anterior: Bootloader - AN1310

Saludos!

PD: Pido disculpas si es que no se entiende pero estuve luchando varias horas con el editor de videos para poder mezclar la captura de pantalla con lo que filmaba desde el celular :)


domingo, 24 de febrero de 2013

Bootloader - AN1310

En esta entrada voy a hablar del Bootloader que utilizo para programar mi PIC16F88.

Un Bootloader es una porción de código estática dentro del pic que se ejecuta antes del código que nosotros programaremos. Cuando se activa permite comunicarse con la PC para realizar actualizaciones del programa que debe ejecutar el pic. Esto permite que el pic se programe a sí mismo sin necesidad de un grabador de pics.

Este código generalmente se encuentra en la parte más alta de la memoria de programa y no debe ser modificado por el programa que nosotros hagamos

¿Cuál es la ventaja de utilizar un bootloader? La ventaja más significativa es que podemos construir un circuito con un código base, soldar todos sus componentes y a medida que desarrollamos el software o descubrimos bugs, mediante el bootloader le actualizamos su firmware.

Como desventaja, hay menos espacio en el chip para nuestro código.

En la siguiente imagen podemos ver de forma simple cómo se ve un pic normal y uno con bootloader:




AN1310


Hay varios Bootloader disponibles para el pic16f88 y hasta podríamos hacernos el propio pero en lugar de eso vamos a utilizar el que nos provee Microchip, el AN1310.

El AN1310 es un Bootloader bastante pesado ya que ocupa unas 1000 palabras de programa (el PIC16F88 tiene 4096 palabras). Está escrito en assembler y debemos compilarlo para cada tipo de pic en particular ya que cambian las posiciones de memoria.

Para descargarlo debemos ir a la siguiente dirección:

Este es el esquema que debe tener el circuito que hagamos para conectar nuestro pic:


Para el PIC 16F88 en lugar +3.3V utilizaremos los +5V que venimos usando en los posts anteriores.

Para explicarlo brevemente, se utilizan las líneas RXD y TXD del puerto serial para cargar los datos al pic mediante la interfaz USART mientras que se utiliza la línea de control RTS para provocar un "Reset" del pic.

Este reset por software es muy útil para que luego de cargar un programa se pueda probar o frenar el mismo. 

Interfaz del programa:


Al conectar nuestro pic mediante el circuito presentado anteriormente al puerto serial de la pc y hacer click en el botón "bootloader Mode" (el cuadrado rojo), y si todo está conectado ok, veremos lo siguiente:


Cargaremos el mismo programa que vengo haciendo en los primeros posts con algunos cambios que mostraré más adelante y haciendo click en write device pasará el programa a nuestro pics pocos segundos:


Luego de cargar el programa hacemos click en el botón "Run application firmware" (el verde) y podremos ver nuestro programa funcionado.

En el manual de este bootloader podremos encontrar muchas más opciones.

Configuración que debe tener nuestro programa para que funcione correctamente:


Para que un programa hecho en MPLABX cargue correctamente utilizando el bootloader debemos modificar las opciones del linker de XC8 para que no sobreescriba los sectores de memoria reservados:


Para el PIC 16F88 las opciones son: --ROM=default,-e40-fff --RAM=default,-7E-7F

Lo que estamos indicándole es: Para la memoria rom usá el espacio default excepto las posiciones entre E40 y FFF. Para la memoria RAM usá el espacio default excepto las posiciones entre 7E y 7F.

Acabo de subir a GitHub el proyecto PIC16F88_03_TestBootLoader con el programa del led intermitente más la configuración anterior y el proyecto PIC16F88_04_Bootloader_20Mhz con la configuración necesaria para compilar el bootloader. Hay que tener en cuenta que el bootloader se compila en assembler así que tienen que tener habilitado el compilador MPASMX que se encuentra en la carpeta de instalación del MPLABX.

Repositorio:

Saludos,


Fuentes:
TinyPIC - http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm
AN1310 - http://ww1.microchip.com/downloads/en/AppNotes/01310a.pdf


martes, 19 de febrero de 2013

Mi repositorio en GitHub

Hola, esta entrada va a ser bastante corta.

Acabo de crear el repositorio "programandopics" en GitHub para poder compartir el código que voy haciendo para así tener todos los ejemplos de pics juntos.

La dirección es:

https://github.com/jgquiroga/programandopics

Ya están subidos los ejemplos para encender un led de forma intermitente.

Saludos!

sábado, 22 de diciembre de 2012

USART - Comunicación Pic - PC

Comunicación Serial con el PIC + Fuente de 5 Volts.


En este post les voy a mostrar el circuito que hice para poder conectar mi pic mediante un cable serial a la PC. Esto nos permitirá realizar programas que controlen las acciones del PIC o que reciban información del PIC. En mi caso, primero voy a utilizarla para grabar programas mediante un Bootloader y así evitar tener que mover el pic a mi grabadora JDM. Luego lo voy a utilizar para mover servomotores.

Componentes necesarios:


Para la fuente de +5V (ver en detalle en un post previo):


  • 7805 - 1 circuito integrado 7805
  • C1, C4 - 2 capacitores de 470uF
  • C2, C3 - 2 capacitores de 0.1uF
  • R1 - 1 resistencia de 220 ohm (depende del LED)
  • LED - 1 LED Rojo
  • BAT1 - 1 batería de 9Volts
  • 9V - 1 conector macho de 2 patas.
  • PORT1 - 1 conector macho a placa de 2 o 4 patas (Este conector tendrá la salida a 5Volts)


Para la comunicación serial


  • MAX232 - 1 circuito integrado Max232
  • C5, C6, C7, C8, C9 - 5 capacitores de 1uF
  • PortPIC, PortPC - 2 conectores macho a placa de 4 pines



Este es el diagrama del esquemático de la fuente de 5Volts:


Fuente de 5 Volts


Este el es diagrama para la comunicación serial:

MAX32 - USART


Para explicar de forma básica que es lo que hace este circuito podemos pensar en 2 cables que se unen entre la PC y el PIC. Estos 2 cables tienen la función de enviar (TX) y recibir (RX) datos de forma serial, es decir, un bit atrás del otro:

Comunicación simplificada entre PC y PIC


El PIC16F88 cuenta con la función USART (Universal Synchronous-Asynchronous Receiver-Transmitter) que permite utilizar 2 de sus patas para esta comunicación. Para simbolizar un bit en 1, la salida debe estar a +5V, y para simbolizar un 0, en bajo voltaje, cercano a los 0V (TTL).

Por el lado de la PC utilizaremos el puerto Serial que envía señales en base al protocolo RS-232 simbolizando un 1 con un voltaje entre +3 y +15V y un 0 con un voltaje de entre -15 y -3V, es decir, un 1 es voltaje positivo y un 0 es voltaje negativo.

Como podemos observar, el tipo de comunicación de los dispositivos anteriores no es compatible, es por esto que debemos utilizar un componente en el medio para que transforme estas señales. Este componente es el MAX232 el cual nos provee de 2 pares de conversores de señal. Para la comunicación con el pic sólo es necesario 1 par de estos conversores.

Si nos fijamos bien, del par de Rx/Tx que nos sobra del MAX232 una línea Tx la nombré RTS ya que para próximos circuitos me servirá de señal de reset.

En un próximo post probaremos este circuito en funcionamiento.

Les dejo unos planos de cómo quedaría en una placa de PCB (los diagramas los hice con DipTrace):

Diagrama PCB hecho con Diptrace

Diagrama PCB hecho con Diptrace mostrando los componentes
Fotos del circuito armado:

Circuito listo para alimentar un pic y comunicarse con la pc
Nota: Luego de haber puesto los componentes en el circuito me di cuenta que era muy poco el espacio entre los capacitores de la fuente de alimentación así que para mi siguiente circuito los alejaré más.

Vista del circuito pasado a un PCB



Saludos!

martes, 2 de octubre de 2012

Distintas configuraciones del Oscilador con el PIC

Vamos a ver las distintas configuraciones del oscilador que puede tener el PIC16F88

En el Post anterior (Primer proyecto en XC8) utilicé el oscilador interno del PIC16F88 a 8Mhz con los siguientes fragmentos de código:

/*
 * File:   system.h
 */
#define _XTAL_FREQ       8000000
 
/**
 * File:        configuration_bits.c
 */
 
__CONFIG(MCLRE_ON & CP_OFF & CPD_OFF & LVP_OFF & BOREN_OFF &
         WDTE_OFF & FOSC_INTOSCIO & PWRTE_OFF);
__CONFIG(IESO_OFF & FCMEN_OFF);

/**
 * File:        system.c
 */
void ConfigureOscillator(void) {
    // Configura el Oscilador interno a 8Mhz
    OSCCONbits.IRCF = 0b111;
}


Con los mismos bits de configuración del código anterior, para cambiar la frecuencia del oscilador interno lo que debemos hacer es cambiar el valor de OSCCONbits.IRCF (Internal RC Oscillator Frequency) por uno de los siguientes:

0b000 = 31.25 kHz
0b001 = 125 kHz
0b010 = 250 kHz
0b011 = 500 kHz
0b100 = 1 MHz
0b101 = 2 MHz
0b110 = 4 MHz
0b111 = 8 MHz

El "0b" que aparece adelante de cada valor le indica al compilador que lo que le estamos pasando es un número binario. También podríamos pasarle el valor en hexadecimal pero queda más claro de esta manera. IRCF ocupa 3 bits del registro OSCCON (bits 6,5 y 4).

Por ejemplo, si al programa del Post anterior le queremos cambiar la frecuencia del oscilador interno a 4 Mhz, debemos setear en IRCF el valor 0b110 y actualizar el macro _XTAL_FREQ para que la rutina de delay funcione correctamente:

/*
 * File:   system.h
 */
#define _XTAL_FREQ       4000000     // Necesario para la rutina de Delay


/**
 * File:        system.c
 */
void ConfigureOscillator(void) {
    // Configura el Oscilador interno a 4Mhz
    OSCCONbits.IRCF = 0b110;
}

Una de las ventajas que trae el seteo del oscilador interno es que podemos disponer de 2 pines más para utilizarlos como Entrada/Salida, pero trae como desventaja que no es del todo preciso.

Utilización de un Cristal externo

Si utilizamos un cristal externo, vamos a tener mucha más precisión que si utilizásemos el oscilador interno. Aparte de esto, podemos llegar a frecuencias mayores lo que permite que nuestro pic realice muchas más acciones en la misma cantidad de tiempo.

Por ejemplo, si queremos utilizar un cristal externo de 20 MHz debemos hacer los siguientes cambios en el código:

/*
 * File:   system.h
 */
#define _XTAL_FREQ       20000000 // Necesario para la rutina de Delay
 
/**
 * File:        configuration_bits.c
 */
 
__CONFIG(MCLRE_ON & CP_OFF & CPD_OFF & LVP_OFF & BOREN_OFF &
         WDTE_OFF & FOSC_HS & PWRTE_OFF);
__CONFIG(IESO_OFF & FCMEN_OFF);

/**
 * File:        system.c
 */
void ConfigureOscillator(void) {
    // No se setea ninguna configuración
}


Ahora el circuito nos quedará de la siguiente manera:

Circuito agregando el cristal externo de 20 Mhz y 2 capacitores de 0,15pF:
Imagen 1 - Cristal externo


El valor de los capacitores va a depender del cristal como podemos leerlo en la ficha técnica del PIC16F88:

Imagen 2


Se pueden agregar capacitores de más tamaño para aumentar la estabilidad del clock con la contra de que se retrasa unos milisegundos más el inicio. En mi caso utilicé 2 capacitores de 22pF.

Hay que tener en cuenta que tanto el cristal como los capacitores deben estar lo más cerca posible del PIC para evitar interferencias.

Cómo queda el circuito en mi protoboard:

Imagen 3

Imagen 4

Hasta la próxima!
Saludos.

Related Posts Plugin for WordPress, Blogger...