TEORÍA Y PRAXIS DE
 LAS COMUNICACIONES TTL

   Una y otra vez vemos consultas, consultas y consultas sobre este tema ...

   Desde la mas simple emisión o recepción de un sólo carácter por el PIC, con o sin el uso de interrupciones, hasta el tratamiento de búferes lineales o cíclicos, comandos de control simples o complejos, unidireccionales o interactivos, y que incluyen parámetros de todo tipo, color y sabor. Y planteado para comunicar PIC's con PC's, PIC's con PIC's ó PIC's con casi cualquier otro tipo de dispositivo, usando niveles TTL, RS232, RS485 ...

   Sobre este tema hay innumerables artículos abiertos en Internet con absolutamente todo lo necesario para realizar casi cualquier cosa que podamos imaginar, usando un buscador y teniendo la paciencia necesaria para leer y rebuscar entre los resultados este artículo sería totalmente innecesario.

   Lo que no voy a tratar son los hardware's necesarios para comunicar distintos dispositivos según los distintos protocolos y/o niveles. Desde el punto de vista de un PIC es totalmente indiferente si se comunica con un PC o con otro PIC y es absolutamente igual si lo hace en RS232 con el uno que en TTL con el otro.

   Escribo este artículo en un intento por clarificar conceptos, organizarlos y mostrarlos de la forma mas clara y sencilla posible, unificarlos y crear una jerarquía de menos a más según sea lo que necesitemos creciendo en complejidad.

   Pero sin quedarme sólo en la teoría sino que además deseo proponer ejemplos prácticos listos para usar, profusamente comentados línea a línea para que sea posible "leer" el programa, seguir su ejecución, mediante los comentarios añadidos. Con todos los ejemplos escritos, compilados y probados sobre un PIC para certificar su correcto funcionamiento.

   En este artículo voy a desarrollar, en lenguaje C variante CCS, las técnicas y conceptos necesarios para emitir y recibir con un PIC de las series 16F y 18F (por la gran similitud que hay entre ellas, tanta que solo va a ser necesario cambiar el #include del modelo de PIC concreto y los #defines de los pines reales conectados a la USART). Vamos a presentar desde el mas simple echo hasta un completo tratamiento de comandos con parámetros de distinto tipo.

   Voy a ir escribiendo sub-artículos cerrados y completos. Cada uno con sus respectivos Objetivos, Implementación en C y su Programa Fuente completo funcionando.

   Y como he descrito anteriormente avanzando en complejidad e intentando que estos "saltos" de lo sencillo a lo complejo se vayan haciendo paulatinamente, paso a paso, y así poder describir esos avances de forma que sean acumulables para los amigos que empiezan y no se vean en la obligación de "tragar" mas de lo que son capaces de comprender.

   Todos los programas los voy a escribir en CCS C, versión 3.242, y van a ser probados sobre un PIC 18F4550 con un cristal de 20 Mhz con el PLL activado para generar un ciclo de reloj de 48 Mhz, conectado a un PC mediante una interface hardware RS232 construida alrededor de un MAX232, transmitiendo y recibiendo a 115200 baudios, 8 bits, 1 bit de Stop y sin Paridad (none) . Por ello los fuses que aparecerán en los ejemplos y la definición CCS del canal Serie va a ser:

   Esta parte va a ser común a todos los ejemplos y es la única, salvo que expresamente se diga lo contrario, que es necesario adaptar a cada uno de los distintos modelos y condiciones de vuestro PIC en particular. Si esta cabecera corresponde con vuestro PIC todos los ejemplos que tratemos deben funcionar correctamente desde el principio.

Así si nuestro PIC es un 16F876A, con un cristal de 4 Mhz y transmitiendo y recibiendo a 9600 baudios la cabecera debería ser:

   Como veis las modificaciones son mínimas. El resto lo dejamos para cada uno de los artículos que tratemos. Espero que os guste y os sirva.

   Lo mas simple que se puede hacer con un PIC en esto de las comunicaciones es recibir un carácter y devolverlo a modo de eco. Sin manos, sin pies y casi sin bicicleta, esperamos a recibir algo e inmediatamente lo reenviamos a su destino.

   Para implementarlo en C lo que vamos a hacer es montar nuestro sempiterno bucle infinito del While(true) y dentro de él vamos a utilizar las funciones built-in de C llamadas kbhit() que devuelve true cuando hay algo pendiente de recibir (comprueba si está en alto el bit 5 RCIF del registro PIR1), getc() que obtiene, "lee", el byte recibido (descarga RCREG) y putc() que emite un byte por la USART (escribe TXREG).

   Podemos describir lo que vamos a hacer de la forma: Espera mientras te avisen que hay algo pendiente de recibir, que cuando llegue lo lees y lo vuelves a enviar, y así hasta el infinito y mas allá. 

   Recuerda que la cabecera es la misma para todos los programas y la tienes descrita en nuestra Introducción  de esta serie.

   No tan simple como nuestro anterior ejemplo pero casi. Esta vez vamos a hacer que el eco se produzca de igual forma que anteriormente pero haciendo uso de la interrupción por recepción serie, INT_RDA, que se nos va a disparar cuando nuestro PIC reciba un carácter por dicho canal.

   Para implementarlo en C lo que vamos a hacer es simplemente mover la recepción y reenvío del carácter desde el bucle infinito en el main(), que es donde lo teníamos antes, a una rutina especial que solo se ejecutará cada vez que se reciba un carácter por la USART. Recordad que la función escrita a continuación de la directiva #int_rda será la que se ejecute cuando se dispare dicha interrupción. De ahí que le haya llamado rda_handler o manejador de la interrupción RDA.

   Podemos describir lo que vamos a hacer de la forma: Haz lo que te de la gana en el main() porque cuando te avisen de que hay algo pendiente de recibir saldrás de allí y en la rutina de la interrupción lo lees y lo vuelves a enviar, devolviéndote adonde estabas en cuanto termines. 

   Recuerda que la cabecera es la misma para todos los programas y la tienes descrita en nuestra Introducción  de esta serie.

   Entramos ya en terrenos con una utilidad directa. En este tercer ejemplo tenemos la intención de recibir comandos desde fuera del PIC y ejecutar distintas funciones según sea lo recibido. Pero además vamos a tener un pequeño "feed-back" para poder saber qué es lo que está recibiendo el PIC, de forma que el PIC nos devuelva el comando recibido y los resultados de la función que se ejecuta, o algo que nos indique que el comando es erróneo.

   Lo que vamos a hacer es declarar una variable de tipo char en la RAM a la que llamaremos Command, que inicializaremos a cero 0x00 en el main() y sobre la que recogeremos lo que recibamos por el canal serie con la interrupción #INT_RDA, tal como vimos en el ejemplo anterior.
 

   En el main(), dentro del bucle infinito While(true), comprobaremos en cada vuelta si el contenido de Command es distinto de de 0x00 (recordad que lo inicializamos con este valor) ya que entonces significaría que si hemos recibido algo.
 

   Entonces lo primero que haremos será monitorizar esta recepción mediante un printf y después usando un switch ejecutaremos la función seleccionada. En caso de no ser uno de los que hemos contemplado en el switch devolveremos una señal en tal sentido.
 

   En cualquier caso volveremos a inicializar a 0x00 la variable Command para no volver a ejecutar la misma función hasta no recibir de nuevo el comando correspondiente.

   Recuerda que la cabecera es la misma para todos los programas y la tienes descrita en nuestra Introducción  de esta serie.

   Un detalle importante a tener en cuenta con este modo de tratar los comandos recibidos: Aunque la USART no pierda ningún carácter que pueda enviársele solo se ejecutarán aquellos que sean recibidos fuera de la ejecución de una de las funciones asociadas a ellos, y esto es debido a que tras la ejecución de cualquiera de ellas ponemos a 0x00 la variable Command, por eso cualquier cosa recibida durante la ejecución no se tendrá en cuenta.

   Las más de las veces todo lo que hemos visto hasta ahora de Comandos de Un Solo Carácter se nos queda corto, ya sea porque necesitamos comandos mas largos, usando palabras en lugar de solo una letra, ya sea porque necesitamos argumentos, o sea datos añadidos a nuestro comandos que deben ser procesados a la llegada de éstos. Todo esto no es posible montarlo procesando uno a uno los caracteres que le vamos enviando al PIC.
 

   Hay que hacerlo recibiendo y acumulando en la memoria del PIC todo aquello que necesitamos y enviando como último carácter uno especial que dispare su procesado. Esto es lo que se conoce como "recibir sobre un buffer" y es lo que vamos a estudiar aquí y ahora: Recibir caracteres sobre un buffer, uno a uno, y procesarlo cuando se reciba uno en concreto, yo siempre uso 0x0D [Retorno de Carro] o sea al pulsar la tecla [Enter].

   El primer recurso que necesitamos es el Buffer. En C nuestro buffer va a ser una matriz (un arreglo) de caracteres, también conocido como string, o sea n caracteres consecutivos en la memoria del PIC, de forma que el primer carácter que recibamos lo guardemos en la primera posición del buffer, la 0, el segundo en la siguiente, la 1, y así sucesivamente hasta que le enviemos el carácter especial de procesado o que se nos acabe el buffer porque hayamos alcanzado su final.
 

   Muy importante es la longitud máxima que vamos a darle a nuestro buffer, o sea el máximo número de caracteres que va a tener, tanto para reservar la memoria RAM correspondiente como para detectar si hemos alcanzado el final del mismo y no podemos seguir recibiendo sobre él so pena de sobrescribir otras zonas de la memoria del PIC. Así que vamos a definir una constante con esta Longitud Máxima del buffer que utilizaremos después para estos dos cometidos: Declarar el buffer en la RAM y controlar la recepción máxima de caracteres sobre él.
 

   Además necesitamos un recurso añadido que nos diga a qué posición debe guardarse el siguiente carácter que se reciba. Esto lo vamos a hacer declarando en RAM una variable de tipo entero que inicialmente pondremos a 0 de forma que al recibir el primer carácter lo guardemos en esa posición e incrementamos nuestro índice, así al llegar el siguiente lo guardaremos en 1 y volveremos a incrementar el índice. ¿Hasta cuando? pues hasta recibir el carácter especial de final o llegar al final físico declarado con la constante anterior.

   Con lenbuff definimos la máxima longitud del buffer que lo usamos al declarar el propio buffer en cbuff[lenbuff] y utilizaremos xbuff como índice del mismo, poniéndolo a cero para comenzar e incrementando su valor cada vez que guardemos un carácter en el buffer.
 

   Tenemos entonces ya lo fundamental, que es el "receptáculo" donde guardar lo recibido y los recursos para ello. Tenemos ahora que recibirlo y guardarlo efectivamente.
 

   Para ello vamos a utilizar la Interrupción por Recepción Serie que vimos en Comandos de un solo carácter pero que en aquel caso era un simple command=getc() y en el que nos ocupa va a ser un mucho mas complejo add_2_cbuff() que es una función donde vamos ha hacer todo lo necesario para recoger el carácter recibido y dejar el buffer preparado para el siguiente carácter por recibir.
 

   Como veis en el código anterior distinguimos en lo recibido si es cualquier cosa o es el carácter especial 0x0D en cuyo caso ponemos un flag en alto.
 

   Ya que estamos interactuando con nuestro PIC vamos a hacerlo de forma mas completa. Por un lado vamos a implementar alguna forma de feed-back, algo que nos diga cómo va nuestro buffer llenándose, y algo mas de control sobre él. Por ejemplo una tecla para borrar el último carácter recibido y poder así corregir un error de digitación o incluso una tecla especial para borrar todo el buffer almacenado hasta el momento. Así convertiremos las teclas Backspace y Escape, códigos ASCII 0x08 y 0x1B respectivamente, en teclas especiales también junto a nuestro anterior 0x0D.
 

   Introducimos entonces una nueva función a la que vamos a llamar echo_sel() por "Eco selectivo" para monitorizar lo que estamos enviándole al PIC y también vamos a modificar nuestra add_2_cbuff() anterior para contemplar las nuevas posibilidades de borrado del buffer.
 

   La función echo_sel() la vamos a llamar después de guardar lo recibido en el buffer y así nos irá informando de cómo está el buffer y de si hemos pulsado alguna de las teclas especiales, mostrándonos el resultado sobre el buffer.
 

   Fijaos que al pulsar la tecla Backspace lo único que hacemos es decrementar la variable índice del buffer y ponemos esa posición a 0x00, mientras que por el contrario cuando pulsamos la tecla Escape lo que hacemos es borrar todo el buffer y poner dicho índice a cero.
 

   Con lo que ya lo tenemos casi todo. Solo constatar que el main() es hiper-simple ya que lo único que hacemos en él, aparte de habilitar la correspondiente interrupción es esperar a que el flag para procesar comando se ponga en alto, cosa que solo haremos en add_2_cbuff() cuando recibamos el 0x0D. En ese caso ejecutaremos la función commad_process() donde haremos lo que nos de la gana con lo recibido (en este ejemplo lo copiamos a otra variable y jugamos con los printf para mostrarlo)
 

   Recuerda que la cabecera es la misma para todos los programas y la tienes descrita en nuestra Introducción  de esta serie.

   Aquí podéis ver un ejemplo de este programa funcionando. Un primera parte donde se presenta nuestro PIC y nos informa de sus posibilidades, es la parte de la función commad_menu() y después un ejemplo de escribir una serie de caracteres pulsando a continuación [Escape] para borrar todo lo escrito, y otro con la eliminación del último caracter escrito y su posterior procesado.