Que lenguaje usar para programar Microcontroladores PIC Es la primera pregunta que debemos contestarnos al querer programar un microcontrolador, frente a esta pregunta eres tu el que debe decidir el lenguaje de programación, en esta entrada expongo el porque he elegido hacerlo en CCS.

ASSEMBLER

En mi opinión este es el mejor lenguaje para comenzar a programar, esto si queremos saber exactamente que estamos haciendo con el microcontrolador. Mi recomendación es comenzar con lenguaje ensamblador aprender a utilizar los puertos a configurar registros etc, todo lo básico. Y luego pasarse a un lenguaje de alto nivel como CCS o C18. Esto es opcional si quieres comenzar directamente con CCS puedes hacerlo. Ventajas - Precisión: Controla totalmente la operación del microcontrolador y permite al programador precisión en las operaciones. - Herramienta educacional: permite conocer a detalle la arquitectura interna del microcontrolador, el set de instrucciones, los registros y su funcionamiento interno. - Tamaño: los compiladores generan más código máquina del necesario; por ello, el programa ejecutable crece. Por lo tanto cuando es importante reducir el tamaño del ejecutable, optimizando el uso de la memoria y teniendo también beneficios en velocidad, puede convenir usar el lenguaje Ensamblador. Al ser un lenguaje más primitivo, el Ensamblador tiene ciertas desventajas:

- Códigos mas complejos desde el punto de vista del programador: en assembler debemos declarar correctamente todo lo que usaremos a diferencia de los lenguajes basados en C, esto hace que veamos nuestro código mas extenso y complejo. - Tiempo programando: Para aplicaciones complejas no recomendaría asembler ya que se debe invertir una cantidad de tiempo muchísimo mayor que con otros lenguajes. - Falta de potabilidad: debido a que depende de la estructura interna del microcontrolador, el código de un microcontrolador no puede correr en otro de diferente arquitectura. Ejemplo de código assembler ?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

PROCESSOR 16f886 ;seleccionamos que microcontrolador

usaremos

#INCLUDE <16f886.inc> ;carga librería del microcontrolador

ORG 0x00 ;origen de programa

bsf STATUS,RP0 ;acceso al banco 1 de la memoria

movlw b'0001111'

movwf TRISA ;configura el puertoA como entrada

clrf TRISB ;configura el puertoB como salida

bcf STATUS,RP0 ;RP0 a 0 para acceder al banco 0

inicio

movf PORTA,W ;mueve el contenido del PuertoA a W

movwf PORTB ;mueve el dato de W al puertoB

goto inicio ;salta a inicio y entra en un bucle

END ;fin del código

EL LENGUAJE C

Ventajas: - Facilidad de uso: Los programas en C son más fáciles de mantener (revisar, modificar, ampliar).

Existen muchísimas librerías libremente disponibles para el uso de cualquier programador, lo cual facilita el desarrollo de una aplicación. - Potabilidad: Generalmente un programa escrito para un tipo de microcontrolador puede correr con mínimas modificaciones en otro microcontrolador de diferente arquitectura. - Eficiencia: Es más rápido y eficiente que otros lenguajes de alto nivel usados también para programar microcontroladores y su uso está altamente difundido en aplicaciones profesionales. Con compiladores modernos puede llegar a ser tan rápido como el ensamblador dependiendo de la habilidad y los recursos del programador. Desventajas: - El código escrito en C ocupa más memoria que el escrito en ensamblador. Los programas al compilarlos pueden resultar un poco extensos y pesados por ello debe tenerse en cuenta la capacidad de memoria de programa del PIC a utilizar. - Control:Con este lenguaje no se puede controlar del todo los tiempos y los registros bit a bit.

Compilador CCS PCW HD Este es un compilador de punto flotante que puede integrarse al ambiente MPLAB IDE de Microchip. Un dato importante de este compilador, es que abstrae del hardware, y con ello sacas muy rápido tus proyectos, no tienes que conocer tan finamente al microcontrolador que programas y sus "modulos", ademas trae una cantidad de librerías y programas de ejemplos,esto acorta increíblemente los tiempos de aprendizaje y desarrollo de los proyectos. A continuación veremos algunas características que presenta el compilador PCW CCS y que hacen de él una buena opción para elegirlo como compilador de C para programar Microcontroladores PIC

1. Al compilar genera un código máquina muy compacto y eficiente. 2. Se integra perfectamente con MPLAB y otros simuladores/emuladores como

PROTEUS para el proceso de depuración. 3. Incluye una biblioteca muy completa de funciones precompiladas para el acceso al

hardware de los dispositivos (entrada/salida, temporizaciones, conversor A/D, transmisión RS-232,bus I2C….,etc.

4. Tiene numerosas librerías ya integradas al compilador para dispositivos externos, tales como pantallas LCD, teclados numéricos, memorias EEPROM, conversores A/D, relojes en tiempo real, etc.

5. Permite insertar partes de código directamente en Ensamblador, manteniendo otras partes del programa en C.

6. Primeros Pasos con CCS encender un LED 7. En la "entrada anterior" aprendimos a descargar e instalar el Compilador CCS,

ademas crear nuestro primer código fuente (vacío), en esta entrada aprenderemos un poco mas sobre como empezar a programar, para esto vamos a hacer el hola mundo de la electrónica, encender y apagar un LED. Pero primero vamos a conocer un poco mas sobre este lenguaje de programación.

8. Gestión de los puertos de Entrada y Salida:

9. Los puertos son el punto de comunicación entre el microncontrolador y el mundo

exterior , a través de ellos se pueden recibir y enviar señales al exterior para efectuar procesos de control electrónico sobre otros dispositivos. En el lenguaje CCS se pueden gestionar los puertos de 2 formas: 1.- Declarando los registros TRISX y PORTX. Se definen los registros PORTx y TRISx como bytes y se sitúan en la posición correspondiente de la memoria RAM. La directiva utilizada de C es #BYTE

10. #BYTE variable=constante; 11. ?

1 2 3 4

#BYTE TRISA = 0x85 //dirección del registro TRISA en el banco de

memoria

#BYTE PORTA = 0x05 //dirección del registro PORTA en el banco de

memoria

#BYTE TRISB = 0x86 //dirección del registro TRISb en el banco de

memoria

#BYTE PORTB = 0x06 //dirección del registro PORTB en el banco de

memoria

12. Una vez definidas estas variables se pueden configurar y controlar los puertos. 13. ?

1 2 3

TRISA = 0xFF; // todos los pines de entrada

TRISB = 0x00; // todos los pines de salida

TRISC = 0x0F; // 4 terminales de salida, 4 terminales de entrada

14. También podemos trabajar bit a bit con los registros o variables definidas previamente. 15. ?

1 2 3

bit_clear(PIN_B0) ; //Pone a 0 el bit especifico de la variable

bit_set(PIN_B0); //Pone a 1 el bit especifico de la variable

bit_test(PIN_B0); //Muestra el bit especifico de la variable

16. o podemos definir todos los bits del puerto de una vez con: 17. ?

1 PORTC = 0xFF; //define todo el puertoA a 1

18. 2.- Utilizando las directivas especificas del compilador. El Lenguaje C admite unas directivas de compilación que le dicen al compilador cómo debe tratar los TRIS del puerto, esta es la manera mas simple de hacerlo y es la que usaremos. Estas directivas son: USE FAST_IO, USE FIXED_IO, USE_STANDARD_IO Si declaramos un puerto cómo #USE FAST_IO(PUERTO) Es el usuario quien debe asegurarse de que el sentido del pin es el correcto y para ello debe colocar antes de leer o escribir en el puerto correspondiente el SET_TRIS_X(0b00000000) para indicar el uso de entrada o salida de cada bit del puerto.

Si declaramos un puerto cómo #USE FIXED_IO(PUERTO_OUTPUTS=1,3,5,7) El compilador genera e inserta en tu código los SET_TRIS_X(0b10101010) correspondientes a dicha declaración independiente del uso que tus instrucciones hagan después de dichos pines. Si has declarado con FIXED_IO de salida el pin 1 del puerto X y después lo lees el compilador no hará nada y estarás leyendo un puerto de salida. Si por último declaramos el puerto cómo #USE STANDARD_IO(PUERTO) El compilador generará automáticamente e insertará antes de cualquier operación de entrada o salida de cualquier pin del puerto X los SET_TRIS_X() correspondientes a la instrucción que le sigue. Esto hace que los TRIS siempre estén de acuerdo con la instrucción a ejecutar. Si colocamos en nuestro código un OUTPUT_HIGH(PIN_B0) y el puerto B está declarado como #USE STANDARD_IO(B) justo antes del output habrá un TRIS declarando el PIN_B0 como salida, si a continuación ponemos un INPUT_(PIN_B0) el compilador pondrá ahora un TRIS para declarar PIN_B0 como entrada. Este #USE STANDARD_IO(X) es el modo POR DEFECTO de todos los puertos en CCS si no se declara lo contrario. Gestión de los puertos a través de Directivas:

19. ?

1 2 3 4 5

output_X(valor); //Por el puerto correspondiente saca el valor

(0-255).

input_X(); //Se obtiene el valor en el puerto

correspondiente.

set_tris_X(valor); //Carga el registro TRISx con el valor (0-

255)

port_b_pullups(true); //Habilita las resistencias pul-up en el

PORTB .

get_trisX(); //Devuelve el valor del registro TRISx (x es

A,B,C,D…)

20. Las funciones para trabajar bit a bit son:

21. ?

1 2 3 4

output_low(pin*) //Pin a 0.

output_high(pin*) //Pin a 1

output_bit(pin*,valor) //Pin al valor especificado

input(pin*); //Lee el valor del pin.

22.

23. Estructuras de Control Repetitivas

24. 25. Las estructuras de control repetitivas o iterativas, también conocidas como bucles se

pueden usar cuando se quiere repetir cierta parte del código n veces, otras permiten repetir un segmento de código cuando se cumplen ciertas condiciones. Bucle WHILE Este bucle ejecuta una instrucción o un conjunto de instrucciones mientras la condición se cumpla, generalmente a la condición se le coloca el valor true, para que siempre se repita.

26. ?

1 2 3 4

while(condición)

{

segmento de código a repetir

}

27. Bucle FOR Este bucle permite ejecutar una instrucción o un bloque de instrucciones una cantidad determinada de veces. se suele reemplazar por el ciclo while cuando se conoce o se desea un cierto numero de iteraciones.

28. ?

1 2 3 4

for(int i=0;i<10;i++)

{

bloque;

}

29.

30. Configuración de los FUSES

31. La directiva FUSES establece los distintos bits de configuración del micro, los mismos que puedes seleccionar en tu software de grabación. Cada micro tiene los suyos, y los podrás encontrar en el apartado "Configuration Word" del correspondiente datasheet, En CCS puedes encontrar los fuses correspondientes al microcontrolador que estamos usando en el menú VIEW > CONFIG BITS.

32. 33.

Nos aparecerá una lista con todos los fuses de microcontrolador que seleccionamos.

34. 35.

36. De esta lista los mas importantes son: 37.

WDT (Watchdog Timer): 38. ?

1 2

#fuses WDT

#fuses NOWDT

39. El famoso "perro guardian" del pic. Esta es una capacidad del pic de autoresetearse. Es muy útil, por ejemplo si un Pic, por un descuido de programación, se queda en un bucle infinito, esta "utilidad" lo sacará de él. Su funcionamiento es sumamente sencillo. Simplemente es un registro que debemos borrar cada cierto tiempo. Si transcurrido un cierto tiempo el registro no ha sido borrado el pic se resetea. OSC (Oscilador):

40. ?

1 2

#fuses HS

#fuses XT

41. Es el modo de oscilación que va a usar el Pic, los mas usados son: XT: viene de XTAL (cristal). Este modo de funcionamiento implica que tendremos que disponer de un cristal de cuarzo externo al Pic y dos condensadores. HS: Para cuando necesitemos aplicaciones de "alta velocidad", mas de 8Mhz. Se basa también en un cristal de cuarzo, como el XT. PUT (Power Up Timer Reset):

42. ?

1 2

#fuses PUT

#fuses NOPUT

43. Si activamos este FUSE, lo que conseguimos es que se genere un retardo en la inicialización del Pic. Esto se usa para que la tensión se estabilice, por lo que se recomienda su uso. Ahora ya tenemos los conocimientos básicos necesarios para realizar nuestro primero proyecto el hola mundo de la electrónica encender y apagar un LED, vamos allá.

PROYECTO: Encender y apagar un LED, ademas agregar un retardo para que el encendido y apagado del led pueda ser visualizado correctamente.

Código:

44. ?

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <16f886.h> //definimos que microncontrolador

usaremos

#fuses nowdt //no usar el WDT (watchdog timer)

#use delay(clock=20M) //definimos un cristal de 20Mhz.

void main() //declaramos la función principal

{

while(true) //bucle infinito

{

output_high(pin_b0); //Pin B0 en alto

delay_ms(200); //retardo de 200ms

output_low(pin_b0); //Pin B0 en bajo

delay_ms(200); //retardo de 200ms

}

}

45. Esquema Proteus:

46.

47. Como Incorporar una Pantalla LCD 48. En esta entrada aprenderemos a utilizar una pantalla LCD la mas común es la 2x16

49. 50. 51. Esta es la manera de conectar la LCD generalmente usaremos 4 lineas para los datos

(D4-D7) los bits RS,RW , GND VDD y VEE pin al cual ira un potenciómetro para regular el contraste, ademas de los pines bk+ y bk- para el blackligth en las pantallas que traen

iluminación LED de fondo.

52. 53.

54. PROYECTO: Enviar un mensaje a una pantalla LCD conectada al puertoC de microcontrolador. CCS dispone de una librería para trabajar con pantallas LCD llamada lcd.h la cual llamamos con la instrucción: #include <lcd.c>

55. 56.

La abrimos como muestra la imagen y dentro encontramos los comandos necesarios para controlarla:

57. ?

1 2 3

lcd_init() Must be called before any other function.

4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

lcd_putc(c) Will display c on the next position of the LCD.

\a Set cursor position to upper

left

\f Clear display, set cursor to upper

left

\n Go to start of second

line

\b Move back one

position

lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1)

lcd_getc(x,y) Returns character at position x,y on

LCD

CONFIGURACION

Nos dice que podemos controlarla de 2 maneras utilizando

a.) acceso por puerto

con este codigo le decimos que utilizaremos un completo.

ejemplo:

#define LCD_DATA_PORT getenv("SFR:PORTC")

b.) acceso por pines

aquí podemos usar los pines de la manera que queramos.

ejemplo:

#define

LCD_ENABLE_PIN PIN_C0

#define

LCD_RS_PIN PIN_C1

#define

LCD_RW_PIN PIN_C2

#define

LCD_DATA4 PIN_C4

#define

LCD_DATA5 PIN_C5

#define

LCD_DATA6 PIN_C6

#define

LCD_DATA7 PIN_C7

58. El codigo queda como sigue:

59. ?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include &lt16F886.h&gt

#FUSES NOWDT //No Watch Dog Timer

#use delay(crystal=20000000) //reloj de 20Mhz

#define LCD_DATA_PORT getenv("SFR:PORTC") //indicamos lcd

conectada a PuertoC

#include &ltlcd.c&gt //librería LCD viene con

el compilador

void main()

{

lcd_init(); //inilicializar LCD

while(TRUE)

{

16 17 18 19 20

lcd_gotoxy(1,1); //ir a la linea 1 posicion 1

printf(lcd_putc,"LCD 16x2"); //mensaje en linea1

delay_ms(50); //retardo de 50ms

lcd_gotoxy(1,2); //ir a la linea 2 posicion 1

printf(lcd_putc,"hacermirobot"); //mensaje linea 2

delay_ms(50); //retardo de 50ms

}

}

60. Montaje en PROTEUS

61. 62. 63.

64. El conversor Análogo Digital ADC 65. Un poco de teoría:

El conversor análogo digital se utiliza para convertir señales análogas provenientes de sensores conectados a la entrada del microcontrolador en señales digitales para ser mostradas en indicadores tal como una pantalla lcd.

66. 67.

El microcontrolador PIC19F886 como la mayoría de los microcontroladores de la gama media cuenta un modulo conversor análogo digital de 8 a 10 bits selecionables por el programador. La tensión de entrada puede variar entre 0 a 5volts si utilizamos el adc en el modo de 10bits significa que tenemos 10 bits para representar digitalmente la señal analógica de entrada, como 2^10=1024, tendremos los valores de entre 0 a 1024 para representar las tensiones de 0 a 5v.

para calcular la resolución usamos la siguiente formula:

68. 69.

70. Si consideramos una tensión de entrada Vin de 5v y 10bits tendremos:

71. 72. de este modo si la el valor leído es 511 511*0.0048 nos da un voltaje de 2.49v. 73.

74.

75. Configuración del ADC

76. EN CCS para controlar el conversor ADC se debe hacer mediante las siguientes instrucciones: #device ADC= 10: Selecciona la cantidad de bits que usara el conversor (8 o 10). SETUP_ADC(mode): Esta función configura el reloj del conversor, los parámetros que acepta son:

77. ?

1 2 3 4

ADC_CLOCK_DIV_2

ADC_CLOCK_DIV_8

ADC_CLOCK_DIV_32

ADC_CLOCK_INTERNAL

78. SETUP_ADC_PORTS(value): Esta función configura cuales pines del ADC serán analógicos y cuales digitales o alguna combinación de ambos. Las constantes usadas son diferentes para cada chip. se debe revisar el archivo .h, ejemplo.

79. ?

1 2

AN0_AN1_AN3 pines RA0, RA1 y RA3 analógicos y los restantes

digitales.

ALL_ANALOG y NO_ANALOGS, estas constantes son válidas para todos los

chips.

80. SET_ADC_CHANNEL(channel: Especifica el canal a utilizar por la función READ_ADC(). El número de canal empieza en 0. Es preciso esperar un corto espacio de tiempo después de cambiar el canal de adquisición, antes de que se puedan obtener lecturas de datos válidos.Ejemplo:

81. ?

1 set_adc_channel(2);

82.

PROYECTO: Probar el funcionamiento del conversor análogo digital utilizando un potenciómetro que simula un sensor a la entrada del pin AN0 del PIC y visualizar la salida digital en un LCD. Montaje en Proteus:

83. 84.

Codigo CCS: 85. ?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#include <16F886.h>

#device adc=10 //10bits

#fuses nowdt

#use delay(clock=20000000)

#define LCD_DATA_PORT getenv("SFR:PORTC") //lcd conectado al

puerto C.

#include <lcd.c>

void main()

{

int16 q;

float p;

setup_adc_ports(sAN0); //AN0 en otros

microcontroladores.

setup_adc(adc_clock_internal); //reloj interno.

lcd_init(); //inicializar el lcd.

while(true)

{

set_adc_channel(0); //canal 0.

delay_us(20);

lcd_gotoxy(1,1);

q=read_adc();

p=(5.0*q)/1024.0;

printf(lcd_putc," ADC = %ld",q);

printf(lcd_putc,"\nVoltaje=%1.2fv",p);

}

}