conectividad inalámbrica con transceptor nrf24l01

0

DIVISIÓN ACADEMICA DE MANTENIMIENTO INDUSTRIAL Y

MECATRÓNICA

“CONECTIVIDAD INALÁMBRICA CON TRANSCEPTOR nRF24L01+”

INFORME FINAL DE ESTADÍA QUE PARA OBTENER EL TÍTULO DE

INGENIERO EN MECATRÓNICA PRESENTA

T.S.U. JOSÉ LUIS TOMÁS TORRES

Matricula: 200939108

ASESOR INDUSTRIAL: ING. L. MICHEL KUN ASESOR ACADEMICO: ING. OSCAR CARRILLO GALLEGOS NICOLAS ROMERO EDO. DE MEXICO ABRIL DE 2013

1

DIVISIÓN ACADEMICA DE MANTENIMIENTO INDUSTRIAL Y

MECATRÓNICA

“CONECTIVIDAD INALÁMBRICA CON TRANSCEPTOR nRF24L01+”

INFORME FINAL DE ESTADÍA QUE PARA OBTENER EL TÍTULO DE

INGENIERO EN MECATRÓNICA PRESENTA

T.S.U. JOSÉ LUIS TOMÁS TORRES

Matricula: 200939108

M. en I. Enrique García Trinidad Asesor académico

Ing. L. Michel Kun Asesor industrial

3

INDICE RESUMEN**************************************************************************** 5 LISTA DE FIGURAS***************************************************************** 6 LISTA DE TABLAS****************************************************************** 6 ABREVIATURAS Y SIMBOLOS**************************************************** 7 ANTECEDENES DE LA EMPRESA************************************************ 8 PLANTEAMIENTO GENERAL DEL PROBLEMA********************************* 9 OBJETIVO GENERAL*************************************************************** 10 OBJETIVOS ESPECIFICOS******************************************************** 10 JUSTIFICACION********************************************************************* 10 CAPITULO 1 MARCO TEÓRICO *************************************************** 11 1.1 Mecatrónica ********************************************************************* 11 1.1.1 Electrónica *************************************************************** 11 1.1.1.1 Telecomunicaciones ******************************************* 11 1.1.1.1.1 Espectro Electromagnético************************ 11 1.1.1.1.2 Interface Serial Periférica (SPI)****************** 14 1.1.1.2 Ingeniería de componentes*********************************** 19 1.1.1.2.1 Transceptor nRF24L01+************************** 19 1.1.1.2.2 Regulador de voltaje******************************* 31 1.1.1.2.3 Diodo Zener**************************************** 35 1.1.2 Control ******************************************************************** 36 1.1.2.1 Programación en Lenguaje C********************************* 38 1.1.2.2 Microcontroladores******************************************** 41 1.1.2.3 Arduino********************************************************** 60 1.2 Electricidad*********************************************************************** 76 1.2.1 Voltaje******************************************************************** 76 1.2.2 Corriente Eléctrica******************************************************* 77 1.2.3 Resistencia Eléctrica**************************************************** 77 1.2.4 Circuito Eléctrico********************************************************* 77 CAPITULO 2 DESARROLLO****************************** ************************* 79 2.1 Introducción*********************************************************************** 79 2.2 Lista de Componentes ********************************************************** 80 2.3 Comunicación SPI entre ATmega8 y ATmega328P*************************** 81 2.3.1 Configuraciones en software para ATmega8**************************** 82 2.3.2 Configuraciones en software para ATmega328P*********************** 84

4

2.3.3 Resultados obtenidos***************************************************** 86 2.4 Plataforma de Hardware abierto “ARDUINO” ********************************* 88 2.4.1 Funcionamiento del editor de texto*************************************** 89 2.4.2 Creación del código fuente************************************************ 89 2.5 Estudio de comandos para el control del dispositivo nRF24L01+ *********** 92 2.6 Comunicación SPI entre el dispositivo nRF24L01+ y el ATmega328P ***** 95 2.6.1 Configuraciones en software para ATmega328P*********************** 96 2.7 Transmisor y receptor con plataforma “ARDUINO”**************************** 102 2.7.1 Configuración para el transmisor***************************************** 102 2.7.1.1 Configuraciones en software para Arduino uno**************** 103 2.7.2 Configuración para el receptor******************************************** 105 2.7.2.1 Configuraciones en software para Arduino uno**************** 105 2.8 Transmisor y receptor con ATmega8****************************************** 109 2.8.1 Configuración para el transmisor**************************************** 109 2.8.1.1 Configuraciones en software para ATmega8****************** 109 2.8.2 Configuraciones para el receptor***************************************** 112 2.8.2.1 Configuraciones en software para ATmega8******************* 112 RESULTADOS*********************************************************************** 116 CONCLUSIONES******************************************************************** 116 REFERENCIAS BIBLIOGRÁFICAS ************************************************ 117

5

RESUMEN Este proyecto parte de la necesidad de, tener un sistema de conectividad inalámbrica, en el cual no existan interferencias al momento de tener más de 6 comunicaciones MASTER-SLAVE al mismo tiempo. La finalidad de este proyecto consiste en crear el sistema antes mencionado, para poder incorporarlo a un sistema de automatización. Este proyecto NO hace referencia, a que este tipo de sistemas inalámbricos no existan, el problema en los actuales sistemas es el alto costo de producción y, por ende, de compra.

6

LISTA DE FIGURAS Fig. 1.1 Protocolo SPI (Master - Slave)*********************************** 15 Fig. 1.2 Diagrama de bloques del transceptor nRF24L01+************* 21 Fig. 1.3 Paquete Enhanced ShockBurst con carga útil ***************** 25 Fig. 1.4 Operaciones de un PTX con Enhanced Shockburst*********** 28 Fig. 1.5 Operaciones de un PRX con Enhanced Shockburst*********** 29 Fig. 1.6 Diodo Zener******************************************************* 35 Fig. 2.1 MCU ATmega328P*********************************************** 80 Fig. 2.2 Tarjeta “ARDUINO UNO”, como base ATmega328P********** 80 Fig. 2.3 Dispositivo transceptor nRF24L01+***************************** 80 Fig. 2.4 Diagrama de conexiones entre ATmega8 y ATmega328P**** 81 Fig. 2.5 1er Resultado obtenido entre ATmega8 y ATmega328P

(mediante SPI)**************************************************** 87

Fig. 2.6 2do Resultado obtenido entre ATmega8 y ATmega328P (mediante SPI)****************************************************

87

Fig. 2.7 3er Resultado obtenido entre ATmega8 y ATmega328P (mediante SPI)****************************************************

87

Fig. 2.8 Diagrama de conexiones para el editor de texto*************** 88 Fig. 2.9 Diagrama de conexiones entre ATmega328P y nRF24L01+** 95 Fig. 2.10 Estado del registro “STATUS” al leerlo por primera vez******* 101 Fig. 2.11 Estado del registro “STATUS” después de escribirlo********** 101 Fig. 2.12 Diagrama de conexiones entre ATmega328P y nRF24L01+** 102 Fig. 2.13 Diagrama de conexiones entre ATmega328P y nRF24L01+** 105 Fig. 2.14 Variable recibida, mostrada a través del monitor serial del

software Arduino************************************************** 107

Fig. 2.15 Imagen de las dos tarjetas “ARDUINO UNO” transmitiendo y recibiendo datos **************************************************

108

Fig. 2.16 Diagrama de conexiones entre ATmega8 y nRF24L01+****** 109 Fig. 2.17 Diagrama de conexiones entre ATmega8 y nRF24L01+****** 112

LISTA DE TABLAS

Tab. 1.1 El espectro electromagnético************************************ 12 Tab. 1.2 Rangos de operación de cada banda*************************** 12 Tab. 1.3 Modos de operación del nRF24L01***************************** 22 Tab. 1.4 Configuración de la potencia de salida RF********************** 23 Tab. 2.1 Comandos (los cuales deben ser enviados a través de

comunicación SPI) del dispositivo nRF24L01+***************** 92

7

ABREVIATURAS Y SIMBOLOS A Amperes

CD Corriente directa

V Volt

Hz Hertz

I Corriente

mA mili ampere

P Potencia

R Resistencia

W Watt

Kw Kilo Watt

MCU Microcontrolador

Ω Ohms

GND Tierra

8

ANTECEDENTES DE LA EMPRESA Laboratorios Electrónicos Mexicanos es una empresa dedicada a desarrollar equipos de altísima tecnología para ayudar a la independencia social y monetaria de los más pobres, desarrollándoles los equipos más modernos del mundo. Los inicios de Laboratorios Electrónicos Mexicanos empiezan en México en 1963. Desde la llegada de su creador, el Ing. León Michel Kun en 1954, se dedicó a arreglar equipo médico como lo eran los desfribiladores cardiacos y otros equipos eléctricos médicos. Pero no fue hasta 1979 que en conjunto con Silicon Valley, deciden fabricar la primera computadora con sistema operativo mexicano. Fue una computadora del tipo “Radio Shack” con procesador Z-80 que fue la precursora de la Apple Commodore y de la IBM PC. El último desarrollo médico que ha diseñado Laboratorios Electrónicos Mexicanos son los brazos Robóticos que utiliza el Instituto de Rehabilitación durante las operaciones médicas, es un sistema con mas de 18 robots y 5 kilómetros de fibra óptica, utilizados primordialmente para enseñanza médica. De esta manera, Laboratorios Electrónicos Mexicanos se ha considerado una empresa capaz de resolver todos los retos impuestos por un mercado en continua transformación. Para poder cubrir las exigencias y puntos estratégicos de sus clientes, se encarga de valorar todos los factores posibles de fallas, evaluar los costos reales del proyecto y de la construcción, buscando las mejores opciones en calidad de materiales. Es por eso, que dentro de ella se desarrollan proyectos completos, basándose en la idea general y en las necesidades específicas del cliente, dando así al mismo, un servicio de máxima confiabilidad, desarrollo y progreso en sus necesidades industriales.

9

PLANTEAMIENTO GENERAL DEL PROBLEMA El reto de este proyecto es crear el sistema de conectividad inalámbrica, partiendo del estudio del protocolo SPI, para así, poder manipular al dispositivo nRF24L01+, el cual se requiere sea controlado a través del MCU ATmega8. Todo lo anterior con el principal objetivo de poder reducir los costos de producción. Es necesario comentar que, para poder cumplir este reto es necesario estudiar a fondo otro tipo de dispositivos que contengan el Protocolo de comunicación SPI. Uno de ellos, la plataforma de hardware abierto ARDUINO.

10

OBJETIVO GENERAL Realizar la transmisión de datos utilizando 2 transceptores nRF24L01+. OBJETIVOS ESPECÍFICOS *Programar un transceptor en modo transmisor utilizando un microcontrolador AVR.

*Programar un transceptor en modo receptor utilizando un microcontrolador AVR.

*Lograr la transmisión y recepción de datos entre 2 transceptores

nRF24L01+.

JUSTIFICACIÓN Obtener una comunicación master-slave en por lo menos 6 casos al mismo tiempo, sin que exista interferencia entre estos.

11

CAPITULO 1 MARCO TEÓRICO

1.1 MECATRÓNICA La mecatrónica es una disciplina que une la ingeniería mecánica, ingeniería

electrónica, ingeniería de control e ingeniería informática; la cual sirve para diseñar y desarrollar productos que involucren sistemas de control para el diseño de productos o procesos inteligentes, lo cual busca crear maquinaria más compleja para facilitar las actividades del ser humano a través de procesos electrónicos en la industria mecánica principalmente. Debido a que combina varias ingenierías en una sola, su punto fuerte es la versatilidad

1.1.1 ELECTRÓNICA Rama de la ingeniería, basada en la electrónica, que se encarga de resolver

problemas de la ingeniería tales como el control de procesos industriales, la transformación de la electricidad para el funcionamiento de diversos tipos y tiene aplicación en la industria, en las telecomunicaciones, en el diseño y análisis de instrumentación electrónica, microcontroladores y microprocesadores.

1.1.1.1 TELECOMUNICACIONES Aplicación de la técnica que diseña sistemas que permitan

la comunicación a larga distancia, a través de la transmisión y recepción de señales. Toda emisión, transmisión y recepción de signos, señales, escritos e imágenes, sonidos e informaciones de cualquier naturaleza, por hilo, radioelectricidad, medios ópticos u otros sistemas electromagnéticos, es considerado telecomunicación. El término «telecomunicación» resulta al añadir a comunicación el prefijo griego “tele-“, que significa “distancia”.

1.1.1.1.1 ESPECTRO ELECTROMAGNETICO Se denomina espectro electromagnético a la distribución energética del

conjunto de las ondas electromagnéticas. El espectro electromagnético se extiende desde la radiación de menor

longitud de onda, como los rayos gamma y los rayos X, pasando por la luz ultravioleta, la luz visible y los rayos infrarrojos, hasta las ondas electromagnéticas de mayor longitud de onda, como son las ondas de radio.

Para su estudio, el espectro electromagnético se divide en segmentos o bandas, aunque esta división es inexacta. Existen ondas que tienen una frecuencia, pero varios usos, por lo que algunas frecuencias pueden quedar en ocasiones incluidas en dos rangos.

12

Banda Longitud de onda (m) Frecuencia (Hz) Rayos gamma < 10 pm > 30,0 EHz

Rayos X < 10 nm > 30,0 PHz

Ultravioleta < 200 nm > 1,5 PHz Ultravioleta < 380 nm > 789 THz Luz Visible < 780 nm > 384 THz Infrarrojo < 2,5 µm > 120 THz Infrarrojo < 50 µm > 6,00 THz Infrarrojo < 1 mm > 300 GHz Microondas < 30 cm > 1 GHz Ultra Alta Frecuencia - Radio < 1 m > 300 MHz Muy Alta Frecuencia - Radio < 10 m > 30 MHz Onda Corta - Radio < 180 m > 1,7 MHz Onda Media - Radio < 650 m > 650 kHz Onda Larga - Radio < 10 km > 30 kHz Muy Baja Frecuencia - Radio > 10 km < 30 kHz Tabla 1.1 El espectro electromagnético.

Radiofrecuencia En radiocomunicaciones, los rangos se abrevian con sus siglas en inglés.

Los rangos son: Nombre Abreviatura

inglesa Frecuencias Longitud de onda

Extra baja frecuencia ELF 3-30 Hz 100.000–10.000 km Super baja frecuencia SLF 30-300 Hz 10.000–1000 km Ultra baja frecuencia ULF 300–3000 Hz 1000–100 km Muy baja frecuencia VLF 3–30 kHz 100–10 km Baja frecuencia LF 30–300 kHz 10–1 km Media frecuencia MF 300–3000 kHz 1 km – 100 m Alta frecuencia HF 3–30 MHz 100–10 m Muy alta frecuencia VHF 30–300 MHz 10–1 m Ultra alta frecuencia UHF 300–3000 MHz 1 m – 100 mm Super alta frecuencia SHF 3-30 GHz 100-10 mm Extra alta frecuencia EHF 30-300 GHz 10–1 mm

Tabla 1.2 Rangos de operación de cada banda.

13

Frecuencias extremadamente bajas : ELF (Extremely Low Frequencies), son aquellas que se encuentran en el intervalo de 3 a 30 Hz. Este rango es equivalente a aquellas frecuencias del sonido en la parte más baja (grave) del intervalo de percepción del oído humano. Cabe destacar aquí que el oído humano percibe ondas sonoras, no electromagnéticas, sin embargo se establece la analogía para poder hacer una mejor comparación.

Frecuencias super bajas : SLF (Super Low Frequencies), son aquellas que

se encuentran en el intervalo de 30 a 300 Hz. En este rango se incluyen las ondas electromagnéticas de frecuencia equivalente a los sonidos graves que percibe el oído humano típico.

Frecuencias ultra bajas : ULF (Ultra Low Frequencies), son aquellas en el

intervalo de 300 a 3000 Hz. Este es el intervalo equivalente a la frecuencia sonora normal para la mayor parte de la voz humana.

Frecuencias muy bajas : VLF (Very Low Frequencies), Se pueden incluir

aquí las frecuencias de 3 a 30 kHz. El intervalo de VLF es usado típicamente en comunicaciones gubernamentales y militares.

Frecuencias bajas : LF (Low Frequencies), son aquellas en el intervalo de

30 a 300 kHz. Los principales servicios de comunicaciones que trabajan en este rango están la navegación aeronáutica y marina.

Frecuencias medias : MF (Medium Frequencies), están en el intervalo de

300 a 3000 kHz. Las ondas más importantes en este rango son las de radiodifusión de AM (530 a 1605 kHz).

Frecuencias altas : HF (High Frequencies), son aquellas contenidas en el

rango de 3 a 30 MHz. A estas se les conoce también como "onda corta". Es en este intervalo que se tiene una amplia gama de tipos de radiocomunicaciones como radiodifusión, comunicaciones gubernamentales y militares. Las comunicaciones en banda de radioaficionados y banda civil también ocurren en esta parte del espectro.

Frecuencias muy altas : VHF (Very High Frequencies), van de 30 a 300

MHz. Es un rango popular usado para muchos servicios, como la radio móvil, comunicaciones marinas y aeronáuticas, transmisión de radio en FM (88 a 108 MHz) y los canales de televisión del 2 al 12.

14

Frecuencias ultra altas : UHF (Ultra High Frequencies), abarcan de 300 a 3000 MHz, incluye los canales de televisión de UHF, es decir, del 21 al 69 y se usan también en servicios móviles de comunicación en tierra, en servicios de telefonía celular y en comunicaciones militares.

Frecuencias super altas : SHF (Super High Frequencies), son aquellas

entre 3 y 30 GHz y son ampliamente utilizadas para comunicaciones vía satélite y radioenlaces terrestres. Además, pretenden utilizarse en comunicaciones de alta tasa de transmisión de datos a muy corto alcance.

Frecuencias extremadamente altas : EHF (Extrematedly High

Frequencies), se extienden de 30 a 300 GHz. Los equipos usados para transmitir y recibir estas señales son más complejos y costosos, por lo que no están muy difundidos aún.

Microondas Cabe destacar que las frecuencias entre 1 GHz y 300 GHz, son

llamadas microondas. Estas frecuencias abarcan parte del rango de UHF y todo el rango de SHF y EHF. Estas ondas se utilizan en numerosos sistemas, como múltiples dispositivos de transmisión de datos, radares y hornos microondas.

1.1.1.1.2 INTERFACE SERIAL PERIFÉRICA (SPI) El Bus SPI (del inglés Serial Peripheral Interface) es un estándar de

comunicaciones, usado principalmente para la transferencia de información entre circuitos integrados en equipos electrónicos. El bus de interfaz de periféricos serie o bus SPI es un estándar para controlar casi cualquier dispositivo electrónico digital que acepte un flujo de bits serie regulado por un reloj.

Incluye una línea de reloj, dato entrante, dato saliente y un pin de chip select, que conecta o desconecta la operación del dispositivo con el que uno desea comunicarse. De esta forma, este estándar permite multiplexar las líneas de reloj.

Muchos sistemas digitales tienen periféricos que necesitan existir pero no ser rápidos. La ventajas de un bus serie es que minimiza el número de conductores, pines y el tamaño del circuito integrado. Esto reduce el coste de fabricar montar y probar la electrónica. Un bus de periféricos serie es la opción más flexible cuando se tiene tipos diferentes de periféricos serie. El hardware consiste en señales de reloj, data in, data out y chip select para cada circuito integrado que tiene que ser controlado. Casi cualquier dispositivo digital puede ser controlado con esta combinación de señales. Los dispositivos se diferencian en un número predecible de formas. Unos leen el dato cuando el reloj sube otros cuando el reloj baja.

15

Algunos lo leen en el flanco de subida del reloj y otros en el flanco de bajada. Escribir es casi siempre en la dirección opuesta de la dirección de movimiento del reloj. Algunos dispositivos tienen dos relojes. Uno para capturar o mostrar los datos y el otro para el dispositivo interno.

Figura 1.1 Protocolo SPI (Master – Slave). OPERACIÓN El SPI es un protocolo síncrono. La sincronización y la transmisión de datos

se realizan por medio de 4 señales: • SCLK ó SCK (Clock): Es el pulso que marca la sincronización. Con cada pulso

de este reloj, se lee o se envía un bit. • MOSI (Master Output Slave Input): Salida de datos del Master y entrada de

datos al Slave. • MISO (Master Input Slave Output): Salida de datos del Slave y entrada al

Master. • CSN ó SS/Slave Select : Para seleccionar un Slave, o para que el Master le

diga al Slave que se active.

La Cadena de bits es enviada de manera síncrona con los pulsos del reloj, es decir con cada pulso, el Master envía un bit. Para que empiece la transmisión el Master baja la señal SS/Select a cero, con esto el Slave se activa y empieza la transmisión, con un pulso de reloj al mismo tiempo que el primer bit es leído. Nótese que los pulsos de reloj pueden estar programados de manera que la transmisión del bit se realice en 4 modos diferentes, a esto se llama polaridad y fase de la transmisión:

Bus SPI: un maestro y un esclavo.

SPI bus: un maestro y tres esclavos.

16

• 1. Con el flanco de subida sin retraso. • 2. Con el flanco de subida con retraso. • 3. Con el flanco de bajada sin retraso. • 4. Con el flanco de bajada con retraso.

PROS Y CONTRAS DEL BUS SPI * VENTAJAS

• Comunicación Full Duplex • Mayor velocidad de transmisión que con I²C o SMBus • Protocolo flexible en que se puede tener un control absoluto sobre los bits

transmitidos • No está limitado a la transferencia de bloques de 8 bits • Elección del tamaño de la trama de bits, de su significado y propósito

• Su implementación en hardware es extremadamente simple • Consume menos energía que I²C o que SMBus debido que posee menos

circuitos (incluyendo las resistencias pull-up) y estos son más simples • No es necesario arbitraje o mecanismo de respuesta ante fallos • Los dispositivos clientes usan el reloj que envía el servidor, no necesitan

por tanto su propio reloj • No es obligatorio implementar un transceptor (emisor y receptor), un

dispositivo conectado puede configurarse para que solo envíe, sólo reciba o ambas cosas a la vez

• Usa mucho menos terminales en cada chip/conector que una interfaz paralelo equivalente

• Como mucho una única señal específica para cada cliente (señal SS), las demás señales pueden ser compartidas

*DESVENTAJAS

• Consume más pines de cada chip que I²C, incluso en la variante de 3 hilos • El direccionamiento se hace mediante líneas específicas (señalización fuera de

banda) a diferencia de lo que ocurre en I²C que se selecciona cada chip mediante una dirección de 7 bits que se envía por las mismas líneas del bus

• No hay control de flujo por hardware • No hay señal de asentimiento. El servidor podría estar enviando información

sin que estuviese conectado ningún cliente y no se daría cuenta de nada • No permite fácilmente tener varios servidores conectados al bus • Sólo funciona en las distancias cortas a diferencia de, por ejemplo, RS-

232, RS-485, o Bus CAN

17

SPI EN ATMEGA328P El SPI Master inicializa el ciclo de comunicación cuando se coloca en bajo

el Selector de Esclavo (SS). Master y Slave preparan los datos a ser enviados en sus respectivos registros de desplazamiento y el Master genera el pulso del reloj en el pin SCK para el intercambio de datos. Los datos son siempre intercambiados desde el Maestro al Esclavo en MasterOut-SlaveIn, MOSI, y desde Esclavo al Maestro en MasterIn-SlaveOut, MISO. Después de cada paquete de datos el Maestro debe sincronizar el esclavo llevando a 'alto' el selector de Esclavo (SS).

Cuando se configure como Maestro, la interfaz SPI no tendrá un control automático de la línea SS. Este debe ser manejado por software antes de que la comunicación pueda empezar, cuando esto es realizado, escribiendo un byte en el registro de la SPI comienza el reloj de la SPI, y el hardware cambia los 8 bits dentro del Esclavo. Después de cambiar un Byte, el reloj del SPI para, habilitando el fin de la transmisión (SPIF). Si la interrupción del SPI está habilitado (SPIE) en el registro SPCR, una interrupción es requerida. El Master podría continuar al cambio del siguiente byte escribiendo dentro del SPDR, o señalizar el fin del paquete colocando en alto el Esclavo seleccionado, línea SS. El último byte llegado se mantendrá en el registro Buffer para luego usarse.

Cuando lo configuramos como un Esclavo, la interfaz SPI permanecerá durmiendo con MISO en tres-estados siempre y cuando el pin SS este deshabilitado. En este estado, por el software se podría actualizar el contenido del registro SPDR, pero los datos no serán desplazados por la llegada del pulso de reloj en el pin SCK hasta que el pin SS no sea habilitado (‘0’). Será visto como un byte completamente desplazado en el fin de la transmisión cuando SPIF se habilite. Si la interrupción SPI, SPIE en SPCR, está habilitada, una interrupción es solicitada. El Esclavo podría continuar para colocar nuevos datos para ser enviados dentro del SPDR antes de seguir leyendo la data que va llegando. El último byte que entra permanecerá en el buffer para luego usarse. (MSTR en SPCR es seteado), el usuario puede determinar la dirección del pin SS.

Si SS es configurado como salida, el pin es una salida general la cual no afecta el sistema SPI. Típicamente, el pin SS será manejado desde el Esclavo.

Si es como entrada, este debe ser enviado a alto para asegurar la operación SPI del Master.

18

BYTE SPCR

• Bit 7 - SPIE Habilitación de interrupción en SPI, si el bit SPIF (SPSR) y el SRGE son

habilitados. • Bit 6 - SPE

SPI habilitado, debe ser habilitado para cualquier operación SPI. • Bit 5 - DORD

Orden de datos, si es '1' el LSB sale primero. Si es '0' el MSB sale primero. • Bit 4 - MSTR

Selector Master o Esclavo, si es '1' es Master, de lo contrario Esclavo. Si el pin SS es configurado como entrada y es habilitado ('0') mientras MSTR está habilitado, MSTR será deshabilitado, y SPIF (en SPSR) se habilitara.

• Bit 3 - CPOL Polaridad del reloj, si es '1' SCK será activo en alto de lo contrario será

activo en bajo. • Bit 2- CPHA

Fase del reloj. • Bit 1,0 - SPR1, SPR0

Selección de la velocidad del reloj, solo funciona en modo master. BYTE SPSR

• Bit 7 - SPIF Bandera de interrupción del SPI. Cuando una transferencia serial es

completada, la bandera SPIF es habilitada. Una interrupción es generada si SPIE (en SPCR) y SREG están habilitados. Si SS es una entrada y está en habilitada ('0') cuando el SPI está en modo Master, este también habilitara la bandera SPIF. SPIF es deshabilitada por hardware cuando es ejecutada la correspondiente interrupción manualmente. Alternativamente, el bit SPIF es deshabilitado por la primera lectura del registro de estado SPI con SPIF activo.

• Bit 6 - WCOL Bandera de colisión de escritura, es habilitada si se produce una escritura

durante la transferencia. Es deshabilitado por la primera lectura del registro de estado SPI (SPDR).

• Bit 0 - SPI2x Duplicador de velocidad de los bits.

19

BYTE SPDR Es un registro de lectura y escritura usado para la transmisión de datos

entre el registro de archivos y el registro de cambio SPI. 1.1.1.2 INGENIERÍA DE COMPONENTES Gran parte del proceso de producción en las empresas de electricidad y

electrónica está relacionado con el diseño de circuitos. En este proceso es de gran importancia un conocimiento especializado de los componentes, lo que ha dado lugar a una especialidad dentro de la ingeniería electrónica denominada ingeniería de componentes.

En esta especialidad el ingeniero deberá encargarse de una serie de funciones en las que cabe destacar las siguientes: • Asesorar a los diseñadores: Para ello deberá tener conocimientos profundos

sobre componentes tanto a nivel teórico como práctico. Además deberá estar constantemente al día para conocer las novedades del mercado así como sus tendencias.

• Redactar normas: Relacionadas con el manejo de los componentes desde que entran en la empresa hasta que pasan a la cadena de montaje.

• Elaborar una lista de componentes preferidos. • Seleccionar componentes: Deberá elegirlo de entre la lista de preferidos y si no

está, realizar un estudio de posibles candidatos. Con ello se persigue mejorar los diseños.

• Relacionarse con los proveedores: Para resolver problemas técnicos o de cualquier otro tipo.

En la ingeniería de componentes se tiene en cuenta los materiales empleados así como los procesos de fabricación, por lo que el ingeniero deberá tener conocimientos al respecto.

TRANSCEPTOR nRF24L01+ El módulo nRF24L01+ es un radio transceptor que opera a 2.4 GHz con un

motor de protocolo de banda base incrustado (Enhanced ShockBurst ™), adecuada para aplicaciones inalámbricas de ultra bajo consumo de energía. El + nRF24L01 está diseñado para el funcionamiento en la banda de frecuencia ISM (Industrial Scientific and Medical) desde los 2.400 a 2.4835 GHz. Se puede diseñar un sistema de radio utilizando el nRF24L01+, un MCU (microcontrolador) y unos pocos componentes externos pasivos.

El nRF24L01+ puede operar y configurarse a través de un interfaz periférico serial (Comunicación SPI). Por medio de esta interfaz se puede manipular el mapa de registros, el mismo que contiene todos los registros de configuración del nRF24L01+ a los que puede ser accesado en todos los modos de funcionamiento del chip.

20

El protocolo motor embebido en banda base (Enhanced ShockBurst™) se basa en la comunicación por paquetes y es compatible con varios modos de funcionamiento, tales como: modo manual y el protocolo autónomo avanzado. Los FIFOs Internos asegurar un flujo correcto de datos entre la parte de radio y el MCU del sistema. Enhanced ShockBurst™ reduce el coste del sistema porque maneja todas las operaciones de alta velocidad de la capa de enlace.

La parte de radio usa modulación GFSK. Tiene parámetros configurables por el usuario como canal de frecuencia, potencia y caudal de aire de datos. El nRF24L01+ soporta una velocidad de datos de 250 kbps, 1 Mbps y 2 Mbps. La combinación de la alta velocidad de datos y los dos modos de ahorro de energía hacen que el nRF24L01+ sea muy adecuado para diseños de ultra baja potencia.

Los reguladores de tensión interna aseguran un alto grado de rechazo de alimentación (PSRR) y un amplio rango de alimentación.

CARACTERÍSTICAS Características más importantes del nRF24L01+: Radio frecuencia: - Opera en la banda ISM de 2,4 GHz - 126 canales de RF - Pines de RX y TX comunes - Modulación GFSK - Tasa de transferencia de datos de 250kbps, 1 y 2 Mbps

- 1MHz de separación entre canales a 1Mbps para que no se sobrepongan los canales - 2MHz de separación entre canales a 2Mbps para que no se sobrepongan los canales

Transmisor: - Potencia de salida programable: 0, -6, -12 ó -18dBm - 11.3mA a 0 dBm de potencia de salida Receptor: - Filtros de canal integrados - Corriente de 13.5mA a 2Mbps - -82dBm de sensibilidad a 2Mbps - -85dBm de sensibilidad a 1Mbps - -94dBm de sensibilidad a 250kbps Sintetizador de RF: - Sintetizador completamente integrado - VCO con diodo varactor ó resonador - Utiliza cristal de 16MHz

21

Enhanced ShockBurst ™: - 1 a 32 bytes de longitud de carga dinámica - Manejo automático de paquetes - Manejo automático de transacción de paquetes

- 6 tubos de datos multirecepción (MultiCeiver ™) para redes en estrella 1:6 (1 master, 6 esclavos)

Gestión de energía: - Regulador de voltaje integrado - Rango de voltaje: 1,9 a 3,6 V

- Modos de inactividad con rápidos tiempos de arranque para la gestión avanzada de energía - Consumo de corriente: 26µA en modo Standby-I, y de 900nA en modo apagado - Max 1.5ms para la puesta en marcha desde modo apagado - Max 130US para la puesta en marcha desde modo Standby-I

Interfaz SPI: - 4 pines para hardware SPI - Tasa de transferencia máxima 10Mbps - 3 FIFOs independientes para TX y RX de 32 bytes - Entradas tolerantes de hasta 5V

Figura 1.2.- Diagrama de bloques del transceptor nRF24L01+

22

MODOS DE OPERACIÓN DEL MÓDULO nRF24L01+ El módulo cuenta con 4 modos principales de operación, que definen la

función a realizar en cierto instante de tiempo: - Modo de ahorro de energía (POWER DOWN MODE) En este modo de operación el nRF24L01+ es deshabilitado, para

conseguir un mínimo consumo de corriente, configurando el bit PWR_UP = 0, en el registro CONFIG.

- Modo de espera (STANDBY MODES)

- Modo de Recepción (RX MODE)

- Modo de Transmisión (TX MODE)

23

TASA DE TRANSFERENCIA DE DATOS (Air data rate) La tasa de transferencia de datos para el módulo nRF24L01+ puede ser

250Kbps, 1Mbps ó 2 Mbps. A mayor velocidad de transmisión, se tiene un menor consumo promedio de corriente ya la vez, se reduce la probabilidad de colisiones en el aire.

Este parámetro, se configura por medio del bit RF_DR ubicado en el registro RF_SETUP.

FRECUENCIAS DEL CANAL RF La frecuencia del canal RF determina el centro del canal usado por el

módulo nRF24L01+. El canal ocupa un ancho de banda de 1 MHz a una velocidad de transmisión de 1 Mbps y 2 MHz a 2Mbps. El nRF24L01+ puede operar en frecuencias que van desde 2,400 GHz hasta 2,525 GHz.

Por defecto la resolución del canal de frecuencia RF es de 1 MHz, por lo que se debe asegurar que el ancho de banda del canal sea mayor o igual a la resolución.

Para que se habilite la comunicación entre un módulo transmisor y un receptor deben estar programados con la misma frecuencia de canal de transmisión. La frecuencia de canal RF se configura por medio del registro RF_CH según la siguiente fórmula:

CONTROL DE PA El control de PA es usado paera establecer la salida de energía desde el

amplificador de potencia del nRF24L01+ (PA). Se lo configura a través de los bits RF_PWR ubicados en el registro RF_SETUP, en modo de transmisión (TX mode) se tiene cuatro opciones programables como se indica en la tabla 1.4

CONTROL DE Rx/Tx Para configurar al módulo nRF24L01+ como transmisor o como receptor, se

emplea el bit PRIM_RX que se ubica en el registro CONFIG.

24

ENHANCED SHOCKBURST

FUNCIONAMIENTO DEL ENHANCED SHOCKBURST

25

FORMATO DE UN PAQUETE ENHANCED SHOCKBURST

CAMPO PREÁMBULO (1 BYTE) Es una secuencia de 8 Bits usada para detectar los niveles 0 y 1 en el lado

del receptor. Si el primer bit es 1 el preámbulo es automáticamente establecido a 10101010 y si el primer bit es 0 el preámbulo será 01010101. Esto se hace para asegurar que las transiciones son suficientes en el preámbulo de estabilizar el receptor.

CAMPO DIRECCIÓN (3-5 BYTES) El receptor utiliza el campo dirección para asegurarse que los paquetes que

está detectando, sean los correctos. La longitud de este campo puede ser configurada a 3, 4 ó 5 bytes, empleando el registro AW.

CARGA ÚTIL (PAYLOAD) La carga útil es el contenido del paquete definido por el usuario, la cual

puede ser desde 0 hasta 32 bytes de longitud y es transmitida de forma inalámbrica.

CRC (CYCLIC REDUNDANCY CHECK)

26

OPERACIÓN PTX

27

OPERACIÓN PRX

28

Figura 1.4 Operaciones de un PTX con Enhanced Shockburst

29

Figura 1.5 Operaciones de un PRX con Enhanced Shockburst

30

MÚLTIPLES RECEPCIONES/TRANSMISIONES (MULTICEIVER)

31

1.1.1.2.2 REGULADOR DE VOLTAJE Un regulador de tensión o regulador de voltaje es un

dispositivo electrónico diseñado para mantener un nivel de voltaje constante. Los reguladores electrónicos de tensión se encuentran en dispositivos como

las fuentes de alimentación de los computadores, donde estabilizan los voltajes DC usados por el procesador y otros elementos. En los alternadores de los automóviles y en las plantas generadoras, los reguladores de voltaje controlan la salida de la planta. En un sistema de distribución de energía eléctrica, los reguladores de voltaje pueden instalarse en una subestación o junto con las líneas de distribución de forma que todos los consumidores reciban un voltaje constante independientemente de que tanta potencia exista en la línea.

32

MEDICIÓN DE LA CALIDAD DE REGULACIÓN Para que el voltaje de salida siempre se mantenga constante, la regulación

se especifica por dos medidas: • Regulación de carga es el cambio en el voltaje de salida para un cambio

dado en la corriente de carga (Por ejemplo: "típicamente 15mV, máximo 100mV para corrientes de carga entre 5mA y 1.4A, en alguna temperatura específica y voltaje de entrada")

• Regulación de línea o regulación de entrada es el grado al cual el voltaje de entrada cambia con el voltaje de salida. Es decir, como una relación del cambio entre voltaje de entrada y de salida (por ejemplo, "Típicamente 13V/V"), o el cambio de voltaje de salida sobre el rango de voltaje de entrada especificado (por ejemplo "más o menos el 2% del voltaje de entrada entre 90V y 260V, 50-60Hz").

Otros parámetros importantes son: • Coeficiente de temperatura: del voltaje de salida es el cambio en el voltaje de

salida con la temperatura (probablemente un promedio dentro de un rango de temperatura).

• Precisión del voltaje de un regulador de voltaje refleja el error en el voltaje de salida sin tomar en cuenta la temperatura o el tiempo de funcionamiento del mismo.

• Voltaje de caída es la diferencia mínima entre el voltaje de entrada y el voltaje de salida para el cual el regulador puede aún suministrar la corriente especificada. Un regulador de baja caída está diseñado para trabajar bien incluso con una alimentación de entrada de solamente un voltio o menor al voltaje de salida. La diferencia de entrada-salida en el que el regulador de voltaje no mantendrá la regulación es el voltaje de caída. Mayor reducción en el voltaje de entrada producirá un voltaje de salida reducido. Este valor depende de la corriente de carga y de la temperatura máxima.

• Valores máximos permitidos están definidos para los componentes del regulador, y especifican las corrientes de salida pico que pueden usarse, el voltaje máximo de entrada, la disipación máxima de potencia dada una temperatura, etc.

• Ruido de salida (ruido blanco térmico) e impedancia dinámica de salida puede definirse en un gráfico en contra de la frecuencia, mientras que el rizo de salida puede darse como voltaje pico a pico o voltaje RMS, o en términos de su espectro.

• Corriente de consumo es la corriente que pasa internamente por el circuito que no se va para la carga, medido normalmente como la corriente de entrada cuando no hay una carga conectada. Es además un signo de eficiencia, algunos reguladores lineales son más eficientes con cargas de corriente baja que las fuentes conmutadas.

33

• Respuesta transitoria es la reacción del regulador cuando hay un cambio súbito de la corriente de carga (carga transitoria) o en el voltaje de entrada (línea transitoria). Algunos reguladores tienden a oscilar o al tener una respuesta lenta de tiempo que en muchos casos puede tener resultados no deseados. Este valor es diferente de los parámetros de regulación, ya que estos hablan del regulador en un estado estable. La respuesta transitoria muestra el comportamiento del regulador frente a un cambio. Esta información se provee en la documentación técnica de un regulador y también depende de la capacitancia de salida.

• Protección de inserción de espejo de imagen significa que los reguladores están diseñados para su uso cuando hay un voltaje en su pin de salida y la corriente AC está desconectada. Reguladores con esta protección pueden tolerar la entrada que está aterrizada y la salida estar a un potencial mucho más alto que la entrada, pero no mucho más alto el voltaje de entrada máximo permitido en el regulador. Sólo algunos reguladores pueden soportar este estado continuamente, otros podrían hacerlo por un minuto. Esta situación es similar a los reguladores de tres terminales que se montan como una imagen de espejo. Los reguladores de tres terminales cuando se montan incorrectamente en un PCB tiene una terminal de salida conectado a una entrada de corriente continua no regulada y la entrada está conectada a la carga. Además, este tipo de protección es importante cuando el circuito regulador es usado en circuito de carga para baterías. Un regulador sin este tipo de protección puede dañarse si hay un daño en la red eléctrica o no está encendido. En esta situación el voltaje de entrada es cero, mientras que la terminal de salida está en las terminales de la batería.

REGULADOR DE VOLTAJE ELECTRÓNICO Un regulador simple puede hacerse de una resistencia en serie con

un diodo (o serie de diodos). Debido a la curva característica del diodo, el voltaje a través del diodo cambia ligeramente debido a la corriente que pasa por él. Cuando la precisión en el voltaje no es necesaria, el diseño puede funcionar.

Los reguladores de voltaje retroalimentados operan al comparar el voltaje de salida actual con algún voltaje de referencia asignado. Cualquier diferencia es amplificada y usada para controlar el elemento de regulación para reducir el voltaje de error. Esto forma un lazo de control de realimentación negativa, haciendo que la ganancia tienda a incrementar la precisión de regulación pero reducir la estabilidad (se debe evitar la oscilación, durante los cambios de paso). También habrá una compensación entre la estabilidad y la velocidad de respuesta a los cambios.

34

Reguladores integrados Hoy en día es más común encontrar en las fuentes de alimentación

reguladores integrados, normalmente son componentes muy parecidos a los transistores de potencia, suelen tener tres terminales, uno de entrada, un común o masa, y uno de salida, tienen una capacidad de reducción del rizado muy alta y normalmente sólo hay que conectarles un par de condensadores. Existen circuitos reguladores con un gran abanico de tensiones y corrientes de funcionamiento. La serie más conocida de reguladores integrados es la 78xx y la serie 79xx para tensiones negativas. Los de mayor potencia necesitarán un disipador de calor, este es los principales problemas de los reguladores serie lineales tanto discretos como integrados, al estar en serie con la carga las caídas de tensión en sus componentes provocan grandes disipaciones de potencia. Normalmente estos reguladores no son buenos para aplicaciones de audio por el ruido que pueden introducir en preamplificadores. Para ello es mejor utilizar regulación con componentes discretos o reguladores tipo LDO de bajo ruido.

Reguladores conmutados Los reguladores conmutados solucionan los problemas de los dispositivos

anteriormente citados, poseen mayor rendimiento de conversión, ya que los transistores funcionan en conmutación, reduciendo así la potencia disipada en estos y el tamaño de los disipadores. Se pueden encontrar este tipo de fuentes en los ordenadores personales, en electrodomésticos, reproductores DVD, etc., una desventaja es la producción de ruido electromagnético producido por la conmutación a frecuencias elevadas, teniendo que apantallar y diseñar correctamente la PCB (Placa de Circuito Impreso) del convertidor.

REGULADORES ELECTROMECÁNICOS Este es un tipo antiguo de regulador usado en 1920 que usa el principio de

una espira en una posición fija y una espira secundaria que puede rotarse en un eje en paralelo con la espira fija.

Cuando la espira movible se posiciona perpendicular a la espira fija, las fuerzas magnéticas que actúan sobre la espira movible balancea entre sí y el voltaje de salida no cambia. Al rotar la espira en una dirección o alejarla de la posición central incrementará o reducirá el voltaje en la espira secundaria movible.

Este tipo de regulador puede automatizarse por medio de un mecanismo servo controlado para cambiar la posición de la espira movible logrando así que el voltaje se incremente o disminuya. Un mecanismo de frenado se usa para mantener a la espira movible en la posición que queda en contra de las fuerzas magnéticas que actúan en la espira.

35

1.1.1.2.3 DIODO ZENER Es un diodo de cromo que se ha construido para que funcione en las zonas

de rupturas, recibe ese nombre por su inventor, el Dr.Clarence Melvin Zener. El diodo Zener es la parte esencial de los reguladores de tensión casi constantes con independencia de que se presenten grandes variaciones de la tensión de red, de la resistencia de carga y temperatura.

Son mal llamados a veces diodos de avalancha, pues presentan comportamientos similares a estos, pero los mecanismos involucrados son diferentes.

Figura 1.6 Diodo Zener CARACTERÍSTICAS Si a un diodo Zener se le aplica una corriente eléctrica del ánodo al cátodo

(polarización directa) toma las características de un diodo rectificador básico, pero si se le suministra corriente eléctrica de cátodo a ánodo (polarización inversa), el diodo solo dejara pasar un voltaje constante.

En conclusión: el diodo Zener debe ser polarizado al revés para que adopte su característica de regulador de tensión.

Su símbolo es como el de un diodo normal pero tiene dos terminales a los lados. Este diodo se comporta como un diodo convencional en condiciones de alta corriente porque cuando recibe demasiada corriente se quema.

36

1.1.2 CONTROL La ingeniería de control es la rama de la ingeniería que se basa en el uso

de elementos sistemáticos como controladores, control numérico o servomecanismos relacionados con aplicaciones de la tecnología de la información, como son tecnologías de ayuda por computador CAD, CAM o CAx, para el control industrial de maquinaria y procesos, reduciendo la necesidad de intervención humana. En el ámbito de la industrialización, la automatización está un paso por delante de la mecanización. Mientras que la mecanización provee operadores humanos con maquinaria para ayudar a exigencias musculares de trabajo, la automatización reduce considerablemente la necesidad para exigencias humanas sensoriales y mentales. Los procesos y los sistemas también pueden ser automatizados.

La Ingeniería de Control se preocupó desde sus orígenes de la automatización y del control automático de sistemas complejos, sin intervención humana directa. Campos como el control de procesos, control de sistemas electromecánicos, supervisión y ajuste de controladores y otros donde se aplican teorías y técnicas entre las que podemos destacar: Control óptimo, control predictivo, control robusto y control no lineal entre otros, todo ello con trabajos y aplicaciones muy diversas (investigación básica, investigación aplicada, militares, industriales, comerciales, etc.), las cuales han hecho de la ingeniería de control una materia científica y tecnológica imprescindible hoy en día.

La ingeniería de control moderna se relaciona de cerca con la Ingeniería eléctrica y la electrónica, pues los circuitos electrónicos pueden ser modelizados fácilmente usando técnicas de la teoría de control.

En muchas universidades, los cursos de ingeniería de control son dictados generalmente por la Facultad de Ingeniería Eléctrica. Anterior a la electrónica moderna, los dispositivos para el control de procesos eran diseñados por la ingeniería mecánica, los que incluían dispositivos tales como levas junto con dispositivos neumáticos e hidráulicos. Algunos de estos dispositivos mecánicos siguen siendo usados en la actualidad en combinación con modernos dispositivos electrónicos.

El control aplicado en la industria se conoce como control de procesos. Se ocupa sobre todo del control de variables como temperatura, presión, caudal, etc, en un proceso químico de una planta. Se incluye como parte del plan de estudios de cualquier programa de ingeniería química. Emplea muchos de los principios de la ingeniería de control. La ingeniería de control es un área muy amplia y cualquier ingeniería puede utilizar los mismos principios y técnicas que esta utiliza.

La ingeniería de control se ha diversificado a tal punto que hoy se aplica incluso en campos como la biología, las finanzas, e incluso el comportamiento humano.

37

El estudiante de ingeniería de control comienza el curso con los llamados sistemas de control lineal que requieren del uso de matemática elemental y la transformada de Laplace (llamada teoría de control clásica). En el control lineal, el estudiante hace análisis de los sistemas en el dominio de la frecuencia y del tiempo mientras que en los sistemas no lineales y en el control digital se requiere el uso del álgebra lineal y de la transformada Z respectivamente. A partir de aquí hay varias ramas secundarias.

La Ingeniería de control es una disciplina que se focaliza en modelizar matemáticamente una gama diversa de sistemas dinámicos y el diseño de controladores que harán que estos sistemas se comporten de la manera deseada. Aunque tales controladores no necesariamente son electrónicos y por lo tanto la ingeniería de control es a menudo un subcampo de otras ingenierías como la mecánica.

Dispositivos tales como circuitos eléctricos, procesadores digitales y los microcontroladores son muy utilizados en todo sistema de control moderno. La ingeniería de control tiene un amplio rango de aplicación en áreas como los sistemas de vuelo y de propulsión de los aviones de aerolíneas, militares, en la carrera espacial y últimamente en la industria automotriz.

El objetivo del control automático es poder manejar con una o más entradas (o referencia), una o más salidas de una planta o sistema, para hacerlo, la idea más primitiva es colocar entre la referencia y la planta, un controlador que sea el inverso de la función de transferencia de la planta, de tal manera que la función de transferencia de todo el sistema (la planta más el controlador), sea igual a uno.

Logrando de esta manera que la salida sea igual a la entrada; esta primera idea se denomina control en la lazo abierto. Un ejemplo clásico de control en lazo abierto es una lavadora de ropa ya que ésta funciona durante un ciclo predeterminado sin hacer uso de sensores.

Las desventajas que tiene el control por lazo abier to son: -Jamás se conoce la planta, a lo más se puede conocer un modelo

aproximado, por lo que no se puede lograr el inverso perfecto. -No se puede usar para controlar plantas inestables. -No compensa perturbaciones en el sistema. -Si la planta tiene grado relativo mayor que cero, no se puede crear un

controlador que la invierta, ya que no se puede hacer una función de transferencia con grado menor que cero.

-Es imposible invertir perfectamente una planta, si esta tiene retardos, ya que su inverso sería un adelanto en el tiempo (se debería tener la capacidad de predecir el futuro).

38

Una idea más avanzada, y más ampliamente implementada, es el concepto de feedback o realimentación, en que se usa la medición de la salida del sistema, como otra entrada del mismo, de tal forma que se puede diseñar un controlador que ajuste la actuación para variar la salida y llevarla al valor deseado. Por ejemplo el cuerpo humano realiza un control por realimentación para mantener la homeostasis, tiene sensores para cada elemento en el cuerpo y si es que se detecta una cantidad anormal, el cuerpo tiene sistemas para compensarlo (estos sistemas serían el controlador), los que produce una actuación (cierra válvulas, produce más sustancia, etc) hasta que los sensores le indican al cuerpo que ya se alcanzó el equilibrio; otro ejemplo:

En un automóvil con control de crucero la velocidad se sensa y se retroalimenta continuamente al sistema que ajusta la velocidad del motor por medio del suministro de combustible al mismo, en este último caso la salida del sistema sería la velocidad del motor, el controlador sería el sistema que decide cuanto combustible echar de acuerdo a la velocidad y la actuación sería la cantidad de combustible suministrado.

Las ventajas que tiene el control por retroalimenta ción son: -Puede controlar sistemas inestables -Puede compensar perturbaciones -Puede controlar sistemas incluso si estos tienen errores de modelado Desventajas: -El uso de sensores hace más caro (en dinero) el control -Se introduce el problema del ruido, al hacer la medición

1.1.2.1 PROGRAMACIÓN EN LENGUAJE C Un lenguaje de programación es un idioma artificial diseñado para

expresar procesos que pueden ser llevadas a cabo por máquinas como las computadoras.

Pueden usarse para crear programas que controlen el comportamiento físico y lógico de una máquina, para expresar algoritmos con precisión, o como modo de comunicación humana.

Está firmado por un conjunto de símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones. Al proceso por el cual se escribe, se prueba, se depura, se compila y se mantiene el código fuente de un programa informático se le llama programación.

También la palabra programación se define como el proceso de creación de un programa de computadora, mediante la aplicación de procedimientos lógicos, a través de los siguientes pasos:

39

• El desarrollo lógico del programa para resolver un problema en particular. • Escritura de la lógica del programa empleando un lenguaje de programación

específico (codificación del programa). • Ensamblaje o compilación del programa hasta convertirlo en lenguaje de

máquina. • Prueba y depuración del programa. • Desarrollo de la documentación.

Existe un error común que trata por sinónimos los términos 'lenguaje de programación' y 'lenguaje informático'. Los lenguajes informáticos engloban a los lenguajes de programación y a otros más, como por ejemplo HTML (lenguaje para el marcado de páginas web que no es propiamente un lenguaje de programación, sino un conjunto de instrucciones que permiten diseñar el contenido de los documentos).

Permite especificar de manera precisa sobre qué datos debe operar una computadora, cómo deben ser almacenados o transmitidos y qué acciones debe tomar bajo una variada gama de circunstancias. Todo esto, a través de un lenguaje que intenta estar relativamente próximo al lenguaje humano o natural. Una característica relevante de los lenguajes de programación es precisamente que más de un programador pueda usar un conjunto común de instrucciones que sean comprendidas entre ellos para realizar la construcción de un programa de forma colaborativa.

ELEMENTOS VARIABLES Y VECTORES Las variables podrían calificarse como contenedores de datos y por ello se

diferencian según el tipo de dato que son capaces de almacenar. En la mayoría de lenguajes de programación se requiere especificar un tipo de variable concreto para guardar un dato concreto. Por ejemplo, en Java, si deseamos guardar una cadena de texto deberemos especificar que la variable es del tipo "String". Por contra en otros lenguajes como PHP, este tipo de especificación de variables no es necesario. Además también existen variables compuestas por varias variables llamadas vectores. Un vector no es más que un conjunto de variables consecutivas en memoria y del mismo tipo guardadas dentro de una variable contenedor. A continuación añadimos un listado con los tipos de variables y vectores más comunes:

-Variables tipo Char: Estas variables contienen un único carácter, es decir, una letra, un signo o un número.

-Variables tipo Int: Contienen un número entero. -Variables tipo float: Contienen un número decimal.

40

-Variables tipo String: Contienen cadenas de texto, o lo que es lo mismo, es un vector con varias variables del tipo Char.

-Variables del tipo Boolean: Solo pueden contener un 0 o un 1. El cero es considerado para muchos lenguajes como el literal "False" mientras que el 1 se considera "True".

CONDICIONANTES Los condicionantes son estructuras de código que indican que, para que

cierta parte del programa se ejecute, deben cumplirse ciertas premisas; por ejemplo: que dos valores sean iguales, que un valor exista, que un valor sea mayor que otro... Estos condicionantes por lo general solo se ejecutan una vez a lo largo del programa. Los condicionantes más conocidos y empleados en programación son: • If: Indica una condición para que se ejecute una parte del programa. • Else if : Siempre va precedido de un "If" e indica una condición para que se

ejecute una parte del programa siempre que no cumpla la condición del if previo y si se cumpla con la que el "else if" especifique.

• Else : Siempre precedido de "If" y en ocasiones de "Else If". Indica que debe ejecutarse cuando no se cumplan las condiciones previas.

BUCLES Los bucles son parientes cercanos de los condicionantes, pero ejecutan

constantemente un código mientras se cumpla una determinada condición. Los más frecuentes son: • For : Ejecuta un código mientras una variable se encuentre entre 2

determinados parámetros. • While : Ejecuta un código mientras se cumpla la condición que solicita.

Hay que decir que a pesar de que existan distintos tipos de bucles, ambos son capaces de realizar exactamente las mismas funciones. El empleo de uno u otro depende, por lo general, del gusto del programador.

FUNCIONES Las funciones se crearon para evitar tener que repetir constantemente

fragmentos de código. Una función podría considerarse como una variable que encierra código dentro de si. Por lo tanto cuando accedemos a dicha variable (la función) en realidad lo que estamos es diciendo al programa que ejecute un determinado código predefinido anteriormente.

Todos los lenguajes de programación tienen algunos elementos de formación primitivos para la descripción de los datos y de los procesos o transformaciones aplicadas a estos datos (tal como la suma de dos números o la selección de un elemento que forma parte de una colección).

41

Estos elementos primitivos son definidos por reglas sintácticas y semánticas que describen su estructura y significado respectivamente.

1.1.2.2 MICROCONTROLADORES

Un microcontrolador (abreviado µC, UC o MCU) es un circuito integrado programable, capaz de ejecutar las órdenes grabadas en su memoria.

Está compuesto de varios bloques funcionales, los cuales cumplen una tarea específica. Un microcontrolador incluye en su interior las tres principales unidades funcionales de una computadora:

Unidad central de procesamiento. Memoria Periféricos de entrada/salida. Algunos microcontroladores pueden utilizar palabras de cuatro bits y

funcionan a velocidad de reloj con frecuencias tan bajas como 4 kHz, con un consumo de baja potencia (mW o micro vatios). Por lo general, tendrá la capacidad para mantener la funcionalidad a la espera de un evento como pulsar un botón o de otra interrupción, el consumo de energía durante el sueño (reloj de la CPU y los periféricos de la mayoría) puede ser sólo nano vatios, lo que hace que muchos de ellos muy adecuados para aplicaciones con batería de larga duración. Otros microcontroladores pueden servir para roles de rendimiento crítico, donde sea necesario actuar más como un procesador digital de señal (DSP), con velocidades de reloj y consumo de energía más altos.

Cuando es fabricado, el microcontrolador no contiene datos en la memoria ROM. Para que pueda controlar algún proceso es necesario generar o crear y luego grabar en la EEPROM o equivalente del microcontrolador algún programa, el cual puede ser escrito en lenguaje ensamblador u otro lenguaje para microcontroladores; sin embargo, para que el programa pueda ser grabado en la memoria del microcontrolador, debe ser codificado en sistema numérico hexadecimal que es finalmente el sistema que hace trabajar al microcontrolador cuando éste es alimentado con el voltaje adecuado y asociado a dispositivos analógicos y discretos para su funcionamiento

Los microcontroladores son diseñados para reducir el costo económico y el consumo de energía de un sistema en particular. Por eso el tamaño de la unidad central de procesamiento, la cantidad de memoria y los periféricos incluidos dependerán de la aplicación. El control de un electrodoméstico sencillo como una batidora utilizará un procesador muy pequeño (4 u 8 bits) porque sustituirá a un autómata finito. En cambio, un reproductor de música y/o vídeo digital (MP3o MP4) requerirá de un procesador de 32 bits o de 64 bits y de uno o más códecs de señal digital (audio y/o vídeo). El control de un sistema de frenos ABS (Antilock Brake System) se basa normalmente en un microcontrolador de 16 bits, al igual que el sistema de control electrónico del motor en un automóvil.

42

Los microcontroladores representan la inmensa mayoría de los chips de computadoras vendidos, sobre un 50% son controladores "simples" y el restante corresponde a DSP más especializados. Mientras se pueden tener uno o dos microprocesadores de propósito general en casa (Ud. está usando uno para esto), usted tiene distribuidos seguramente entre los electrodomésticos de su hogar una o dos docenas de microcontroladores. Pueden encontrarse en casi cualquier dispositivo electrónico como automóviles, lavadoras, hornos microondas, teléfonos, etc.

Un microcontrolador difiere de una unidad central de procesamiento normal, debido a que es más fácil convertirla en una computadora en funcionamiento, con un mínimo de circuitos integrados externos de apoyo. La idea es que el circuito integrado se coloque en el dispositivo, enganchado a la fuente de energía y de información que necesite, y eso es todo. Un microprocesador tradicional no le permitirá hacer esto, ya que espera que todas estas tareas sean manejadas por otros chips. Hay que agregarle los módulos de entrada y salida (puertos) y la memoria para almacenamiento de información.

Un microcontrolador típico tendrá un generador de reloj integrado y una pequeña cantidad de memoria de acceso aleatorio y/o ROM/EPROM/EEPROM/flash, con lo que para hacerlo funcionar todo lo que se necesita son unos pocos programas de control y un cristal de sincronización. Los microcontroladores disponen generalmente también de una gran variedad de dispositivos de entrada/salida, como convertidor analógico digital, temporizadores, UARTs y buses de interfaz serie especializados, como I2C y CAN. Frecuentemente, estos dispositivos integrados pueden ser controlados por instrucciones de procesadores especializados. Los modernos microcontroladores frecuentemente incluyen un lenguaje de programación integrado, como el lenguaje de programación BASIC que se utiliza bastante con este propósito.

Los microcontroladores negocian la velocidad y la flexibilidad para facilitar su uso. Debido a que se utiliza bastante sitio en el chip para incluir funcionalidad, como los dispositivos de entrada/salida o la memoria que incluye el microcontrolador, se ha de prescindir de cualquier otra circuitería.

1.1.2.2 MICROCONTROLADORES Un microcontrolador (abreviado µC, UC o MCU) es un circuito

integrado programable, capaz de ejecutar las órdenes grabadas en su memoria. Está compuesto de varios bloques funcionales, los cuales cumplen una

tarea específica. Un microcontrolador incluye en su interior las tres principales unidades funcionales de una computadora:

43

Unidad central de procesamiento. Memoria Periféricos de entrada/salida. Algunos microcontroladores pueden utilizar palabras de cuatro bits y

funcionan a velocidad de reloj con frecuencias tan bajas como 4 kHz, con un consumo de baja potencia (mW o micro vatios). Por lo general, tendrá la capacidad para mantener la funcionalidad a la espera de un evento como pulsar un botón o de otra interrupción, el consumo de energía durante el sueño (reloj de la CPU y los periféricos de la mayoría) puede ser sólo nano vatios, lo que hace que muchos de ellos muy adecuados para aplicaciones con batería de larga duración. Otros microcontroladores pueden servir para roles de rendimiento crítico, donde sea necesario actuar más como un procesador digital de señal (DSP), con velocidades de reloj y consumo de energía más altos.

Cuando es fabricado, el microcontrolador no contiene datos en la memoria ROM. Para que pueda controlar algún proceso es necesario generar o crear y luego grabar en la EEPROM o equivalente del microcontrolador algún programa, el cual puede ser escrito en lenguaje ensamblador u otro lenguaje para microcontroladores; sin embargo, para que el programa pueda ser grabado en la memoria del microcontrolador, debe ser codificado en sistema numérico hexadecimal que es finalmente el sistema que hace trabajar al microcontrolador cuando éste es alimentado con el voltaje adecuado y asociado a dispositivos analógicos y discretos para su funcionamiento

Los microcontroladores son diseñados para reducir el costo económico y el consumo de energía de un sistema en particular. Por eso el tamaño de la unidad central de procesamiento, la cantidad de memoria y los periféricos incluidos dependerán de la aplicación. El control de un electrodoméstico sencillo como una batidora utilizará un procesador muy pequeño (4 u 8 bits) porque sustituirá a un autómata finito. En cambio, un reproductor de música y/o vídeo digital (MP3o MP4) requerirá de un procesador de 32 bits o de 64 bits y de uno o más códecs de señal digital (audio y/o vídeo). El control de un sistema de frenos ABS (Antilock Brake System) se basa normalmente en un microcontrolador de 16 bits, al igual que el sistema de control electrónico del motor en un automóvil.

Los microcontroladores representan la inmensa mayoría de los chips de computadoras vendidos, sobre un 50% son controladores "simples" y el restante corresponde a DSP más especializados. Mientras se pueden tener uno o dos microprocesadores de propósito general en casa (Ud. está usando uno para esto), usted tiene distribuidos seguramente entre los electrodomésticos de su hogar una o dos docenas de microcontroladores. Pueden encontrarse en casi cualquier dispositivo electrónico como automóviles, lavadoras, hornos microondas, teléfonos, etc.

44

Un microcontrolador difiere de una unidad central de procesamiento normal, debido a que es más fácil convertirla en una computadora en funcionamiento, con un mínimo de circuitos integrados externos de apoyo. La idea es que el circuito integrado se coloque en el dispositivo, enganchado a la fuente de energía y de información que necesite, y eso es todo. Un microprocesador tradicional no le permitirá hacer esto, ya que espera que todas estas tareas sean manejadas por otros chips. Hay que agregarle los módulos de entrada y salida (puertos) y la memoria para almacenamiento de información.

Un microcontrolador típico tendrá un generador de reloj integrado y una

pequeña cantidad de memoria de acceso aleatorio y/o ROM/EPROM/EEPROM/flash, con lo que para hacerlo funcionar todo lo que se necesita son unos pocos programas de control y un cristal de sincronización. Los microcontroladores disponen generalmente también de una gran variedad de dispositivos de entrada/salida, como convertidor analógico digital, temporizadores, UARTs y buses de interfaz serie especializados, como I2C y CAN. Frecuentemente, estos dispositivos integrados pueden ser controlados por instrucciones de procesadores especializados. Los modernos microcontroladores frecuentemente incluyen un lenguaje de programación integrado, como el lenguaje de programación BASIC que se utiliza bastante con este propósito.

Los microcontroladores negocian la velocidad y la flexibilidad para facilitar

su uso. Debido a que se utiliza bastante sitio en el chip para incluir funcionalidad, como los dispositivos de entrada/salida o la memoria que incluye el microcontrolador, se ha de prescindir de cualquier otra circuitería.

ARQUITECTURA Básicamente existen dos arquitecturas de computadoras, y por supuesto,

están presentes en el mundo de los microcontroladores: Von Neumann y Harvard. Ambas se diferencian en la forma de conexión de la memoria al procesador y en los buses que cada una necesita.

Arquitectura Von Neumann La arquitectura Von Neumann utiliza el mismo dispositivo de

almacenamiento tanto para las instrucciones como para los datos, siendo la que se utiliza en un ordenador personal porque permite ahorrar una buena cantidad de líneas de E/S, que son bastante costosas, sobre todo para aquellos sistemas donde el procesador se monta en algún tipo de zócalo alojado en una placa madre. También esta organización les ahorra a los diseñadores de placas madre una buena cantidad de problemas y reduce el costo de este tipo de sistemas.

45

En un ordenador personal, cuando se carga un programa en memoria, a éste se le asigna un espacio de direcciones de la memoria que se divide en segmentos, de los cuales típicamente tenderemos los siguientes: código (programa), datos y pila. Es por ello que podemos hablar de la memoria como un todo, aunque existan distintos dispositivos físicos en el sistema (disco duro, memoria RAM, memoria flash, unidad de disco óptico...).

En el caso de los microcontroladores, existen dos tipos de memoria bien

definidas: memoria de datos (típicamente algún tipo de SRAM) y memoria de programas (ROM, PROM, EEPROM, flash u de otro tipo no volátil). En este caso la organización es distinta a las del ordenador personal, porque hay circuitos distintos para cada memoria y normalmente no se utilizan los registros de segmentos, sino que la memoria está segregada y el acceso a cada tipo de memoria depende de las instrucciones del procesador.

A pesar de que en los sistemas integrados con arquitectura Von Neumann

la memoria esté segregada, y existan diferencias con respecto a la definición tradicional de esta arquitectura; los buses para acceder a ambos tipos de memoria son los mismos, del procesador solamente salen el bus de datos, el de direcciones, y el de control. Como conclusión, la arquitectura no ha sido alterada, porque la forma en que se conecta la memoria al procesador sigue el mismo principio definido en la arquitectura básica.

Algunas familias de microcontroladores como la Intel 8051 y la Z80

implementan este tipo de arquitectura, fundamentalmente porque era la utilizada cuando aparecieron los primeros microcontroladores.

Arquitectura Harvard La otra variante es la arquitectura Harvard, y por excelencia la utilizada en

supercomputadoras, en los microcontroladores, y sistemas integrados en general. En este caso, además de la memoria, el procesador tiene los buses segregados, de modo que cada tipo de memoria tiene un bus de datos, uno de direcciones y uno de control.

La ventaja fundamental de esta arquitectura es que permite adecuar el tamaño de los buses a las características de cada tipo de memoria; además, el procesador puede acceder a cada una de ellas de forma simultánea, lo que se traduce en un aumento significativo de la velocidad de procesamiento. Típicamente los sistemas con esta arquitectura pueden ser dos veces más rápidos que sistemas similares con arquitectura Von Neumann.

46

La desventaja está en que consume muchas líneas de E/S del procesador; por lo que en sistemas donde el procesador está ubicado en su propio encapsulado, solo se utiliza en supercomputadoras. Sin embargo, en los microcontroladores y otros sistemas integrados, donde usualmente la memoria de datos y programas comparten el mismo encapsulado que el procesador, este inconveniente deja de ser un problema serio y es por ello que encontramos la arquitectura Harvard en la mayoría de los microcontroladores.

Por eso es importante recordar que un microcontrolador se puede configurar de diferentes maneras, siempre y cuando se respete el tamaño de memoria que este requiera para su correcto funcionamiento.

Registros Son un espacio de memoria muy reducido pero necesario para cualquier

microprocesador, de aquí se toman los datos para varias operaciones que debe realizar el resto de los circuitos del procesador. Los registros sirven para almacenar los resultados de la ejecución de instrucciones, cargar datos desde la memoria externa o almacenarlos en ella.

Aunque la importancia de los registros parezca trivial, no lo es en absoluto. De hecho una parte de los registros, la destinada a los datos, es la que determina uno de los parámetros más importantes de cualquier microprocesador. Cuando escuchamos que un procesador es de 4, 8, 16, 32 o 64 bits, nos estamos refiriendo a procesadores que realizan sus operaciones con registros de datos de ese tamaño, y por supuesto, esto determina muchas de las potencialidades de estas máquinas.

Mientras mayor sea el número de bits de los registros de datos del procesador, mayores serán sus prestaciones, en cuanto a poder de cómputo y velocidad de ejecución, ya que este parámetro determina la potencia que se puede incorporar al resto de los componentes del sistema, por ejemplo, no tiene sentido tener una ALU de 16 bits en un procesador de 8 bits.

Por otro lado un procesador de 16 bits, puede que haga una suma de 16 bits en un solo ciclo de máquina, mientras que uno de 8 bits deberá ejecutar varias instrucciones antes de tener el resultado, aun cuando ambos procesadores tengan la misma velocidad de ejecución para sus instrucciones. El procesador de 16 bits será más rápido porque puede hacer el mismo tipo de tareas que uno de 8 bits, en menos tiempo.

Unidad de control Esta unidad es de las más importantes en el procesador, en ella recae la

lógica necesaria para la decodificación y ejecución de las instrucciones, el control de los registros, la ALU, los buses y cuanta cosa más se quiera meter en el procesador.

47

La unidad de control es uno de los elementos fundamentales que determinan las prestaciones del procesador, ya que su tipo y estructura, determina parámetros tales como el tipo de conjunto de instrucciones, velocidad de ejecución, tiempo del ciclo de máquina, tipo de buses que puede tener el sistema, manejo de interrupciones y un buen número de cosas más que en cualquier procesador van a parar a este bloque.

Por supuesto, las unidades de control, son el elemento más complejo de un procesador y normalmente están divididas en unidades más pequeñas trabajando de conjunto. La unidad de control agrupa componentes tales como la unidad de decodificación, unidad de ejecución, controladores de memoria cache, controladores de buses, controlador de interrupciones, pipelines, entre otros elementos, dependiendo siempre del tipo de procesador.

Unidad aritmético-lógica Como los procesadores son circuitos que hacen básicamente operaciones

lógicas y matemáticas, se le dedica a este proceso una unidad completa, con cierta independencia. Aquí es donde se realizan las sumas, restas, y operaciones lógicas típicas del álgebra de Boole.

Actualmente este tipo de unidades ha evolucionado mucho y los procesadores más modernos tienen varias ALU, especializadas en la realización de operaciones complejas como las operaciones en coma flotante. De hecho en muchos casos le han cambiado su nombre por el de “coprocesador matemático”, aunque este es un término que surgió para dar nombre a un tipo especial de procesador que se conecta directamente al procesador más tradicional.

Su impacto en las prestaciones del procesador es también importante porque, dependiendo de su potencia, tareas más o menos complejas, pueden hacerse en tiempos muy cortos, como por ejemplo, los cálculos en coma flotante.

Esto no siempre funciona, puesto que se necesita de un termo resistor para compensar su registro de memoria, por lo que este termo resistor se puede sustituir por un transductor se presencia, para que su memoria de registro no sea complaciente para su velocidad de registro.

Buses Son el medio de comunicación que utilizan los diferentes componentes del

procesador para intercambiar información entre sí, eventualmente los buses o una parte de ellos estarán reflejados en los pines del encapsulado del procesador.

En el caso de los microcontroladores, no es común que los buses estén

reflejados en el encapsulado del circuito, ya que estos se destinan básicamente a las E/S de propósito general y periféricos del sistema.

48

Existen tres tipos de buses: • Dirección: Se utiliza para seleccionar al dispositivo con el cual se quiere

trabajar o en el caso de las memorias, seleccionar el dato que se desea leer o escribir.

• Datos. • Control: Se utiliza para gestionar los distintos procesos de escritura lectura y

controlar la operación de los dispositivos del sistema.

Conjunto de instrucciones Aunque no aparezca en el esquema, no podíamos dejar al conjunto o

repertorio de instrucciones fuera de esta fiesta, porque este elemento determina lo que puede hacer el procesador.

Define las operaciones básicas que puede realizar el procesador, que conjugadas y organizadas forman lo que conocemos como software. El conjunto de instrucciones vienen siendo como las letras del alfabeto, el elemento básico del lenguaje, que organizadas adecuadamente permiten escribir palabras, oraciones y cuanto programa se le ocurra.

Existen dos tipos básicos de repertorios de instrucciones, que determinan la arquitectura del procesador: CISC y RISC.

CISC, del inglés Complex instruction set computing, Computadora de Conjunto de Instrucciones Complejo. Los microprocesadores CISC tienen un conjunto de instrucciones que se caracteriza por ser muy amplio y que permiten realizar operaciones complejas entre operandos situados en la memoria o en los registros internos. Este tipo de repertorio dificulta el paralelismo entre instrucciones, por lo que en la actualidad, la mayoría de los sistemas CISC de alto rendimiento, convierten las instrucciones complejas en varias instrucciones simples del tipo RISC, llamadas generalmente microinstrucciones.

Dentro de los microcontroladores CISC podemos encontrar a la popular familia Intel 8051 y la Z80, aunque actualmente existen versiones CISC-RISC de estos microcontroladores, que pretenden aprovechar las ventajas de los procesadores RISC a la vez que se mantiene la compatibilidad hacia atrás con las instrucciones de tipo CISC.

RISC, del inglés Reduced Instruction Set Computer, Computadora con Conjunto de Instrucciones Reducido. Se centra en la obtención de procesadores con las siguientes características fundamentales: • Instrucciones de tamaño fijo. • Pocas instrucciones. • Sólo las instrucciones de carga y almacenamiento acceden a la memoria de

datos. • Número relativamente elevado de registros de propósito general.

49

Una de las características más destacables de este tipo de procesadores es que posibilitan el paralelismo en la ejecución, y reducen los accesos a memoria. Es por eso que los procesadores más modernos, tradicionalmente basados en arquitecturas CISC implementan mecanismos de traducción de instrucciones CISC a RISC, para aprovechar las ventajas de este tipo de procesadores. Los procesadores de los microcontroladores PIC son de tipo RISC.

MEMORIA Anteriormente habíamos visto que la memoria en los microcontroladores

debe estar ubicada dentro del mismo encapsulado, esto es así la mayoría de las veces, porque la idea fundamental es mantener el grueso de los circuitos del sistema dentro de un solo integrado.

En los microcontroladores la memoria no es abundante, aquí no encontrará

Gigabytes de memoria como en las computadoras personales. Típicamente la memoria de programas no excederá de 16 K-localizaciones de memoria no volátil (flash o eprom) para contener los programas.

La memoria RAM está destinada al almacenamiento de información

temporal que será utilizada por el procesador para realizar cálculos u otro tipo de operaciones lógicas. En el espacio de direcciones de memoria RAM se ubican además los registros de trabajo del procesador y los de configuración y trabajo de los distintos periféricos del microcontrolador. Es por ello que en la mayoría de los casos, aunque se tenga un espacio de direcciones de un tamaño determinado, la cantidad de memoria RAM de que dispone el programador para almacenar sus datos es menor que la que puede direccionar el procesador.

El tipo de memoria utilizada en las memorias RAM de los

microcontroladores es SRAM, lo que evita tener que implementar sistemas de refrescamiento como en el caso de las computadoras personales, que utilizan gran cantidad de memoria, típicamente alguna tecnología DRAM. A pesar de que la memoria SRAM es más costosa que la DRAM, es el tipo adecuado para los microcontroladores porque éstos poseen pequeñas cantidades de memoria RAM.

En el caso de la memoria de programas se utilizan diferentes tecnologías, y

el uso de una u otra depende de las características de la aplicación a desarrollar, a continuación se describen las cinco tecnologías existentes, que mayor utilización tienen o han tenido:

50

• Máscara ROM. En este caso no se “graba” el programa en memoria sino que el microcontrolador se fabrica con el programa, es un proceso similar al de producción de los CD comerciales mediante masterización. El costo inicial de producir un circuito de este tipo es alto, porque el diseño y producción de la máscara es un proceso costoso, sin embargo, cuando se necesitan varios miles o incluso cientos de miles de microcontroladores para una aplicación determinada, como por ejemplo, algún electrodoméstico, el costo inicial de producción de la máscara y el de fabricación del circuito se distribuye entre todos los circuitos de la serie y, el costo final de ésta, es bastante menor que el de sus semejantes con otro tipo de memoria.

• Memoria PROM (Programmable Read-Only Memory) también conocida como OTP (One Time Programmable). Este tipo de memoria, también es conocida como PROM o simplemente ROM.

Los microcontroladores con memoria OTP se pueden programar una sola

vez, con algún tipo de programador. Se utilizan en sistemas donde el programa no requiera futuras actualizaciones y para series relativamente pequeñas, donde la variante de máscara sea muy costosa, también para sistemas que requieren serialización de datos, almacenados como constantes en la memoria de programas.

• Memoria EPROM (Erasable Programmable Read Only Memory). Los microcontroladores con este tipo de memoria son muy fáciles de identificar porque su encapsulado es de cerámica y llevan encima una ventanita de vidrio desde la cual puede verse la oblea de silicio del microcontrolador.

Se fabrican así porque la memoria EPROM es reprogramable, pero antes

debe borrase, y para ello hay que exponerla a una fuente de luz ultravioleta, el proceso de grabación es similar al empleado para las memorias OTP.

Al aparecer tecnologías menos costosas y más flexibles, como las

memorias EEPROM y FLASH, este tipo de memoria han caído en desuso, se utilizaban en sistemas que requieren actualizaciones del programa y para los procesos de desarrollo y puesta a punto.

• EEPROM (Electrical Erasable Programmable Read Only Memory). Fueron el sustituto natural de las memorias EPROM, la diferencia fundamental es que pueden ser borradas eléctricamente, por lo que la ventanilla de cristal de cuarzo y los encapsulados cerámicos no son necesarios.

51

Al disminuir los costos de los encapsulados, los microcontroladores con este tipo de memoria se hicieron más baratos y cómodos para trabajar que sus equivalentes con memoria EPROM.

Otra característica destacable de este tipo de microcontrolador es que fue en ellos donde comenzaron a utilizarse los sistemas de programación en el sistema que evitan tener que sacar el microcontrolador de la tarjeta que lo aloja para hacer actualizaciones al programa.

• Memoria flash. En el campo de las memorias reprogramables para microcontroladores, son el último avance tecnológico en uso a gran escala, y han sustituido a los microcontroladores con memoria EEPROM.

A las ventajas de las memorias flash se le adicionan su gran densidad respecto a sus predecesoras lo que permite incrementar la cantidad de memoria de programas a un costo muy bajo. Pueden además ser programadas con las mismas tensiones de alimentación del microcontrolador, el acceso en lectura y la velocidad de programación es superior, disminución de los costos de producción, entre otras.

Lo más habitual es encontrar que la memoria de programas y datos está ubicada toda dentro del microcontrolador, de hecho, actualmente son pocos los microcontroladores que permiten conectar memoria de programas en el exterior del encapsulado. Las razones para estas “limitaciones” están dadas porque el objetivo fundamental es obtener la mayor integración posible y conectar memorias externas consume líneas de E/S que son uno de los recursos más preciados de los microcontroladores.

A pesar de lo anterior existen familias como la Intel 8051 cuyos microcontroladores tienen la capacidad de ser expandidos en una variada gama de configuraciones para el uso de memoria de programas externa. En el caso de los PIC, estas posibilidades están limitadas sólo a algunos microcontroladores de la gama alta, la Figura 5 muestra algunas de las configuraciones para memoria de programa que podemos encontrar en los microcontroladores. La configuración (a) es la típica y podemos encontrarla casi en el 100% de los microcontroladores. La configuración (b) es poco frecuente y generalmente se logra configurando al microcontrolador para sacrificar la memoria de programas interna, sin embargo el Intel 8031 es un microcontrolador sin memoria de programas interna. La configuración (c) es la que se encuentra habitualmente en los microcontroladores que tienen posibilidades de expandir su memoria de programas como algunos PIC de gama alta.

52

Cuando se requiere aumentar la cantidad de memoria de datos, lo más frecuente es colocar dispositivos de memoria externa en forma de periféricos, de esta forma se pueden utilizar memorias RAM, FLASH o incluso discos duros como los de los ordenadores personales, mientras que para los cálculos y demás operaciones que requieran almacenamiento temporal de datos se utiliza la memoria RAM interna del microcontrolador. Esta forma de expandir la memoria de datos está determinada, en la mayoría de los casos, por el tipo de repertorio de instrucciones del procesador y porque permite un elevado número de configuraciones distintas, además del consiguiente ahorro de líneas de E/S que se logra con el uso de memorias con buses de comunicación serie.

INTERRUPCIONES Las interrupciones son esencialmente llamadas a subrutina generadas por

los dispositivos físicos, al contrario de las subrutinas normales de un programa en ejecución. Como el salto de subrutina no es parte del hilo o secuencia de ejecución programada, el controlador guarda el estado del procesador en la pila de memoria y entra a ejecutar un código especial llamado "manejador de interrupciones" que atiende al periférico específico que generó la interrupción. Al terminar la rutina, una instrucción especial le indica al procesador el fin de la atención de la interrupción. En ese momento el controlador restablece el estado anterior, y el programa que se estaba ejecutando antes de la interrupción sigue como si nada hubiese pasado. Las rutinas de atención de interrupciones deben ser lo más breves posibles para que el rendimiento del sistema sea satisfactorio, porque normalmente cuando una interrupción es atendida, todas las demás interrupciones están en espera.

Imagine que está esperando la visita de un amigo, al que llamaremos Juan. Usted y Juan han acordado que cuando él llegue a su casa esperará pacientemente a que le abra la puerta. Juan no debe tocar a la puerta porque alguien en la casa duerme y no quiere que le despierten.

Ahora usted ha decidido leer un libro mientras espera a que Juan llegue a la casa, y para comprobar si ha llegado, cada cierto tiempo detiene la lectura, marca la página donde se quedó, se levanta y va hasta la puerta, abre y comprueba si Juan ha llegado, si éste todavía no está en la puerta, esperará unos minutos, cerrará la puerta y regresará a su lectura durante algún tiempo.

Como verá este es un método poco eficiente para esperar a Juan porque requiere que deje la lectura cada cierto tiempo y vaya hasta la puerta a comprobar si él ha llegado, además debe esperar un rato si todavía no llega. Y por si fuera poco, imagine que Juan no llega nunca porque se le presentó un problema, tuvo que cancelar la cita y no pudo avisarle a tiempo, o peor, que Juan ha llegado a la puerta un instante después que usted la cerraba.

53

Juan, respetando lo acordado, espera un tiempo, pero se cansa de esperar a que le abran y decide marcharse porque cree que ya usted no está en la casa o no puede atenderlo. A este método de atender la llegada de Juan lo llamaremos encuesta.

Veamos ahora otro método. En esta ocasión simplemente se recuesta en el sofá de la sala y comienza a leer su libro, cuando Juan llegue debe tocar el timbre de la puerta y esperar unos momentos a que le atiendan. Cuando usted oye sonar el timbre, interrumpe la lectura, marca la página donde se quedó y va hasta la puerta para atender a la persona que toca el timbre. Una vez que Juan o la persona que ha tocado el timbre, se marcha, usted regresa a su asiento y retoma la lectura justo donde la dejó. Este último es un método más eficiente que el anterior porque le deja más tiempo para leer y elimina algunos inconvenientes como el de que Juan nunca llegue o se marche antes de que usted abra la puerta. Es, en principio, un método simple pero muy eficaz y eficiente, lo llamaremos atención por interrupción.

El primero de ellos, la encuesta, es un método eficaz, pero poco eficiente porque requiere realizar lecturas constantes y muchas veces innecesarias del estado del proceso que queremos atender. Sin embargo, es muy utilizado en la programación de microcontroladores porque resulta fácil de aprender, la implementación de código con este método es menos compleja y no requiere de hardware especial para llevarla adelante. Por otra parte, la encuesta, tiene muchas deficiencias que con frecuencia obligan al diseñador a moverse hacia otros horizontes

El mundo está lleno de situaciones; de las cuales no podemos determinar ni cuando, ni cómo ni por qué se producen, en la mayoría de los casos lo único que podemos hacer es enterarnos de que determinada situación, asociada a un proceso, ha ocurrido. Para ello seleccionamos alguna condición o grupo de condiciones que nos indican que el proceso que nos interesa debe ser atendido, a este fenómeno, en el cual se dan las condiciones que nos interesa conocer, lo llamaremos evento. En el segundo ejemplo vemos que para atender a Juan, éste debe tocar el timbre, por tanto, la llegada de Juan es el proceso que debemos atender y el sonido del timbre es el evento que nos indica que Juan ha llegado.

El método de atención a procesos por interrupción, visto desde la óptica del ejemplo que utilicé para mostrarlo, es más simple que el de la encuesta, pero no es cierto, el método se complica porque requiere que el microprocesador incorpore circuitos adicionales para registrar los eventos que le indican que debe atender al proceso asociado y comprender estos circuitos y su dinámica no es una tarea sencilla.

54

Los circuitos para la atención a las interrupciones y todas las tareas que debe realizar el procesador para atender al proceso que lo interrumpe son bastante complejos y requieren una visión diferente de la que estamos acostumbrados a tener de nuestro mundo.

Los seres humanos no estamos conscientes de las interrupciones, en nuestro organismo existen mecanismos que nos interrumpen constantemente, para ello tenemos a nuestro sistema sensorial, pero no somos conscientes del proceso de interrupción, aunque sí de la atención a las interrupciones. Eso es porque incorporamos mecanismos que nos sacan rápidamente de la tarea que estemos haciendo para atender una situación que no puede o no debe esperar mucho tiempo. Bien, esa misma es la idea que se incorpora en los microprocesadores para atender procesos que no pueden esperar o que no sabemos cuándo deben ser atendidos porque ello depende de determinadas condiciones.

La cosa se complica en la secuencia de acciones a realizar desde el momento en que se desencadena el proceso de interrupción, hasta que se ejecuta el programa que lo atiende, y en la secuencia de acciones posteriores a la atención. Piense en cuantas cosas debe hacer su organismo ante una interrupción, utilicemos el segundo ejemplo para atender la llegada de Juan. Piense en cuantas cosas su cerebro hace a espaldas de su conciencia, desde el momento en que suena el timbre hasta que usted se encuentra listo (consciente de que es probable que Juan ha llegado) para abrir la puerta, y todo lo que su cerebro debe trabajar para retomar la lectura después que Juan se ha marchado. Todo eso, excepto abrir la puerta y atender a Juan, lo hacemos de forma “inconsciente” porque para ello tenemos sistemas dedicados en nuestro organismo, pero en el mundo de los microcontroladores debemos conocer todos esos detalles para poder utilizar los mecanismos de interrupción.

Los procesos de atención a interrupciones tienen la ventaja de que se implementan por hardware ubicado en el procesador, así que es un método rápido de hacer que el procesador se dedique a ejecutar un programa especial para atender eventos que no pueden esperar por mecanismos lentos como el de encuesta.

En términos generales, un proceso de interrupción y su atención por parte del procesador, tiene la siguiente secuencia de acciones:

1. En el mundo real se produce el evento para el cual queremos que el procesador ejecute un programa especial, este proceso tiene la característica de que no puede esperar mucho tiempo antes de ser atendido o no sabemos en qué momento debe ser atendido.

2. El circuito encargado de detectar la ocurrencia del evento se activa, y como consecuencia, activa la entrada de interrupción del procesador.

55

3. La unidad de control detecta que se ha producido una interrupción y “levanta” una bandera para registrar esta situación; de esta forma si las condiciones que provocaron el evento desaparecen y el circuito encargado de detectarlo desactiva la entrada de interrupción del procesador, ésta se producirá de cualquier modo, porque ha sido registrada.

4. La unidad de ejecución termina con la instrucción en curso y justo antes de comenzar a ejecutar la siguiente comprueba que se ha registrado una interrupción

5. Se desencadena un proceso que permite guardar el estado actual del programa en ejecución y saltar a una dirección especial de memoria de programas, donde está la primera instrucción de la subrutina de atención a interrupción.

6. Se ejecuta el código de atención a interrupción, esta es la parte “consciente” de todo el proceso porque es donde se realizan las acciones propias de la atención a la interrupción y el programador juega su papel.

7. Cuando en la subrutina de atención a interrupción se ejecuta la instrucción de retorno, se desencadena el proceso de restauración del procesador al estado en que estaba antes de la atención a la interrupción.

Como podemos observar, el mecanismo de interrupción es bastante complicado, sin embargo tiene dos ventajas que obligan a su implementación: la velocidad y su capacidad de ser asíncrono. Ambas de conjunto permiten que aprovechemos al máximo las capacidades de trabajo de nuestro procesador.

Los mecanismos de interrupción no solo se utilizan para atender eventos ligados a procesos que requieren atención inmediata sino que se utilizan además para atender eventos de procesos asíncronos.

Las interrupciones son tan eficaces que permiten que el procesador actúe como si estuviese haciendo varias cosas a la vez cuando en realidad se dedica a la misma rutina de siempre, ejecutar instrucciones una detrás de la otra.

PERIFÉRICOS Cuando observamos la organización básica de un microcontrolador,

señalamos que dentro de este se ubican un conjunto de periféricos. A continuación describiremos algunos de los periféricos que con mayor frecuencia encontraremos en los microcontroladores.

Entradas y salidas de propósito general También conocidos como puertos de E/S, generalmente agrupadas en

puertos de 8 bits de longitud, permiten leer datos del exterior o escribir en ellos desde el interior del microcontrolador, el destino habitual es el trabajo con dispositivos simples como relés, LED, o cualquier otra cosa que se le ocurra al programador.

56

Algunos puertos de E/S tienen características especiales que le permiten manejar salidas con determinados requerimientos de corriente, o incorporan mecanismos especiales de interrupción para el procesador.

Típicamente cualquier pin de E/S puede ser considerada E/S de propósito general, pero como los microcontroladores no pueden tener infinitos pines, ni siquiera todos los pines que queramos, las E/S de propósito general comparten los pines con otros periféricos. Para usar un pin con cualquiera de las características a él asignadas debemos configurarlo mediante los registros destinados a ellos.

Temporizadores y contadores Son circuitos sincrónicos para el conteo de los pulsos que llegan a su poder

para conseguir la entrada de reloj. Si la fuente de un gran conteo es el oscilador interno del microcontrolador es común que no tengan un pin asociado, y en este caso trabajan como temporizadores. Por otra parte, cuando la fuente de conteo es externa, entonces tienen asociado un pin configurado como entrada, este es el modo contador.

Los temporizadores son uno de los periféricos más habituales en los microcontroladores y se utilizan para muchas tareas, como por ejemplo, la medición de frecuencia, implementación de relojes, para el trabajo de conjunto con otros periféricos que requieren una base estable de tiempo entre otras funcionalidades. Es frecuente que un microcontrolador típico incorpore más de un temporizador/contador e incluso algunos tienen arreglos de contadores. Como veremos más adelante este periférico es un elemento casi imprescindible y es habitual que tengan asociada alguna interrupción. Los tamaños típicos de los registros de conteo son 8 y 16 bits, pudiendo encontrar dispositivos que solo tienen temporizadores de un tamaño o con más frecuencia con ambos tipos de registro de conteo.

Conversor analógico/digital Como es muy frecuente el trabajo con señales analógicas, éstas deben ser

convertidas a digital y por ello muchos microcontroladores incorporan un conversor analógico-digital, el cual se utiliza para tomar datos de varias entradas diferentes que se seleccionan mediante un multiplexor.

Las resoluciones más frecuentes son 8 y 10 bits, que son suficientes para aplicaciones sencillas. Para aplicaciones en control e instrumentación están disponibles resoluciones de 12bit, 16bit y 24bit. También es posible conectar un convertidor externo, en caso de necesidad

57

Puertos de comunicación Puerto serie Este periférico está presente en casi cualquier microcontrolador,

normalmente en forma de UART (Universal Asynchronous Receiver Transmitter) o USART (Universal Synchronous Asynchronous Receiver Transmitter) dependiendo de si permiten o no el modo sincrónico de comunicación.

El destino común de este periférico es la comunicación con otro microcontrolador o con una PC y en la mayoría de los casos hay que agregar circuitos externos para completar la interfaz de comunicación. La forma más común de completar el puerto serie es para comunicarlo con una PC mediante la interfaz EIA-232 (más conocida como RS-232), es por ello que muchas personas se refieren a la UART o USART como puerto serie RS-232, pero esto constituye un error, puesto que este periférico se puede utilizar para interconectar dispositivos mediante otros estándares de comunicación. En aplicaciones industriales se utiliza preferiblemente RS-485 por su superior alcance en distancia, velocidad y resistencia al ruido.

SPI Este tipo de periférico se utiliza para comunicar al microcontrolador con

otros microcontroladores o con periféricos externos conectados a él, por medio de una interfaz muy sencilla. Hay solo un nodo controlador que permite iniciar cualquier transacción, lo cual es una desventaja en sistemas complejos, pero su sencillez permite el aislamiento galvánico de forma directa por medio de opto acopladores.

I2C Cumple las mismas funciones que el SPI, pero requiere menos señales de

comunicación y cualquier nodo puede iniciar una transacción. Es muy utilizado para conectar las tarjetas gráficas de las computadoras personales con los monitores, para que estos últimos informen de sus prestaciones y permitir la autoconfiguración del sistema de vídeo.

USB Los microcontroladores son los que han permitido la existencia de este

sistema de comunicación. Es un sistema que trabaja por polling (monitorización) de un conjunto de periféricos inteligentes por parte de un amo, que es normalmente un computador personal. Cada modo inteligente está gobernado inevitablemente por un microcontrolador.

Ethernet Es el sistema más extendido en el mundo para redes de área

local cableadas. Los microcontroladores más poderosos de 32 bits se usan para implementar periféricos lo suficientemente poderosos como para que puedan ser accesados directamente por la red.

58

Muchos de los enrutadores caseros de pequeñas empresas están construidos en base a un microcontrolador que hace del cerebro del sistema.

Can Este protocolo es del tipo CSMA/CD con tolerancia a elevados voltajes de

modo común y orientado al tiempo real. Este protocolo es el estándar más importante en la industria automotriz (OBD). También se usa como capa física del "field bus" para el control industrial.

Otros puertos de comunicación Hay una enorme cantidad de otros buses disponibles para la industria

automotriz (linbus) o de medios audiovisuales como el i2s, IEEE 1394. Es usuario se los encontrará cuando trabaje en algún área especializada.

Comparadores Son circuitos analógicos basados en amplificadores operacionales que

tienen la característica de comparar dos señales analógicas y dar como salida los niveles lógicos ‘0’ o ‘1’ en dependencia del resultado de la comparación. Es un periférico muy útil para detectar cambios en señales de entrada de las que solamente nos interesa conocer cuando está en un rango determinado de webetas

Modulador de ancho de pulsos Los PWM (Pulse Width Modulator) son periféricos muy útiles sobre todo

para el control de motores, sin embargo hay un grupo de aplicaciones que pueden realizarse con este periférico, dentro de las cuales podemos citar: inversión DC/AC para UPS, conversión digital analógica D/A, control regulado de luz (dimming) entre otras.

Memoria de datos no volátil Muchos microcontroladores han incorporado este tipo de memoria como un

periférico más, para el almacenamiento de datos de configuración o de los procesos que se controlan. Esta memoria es independiente de la memoria de datos tipo RAM o la memoria de programas, en la que se almacena el código del programa a ejecutar por el procesador del microcontrolador.

Muchos de los microcontroladores PIC, incluyen este tipo de memoria, típicamente en forma de memoria EEPROM, incluso algunos de ellos permiten utilizar parte de la memoria de programas como memoria de datos no volátil, por lo que el procesador tiene la capacidad de escribir en la memoria de programas como si ésta fuese un periférico más.

59

MICROCONTROLADORES ATMEL AVR Los AVR son una familia de microcontroladores RISC del fabricante

estadounidense Atmel. La arquitectura de los AVR fue concebida por dos estudiantes en el Norwegian Institute of Technology, y posteriormente refinada y desarrollada en Atmel Norway , la empresa subsidiaria de Atmel, fundada por los dos arquitectos del chip. Cuenta con bastantes aficionados debido a su diseño simple y la facilidad de programación. Se pueden dividir en los siguientes grupos :

• ATxmega : procesadores muy potentes con 16 a 384 kB de memoria flash programable, encapsulados de 44, 64 y 100 pines (A4, A3, A1), capacidad de DMA, eventos, criptografía y amplio conjunto de periféricos con DACs.

• ATmega : microcontroladores AVR grandes con 4 a 256 kB de memoria flash programable, encapsulados de 28 a 100 pines, conjunto de instrucciones extendido (multiplicación y direccionamiento de programas mayores) y amplio conjunto de periféricos.

• ATtiny : pequeños microcontroladores AVR con 0,5 a 8 kB de memoria flash programable, encapsulados de 6 a 20 pines y un limitado set de periféricos.

• AT90USB : ATmega integrado con controlador USB • AT90CAN : ATmega con controlador de bus CAN • Tipos especiales: algunos modelos especiales, por ejemplo, para el

control de los cargadores de baterías, pantallas LCD y los controles de los motores o la iluminación.

• AT90S: tipos obsoletos, los AVRs clásicos Bajo el nombre AVR32, Atmel tiene una arquitectura RISC de 32 bits con

soporte de DSP y SIMD. A pesar de la similitud de sus nombres y logotipos, las dos arquitecturas tienen poco en común.

El AVR es una CPU de arquitectura Harvard. Tiene 32 registros de 8 bits. Algunas instrucciones sólo operan en un subconjunto de estos registros. La concatenación de los 32 registros, los registros de entrada/salida y la memoria de datos conforman un espacio de direcciones unificado, al cual se accede a través de operaciones de carga/almacenamiento. A diferencia de los microcontroladores PIC, el stack se ubica en este espacio de memoria unificado, y no está limitado a un tamaño fijo.

El AVR fue diseñado desde un comienzo para la ejecución eficiente de código C compilado. Como este lenguaje utiliza profusamente punteros para el manejo de variables en memoria, los tres últimos pares de registros internos del procesador son usados como punteros de 16 bit al espacio de memoria externa, bajo los nombres X, Y y Z. Esto es un compromiso que se hace en arquitecturas de ocho bit desde los tiempos de Intel 8008, ya que su tamaño de palabra nativo de 8 bit (256 localidades accedidas) es pobre para direccionar.

60

Por otro lado, hacer que todo el banco superior de 16 registros de 8 bit tenga un comportamiento alterno como un banco de 8 registros de 16 bit, complicaría mucho el diseño, violando la premisa original de su simplicidad. Además, algunas instrucciones tales como 'suma inmediata' ('add immediate' en inglés) faltan, ya que la instrucción 'resta inmediata' ('substract immediate' en inglés) con el complemento dos puede ser usada como alternativa.

El set de instrucciones AVR está implementado físicamente y disponible en el mercado en diferentes dispositivos, que comparten el mismo núcleo AVR pero tienen distintos periféricos y cantidades de RAM y ROM: desde el microcontrolador de la familia Tiny AVR ATtiny11 con 1KB de memoria flash y sin RAM (sólo los 32 registros), y 8 pines, hasta el microcontrolador ATmega2560 de la familia Mega AVR con 256KB de memoria flash, 8KB de memoria RAM, 4KB de memoria EEPROM, conversor análogo digital de 10 bits y 16 canales, temporizadores, comparador analógico, JTAG, etc. La compatibilidad entre los distintos modelos es preservada en un grado razonable.

Los microcontroladores AVR tienen una cañería ('pipeline' en inglés) con dos etapas (cargar y ejecutar), que les permite ejecutar la mayoría de las instrucciones en un ciclo de reloj, lo que los hace relativamente rápidos entre los microcontroladores de 8-bit.

El set de instrucciones de los AVR es más regular que la de la mayoría de los microcontroladores de 8-bit (por ejemplo, los PIC). Sin embargo, no es completamente ortogonal:

• Los registros punteros X, Y y Z tienen capacidades de direccionamiento diferentes entre sí (ver más arriba por qué).

• Los registros 0 al 15 tienen diferentes capacidades de direccionamiento que los registros 16 al 31.

• Las registros de I/O 0 al 31 tienen distintas características que las posiciones 32 al 63.

• La instrucción CLR afecta los 'flag', mientras que la instrucción SER no lo hace, a pesar de que parecen ser instrucciones complementarias (dejar todos los bits en 1, y dejar todos los bits en 0, respectivamente).

• Los códigos de operación 0x95C8 y 0x9004 hacen exactamente lo mismo (LPM).

1.1.2.3 ARDUINO Arduino es una plataforma de hardware libre, basada en una placa con

un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos de entrada/salida.

61

Los microcontroladores más usados son el Atmega168, Atmega328, Atmega1280, ATmega8 por su sencillez y bajo coste que permiten el desarrollo de múltiples diseños. Por otro lado el software consiste en un entorno de desarrollo que implementa el lenguaje de programación Processing/Wiring y el cargador de arranque (boot loader) que corre en la placa.

Desde octubre de 2012, Arduino se usa también con microcontroladores CortexM3 de ARM de 32 bits, que coexistirán con las más limitadas, pero también económicas AVR de 8 bits. ARM y AVR no son plataformas compatibles a nivel binario, pero se pueden programar con el mismo IDE de Arduino y hacerse programas que compilen sin cambios en las dos plataformas. Eso sí, los microcontroladores CortexM3 usan 3.3V, a diferencia de la mayoría de las placas con AVR que usan mayormente 5V. Sin embargo ya anteriormente se lanzaron placas Arduino con Atmel AVR a 3.3V como la Arduino Fio y existen clónicos de Arduino Nano y Pro como Meduino en que se puede conmutar el voltaje.

Arduino se puede utilizar para desarrollar objetos interactivos autónomos o puede ser conectado a software del ordenador (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). Las placas se pueden montar a mano o adquirirse. El entorno de desarrollo integrado libre se puede descargar gratuitamente.

Al ser open-hardware, tanto su diseño como su distribución son libres. Es decir, puede utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.

El proyecto Arduino recibió una mención honorífica en la categoría de Comunidades Digital en el Prix Ars Electrónica de 2006.

Entradas y salidas Poniendo de ejemplo al Diecimila, consta de 14 entradas digitales

configurables entrada i/o salidas que operan a 5 voltios. Cada pin puede proporcionar o recibir como máximo 40 mA. Los pines 3, 5, 6, 8, 10 y 11 pueden proporcionar una salida PWM (Pulse Width Modulation). Si se conecta cualquier cosa a los pines 0 y 1, eso interferirá con la comunicación USB. Diecimila también tiene 6 entradas analógicas que proporcionan una resolución de 10 bits. Por defecto miden de 0 voltios (masa) hasta 5 voltios, aunque es posible cambiar el nivel más alto, utilizando el pin Aref y algún código de bajo nivel.

Lenguaje de programación Arduino La plataforma Arduino se programa mediante el uso de un lenguaje propio

basado en el popular lenguaje de programación de alto nivel Processing. Sin embargo, es posible utilizar otros lenguajes de programación y aplicaciones populares en Arduino. Algunos ejemplos son:

62

• Java • Flash (mediante ActionScript) • Processing • Pure Data • MaxMSP (entorno gráfico de programación para aplicaciones

musicales, de audio y multimedia) • VVVV (síntesis de vídeo en tiempo real) • Adobe Director • Python • Ruby • C • C++ (mediante libSerial o en Windows) • C# • Cocoa/Objective-C (para Mac OS X) • Linux TTY (terminales de Linux) • 3DVIA Virtools (aplicaciones interactivas y de tiempo real) • SuperCollider (síntesis de audio en tiempo real) • Instant Reality (X3D) • Liberlab (software de medición y experimentación) • BlitzMax (con acceso restringido) • Squeak (implementación libre de Smalltalk) • Mathematica • Matlab • Minibloq (Entorno gráfico de programación, corre también en OLPC) • Isadora (Interactividad audiovisual en tiempo real) • Perl • Physical Etoys (Entorno gráfico de programación usado para

proyectos de robótica educativa) • Scratch for Arduino (S4A) (entorno gráfico de programación,

modificación del entorno para niños Scratch, del MIT) • Visual Basic .NET • VBScript • Gambas • Php Esto es posible debido a que Arduino se comunica mediante la transmisión

de datos en formato serie que es algo que la mayoría de los lenguajes anteriormente citados soportan. Para los que no soportan el formato serie de forma nativa, es posible utilizar software intermediario que traduzca los mensajes enviados por ambas partes para permitir una comunicación fluida.

63

Es bastante interesante tener la posibilidad de interactuar Arduino mediante esta gran variedad de sistemas y lenguajes puesto que dependiendo de cuales sean las necesidades del problema que vamos a resolver podremos aprovecharnos de la gran compatibilidad de comunicación que ofrece.

Funciones básicas y operadores Arduino está basado en C y soporta todas las funciones del estándar C y

algunas de C++. A continuación se muestra un resumen con todas la estructura del lenguaje Arduino:

Sintaxis Básica • Delimitadores: ;, • Comentarios: //, /* */ • Cabeceras: #define, #include • Operadores aritméticos: +, -, *, /, % • Asignación: = • Operadores de comparación: ==, !=, <, >, <=, >= • Operadores Booleanos: &&, ||, ! • Operadores de acceso a punteros: *, & • Operadores de bits: &, |, ^, ~, <<, >> • Operadores compuestos: • Incremento/decremento de variables: ++, -- • Asignación y operación: +=, -=, *=, /=, &=, |= Estructuras de control • Condicionales: if, if...else, switch case • Bucles: for, while, do... while • Bifurcaciones y saltos: break, continue, return, goto Variables En cuanto al tratamiento de las variables también comparte un gran

parecido con el lenguaje C. Constantes • HIGH / LOW: niveles alto y bajo en pines. Los niveles altos son

aquellos de 3 voltios o más. • INPUT / OUTPUT: entrada o salida • true / false Tipos de datos • void, boolean, char, unsigned char, byte, int, unsigned int, word, long,

unsigned long, float, double, string, array Conversión entre tipos Estas funciones reciben como argumento una variable de cualquier tipo y

devuelven una variable convertida en el tipo deseado.

64

• char(), byte(), int(), word(), long(), float() Cualificadores y ámbito de las variables • static, volatile, const Utilidades • sizeof()

Funciones Básicas En cuanto a las funciones básicas del lenguaje nos encontramos con las

siguientes: E/S Digital • pinMode(pin, modo) • digitalWrite(pin, valor) • int digitalRead(pin) E/S Analógica • analogReference(tipo) • int analogRead(pin) • analogWrite(pin, valor) E/S Avanzada • shiftOut(dataPin, clockPin, bitOrder, valor) • unsigned long pulseIn(pin, valor) Tiempo • unsigned long millis() • unsigned long micros() • delay(ms) • delayMicroseconds(microsegundos) Matemáticas • min(x, y), max(x, y), abs(x), constrain(x, a, b), map(valor, fromLow,

fromHigh, toLow, toHigh), pow(base, exponente), sqrt(x) Trigonometría • sin(rad), cos(rad), tan(rad) Números aleatorios • randomSeed(semilla), long random(máx), long random(mín, máx) Bits y Bytes • lowByte(), highByte(), bitRead(), bitWrite(), bitSet(), bitClear(), bit() Interrupciones externas • attachInterrupt(interrupción, función, modo) • detachInterrupt(interrupción) Interrupciones • interrupts(), noInterrupts()

65

Comunicación por puerto serie Las funciones de manejo del puerto serie deben ir precedidas de "Serial."

aunque no necesitan ninguna declaración en la cabecera del programa. Por esto se consideran funciones base del lenguaje.

• begin(), available(), read(), flush(), print(), println(), write() Manipulación de puertos Los registros de puertos permiten la manipulación a más bajo nivel y de

forma más rápida de los pines de E/S del microcontrolador de las placas Arduino. Los pines de las placas Arduino están repartidos entre los registros B(0-7), C (analógicos) y D(8-13). Mediante las siguientes variables podemos ver y modificar su estado:

• DDR[B/C/D]: Data Direction Register (o dirección del registro de datos) del puerto B, C ó D. Sirve para especificar que pines queremos usar como de entrada y cuáles de salida. Variable de Lectura/Escritura.

• PORT[B/C/D]: Data Register (o registro de datos) del puerto B, C ó D. Variable de Lectura/Escritura.

• PIN[B/C/D]: Input Pins Register (o registro de pines de entrada) del puerto B, C ó D. Variable de sólo lectura.

Por ejemplo, para especificar que queremos utilizar los pines 9 a 13 como salidas y el 8 como entrada (puesto que el puerto D usa los pines de la placa Arduino 8 al 13 digitales) bastaría utilizar la siguiente asignación:

DDRD = B11111110;

Como se ha podido comprobar, si conocemos el lenguaje C, no tendremos dificultades para programar en Arduino puesto que se parecen enormemente. Tan sólo debemos aprender algunas funciones específicas de que dispone el lenguaje para manejar los diferentes parámetros de Arduino. Se pueden construir aplicaciones de cierta complejidad sin necesidad de muchos conceptos previos.

A.V.R. Libc Los programas compilados con Arduino (salvo en las placas con CorteX

M3) se enlazan contra AVR Libc por lo que tienen acceso a algunas de sus funciones. AVR Libc es un proyecto de software libre con el objetivo de proporcionar una biblioteca C de alta calidad para utilizarse con el compilador GCC sobre microcontroladores Atmel AVR. Se compone de 3 partes:

• avr-binutils • avr-gcc • avr-libc

La mayoría del lenguaje de programación Arduino está escrita con constantes y funciones de AVR y ciertas funcionalidades sólo se pueden obtener haciendo uso de AVR.

66

Interrupciones Para desactivar las interrupciones:

cli(); // desactiva las interrupciones globales

Para activarlas:

sei(); // activa las interrupciones

Esto afectará al temporizador y a la comunicación serie. La función delayMicroseconds() desactiva las interrupciones cuando se ejecuta.

Temporizadores La función delayMicroseconds() crea el menor retardo posible del lenguaje

Arduino que ronda los 2µs. Para retardos más pequeños se debe utilizar la llamada de ensamblador

'nop' (no operación). Cada sentencia 'nop' se ejecutará en un ciclo de máquina (16 Mhz): unos 62.5ns. Se haría de la siguiente manera:

__asm__("nop\n\t");

Manipulación de puertos La manipulación de puertos con código AVR es más rápida que utilizar la

función digitalWrite() de Arduino. Establecer Bits en variables cbi y sbi son mecanismos estándar (AVR) para establecer o limpiar bits en

PORT y otras variables. Será necesario utilizar las siguientes cabeceras para poder utilizarlos:

# ifndef cbi # define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) # endif # ifndef sbi # define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) # endif

Para utilizarlas hay que pasarles como argumento la variable PORT y un pin para establecerlo o limpiarlo.

Gracias a estos pequeños hacks tendremos la posibilidad de mejorar los tiempos de ejecución de ciertas tareas críticas o de aquellas que se repitan muchas veces obteniendo mejores resultados. No obstante el código fuente que escribamos resultará probablemente menos legible si los utilizamos por lo que habrá que sopesarlo en función de nuestras necesidades.

67

Diferencias con Processing La sintaxis del lenguaje de programación Arduino es una versión

simplificada de C/C++ y tiene algunas diferencias respecto de Processing. Ya desde el punto de que Arduino está basado en C/C++ mientras que Processing se basa en Java. En cuanto a la sintaxis de ambos lenguajes y el modo en que se programan existen también varias diferencias:

• Arrays

Arduino Processing int bar[8]; bar[0] = 1;

int[] bar = new int[8]; bar[0] = 1;

int foo[] = 0, 1, 2 ; int foo[] = 0, 1, 2 ; o bien int[] foo = 0, 1, 2 ;

• Impresión de cadenas

Arduino Processing Serial.println("hello world"); println("hello world"); int i = 5; Serial.println(i);

int i = 5; println(i);

int i = 5; Serial.print("i = "); Serial.print(i); Serial.println();

int i = 5; println("i = " + i);

Las diferencias son escasas por lo que alguien que conozca bien Processing tendrá muy pocos problemas a la hora de programar en Arduino.

Primer contacto: Hola Mundo en Arduino El primer paso antes de comprobar que la instalación es correcta y empezar

a trabajar con Arduino es abrir algunos ejemplos prácticos que vienen disponibles con el dispositivo. Es recomendable abrir el ejemplo “led_blink” que encontraremos en el menú File, Sketchbook, Examples, led_blink. Este código crea una intermitencia por segundo en un led conectado en el pin 13. Es cuestión de comprobar que el código es correcto, para eso, presionamos el botón que es un triángulo (en forma de "play") y seguidamente haremos un "upload" (que es la flecha hacia la derecha) para cargar el programa a la placa. Si el led empieza a parpadear, todo estará correcto.

68

Veamos el código necesario para conseguirlo:

# define LED_PIN 13 void setup () // Activamos el pin 13 para salida digital pinMode (LED_PIN, OUTPUT); // Bucle infinito void loop () // Encendemos el led enviando una señal alta digitalWrite (LED_PIN, HIGH); // Esperamos un segundo (1000 ms) delay (1000); // Apagamos el led enviando una señal baja digitalWrite (LED_PIN, LOW); // Esperamos un segundo (1000 ms) delay (1000);

El orden de ejecución será: Primero se hace una llamada a la función init()

que inicializa el programa, después se ejecuta la función setup() que configura diversos parámetros, y por último se ejecuta un bucle while(1) que llama repetidamente a la función loop. Todo ello se ejecuta dentro de main() y podría haberse indicado explícitamente (en el caso anterior se encarga el IDE de añadir el código que se ha omitido).

Bibliotecas en Arduino Para hacer uso de una biblioteca en Sketch (el IDE de Arduino), basta con

hacer clic sobre “Import Library” en el menú, escoger una biblioteca y se añadirá el #include correspondiente. Las bibliotecas estándar que ofrece Arduino son las siguientes:

Serial Lectura y escritura por el puerto serie. EEPROM Lectura y escritura en el almacenamiento permanente.

• read(), write()

69

Ethernet Conexión a Internet mediante “Arduino Ethernet Shield“. Puede funcionar

como servidor que acepta peticiones remotas o como cliente. Se permiten hasta cuatro conexiones simultaneas.

• Servidor: Server(), begin(), available(), write(), print(), println() • Cliente: Client(), connected(), connect(), write(), print(), println(),

available(), read(), flush(), stop() Firmata Comunicación con aplicaciones de ordenador utilizando el protocolo

estándar del puerto serie. LiquidCrystal Control de LCDs con chipset Hitachi HD44780 o

compatibles. La biblioteca soporta los modos de 4 y 8 bits. Servo Control de servo motores. A partir de la versión 0017 de Arduino la

biblioteca soporta hasta 12 motores en la mayoría de placas Arduino y 48 en la Arduino Mega.

• attach(), write(), writeMicroseconds(), read(), attached(), detach() El manejo de la biblioteca es bastante sencillo. Mediante attach(número de

pin) añadimos un servo y mediante write podemos indicar los grados que queremos que tenga el motor (habitualmente de 0 a 180).

Software Serial Comunicación serie en pines digitales. Por defecto Arduino incluye

comunicación sólo en los pines 0 y 1 pero gracias a esta biblioteca podemos realizar esta comunicación con el resto de pines.

Stepper Control de motores paso a paso unipolares o bipolares.

• Stepper(steps, pin1, pin2), Stepper(steps, pin1, pin2, pin3, pin4), setSpeed(rpm), step(steps)

El manejo es sencillo. Basta con iniciar el motor mediante Stepper indicando los pasos que tiene y los pines a los que está asociado. Se indica la velocidad a la que queramos que gire en revoluciones por minuto con setSpeed(rpm) y se indican los pasos que queremos que avance con step(pasos).

Wire Envío y recepción de datos sobre una red de dispositivos o sensores

mediante Two Wire Interface (TWI/I2C). Además las bibliotecas Matrix y Sprite de Wiring son totalmente compatibles

con Arduino y sirven para manejo de matrices de leds. También se ofrece información sobre diversas bibliotecas desarrolladas por

contribuidores diversos que permiten realizar muchas tareas.

70

Creación de bibliotecas Además de las bibliotecas base, las que son compatibles y las que han

aportado otras personas tenemos la posibilidad de escribir nuestra propia biblioteca. Esto es muy interesante por varias razones: permite disponer de código que puede reutilizarse en otros proyectos de forma cómoda; nos permite mantener el código fuente principal separado de las bibliotecas de forma que sean mantenibles de forma separada; y la organización de los programas construidos es más clara y elegante.

Veamos un ejemplo de la creación de una biblioteca que envía código Morse:

Creamos el fichero Morse.h que incluye la definición de la clase Morse que tiene 3 funciones: un constructor (Morse()), una función para enviar 1 punto (dot()) y una función para enviar una raya (dash()). La variable _pin permite indicar el pin que vamos a utilizar. /* Morse.h - Library for flashing Morse code. Created by David A. Mellis, November 2, 2007. Released into the public domain. */ # ifndef Morse_h # define Morse_h # include "WProgram.h" class Morse public: Morse(int pin); void dot(); void dash(); private: int _pin; ; # endif

71

Además necesitaremos un fichero Morse.cpp con el código, es decir con la implementación de los métodos declarados: /* Morse.cpp - Library for flashing Morse code. Created by David A. Mellis, November 2, 2007. Released into the public domain. */ # include "WProgram.h" # include "Morse.h" Morse::Morse(int pin) pinMode(pin, OUTPUT); _pin = pin; void Morse::dot() digitalWrite(_pin, HIGH); delay(250); digitalWrite(_pin, LOW); delay(250); void Morse::dash() digitalWrite(_pin, HIGH); delay(1000); digitalWrite(_pin, LOW); delay(250);

Y con esto ya podríamos utilizar la biblioteca mediante el correspondietne #include. Si quisiéramos enviar un SOS por el pin 13 bastaría con llamar a Morse(13) y ejecutar

72

morse.dot(); morse.dot(); morse.dot(); morse.dash(); morse.dash(); morse.dash(); morse.dot(); morse.dot(); morse.dot();

Instalación Windows Para la instalación de la placa Arduino en el sistema operativo Windows

conviene seguir los siguientes pasos: Con la placa desconectada:

Interfaz del entorno de desarrollo Arduino S.O. Windows. • Descargar e instalar el Java Runtime Enviroment (J2RE). • Descargar la última versión del IDE Arduino. Nota: Es recomendable descomprimir el fichero en el directorio raíz (c:\)

manteniendo la estructura original. • Entre todas las carpetas creadas en el directorio Arduino conviene

destacar las siguientes:

c:\arduino-0012\hardware\bootloader:

73

Ésta contiene el software necesario para cargar el firmware en el chip Atmega168, para trabajar con Arduino. Sólo se utiliza si os habéis montado vosotros mismos la placa, o en el caso que se haya estropeado el chip y hayáis comprado uno nuevo.

c:\arduino-0012\drivers:

Contiene los drivers necesarios para el funcionamiento de la placa Arduino con el PC con S.O. Windows: FTDI USB Drivers.

Instalar FTDI USB Drivers Ahora sí, conectar la placa USB. Se abrirá automáticamente el asistente de

Windows para nuevo hardware encontrado: 1. Seleccionar "No por el momento" y presionar "Siguiente". 2. Seleccionar "Instalar desde una lista o ubicación específica

(avanzado)" y presionar "Siguiente". 3. "Buscar el controlador más adecuado en estas ubicaciones"

presiona "Examinar".Seleccionar la carpeta donde hayas descomprimido el driver y presiona “Siguiente”. Si no habido ningún problema el driver de la placa estará instalado. Abrir el IDE Arduino Ejecutamos el fichero Arduino.exe para abrir la interface. Aquí configuramos

el puerto USB donde tenemos conectada la placa para empezar a trabajar.

74

GNU/Linux

Interfaz del entorno de desarrollo Arduino S.O. GNU/Linux. Para instalar Arduino en un sistema GNU/Linux necesitamos los siguientes

programas para resolver las dependencias: • Sun java runtime, jre. • avr-gcc, compilador para la familia de microcontroladores avr de

atmel. • avr-libc, libc del compilador avr-gcc.

Para instalarlos, podemos utilizar el gestor de paquetes o el terminal de comandos. En distribuciones basadas en Debian, ejecutaríamos:

apt-get install sun-java5-jre gcc-avr avr-libc

75

En algunas distribuciones conviene desinstalar, si no es necesario, el programa "brltty". Éste se encarga de permitir el acceso al terminal para personas ciegas a través de un dispositivo especial en braille.

killall brltty apt-get remove brltty

Los dos síntomas de este problema son: • No aparece la opción /dev/tty/USB0 en el menú Tools, Serial Port. • Si se observa el LED Rx de la placa Arduino, éste se ilumina de 3 a 5

veces cada 5 ó 6 segundos. Por último, descargamos el framework de Arduino. Lo descomprimimos en

la carpeta deseada y lo ejecutamos:

./Arduino

Si todo ha ido bien ya lo tendremos en funcionamiento. Aplicaciones Las aplicaciones que nos ofrece Arduino son múltiples, y dependerá de

nuestra imaginación. Mediante sensores podemos crear aplicaciones sencillas enfocadas a la docencia para estudiantes de electrónica, proyectos más elaborados para la industria o incluso sistemas dirigidos simplemente al ocio. Es muy utilizado también en los entornos artísticos para crear obras más elaboradas, dada su facilidad de programación.

76

1.2 ELECTRICIDAD La electricidad (del griego elektron, cuyo significado es ámbar) es un

fenómeno físico cuyo origen son las cargas eléctricas y cuya energía se manifiesta en fenómenos mecánicos, térmicos, luminosos y químicos, entre otros, en otras palabras es el flujo de electrones.

Se puede observar de forma natural en fenómenos atmosféricos, por ejemplo los rayos, que son descargas eléctricas producidas por la transferencia de energía entre la ionosfera y la superficie terrestre.

1.2.1 VOLTAJE El voltaje eléctrico o diferencia de potencial es una magnitud física que

cuantifica la diferencia de potencial eléctrico entre dos puntos. También se puede definir como el trabajo por unidad de carga ejercido por

el campo eléctrico sobre una partícula cargada para moverla entre dos posiciones determinadas. Se puede medir con un voltímetro.

También es denominada como voltaje cuando se expresa en voltios (V),

que es la unidad del Sistema Internacional de Unidades para esta magnitud y para el potencial eléctrico.

El voltaje es independiente del camino recorrido por la carga y depende

exclusivamente del potencial eléctrico de los puntos A y B en el campo eléctrico, que es un campo conservativo.

Si dos puntos que tienen una diferencia de potencial se unen mediante un

conductor, se producirá un flujo de electrones. Parte de la carga que crea el punto de mayor potencial se trasladará a través del conductor al punto de menor potencial y, en ausencia de una fuente externa (generador), esta corriente cesará cuando ambos puntos igualen su potencial eléctrico (ley de Henry). Este traslado de cargas es lo que se conoce como corriente eléctrica.

Cuando se habla sobre una diferencia de potencial en un sólo punto, o

potencial, se refiere a la diferencia de potencial entre este punto y algún otro donde el potencial sea cero.

77

1.2.2 CORRIENTE ELÉCTRICA La corriente o intensidad eléctrica es el flujo de carga por unidad de tiempo

que recorre un material. Se debe a un movimiento de los electrones en el interior del material. En el Sistema Internacional de Unidades se expresa en C/s (culombios sobre segundo), unidad que se denomina amperio. Una corriente eléctrica, puesto que se trata de un movimiento de cargas, produce un campo magnético, lo que se aprovecha en el electroimán.

El instrumento usado para medir la intensidad de la corriente eléctrica es el

galvanómetro que, calibrado en amperios, se llama amperímetro, colocado en serie con el conductor cuya intensidad se desea medir.

1.2.3 RESISTENCIA ELÉCTRICA La resistencia eléctrica de un objeto es una medida de su oposición al paso

de corriente. Descubierta por Georg. Ohm en 1827, la resistencia eléctrica tiene un

parecido conceptual a la fricción en la física mecánica. La unidad de la resistencia en el Sistema Internacional de Unidades es el ohmio (Ω). Para su medición en la práctica existen diversos métodos, entre los que se encuentra el uso de un ohmímetro. Además, su cantidad recíproca es la conductancia, medida en Siemens.

Para una gran cantidad de materiales y condiciones, la resistencia eléctrica depende de la corriente eléctrica que pasa a través de un objeto y el voltaje en los terminales de este. Esto significa que, dada una temperatura y un material, la resistencia es un valor que se mantendrá constante. Además, de acuerdo con la ley de Ohm la resistencia de un material puede definirse como la razón de la tensión y la corriente.

1.2.4 CIRCUITO ELÉCTRICO Un circuito es una red eléctrica (interconexión de dos o más componentes,

tales como resistencias, inductores, capacitores, fuentes, interruptores y semiconductores) que contiene al menos una trayectoria cerrada. Los circuitos que contienen solo fuentes, componentes lineales (resistores, capacitores, inductores), y elementos de distribución lineales (líneas de transmisión o cables) pueden analizarse por métodos algebraicos para determinar su comportamiento en corriente directa o en corriente alterna.

78

Un circuito que tiene componentes electrónicos es denominado un circuito electrónico. Estas redes son generalmente no lineales y requieren diseños y herramientas de análisis mucho más complejos.

79

CAPITULO 2 DESARROLLO 2.1 INTRODUCCIÓN Como acción principal, llevé a cabo el reconocimiento de los componentes

que utilicé para poder desarrollar este proyecto; los cuales serán mencionados y descritos a lo largo de este capítulo. Cabe mencionar que, dentro del reconocimiento de componentes, me encontré con un dispositivo el cual debía ser controlado mediante comunicación SPI.

Fue así como el siguiente paso consistió en investigar todo lo relacionado a

la comunicación SPI; tema que implementé, en un inicio, entre el microcontrolador ATmega8 y el microcontrolador ATmega328P.

Al conocer las características de la comunicación SPI y el correcto control

del mismo, fue necesario conocer otros dispositivos que utilizaran este tipo de comunicación, de esta manera fue que conocí la plataforma de hardware abierto “ARDUINO”, plataforma que tuve que investigar a fondo.

Obtenido el control de los puntos anteriores, la siguiente acción consistió en

investigar y estudiar el componente denominado TRANSCEPTOR nRF24L01+ , el cual es la base de este proyecto.

Una vez estudiados y controlados los componentes principales para este

proyecto, mi siguiente paso fue, implementar la comunicación SPI entre el microcontrolador ATmega328 y el transceptor; en esta implementación solo conseguí leer y escribir en los registros pertenecientes al transceptor, es decir poder ver y modificar sus valores por defecto.

Hasta este momento pude asegurar que, una vez dominados los comandos

de lectura y escritura, era momento de dar el gran salto. De esta manera fue que realicé la comunicación entre la plataforma ARDUINO y el transceptor, esto con el fin de controlar a un transceptor como TRANSMISOR y a otro como RECEPTOR, y así poder enviar y recibir el incremento de una variable (de 0 a 255).

Era necesario perfeccionar lo que se tenía hasta el momento. Por tal razón,

como última acción y para bajar radicalmente el costo de inversión en componentes, realicé el control a distancia, esta vez sustituyendo la plataforma ARDUINO por el microcontrolador ATmega8.

Fue de esta manera como el proyecto que realicé se dio por concluido.

80

2.2 LISTA DE COMPONENTES * Circuito Integrado de 28 pines “ATmega328P” marca ATMEL

Figura 2.1 MCU ATmega328P * Tarjeta de hardware abierto “ARDUINO UNO” marca ARDUINO

Figura 2.2 Tarjeta “ARDUINO UNO”, como base MCU ATmega328P * Dispositivo Transceptor “nRF24L01+” marca NORDIC

Figura 2.3 Dispositivo transceptor nRF24L01+

81

2.3 COMUNICACIÓN SPI ENTRE ATmega8 y ATmega328P Es de suma importancia mencionar que, esta etapa fue desarrollada con el

objetivo de introducirme a la comunicación SPI, ya que este tipo de comunicación es la base para manipular al dispositivo transceptor nRF24L01+. En este apartado se pretende ayudar al lector, para que se capaz de configurar a un dispositivo como MASTER ó como ESCLAVO (en cuanto a comunicación SPI se refiere).

El software (compilador) utilizado para la creación del código en lenguaje C,

es conocido como CodeVision AVR, la versión utilizada es 2.05.0. El programador es conocido como Khazama AVR programmer. No es objetivo de este APARTADO (ni de ningún otro) explicar el proceso

detallado, paso por paso, de cómo se deben enviar las instrucciones para que los dispositivos puedan configurarse, para esto recomiendo algunos tutoriales más especializados. Por ahora me interesa describir las etapas que desarrollé para generar la comunicación entre MCU´s.

Esta etapa consistió en; transmitir un valor analógico, el cual fue obtenido a

través del ADC en el ATmega8 (configurado como Master) y mostrado en un LCD conectado en el ATmega328P (configurado como Esclavo).

Figura 2.4 Diagrama de conexiones entre ATmega8 y ATmega328P.

82

2.3.1.- Configuraciones en software para ATmega8 A continuación, se mencionarán las configuraciones que realicé en el

software Codevision AVR para desarrollar esta etapa: 1.- Crear un nuevo proyecto:

2.- Configurar el chip y el tipo de reloj a utilizar

3.- Configurar el ADC en el ATmega8 para, detectar el valor analógico que

es enviado a través de comunicación SPI

83

4.- Creación del código fuente #include <mega8.h> #include <API.h> #include <nRF24L01.h> #define SCK PORTB.5 // PB5 es definido como SCK (Bit para comunicación SPI) #define MISO PINB.4 // PB4 es definido como MISO (Bit para comunicación SPI) #define MOSI PORTB.3 // PB3 es definido como MOSI (Bit para comunicación SPI) #define SS PORTB.2 // PB2 es definido como SS (Bit para comunicación SPI) /* ¡¡¡¡¡¡¡¡¡¡ Sólo para modo MASTER!!!!!!!!!! (SCK) ó (SCLK) >>>> Genera la señal de reloj y sincroniza la transferencia de datos. (Salida) (MOSI) >>>> (Master Out Slave In) transporta los datos del maestro hacia el esclavo. (Salida) (MISO) >>>> (Master In Slave Out) transporta los datos del esclavo hacia el maestro. (Entrada) (SS) >>>> (Select Slave) al generar un pulso negativo por este pin, se informa al esclavo que la transferencia de datos está por comenzar. (salida) */////////////////////////////////////////////////////////////////////////////// #define spi2x SPSR.0 // Bit0 del registro SPSR es renombrado como "spi2x" (Bit Duplicador de

velocidad en la transferencia de los bit) #include <delay.h> #include <stdio.h> #define ADC_VREF_TYPE 0x60 // Read the 8 most significant bits // of the AD conversion result unsigned char read_adc(unsigned char adc_input) ADMUX=adc_input | (ADC_VREF_TYPE & 0xff); // Delay needed for the stabilization of the ADC input voltage delay_us(10); // Start the AD conversion ADCSRA|=0x40; // Wait for the AD conversion to complete while ((ADCSRA & 0x10)==0); ADCSRA|=0x10; return ADCH; // Declare your global variables here char lcd [16]; unsigned char valor_enviado; // para utilizar solo en modo Master void SPI_master_start(void) // etiqueta para iniciar SPI en modo Master // No es posible mostrar el contenido de esta subrutina void SPI_slave_start(void) // etiqueta para iniciar SPI en modo Esclavo // No es posible mostrar el contenido de esta subrutina void SPI_write(unsigned char dato) // etiqueta para enviar un dato (byte) al esclavo (solo si se

configura como Master) // No es posible mostrar el contenido de esta subrutina void SPI_read(void) // etiqueta para recibir un dato (byte) (solo si se configura como esclavo) // No es posible mostrar el contenido de esta subrutina void main(void) PORTB=0x00; DDRB=0xFF; PORTC=0x00;

84

DDRC=0x00; PORTD=0x00; DDRD=0xFF; while (1) valor_enviado = read_adc(0); // leer el ADC (0) pin23 y asignar el valor leído a la variable

"valor_enviado" SPI_master_start(); // Iniciar la interface SPI en modo master delay_ms(5); // mantener espera de 5 ms SPI_write(valor_enviado); // enviar el valor asignado a la variable "valor_enviado"

2.3.2.- Configuraciones en software para ATmega328p A continuación, se mencionarán las configuraciones que realicé en el



85

3.- Configurar el uso de LCD para mostrar el valor analógico que es recibido a través de comunicación SPI

4.- Creación del código fuente #include <mega328p.h> #define SCK PINB.5 // PB5 es definido como SCK (Bit para comunicación SPI) #define MISO PORTB.4 // PB4 es definido como MISO (Bit para comunicación SPI) #define MOSI PINB.3 // PB3 es definido como MOSI (Bit para comunicación SPI) #define SS PINB.2 // PB2 es definido como SS (Bit para comunicación SPI) #include <delay.h> #include <stdio.h> // Alphanumeric LCD Module functions #include <alcd.h> // Declare your global variables here char lcd [16]; unsigned char valor_recibido; // para utilizar solo en modo Esclavo void SPI_master_start(void) // etiqueta para iniciar SPI en modo Master // No es posible mostrar el contenido de esta subrutina void SPI_slave_start(void) // etiqueta para iniciar SPI en modo Esclavo // No es posible mostrar el contenido de esta subrutina

86

void SPI_write(unsigned char dato) // etiqueta para enviar un dato (byte) al esclavo (solo si se configura como Master)

// No es posible mostrar el contenido de esta subrutina void SPI_read(void) // etiqueta para recibir un dato (byte) (solo si se configura como esclavo) // No es posible mostrar parte del contenido de esta subrutina lcd_gotoxy(0,0); sprintf(lcd,"Dato_rec= %x ",valor_recibido);//mostrar el siguiente texto en el LCD lcd_puts(lcd); delay_us(100); void main(void) PORTB=0x00; DDRB=0xFF; PORTC=0x00; DDRC=0x00; PORTD=0x00; DDRD=0xFF; // Alphanumeric LCD initialization // Connections specified in the // Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu: // RS - PORTD Bit 0 // RD - PORTB Bit 0 // EN - PORTD Bit 1 // D4 - PORTD Bit 2 // D5 - PORTD Bit 3 // D6 - PORTD Bit 4 // D7 - PORTD Bit 5 // Characters/line: 16 lcd_init(16); while (1) delay_ms(100); SPI_slave_start(); // Se inicia el modo esclavo delay_us(2); SPI_read(); // Se lee el byte recibido y se muestra en LCD

2.3.3.- Resultados obtenidos

A continuación, se muestran 3 resultados plasmados en la LCD, los cuales

dependen del posicionamiento del potenciómetro, que puede variar de 0 a 5v (0 a 255 valor decimal).

87

Figura 2.5 1er Resultado obtenido entre ATmega8 y ATmega328P

(mediante SPI).

Figura 2.6 2do Resultado obtenido entre ATmega8 y ATmega328P

(mediante SPI).

Figura 2.7 3er Resultado obtenido entre ATmega8 y ATmega328P

(mediante SPI).

88

2.4 PLATAFORMA DE HARDWARE ABIERTO “ARDUINO” El software (compilador) utilizado para la creación del código necesario,

puede ser descargado de la página principal de ARDUINO, no se requiere de un segundo software ya que, el antes mencionado, contiene en su interface el grabador de programa.

No es objetivo de este APARTADO (ni de ningún otro) explicar el proceso

detallado, paso por paso, de cómo se deben enviar las instrucciones para que los dispositivos puedan configurarse, para esto recomiendo algunos tutoriales más especializados.

El objetivo de esta etapa fue introducirme a la plataforma ya mencionada. La manera más fácil de hacerlo fue creando un editor de texto, el cual

marcaba en un LCD el carácter presionado en un teclado matricial de 4 columnas por 4 filas.

Figura 2.8 Diagrama de conexiones para el editor de texto.

89

2.4.1.- Funcionamiento del editor de texto Este editor de texto consiste en 2 partes * Se muestra en la LCD el texto:

“Lab Mex S.A C.V Jose Luis”

Este texto se desplaza a la izquierda, después a la derecha y nuevamente a la izquierda.

* Una vez que el texto anterior desaparezca, usted puede comenzar a

introducir los caracteres que prefiera. Sólo puede introducir 32 caracteres (16 arriba y 16 abajo). IMPORTANTE

La tecla ‘*’ le servirá para borrar aquellos caracteres que uste d no

requiera. 2.4.2 Creación del código fuente

// Este Programa muestra, en una LCD, los caracteres que son pulsados // en un KeyPad de 4x4. Se excluye el caracter '*' el cual servirá para borrar los caracteres no deseados.

int cuadro = 0; // Se declara esta variable para poder controlar el espacio donde se

introducirá o borrará un caracter. int fila = 0; // Se declara esta variable para poder controlar la fila en donde se

introducirá o borrará un caracter. // Se incluye la librería para controlar la LCD: #include <LiquidCrystal.h> // Asignacion de pines para lograr la interface con la LCD LiquidCrystal lcd(13, 12, 11, 10, 9, 8); // Se incluye la librería para controlar el KeyPad: #include <Keypad.h> const byte ROWS = 4; //Se manifiestan el numero de filas const byte COLS = 4; //Se manifiestan el numero de columnas char hexaKeys [ROWS][COLS] = '1','2','3','A', '4','5','6','B', //Se introducen los valores que corresponden al KeyPad '7','8','9','C', ' ','0','#','D' ; byte rowPins[ROWS] = 7, 6, 5, 4; //pines asignados a las filas del teclado byte colPins[COLS] = 3, 2, 1, 0; //pines asignados a las columnas del teclado Keypad custonKeypad = Keypad( makeKeymap (hexaKeys), rowPins, colPins, ROWS, COLS); void setup() // configuración para el numero de columnas y filas de la LCD: lcd.begin(16, 2); // Imprime en la siguiente direccion de la LCD (x, y). lcd.setCursor(0, 0);

90

// Imprimir el siguiente texto lcd.print("Lab Mex S.A C.V"); // Imprime en la siguiente direccion de la LCD (x, y). lcd.setCursor(3, 1); // Imprimir el siguiente texto lcd.print("Jose Luis"); delay (2000); for (int positionCounter = 0; positionCounter < 13; positionCounter++) lcd.scrollDisplayLeft(); // Serie de instrucciones que

ayudan a desplazar el texto delay (300); // hacia la izquierda for (int positionCounter = 0; positionCounter < 29; positionCounter++) lcd.scrollDisplayRight(); // Serie de instrucciones que

ayudan a desplazar el texto delay (300); // hacia la derecha for (int positionCounter = 0; positionCounter < 16; positionCounter++) lcd.scrollDisplayLeft(); // Serie de instrucciones que

ayudan a desplazar el texto delay (300); // hacia la izquierda para que quede

centrado delay (2000); lcd.setCursor(0, 0); lcd.print(" "); // serie de instrucciones para limpiar

la LCD lcd.setCursor(0, 1); lcd.print(" "); void loop() char tecla = custonKeypad.getKey(); // se declara la variable 'tecla' y se le asigna el

caracter presionado lcd.display(); if (tecla) lcd.setCursor(cuadro, fila); // la tecla se imprimirá en 0, 0 que es el valor asignado a

cada variable lcd.print(tecla); // se imprimirá la tecla presionada cuadro ++; // la variable 'cuadro' aumenta en 1 para imprimir el siguiente caracter en

el sig cuadro if (cuadro < 0 && fila == 0) // en caso de que el valor de 'cuadro' sea menor a cero y

este se encuentre en la fila 0 cuadro = 1; // debe regresarse al cuadro 1 else if (cuadro > 17 && fila == 1) // en caso de que el valor de 'cuadro' sea mayor

que 17 y este se encuentre en la fila 1 cuadro = 16; // debe regresarse al cuadro 16

91

else if (tecla == ' ') // tecla asignada para borrar el caracter no deseado if (cuadro == 0 && fila == 1) // si el cursor se encuentra en el primer cuadro de la

fila 1 debe transferirse cuadro = 17; // al ultimo cuadro de la fila 0 fila = 0; cuadro= cuadro - 2; // a 'cuadro' se le restan 2 unidades para poder borrar el

caracter no deseado lcd.setCursor(cuadro, fila); lcd.print(' '); else if (cuadro == 16 && fila == 0) // si el cursor imprime caracter en el último

cuadro de la fila cero cuadro = 0; // debe transferirse al primer cuadro de la fila 1. fila = 1;

92

2.5 ESTUDIO DE COMANDOS PARA EL CONTROL DEL DISPOSI TIVO nRF24L01+.

En la parte inferior se muestra una tabla que contiene los comandos

necesarios para, controlar al dispositivo nRF24L01+. Cabe mencionar que dichos comandos deben ser enviados mediante comunicación SPI.



Tabla 2.1 Comandos (los cuales deben ser enviados a través de

comunicación SPI) del dispositivo nRF24L01+.

93

Tomaremos como ejemplo el primer comando de esta tabla: “R_REGISTER”.- (Read Register) leer registro por sus palabras en inglés. Con este comando usted puede visualizar a través de un LCD, por ejemplo,

el valor por defecto de cualquier registro ubicado dentro del transceptor nRF24L01+.

Supongamos que queremos leer el registro denominado “STATUS”, dicho

registro tiene la dirección de memoria (en valor hexadecimal) 0x07. Como podemos observar en la tabla, el comando se encuentra en código

binario, por lo tanto es necesario convertir el valor de la dirección del registro en código binario.

Dado lo anterior se realiza que: 0x07 = 0b’0000 0111’ Observando la tabla obtenemos que el comando de “R_REGISTER” sea: 0b’000A AAAA’; En este caso, las letras A deben ser sustituidas por el valor

binario del registro que deseamos leer. Siendo así, el comando queda de la siguiente manera:

0b’0000 0111’ Los 3 bits en color rojo representan los primeros 3 bits del comando

“R_REGISTER”, los siguientes 5 bits en color azul representan los últimos 5 bits de la dirección del registro “STATUS”.

Por lo tanto al enviar el comando anterior, estamos informando al

dispositivo nRF24L01+ que, deseamos saber el estado en el registro “STATUS”. Se debe realizar la misma operación para utilizar el comando

“W_REGISTER”, el cual sirve para escribir ó modificar el valor en cualquier registro. En adición a las operaciones anteriores, se debe mandar inmediatamente después de éste comando, el valor que desea ESCRIBIR en el registro de su elección.

Tomando como ejemplo el mismo registro “STATUS” con dirección de

memoria (en valor hexadecimal) 0x07.

94

Como podemos observar en la tabla, el comando se encuentra en código binario, por lo tanto es necesario convertir el valor de la dirección del registro en código binario.

Dado lo anterior se realiza que: 0x07 = 0b’0000 0111’ Observando la tabla obtenemos que el comando de “W_REGISTER” sea: 0b’001A AAAA’; En este caso, las letras A deben ser sustituidas por el valor

binario del registro que deseamos escribir. Siendo así, el comando queda de la siguiente manera:

0b’0010 0111’ Los 3 bits en color rojo representan los primeros 3 bits del comando

“W_REGISTER”, los siguientes 5 bits en color azul representan los últimos 5 bits de la dirección del registro “STATUS”.

Por lo tanto al enviar el comando anterior, estamos informando al

dispositivo nRF24L01+ que, deseamos modificar el valor en los bits del registro “STATUS”.

Seguido de lo anterior debemos enviar el valor que queremos quede

establecido en dicho registro. Cabe mencionar que en este caso, los únicos bits que podemos modificar son:

RX_DR.- Bit 6 TX_DS.- Bit 5 MAX_RT.- Bit 4. Los comandos posteriores pueden ser enviados directamente.

95

2.6 COMUNICACIÓN SPI ENTRE EL DISPOSITIVO nRF24L01+ Y EL ATmega328p.

Una vez comprendidos los puntos 2.3, 2.4 y 2.5, es posible realizar la

siguiente etapa, la cual consiste en controlar al dispositivo transceptor nRF24L01+ desde el MCU ATmega328P (leer y escribir registros del transceptor).



Figura 2.9 Diagrama de conexiones entre ATmega328P y nRF24L01+

96

2.6.1.- Configuraciones en software para ATmega328P A continuación, se mencionarán las configuraciones que realicé en el



3.- Configurar el uso de LCD para mostrar el valor analógico que es recibido

a través de comunicación SPI

97

4.- Creación del código fuente para leer el registro // Este Programa muestra, en un LCD, el valor por defecto del registro “STATUS” // Posteriormente el valor es modificado y mostrado nuevamente como nuevo valor del registro “STATUS”. #include <mega328p.h> #include <API.h> // Contiene el nombre de los comandos a utilizar para el transceptor #define SCK PORTB.5 // PB5 es definido como SCK (Bit para comunicación SPI #define MISO PINB.4 // PB4 es definido como MISO (Bit para comunicación SPI) #define MOSI PORTB.3 // PB3 es definido como MOSI (Bit para comunicación SPI) #define SS PORTB.2 // PB2 es definido como SS (Bit para comunicación SPI) /* ¡¡¡¡¡¡¡¡¡¡ Sólo para modo MASTER!!!!!!!!!! (SCK)ó(SCLK) >>>> Genera la señal de reloj y sincroniza la transferencia de datos. (salida) (MOSI) >>>> (Master Out Slave In) transporta los datos del maestro hacia el esclavo. (salida) (MISO) >>>> (Master In Slave Out) transporta los datos del esclavo hacia el maestro. (entrada) (SS) >>>> (Select Slave) al generar un pulso negativo se informa al esclavo que la transferencia de datos está por comenzar. (salida) */////////////////////////////////////////////////////////////////////////////// #define spi2x SPSR.0 // Bit0 del registro SPSR es renombrado como "spi2x" (Bit Duplicador de velocidad en la transferencia de los bit) #include <delay.h> #include <stdio.h> // Alphanumeric LCD Module functions #include <alcd.h> #define ADC_VREF_TYPE 0x60 // Read the 8 most significant bits // of the AD conversion result unsigned char read_adc(unsigned char adc_input) ADMUX=adc_input | (ADC_VREF_TYPE & 0xff); // Delay needed for the stabilization of the ADC input voltage delay_us(10); // Start the AD conversion ADCSRA|=0x40; // Wait for the AD conversion to complete while ((ADCSRA & 0x10)==0); ADCSRA|=0x10; return ADCH; // Declare your global variables here char lcd [16]; unsigned short valor_recibido; // variable utilizada para leer el registro SPDR en la interfaz SPI int i = 0; void SPI_master_start(void) // etiqueta para iniciar SPI en modo Master

// No es posible mostrar el contenido de esta subrutina

98

void SPI_write(unsigned char dato) // etiqueta para enviar un dato (byte) al esclavo (solo si se configura como Master)


void SPI_read(void) // etiqueta para recibir un dato (byte)


void Read_register(unsigned char registro) // etiqueta para leer el estado en cualquier registro del transceptor


void Write_register(unsigned char registro, unsigned char valor) // etiqueta para escribir en cualquier registro del transceptor // ingresar el nombre del registro y el valor a introducir


void main(void) // Declare your local variables here // Crystal Oscillator division factor: 1 #pragma optsize- CLKPR=0x80; CLKPR=0x00; #ifdef _OPTIMIZE_SIZE_ #pragma optsize+ #endif // Input/Output Ports initialization // Port B initialization // Func7=Out Func6=Out Func5=Out Func4=In Func3=Out Func2=Out Func1=Out Func0=Out // State7=0 State6=0 State5=0 State4=T State3=0 State2=0 State1=0 State0=0 PORTB=0x00; DDRB=0xEF; // Port C initialization // Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTC=0x00; DDRC=0x00; // Port D initialization // Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out // State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 PORTD=0x00; DDRD=0xFF; // Timer/Counter 0 initialization // Clock source: System Clock // Clock value: Timer 0 Stopped // Mode: Normal top=0xFF // OC0A output: Disconnected // OC0B output: Disconnected

99

TCCR0A=0x00; TCCR0B=0x00; TCNT0=0x00; OCR0A=0x00; OCR0B=0x00; // Timer/Counter 1 initialization // Clock source: System Clock // Clock value: Timer1 Stopped // Mode: Normal top=0xFFFF // OC1A output: Discon. // OC1B output: Discon. // Noise Canceler: Off // Input Capture on Falling Edge // Timer1 Overflow Interrupt: Off // Input Capture Interrupt: Off // Compare A Match Interrupt: Off // Compare B Match Interrupt: Off TCCR1A=0x00; TCCR1B=0x00; TCNT1H=0x00; TCNT1L=0x00; ICR1H=0x00; ICR1L=0x00; OCR1AH=0x00; OCR1AL=0x00; OCR1BH=0x00; OCR1BL=0x00; // Timer/Counter 2 initialization // Clock source: System Clock // Clock value: Timer2 Stopped // Mode: Normal top=0xFF // OC2A output: Disconnected // OC2B output: Disconnected ASSR=0x00; TCCR2A=0x00; TCCR2B=0x00; TCNT2=0x00; OCR2A=0x00; OCR2B=0x00; // External Interrupt(s) initialization // INT0: Off // INT1: Off // Interrupt on any change on pins PCINT0-7: Off // Interrupt on any change on pins PCINT8-14: Off // Interrupt on any change on pins PCINT16-23: Off EICRA=0x00; EIMSK=0x00; PCICR=0x00; // Timer/Counter 0 Interrupt(s) initialization TIMSK0=0x00; // Timer/Counter 1 Interrupt(s) initialization TIMSK1=0x00; // Timer/Counter 2 Interrupt(s) initialization TIMSK2=0x00; // USART initialization // USART disabled UCSR0B=0x00; // Analog Comparator initialization // Analog Comparator: Off

100

// Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=0x80; ADCSRB=0x00; DIDR1=0x00; // ADC initialization // ADC Clock frequency: 125.000 kHz // ADC Voltage Reference: AVCC pin // ADC Auto Trigger Source: ADC Stopped // Only the 8 most significant bits of // the AD conversion result are used // Digital input buffers on ADC0: On, ADC1: On, ADC2: On, ADC3: On // ADC4: On, ADC5: On DIDR0=0x00; ADMUX=ADC_VREF_TYPE & 0xff; ADCSRA=0x87; // SPI initialization // SPI disabled SPCR=0x00; // TWI initialization // TWI disabled TWCR=0x00; // Alphanumeric LCD initialization // Connections specified in the // Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu: // RS - PORTD Bit 0 // RD - PORTB Bit 1 // EN - PORTD Bit 1 // D4 - PORTD Bit 2 // D5 - PORTD Bit 3 // D6 - PORTD Bit 4 // D7 - PORTD Bit 5 // Characters/line: 16 lcd_init(16); while (1) Read_register(STATUS); //Se introduce el nombre del registro que desea leer delay_ms(500); // se muestra el valo del registro deseado durante 500 milisegundos while (i < 1) // Loop para modificar el valor de un registro solo una vez Write_register(STATUS,0x7A); // Se introduce el nombre del registro que desea

//modificar, seguido del valor que desea asignar delay_ms(500); // espera de 500 milisegundos i++;

101

Figura 2.10 Estado del registro “STATUS” al leerlo por primera vez

Figura 2.11 Estado del registro “STATUS” después de escribirlo

102

2.7 TRANSMISOR Y RECEPTOR CON PLATAFORMA ARDUINO Una vez comprendido el punto 2.6, es posible realizar la siguiente etapa, la

cual consiste en controlar al dispositivo transceptor nRF24L01+ desde la plataforma abierta ARDUINO, esto con el fin de programar a un dispositivo como transmisor y a otro como receptor (para transferir el incremento de una variable).



2.7.1 Configuración para el transmisor

Figura 2.12 Diagrama de conexiones entre ATmega328P y nRF24L01+

103

2.7.1.1.- Configuraciones en software para Arduino uno 1.- Creación del código fuente para configurar al dispositivo nRF24L01+

como transmisor. *********************************************************************/ ** CS - to digital pin 8 ** ** CSN - to digital pin 9 (SS pin) ** ** MOSI - to digital pin 11 (MOSI pin) ** ** MISO - to digital pin 12 (MISO pin) ** ** CLK - to digital pin 13 (SCK pin) ** *********************************************************************/ #include <SPI.h> #include "API.h" #include "nRF24L01.h" //*************************************************** #define TX_ADR_WIDTH 5 // 5 unsigned chars TX(RX) address width #define TX_PLOAD_WIDTH 16 // 32 unsigned chars TX payload unsigned char TX_ADDRESS[TX_ADR_WIDTH] = 0x34, 0x43, 0x10, 0x10, 0x01 ; // Define a static TX address unsigned char tx_buf[TX_PLOAD_WIDTH] = 0; //*************************************************** void setup() Serial.begin(9600); pinMode(CE, OUTPUT); pinMode(CSN, OUTPUT); pinMode(IRQ, INPUT); SPI.begin(); delay(50); init_io(); // Initialize IO port unsigned char sstatus=SPI_Read(STATUS); Serial.println("*******************TX_Mode Start****************************"); Serial.print("status = "); Serial.println(sstatus,HEX); TX_Mode(); // set TX mode void loop() int k = 0; for(;;) for(int i=0; i<16; i++) tx_buf[i] = k++;

unsigned char sstatus = SPI_Read(STATUS); // read register STATUS's value if(sstatus&TX_DS) // if receive data ready (TX_DS) interrupt SPI_RW_Reg(FLUSH_TX,0); SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH); // write playload to TX_FIFO if(sstatus&MAX_RT) // if (MAX_RT) interrupt, this is retransmit than SETUP_RETR SPI_RW_Reg(FLUSH_TX,0); SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH); // disable standy-mode SPI_RW_Reg(WRITE_REG+STATUS,sstatus); // clear RX_DR or TX_DS or MAX_RT interrupt flag

104

delay(1000); //************************************************** // Function: init_io(); //************************************************** void init_io(void) Impossible to show this section /************************************************** / Function: SPI_RW(); *************************************************** unsigned char SPI_RW(unsigned char Byte) Impossible to show this section /************************************************** * Function: SPI_RW_Reg(); /************************************************** unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value) Impossible to show this section /************************************************** * Function: SPI_Read(); /************************************************** unsigned char SPI_Read(unsigned char reg) Impossible to show this section /************************************************** * Function: SPI_Read_Buf(); /************************************************** unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) Impossible to show this section /************************************************** * Function: SPI_Write_Buf(); /************************************************** unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) Impossible to show this section /************************************************** * Function: TX_Mode(); /************************************************** void TX_Mode(void) Impossible to show this section

105

2.7.2 Configuración para el receptor

Figura 2.13 Diagrama de conexiones entre ATmega328P y nRF24L01+ 2.7.2.1.- Configuraciones en software para Arduino uno 1.- Creación del código fuente para configurar al dispositivo nRF24L01+

como receptor. *********************************************************************/ ** CE - to digital pin 8 ** ** CSN - to digital pin 9 (SS pin) ** ** MOSI - to digital pin 11 (MOSI pin) ** ** MISO - to digital pin 12 (MISO pin) ** ** CLK - to digital pin 13 (SCK pin) ** *********************************************************************/ #include <SPI.h> #include "API.h" #include "nRF24L01.h" //*************************************************** #define TX_ADR_WIDTH 5 // 5 unsigned chars TX(RX) address width

106

#define TX_PLOAD_WIDTH 16 // 32 unsigned chars TX payload unsigned char TX_ADDRESS[TX_ADR_WIDTH] = 0x34, 0x43, 0x10, 0x10, 0x01 ; // Define a static TX address unsigned char rx_buf[TX_PLOAD_WIDTH] = 0; // initialize value //*************************************************** void setup() Serial.begin(9600); pinMode(CE, OUTPUT); pinMode(CSN, OUTPUT); pinMode(IRQ, INPUT); SPI.begin(); delay(50); init_io(); // Initialize IO port unsigned char sstatus=SPI_Read(STATUS); Serial.println("*******************TX_Mode Start****************************"); Serial.print("status = "); Serial.println(sstatus,HEX); RX_Mode(); // set RX mode void loop() for(;;) unsigned char status = SPI_Read(STATUS); // read register STATUS's value if(status&RX_DR) // if receive data ready (TX_DS) interrupt SPI_Read_Buf(RD_RX_PLOAD, rx_buf, TX_PLOAD_WIDTH); // read playload to rx_buf SPI_RW_Reg(FLUSH_RX,0); // clear RX_FIFO for(int i=0; i<16; i++) Serial.print(" "); Serial.print(rx_buf[i],DEC); // print rx_buf Serial.println(" "); SPI_RW_Reg(WRITE_REG+STATUS,status); //clear RX_DR or TX_DS or MAX_RT interrupt flag delay(1000); //************************************************** // Function: init_io(); //************************************************** void init_io(void) Impossible to show this section /************************************************** / Function: SPI_RW(); *************************************************** unsigned char SPI_RW(unsigned char Byte) Impossible to show this section /************************************************** * Function: SPI_RW_Reg(); /************************************************** unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)

107

Impossible to show this section /************************************************** * Function: SPI_Read(); /************************************************** unsigned char SPI_Read(unsigned char reg) Impossible to show this section /************************************************** * Function: SPI_Read_Buf(); /************************************************** unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) Impossible to show this section /************************************************** * Function: SPI_Write_Buf(); /************************************************** unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) Impossible to show this section /************************************************** * Function: RX_Mode(); /************************************************** void RX_Mode(void) Impossible to show this section

Figura 2.14 variable recibida, mostrada a través del monitor serial del

software Arduino.

108

Figura 2.15 Imagen de las dos tarjetas “ARDUINO UNO” transmitiendo y

recibiendo datos.

109

2.8 TRANSMISOR Y RECEPTOR CON ATmega8 La finalidad de este apartado es orientar al lector para que pueda controlar

al dispositivo nRF24L01+ con el MCU ATmega8, esto con el fin de programar a un dispositivo como transmisor y a otro como receptor (para transferir el incremento de una variable), además de que al hacerlo reduce el costo del proyecto significativamente.

No es objetivo de este APARTADO (ni de ningún otro) explicar el proceso detallado, paso por paso, de cómo se deben enviar las instrucciones para que los dispositivos puedan configurarse, para esto recomiendo algunos tutoriales más especializados.

2.8.1 Configuración para el transmisor

Figura 2.16 Diagrama de conexiones entre ATmega8 y nRF24L01+ 2.8.1.1.- Configuraciones en software para ATmega8 1.- Creación del código fuente para configurar al dispositivo nRF24L01+

como transmisor. #include <mega8.h> #include <API.h> // Contiene el nombre de los comandos y de los registros que se utilizan para el transceptor nRF24L01+ #define SCK PORTB.5 // PB5 es definido como SCK (Bit para comunicación SPI) Se conecta a SCk del transceptor #define MISO PINB.4 // PB4 es definido como MISO (Bit para comunicación SPI) Se conecta a MISO del transceptor

110

#define MOSI PORTB.3 // PB3 es definido como MOSI (Bit para comunicación SPI) Se conecta a MOSI del transceptor #define SS PORTB.2 // PB2 es definido como SS (Bit para comunicación SPI) Se conecta a CSN del transceptor /* ¡¡¡¡¡¡¡¡¡¡ Sólo para modo MASTER !!!!!!!!!! (SCK)ó(SCLK) >>>> Genera la señal de reloj y sincroniza la transferencia de datos. (salida) (MOSI) >>>> (Master Out Slave In) transporta los datos del maestro hacia el esclavo. (salida) (MISO) >>>> (Master In Slave Out) transporta los datos del esclavo hacia el maestro. (entrada) (SS) >>>> (Select Slave) al generar un pulso negativo (cero lógico) por este pin, se informa al

esclavo que la transferencia de datos está por comenzar. (salida) #define CE PORTB.1 // Chip Enable para comunicación con nRF24L01+ Se conecta a CE del transceptor #define TX_ADR_WIDTH 5 // Para el ancho de dirección en TX / RX se asignan 5 unsigned chars #define TX_PAYLOAD_WIDTH 16 // Para la carga útil en TX se asignan 6 unsigned chars #include <delay.h> #include <stdio.h> // Alphanumeric LCD Module functions #include <alcd.h> // Declare your global variables here unsigned char TX_ADDRESS[TX_ADR_WIDTH] = 0x34, 0x43, 0x10, 0x10, 0x01 ; // Se define una dirección estática para TX (Cabe mencionar que el RECEPTOR debe contener la misma dirección) unsigned char tx_buf[TX_PAYLOAD_WIDTH] = 0; // Variable a la cual se le asignará la carga util (payload) que será transmitida char lcd [16]; void SPI_begin(void) // etiqueta para iniciar SPI en modo Master No es posible mostrar el contenido de esta seccion void init_io(void) // etiqueta para configuración previa que consiste en deshabilitar tanto la comunicación SPI como al transceptor No es posible mostrar el contenido de esta seccion unsigned char SPI_RW(unsigned char Byte) // Etiqueta utilizada para contener un valor, el cual será enviado por la interface SPI No es posible mostrar el contenido de esta sección unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value) // etiqueta que se utiliza para escribir el dato (value) en el registro (reg) No es posible mostrar el contenido de esta seccion

111

unsigned char SPI_Read(unsigned char reg) // Etiqueta utilizada para leer el estado de algun registro No es posible mostrar el contenido de esta seccion unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) //etiqueta utilizada para leer un registro que contien mas de 1 byte de memoria No es posible mostrar el contenido de esta seccion unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) //etiqueta utilizada para escribir un registro que contien mas de 1 byte de memoria No es posible mostrar el contenido de esta sección void TX_Mode(int Canal) // Etiqueta que inicializa al transceptor en modo transmisor No es posible mostrar el contenido de esta sección void main(void) // Alphanumeric LCD initialization // Connections specified in the // Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu: // RS - PORTD Bit 0 // RD - PORTD Bit 6 // EN - PORTD Bit 1 // D4 - PORTD Bit 2 // D5 - PORTD Bit 3 // D6 - PORTD Bit 4 // D7 - PORTD Bit 5 // Characters/line: 16 lcd_init(16); DDRC=0x00; // PORTC <<< entradas para los push botton DDRB.1 = 1; // CE <<<<< salida DDRB.2 = 1; // SS <<< salida SPI_begin(); delay_us(50); init_io(); // Initialize IO port lcd_gotoxy(0,0); sprintf(lcd,"TX_Mode Start");//mostrar el sig texto en LCD lcd_puts(lcd); delay_ms(10); TX_Mode(0); while (1)

int k = 0; for(;;)

for(int i=0; i<16; i++) tx_buf[i] = k++; unsigned char sstatus = SPI_Read(STATUS); // read register STATUS's value

if(sstatus&TX_DS) // if receive data ready (TX_DS) interrupt

112

SPI_RW_Reg(FLUSH_TX,0); SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH); if(sstatus&MAX_RT) SPI_RW_Reg(FLUSH_TX,0); SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH); // disable standy-

mode SPI_RW_Reg(WRITE_REG+STATUS,sstatus); delay(1000);

2.8.2 Configuración para el receptor

Figura 2.17 Diagrama de conexiones entre ATmega8 y nRF24L01+ 2.8.2.1.- Configuraciones en software para ATmega8

#include <mega8.h> #include <API.h> // Contiene el nombre de los comandos y de los registros que se utilizan para el transceptor nRF24L01+ #define SCK PORTB.5 // PB5 es definido como SCK (Bit para comunicación SPI) Se conecta a SCk del transceptor

113

#define MISO PINB.4 // PB4 es definido como MISO (Bit para comunicación SPI) Se conecta a MISO del transceptor #define MOSI PORTB.3 // PB3 es definido como MOSI (Bit para comunicación SPI) Se conecta a MOSI del transceptor #define SS PORTB.2 // PB2 es definido como SS (Bit para comunicación SPI) Se conecta a CSN del transceptor /* ¡¡¡¡¡¡¡¡¡¡ Sólo para modo MASTER !!!!!!!!!! (SCK)ó(SCLK) >>>> Genera la señal de reloj y sincroniza la transferencia de datos. (salida) (MOSI) >>>> (Master Out Slave In) transporta los datos del maestro hacia el esclavo. (salida) (MISO) >>>> (Master In Slave Out) transporta los datos del esclavo hacia el maestro. (entrada) (SS) >>>> (Select Slave) al generar un pulso negativo (cero lógico) por este pin, se informa al

esclavo que la transferencia de datos está por comenzar. (salida) #define CE PORTB.1 // Chip Enable para comunicación con nRF24L01+ Se conecta a CE del transceptor #define TX_ADR_WIDTH 5 // Para el ancho de dirección en TX / RX se asignan 5 unsigned chars #define TX_PAYLOAD_WIDTH 16 // Para la carga útil en TX se asignan 6 unsigned chars #include <delay.h> #include <stdio.h> // Alphanumeric LCD Module functions #include <alcd.h> // Declare your global variables here unsigned char TX_ADDRESS[TX_ADR_WIDTH] = 0x34, 0x43, 0x10, 0x10, 0x01 ; // Se define una dirección estática para TX (Cabe mencionar que el RECEPTOR debe contener la misma dirección) unsigned char rx_buf[TX_PAYLOAD_WIDTH] = 0; // Variable a la cual se le asignará la carga util (payload) que será transmitida char lcd [16]; void SPI_begin(void) // etiqueta para iniciar SPI en modo Master No es posible mostrar el contenido de esta seccion void init_io(void) // etiqueta para configuración previa que consiste en deshabilitar tanto la comunicación SPI como al transceptor No es posible mostrar el contenido de esta seccion unsigned char SPI_RW(unsigned char Byte) // Etiqueta utilizada para contener un valor, el cual será enviado por la interface SPI No es posible mostrar el contenido de esta sección unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value) // etiqueta que se utiliza para escribir el dato (value) en el registro (reg)

114

No es posible mostrar el contenido de esta seccion unsigned char SPI_Read(unsigned char reg) // Etiqueta utilizada para leer el estado de algun registro No es posible mostrar el contenido de esta seccion unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) //etiqueta utilizada para leer un registro que contien mas de 1 byte de memoria No es posible mostrar el contenido de esta seccion unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes) //etiqueta utilizada para escribir un registro que contien mas de 1 byte de memoria No es posible mostrar el contenido de esta sección void rX_Mode(int Canal) // Etiqueta que inicializa al transceptor en modo transmisor No es posible mostrar el contenido de esta sección void main(void) // Alphanumeric LCD initialization // Connections specified in the // Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu: // RS - PORTD Bit 0 // RD - PORTD Bit 6 // EN - PORTD Bit 1 // D4 - PORTD Bit 2 // D5 - PORTD Bit 3 // D6 - PORTD Bit 4 // D7 - PORTD Bit 5 // Characters/line: 16 lcd_init(16); DDRB.1 = 1; // CE <<<<< salida DDRB.2 = 1; // SS <<< salida SPI_begin(); delay_us(50); init_io(); // Initialize IO port lcd_gotoxy(0,0); sprintf(lcd,"RX_Mode Start");//mostrar el sig texto en LCD lcd_puts(lcd); delay_ms(10); RX_Mode(0); while (1)

for(;;) unsigned char status = SPI_Read(STATUS); // read register STATUS's value if(status&RX_DR) // if receive data ready (TX_DS) interrupt SPI_Read_Buf(RD_RX_PLOAD, rx_buf, TX_PLOAD_WIDTH); SPI_RW_Reg(FLUSH_RX,0); // clear RX_FIFO

115

for(int i=0; i<16; i++)

lcd_gotoxy(0,1); sprintf(lcd,"%d",rx_buf[1]);//mostrar el sig texto en LCD lcd_puts(lcd);

delay_ms(10);

SPI_RW_Reg(WRITE_REG+STATUS,status); delay(1000);

116

RESULTADOS Se creó un sistema de conectividad inalámbrica, el cual, opera en la banda

ISM (industrial, Scientific and Medical) de los 2.4 GHz., contiene 126 canales de selección para la transferencia de datos, un alcance de casi 40 mts. y un tamaño muy pequeño

Además el costo de producción es increíblemente bajo. CONCLUSIONES En este proyecto se logran cumplir los objetivos empresariales, donde se

diseña, investiga y desarrolla un sistema de conectividad inalámbrica altamente eficiente. Cabe mencionar que desarrollar este sistema, requiere de mucho tiempo.

Además se consigue que los becarios pongan en práctica los conocimientos

adquiridos en la institución y de igual forma adquieran experiencia laboral.

117

REFERENCIAS BIBLIOGRÁFICAS. 1.- W Bolton. Mecatrónica Sistemas de control electrónico en la ingeniería mecánica y eléctrica Tercera edición Alfa omega Grupo Editor (México) Año 1994

2.- W Bolton. Mecatrónica Electricidad/Electrónica Marcombo 2002 02 ed.

3.- Boon, G.K.; Mercado, A. Automatización flexible en la industria Ed. LIMUSA-Noriega México, 1991.

118

LINKS DE BUSQUEDA 1.- http://nrqm.ca/nrf24l01/firmware/ 2.- http://www.aquihayapuntes.com/indice-practicas-pic-en-c/conexion-

inalambrica-entre-dos-microcontroladores.html 3.- http://www.ccsinfo.com/forum/viewtopic.php?t=36270 4.- http://www.bizintekinnova.com/es/proyecto-moway 5.- https://sites.google.com/site/proyectosroboticos/nrf24l01/16f876-nrf24l01 6.- https://sites.google.com/site/proyectosroboticos/nrf24l01/nrf24l01-

18f4550 7.- http://bibdigital.epn.edu.ec/bitstream/15000/2248/1/CD-2985.pdf 8.- http://www.codeforge.com/read/8632 9.- http://www.codeforge.com/read/8632/24L01_base.c__html 10.- http://www.codeforge.com/read/146075/fasong.c__html

conectividad inalámbrica con transceptor nrf24l01

Documents