Programación en C para PIC.

Sumario

Capítulo I......................................................6

Los PIC's y un poco de su historia...................................6

Como funciona un Microcontrolador PIC.............................7

Arquitectura de los PIC's.........................................10

Arquitectura Hardvard:..........................................10

Entorno de programación.........................................11

Hardware Programador..........................................12

Programar PIC con GNU/Linux....................................12

El lenguaje C..................................................14

El lenguaje C para Microcontroladores PIC...........................15

Estructura de proyecto en XC8 con MPLAB..........................16

Variables en XC8...............................................23

Operadores....................................................25

Estructuras de Control...........................................26

Directivas del Pre-Procesador.....................................29

Control del LCD (HD44780)......................................30

Manejo de un LCD con XC8......................................32

Interrupciones en XC8...........................................41

Declaración de los registros internos................................49

Punteros......................................................49

Funciones.....................................................53

Punteros a Funciones............................................56

Estructuras....................................................59

Uso del conversor A/D...........................................64

Capítulo II....................................................70

Memoria EEPROM interna del PIC.................................70

El protocolo I2C................................................75

RTC DS1307 (Real Time Clock)...................................82

La dirección del dispositivo.......................................86

PCF8574......................................................93

Protocolo 1-wire................................................97

Sensor de temperatura 1-wire DS18B20.............................98

Capítulo III..................................................111

El Puerto USB................................................111

Token y Packets...............................................120

Clase USB CDC con PIC16F1455.................................124

Algunos ejemplos de programas para otros PIC......................130

Encendiendo un LED con PIC12F683..............................130

Encendiendo un LED con PIC16F84...............................131

Manejando botones y LED´s con PIC12F629........................131

Capítulo IV..................................................134

ESP32.......................................................134

Porque mezclar ESP32 con PIC's?................................136

Alimentación para el ESP32 Thing................................137

Algunos pines especiales........................................138

El Internet de las Cosas.........................................139

Que es HTML?...............................................139

Ejemplos de algunas etiquetas HTML..............................140

Servidores web con electrónica...................................142

Que es Ajax?.................................................143

ESP32 con Arduino............................................146

Como programar la placa ESP32 Thing.............................148

Hola Mundo con ESP32.........................................149

Voltímetro web con Ajax........................................149

Como funcionan las cosas dentro del PIC...........................151

Como funcionan las cosas en la página web.........................153

Como funcionan las cosas en el servidor web........................157

Electrónica y conexionado del proyecto.............................164

Lectura de un sensor DS18B20 desde una WEB......................167

Página web para ver los datos del sensor............................170

Control de pines con botones web.................................172

Que es un Socket de Red?.......................................178

Enviando un contador por un Socket con un PIC......................179

Socket y datos de un sensor DS18B20..............................185

Que es el protocolo MQTT.......................................186

Por qué MQTT................................................187

Como funciona MQTT?........................................187

MQTT con PIC's..............................................188

Pasos para subscribir a un tópico..................................189

Otros ejemplos con ESP32 y Arduino IDE..........................197

El Internet de las Cosas.........................................197

Como funciona................................................197

Riesgos de IOT................................................197

Web Server con ESP32.........................................198

Control HTML de un LED con ESP32 .............................201

Implementado AJAX con ESP32..................................204

Bibliografía...................................................208

Sobre del autor.

Daniel Schmidt trabaja con microcontroladores PIC desde que estos hicieron su aparición. Su trabajo con microcontroladores tuvo su origen en la plataforma de  microcontroladores Motorola, y cuando Microchip puso en el mercado los populares PIC's estos fueron inmediatamente agregados a su escenario de trabajo, sobre todo porque en el tiempo en que aparecieron, pocos eran los microcontroladores con tecnología EEPROM lo que facilitaba y aceleraba mucho el trabajo en la depuración de códigos.

Ha desarrollado gran cantidad de sistemas de control y seguridad tanto para entornos industriales como domésticos.

En el ámbito universitario ha sido a lo largo de los años, un gran difusor de tecnología que promueve el uso de microcontroladores.

Acerca de este libro.

El presente libro pretende ser una introducción a la programación de microcontroladores PIC con el lenguaje C usando el compilador oficial de Microchip XC8.

Ha sido redactado en un lenguaje simple con muchos ejemplos comentados para hacer mas fácil su entendimiento y con un mínimo de dedicación alcanzar los objetivos propuestos.

También se ha visto en la práctica que aplicaciones que incluyen trabajos que mueven datos por TCP-IP, en aplicaciones reales en terreno, los micros de ocho bits a los que también cargamos con la propia aplicación de trabajo, sus recursos no alcanzan para un nivel de respuesta adecuado. Para resolver esto las posibles soluciones son, cambiar a un microcontrolador mas potente, lo que obliga a portar el código ya escrito a un nuevo microcontrolador.

Esto puede ser un poco engorroso sobre todo si tenemos una aplicación ya funcionando y ampliamente probada corriendo en un viejo PIC12xx o 16xx, portar todo el código puede llevar tiempo.

La otra posible solución es separar la gestión y manejo de los procesos de red sumando al proyecto una electrónica dedicada a este trabajo.

Actualmente tenemos varias posibles soluciones algunas muy económicas como Pico W sin embargo tendríamos que trabajar con MicroPython y la idea es seguir con la línea de C.

Entonces tenemos ESP32 que si bien es un poco mas costoso que Pico W, organiza y maneja todos los procesos que tienen relación con el manejo de datos por TCP-IP.

Fácilmente podemos implementar servidores web, manejo de socket, manejo de datos relacionados con el Internet de las Cosas, protocolo MQTT y muchas cosas mas.

Como la programación del ESP32 es también C, se puede programar en un entorno muy popular como el de Arduino y así tener acceso a todas las biblioteca de Arduino para el manejo de Internet.

Porque mezclar Arduino y Microchip, se preguntará el lector. Y... porqué no. Entendiendo que no existe el microcontrolador perfecto, solo hay problemas y soluciones y si la solución mas práctica, efectiva, y funcional viene con esta unión de dos arquitecturas, perfecto!!.

Capítulo I

Los PIC's y un poco de su historia.

Los PIC son una familia de microcontroladores tipo RISC fabricados por Microchip Technology Inc. y derivados del PIC1650, originalmente desarrollado por la división de microelectrónica de General Instrument.

El nombre actual no es un acrónimo, en realidad el nombre completo es PICmicro, aunque generalmente se utiliza como Peripheral Interface Controller (Controlador de Interfaz Periférico).

El PIC original se diseñó para ser usado con la CPU CP16000. CPU que en general tenía prestaciones pobres de entradas y salidas, el PIC de 8 bits se desarrolló en 1975 para mejorar el rendimiento de la CP16000 mejorando las prestaciones de entradas y salidas.

El PIC utilizaba microcódigo simple almacenado en ROM para realizar estas tareas.

Aunque el término no se usaba esos años, se trata de un diseño RISC que ejecuta una instrucción cada 4 ciclos del oscilador.

En 1985 la división de microelectrónica de General Instrument se separa como compañía independiente y cambia el nombre a Microchip Technology.

El PIC, sin embargo, se mejoró con EPROM para conseguir un controlador de canal programable. Hoy en día multitud de PIC´s vienen con varios periféricos incluidos (módulos de comunicación serie, UART, núcleos de control de motores, etc.) y con memoria de programa desde 512 a 32000 palabras (una palabra corresponde a una instrucción en lenguaje ensamblador, y puede ser de 12, 14, 16 o 32 bits, dependiendo de la familia específica de PIC).

El PIC usa un juego de instrucciones, cuyo número puede variar desde 35 para PIC de gama baja a 70 para los de gama alta. Las instrucciones se clasifican entre las que realizan operaciones entre el acumulador y una constante, entre el acumulador y una posición de memoria, instrucciones de condicionamiento y de salto/retorno, implementación de interrupciones y una para pasar a modo de bajo consumo llamada sleep.

Microchip proporciona un entorno de desarrollo libre llamado MPLAB que incluye un simulador software y un ensamblador. Otras empresas desarrollan compiladores C y BASIC. Microchip también vende compiladores C para los PIC como el XC8 para todos los micros de 8 bits, XC16 para micros de 16 bits, y XC32 para 32 bits.

Para transferir el código desde una PC al PIC normalmente se usa un dispositivo llamado programador. La mayoría de los PIC´s que Microchip distribuye incorporan ICSP (In Circuit Serial Programming, programación serie incorporada) o LVP (Low Voltage Programming, programación a bajo voltaje), lo que permite programar el PIC directamente en el circuito destino.

Para la ICSP se usan los pines RB6 y RB7 (En algunos modelos pueden usarse otros pines como el GP0 y GP1 o el RA0 y RA1) como reloj y datos y el MCLR para activar el modo programación aplicando un voltaje de 13 voltios.

Existen muchos programadores de PIC, desde los más simples que dejan al software los detalles de comunicaciones, a los más complejos, que pueden verificar el dispositivo a diversas tensiones de alimentación e implementan en hardware casi todas las funcionalidades. Muchos de estos programadores complejos incluyen ellos mismos PIC pre-programados como interfaz para enviar las órdenes al PIC que se desea programar.

La arquitectura se dirigen a la maximización de la velocidad, PIC fue uno de los primeros escalares diseños de CPU, y sigue siendo uno de los más simples y más baratos. La arquitectura de Harvard en el que las instrucciones y los datos provienen de diferentes fuentes-simplifica la sincronización y diseño de microcircuitos.

El conjunto de instrucciones es adecuado para la aplicación de tablas de búsqueda rápida en el espacio de programa. Estas búsquedas tienen una instrucción y dos ciclos de instrucción. Muchas de las funciones se pueden modelar de esta manera.

Como funciona un Microcontrolador PIC.

Para entender un poco como funcionan las cosas dentro de un microcontrolador podríamos comenzar definiendo sus partes.

CPU

Dentro de la CPU está la Unidad de Control (UC) quien se encarga de que todo suceda de acuerdo a lo previsto, la UC es pues quien decide cuando y como las acciones se llevan a cabo.

Se lee una instrucción desde la memoria de programa se la pasa al decodificador de instrucciones y el contador de programa (PC) se incrementa en uno para leer en la siguiente dirección en la memoria de programa.

La Unidad de Aritmética y Lógica (ALU).

También dentro de la CPU, es la encargada de resolver los problemas matemáticos y lógicos, cuando por ejemplo hay que resolver una operación de suma, la UC le pasa a la ALU las variables esta lo resuelve y le entrega los resultados a la UC para que esta disponga de ellos, entonces la UC consulta el programa para saber que debe hacer con el resultado.

I/O Ports.

Controlan los pines que son el vínculo con el exterior, estos pines se pueden configurar como entradas o salidas dependiendo de la necesidad.

––––––––

Memoria de Programa.

Es la memoria donde reside el código de la aplicación. Si por ejemplo hemos programado una alarma, es en esta memoria donde el código de la alarma reside.

La memoria de programa es la que programamos con nuestro programador, esta memoria es del tipo FLASH.

Memoria Ram.

La memoria RAM es una memoria de lectura y escritura pero temporal es decir los datos en ella se mantienen el tiempo que se haya energía en el sistema, si la memoria se queda sin energía la información se pierde. En un microcontrolador es la memoria destinada a guardar las variables temporales de proceso, variables de programa que solo son importantes en ese momento. Todos los microcontroladores tienen memoria RAM, algunos más otros menos pero todos disponen de esta memoria, no solo es usada por el programa para guardar los datos generados en tiempo de ejecución sino que también los registros propios del microcontrolador radican en RAM, registros de configuración, registros de estado, se puede decir que la CPU se comunica con nosotros a través de estos registros son los llamados SFR (Registro de Funciones Especiales).

Stack de Memoria o Pila.

El stack es memoria RAM donde el controlador guarda datos temporales de uso propio de la CPU, no depende del programador y es manejado por el controlador, tiene en la serie 18 de pic´s 31 niveles de profundidad lo que mejora notablemente el anidamiento de interrupciones que se verá mas adelante.

Tradicionalmente la pila o stack, sólo se ha utilizado como un espacio de almacenamiento para las direcciones de retorno de subrutinas o rutinas de interrupción, en donde las operaciones para meter y sacar datos de la pila estan escondidos.

En su mayor parte, los usuarios no tienen acceso directo a la información en la pila.

El microcontrolador PIC18 se aparta un poco de esta tradición. Con el núcleo PIC18 nuevo, los usuarios tienen ahora acceso a la pila y se puede modificar el puntero de pila y pila de datos directamente. Habiendo tales niveles de acceso a la pila permite algunas posibilidades de programación única e interesante.

La memoria EEPROM.

Es una memoria permanente como la ROM pero a diferencia de esta, se puede escribir en ella, se la puede borrar y desde luego leer, no todos los microcontroladores tienen EEPROM para guardar variables de programa, un ejemplo de uso podría ser un sistema de alarma donde el usuario guarda su clave de acceso y no queremos que la clave se pierda si se desconecta la fuente de poder además el usurario puede cambiar la clave cuando quiera ya que puede escribir en ella a voluntad.

El PIC18F4550 dispone de 256 bytes en EEPROM.

La memoria ROM.

Se encuentran grabadas entre otras varias cosas las instrucciones del microcontrolador, fueron puestas ahí por Microchip fabricante del pic, (Son 77 en el PIC18F4620) y básicamente son la esencia de lo que el micro puede hacer, la ROM es una memoria permanente, no se puede escribir en ella ni borrar, solo se la puede leer y es el propio microcontrolador en funcionamiento quien lee las instrucciones ahí escritas esta memoria es transparente al usuario y el programador solo accesible por la CPU.

La memoria Flash.

Es una memoria también permanente como la EEPROM, es en realidad una evolución de esta, la FLASH es mas rápida que la EEPROM y si bien es de borrado y escritura eléctrica como la EEPROM en la FLASH las cosas son diferentes, una memoria EEPROM puede ser borrada por palabras, es decir por Bytes, se puede acceder a una EEPROM y alterar solo un Byte dentro de la memoria o Bytes en distintas regiones de la memoria.

La FLASH solo se escribe o borra por paginas, es decir la FLASH está paginada y