Memoria Arduino y Persiana
Anuncio
PROYECTOS
ARDUINO 2013
Alumno: Iván Sáez Ruiz
Tutor: Carlos Villora Fernández
I.E.S. Universidad Laboral
Contenido
ARDUINO .......................................................................................................................................... 3
¿Qué es Arduino? ......................................................................................................................... 3
Justificación. ................................................................................................................................. 3
Esquema original. ......................................................................................................................... 4
Esquema adaptado....................................................................................................................... 5
Realización de la placa. ................................................................................................................ 7
Preparado de ATMEGA168. ....................................................................................................... 10
Transmisión del programa. ................................................................................................. 11
Lista de materiales. ............................................................................................................... 14
PERSIANA DOMÓTICA .................................................................................................................. 15
Antecedentes ............................................................................................................................. 15
Justificación y propósito del proyecto ....................................................................................... 16
Ejecución del proyecto ............................................................................................................... 17
Material Necesario ................................................................................................................. 17
Placa Ethernet Shield ....................................................................................................... 18
¿Qué es y cómo funciona una placa de Ethernet Shield? .......................................................... 21
Programa. ................................................................................................................................... 23
........................................................................................................................................................ 25
Lista y Precios de los Materiales. ............................................................................................... 28
Notación Bibliográfica. ............................................................................................................... 29
ARDUINO
¿Qué es 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.2 3
El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos
de entrada/salida. 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 microcontroladoras CortexM3 de
ARM de 32 bits5 , 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í, las microcontroladoras CortexM3 usan 3.3V, a diferencia
de la mayoría de las placas con AVR que usan mayoriamente 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 es libre. 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.
Justificación.
En el mercado podemos encontrar una gran variedad de placas Arduino con un
amplio abanico de precios y prestaciones. A pesar de esto fabricar y montar nuestra
propia placa es una gran experiencia educativa, que nos permite aprender y coger
confianza en nuestro propio trabajo.
Esquema original.
Esquema adaptado.
Este circuito ha sido realizado con el programa DipTrace en la parte de
Eschematics.
Este circuito ha sido realizado con el programa DipTrace en la parte de PCB
Layout.
Realización de la placa.
Métodos para hacer placas de circuito impreso, en adelante PCBs, hay muchos. Desde
los mas sofisticados y orientados a producción a los más artesanales como dibujar tu
mismo a mano las pistas sobre la placa de cobre en bruto.
Para usar este método vas a necesitar:
Una plancha, las de la ropa de toda la vida
Papel fotográfico. 3€ (euros), 100 hojas en Lidl tamaño 10x15 cm.
Placa de cobre. 1€ en eBay o Focalprice.com. Tamaño 15x20 cm
Lija fina.
Jabón
Una impresora láser
Parte de atacado (Mezcla para atacador rápido):
Agua oxigenada 110 volúmenes (v/v). 4€ medio litro (2009). En farmacias
Ácido clorhídrico (Salfumán). Droguerías, supermercados. 0,50 €.
Lo más complicado para este laboratorio casero puede ser la impresora láser, pero han
bajado tanto de precio que poco a poco empiezan a verse en casi todas las casas.
Paso 1. Imprime en el papel fotográfico el circuito que quieras
obtener. Recuerda imprimirlo con la opción de “espejo” activada,
sino, al acabar, tendrás un circuito al revés del que querías.
Imprímelo con una impresora láser y con toda la resolución y
el toner que puedas. Usar una impresora láser no es capricho, la
tinta que utilizan, el toner, es diferente a las impresoras de
inyección de tinta, De hecho, ni siquiera es tinta, es un polvo seco.
Una vez que lo tengas impreso correctamente, vámonos al paso 2.
Paso 2. Recorta el circuito impreso en el papel dejando un pequeño borde de 4 o 5
mm y ponlo sobre la placa de cobre, con la cara impresa sobre el propio cobre.
Ahora coge un trapo y se lo pones también encima, para que cuando apoyes la
plancha sobre el papel no lo derritas, ya que estos papeles suelen tener
componentes plásticos.
Paso 3. Lija la placa de cobre donde vayas a darle vida a tu circuito. Usa una lija
fina y sobre todo, lija los bordes bien, para que al apoyar el papel no se queden los
bordes mas elevados que el centro. Después lávala con jabón para eliminar la
grasa que pueda tener. Evita tocarla con los dedos sucios después de este paso.
Paso 4. Este es el paso importante. El toner tiene una temperatura de fusión
dependiendo de la marca entre los 100ºC y los 220ºC. Superar en exceso esta
temperatura, quema el toner, perdiendo este
totalmente la adherencia. Si esto ocurre,
tendrás que tirar el papel y empezar de
nuevo. El objetivo entonces es el siguiente,
calienta la plancha sin pasarte, es mejor
probar la primera vez a menos temperatura
que tener que tirar el papel. Ahora pon la
plancha sobre el montaje, aprieta fuerte y
espera unos 15 segundos, muévela y aprieta
bien por los bordes. Este proceso derrite el
toner, que se adhiere al cobre con bastante
fuerza. Ahora tenemos el toner adherido al
papel y al cobre por igual.
Paso 5. Sumerge unos minutos -dependiendo del grosor del papel que hayas
usado- la placa con el papel en agua jabonosa. Cuando el papel este blando
retíralo con cuidado y verás cómo tu circuito está perfectamente dibujado sobre el
cobre.
Paso 6. Ahora mezcla en un recipiente plástico el
ácido clorhídrico con el agua oxigenada. ¿Las
proporciones? Lo mejor que puedes hacer es
mezclar al 50%, para no complicarte la vida.
Echa la placa en la mezcla y en unos segundos
dependiendo de la mezcla tendrás la placa
atacada y lista para perforar. Otra opción es
usar cloruro férrico. Ciertamente puede ser más
barato, pero sinceramente, para que funcione
bien, hay que calentarlo, mezclarlo bien,
además es muy muy lento en comparación y no
es fácil de conseguir en lugares donde no haya
tiendas de electrónica. Esta es la fase en la que debemos estar mas atentos, pues si
el acido resultara fuerte podría diluir el toner. Lo ideal es que cuando coloques la
placa en disolución, el cobre coja un color rojizo y empiece a burbujear. Miren la
imagen.
Paso 7. Una vez se saque la placa del acido hay que
enjuagarla con abundante agua para que el acido no la sigua
comiendo, luego conviene secarla con un trapo limpio. Una
vez seca, se empapara el toner con acetona y se rascara con
un cepillo de dientes o con la lana de acero, eliminando así
todo el toner de la placa.
Paso 8. Con una puntilla fina o punzón y un martillo vamos marcando los orificios
donde se taladrara. No consiste en taladrar la placa con la puntilla, solo de
hacerle una marquita para que la broca no patine y corte las pistas. Una vez
listas las marcas, procederemos a taladrar la placa, para lo cual usaremos un
taladro que acepte brocas de 1mm. Si la broca quedase pequeña y no fuera
agarrada por el taladro, pueden colocar un trozo de cinta aislante, pero una
mejor solución que se me ocurrió fue, con un trozo de cable rígido fino (del
usado en telefonía), ir liando en vueltas muy juntas toda la parte trasera de la
broca, una vez liada, la cojo con el tronillo o gato y la lleno de estaño,
intentando que quede toda una pieza y solucionado, todavía y después de al
menos 10 placas mas, la broca no me da ningún problema.
Paso 9. Bueno, que deciros de esto,
solo que si vais a usar IC's que los
montéis sobre zócalos, que
mantengáis la punta del soldador
limpia, y que vayáis soldando los
componentes de los mas pequeños
(resistencias, zócalos, etc...).
Si os hiciese falta un tuto de como
soldar, solo pedídmelo y lo hago igual que este con fotos y por pasos, a fin de
cuentas estamos aquí para ayudarnos.
Ya solo queda
probar que todo funciona correctamente, y que el proyecto, cumpla bien su
cometido. Ahora solo espero que todo les haya dado buen resultado y que
como yo, hayan disfrutado haciendo sus trabajos.
Preparado de ATMEGA168.
Si estamos ante un micro “limpio” lo primero que tenemos que hacer es seguir
los siguientes pasos:
Necesitamos:
-Un Arduino.
-Un programador ICSP.
-AVR Studio.
Hay varias maneras para darle formato al micro, una de ellas es disponer de un
programador de alto voltaje paralelo, y otra es, generar una señal de reloj (o CLOCK)
de mas o menos 1MHZ de frecuencia. Esta ultima es la que vamos a usar.
La mejor opción es generar nosotros mismos esa misma señal mediante un micro
externo, y como no, que mas fácil que usar un arduino para dicha tarea, fácil de
programar y rápido de entender!
Una vez llegados a este punto solo tenemos que hacer dos pasos:
- Poner el chip en una protoboard o similar y conectar el ICSP.
- Programar el arduino con el siguiente sketch...
void setup() {
// inicializamos el pin 7 como salida, que sera nuestra salida de XTAL
pinMode(7, OUTPUT);
}
void loop()
{
digitalWrite(7, HIGH);
digitalWrite(7, LOW);
}
- Una vez hecho esto, procedemos a conectar el PIN 7 con el XTAL1 del micro.
- Ahora se trata de ir al "AVR Studio" y poner en la configuración del MKII (Tools>Program
AVR>Connect... y conectar al programador) que la velocidad de ICSP será 125Khz.
-Hecho esto deberíamos probar un par de veces a ver si lo reconoce. Si no funcionase,
habría que ir bajando la velocidad y repetir lo dicho anteriormente. Después de un par
de intentos debería funcionar.
Transmisión del programa.
Una vez fabricada la placa le introduciremos el programa el cual hará funcionar nuestro
proyecto. Al carecer de entrada de datos USB utilizaremos los conectores ICSP. Para ello
el programa debe estar en formato .hex el cual se ha generado y está situado en los
archivos temporales.
El núcleo de cualquier placa Arduino se compone simplemente de un microcontrolador
AVR. En el caso de la placa Arduino UNO, su respectivo microcontrolador es
el ATMega328.
Conforme uno se va adentrando en el mundo de Arduino y los proyectos se vayan
haciendo cada vez más grandes y complicados, puede presentarse la necesidad de
recurrir al uso de un segundo microcontrolador, para lo cual, es completamente notable
que conseguir un AVR por separado es mucho más barato y/o rentable que volver a
comprar una nueva placa Arduino.
Un inconveniente de comprar un nuevo microcontrolador AVR es que éste vendrá de
fábrica completamente “limpio” (sin ningún programa cargado), como consecuencia,
habrá que grabar por primera vez el Bootloader (Gestor de arranque) para que éste
pueda cargar y hacer funcionar los sketches programados con el software de Arduino.
La placa Arduino posee una entrada ICSP (In Chip Serial Programmer) que tiene acceso
a la memoria de programa del AVR, esto es, que puede grabar directamente desde la
PC al microcontrolador cualquier programa. Uno de ellos, el mismo Bootloader de
Arduino.
Para grabar el Bootloader es necesario el uso de un programador AVR.
Para comprobar que el programa introducido funciona comprobaremos en el proyecto,
en este caso el Simón. Construiremos la placa para que los pines de dicha placa
encajen perfectamente en la placa Arduino ya construida.
Este circuito ha sido realizado con el programa DipTrace en la parte de
Eschematics.
Este circuito ha sido realizado con el programa DipTrace en la parte de PCB
Layout.
Lista de materiales.
MATERIAL
Placa virgen fibra Bungard 1 cara
Regletas de conexión paso 5 mm
Conector Hembra Arduino 6 Pines
Conector Hembra Arduino 8 Pines
Conector Macho Doble 2x3 Pines ICSP
Estabilizador de tensión 7805
Condensador 100nF
Condensador 22nF
Resistencia 1K
Resistencia 10K
Cristal de cuarzo
Diodo 1N4148
Led Rojo 3mm
Pulsador 1 circuito 12x12 mm. long.
UNIDAD
1
2
2
2
1
1
3
2
1
1
1
1
1
1
PRECIO
1,45 €
0,59 €
0,50 €
0,50 €
1.50 €
0,36 €
0,16 €
0,12 €
0,02 €
0,02€
0,70 €
0,05 €
1,37 €
0,45 €
TIENDA
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
Comprar
PERSIANA DOMÓTICA
Antecedentes
Por inmótica entendemos la incorporación al equipamiento de edificios de uso terciario o
industrial (oficinas, edificios corporativos, hoteleros, empresaria-les y similares), de sistemas de
gestión técnica automatizada de las instalaciones, con el objetivo de reducir el consumo de
energía, aumentar el confort y la segur i-dad de los mismos.
Entenderemos que un edificio es "inteligente" si incorpora sistemas de información en todo el
edificio, ofreciendo servicios avanzados de la actividad y de las telecomunicaciones. Con
control automatizado, monitorización, gestión y mantenimiento de los distintos subsistemas o
servicios del edificio, de forma óptima e integrada, local y remotamente. Diseñados con
suficiente flexibilidad como para que sea se n-cilla y económicamente rentable la
implantación de futuros sistemas. La inmótica integra la domótica interna dentro de una
estructura en red.
Desarrollo de sistema inmótico con plataforma Arduino.
Arduino es una plataforma de hardware libre basada en una sencilla placa con un micro
controlador y un entorno de desarrollo que implementa el lenguaje de programación
Processing/Wiring. 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 pu e-den montar a mano o adquirirse. El entorno de
desarrollo integrado libre se puede descargar gratuitamente.
Las plataformas Arduino están basadas en los microcontroladores Atmega168, Atmega328,
Atmega1280, ATmega8 y otros similares, chips sencillos y de bajo coste que permiten el
desarrollo de múltiples diseños.
Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, pue-de 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 Electronica de 2006
Un poco más sobre inmótica...
Beneficios de la inmótica: Para el propietario del edificio, quien puede ofrecer un edificio más
atractivo mientras alcanza grandes reducciones en los costos de energía y operación. Para
los usuarios del edificio, los cuales mejoran notablemente su confort y seguridad. Para el
personal de mantenimiento del edificio que, mediante la información almacenada y el
posterior estudio de tendencias, puede prevenir desperfectos. Para el personal de seguridad,
el cual ve facilitada y complementada su tarea con el fin de hacerla mucho más eficiente.
Aplicaciones de la inmótica: ofrece la posibilidad de monitorización del funcionamiento
general del edificio. Los ascensores, el balance energético, el riego, la climatización e
iluminación de las áreas comunes, la sensorización de variables analógicas como
temperatura y humedad, control y alertas en función de parámetros determinados, el sistema
de accesos, sistemas de detección de incendios, etc. Del mismo modo permite un mayor
control de accesos y el seguimiento continuo de quien haya ingresado al edificio. Se ha
aplicado con éxito en edificios residenciales, de oficinas, hoteles, hospitales, museos, centros
comerciales, geriátricos, barrios cerrados e industrias. Un poco más sobre Arduino...
En la comunidad educativa, la plataforma Arduino se está extendiendo enormemente en los
últimos años para la enseñanza de diferentes materias: Desarrollo de productos electrónicos,
Programación en C/C++, Microcontroladores, Tecnología, etc... Ello es debido a varios
factores que hacen de la plataforma un entorno único en el marco tecnológico actual:
• Software y hardware libre
• Alta disponibilidad en el mercado y diferentes versiones
• Disponibilidad de librerías para su conexión a múltiples dispositivos
• Disponibilidad de librerías de comunicaciones para diferentes protocolos y buses de campo
• Amplio soporte con una comunidad muy extendida y dinámica
• Muy bajo coste al no requerir ningún pago de licencias y/o royalties tanto en el hardware
como en el software de desarrollo
Justificación y propósito del proyecto
Este proyecto tiene como objetivo automatizar por diferentes modos el accionamiento de
una persiana para optimizar la sostenibilidad que ésta nos puede llegar a dar.
Los modos de funcionamiento serán los siguientes:
1Con pulsadores: Mediante unos pulsadores podremos editar la posición a nuestro
gusto en ese momento. Los botones funcionaran así:
a) Apertura máxima.
b) Cierre máximo.
c) Apertura parcial.
d) Cierre parcial.
2Por internet: Se creará una página web en la que mediante la plataforma Flash
y una placa de Ethernet conectada a Arduino accionaremos la persiana en los modos
anteriormente mencionados.
La tecnología evoluciona para hacernos más fácil el día a día en el hogar, una de estas
evoluciones se ha aplicado en las persianas.
Esta automatización es muy útil ya que es un elemento que se acciona pocas veces al
día pero se deben realizar todos los días, por eso, con un programa sencillo nos
podemos un gran trabajo. También es muy útil en aquellas partes de la casa en las que
es difícil el acceso manualmente a la persiana. En el apartado del mantenimiento el
accionamiento mecánico sufre menos ya que todas las veces se ejerce la misma fuerza.
Ejecución del proyecto
Material Necesario
Persiana
Las persianas se automatizan simplemente montando
el motor, llamado tubular por su forma, en el interior
del tubo de enrollamiento de la persiana. El
accionamiento se puede ejecutar desde cerca de la
persiana, con unos simples pulsadores, o mediante
internet.
El motor funciona con una alimentación de 230 V. Su
funcionamiento es fiable y preciso.
Automatizar las persianas existentes es fácil,
económico y rápido gracias a la posibilidad de
instalar un sistema de automatización vía Ethernet con
central electrónica incorporada en el motor tubular.
Dicha solución evita el costo y la incomodidad de tener que realizar obras de
mampostería o de aplicar canaletas antiestéticas para el paso de los cables de mando.
Las persianas automatizadas le evitarán cualquier esfuerzo y garantizan el cierre
perfecto de la vivienda durante su ausencia.
Arduino 1
Arduino es una plataforma de electrónica abierta
para la creación de prototipos basada en software y
hardware flexibles y fáciles de usar. Se creó para
artistas, diseñadores, aficionados y cualquiera
interesado en crear entornos u objetos interactivos.
Arduino puede tomar información del entorno a
través de sus pines de entrada de toda una gama de
sensores y puede afectar aquello que le rodea
controlando luces, motores y otros actuadores. El
microcontrolador en la placa Arduino se programa mediante el lenguaje de
programación Arduino(basasdo en Wiring) y el entorno de desarrollo Arduino (basado
en Processing). Los proyectos hechos con Arduino pueden ejecutarse sin necesidad de
conectar a un ordenador, si bien tienen la posibilidad de hacerlo y comunicar con
diferentes tipos de software (p.ej. Flash, Processing, MaxMSP).
Placa Ethernet Shield
La Arduino Ethernet es un microcontrolador pasado en el ATmega328 (datasheet). Tiene
14 pines digitales de E/S, 6 entradas analógicas, un oscilador de 16Mhz, un conector
RJ45, un conector de alimentación, un conector ICSP y un botón de reset.
Nota: los Pines 10, 11, 12 y 13 están reserbados para la comunicación con el módulo
Ethernet, por lo que no pueden ser utilizados para otros usos. Esto reduce el numero de
pines disponibles a 9, con 4 capaces de dar salida PWM.
La placa puede ser alimentadad desde un módulo POE (Power over Ethernet).
La Arduino Ethernet difiere de otras placas en que no
posee un chip convertidor USB a Serie (como el
ATmega8u2 de la UNO o el FTDI de modelos
anteriores, pero posee un chip Wiznet Ethernet, el
mismo que emplea el Ethernet shield.
En la placa se encuentra un slot para tarjeta microSD,
el cual puede ser usado para almacenar ficheros y
enviarlos mas tarde por la red. Este slot microSD es
accesible a través de la librería SD.
La comunicación con el slot microSD se hace a través
del protocolo SPI, por lo que utiliza los pines 11, 12 y 13
al igual que el chip Wiznet, para el pin SS se reserva el
pin 4, por lo que tampoco podrá ser utilizado para otros propósitos si le emplea la
microSD.
Para programar la Arduino Ethernet se necesita un convertidor USB a Serie esterno
INCLUIDO en este kit. Este programador externo provee de comunicación con el
ordenador y alimentación electrica a través de USB.
Microcontrolador
Voltage de funcionamiento
Alimentación (recomendada)
Voltage máximo de entrada(no
recomendado)
Pines digitales I/O
Pines de entrada analógica
Corriente DC por I/O Pin
Corriente DC para el pin 3.3V
Memoria Flash
ATmega328
5V
7-12V
20V
14 (de los cuales 6 dan salida PWM)
6
40 mA
50 mA
32 KB (ATmega328) 0.5 KB usados por el
bootloader
SRAM
2 KB (ATmega328)
EEPROM
1 KB (ATmega328)
Velocidad de reloj
16 MHz
Para más información consultar la página oficial de la Arduino Ethernet.
Librería Ethernet. Desde la publicación del Arduino IDE 1.0 esta librería soporta DHCP
Placa de Relé con Octocoplador
Un relé, relais o relevador es un interruptor que
está accionado mediante un electroimán.
Este dispositivo electromecánico es
comandado por un circuito accionado por
una bobina. Permite controlar circuitos de
salida que posean mayor potencia que los de
entrada, oficiando de amplificador eléctrico.
El relé está compuesto por dos tipos de
contactos, los de trabajo, que se cierran
cuando la bobina se alimenta, y los de reposo
que se cierran cuando la bobina no es
alimentada.
Este circuito ha sido realizado con el programa DipTrace en la parte de Eschematics.
Este circuito ha sido realizado con el programa DipTrace en la parte de PCB
Layout.
PULSADORES
Un pulsador es un dispositivo utilizado para
activar alguna función. Los pulsadores son
de diversa forma y tamaño y se
encuentran en todo tipo de dispositivos,
aunque principalmente en aparatos
eléctricos o electrónicos. Los botones son
por lo general activados al ser pulsados,
hace pasar la corriente mientras es
accionado. Cuando ya no se actúa sobre
él vuelve a su posición de reposo.
Puede ser el contacto normalmente
cerrado en reposo NC, o con el contacto
normalmente abierto NA.
Este circuito ha sido realizado con el programa DipTrace en la parte de Eschematics.
Este circuito ha sido realizado con el programa DipTrace en la parte de PCB Layout.
¿Qué es y cómo funciona una placa de Ethernet Shield?
El Arduino Ethernet Shield conecta el Arduino a Internet en cuestión de minutos. Sólo
tiene que conectar este módulo en la placa Arduino, conectarlo a la red con
un conector RJ45 cable (no incluido) y seguir algunas instrucciones sencillas para
empezar a controlar su mundo a través de Internet. Como siempre con Arduino, todos
los elementos de la plataforma - hardware, software y documentación - es de libre
acceso y de fuente abierta. Esto significa que usted puede aprender exactamente
cómo se hace y utilice su diseño como punto de partida para sus propios
circuitos. Cientos de miles de placas Arduino ya están impulsando la creatividad de las
personas en todo el mundo, todos los días. Únete a nosotros, Arduino es usted!
Requiere y placa Arduino (no incluido)
Tensión 5 V (suministrados desde la placa Arduino)
Ethernet Controller: W5100 con buffer interno de 16K
Velocidad de conexión: 10/100Mb
Conexión con Arduino en puerto SPI
Descripción
El Arduino Ethernet Shield permite a una placa Arduino
conectarse a internet. Se basa en la Wiznet W5100 chip
Ethernet ( hoja de datos ). El W5100 Wiznet proporciona una
red (IP) de pila capaz de TCP y UDP. Soporta hasta cuatro
conexiones de socket simultáneas. Utilice la librería Ethernet para escribir sketches que
se conectan a Internet a través de la pantalla. El escudo de Ethernet se conecta a una
placa Arduino con largas Wire Wrap-headers que se extienden a través del escudo. Esto
mantiene la disposición de las clavijas intacta y permite que otro escudo para ser
apilados en la parte superior.
La revisión más reciente de la Junta expone el pinout 1.0 en rev 3 de la placa Arduino
UNO.
The Shield Ethernet tiene un estándar de conexión RJ-45, con un transformador de línea
integrada y Power over Ethernet habilitado.
Hay una bordo micro-SD ranura de la tarjeta, que puede ser usado para almacenar
archivos para servir a través de la red. Es compatible con el Arduino Uno y Mega
(usando la biblioteca de Ethernet). El CODEC de lector de tarjetas microSD se puede
acceder a través de la Biblioteca SD. Cuando se trabaja con esta biblioteca, SS es el pin
4. La revisión original del escudo figura una ranura SD de tamaño completo de tarjeta, lo
que no es compatible.
La pantalla también incluye un
controlador de reajuste, para
asegurarse de que el módulo Ethernet
W5100 se reinicia correctamente en el
encendido. Las revisiones anteriores del
escudo no eran compatibles con la
Mega y la necesidad de restablecer
manualmente después del encendido.
El escudo actual tiene una
alimentación a través de Ethernet
( PoE ) Módulo diseñado para extraer
energía de una convencional de par
trenzado Categoría 5 cable Ethernet:
IEEE802 0,3 af cumple
Bajo rizado de salida y ruido (100mVpp)
36V Rango de voltaje de entrada de 57V a
Protección contra sobrecarga y cortocircuito
Salida de 9V
Alta eficiencia convertidor DC / DC: typ 75% 50% de Carga
1500V de aislamiento (entrada a salida)
NB: la alimentación a través de Ethernet módulo hardware propietario es no hecho por
Arduino, es un accesorio de terceros. Para obtener más información, consulte la hoja de
datos
El escudo no viene con el PoE módulo incorporado, que es un componente separado
que debe ser añadido.
Arduino se comunica tanto con el W5100 y la tarjeta SD con el bus SPI (a través de la
cabecera ICSP). Esto es en los pines digitales 11, 12 y 13 en el Duemilanove y los
pasadores 50, 51, y 52 en el Mega. En ambas tablas, el pasador 10 se utiliza para
seleccionar el W5100 y el pin 4 para la tarjeta SD. Estas patillas no se puede utilizar para
general i / o. En la Mega, el hardware SS pin, 53, no se utiliza para seleccionar el W5100 o
la tarjeta SD, pero debe mantenerse como una salida o la interfaz SPI no funcionará.
Tenga en cuenta que debido a que el W5100 y la cuota de la tarjeta SD del bus SPI, sólo
uno puede estar activo a la vez.Si está utilizando ambos periféricos en su programa, esto
debe ser atendido por las bibliotecas correspondientes. Si usted no está utilizando uno
de los periféricos de su programa, sin embargo, tendrá que explícitamente anular su
selección. Para hacer esto con la tarjeta SD, ajuste el pin 4 como salida y escribir un alto
a la misma. Para el W5100, sistema digital de 10 pines como salida alta.
El protector provee un estándar RJ45 ethernet jack.
El botón de reinicio se restablece el escudo tanto el W5100 y la placa Arduino.
El escudo contiene un número de informativos LEDs :
PWR: indica que la placa y el escudo son alimentados
LINK: indica la presencia de un enlace de red y parpadea cuando el escudo transmite o
recibe datos
FULLD: indica que la conexión de red es full duplex
100M: indica la presencia de una conexión de red 100 Mb / s (en lugar de 10 Mb / s)
RX: parpadea cuando la pantalla recibe datos
TX: parpadea cuando el escudo envía datos
COLL: parpadea cuando se detectan colisiones de red
El puente de soldadura de la marca "INT" puede conectarse a permitir que la placa
Arduino a recibir por interrupciones notificación de eventos desde el W5100, pero esto
no es apoyado por la librería Ethernet. El puente conecta el pin INT del W5100 para pin
digital 2 de la Arduino.
Programa.
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFF, 0xEE}; // la mac de tu
ethernet
byte ip[] = {
192, 168, 10, 150}; // ip de tu red local y que deberas
activar en el router
EthernetServer server(502); // puerto por el accedes y
deber estar activado en el router
EthernetClient cliente;
word Registros[20];
byte Paquete[256];
byte Bytes;
// Declaracion de pines, modo y nivel.
int pinesTotales = 11;
// pines digitales
int pines[] = {
3,4,5,6,7,8,9,10,11,12,13};
// modo 1 = OUTPUT modo 0 = INPUT
int modoPines[] = {
0,0,0,0,0,1,1,1,1,1,1};
// nivel 0 = LOW nivel 1 = HIGH
int nivelPines[] = {
0,0,0,0,0,1,1,0,0,0,0};
// 1,1 por ser reles inversos. (logica negativa)
unsigned long tiempo;
unsigned long retardo;
int tiempoSubida = 12000;
void setup()
{
Ethernet.begin(mac, ip);
server.begin(); // Comunicación con el router
(ordenadores en red)
Serial.begin(9600); // Mostrar datos en pantalla
"monitor serial"
// Inicializamos los pines digitales
for (int i=0; i < pinesTotales; i++)
{
pinMode(pines[i], modoPines[i]);
digitalWrite(pines[i], nivelPines[i]);
}
Registros[9] = 1;
Registros[8] = 1;
}
void loop()
{
for (byte i=0; i < pinesTotales; i++)
{
nivelPines[i] = Registros[i+3];
}
// Inicializamos los pines digitales
for (int i=0; i < pinesTotales;i++)
{
digitalWrite(pines[i], nivelPines[i]);
}
Fon_Recibir();
Fon_Persiana();
}
void Fon_Persiana()
{
// Si activo pulsador en el pin 6
if (digitalRead(6))
{
Registros[8] = 0;
digitalWrite(8,LOW);
Fon_Recibir();
tiempo = millis();
while (digitalRead(6))
{
Fon_Recibir();
}; // espero soltar boton
if ((millis() - tiempo) < 1000)
{
unsigned long t = millis();
while ((millis() - t) < tiempoSubida)
{
Fon_Recibir();
}
}
Registros[8] = 1;
Registros[6] = 0;
digitalWrite(9, HIGH);
Fon_Recibir();
}
// Si activo pulsador en el pin 7
else if (digitalRead(7))
{
Registros[9] = 0;
digitalWrite(9,LOW);
Fon_Recibir();
tiempo = millis();
while (digitalRead(7))
{
Fon_Recibir();
} // espero soltar boton
if ((millis() - tiempo) < 1000)
{
unsigned long t = millis();
while ((millis() - t) < tiempoSubida)
{
Fon_Recibir();
}
}
Registros[9] = 1;
Registros[7] = 0;
digitalWrite(9, HIGH);
Fon_Recibir();
}
// Si recibo desde internet el registro 6 a 1
else if (Registros[6])
{
Registros[8] = 0;
digitalWrite(8,LOW);
Fon_Recibir();
tiempo = millis();
while ((Registros[6]))
{
Fon_Recibir();
// para subir a tope la persiana y salir de este bucle,
aunque no se reciba nada del ordenador
if ((millis() - tiempo) > tiempoSubida)
{
Registros[6] = 0;
}
}
Registros[8] = 1;
digitalWrite(8, HIGH);
}
// Si recibo desde internet el registro 7 a 1
else if (Registros[7])
{
Registros[9] = 0;
digitalWrite(9,LOW);
Fon_Recibir();
tiempo = millis();
while ((Registros[7]))
{
Fon_Recibir();
// para subir a tope la persiana y salir de este bucle,
aunque no se reciba nada del ordenador
if ((millis() - tiempo) > tiempoSubida)
{
Registros[7] = 0;
}
}
Registros[9] = 1;
digitalWrite(9, HIGH);
}
}
boolean Fon_Comprobar_CRC(byte *Paquete, byte inicio, byte Bytes_Recibidos)
{
word crc_calculado = CRC(Paquete, inicio, Bytes_Recibidos-2); /* CRC */
word crc_recibido = (Paquete[Bytes_Recibidos-2] << 8) | Paquete[Bytes_Recibidos-1];
if (crc_calculado != crc_recibido)
{
crc_calculado = CRC(Paquete, inicio, Bytes_Recibidos);
Paquete[Bytes_Recibidos++] = crc_calculado >> 8;
Paquete[Bytes_Recibidos++] = crc_calculado & 0x00FF;
return 0;
}
else
{
return 1;
}}
word CRC(byte *Paquete, byte inicio, byte final)
{
int i,j;
word temporal, temporal2, bandera;
temporal = 0xFFFFF;
for (i=inicio; i < final; i++)
{
temporal = temporal ^ Paquete[i];
for (j=1; j <= 8; j++)
{
bandera = temporal & 0x0001;
temporal = temporal >> 1;
if (bandera) temporal = temporal ^ 0xA001;
} }
// ordenar inversamente
temporal2 = temporal >> 8;
temporal = (temporal << 8) | temporal2;
temporal &= 0xFFFF;
return temporal;
} // Fin de la funcion
CRC
/*
* Funcion: Anade_CRC
*/
void Anade_CRC(byte *Paquete, byte Bytes_Paquete)
{
int temp_crc = CRC(Paquete, 0, Bytes_Paquete); /* crc */
Paquete[Bytes_Paquete++] = temp_crc >> 8;
Paquete[Bytes_Paquete] = temp_crc & 0x00FF;
} // Fin de la funcion Anade_CRC
// Preparado para recibir la trama del ordenador, tanto udp 1 3 0 0 0 0 1 12 22 crc crc
// como tcp 0 0 0 0 0 9 1 3 0 0 0 1 2 crc crc, siendo 9 el numero de bytes que se envian despues
// Recibe los datos y los almacena en "paquete" y si son correctos devuelve "true",
// en caso contrario devuelve "false"
boolean Fon_Recibe_Del_Ordenador(EthernetClient cliente, byte *paquete)
{
if (cliente)
{
while(cliente.connected())
{ // si hay datos los guarda en "paquete" y el numero de bytes se guardan en "Bytes"
while(cliente.available())
{
paquete[Bytes++] = cliente.read();
Serial.print(paquete[Bytes-1]);
Serial.print(" ");
}
Serial.println();
// si se han recibido datos
if (Bytes > 0)
{
//cliente.print(Bytes);
// si recibo tcp 0 0 0 0 0 x quito los 6 primeros del paquete
if ((paquete[0] == 0) && (paquete[1] == 0))
{
for (int i=6; i < Bytes; i++)
{
paquete[i-6] = paquete[i];
}
Bytes = Bytes - 6;
}
// comprobamos en pantalla los datos recibidos
for (int i=0; i < Bytes; i++)
{
//Serial.println(paquete[i]);
}
// comprobamos el crc. (pestaña crc)
if (Fon_Comprobar_CRC(paquete, 0, Bytes))
{return 1;
}
else
{ return 0;
} }
} // if cliente
cliente.stop();
}}
void Fon_Recibir()
{
Bytes = 0;
cliente = server.available();
if (Fon_Recibe_Del_Ordenador(cliente, Paquete))
{
if (Paquete[1] == 0x03)
{
Fon_Transmitir_Al_Ordenador();
}
if (Paquete[1] == 0x10)
{
Serial.print("paquete 3=");
Serial.print(Paquete[3]);
Serial.print(" paquete 8=");
Serial.println(Paquete[8]);
Registros[Paquete[3]] = Paquete[8];
for (int i=0; i < 20; i++)
{
Serial.print(i);
Serial.print("=");
Serial.print(Registros[i]);
Serial.print(" ");
}
Serial.println();
}
cliente.flush();
Serial.println();
}
}
void Fon_Transmitir_Al_Ordenador()
{
int cont = 3;
Paquete[0] = 1;
Paquete[1] = 0x03;
Paquete[2] = 40;
for (int i=0; i < 20; i++)
{
Paquete[cont++] = Registros[i] >> 8;
Paquete[cont++] = Registros[i] & 0x00FF;
}
cont--;
Anade_CRC(Paquete, cont);
cont +=2;
cliente.write(cont);
for (int i=0; i < cont; i++)
{
cliente.write(Paquete[i]);
Serial.print(Paquete[i]);
Serial.print(" ");
}
Serial.println();
cliente.flush();
}
Lista y Precios de los Materiales.
COMPONENTE
Persiana Motorizada
Arduino One
Ethernet Shield
Placa Reles
Placa Pulsadores
Placa Board
Cableado
UNIDAD
1
1
1
1
1
1
1
TOTAL
PRECIO
70,00 €
25,90€
32,50€
12,20€
2,00€
5,10€
4,75€
152,45€
Fotos descriptivas.
Vista General
Conex. Ethernet, Relés y Pulsadores
Conexiones Motor Persiana
Detalle Motor persiana a Relés
Montaje en Detalle
Notación Bibliográfica.
Paginas web.
http://www.arduino.cc
http://arduino.cc/forum/
http://programar-enc.blogspot.com.es/
http://www.diegotecnology.es/domotica-arduino-android/
Libros
Título: 30 Proyectos con Arduino
Autor: Simon Monk
