PONTIFICIA UNIVERSIDAD CATÓLICA DEL ECUADOR SEDE AMBATO
DISEÑO DE UN MÓDULO PROGRAMABLE DE APLICACIÓN UNIVERSAL CON CUATRO SALIDADS PARA ACTUADORES Y CUATRO ENTRADAS PARA SENSORES.
Ing. MSc. MARCO POLO SILVA SEGOVIA
AMBATO NOVIEMBRE, 2009-11-30
1
Contenido INTRODUCCIÓN ........................................................................................................................ 5 CAPITULO I................................................................................................................................. 6 ARQUITECTURA, PROGRAMACIÓN Y APLICACIONES DE LOS MICROCONTROLADORES ....................................................................................................... 6 1.
Introducción a los microcontroladores. ................................................................................. 6
1.1.
Controlador ....................................................................................................................... 6
1.2.
Microcontroladores ........................................................................................................... 7
1.3.
Microprocesadores y Microcontroladores ......................................................................... 8
1.3.1.
Hardware ....................................................................................................................... 9
1.3.2.
Aplicaciones .................................................................................................................. 9
1.3.3.
Características del repertorio de instrucciones ............................................................ 10
1.4.
Organización de una computadora .................................................................................. 10
1.5.
Organización de un Microcontrolador ............................................................................ 11
1.5.1.
La Unidad Central de Procesos. .................................................................................. 11
1.5.2.
Tipos de CPUs............................................................................................................. 12
1.5.3.
Tareas de la CPU ......................................................................................................... 13
1.5.4.
Sistema de Memoria .................................................................................................... 14
1.5.5.
Periféricos incorporados a un Microcontrolador: Oscilador ....................................... 15
1.5.5.1.
Periféricos: Timer .................................................................................................... 16
1.5.5.2.
Periféricos: Watchdog Timer .................................................................................. 16
1.5.5.3.
Periféricos: UART (Serial Port) .............................................................................. 17
1.5.5.4.
Periféricos: Digital I/O Port .................................................................................... 17
1.5.5.5.
Periféricos: Analog I/O Port .................................................................................... 17
1.6.
Tipos de Arquitecturas de Microcontroladores ............................................................... 18
1.7.
Familias populares de Microcontroladores ..................................................................... 19
1.8.
Elección de un Microcontrolador .................................................................................... 21
1.9.
Criterios de selección. ¿Qué μP/μC uso? ........................................................................ 21
1.10.
Lenguajes de programación ........................................................................................ 22
1.10.1.
Lenguaje Máquina/ensamblador ................................................................................. 22
1.10.1.1.
Tipos de instrucciones: ............................................................................................ 23
1.10.1.2.
Formato de las Instrucciones: .................................................................................. 23
1.10.2.
Intérpretes .................................................................................................................... 23
1.10.3.
Compiladores .............................................................................................................. 24
1.10.4.
Simuladores ................................................................................................................. 24
1.10.5.
Debuggers residentes................................................................................................... 25
1.10.6.
Generadores de Código ............................................................................................... 25
1.10.7.
Emuladores .................................................................................................................. 25
1.11.
Descripción de un PIC................................................................................................. 25
1.12.
Herramientas de desarrollo.......................................................................................... 27
CAPITULO II ............................................................................................................................. 28 LOS MICROCNTROLADORES AVR Y EL DESARROLLO DE HARDWARE LIBRE ...... 28 2.1. LA FAMILIA DE MICRO CONTROLADORES AVR ..................................................... 28 2.1.1. Aspecto Externo ATMega8 ............................................................................................... 28 2.1.2. Aspecto Externo ATMega16 ............................................................................................. 29 2.1.3. AVR CPU CORE .............................................................................................................. 33 2.1.4. Memoria de programa. ...................................................................................................... 37 2.1.5. Memoria SRAM de Datos ................................................................................................. 39 2.1.6. Archivo de Registros ......................................................................................................... 40 2.1.7. Registros I/O ..................................................................................................................... 41 2.1.8. Registros I/O (Parcial) ....................................................................................................... 42 2.1.9. Registro de ESTADO (SREG: 0x3F o 0x5F) ................................................................... 42 2.1.10. Apuntador de Pila (SP).................................................................................................... 43 2.1.11. Acceso al espacio de Propósito General.......................................................................... 44 2.1.12. Memoria EEPROM para datos ........................................................................................ 45 2.1.13. Bits del registro de CONTROL:...................................................................................... 46 2.1.14. Puertos de Entrada/Salida................................................................................................ 51 2.1.15.
Sistema de Interrupciones ........................................................................................... 55
2.1.16.
Interrupciones en los AVRs ........................................................................................ 56
2.1.17.
Sistema de Inicialización. ............................................................................................ 61
2.1.18.
Inicialización por Brown-out ...................................................................................... 65
2.1.19. Inicialización por Watchdog ........................................................................................... 65 2.1.20.
Sistema del reloj. ......................................................................................................... 66
2.2.
Ventanas de programación, usando al AVR Studio y al AVR Dragon. .......................... 67
2.3.
Ventanas de PonyProg .................................................................................................... 68
2.4.
Cristal/Resonador ............................................................................................................ 69
2.4.1.
Cristal/Resonador Externo .......................................................................................... 69
2.4.2.
Cristal/Resonador de Baja Frecuencia ........................................................................ 70
2.4.3.
Oscilador RC Externo ................................................................................................. 71
2.4.4.
Oscilador RC Calibrado Interno .................................................................................. 72
2.4.5.
Reloj Externo .............................................................................................................. 72
2.4.6.
Distribución del reloj ................................................................................................... 73
2.5.
Administración de la Potencia y modos SLEEP ............................................................. 74
CAPÍTULO III ............................................................................................................................ 76 DISEÑO DE UN MÓDULO PROGRAMABLE DE APLICACIÓN UNIVERSAL CON CUATRO SALIDADS PARA ACTUADORES Y CUATRO ENTRADAS PARA SENSORES. ..................................................................................................................................................... 76 3.1. Introducción. ........................................................................................................................ 76 3.2. Campos de aplicación del proyecto ...................................................................................... 76 3.3. La placa electrónica. ............................................................................................................. 76 3.4. Diseño de la electrónica de la Placa serie de una capa ......................................................... 77 3.5. Diseño del PCB .................................................................................................................... 78 3.6. Listado de Materiales ........................................................................................................... 78 3.7. Implementación del prototipo. ............................................................................................. 82 3.7. Con que elementos podemos interactuar. ............................................................................ 83 3.8. Puesta en marcha .................................................................................................................. 84 3.8.1. Cable de comunicaciones (serie/usb) ................................................................................ 84 3.8.2. Fuente de alimentación (opcional) .................................................................................... 84 3.8.3. PC / portátil + adaptador serie-usb (opcional)................................................................... 84 3.9. Código necesario para el arranque o bootloader. ................................................................. 85
INTRODUCCIÓN
El desarrollo de la electrónica y la mecánica, han permitido el crecimiento vertiginoso de la robótica. En la actualidad industrias como la Honda del Japón han asignado grandes cantidades de recursos económicos, materiales y tecnológicos para el desarrollo de robots de toda índole y para aplicaciones muy variadas. La Pontificia Universidad Católica del Ecuador y en especial la sede Ambato, está muy interesada en el desarrollo de estas tecnologías, y ha emprendido un agresivo programa de investigación aplicada que permita impulsar a la robótica a niveles similares a los que las Escuelas Politécnicas de nuestro país. Este proyecto en particular sienta las bases para el desarrollo de las tecnologías que involucran la Robótica. Aportando así con una plataforma para el desarrollo de proyectos de electrónica de control y robótica. En el primer capítulo, se abordan los temas que involucran de forma general a los elementos que se constituyen en los verdaderos cerebros de los robots, como son los microcontroladores y sus características electrónicas y tecnológicas. El segundo capítulo, se centra en un tipo particular de microcontroladores, la familia de los AVR cuya tecnología ha permitido a la NASA llevar a sus naves espaciales a los confines de nuestro sistema solar y más allá. Finalmente el tercer capítulo se centra en el diseño y la construcción del prototipo de una plataforma de aplicación general que es el tema de este proyecto de investigación aplicada.
5
CAPITULO I
ARQUITECTURA, PROGRAMACIÓN Y APLICACIONES DE LOS MICROCONTROLADORES
1. Introducción a los microcontroladores.
1.1.
Controlador
Un controlador es un dispositivo que se emplea para el gobierno de uno o varios procesos. Aunque el concepto de controlador ha permanecido invariable a través del tiempo, su implementación física ha variado frecuentemente. Hace tres décadas, los controladores se construían exclusivamente con componentes de lógica discreta, posteriormente se emplearon los microprocesadores, que se rodeaban con chips de memoria y E/S sobre una tarjeta de circuito impreso. Prácticamente se trataba de una computadora en una sola tarjeta (SBC, Single BoardComputer). Aunque un controlador prácticamente incluye los elementos necesarios para ser considerado como una computadora, frecuentemente no es tratado como tal, ya que su uso típico consiste en el desempeño de funciones de “control” interactuando con el “mundo real” para monitorear condiciones (a través de sensores) y en respuesta a ello, encender o apagar dispositivos (por medio de actuadores). Los controladores están enfocados a sistemas de propósito específico, por ejemplo: cajas registradoras, hornos de microondas, videojuegos, videocámaras, equipos de sonido, instrumentos musicales, máquinas de escribir, fotocopiadoras, etc. En la actualidad, todos los elementos del controlador se han podido incluir en un circuito integrado, el cual recibe el nombre de microcontrolador. Realmente consiste en un sencillo pero completo sistema contenido en un solo circuito integrado
6
SBC (Single board Computer)
1.2.
MCU (Micro Controller Unit)
Microcontroladores
Un microcontrolador es un Circuito Integrado con tecnología VLSI (Very Large Scale Integration - integración en muy alta escala) que contiene una Unidad Central de Procesos (CPU), memoria para código, memoria para datos, además de otros recursos necesarios para el desarrollo de aplicaciones, por lo general con un propósito específico. Un microcontrolador es de hecho una computadora completa situada en un único chip.
7
Aplicaciones de los microcontroladores
Aplicaciones 10,00%
30,00%
15,00% 18,00%
27,00%
INDUSTRIA COMPUTADORAS AUTOMOVILES CONSUMO COMUNICACIONES
Porcentajes de utilizaci贸n en distintas 谩reas de los microcontroladores
1.3.
Microprocesadores y Microcontroladores
8
Aunque los microprocesadores y microcontroladores son dispositivos con algunas similitudes, existen diferencias importantes entre ellos, las cuales revisaremos desde 3 perspectivas diferentes: Hardware Aplicaciones Características del repertorio de instrucciones.
1.3.1. Hardware Microprocesadores Es una Unidad Central de Procesamiento en un circuito integrado. Microcontroladores RAM, ROM, interfaz serial, interfaz paralela, manejo de interrupciones, temporizadores, etc. Todo en un circuito integrado. Las limitantes en el microcontrolador son:
Velocidad de procesamiento
Tamaño de los datos
Espacio de direccionamiento de memoria
1.3.2. Aplicaciones Microprocesadores Los microprocesadores son comúnmente usados como CPU en las computadoras. Aunque también existen tarjetas de evaluación y desarrollo con base en algún microprocesador (SBC, Single Board Computer), pero éstas cada vez son menos comunes. Son la base para la construcción de sistemas de propósito general. Microcontroladores Los
microcontroladores
son
encontrados
en
sistemas
mínimos
desempeñando actividades orientadas al control. Son la base para sistemas con propósito específico. 9
1.3.3. Características del repertorio de instrucciones Microprocesadores Los microprocesadores deben incluir modos de direccionamiento capaces de manejar grandes cantidades de datos. Se espera que sus instrucciones operen sobre palabras (32 bits) o palabras dobles (64 bits).
Microcontroladores Un microcontrolador debe poder manjar bits directamente. Por ejemplo: para encender o apagar un motor basta con cambiar el estado de un bit. La mayoría de microcontroladores incluyen un procesador booleano que permite hacer operaciones lógicas directamente sobre bits.
1.4.
Organización de una computadora
Arquitectura de una computadora
10
1.5.
Organización de un Microcontrolador
Arquitectura de un microcontrolador
1.5.1. La Unidad Central de Procesos. Administra todas las actividades en el sistema y ejecuta todas las operaciones sobre los datos. Su tarea puede reducirse a las siguientes operaciones: Atrapar una instrucción. Decodificarla. Ejecutarla. Cada instrucción contiene un código de operación (opcode) y uno o más operandos sobre los que se realizará la operación. Estas instrucciones usualmente incluyen: Aritméticas: suma, resta, producto, división, etc. Lógicas: AND, OR, NOT, etc. Transferencia de datos. Bifurcaciones (condicionales o incondicionales) 11
Un grupo de instrucciones para un procesador particular forma su repertorio de instrucciones. Una familia de computadoras comparte un repertorio de instrucciones, aunque sus integrantes pueden variar en costo y rendimiento.
1.5.2. Tipos de CPUs. CISC: Complex Instruction Set Computers.- Una arquitectura RISC tiene pocas instrucciones y generalmente del mismo tamaño y muchas veces corresponde con el tamaño de los datos; en la CISC hay demasiadas instrucciones con diferentes tamaños y formatos, que pueden ocupar varios bytes, uno para el opcode y el resto para los operandos. Pero una instrucción CISC puede corresponder a varias instrucciones RISC. RISC:
Reduced
Instruction
Set
Computers.-
Con
tecnologías
de
semiconductores comparables e igual frecuencia de reloj, un procesador RISC típico tiene una capacidad de procesamiento de dos a cuatro veces mayor que la de un CISC y su estructura de hardware es tan simple, que se puede realizar en una fracción de la superficie ocupada por el circuito integrado de un procesador CISC.
12
La Unidad Central de Proceso (Visión simplificada)
1.5.3. Tareas de la CPU 1) Atrapar la instrucción: es una etapa fundamental que involucra los siguientes pasos: a) El contenido del PC es colocado en el bus de direcciones. b) Una señal de control (READ) es activada. c) Un dato (la instrucción) es leído de la RAM y puesto en el bus de datos. d) El dato es colocado en el registro de instrucción (IR). e) El PC es preparado para la siguiente instrucción.
13
Atrapar la instrucción
2) Decodificación: consiste en descifrar el opcode para generar las señales de control necesarias, dependiendo del tipo de instrucción. 3) Ejecución: consiste en la habilitación de la ALU para obtener algún resultado, cargar datos desde memoria, almacenar datos en memoria, modificar el valor del PC, etcétera (según las señales generadas por el control). Una serie de instrucciones combinada para realizar alguna tarea significativa es llamado programa. El grado en el cual las tareas son realizadas eficiente y correctamente depende en mucho del software, no de qué tan sofisticado sea el CPU.
1.5.4. Sistema de Memoria Una computadora (y por lo tanto, también un microcontrolador) debe contar con memoria de código y memoria para datos. Existen 2 modelos o Arquitecturas, de acuerdo con la organización de la memoria: 14
Arquitecturas de Microcontroladores
La mayoría de Microcontroladores utilizan una Arquitectura Harvard. La memoria de código (o de instrucciones o de programa) almacena las instrucciones que forman al programa. Para acomodar programas grandes, la memoria de código se puede particionar como memoria interna y memoria externa, en algunos microcontroladores. Usualmente la memoria de programa es no volátil y puede ser del tipo EPROM, EEPROM, Flash, ROM enmascarable o OTP (one-time programmable). Para la memoria de datos, los microcontroladores pueden contener RAM o EEPROM, para el uso de variables o de una pila. Todos los microcontroladores tienen memoria interna de datos, en diferentes magnitudes, algunos además cuentan con la capacidad de expansión usando una memoria externa.
1.5.5. Periféricos incorporados a un Microcontrolador: Oscilador La Unidad Central de Procesos va tomando las instrucciones de la memoria de programa a cierta frecuencia. Está frecuencia está determinada por el circuito de oscilación, el cual puede ser temporizado por un circuito RC (Oscilador con resistencia y condensador) o un cristal de cuarzo externo. Tan pronto como se suministra la alimentación eléctrica, el oscilador empieza su operación. 15
Arquitectura del microcontrolador
1.5.5.1.
Periféricos: Timer
El timer (Temporizador) es usado para eventos de tiempo, se compone de registros que se incrementan automáticamente cada ciclo de reloj y sus desbordamientos indican que ha transcurrido un intervalo de tiempo. El timer también puede ser usado para contar eventos, tanto internos como externos, en ese caso, el timer es conocido como contador. Por ejemplo, si alguna salida debe actualizarse a cierto intervalo de tiempo, el timer genera la señalización que le indica a la CPU cada que transcurre el intervalo deseado.
1.5.5.2.
Periféricos: Watchdog Timer
El Watchdog Timer (perro guardián) es un temporizador con una función especial, también lleva un control de intervalos de tiempo, pero sus desbordamientos reinician al procesador (aplican un reset). Si se utiliza, en posiciones estratégicas del programa debe incluirse una instrucción que lo reinicie, para evitar que desborde. 16
Su objetivo es que si por alguna condición externa el microcontrolador se cicla en algún estado inesperado, se reinicialice y regresé la operación al sistema.
1.5.5.3.
Periféricos: UART (Serial Port)
La mayoría de Microcontroladores cuentan con una UART (Universal Asynchronous Receiver Transceiver), para comunicación serial con dispositivos o sistemas externos, bajo protocolos y razones de transmisiones estándares. La comunicación serial puede ser: Síncrona: Además de la línea de datos se utiliza una línea de reloj. Asíncrona: Sólo hay una línea de datos, para el transmisor y receptor se deben configurar el Baud Rate (bits/segundo) y el formato de las tramas.
1.5.5.4.
Periféricos: Digital I/O Port
Los microcontroladores usan componentes digitales de Entrada/Salida para intercambiar datos digitales con el mundo exterior. A diferencia del puerto serie donde se transfiere un bit a la vez, los puertos digitales permiten el intercambio de bytes. Todos los microcontroladores tienen estos puertos y son frecuentemente usados como entradas por medio de botones, interruptores, sensores con salida a relevador, etc., y como salidas para el manejo de LEDs, visualizadores de 7 segmentos, activación de motores, etc.
1.5.5.5.
Periféricos: Analog I/O Port
Para entradas analógicas algunos microcontroladores incorporan Convertidores Analógico a Digital (ADC) o comparadores analógicos. Éstos son muy útiles por que sin recursos adicionales, permiten obtener información analógica del exterior, para monitorear parámetros como temperatura, velocidad, humedad, etc.
17
Para salidas analógicas podría pensarse en un Convertidor Digital a Analógico (DAC) pero no es común que se incluya en un microcontrolador. Lo que algunos microcontroladores incluyen es salidas con Modulación por Ancho de Pulso (PWM), las cuales, con pocos elementos externos pueden generar salidas analógicas.
1.6.
Tipos de Arquitecturas de Microcontroladores Pueden clasificarse por la arquitectura del procesador como RISC o CISC. Por el tamaño de los datos, se tienen microcontroladores de 4 bits, de 8 bits, de 16 bits y hasta de 32 bits. Con base en cómo se puede tener acceso a la memoria de código y datos, se tienen 2 modelos Arquitectura Von Neumann y Arquitectura Harvard. Otra clasificación proviene de la forma en que los datos internos son almacenados y manipulados dentro de la CPU. Los microcontroladores manipulan datos con ayuda de un programa de usuario, este esquema de clasificación distingue a las arquitecturas de acuerdo en cómo la CPU ejecuta las instrucciones y tiene acceso a los datos que involucra cada instrucción. Bajo este esquema, se tienen los siguientes modelos básicos: Pila Acumulador Registro-Memoria Registro-Registro(También conocida como Carga-Almacenamiento)
Operación: C = A –B A, B y C son variables, por lo tanto, se encuentran en memoria de datos.
18
1.7.
Familias populares de Microcontroladores
19
Marcas y modelos de microcontroladores mรกs populares
20
1.8.
Elección de un Microcontrolador
Microcontroladores Consideraciones Básicas: Prestaciones Gama baja: 4, 8 y 16 bits. Dedicados fundamentalmente a tareas de control (electrodomésticos, cabinas telefónicas, smart-cards, algunos periféricos de ordenadores, etc.) Generalmente son μC. Gama media: 16 y 32 bits. Tareas de control con cierto grado de procesamiento (control en automóvil, teléfonos móviles, PDA,…) Suelen ser P o C + periféricos integrados, y memoria externa. Gama alta: 32, 64 y 128 bits. Fundamentalmente procesamiento (ordenadores, videoconsolas, etc.) Casi en su totalidad son μP +circuitería periférica + memoria Tecnología–Alimentación (5v, 3.3v, 2.5v, 1.5v) Consumo (desde μW a decenas de W) Frecuencia (desde KHz a GHz)
1.9.
Criterios de selección. ¿Qué μP/μC uso? Requisitos y coste: Prestaciones:
¿Cumple
especificaciones?
Análisis
del
rendimiento medio o del peor caso (en esto influye tanto el hardware como el software) Tecnología: Alimentación, consumo Coste: (desde 2 USD a 1000 USD o más) Fiabilidad: Fundamental en aplicaciones de soporte vital Herramientas de desarrollo (precio, complejidad, prestaciones) Otros factores 21
Experiencia y soporte Compatibilidad Disponibilidad y segundas fuentes Repercusión del tiempo de desarrollo sobre los beneficios: Pequeños retrasos en el tiempo de puesta en el mercado pueden producir grandes pérdidas Vida media de un producto: La vida media de los productos tecnológicos es cada vez más corta (hoy en día, en torno a 2 años) Obsolescencia de la tecnología: La rápida evolución de la tecnología hace que los tiempos de desarrollo deban ser cortos para mantener competitividad. Ej: Hacemos un diseño de una agenda electrónica, que hoy es competitivo (con un ARM, a 100MHz, y un consumo de 10mW/MHz), pero tardamos dos años. Cuando salga al mercado puede no ser competitivo (podría haber ARMs a 300 Mhz y 5mW/MHz).
1.10. Lenguajes de programación El lenguaje nativo de estos microcontroladores es el ASM, y en el caso de la familia “16F” solo posee 35 instrucciones. Pero el ASM es un lenguaje que esta mucho más cerca del hardware que del programador, y gracias a la miniaturización que permite incorporar cada vez más memoria dentro de un microcontrolador sin aumentar prácticamente su costo, han surgido compiladores de lenguajes de alto nivel. Entre ellos se encuentran varios lenguajes BASIC y C. El BASIC resulta bastante más simple de aprender.
1.10.1. Lenguaje Máquina/ensamblador Lenguaje Máquina (código máquina) es la representación del programa tal como la entiende el microcontrolador.
22
El lenguaje ensamblador es una representación alfanumérica del lenguaje máquina, lo que facilita su lectura: Cada instrucción en lenguaje ensamblador se corresponde con una instrucción en código máquina: OR P1,#4 → 91 04 10 Un programa en lenguaje ensamblador es óptimo y rápido. Se requiere un buen conocimiento de la arquitectura del micro para programar en ensamblador.
1.10.1.1. Tipos de instrucciones: De transferencia de datos, aritméticas, lógicas, de tratamiento de bloques, de salto (condicional o incondicional), de control de interrupciones, de control de contadores, etc.
1.10.1.2. Formato de las Instrucciones: Arquitectura RISC (PIC de Microchip). Arquitectura CISC (Família 96 de Intel).
1.10.2. Intérpretes Un intérprete es un traductor de un lenguaje de alto nivel (próximo al lenguaje natural) a código máquina. El intérprete está residente en el microcontrolador. Ejecuta el programa leyendo cada sentencia en alto nivel traduciéndolas y ejecutándolas. Los dos más conocidos son el BASIC y el FORTH: El BASIC es más sencillo y legible. 23
EL FORTH es muy rápido por su proximidad al ensamblador.
1.10.3. Compiladores Se encargan de traducir todo el programa de alto nivel directamente a código máquina. El código máquina se pasa a la memoria del micro. El micro ejecuta el programa sin interpretado. Los compiladores más conocidos para los microcontroladores son: C, permite el acceso a la estructura del micro (registros, bits). BASIC compilado. PL/M de Intel. ADA para micros de 16 bits o más. FORTH compilado.
1.10.4. Simuladores Un simulador ejecuta el programa de un microcontrolador en un ordenador: Se puede ejecutar el programa paso a paso y ver exactamente qué pasa según el programa se ejecuta. Permiten ver y modificar el contenido de los registros, memoria, variables y ver cómo responde el programa. No soporta interrupciones reales. Evita el ciclo programado/borrado de la EPROM en el desarrollo de programas
24
1.10.5. Debuggers residentes Un debugger residente corre su programa dentro del propio micro, al mismo tiempo muestra el progreso de depuración en un máquina host (un PC). Tiene las mismas características que un simulador normal con la ventaja adicional de que el programa corre en un micro real.
1.10.6. Generadores de Código Ayudan a generar código de forma automática. Pueden generar código tanto en lenguajes de alto nivel (C) como de bajo nivel (ensamblador).
1.10.7. Emuladores Es la mejor opción para desarrollar un sistema, pero es cara. Un emulador en un sistema que sustituye al microcontrolador al mismo tiempo que está captando información. Sustituye al micro en el PCB (placa / físicamente). Da total información sobre lo que está pasando en la realidad y no requiere ningún recurso de la tarjeta que se analiza. El emulador puede venir con su propio visualizador o conectado a un PC.
1.11. Descripción de un PIC Los pines del PIC se dedican casi en su totalidad a los puertos que mencionábamos anteriormente. El resto (2 o más) son los encargados de proporcionar la alimentación al chip, y a veces, un sistema de RESET. Desde BASIC es posible saber si un pin esta en “estado alto” (conectado a 5V o a un “1” lógico) o en “estado bajo” (puesto a 0V o a un “0” lógico”). También se puede poner un pin de un puerto a “1” o “0”. De esta manera, 25
y mediante un rele, por ejemplo, se puede encender o apagar una luz, motor, maquina, etc. Uno de los microcontroladores m谩s famosos de todos los tiempos ha sido, sin duda, el PIC16F84A, que ya es considerado obsoleto. Un buen reemplazo es el PIC16F628A, y es el que utilizaremos en la mayor铆a de los ejemplos y proyectos que veamos. La disposici贸n de sus pines es la siguiente:
Distribuci贸n de pines de un Pic 16F628A
26
1.12. Herramientas de desarrollo
Software para el desarrollo de aplicaciones con microcontroladores
ISIS de Proteus: Edici贸n de Esquem谩ticos Simulaci贸n Visual ARES: Desarrollo de Circuitos Impresos
27
CAPITULO II
LOS MICROCNTROLADORES AVR Y EL DESARROLLO DE HARDWARE LIBRE
2.1. LA FAMILIA DE MICRO CONTROLADORES AVR
La familia de microcontroladores AVR es muy numerosa, incluye 71 dispositivos que comparten el núcleo, pero difieren en recursos.
En particular utilizaremos el ATMega8 o el ATMega16, cuyas características técnicas se resumen a continuación:
Características técnicas ATMega8 y ATMega16
2.1.1. Aspecto Externo ATMega8
Incluye 3 puertos, todas las terminales con una función alterna. PB –8 bits 28
PC –7 bits PD –8 bits3
ATMega8
2.1.2. Aspecto Externo ATMega16
Incluye 4 puertos, todas las terminales con una función alterna. PA – 8 bits PB – 8 bits PC – 8 bits PD – 8 bits4
29
ATMega16
30
Interior del Micro controlador (ATMega-8)
31
Interior del Micro controlador (ATMega-16)
32
2.1.3. AVR CPU CORE
CPU CORE
La principal función del CPU CORE es asegurar la correcta ejecución de programas. La CPU debe poder tener acceso a las memorias, realizar cálculos, controlar periféricos y manejar interrupciones. Para maximizar el rendimiento y paralelismo, el AVR usa una arquitectura Harvard – con memorias y buses separados para instrucciones y datos. La ALU soporta operaciones aritméticas y lógicas entre registros o entre un registro y una constante. Aunque también hay operaciones con un solo registro. Después de una operación aritmética, el registro de Estado (Status Register) es actualizado, para reflejar información acerca de la operación.
El Archivo de Registros contiene 32 registros de propósito general de 8 bits, habilitados para un acceso rápido. Seis de los 32 registros pueden ser usados como apuntadores de 16 bits para direccionamiento indirecto en el espacio de datos, habilitando cálculos de
33
direcciones eficientes. Para ello, estos registros se denominan X, Y y Z. El registro Z también puede usarse como apuntador a la memoria de programa.
Archivo de Registros
El flujo del programa lo determinan las instrucciones de saltos condicionales e incondicionales y llamadas a rutinas, que pueden abarcar completamente el espacio de direcciones.
Las instrucciones en la memoria de Programa son ejecutadas con una segmentación de dos etapas. Mientras una instrucción está siendo ejecutada, la siguiente es capturada de la memoria de programa. Este concepto hace que se produzca una instrucción por cada ciclo de reloj.
34
Con esto aparenta que las instrucciones solo requieren de un ciclo de reloj (excepto los saltos). Generando un rendimiento aproximado a 1 MIPS por MHz de la frecuencia de trabajo del oscilador.
Para la ejecuci贸n, la duraci贸n del ciclo es suficiente para permitir la lectura de registros, la operaci贸n de la ALU y la escritura en el registro destino.
35
AVR CPU CORE Mapa de memoria
36
2.1.4. Memoria de programa.
Espacio continuo de memoria Flash cuyo tamaño varía entre procesadores, para el ATMega8 es de 8 Kbytes (organizados como 4 K x 16 bits) y para el ATMega16 es de 16Kbytes (organizados como 8 K x 16 bits). Soporta hasta 10,000 ciclos de escritura/borrado.
La memoria se puede particionar en una sección para aplicación y una sección de arranque, donde podría manejarse un cargador para auto programación (Boot Loader Support – Read – While – Write Self - Programming).
En el espacio de almacenamiento se incluyen a los Vectores de Interrupciones, iniciando en la dirección $000. El número de vectores, en la familia AVR, varia de procesador a procesador, en función de los recursos existentes.
Programa( $ 1FFF , en ATMega16 )
37
Memoria de Programa Vectores de Interrupci贸n en el ATmega8
38
Memoria de Programa Vectores de Interrupci贸n en el ATmega1618
2.1.5. Memoria SRAM de Datos Es un espacio de 1120 localidades de 8 bits e incluyen: Un Archivo de Registros de 32 localidades. 64 Registros I/O. 1024 localidades de prop贸sito general.
39
Memoria SRAM de Datos
2.1.6. Archivo de Registros
El archivo de Registros está optimizado para el repertorio de instrucciones AVR. Las instrucciones que operan sobre el Archivo de Registros tienen acceso casi a todos ellos, y la mayoría se ejecutan en 1 ciclo de reloj. Cada registro tienen una dirección que le permite ser tratado como cualquier otra localidad de RAM (0x000–0x01F), utilizando instrucciones LD y SD. De R26 a R31 pueden usarse como apuntadores para direccionamiento indirecto.
40
Archivo de Registros
2.1.7. Registros I/O
Son 64 Registros e incluyen a los Puertos de Entrada/Salida, así como registros para la configuración, el control y el estado de los periféricos con que cuenta el ATmega8. Se tiene acceso a los registros I/O con las instrucciones IN y OUT, intercambiando datos con el Archivo de Registros. Con estas instrucciones deben usarse las direcciones 0x00 - 0x3F. Los registros I/O pueden ser tratados como memoria, con las instrucciones LD y ST (direcciones 0x20 -0x5F). Los Registros I/O en el rango 0x00 -0x1F son accesibles por bit. Para modificarse, con instrucciones SBI y CBI o para evaluarse, a través de las instrucciones SBIS y SBIC.
41
2.1.8. Registros I/O (Parcial)
La lista completa de registros I/O está en las Hojas de Especificaciones. Los registros I/O para el manejo de periféricos, se revisarán en sus correspondientes secciones.
2.1.9. Registro de ESTADO (SREG: 0x3F o 0x5F)
Bit Read/Write
Valor inicial
I: Habilitador global de Interrupciones, con un 1 lógico, las interrupciones son habilitadas. T: Para respaldo de un bit, con la instrucción BLD para Carga y BST para Almacenamiento. 42
H: Bandera de acarreo de los 4 bits inferiores (Half) S: Bit de signo V: Bandera de Sobre flujo, en operaciones de complemento a dos.
N: Bandera de Negativo Z: Bandera de Cero C: Bandera de Acarreo
Se generan con operaciones Aritméticas y lógicas
2.1.10. Apuntador de Pila (SP)
$3E
$3D
La pila es implementada en el espacio de propósito general (que es de 1024 bytes). Es usada para almacenamiento temporal de variables (instrucciones PUSH y POP) o durante la llamada de subrutinas o el manejo de interrupciones. El registro SP es el apuntador al tope de la pila. Realmente el SP se compone de 2 registros, para la parte alta (SPH) y para la parte baja (SPL), esto para direccionar al espacio completo de memoria. La pila tiene un crecimiento hacia abajo, es decir, de las direcciones altas de memoria a las direcciones bajas. Después de un reset, el apuntador de Pila tiene el valor de 0x0000, por lo que debe ser inicializado dentro del programa (con 0x045F), para que realice un almacenamiento dentro de un espacio válido.
43
2.1.11. Acceso al espacio de Propósito General
La arquitectura AVR es del tipo Registro –Registro. Existen diversas instrucciones para cargas o almacenamientos, ya sean de manera directa o indirecta.
44
La etapa de ejecución de un acceso a memoria, ya sea carga o almacenamiento, requiere de dos ciclos de reloj.
2.1.12. Memoria EEPROM para datos
Espacio no volátil para el almacenamiento de datos, cuyo tamaño varía entre procesadores. Para el ATMega8 y ATMega16 es de 512 bytes. La memoria EEPROM está en un espacio independiente y se requiere del uso de 3 registros I/O para su acceso: EEAR -Para la dirección (0x1F, 0x1E).
EEDR -Para el dato (0x1D)
EECR -Para el control (0x1C)
45
2.1.13. Bits del registro de CONTROL:
EERIE: EEPROM Ready Interrupt Enable En alto habilita la interrupción por EEPROM. La EEPROM genera una interrupción cuando EEWE es limpiado. EEMWE: EEPROM Master Write Enable Determina si la puesta en alto de EEWE producirá una escritura en la EEPROM. Al ponerse en alto, se cuenta con 4 ciclos para iniciar la escritura con EEWE, de lo contrario se limpiará automáticamente por Hardware. EEWE: EEPROM Write Enable Debe ponerse en alto para dar inicio a un ciclo de escritura. Se limpiará automáticamente por Hardware al finalizar la escritura. Un programa de usuario puede monitorear este bit o si se pone en alto a EERIE se producirá una interrupción. EERE: EEPROM Read Enable Debe ponerse en alto para un ciclo de lectura, se limpiará automáticamente por Hardware. El dato leído está disponible de manera inmediata. No es posible realizar una lectura si hay una escritura en proceso.
Rutina de Escritura en EEPROM: ; El dato a escribir está en R16 ; Se escribirá en las direcciones R18:R17 EEPROM_write: ; Asegura que no hay escritura en proceso sbicEECR,EEWE rjmpEEPROM_write ; Establece la dirección 46
outEEARH, r18 outEEARL, r17 ; Coloca el dato outEEDR,r16 ; Pone en alto al habilitador maestro sbiEECR,EEMWE ; Inicia la escritura sbiEECR,EEWE ret
Funci贸n de Escritura en EEPROM: // Recibe el dato y la direcci贸n a escribir Void EEPROM_write (unsignedchardato, unsignedintdireccion) { // Asegura que no hay escritura en proceso while( EECR & 1 << EEWE ); // Establece la direcci贸n EEAR = direccion; // Coloca el dato EEDR = dato; // Pone en alto al habilitador maestro EECR |= ( 1 << EEMWE ); // Inicia la escritura 47
EECR |= ( 1 << EEWE );
Rutina de Lectura en EEPROM: ; El dato a leer se dejará en R16 ; Se leerá de las direcciones R18:R17 EEPROM_read: ; Asegura que no hay una escritura en proceso sbicEECR,EEWE rjmpEEPROM_read ; Establece la dirección outEEARH, r18 outEEARL, r17 ; Inicia la lectura sbiEECR,EERE ; Coloca el dato in r16, EEDR ret
Función de Lectura en EEPROM: // Regresa el dato leído, se recibe la dirección unsignedcharEEPROM_read(unsignedintdireccion) {// Asegura que no hay una escritura en proceso while( EECR & 1 << EEWE); 48
// Establece la dirección EEAR = direccion; // Inicia la lectura EECR |= ( 1 << EERE ); // Regresa el dato Return EEDR;}
Puertos de Entrada/Salida en el ATMega8 Incluye 3 puertos, todas las terminales con una función alterna. •PB –8 bits •PC –7 bits •PD –8 bits Las funciones alternas se revisarán conforme se vayan revisando los periféricos que las requieren.
49
Puertos de Entrada/Salida en elATMega8 Incluye 3 puertos, todas las terminales con una función alterna. •PB –8 bits •PC –7 bits •PD –8 bits Las funciones alternas se revisarán conforme se vayan revisando los periféricos que las requieren.
50
2.1.14. Puertos de Entrada/Salida
Para cada puerto se manejan tres registros, dentro del espacio de registros I/O Un registro de lectura/escritura sobre un lacth, conectado a la terminal del puerto (PORTx). En este se escribe, cuando el puerto est谩 configurado como salida. Un registro de lectura/escritura que define la direcci贸n del puerto (DDRx). Las direcciones pueden configurarse de manera independiente, para cada terminal. 1. Salida 2. Entrada Un registro solo de lectura, para hacer lecturas directas en las terminales de los puertos (PINx).
51
Registros para el manejo de puertos
Registros en el ATMega8
Registros en el ATMega16
Puertos de Entrada/Salida El bit PUD (Pull-Up disable) estรก en el registro SFIOR (Special Function IO Register).
52
Puertos de Entrada/Salida ( Configuraciones )
53
Ejemplo en ensamblador ... ; Se pueden tener diferentes combinaciones en ; un puerto Ldir 16, 0B11000011 Ldir 17, 0B00001111 Out PORTB,r16 Out DDRB,r17 ; Inserta noppara sincronización nop ; Lee las terminales del puerto in r16,PINB ...
Ejemplo en lenguaje C Unsigned char i; ... //Se pueden tener diferentes combinaciones en //un puerto PORTB = 0B11000011; DDRB = 0B00001111; // Inserta noppara sincronización asm(“nop”); 54
/* Lee las terminales del puerto */ i = PINB; ...
2.1.15. Sistema de Interrupciones
Una interrupción es la ocurrencia de una condición –un evento –que ocasiona la suspensión temporal de un programa mientras se atiende al evento con otro programa. Una vez que se concluya la atención a la interrupción, se continúa con la ejecución del programa principal. Al utilizar un sistema manejador de interrupciones, se tiene la ilusión de que se están haciendo diferentes tareas en forma simultánea. Al programa que trata con una interrupción se le conoce como rutina de servicio a la interrupción (ISR) o manejador de interrupción. La rutina de atención para una interrupción debe colocarse en una dirección preestablecida por Hardware, formando parte de un vector de interrupciones. Un aspecto importante es que los eventos pueden ocurrir en cualquier momento, es decir, en forma asíncrona.
55
2.1.16. Interrupciones en los AVRs
Por inicialización o Reset Dos interrupciones externas (tres en el ATMega16) Siete interrupciones por los temporizadores (ocho en el ATMega16), pueden ser por comparación, captura o desbordamiento. Una al completar una transferencia serial (puerto SPI) Tres debidas el puerto serie, por transmisión, recepción o buffer vacío (USRAT) Una por el convertidor analógico digital. Una al finalizar una escritura en EEPROM. Una por el comparador analógico. Una por la interfaz serial a dos hilos (TWI). Una para la escritura en memoria de programa. Las interrupciones no están activas, después de un reset. Su activación requiere la puesta en alto del bit I, en el registro de estado (SREG), además de las habilitaciones individuales para cada periférico incorporado en el microcontrolador (se revisarán según se revisen los recursos).
56
Además del Reset, se tienen 18 fuentes de interrupción, con direcciones diferentes, en el vector de interrupciones. Al generarse una interrupción, el PC es almacenado en la pila y toma el valor de una entrada en el vector de interrupciones (según sea la interrupción). Además de desactivar al bit I para no aceptar mas interrupciones. Una rutina de atención a interrupciones debe terminar con la instrucción RETI, la cual recupera el valor de la pila para el PC y ajusta el valor del bit I.
Vectores de Interrupción en el ATmega8
57
Esta es una distribuci贸n t铆pica, el ATMega8 puede ubicar un auto-cargador en su memoria de programa. Si se utiliza, las ubicaciones van a cambiar.
Vectores de Interrupci贸n en el ATmega16
El ATMega16 tambi茅n puede ubicar un auto-cargador en su memoria de programa.
58
Manejo de Interrupciones (para el ATMega8) ; Un programa generalmente inicia en la dirección 0 Org 0x000 rjmpPrincipal
; Se evita el vector de interrupciones
org 0x001 rjmp Externa_0
; Bifurca a su ISR correspondiente
org 0x002 rjmp Externa_1
; Bifurca a su ISR correspondiente
; Si fuera necesario, acá estarían otras bifurcaciones Org 0x013 Principal: . . .
; Acá estará el código principal
...
; Debe activar las interrupciones
...
;
Posterior al código principal, deben situarse las ISRs Externa_0:
; Respuesta a la interrupción externa 0 ... RETI
Externa_1:
; Debe terminar con RETI ; Respuesta a la interrupción externa 1
... RETI
; Debe terminar con RETI
Manejo de Interrupciones (para el ATMega16) ; Un programa generalmente inicia en la dirección 0 59
Org 0x000 Jmp Principal
; Se evita el vector de interrupciones
Org 0x002 Jmp Externa_0
; Bifurca a su ISR correspondiente
org0 x004 jmpExterna_1
; Bifurca a su ISR correspondiente
; Si fuera necesario, acá estarían otras bifurcaciones org0 x02A Principal: . . .; Acá estará el código principal . . .; Debe activar las interrupciones . . .; Posterior al código principal, deben situarse las ISRs Externa_0:
; Respuesta a la interrupción externa 0. . .
RETI
; Debe terminar con RETIExterna_1:; Respuesta a la
interrupción externa 1. . . RETI
; Debe terminar con RETI
Manejo de Interrupciones (Alto Nivel) #include <avr/io.h>// Entradas y salidas #include <avr/interrupt.h>// Interrupciones // Las ISRs se ubican antes del programa principal ISR (INT0_vect)// Servicio a la interrupción externa 0 { .... }
60
ISR (INT1_vect)// Servicio a la interrupción externa 1 { .... } Int main(void)// Programa Principal { . . . . .// Debe activar las interrupciones } En C, todas las funciones de atención a interrupciones se llaman ISR, difieren en el argumento, que corresponde a la etiqueta proporcionada por el fabricante, seguida de la palabra vect. Si la etiqueta es de dos palabras, debe usarse el guión bajo, por ejemplo: TIMER2_COMP_vect.
2.1.17. Sistema de Inicialización.
Power-on Reset. El MCU es inicializado cuando el voltaje de la fuente está por abajo del voltaje de umbral de encendido (VPOT). Reset Externo. El MCU es inicializado cuando un nivel bajo está presente en la terminal RESET por un tiempo mayor que la longitud mínima del pulso (trst). Watch dog Reset. El MCU es inicializado cuando el Watch dog Timer está habilitado y su periodo termina. Brown-out Reset. El MCU es inicializado cuando el detector de reducción de voltaje está habilitado y el voltaje VCC de la fuente va por debajo del umbral establecido (VBOT). Se tienen las siguientes fuentes de Inicialización (Reset): JTAG AVR Reset: El MCU es inicializado tan pronto como hay un un o lógico en el Registro de Reset, del sistema JTAG (Solo en ATMega-16).
61
Sistema de Inicializaci贸n.
62
Sistema de Inicialización.
En el registro MCUSCR (0x34) se registra la condición de reset, poniendo al bit correspondiente en alto.
Una vez que el MCU se recupera de una condición de Reset, espera un tiempo de establecimiento (Tout –con un valor típico de 4 ms), antes de recuperar al sistema, para garantizar que los registros tienen su valor inicial.
63
Inicio con Reset conectado a VCC
Reset extendido de manera externa.
Operaci贸n de un reset externo.
64
2.1.18. Inicialización por Brown-out
outSe refiere a una inicialización cuando el voltaje de alimentación (Vcc) cae por debajo de un umbral pre-establecido (VBOT).
Dentro de los Bits de configuración del ATMega8 existen 2 de interés: BODEN: Habilita la detección (Brown-out detection) BODLEVEL: Sin programar, el umbral es de 2.7 V Programado, el umbral es de 4.0 V
2.1.19. Inicialización por Watchdog
Cuando el temporizador del Watchdog se desborda, genera un pulso corto con una duración de 1 ciclo de reloj. El flanco de subida provoca el reset interno y el de caída el inicio del tiempo de establecimiento.
65
2.1.20. Sistema del reloj.
Se tienen diferentes fuentes para manejar al oscilador interno y a la vez, la se帽ales de reloj se distribuyen por los diferentes m贸dulos:
66
La fuente de reloj se selecciona con 4 bits de configuración internos (no corresponden a algún registro). Se tienen las opciones: Estos bits se deben definir durante el proceso de programación del microcontrolador. Existen otro par de bits (SUT, Set up Time), que junto con los bits CKSEL, ajustan un retardo inicial en la operación del oscilador, después de un reset.
2.2.
Ventanas de programación, usando al AVR Studio y al AVR Dragon.
67
2.3.
Ventanas de PonyProg
68
Nota: PonyProges una herramienta solo de descarga, puede utilizarse en conjunci贸n con programadores que aprovechan la programaci贸n in-systemde los microcontroladores AVR.
2.4.
Cristal/Resonador
2.4.1. Cristal/Resonador Externo
(1) No debe usarse con cristales, solo resonadores cer谩micos.
69
2.4.2. Cristal/Resonador de Baja Frecuencia
Para usar un cristal de 32.768 Khz, el cual proporciona la base para un contador de tiempo real, debe usarse CKSEL = â&#x20AC;&#x153;1001â&#x20AC;?. Programando CKOPT se utilizan los capacitores internos. En caso contrario se recomiendan capacitores con un valor nominal de 36 pF. Los tiempos de arranque bajo estas opciones son:
70
2.4.3. Oscilador RC Externo
La frecuencia se determina como f = 1/(3RC). C debe ser al menos de 22 pF.
Los tiempos de arranque bajo estas opciones son:
71
2.4.4. Oscilador RC Calibrado Interno
Se considera un voltaje de 5.0 volts y una temperatura de 25 °C.
Sus tiempos de arranque:
Los dispositivos se venden con CKSEL = “0001” y SUT = “10”
2.4.5. Reloj Externo
72
Sus tiempos de arranque:
2.4.6. Distribuciรณn del reloj
CPU. Ruteado al CORE AVR: Incluyendo archivo de registros, registro de Estado, Memoria de datos, Stack Pointer, etc.
Flash. Controla las funciones relacionadas con la memoria FLASH, trabaja simultรกneamente con la CPU
ADC. Trabaja en un dominio dedicado al ADC, con el objetivo de reducir el ruido generado por interferencia digital y mejorar las conversiones.
I/O. Es usado por los principales mรณdulos I/O: Temporizadores, SPI y USART. Ademรกs de emplearlo en el mรณdulo de interrupciones externas.
73
ASY. Permite al Timer/Counter asíncrono sincronizarse directamente desde un cristal externo de 32 kHz. Esta frecuencia permite usar al Timer/Counter como un contador de tiempo real aún cuando el dispositivo está en modo SLEEP.
2.5.
Administración de la Potencia y modos SLEEP
Los modos SLEEP habilitan a la aplicación a apagar módulos sin usar en el MCU y por lo tanto, ahorrar energía. El AVR tiene 5 modos SLEEP y para entrar en alguno de ellos, el bit SE (SLEEP enable) del registro MCUCR (MCU Control Register) debe ponerse en alto.
Los bits SM2, SM1 y SM0 de MCUCR determinan el modo:
Nota: 1. El modo Stand by está disponible solo con cristales o resonadores externos. El modo Extended Stand by no está disponible en el ATMega8.
74
75
CAPÍTULO III
DISEÑO DE UN MÓDULO PROGRAMABLE DE APLICACIÓN UNIVERSAL CON CUATRO SALIDADS PARA ACTUADORES Y CUATRO ENTRADAS PARA SENSORES.
3.1. Introducción. El proyecto se constituirá en una plataforma open-hardware basada en una sencilla placa con entradas y salidas (E/S), analógicas y digitales, y en un entorno de desarrollo que implementa el lenguaje Processing/Wiring. Su corazón es el chip Atmega8, un chip sencillo y de bajo coste que permite el desarrollo de múltiples diseños. Al ser open-hardware tanto su diseño como su distribución será libre. Es decir, puede utilizarse libremente para desarrollar cualquier tipo de proyecto sin tener que adquirir ningún tipo de licencia.
3.2. Campos de aplicación del proyecto El proyecto puede utilizarse en el desarrollo de objetos interactivos autónomos o puede conectarse a un PC a través del puerto serie utilizando lenguajes como Flash, Processing, MaxMSP, etc.... Las posibilidades de realizar desarrollos basados en este proyecto tienen como limite la imaginación. Asimismo, su sencillez y su bajo coste, recomiendan su uso como elemento de aprendizaje e iniciación en el mundo de la electrónica digital.
3.3. La placa electrónica. Se ha concebido como una placa básica, y utiliza un interfaz RS232. Este interfaz puede ser utilizada, además de para la programación de la placa, para comunicarse con otros elementos externos que utilicen el puerto serie como por ejemplo un PC. 76
Esta placa es muy sencilla de ensamblar. Su montaje puede ser incluso un ejercicio práctico que nos enseñe a dar los primeros pasos en al mundo de la electrónica digital.
3.4. Diseño de la electrónica de la Placa serie de una capa
77
3.5. Diseño del PCB
3.6. Listado de Materiales LISTA DE PARTES PARA MÓDULO SERIAL PROGRAMABLE POSI CIÓ N
OBSERVACI VALOR
DESCRIPCIÓN ceramic
C1
22pF (22 pico Faradios)
22pF (22 pico Faradios)
ÓN
disc
capacitor ceramic
C2
DETALLE
disc
capacitor ceramic
or
100nF (100 nano Faradios polyester C3
- or 0.1 micro Faradios)
capacitor ceramic
or
100nF (100 nano Faradios polyester C4
- or 0.1 micro Faradios)
C5
100μF
(100
capacitor
micro electrolytic
16volts
(or radial-lead 78
Faradios)
capacitor ceramic
more: 25v) or
100nF (100 nano Faradios polyester C6
- or 0.1 micro Faradios)
capacitor ceramic
or
100nF (100 nano Faradios polyester C7
- or 0.1 micro Faradios) 100ÎźF
C8
(100
capacitor
radial-lead
micro condensador
Faradiosios)
16volts
(o
electrolitico
mas: 25v)
condensador
16volts
electrolitico
no more:
C9
10ÎźF (10 micro Faradios)
polarizado
50v)
D1
1N4004
diodo
DO41-10
D2
1N4148
diodo
DO35-10
D3
1N4148
diodo
DO35-10
radial-lead (or
25v, radial-lead
DC1 2.1mm. DC DC1
power jack IC1 ATMEGA8 (or
IC1
ATMEGA168)
28P3 package
Tension IC2
7805C
ICSP 2x3
Regulator male pin header
ICSP 0.1" (or 2.54 PORT
J1
1x8
female pin header mm.)
D7)
0.1" (or 2.54 PORT J2
1x6
female pin header mm.)
1x8
female pin header mm.)
C(A0-
A5)
0.1" (or 2.54 PORT J3
D(D0-
B(D8-
D13)
right angle pin 0.1" (or 2.54 JP0
1x3
header
mm.)
right angle pin 0.1" (or 2.54 JP4
1x2
header
mm.)
AUTO RESET 79
(silver)brown, black, L1
100μH
leaded inductor
LED 0
choose 3 mm.
LED
LED 1
3 mm.
LED
LED
LED 14
LED
1x6
female pin header
Rx Led a Tx Led a
color choose
3 mm.
a
color choose
3 mm.
golden
color choose
LED 13
axial leaded
color
brown,
Pin13 Led a Power Led
POW ER Q1
16 MHz crystal 1/4
R1
1kohm (1.0 kilo ohm)
Resistencia
±5% 1/4
R2
1kohm (1.0 kilo ohm)
Resistencia
±5% 1/4
R3
1kohm (1.0 kilo ohm)
Resistencia
±5% 1/4
R4
1kohm (1.0 kilo ohm)
Resistencia
±5% 1/4
R5
10kohms (10.0 kilo ohms) Resistencia
±5% 1/4
R6
1kohm (1.0 kilo ohm)
Resistencia
±5% 1/4
R7
10kohms (10.0 kilo ohms) Resistencia
±5% 1/4
R8
10kohms (10.0 kilo ohms) Resistencia
±5% 1/4
R9
4k7ohms (4.7 kilo ohms)
Resistencia
R10
10kohms (10.0 kilo ohms) Resistencia
±5% 1/4
Watt, brown,
black,
red, gold Watt, brown,
black,
red, gold Watt, brown,
black,
red, gold Watt, brown,
black,
red, gold Watt, brown,
black,
orange, gold Watt, brown,
black,
red, gold Watt, brown,
black,
orange, gold Watt, brown,
black,
orange, gold Watt, yellow, violet, red, gold Watt, brown,
black, 80
±5% 1/4 R11
10kohms (10.0 kilo ohms) Resistencia
S1
6x6 mm., 4 terminals
orange, gold Watt, brown,
±5%
Switch Tactile
black,
orange, gold B3F-10XX
NPN general purpose T1
BC547
Transistor
transistor
TO92
PNP general purpose T2
BC557 9
X1
PIN
Transistor
transistor
HEMBRA D-SUB
CONECTOR DE PC
DE-9
CONNECTOR
jump
0.1"
er
mm.)
jump
0.1"
er
mm.)
TO92
(or
2.54
(or
2.54
CONECTOR
VER DETALLE DE LOS ELEMENTOS
EN
EL
ADJUNTO GRAFICO
81
Vista de distribuci贸n real de la placa final.
3.7. Implementaci贸n del prototipo.
82
3.7. Con que elementos podemos interactuar.
La placa circuito está basada en el chip Atmega8. Alrededor de este se monta toda la circuitería necesaria para poder sacarle el máximo partido. Pin de referencia analógica Señal de tierra digital Pines digitales 3-13 Pines digitales 1-2 / entrada y salida del puerto serie: TX/RX Botón de reset Entrada del circuito del programador serie Pines de entrada analógica 0-5 Pines de alimentación y tierra 83
Entrada de la fuente de alimentación externa (9-12V DC), X1 Conmuta entre fuente de alimentación externa o alimentación a través del puerto serie o SV1 Puerto serial
3.8. Puesta en marcha El objetivo del presente documento es describir todos los pasos básicos necesarios para comenzar a trabajar de forma rápida y sencilla con la placa.
3.8.1. Cable de comunicaciones (serie/usb) El cable serie debe tener en sus extremos dos conectores de tipo DB-9. Uno macho (para conectar la placa) y otro hembra (para conectar al PC). Es muy importante comprobar que el cable serie NO sea del tipo NULL MODEM ya que no nos sirve.
3.8.2. Fuente de alimentación (opcional) Se puede utilizar una fuente de alimentación de corriente continua o una pila/batería con el conector apropiado. Se recomienda no obstante el uso de la primera ya que no tenemos que estar pendientes de sustituir las pilas en caso de que se queden sin carga.
En ambos casos el voltaje de la fuente puede ser de entre 6 y 25 voltios, y la polaridad del conector debe ser como se indica en la imagen.
3.8.3. PC / portátil + adaptador serie-usb (opcional) Para programar la placa es necesario disponer de un PC o portátil con puerto serie y/o USB al que conectarla. Es necesario tener en cuenta la disponibilidad de puertos serie/USB de nuestro equipo. 84
Hoy en día la mayoría de los PC-s disponen de puertos serie y USB, sin embargo suele ser difícil encontrar un portátil con puerto serie. En nuestro caso la placa tiene un puerto serie y de no disponer de puerto serie se hace necesario contar con un cable conversor serie-USB.
3.9. Código necesario para el arranque o bootloader. /**********************************************************/ /* Serial Bootloader for Atmel mega8 AVR Controller /*
*/
/* ATmegaBOOT.c /*
*/ */
/* Copyright (c) 2003, Jason P. Kyle /*
*/ */
/* Hacked by DojoCorp - ZGZ - MMX - IVR
*/
/* Hacked by David A. Mellis /*
*/
*/ */
/* This program is free software; you can redistribute it */ /* and/or modify it under the terms of the GNU General /* Public License as published by the Free Software /* Foundation; either version 2 of the License, or /* (at your option) any later version. /*
*/ */
*/
*/ */
/* This program is distributed in the hope that it will */ /* be useful, but WITHOUT ANY WARRANTY; without even the */ /* implied warranty of MERCHANTABILITY or FITNESS FOR A */ /* PARTICULAR PURPOSE. See the GNU General Public /* License for more details. /*
*/
*/ */
85
/* You should have received a copy of the GNU General
*/
/* Public License along with this program; if not, write */ /* to the Free Software Foundation, Inc.,
*/
/* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /*
*/
/* Licence can be viewed at
*/
/* http://www.fsf.org/licenses/gpl.txt /*
*/ */
/* Target = Atmel AVR m8
*/
/**********************************************************/ #include <inttypes.h> #include <avr/io.h> #include <avr/pgmspace.h> #include <avr/eeprom.h> #include <avr/interrupt.h> #include <avr/delay.h> //#define F_CPU
16000000
/* We, Malmoitians, like slow interaction * there fore the slow baud rate ;-) */ //#define BAUD_RATE
9600
/* 6.000.000 is more or less 8 seconds at the * speed configured here */ //#define MAX_TIME_COUNT
6000000
#define MAX_TIME_COUNT (F_CPU>>1) ///#define MAX_TIME_COUNT_MORATORY
1600000
/* SW_MAJOR and MINOR needs to be updated from time to time to avoid warning message from AVR Studio */ 86
#define HW_VER 0x02 #define SW_MAJOR 0x01 #define SW_MINOR 0x12 // AVR-GCC compiler compatibility // avr-gcc compiler v3.1.x and older doesn't support outb() and inb() //
if necessary, convert outb and inb to outp and inp
#ifndef outb #define outb(sfr,val) (_SFR_BYTE(sfr) = (val)) #endif #ifndef inb #define inb(sfr) _SFR_BYTE(sfr) #endif /* defines for future compatibility */ #ifndef cbi #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) #endif #ifndef sbi #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) #endif /* Adjust to suit whatever pin your hardware uses to enter the bootloader */ #define eeprom_rb(addr) eeprom_read_byte ((uint8_t *)(addr)) #define eeprom_rw(addr) eeprom_read_word ((uint16_t *)(addr)) #define eeprom_wb(addr, val) eeprom_write_byte ((uint8_t *)(addr), (uint8_t)(val)) /* Onboard LED is connected to pin PB5 */ #define LED_DDR DDRB #define LED_PORT PORTB #define LED_PIN PINB #define LED
PINB5
87
#define SIG1
0x1E
// Yep, Atmel is the only manufacturer of AVR micros. Single
source :( #define SIG2 0x93 #define SIG3 0x07 #define PAGE_SIZE
0x20U //32 words
void putch(char); char getch(void); void getNch(uint8_t); void byte_response(uint8_t); void nothing_response(void); union address_union { uint16_t word; uint8_t byte[2]; } address; union length_union { uint16_t word; uint8_t byte[2]; } length; struct flags_struct { unsigned eeprom : 1; unsigned rampz : 1; } flags; uint8_t buff[256]; //uint8_t address_high; uint8_t pagesz=0x80; uint8_t i; //uint8_t bootuart0=0,bootuart1=0; void (*app_start)(void) = 0x0000; 88
int main(void) { uint8_t ch,ch2; uint16_t w; //cbi(BL_DDR,BL); //sbi(BL_PORT,BL); asm volatile("nop\n\t"); /* check if flash is programmed already, if not start bootloader anyway */ //if(pgm_read_byte_near(0x0000) != 0xFF) { /* check if bootloader pin is set low */ //if(bit_is_set(BL_PIN,BL)) app_start(); //} /* initialize UART(s) depending on CPU defined */ /* m8 */ UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8;
// set baud rate
UBRRL = (((F_CPU/BAUD_RATE)/16)-1); UCSRB = (1<<RXEN)|(1<<TXEN); // enable Rx & Tx UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // config USART; 8N1 //UBRRL = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1); //UBRRH = (F_CPU/(BAUD_RATE*16L)-1) >> 8; //UCSRA = 0x00; //UCSRC = 0x86; //UCSRB = _BV(TXEN)|_BV(RXEN); /* this was giving uisp problems, so I removed it; without it, the boot works on with uisp and avrdude on the mac (at least). */ //putch('\0'); //uint32_t l; //uint32_t time_count; 89
//time_count=0; /* set LED pin as output */ sbi(LED_DDR,LED); for (i = 0; i < 16; i++) { outb(LED_PORT, inb(LED_PORT) ^ _BV(LED)); _delay_loop_2(0); }
//for (l=0; l<40000000; l++) //outb(LED_PORT, inb(LED_PORT) ^= _BV(LED)); /* flash onboard LED three times to signal entering of bootloader */ //for(i=0; i<3; ++i) { //for(l=0; l<40000000; ++l); //sbi(LED_PORT,LED); //for(l=0; l<40000000; ++l); //cbi(LED_PORT,LED); //} /* see comment at previous call to putch() */ //putch('\0'); // this line is needed for the synchronization of the programmer /* forever */ for (;;) { //if((inb(UCSRA) & _BV(RXC))){ /* get character from UART */ ch = getch();
/* A bunch of if...else if... gives smaller code than switch...case ! */
/* Hello is anyone home ? */ if(ch=='0') { 90
nothing_response(); }
/* Request programmer ID */ /* Not using PROGMEM string due to boot block in m128 being beyond 64kB boundry */ /* Would need to selectively manipulate RAMPZ, and it's only 9 characters anyway so who cares. */ else if(ch=='1') { if (getch() == ' ') { putch(0x14); putch('A'); putch('V'); putch('R'); putch(' '); putch('I'); putch('S'); putch('P'); putch(0x10); } }
/* AVR ISP/STK500 board commands DON'T CARE so default nothing_response */ else if(ch=='@') { ch2 = getch(); if (ch2>0x85) getch(); nothing_response(); }
91
/* AVR ISP/STK500 board requests */ else if(ch=='A') { ch2 = getch(); if(ch2==0x80) byte_response(HW_VER);
// Hardware version
else if(ch2==0x81) byte_response(SW_MAJOR); // Software major version else if(ch2==0x82) byte_response(SW_MINOR); // Software minor version //else if(ch2==0x98) byte_response(0x03);
// Unknown but seems to
be required by avr studio 3.56 else byte_response(0x00);
// Covers various unnecessary
responses we don't care about }
/* Device Parameters DON'T CARE, DEVICE IS FIXED */ else if(ch=='B') { getNch(20); nothing_response(); }
/* Parallel programming stuff DON'T CARE */ else if(ch=='E') { getNch(5); nothing_response(); }
/* Enter programming mode */ else if(ch=='P') { nothing_response(); // FIXME: modified only here by DojoCorp, Mumbai, India, 20050626
92
//time_count=0; // exted the delay once entered prog.mode }
/* Leave programming mode */ else if(ch=='Q') { nothing_response(); //time_count=MAX_TIME_COUNT_MORATORY;
// once the
programming is done, // we should start the application // but uisp has problems with this, // therefore we just change the times // and give the programmer 1 sec to react }
/* Erase device, don't care as we will erase one page at a time anyway. */ else if(ch=='R') { nothing_response(); }
/* Set address, little endian. EEPROM in bytes, FLASH in words */ /* Perhaps extra address bytes may be added in future to support > 128kB FLASH. */ /* This might explain why little endian was used here, big endian used everywhere else. */ else if(ch=='U') { address.byte[0] = getch(); 93
address.byte[1] = getch(); nothing_response(); }
/* Universal SPI programming command, disabled. Would be used for fuses and lock bits. */ else if(ch=='V') { getNch(4); byte_response(0x00); }
/* Write memory, length is big endian and is in bytes */ else if(ch=='d') { length.byte[1] = getch(); length.byte[0] = getch(); flags.eeprom = 0; if (getch() == 'E') flags.eeprom = 1; for (w=0;w<length.word;w++) { buff[w] = getch();
// Store data in buffer, can't keep up with
serial data stream whilst programming pages } if (getch() == ' ') { if (flags.eeprom) {
//Write to EEPROM one byte
at a time for(w=0;w<length.word;w++) { eeprom_wb(address.word,buff[w]); address.word++; } } else {
//Write to FLASH one page at
a time 94
//if (address.byte[1]>127) address_high = 0x01; //Only possible with m128, m256 will need 3rd address byte. FIXME //else address_high = 0x00;
//address.word = address.word << 1;
//address * 2 ->
byte location //if ((length.byte[0] & 0x01)) length.word++; //Even up an odd number of bytes cli();
//Disable interrupts, just to be sure while(bit_is_set(EECR,EEWE));
//Wait for
previous EEPROM writes to complete asm volatile( "clr r17
\n\t" //page_word_count
"lds r30,address
\n\t" //Address of FLASH
location (in words) "lds r31,address+1 \n\t" "lsl r30
\n\t" //address * 2 -> byte
"rol r31
\n\t"
location
"ldi r28,lo8(buff) \n\t" //Start of buffer array in RAM "ldi r29,hi8(buff) \n\t" "lds r24,length
\n\t" //Length of data to be
written (in bytes) "lds r25,length+1 "sbrs r24,0
\n\t" \n\t" //Even up an odd number of
bytes "rjmp length_loop "adiw r24,1 "length_loop:
\n\t" \n\t" \n\t" //Main loop, repeat for
95
number of words in block
"cpi r17,0x00
\n\t" //If page_word_count=0
then erase page "brne no_page_erase \n\t"
"rcall wait_spm
\n\t"
//
"wait_spm1:
\n\t"
//
"lds r16,%0
\n\t" //Wait for previous spm to
complete //
"andi r16,1
\n\t"
//
"cpi r16,1
\n\t"
//
"breq wait_spm1 "ldi r16,0x03
\n\t" \n\t" //Erase page pointed to by
Z "sts %0,r16 "spm
\n\t" \n\t"
"rcall wait_spm
\n\t"
//
"wait_spm2:
\n\t"
//
"lds r16,%0
\n\t" //Wait for previous spm to
complete //
"andi r16,1
\n\t"
//
"cpi r16,1
\n\t"
//
"breq wait_spm2
\n\t"
"ldi r16,0x11
\n\t" //Re-enable RWW section
"sts %0,r16
\n\t"
"spm
\n\t"
96
"no_page_erase:
"ld
\n\t"
r0,Y+
\n\t" //Write 2 bytes into page
buffer "ld
r1,Y+
\n\t"
"rcall wait_spm
\n\t"
//
"wait_spm3:
\n\t"
//
"lds r16,%0
\n\t" //Wait for previous spm to
complete //
"andi r16,1
\n\t"
//
"cpi r16,1
\n\t"
//
"breq wait_spm3
\n\t"
"ldi r16,0x01
\n\t" //Load r0,r1 into FLASH
page buffer "sts %0,r16
\n\t"
"spm
\n\t"
"inc r17
\n\t" //page_word_count++
"cpi r17,%1
\n\t"
"brlo same_page
\n\t" //Still same page in
FLASH "write_page: "clr r17
\n\t" \n\t" //New page, write current
one first "rcall wait_spm
\n\t"
//
"wait_spm4:
\n\t"
//
"lds r16,%0
\n\t" //Wait for previous spm to
complete
97
//
"andi r16,1
\n\t"
//
"cpi r16,1
\n\t"
//
"breq wait_spm4
\n\t"
"ldi r16,0x05
\n\t" //Write page pointed to by
Z "sts %0,r16 "spm
\n\t" \n\t"
"rcall wait_spm
\n\t"
//
"wait_spm5:
\n\t"
//
"lds r16,%0
\n\t" //Wait for previous spm to
complete //
"andi r16,1
\n\t"
//
"cpi r16,1
\n\t"
//
"breq wait_spm5
\n\t"
"ldi r16,0x11
\n\t" //Re-enable RWW section
"sts %0,r16
\n\t"
"spm
\n\t"
"same_page:
\n\t"
"adiw r30,2
\n\t" //Next word in FLASH
"sbiw r24,2
\n\t" //length-2
"breq final_write "rjmp length_loop
\n\t" //Finished \n\t"
"wait_spm: \n\t" "lds r16,%0
\n\t" //Wait for previous spm to
complete 98
"andi r16,1
\n\t"
"cpi r16,1
\n\t"
"breq wait_spm "ret
\n\t"
\n\t"
"final_write: "cpi r17,0
\n\t" \n\t"
"breq block_done "adiw r24,2
\n\t" \n\t" //length+2, fool above
check on length after short page write "rjmp write_page "block_done: "clr __zero_reg__
\n\t" \n\t" \n\t" //restore zero register
: "=m" (SPMCR) : "M" (PAGE_SIZE) : "r0","r16","r17","r24","r25","r28","r29","r30","r31");
/* Should really add a wait for RWW section to be enabled, don't actually need it since we never */ /* exit the bootloader without a power cycle anyhow */ } putch(0x14); putch(0x10); } }
/* Read memory block mode, length is big endian. */ else if(ch=='t') { length.byte[1] = getch(); length.byte[0] = getch();
99
if (getch() == 'E') flags.eeprom = 1; else { flags.eeprom = 0; address.word = address.word << 1;
// address * 2 -> byte
location } if (getch() == ' ') {
// Command terminator
putch(0x14); for (w=0;w < length.word;w++) {
// Can handle odd and
even lengths okay if (flags.eeprom) {
// Byte access EEPROM
read putch(eeprom_rb(address.word)); address.word++; } else { if (!flags.rampz) putch(pgm_read_byte_near(address.word)); address.word++; } } putch(0x10); } }
/* Get device signature bytes */ else if(ch=='u') { if (getch() == ' ') { putch(0x14); putch(SIG1); putch(SIG2); 100
putch(SIG3); putch(0x10); } }
/* Read oscillator calibration byte */ else if(ch=='v') { byte_response(0x00); } //
} else {
//
time_count++;
//
if (time_count>=MAX_TIME_COUNT) {
//
app_start();
//
}
//
} } /* end of forever loop */
} void putch(char ch) { /* m8 */ while (!(inb(UCSRA) & _BV(UDRE))); outb(UDR,ch); } char getch(void) { /* m8 */ uint32_t count = 0; while(!(inb(UCSRA) & _BV(RXC))) { /* HACKME:: here is a good place to count times*/ 101
count++; if (count > MAX_TIME_COUNT) app_start(); } return (inb(UDR)); } void getNch(uint8_t count) { uint8_t i; for(i=0;i<count;i++) { /* m8 */ //while(!(inb(UCSRA) & _BV(RXC))); //inb(UDR); getch(); // need to handle time out } } void byte_response(uint8_t val) { if (getch() == ' ') { putch(0x14); putch(val); putch(0x10); } } void nothing_response(void) { if (getch() == ' ') { putch(0x14); putch(0x10); 102
} } /* end of file ATmegaBOOT.c */
103