MODULO PROGRAMABLE
103
1 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
-
Upload
telmo-viteri -
Category
Documents
-
view
303 -
download
2
description
DISEÑO MODULO PROGRAMABLE
Transcript of MODULO PROGRAMABLE
1
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
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
5
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.
6
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
7
SBC (Single board Computer) MCU (Micro Controller Unit)
1.2. 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.
8
Aplicaciones de los microcontroladores
Porcentajes de utilización en distintas áreas de los microcontroladores
1.3. Microprocesadores y Microcontroladores
10,00%
15,00%
18,00%
27,00%
30,00%
Aplicaciones
INDUSTRIA
COMPUTADORAS
AUTOMOVILES
CONSUMO
COMUNICACIONES
9
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.
10
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
11
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)
12
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.
13
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.
14
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:
15
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.
16
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.
17
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.
18
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.
19
1.7. Familias populares de Microcontroladores
20
Marcas y modelos de microcontroladores más populares
21
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
22
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.
23
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.
24
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
25
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,
26
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
27
1.12. Herramientas de desarrollo
ISIS de Proteus:
Edición de Esquemáticos
Simulación Visual
ARES:
Desarrollo de Circuitos Impresos
Software para el desarrollo de aplicaciones con microcontroladores
28
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
29
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
30
ATMega16
31
Interior del Micro controlador (ATMega-8)
32
Interior del Micro controlador (ATMega-16)
33
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
34
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.
35
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.
36
AVR CPU CORE Mapa de memoria
37
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 )
38
Memoria de Programa Vectores de Interrupción en el ATmega8
39
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.
40
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.
41
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.
42
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.
43
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
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.
Se generan con
operaciones
Aritméticas y lógicas
44
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.
45
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)
46
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
47
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
48
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);
49
// 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.
50
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.
51
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).
52
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).
53
Puertos de Entrada/Salida ( Configuraciones )
54
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”);
55
/* 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 pre-
establecida 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.
56
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).
57
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
58
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.
59
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 ; Debe terminar con RETI
Externa_1: ; 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
60
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
{
. . . .
}
61
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).
62
Sistema de Inicialización.
63
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.
64
Inicio con Reset conectado a VCC
Reset extendido de manera externa.
Operación de un reset externo.
65
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.
66
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:
67
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.
68
2.3. Ventanas de PonyProg
69
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.
70
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 = “1001”.
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:
71
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:
72
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
73
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.
74
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.
75
76
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.
77
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
78
3.5. Diseño del PCB
3.6. Listado de Materiales
LISTA DE PARTES PARA MÓDULO SERIAL PROGRAMABLE
POSI
CIÓ
N VALOR DESCRIPCIÓN DETALLE
OBSERVACI
ÓN
C1 22pF (22 pico Faradios)
ceramic disc
capacitor
C2 22pF (22 pico Faradios)
ceramic disc
capacitor
C3
100nF (100 nano Faradios
- or 0.1 micro Faradios)
ceramic or
polyester
capacitor
C4
100nF (100 nano Faradios
- or 0.1 micro Faradios)
ceramic or
polyester
capacitor
C5 100μF (100 micro electrolytic 16volts (or radial-lead
79
Faradios) capacitor more: 25v)
C6
100nF (100 nano Faradios
- or 0.1 micro Faradios)
ceramic or
polyester
capacitor
C7
100nF (100 nano Faradios
- or 0.1 micro Faradios)
ceramic or
polyester
capacitor radial-lead
C8
100μF (100 micro
Faradiosios)
condensador
electrolitico
16volts (o
mas: 25v) radial-lead
C9 10μF (10 micro Faradios)
condensador
electrolitico no
polarizado
16volts (or
more: 25v,
50v) radial-lead
D1 1N4004 diodo DO41-10
D2 1N4148 diodo DO35-10
D3 1N4148 diodo DO35-10
DC1
DC1 2.1mm. DC
power jack
IC1
IC1 ATMEGA8
(or
ATMEGA168) 28P3 package
IC2 7805C
Tension
Regulator
ICSP 2x3 male pin header ICSP
J1 1x8 female pin header
0.1" (or 2.54
mm.)
PORT D(D0-
D7)
J2 1x6 female pin header
0.1" (or 2.54
mm.)
PORT C(A0-
A5)
J3 1x8 female pin header
0.1" (or 2.54
mm.)
PORT B(D8-
D13)
JP0 1x3
right angle pin
header
0.1" (or 2.54
mm.)
JP4 1x2
right angle pin
header
0.1" (or 2.54
mm.) AUTO RESET
80
L1 100μH leaded inductor axial leaded
(silver)brown,
black, brown,
golden
LED
0 3 mm. LED
choose a
color Rx Led
LED
1 3 mm. LED
choose a
color Tx Led
LED
13 3 mm. LED
choose a
color Pin13 Led
LED
14 3 mm. LED
choose a
color Power Led
POW
ER 1x6 female pin header
Q1 16 MHz crystal
R1 1kohm (1.0 kilo ohm) Resistencia
1/4 Watt,
±5%
brown, black,
red, gold
R2 1kohm (1.0 kilo ohm) Resistencia
1/4 Watt,
±5%
brown, black,
red, gold
R3 1kohm (1.0 kilo ohm) Resistencia
1/4 Watt,
±5%
brown, black,
red, gold
R4 1kohm (1.0 kilo ohm) Resistencia
1/4 Watt,
±5%
brown, black,
red, gold
R5 10kohms (10.0 kilo ohms) Resistencia
1/4 Watt,
±5%
brown, black,
orange, gold
R6 1kohm (1.0 kilo ohm) Resistencia
1/4 Watt,
±5%
brown, black,
red, gold
R7 10kohms (10.0 kilo ohms) Resistencia
1/4 Watt,
±5%
brown, black,
orange, gold
R8 10kohms (10.0 kilo ohms) Resistencia
1/4 Watt,
±5%
brown, black,
orange, gold
R9 4k7ohms (4.7 kilo ohms) Resistencia
1/4 Watt,
±5%
yellow, violet,
red, gold
R10 10kohms (10.0 kilo ohms) Resistencia 1/4 Watt, brown, black,
81
±5% orange, gold
R11 10kohms (10.0 kilo ohms) Resistencia
1/4 Watt,
±5%
brown, black,
orange, gold
S1 6x6 mm., 4 terminals Switch Tactile B3F-10XX
T1 BC547 Transistor
NPN general
purpose
transistor TO92
T2 BC557 Transistor
PNP general
purpose
transistor TO92
X1
9 PIN HEMBRA
CONECTOR DE PC
D-SUB
CONNECTOR
DE-9
CONECTOR
jump
er
0.1" (or 2.54
mm.)
jump
er
0.1" (or 2.54
mm.)
VER DETALLE DE LOS
ELEMENTOS EN EL
ADJUNTO GRAFICO
82
Vista de distribución real de la placa final.
3.7. Implementación del prototipo.
83
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
84
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.
85
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. */
/* */
86
/* 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 */
87
#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
88
#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;
89
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;
90
//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') {
91
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();
}
92
/* 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
93
//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();
94
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
95
//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
location
"rol r31 \n\t"
"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 \n\t"
"sbrs r24,0 \n\t" //Even up an odd number of
bytes
"rjmp length_loop \n\t"
"adiw r24,1 \n\t"
"length_loop: \n\t" //Main loop, repeat for
96
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 \n\t"
"ldi r16,0x03 \n\t" //Erase page pointed to by
Z
"sts %0,r16 \n\t"
"spm \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"
97
"no_page_erase: \n\t"
"ld 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: \n\t"
"clr r17 \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
98
// "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 \n\t"
"spm \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 \n\t" //Finished
"rjmp length_loop \n\t"
"wait_spm: \n\t"
"lds r16,%0 \n\t" //Wait for previous spm to
complete
99
"andi r16,1 \n\t"
"cpi r16,1 \n\t"
"breq wait_spm \n\t"
"ret \n\t"
"final_write: \n\t"
"cpi r17,0 \n\t"
"breq block_done \n\t"
"adiw r24,2 \n\t" //length+2, fool above
check on length after short page write
"rjmp write_page \n\t"
"block_done: \n\t"
"clr __zero_reg__ \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();
100
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);
101
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*/
102
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);
103
}
}
/* end of file ATmegaBOOT.c */
