ATMEGA328p

Sumario

. Capítulo I.....................................................8

. Microcontrolador ATMEGA328P..................................8

. Funcionamiento general de un Microcontrolador.....................10

. Entorno de trabajo MikroC.......................................13

. Instalador de paquetes de Mikroelektronika..........................14

. Programación en lenguajes de alto nivel............................15

. Lenguaje C...................................................16

. Estructura de un programa en C...................................20

. Punteros con C................................................25

. Funciones....................................................27

. Manejo de un display de siete segmentos............................30

. Tipos de datos en Mikroc........................................33

. Operadores Lógicos en Mikroc...................................34

. Estructuras de Control..........................................35

. Interrupciones con MikroC y ATMEGA328.........................37

. Interrupciones externas INT0 INT1................................39

. Eliminando ruidos de contactos en INTx............................41

. Temporizadores...............................................42

. Interrupción del Timer 0 (Modo Comparación).......................43

. Interrupción del Timer 0 (Modo Desborde)..........................48

. Timer 1 y control PWM.........................................49

. Conversor Analógico Digital.....................................55

. Voltímetro con display de siete segmentos..........................57

. Control del LCD (HD44780).....................................61

. Manejo de un LCD 16x2........................................63

. Temperatura interna del chip.....................................67

. KS0108 o compatibles (128x64 pixeles)............................70

. Estructuras en C...............................................79

. Capítulo II...................................................82

. Memoria EEPROM interna del ATMEGA328.......................82

. Funcionamiento de la UART.....................................84

. El protocolo I2C...............................................87

. Esquema electrónico para conectar la memoria al los pines I2C..........92

. RTC DS3231 (Real Time Clock)..................................92

. Protocolo 1-wire...............................................96

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

. Capítulo III.................................................102

. Sensor de temperatura y Humedad DHT22.........................102

. Impresoras Térmicas..........................................107

. Capítulo V..................................................110

. Historia de la Arquitectura ARM.................................110

. Que es Cortex M4.............................................111

. Características heredadas de RISC................................112

. Algunas ventajas de RISC......................................112

. Desventajas de RISC..........................................112

. Bus AMBA..................................................113

. Pipeline.....................................................113

. FPU........................................................115

. ARM y Thumb...............................................116

. El sistema de memoria ARM....................................117

. STM32F407VG Discovery.....................................118

. Características de la placa entrenadora.............................118

. Shield para Discovery..........................................119

. Que es MikroBUS............................................120

. Que necesito para trabajar con ARM..............................120

. MikroC Pro para ARM.........................................122

. Configurando el entorno de trabajo...............................124

. Configurando el reloj y buses internos.............................125

. Programar STM32F407 por UART...............................127

. Mi Primer Programa en MikroC..................................128

. Capítulo VI.................................................133

. Interrupciones para STM32F407.................................133

. Temporizador del sistema (SysTick)..............................138

. Pantalla LCD 16x2 con STM32..................................141

. Funcionamiento de la USART..................................144

. Resultado obtenido con el ejemplo propuesto.......................146

. Conversor Analógico con STM32F407VG.........................146

. Conversor Analógico por Interrupción.............................150

. Midiendo la temperatura del Núcleo Cortex........................153

. Capítulo VII.................................................156

. Canales DMA................................................156

. Modo DMA de doble buffer.....................................163

. Sensor de Temperatura y Humedad HDC1000......................164

. Sensor Barométrico LPS25HB...................................168

. Sensor I2C HTU21D..........................................176

. ARM con RFID..............................................179

. Comandos del CR95HF........................................180

. Hardware usado en el proyecto..................................191

. Driver para el CR95HF con ARM................................192

. Sintetizadores de voz..........................................200

. Programa ejemplo para el sintetizador de voz.......................202

Puerto SDIO con STM32........................................208

. Capítulo VIII................................................214

. Ejemplo con 1-Wire y el sensor DS18B20..........................214

. Que es un socket?............................................217

. Wi-Fi con ESP8266...........................................218

. Enviando datos con ESP8266....................................221

. Controlando LED's por Wi-Fi...................................222

. Midiendo Temperatura y Humedad por Wi-Fi.......................228

. Detección de Luz Visible con OPT3001............................235

. CAN BUS ( Controller Area Network)............................238

. Tecnología ZigBee............................................246

. Topologías de red para ZigBee...................................247

. Conectados por ZigBee........................................247

. Placa ZigBee montada lista para su uso............................248

. Ejemplo para ZigBee Coordinador y Cliente........................248

. Pantallas Táctiles y TFT........................................253

. FSMC (Flexible Static Memory Controller)........................254

. Introducción a Visual TFT......................................257

. Trabajando con Visual TFT.....................................259

. Conversor A/D + Visual TFT....................................268

. Control del Touch con Visual TFT...............................269

Acerca de este libro.

El eje central del libro es la programación para  AVR en ocho bits y en treinta dos bits para la arquitectura de ARM con el compilador MikroC de MikroElektronika

Compilador largamente probado y sin duda una de las herramientas que junto con los compiladores oficiales de las correspondientes marcas, generan código confiable y muy eficiente en el uso de los recursos de los microcontroladores.

MikroC ofrece gran cantidad de código resuelto, funciones y drivers contenidos en una extensa biblioteca que hacen el trabajo del programador mucho más sencillo acortando los tiempos de desarrollo y depuración de código.

Para la mayoría de los programadores de microcontroladores incorporar a su esquema de trabajo la arquitectura de ARM puede ser un paso complejo debido a las grandes diferencias que existen con otras arquitecturas de microcontroladores.

Pensando en esto se ha desarrollado el presente trabajo que pretende hacer más fácil aprender a programar tanto ARM con su núcleo Cortex como también AVR con el popular controlador ATMRGA328P ambos  con el compilador MikroC.

También usaremos Visual TFT y Visual GLCD, programas creados por MikroElektronika para el desarrollo de interfaces con pantallas graficas que genera código para ser compilado directamente por sus compiladores, esto acelera y facilita mucho el diseño de interfaces con este tipo de pantallas.

Se considera este trabajo como introductorio a la programación en el lenguaje C sin embargo encontrará una gran cantidad de ejemplos, rutinas de programación, librerías y textos explicativos sobre una diversidad de temas que pueden ser de utilidad no solo en el proceso de entender cada una de las arquitecturas, sino también para aplicar en desarrollos electrónicos en general.

Todos los ejemplos propuestos están pensados para su realización práctica con electrónica real, esto no significa que no pueda usar simuladores para corroborar su funcionamiento sin embargo la experiencia nos enseña que no siempre los resultados obtenidos en el simulador coinciden con el comportamiento en el terreno físico.

Recuerde que la simulación se ejecuta en un entorno ideal (la memoria del computador), sin ruidos eléctricos ni interferencias del mundo real.

––––––––

Comentarios del autor.

Siendo el microcontrolador ATMEGA328P un dispositivo mundialmente usado por ser el procesador de la popular placa Arduino Uno, es también un microcontrolador con un potencial no explotado ni conocido en su totalidad debido a la forma en que Arduino transparenta muchos de los procesos y configuraciones que ocurren cuando un programa se ejecuta en su memoria.

Por otro lado tenemos los procesadores de ARM, en particular su núcleo Cortex M4. Un poderoso microcontrolador totalmente programado en 32 bits con recursos no solo para el control, también podemos ejecutar programas que involucren audio y video.

Siendo los 32 bits la evolución natural para los programadores que avanzan en su camino con microcontroladores, las unidades de ARM son una buena opción por su alto desempeño y costos razonables.

No se espera que al terminar la lectura de este libro usted sea un experto programador en C, pero sí que tenga una idea clara de lo que es el lenguaje con uno de los compiladores más simple de usar.

Un comentario que siempre hago a mis alumnos es que la evolución es un paso hacia adelante, un cambio superador y en el campo de la electrónica programable eso es C.

A partir de este punto dependerá de usted hasta donde quiera llegar y que tan largo será el camino.

Gracias por permitirme ser parte de ese camino.

Daniel Schmidt

Componentes usados en los ejemplos.

Como se verá a lo largo de las siguientes páginas todos los ejemplos propuestos han sido construidos y verificados en su funcionamiento.

El libro esta dividido en dos partes.

Primera parte: Programación en 8 bits con el controlador ATMEGA328 donde se verán distintos ejemplos usando el programador USBASP, un microcontrolador ATMEGA328P montado sobre un protoboard alimentado con una fuente de 5 Voltios.

También se usarán una serie de resistencias, tres dígitos cátodo común, dos botones pulsadores normal abierto, un sensor DS18B20, una pantallas Hitachi 44780 o compatible, una pantalla gráfica KS0108, un sensor DHT22, algunos condensadores cerámicos, un cristal de 20 Mhz, cables para conexionar sobre el protoboard.

También usaremos un puente USB – RS232, dos potenciómetros de 10K y un pre-set de 5K. En cuanto al software se usará el compilador  MikroC Pro para AVR en su versión libre con Visual GLCD.

Segunda parte: Programación en 32 bits con el controlador STM32F407V Cortex M4.

Para simplificar el hardware se ha usado la entrenadora Discovery con el Cortex M4 ya montado. También estamos usando el escudo de Mikroelektronika para esta placa entrenadora. El compilador usado es MikroC Pro para ARM en su versión libre junto con el Visual TFT.

Se tratan muchos ejemplos con sensores como el HDC1000, LPS25HB, HTU21D, OPT3001.

Usaremos el ESP8266, una placa RFID con el controlador CR95HF.

También un enlace ZigBee con el controlador  MRF24J40MA y dos placas para enlaces CAN.

Capítulo I

Microcontrolador ATMEGA328P.

El microcontrolador ATmega328P que originalmente fué fabricado por ATMEL y ahora por Microchip,  pertenece a la familia de microcontroladores AVR con arquitectura RISC de 8-bit, tiene formato de encapsulado superficial, SMD y también con el formato DIP o dual in-line package (DIP o DIL).

Pines del Microcontrolador ATMEGA328P.

El dispositivo tiene un rendimiento de 20 MIPS a 20 MHz y es el controlador utilizado en las placas Arduino Uno, Nano y Mini.

Originalmente no trae el Bootloader de Arduino pre-cargado por lo que es necesario programarlo en el chip si se lo usará con el IDE de Arduino. No es necesario con Mikro C Pro para AVR.

Características generales del ATmega328.

  Tensión de operación 1.8-5.5V.

  Hasta 20MHz.

  32kB Memoria de programa Flash.

  1kB EEPROM.

  2kB SRAM.

  2 Contadores/Timers de 8-bit.

  1 Contador/Timer de 16-bit.

  RTC con oscilador propio.

  6 canales PWM.

  Conversor ADC de 8 canales.

  Puerto serie USART.

  Interface SPI Master/Slave.

  Interface I2C.

  Watchdog timer.

  Comparadores analógicos.

  23 pines de entrada/salida.

Estructura interna del ATMEGA328P.

Funcionamiento general de un Microcontrolador.

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.

También dentro de la CPU encontramos la ALU que 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.

Puertos de entradas y salidas.

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

Estos pines solo sirven para recibir o enviar señales al mundo exterior, no se deben cargar estos pines con corrientes superiores a los 20mA para evitar dañar el controlador. Siempre que sea necesario activar un dispositivo periférico se usará una interfaz o actuador que reciba la señal del pin y realice el trabajo pesado.

Memoria de Programa (Flash).

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 el programador programa con el código que ha escrito, esta memoria es del tipo FLASH y sería equivalente al disco duro en un computador

.

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 el programador a través de estos registros 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 su funcionamiento  es controlado por el propio controlador. El vector de inicio para este espacio de memoria comienza en la dirección siguiente a la última variable declarada en el programa.

La pila se crea en el espacio de RAM (2KB) disponible. Tradicionalmente la pila o stack sólo se usa como 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 están escondidos.

Los usuarios no tienen acceso directo a la pila y en general trabajando en C los problemas relacionados con un desborde de pila son poco probables que ocurran ya que el enlazador/compilador se encargan de resolver estas cuestiones.  Si es un tema de cuidado cuando se programa en ensamblador.

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 ATmega328 dispone de 1KB de memoria EEPROM.

La memoria ROM.

Se encuentran grabadas entre otras varias cosas las instrucciones del microcontrolador, fueron puestas ahí por ATMEL fabricante del controlador, (Son 131 para el ATMEGA328) 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 controlador 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 páginas, es decir la FLASH está paginada y los datos en ella se procesan por páginas. El tamaño de la pagina en bytes depende del tipo de memoria 64,128,256, etc. En un microcontrolador la memoria FLASH es donde se almacena el código o programa escrito por el programador, comúnmente es lo que se llama memoria de programa.

El tamaño de esta memoria determina el tamaño de nuestro programa, por ejemplo para el ATMEGA328 esta memoria tiene un tamaño de 32KB, si código escrito requiere mas memoria es cuando debemos pensar en un controlador mas grande.

Los Timer.

Son los encargados de generar tiempos y retardo, útiles cuando tenemos programas que hacen tareas en ciclos que se repiten.

ATMEGA328 dispone de dos timers de 8 bit´s y uno de 16 bit´s.

Con los temporizadores se pueden no solo generar tiempos exactos también diseñar controles PWM y contadores.

Los Conversores A/D.

Son los responsables de hacer mediciones, convertir variables analógicas físicas en datos digitales. Medir temperatura, peso, etc y cuantificar estos valores en el mundo digital del controlador. ATMEGA328 dispone de un conversor con 8 canales analógicos de 10 bit´s cada uno. 

Comparadores Analógicos.

Este controlador incorpora un comparador analógico, es útil a la hora de comparar magnitudes de voltaje siempre superiores a 40mV.

––––––––

RTC (Reloj de tiempo real).

Util para programar eventos (luces, riegos, alarmas, etc), sin embargo cuando los eventos deben tener un control muy exacto se requiero de una señal de sincronización para evitar la deriva del propio reloj.

Registros SFR.

Un registro no es otra cosa que una posición de memoria que contiene un dato. Los registros son vectores o posiciones de memoria RAM y son de vital importancia para el programador y fuente de muchos dolores de cabeza. A través de estos registros podemos conocer el estado interno del microcontrolador, que esta haciendo y como es su estado general. A través de estos registros la CPU dialoga con el programador y este puede interactuar con la propia CPU activando bit's de estos registros que determinan acciones dentro del controlador.

Es frecuente que este sea uno de los puntos más oscuros que tiene la programación en estos niveles ya que se requiere un conocimiento fino de la arquitectura interna del controlador para saber interpretar la información de estos registros y enviar hacia la CPU acciones concretas.

El programador también puede crear sus propios registros, lugares de memoria que serán destinados a contener las variables que maneje el programa.

Los registros SFR son propiedad de la CPU y no deben