Programación PIC en C

Este tutorial te guiará paso a paso en el aprendizaje de la programación en lenguaje C utilizando el compilador PCW de CCS. A lo largo del curso, aprenderás los fundamentos del lenguaje C, cómo utilizar las funciones y librerías del compilador PCW, y cómo programar microcontroladores PIC para realizar diferentes tareas y proyectos.

Biblioman

2/19/200965 min read

Curso para aprender a programar en lenguaje C utilizando un compilador para PIC, en concreto el PCW compiler de la casa CCS. Cursos sobre C en Internet a miles, pero todos los que yo he visto están realizados sobre compiladores de propósito general, como Vicual C++ de Microsoft ó Builder C++ de Borlan, sin duda son excelentes compiladores que nos permiten realizar aplicaciones para ordenadores de escritorio tanto en C como en C++ (la versión orientada a objetos de C), pero no sirven para programar PIC, es decir con el ejecutable que generan al compilar no se puede programar un Microcontrolador.

Lo habitual hasta ahora es que los usuarios que se inician en este apasionante mundo de la programación de Microcontroladores, sea de la marca que sea, primero lo hacían utilizando el lenguaje ensamblador, especifico no solo ya para cada marca de microcontrolador sino para cada modelo, ya que hay que conocer perfectamente los recursos de cada Microcontrolador (Número de puertos de Entrada/Salida Relojes internos, etc. ). Al principio de los tiempos de estos dispositivos esto era obligatorio ya que los recursos de memoria y velocidad de procesamiento no eran muy grandes y había que optimizar el código al máximo, esto implicaba que había que utilizar a la fuerza un lenguaje de programación de bajo nivel que bien utilizado explotara los recursos de estos dispositivos sin desperdiciar memoria y velocidad de procesamiento, pero al igual que ha ocurrido con los ordenadores personales las prestaciones de estos dispositivos ha ido creciendo exponencialmente con el tiempo, siendo ya perfectamente factible el utilizar un lenguaje de alto nivel para programar estos dispositivos y aprovecharnos de las ventajas de portabilidad que ofrecen este tipo de lenguajes, de esta manera por ejemplo podemos hacer un programa para un PIC en concreto y utilizarlo en otro de mayores prestaciones sin modificar apenas nada del código fuente.

¿Quien puede sacar provecho de este curso?. Este curso es para ti si:

  • Has programado PIC en Ensamblador y quieres hacerlo en un lenguaje de alto nivel como el C.

  • No has programado nunca Microcontroladores pero conoces el lenguaje de programación C de haberlo utilizado para otros propósitos.

  • No has programado nunca un PIC en Ensamblador, ni conoces ningún lenguaje de alto nivel como el C. Es decir, no tienes ni idea de Microcontroladores ni de programación (Esto es posible porque el curso va ha empezar desde cero es decir con el clásico Hola Mundo con el que empiezan todos los libros de iniciación a la programación.

Bueno alguno pensará que para aprender a programar en C vale cualquier compilador de uso general y lo que realmente interesa es saber las instrucciones de C que tengo que utilizar para configurar por ejemplo un puerto como entrada o salida, o que código tengo que utilizar para utilizar los convertidores A/D que incorporan ya casi todos los PIC, indudablemente ese es el propósito final de este curso y para ello paralelamente a él va haber otro donde se van a ver aplicaciones prácticas. Pero hay que tener en cuenta que los compiladores para Microcontroladores son específicos para estos dispositivos embebidos y no cumplen con el Estándar ANSI C al 100 %, por lo que cuando estés programando lo más seguro es que te vayas dando cuenta que una función que en el C estándar funciona perfectamente aquí te da un error al compilar. Además te irás quedando con mucho código que lo has probado y sabes que te funciona perfectamente, cuando tengas que hacer una aplicación práctica no tendrás la duda si puedes usar una determinada estructura en tu programa ó si es posible utilizar punteros o no y como hacerlo, porque ya lo sabrás a la vez que has ido aprendiendo el lenguaje de programación y no solo eso, te irás familiarizando con las instrucciones específicas del compilador: de que herramientas dispone, sus funciones precompiladas, su sistema de depuración de errores, etc.

¿Que herramientas voy a necesitar para realizar el curso?.

El compilador CCS seguro, vaya es de pago ya empezamos con problemas te puedes bajar una versión de Evaluación por 30 días desde aquí:

http://www.ccsinfo.com/ccsfreedemo.php

Después de rellenar el formulario te descargas el programa de instalación y lo instalas en tu ordenador como un programa más de Windows, aunque tienes que tener en cuenta que solo podrás programar un pequeño conjunto de PIC de cada familia, otro inconveniente es que tienes que estar conectado a Internet para que te funcione si no te aparecerá esta ventanita poco amigable:

Otra limitación es que el tamaño del programa no puede superar los 2K de memoria, aunque para los ejemplos que vamos a hacer aquí te sobra. Bien ya tenemos solucionado el tema del compilador, bien sea por que con la demo nos apañamos o porque tengo un amigo cojonudo que me va ha prestar uno con licencia para que pueda realizar el curso (je,je..).

Bien ya tengo el compilador y puedo empezar a programar y a crear mis .HEX (para el que no lo sepa es el archivo que tenemos que cargar en nuestro PIC para que funcione). Todo esto es muy elemental para el que lo sabe, pero como dije al principio este curso está pensado también para el que no tiene ni idea de programar microcontroladores. Así es que sigamos.

Una vez que tenemos nuestro .HEX tendremos que comprobar que funciona realmente para ello tenemos dos opciones:

  • Montar nuestro circuito con todos sus componentes, programar el PIC con un programador comercial como el PICSTART de Microchip o con uno de los muchos que hay en Internet que sirven perfectamente para empezar a programar estos dispositivos.

  • Utilizar un programa de simulación electrónica como Proteus que tiene la ventaja de disponer de una extensa biblioteca de microcontroladores PIC junto con los componentes auxiliares que normalmente utilizan estos dispositivos: leds, pantallas LCD, teclados, memorias, etc.

Bien nosotros utilizaremos la segunda opción, aunque en una práctica veremos como hacerlo de la primera forma.

La versión de evaluación de Proteus te la puedes descargar desde aquí:

http://www.labcenter.co.uk/download/prodemo_download.cfm

Claro que tiene limitaciones, sino no sería una demo, la principal es que no podemos guardar nuestros

trabajos y la segunda es que no lleva incorporado muchas de las librerías dinámicas necesarias

para realizar la simulación de algunos microcontrloladores. Mira a ver si el amigo que te dejo el compilador te puede dejar también una licencia para este magnífico Simulador.

Nota: en este sitio está prohibido el mostrar ó facilitar enlaces a lugares de descarga de dudosa reputación. Lo digo tambien para que se tenga en cuenta en el foro que próximamente estará a vuestra disposición y donde podremos exponer nuestras dudas ó experiencias sobre este tema y sobre otros que irán saliendo.

Otra cosa que quiero aclarar es que el curso va a ser todo lo práctico que pueda y la forma de proceder será

la siguiente: iré mostrando uno ó varios ejemplos de cada tema y posteriormente haré una Explicación de los mismos. Yo no se vosotros pero yo cada vez que he querido aprender algo nuevo lo primero que he hecho a sido mirar los ejemplos, después vosotros tendréis que comprobar que lo que he dicho es cierto y que el ejemplo compila y funciona sin errores.

Para facilitar la navegación el próximo día presentaré el índice de los temás que va a tratar el curso

Aunque puede que lo vaya modificando según vallamos avanzando.

Vamos a crear nuestro primer ejemplo paso a paso: abrimos el IDE de nuestro compilador y seleccionamos New->Source File según se muestra en la figura de abajo:

Nos saldrá un cuadro de dialogo de guardar de Windows, donde le pondremos un nombre a nuestro archivo y lo guardaremos

Después escribimos el código fuente que se muestra en la figura de abajo y guardamos el documento:

Comentario del programa:

En primer lugar nos encontramos con tres directivas del prepocesador, las identificaremos porque empiezan por el símbolo (#):

  • La primera de ellas es una directiva include su función es introducir un documento dentro de otro. En la posición del programa donde se encuentra esta directiva, se incluirá el archivo indicado. Se suele usar para incluir los archivos de cabecera (generalmente con extensión.h). En este caso concreto se incluye el archivo <16F877A.h>,en este archivo se incluyen las definiciones de los registros del PIC.

  • #use delay (clock=4000000); directiva para el uso de retardos, entre paréntesis tenemos que poner la frecuencia de reloj que vamos a utilizar.

  • #use rs232 (baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8) esta directiva es para la comunicación del PIC con otro dispositivo vía RS232, por ejemplo un ordenador, en ella se encuentran definidas los prototipos de las funciones de entrada y salida como printf().

En segundo y último lugar se encuentra la función main. Este es el núcleo del programa, el que va ha incluir todos los pasos a seguir durante su ejecución. En nuestro primer ejemplo solo contiene una sentencia que hace una llamada a la función printf(), esta función se encarga de mostrar un mensaje por el dispositivo de salida RS-232.

El mensaje que muestra la función printf es el que recibe como parámetro (el texto entre paréntesis). Dicho mensaje es delimitado por las comillas dobles, que indican el principio y el fin de una cadena de texto.

Bien una vez creado el archivo .c de nuestro programa tenemos que crear un proyecto y asociarle el archivo que acabamos de crear, tenemos dos opciones crearlo manualmente ó utilizar el wizard que tiene el IDE, en este primer ejemplo utilizaremos la opción manual.

Después seleccionamos New ->Project Manual

Y añadimos el Ejemplo1.c que hemos creado a nuestro proyecto:

Seleccionamos la pestaña Compile y pulsamos sobre Build All para construir todo.

Vemos que el archivo de salida no nos ha producido ningún error. Por tanto el proyecto se ha generado correctamente.

Y si vamos a la carpeta donde habíamos guardado nuestro primer ejemplo, tenemos todos los archivos que nos ha creado el IDE:

De todos estos archivos los que mas nos interesa son los que están marcados en la figura de arriba. El archivo Ejemplo1.hex es el que tenemos que utilizar para programar el PIC y el que termina con extensión .cof lo utilizaremos para cargarlo en el simulador Proteus y poder simular el programa paso a paso, entre otras posibilidades muy útiles a la hora de depurar nuestro código.

Bien ya tenemos nuestro primer ejemplo generado y listo para cargarlo en nuestro simulador Proteus. Vamos a ello: Arrancamos nuestro simulador Proteus y pasamos a colocar nuestros dispositivos en el área de trabajo. Empezaremos colocando el PIC, para ello hacemos clic en el botón que pone Pick Devices según se muestra en la figura de abajo:

En la ventana que nos aparece en el campo Keywords escribimos el nombre de nuestro PIC.

Una vez seleccionado hacemos doble clic sobre el para incorporarlo a nuestro proyecto.

Bien, vamos por el segundo y último elemento que necesitamos para simular nuestro programa. Hay que tener en cuenta que el simulador es capaz de hacer funcionar nuestro circuito sin algunos elementos que serían necesarios si decidimos montar nuestro circuito en una placa real (por ejemplo la alimentación del PIC y el cristal de cuarzo).

El segundo elemento que necesitamos es un Terminal Virtual que hará las veces de monitor, para poder ver las salidas en formato texto de nuestro PIC como si se tratará del símbolo del sistema en un ordenador de escritorio con el Windows instalado. En la figura de abajo se muestra donde podemos incorporar dicho instrumento.

Con esto ya tendremos los dos elementos necesarios para simular nuestros programas, recordemos que en este curso se va a ver las generalidades del lenguaje C aplicadas a este compilador, en el caso de las aplicaciones prácticas que empezaremos pronto en otro articulo tendremos que hacer un circuito independiente para cada ejemplo ya que cada uno de ellos incorporará elementos diferentes como: diodos Led, motores, teclados, displays, etc.

La interconexión de los dos dispositivos es muy sencilla según se muestra en la figura de abajo, solo hay que hacer clic con el puntero del ratón en forma de lápiz entre los terminales que queremos conexionar:

El pin del PIC que habíamos elegido como transmisión de datos en nuestro programa irá conectado al terminal RXD de recepción de datos en el Terminal Virtual y viceversa.

Bien ahora tenemos que cargar nuestro programa en el PIC para poder simularlo, para ello hacemos doble clic sobre el PIC y nos aparecerá la ventana de la figura de abajo:

Los valores que en un principio tenemos que introducir para que nuestra simulación funcione son los que están señalados en la figura de arriba. En Program File pincharemos sobre la carpeta y seleccionaremos el archivo con extensión .cof que se había creado al compilar nuestro programa, si en vez de este seleccionamos el que tiene extensión .Hex funcionará igual pero no podremos realizar la simulación paso a paso. El otro valor a tener en cuenta es que la frecuencia del reloj del PIC debe coincidir con el valor que le habíamos puesto en el programa en nuestro caso 4 MHz.
Una vez hecho esto guardamos nuestro proyecto.

Si ahora hacemos clic sobre el botón Play se nos abrirá una terminal al estilo MSDos donde nos mostrará la salida de nuestro programa:

Ahora si le damos al botón de simulación paso a paso podremos simular nuestro ejemplo paso a paso.

Si en vez de ello nos sale una ventana mostrando dos advertencias de que no se puede encontrar el código fuente de nuestro ejemplo, como se muestra en la figura de abajo.

Seguiremos los siguientes pasos:

En el menú seleccionamos Source y hacemos clic sobre Define Code Generation Tools

Nos aparecerá la ventana de abajo en la que pulsaremos sobre el botón New

Buscamos en nuestro directorio donde se ha instalado el compilador y seleccionamos CCsc.exe tal y como se muestra en la figura de abajo:

Después en el combo Tool seleccionamos el compilador y configuramos el resto de parámetros tal y como se muestra en la figura de abajo y pulsamos OK:

Ahora nos queda añadir nuestro código fuente para ello vamos al menú seleccionamos Source Add/Remove Source files…

Y añadimos nuestro código fuente ejemplo1.c
Si ahora volvemos a simular nuestro ejemplo paso a paso nos aparecerá la ventana siguiente:

Donde podemos ver la ejecución del programa línea a línea o poner puntos de interrupción en las partes del programa que nosotros queramos. Saber que existe un plugin que permite integrar un visor de proteus en el famoso simulador MPLAB. Incluiré un video en la sección de descargas donde explica como hacerlo, aunque nosotros seguiremos utilizando este método.

Bien a partir de ahora ya podemos empezar a estudiar el lenguaje de programación C en este compilador como si fuera un compilador cualquiera como Microsoft Visual C++ pero comprobando las particularidades de este compilador. Todos los ejemplos van a seguir el mismo procedimiento por lo que solo pondré el código y la explicación del mismo.

Variables

¿Qué son las variables? pues sencillamente el poder identificar con un nombre una o varias posiciones de memoria de la RAM de nuestro PIC y de esta manera el poder almacenar allí los datos que va a utilizar nuestro programa.
En C para poder utilizar una variable primeramente hay que declararla siguiendo la siguiente sintaxis:

tipo nombre_variable [=valor];

Lo que va entre corchetes es porque es opcional es decir, las variables se pueden inicializar ó no al declararlas.
Ejemplo de variable declarada:

int i;

Ejemplo de variable declarada e inicializada:


int i=5;

En una misma línea se puede declarar más de una variable siguiendo el siguiente formato:


tipo nombre_variable1,nombre_variable2,....;

Hay que tener en cuenta que la línea tiene que acabar en punto y coma.
El tipo de datos es obligatorio ponerlo y le dice al compilador cuantas celdillas de memoria tiene que reservar para almacenar el valor de la variable. Los tipos de datos pueden variar de un compilador a otro, vamos a ver los tipos de datos que podemos usar con nuestro compilador CCS.


Los tipos de datos básicos que utiliza nuestro compilador son los siguientes:

Sin embargo el compilador CCS también admite los siguientes tipos de datos definidos en el estándar C y que son los que normalmente se utilizan a la hora de programar:

Todos los tipos excepto float son por defecto sin signo, aunque pueden llevar el especificador unsigned ó signed y su rango de valores será el que corresponda a su tipo básico.

Estos son los tipos básicos, también están los tipos de datos compuestos como Enumeraciones, Estructuras y Uniones que están formados por una combinación de los básicos y que los veremos más adelante.


El nombre de la variable no puede ser una palabra clave (reservada por el compilador para realizar unas funciones determinadas y los caracteres que podemos utilizar son las letras: a-z y A-Z ( ¡ojo! la ñ o Ñ no está permitida), los números: 0-9 y el símbolo de subrayado _. Además hay que tener en cuenta que el primer carácter no puede ser un número.

¿Dónde se declaran las variables?

Las variables según el lugar en que las declaremos pueden ser de dos tipos: globales o locales.

  • La variables globales se declaran fuera de las funciones y pueden ser utilizadas en cualquier parte del programa y se destruyen al finalizar éste.

  • Las variables locales se declaran en la función en que van a ser utilizadas. Sólo existen dentro de la función en que se declara y se destruye al finalizar dicha función. Si una función va a usar argumentos (DATOS), entonces debe declarar las variables que van a aceptar los valores de esos argumentos. Estas variables son los parámetros formales de la función. Se comportan como cualquier otra variable local de la función, creándose al entrar en la función y destruyéndose al salir. Cuando veamos el tema de las funciones veremos ejemplos de estas variables.

Bueno ya está bien de teoría vamos hacer un ejemplo donde vamos a declarar y a usar varios tipos de variables:

Este programa generará la siguiente salida:

Comentario del programa:

  • El compilador utiliza 8 bits para representar los números enteros sin signo con lo cual podemos representar desde el 0 hasta el 255 que corresponde en binario al número: 11111111. Por lo que al asignarle a la variable el valor 256 el compilador no generará un error pero el dato guardado será erróneo, nos mostrará 0 que es el siguiente valor a 255 en binario.

  • Para los números enteros con signo también se utilizan 8 bits pero el último bit se reserva para el signo, con lo que se podrán representar los números desde: -127 al 127.

  • El tipo short se utilizará para las variables de un bit y tendrán como valor 0 ó 1.

  • Para los números tipo long int se reservan 16 bits sin signo con lo que su rango va de 0 a 65535

  • Para el tipo signed long se reservan también 16 bits pero se utiliza uno para el signo, por lo que se tiene un rango que va desde -32767 a 32767.

  • El tipo float define un número de 32 bits en punto flotante. y con el podremos representar los números reales.

  • El tipo char se utiliza para almacenar los caracteres, utiliza 8 bits sin signo suficientes para representar los 256 caracteres del código ASCII.

  • Los símbolos %D, %lu, %ld, %c le indica a la función printf en que formato tiene que representar el número. En la ayuda del compilador vienen los diferentes especificadores que hay para los diferentes tipos de datos. A lo largo de los siguientes ejemplos se irán mostrando algunos más.

CONSIDERACIONES: Hay que intentar siempre utilizar el tipo de dato que menos memoria ocupe dentro de los valores que pueda utilizar la variable. Si abusamos de los tipos grandes para almacenar valores pequeños nos quedaremos sin memoria y en los programas grandes es un dato que tenemos que tener en cuenta.

Nota: en los ejemplos que tengan poco código fuente como este y para que el formato de texto salga con los mismos colores que utiliza el compilador utilizaré imágenes para mostrar el código y en la sección de descargas iré incluyendo los ejemplos del curso para que todo el que no quiera teclearlos a mano se los pueda descargar. Otra cosa no incluiré el circuito en Proteus ya que es el mismo para todos los ejemplos a excepción de que en algunos ejemplos pueda ir cambiando el tipo de PIC.

Constantes

Antes de empezar con el tema de las constantes voy a comentar valga la redundancia la forma de poner comentarios a nuestros programas.

Hay dos formas de poner comentarios en C:

  • Poniendo doble barra (la que hay encima del 7), esta forma es práctica para comentar una línea.

Ejemplo:


//Este texto es un comentario.
//y este otro también.

  • la otra forma es meter el texto a comentar dentro de estos símbolos /* mi comentario*/. La ventaja de este sistema es que podemos comentar bloques de textos enteros.

Ejemplo:

/*Mi comentario empieza aquí.....
mas comentarios ..
y termina aquí */

El comentar nuestro código es una buena costumbre que no debemos pasar por alto, ya que si pasado un tiempo queremos volver a un programa y modificar alguna parte de él ayuda mucho el que su código esté comentado. Otra forma en la que se utilizan los comentarios es a la hora de depurar código, en vez de estar borrando y escribiendo trozos de código que no funcionan correctamente los comentamos, de está forma el compilador no los tratará como código fuente y podremos realizar ajustes y pruebas de una manera más fácil. Muchas veces también vemos que revisando código que han hecho otras personas hay partes del código que están comentadas esto es para hacerlo mas funcional, es decir, por poner un ejemplo, si utilizas el PIC 16F877 des comenta esta parte y si utilizas otro PIC lo dejas comentado, de esta manera comentando o descomentando unas cuantas líneas podemos utilizar el programa en varias situaciones.

Bueno, todo esto para el que tenga una idea de programación seguro que ya lo sabe, pero como dije al principio voy ha intentar que este curso le sirva también al que no tenga ni idea de programación aunque, en este caso, hay que decir también si se es honesto, que aprender un lenguaje de programación al igual que aprender un idioma nuevo supone un esfuerzo considerable y no vasta con leerse un libro de C y decir ¡ya soy un programador de C!, bajo mi modesta opinión lo que hay que hacer es practicar mucho, es decir teclear mucho código compilarlo y comprobar que funciona como nosotros queremos que lo haga, al principio cometeremos muchos errores pero el descubrir cual es la causa del error nos servirá para aprender mas todavía y sobre todo no desanimarse a la primera de cambio cuando algo no funcione. La constancia y la perseverancia son las claves del éxito para conseguir cualquier objetivo, no solo el aprender a programar PIC en C. Y ya está bien porque menudo rollo estoy soltando, así que vamos a empezar con lo que era el tema de este capitulo: las constantes.

Las constantes se refieren a valores fijos que no se pueden alterar por medio del programa.
Pueden definirse constantes de cualquiera de los tipos de datos simples que hemos visto.
Se declaran colocando el modificador const delante del tipo de datos.


Ejemplo:

const int MINIMO=10,INTERVALO=15;

Esto definirá dos constantes MINIMO con el valor de 10 e INTERVALO con el valor de 15.

Otra forma de definir constantes es usando la directiva de compilación #define.


Ejem.

#define MAXIMO 30

Esta orden se ejecuta de la siguiente forma: en la fase de compilación al ejecutar #define el compilador sustituye cada operación de la primera cadena de caracteres por la segunda, MAXIMO por el valor 30 además, no se permite asignar ningún valor a esa constante.
Es decir si pusiéramos:

#define MAXIMO = 30

Al compilar tendríamos un error.

Nota: La declaración #define no acaba en ";"

También podemos tener en nuestro programa Constantes de cadena: una cadena de texto es una secuencia de caracteres encerrados entre dobles comillas. Se usa para funciones de entrada y salida estándar, como función de entrada y salida de texto estamos utilizando la función printf que esta definida dentro de-> #use rs232, pero ya veremos que el compilador CCS proporciona un número considerable de funciones listas para usarse y que nos sirven para comunicarnos con el dispositivo de entrada y salida RS-232.

Hemos dicho que podemos definir constantes prácticamente de cualquier tipo de dato, pero CCS nos permite también representar esas constantes en diferentes sistemas de numeración como hexadecimal, binario, octal, decimal y además definir también constantes de caracteres especiales que el compilador utilizará para realizar acciones concretas. De los sistemas de numeración permitidos los que más se usan son los siguientes:


Decimal

Ejemplo: 222

Hexadecimal empiezan por 0x

Ejemplo: 0x2A

Binario empiezan por 0b

Ejemplo:

0b00001011


Este último formato es muy útil, por ejemplo el PIC dispone de unos registros que sirven para configurar los puertos del PIC como entradas de datos o salida de datos, por defecto vienen configurados como entradas y si quiero utilizar algún pin como salida porque quiero utilizarlo para encender un LED o lo que sea, tengo que poner a cero dicho registro. En el formato binario se ve fácilmente que valores se le va asignar al registro, teniendo en cuenta que los registros empiezan por 0.

Como siempre vamos hacer un ejemplo para ver si nuestro compilador se traga todo lo que he dicho:

Bien si todo va bien obtendremos la siguiente salida:

Comentario: Como dije en la introducción de este curso la finalidad es aprender a programar PIC en lenguaje C eso conlleva saber el lenguaje C, que seguiremos viendo en esta parte del curso, pero también el saber utilizar los recursos y funcionalidades que nos ofrecen los PIC como por ejemplo saber programar sus contadores, como enviar datos a un LCD, el utilizar los conversores A/D, etc. Para ello voy a iniciar próximamente un segundo artículo donde empezaremos a estudiar ejemplos prácticos de los PIC.

En la última práctica que hemos visto (el uso del TMR0 como contador) vimos que el entorno de Proteus nos proporciona una ventana de visualización del estado de los registro SFR de nuestro PIC , muy útil cuando estamos depurando nuestro programa, pero Proteus nos proporciona más ventanas para ver el estado de los registros de nuestro PIC que podemos acceder a ellas por medio del menú Debug --> PIC-CPU cuando estamos ejecutando nuestro programa en el modo de simulación paso a paso o cuando hemos pulsado el botón de pausa, una vista condensada de todas esas ventanas la tenemos en la figura de abajo:

Como vemos aparte de poder ver el estado de los registros SFR del PIC podemos ver el estado de la memoria EPROM del PIC, El contenido de la memoria de programa (donde se encuentra grabado de forma permanente nuestro programa ), el estado de PILA (útil cuando se trabaja con interrupciones y funciones), otra ventana nos muestra el estado de la memoria RAM reservada a los datos ó registros de propósito general (GPR) en formato hexadecimal y otra donde podemos ver el estado de las variables que tenemos activas en ese momento, recordar que si utilizamos variables locales por ejemplo dentro de una función, estás se destruirán al salir de la función. Pero todo esto como he dicho lo tenemos cuando estamos ejecutando nuestro programa en el modo paso a paso ó tenemos nuestro programa en pausa.

Si estamos en modo Run e intentamos acceder a estas ventanas vemos que están deshabilitadas:

¿Qué otro sistema tenemos para depurar nuestros programas? Pues bien una manera que siempre podemos utilizar es utilizar la función printf como herramienta de depuración, es decir, ponemos la función printf en determinadas partes del programa donde queramos saber el estado de una o varias variables y por medio de la terminal podemos saber el valor que van tomando, una vez comprobado que nuestro programa funciona como nosotros queremos borramos las funciones printf que hayamos introducido con propósitos de depuración.

Pero Proteus nos proporciona otro método para ver el estado de las variables cuando estamos ejecutando nuestro programa ya sea en modo Run ó en modo paso, es la ventana Watch Window y podemos acceder a ella por medio del menú Debug --> Watch Windows.

Vamos a ver cómo podemos utilizarla. Para ello compilaremos el siguiente ejemplo:

Es un programa que lo único que hace es incrementar la variable X de 0 a 10 y después hace lo mismo con la variable Y, pero es suficiente para ver cómo utilizar la ventana Watch Windows para ver el valor que van tomando las variables X e Y.

Primeramente compilamos el ejemplo y después dentro del IDE del compilador hacemos clic en el icono Symbol Map según se muestra en la figura de abajo:

Esto hará que nos aparezca el archivo Symbol Map en modo lectura, en este archivo podemos ver en qué posición de memoria se guardarán las diferentes variables que tengamos declaradas en nuestro programa, este archivo se actualizará en cada compilación que hagamos.

Como vemos en la figura de arriba las variable X e Y tienen asignadas las direcciones de memoria 0x011 y 0x012 en la memoria RAM de propósito general (GPR), que como ya sabemos es la que el programador dispone para almacenar los valores de sus variables.

Bien, una vez anotadas estas direcciones volvemos al entorno de Proteus y abrimos la ventana Watch Windows, dentro de ella hacemos clic con el botón derecho del ratón y seleccionamos Add Items (By Address)… , según se muestra en la figura de abajo:

Nos aparecerá una nueva ventana donde iremos añadiendo las variables con su dirección correspondiente:

Una vez añadidas las variables podemos ver el valor que van tomando mientras ejecutamos nuestro programa en la ventana Watch Windows, según se muestra en la figura de abajo:

Pero tenemos aún mas opcciones, por ejemplo podemos establecer condiciones para ello hacemos clic en la variable con el botón derecho y seleccionamos Watchpoint Condition…

Nos aparecerá la ventana que se muestra abajo:

Por ejemplo yo la he configurado para que cuando la variable X sea igual a cinco se pare la simulación, pero admite más condiciones solo hay que ponerse y experimentar con las diferentes opciones que tenemos, también decir que podemos hacer que la ventana Watch Windows nos muestre los registros SFR que nos interesan junto con las variables que nosotros hemos declarado, en fin muchas posibilidades de depuración. El conocer estas herramientas nos puede facilitar mucho el aprendizaje porque vemos la secuencia real que sigue nuestro programa, que algunas veces puede que no coincida con nuestra lógica de funcionamiento del programa.

Función printf()

Aunque no hemos visto el tema de las funciones todavía, pero ya que estamos utilizando esta función muy a menudo, vamos a ver alguna de las posibilidades que nos ofrece. El que tenga conocimientos del lenguaje C sabrá que para utilizar esta función que pertenece al estándar ANSI de C hay que incluir previamente el archivo de cabecera #include <stdio.h>, pero esto con el compilador PCW de CCS no funciona, en este compilador esta función está definida en la directiva:

#use RS232(BAUD=9600,BITS=8,PARITY=N,XMIT=PIN_B1,RCV=PIN_B2)

Esto quiere decir que cada vez que queramos utilizar la función printf tenemos que haber incluido previamente esta directiva, que posibilita la comunicación del PIC con otro dispositivo utilizando el protocolo de comunicación serie RS232, además de la función printf esta directiva permite el uso de otras funciones para la entrada y salida de datos serie como: getc, getchar, gets, puts y kbhit que iremos viendo poco a poco, pero la más importante para la salida de datos sin duda es printf, porque nos permite formatear la salida de esos datos de la forma que nosotros queramos.

Como vemos la directiva #use RS232 admite una serie de parámetros que son los que van entre paréntesis separados por comas, estos son los siguientes:

  • BAUD con este parámetro establecemos la velocidad en baudios a la que queremos que se transmitan los datos por el puerto serie, 9600 es lo normal.

  • BITS número de bits que utilizaremos en la transmisión, el estándar establece que pueden ser 8 ó 9, para la comunicación con microcontroladores con 8 son suficientes.

  • PARITY nos permite utilizar un bit de paridad para la comprobación de errores, está opción la dejamos a No.

  • XMIT está opción nos configura porque patilla del PIC saldrán los datos, está opción junto con la siguiente sí que la tendremos que cambiar a nuestras necesidades.

  • RCV nos configura porque patilla del PIC se recibirán los datos. En el ejemplo, los datos se transmiten por el PIN RB1 y se reciben por RB2.

La forma de hacer la llamada a la función printf es la siguiente:

printf(Nombre Función, Cadena de caracteres , valores);

Como vemos la función printf también admite parámetros que podremos utilizar para formatear el texto de salida. Vamos a ver cuáles son:

El primero es opcional y es el nombre de una función, si no lo ponemos los datos se transmitirán vía RS232 a través de los pines que hayamos configurado en la directiva #use RS232.

El segundo parámetro es una cadena de caracteres encerrada entre comillas dobles.

Y el tercero son datos o nombres de variables cuyo valor queremos que se muestren. Vamos a ver todo esto con ejemplos que es como mejor se ven las cosas:

1º Ejemplo:

Comentario:

En este primer ejemplo vamos a ver el uso de la función printf utilizando diferentes parámetros. Como vamos a utilizar la librería que incluye el compilador para el manejo de un LCD tenemos que incluir la directiva:

#include <LCD.C>

Declaramos una variable i1 de tipo entero que nos va a servir para mostrar su valor en la terminal y en un LCD.

Cuando utilicemos la librería LCD.C y antes de utilizar cualquier otra función incluida en la librería tenemos que llamar a la siguiente función que sirve para inicializar el LCD.

lcd_init();

En la primera llamada a la función printf como parámetros solo incluimos una cadena de caracteres constante que termina en (\r), esa barra invertida junto con la r se le llama secuencia de escape y le está diciendo al compilador que al final de la cadena introduzca un retorno de carro (tecla enter). Las secuencias de escape se utilizan para representar caracteres o acciones especiales.

printf("Esto es una cadena\r");

En la tabla de abajo se muestran las secuencias de escape que tenemos disponibles para utilizar con la función printf:

Vamos con la segunda llamada a la función:

printf("El valor de la variable i1 es: %d",i1);

En este caso tampoco está definido el primer parámetro, por tanto, al igual que en la primera llamada a la función, los datos se enviaran por el puerto serie al pin que hayamos definido en la directiva #use RS232, en esta llamada vemos que tenemos la cadena de caracteres limitada por las comillas dobles y separado por una coma, como tercer parámetro el nombre de la variable i1 que habíamos declarado previamente. En la cadena de caracteres vemos que aparece el carácter de % seguido de la letra d, ese es un carácter especial para la función y lo que le indica a la función es que en esa posición muestre el valor de la variable i1, la d le indica a la función que represente ese valor en formato de número entero. Podemos representar el valor de la variable en diferentes formatos según se muestra en la tabla de abajo:

Si quisiésemos mostrar el valor de más de una variable lo haríamos de la siguiente forma:

printf("El valor i1 es: %d el de i2: %d y el de i3: %d",i1,i2,i3);

Vamos con la última llamada a la función del 1º ejemplo:

printf (lcd_putc,"El valor de i1 es: %d",i1);

En esta llamada hemos incluido el primer parámetro y hemos puesto el nombre de la función lcd_putc, está función está definida en la librería LCD.C que trae el compilador para ayuda del manejo de los dispositivos LCD y que hemos incluido en nuestro programa por medio de la directiva #include <lcd.c>, vemos que la librería está encerrada entre los símbolos de <> esto le indica al compilador que busque la librería en el directorio en que se instalo el compilador, si copiáramos esa librería en otro directorio tendríamos que indicarle la ruta completa, pero esta vez encerrada entre comillas dobles.

Ejemplo:

#include “C:\Ejemplos de C\lcd.c”

Pues bien ahora la función printf no enviará los datos al puerto serie, sino a la función lcd_puct que será la encargada de enviárselos al LCD, esta función por defecto envía los datos al puerto D del PIC, pero accediendo a la librería se puede modificar el puerto fácilmente.

Aquí tenéis un video demostrativo del ejemplo:

2º Ejemplo:

Comentario del programa:

  • El especificador de formato %x indica al sistema que escriba en hexadecimal (base 16) el valor sustituido.

  • El ejemplo también escribe el carácter 'A', apoyándose en cuatro formas distintas de representaciones iníciales. En todos los casos se almacenará el mismo valor numérico, pero son diferentes las representaciones usadas.

  • El carácter (A) sale en la terminal en una línea diferente cada vez que se imprime, eso es debido a la secuencia de escape (\r) utilizada.

  • Observar que el ejemplo se ha hecho sobre el PIC 16f84 que no dispone de una USART hardware para la comunicación serie , pero sin embargo el programa se ha ejecutado correctamente, eso es debido a que la comunicación serie se ha establecido por software por medio de las librerías implementadas en el compilador PCW.

Salida del programa:

Vamos a continuar con las funciones disponibles en CCS para la entrada y salida de datos a través del puerto serie RS-232. Hasta ahora solo hemos visto que con la función printf(), podemos enviar datos formateados a través del pin que hayamos seleccionado en la directiva:

#use RS232(BAUD=9600,BITS=8,PARITY=N,XMIT=PIN_D1,RCV=PIN_D2)

En este caso los datos saldrán por el pin RD1 del PIC. Pero ¿de que funciones disponemos para recibir datos desde fuera hacia nuestro PIC?. El que haya programado en C echará de menos la función scanf() definida en la librería stdio.h y perteneciente al estándar ANSI C. Pero desgraciadamente esa función tampoco está disponible en CCS. Pero tampoco hay por qué preocuparse mucho, porque disponemos de otras. En este caso vamos a ver las funciones: getc(), getch() y getchar(). Las tres hacen lo mismo por lo que podemos usarlas indistintamente.


Estas funciones esperan un carácter por la patilla del PIC que hayamos definido en la directiva #use RS232 con el parámetro RCV. En el caso del ejemplo de arriba, los datos serán recibidos por el pin RD2 del PIC.


Pues vamos a ver nuestro primer ejemplo acerca del uso de estas funciones:

Comentario:

El ejemplo lo que hace es mostrar el valor de la tecla que pulsemos en el teclado y su equivalente en código ASCII


Vamos a explicar su funcionamiento paso a paso:

  • Primeramente, como siempre, incluimos por medio de la directiva #include el archivo de cabecera del PIC que vamos a utilizar, en este caso el PIC16F877.

  • Por medio de #use delay le decimos al compilador la frecuencia de reloj que vamos a utilizar en nuestro circuito.

  • Configuramos los parámetro de la directiva #use RS232, fijaros que XMIT=PIN_D0 y que RCV=PIN_D1. Con lo cual los datos saldrán del PIC por el pin RD0 y entrarán por el pin RD1.

  • Dentro de la función principal main(), escribimos lo que queremos que haga nuestro programa. Las instrucciones siempre empezarán a ejecutarse una a una a partir de esta función y de arriba hacia abajo.

  • Lo primero que hacemos es declarar una variable de tipo char donde almacenaremos el valor de la tecla que pulsemos en el teclado.

  • Después se nos mostrará un mensaje en la terminal invitándonos a que introduzcamos un carácter.

printf("Introduzca un caracter :\r");

  • Después se ejecutará la sentencia:

ch=getch()


Que esperará hasta que pulsemos una tecla y almacenará su valor en la variable ch.

  • La siguiente instrucción:

printf("El caracter %c tiene un valor ASCII decimal de %d.\r",ch,ch);


muestra el valor del carácter y su equivalente en código ASCII

  • Después se repite el proceso dos veces más, pero esta vez utilizando las funciones getc() y getchar()

Al utilizar solo la variable ch, el valor de la nueva tecla pulsada sobrescribirá el valor anterior de la variable.


La salida de nuestro programa será el siguiente:

Bien, hay que decir que el programa finalizará al llegar a la última sentencia incluida en la función main(). Para que el programa termine cuando nosotros queramos tenemos que incluir como mínimo un bucle y establecer una condición para que podamos salir de él, vamos a ver esto con otro ejemplo:

En este ejemplo se irán mostrando en la terminal las teclas que vayamos pulsando por el teclado hasta que pulsemos la tecla ‘n’ momento en el cual finalizará el programa.

Los códigos fuentes de los ejemplos los tenéis aquí.

Un par de funciones mas que se pueden utilizar en la entrada y salida de datos serie RS232 son las funciones gets() y puts().

gets(string): esta función lee los caracteres que se introducen por el teclado hasta que encuentra un retorno de carro (tecla Enter). El pin asignado para la lectura de los caracteres es el que hayamos configurado en RCV. En el ejemplo de abajo el pin RD5.

puts(string): esta función envía la cadena de texto contenida dentro de los paréntesis al pin que hayamos configurado en el parámetro XMIT de la directiva #use RS232, en el ejemplo de abajo el pin RD4. Una vez enviada la cadena añade un retorno de carro.

#use RS232(BAUD=9600, BITS=8, PARITY=N, XMIT=PIN_D4, RCV=PIN_D5)

Vamos a ver un ejemplo sencillo que utilice estas dos funciones:

Comentario

En este ejemplo se ha declarado un tipo de dato que todavía no hemos visto, un array de caracteres:

char nombre[9];

Aunque veremos los tipos de datos compuestos más adelante, podemos adel