Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Introducción A Arduino, Massimo Banzi, Trad. Por Mikeas Micelli
Introducción A Arduino, Massimo Banzi, Trad. Por Mikeas Micelli
a
Arduino
Massimo Banzi
Primera edición
Introducción a Arduino
by Massimo Banzi
Publicado por Make:Books, Una huella de Maker Media, Una división de O’Reilly Media, Inc.
1005 Gravenstein Highway North, Sebastopol, CA 95472
O’Reilly books Pueden ser comprados para uso educativo, comercial o de promoción de ventas. Para obtener
más información, departamento de ventas corporativo / institucional: 800-998-9938 or
corporate@oreilly.com.
El logotipo de O'Reilly es una marca registrada de O'Reilly Media, Inc. Las designaciones de la serie Make: Projects
y las referencias relacionadas son marcas registradas de O'Reilly Media, Inc. Las marcas comerciales de terceros
utilizadas en este trabajo son propiedad de Sus respectivos propietarios.
Mensaje importante a nuestros lectores: Su seguridad es su propia responsabilidad, incluyendo el uso apropiado
del equipo y equipo de seguridad, y determinar si usted tiene habilidad y experiencia adecuadas. La electricidad y
otros recursos utilizados para estos proyectos son peligrosos a menos que se utilicen adecuadamente y con las
precauciones adecuadas, incluido el equipo de seguridad. Algunas fotos ilustrativas no representan precauciones
o equipos de seguridad, con el fin de mostrar los pasos del proyecto con mayor claridad. Estos proyectos no están
destinados a ser utilizados por niños.
El uso de las instrucciones y sugerencias de Introducción a Arduino es bajo su propio riesgo. O'Reilly Media, Inc. y
el autor renuncian a toda responsabilidad por cualquier daño, lesión o gasto resultante. Es su responsabilidad
asegurarse de que sus actividades cumplen con las leyes aplicables, incluidos los derechos de autor.
ISBN: 978-0-596-15551-3
Contenido
Prefacio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v
1/ Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Audiencia deseada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . 2
¿Qué es la informática física? . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3/ La Plataforma Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
El hardware de Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
El Software (IDE). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Instalación de Arduino en su computadora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Instalación de controladores: Macintosh. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
Instalación de controladores: Windows. . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . .23
Identificación de puertos: Macintosh. . . . ... . . . . . . . ... . . . . . . . . . . . . . . . . . . . . .25
Identificación del Puerto: Windows . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . .26
7/ Solución de problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Prueba de la Junta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Prueba de su circuito de Breadboard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
Aislar los problemas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Problemas con el IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Cómo obtener ayuda en línea. . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Apéndices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Apéndice A / El tablero de pan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
Apéndice B / Lectura de los Reactores y Condensadores. . . . . . . . . . . . . . . . . . . . . .95
Apéndice C / La referencia rápida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Apéndice
D / Lectura de diagramas esquemáticos. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Prefacio
Hace unos años me dieron un reto muy interesante: enseñar a los
diseñadores el mínimo en la electrónica para que pudieran construir
prototipos interactivos de los objetos que estaban diseñando.
Comencé a seguir un instinto subconsciente para enseñar la electrónica de la misma
manera que me enseñaron en la escuela. Más tarde me di cuenta de que simplemente
no estaba funcionando tan bien como me gustaría, y comenzó a recordar sentado en
una clase, aburrido como el infierno, escuchando toda esa teoría que se me lanzó sin
ninguna aplicación práctica para ello.
Como un niño, siempre me fascinó descubrir cómo funcionan las cosas; Por lo tanto,
solía separarlos. Esta pasión creció mientras apuntaba cualquier objeto no utilizado en la
casa y luego lo desmonté en pedacitos. Eventualmente, la gente me trajo todo tipo de
dispositivos para diseccionar. Mis más grandes
Prefacio v
Después de bastante de esta disección, sabía qué componentes electrónicos eran y más
o menos lo que hicieron. Además, mi casa estaba llena de viejas revistas electrónicas
que mi padre debió haber comprado a principios de los años setenta. Pasé horas
leyendo los artículos y mirando los diagramas de circuito sin entender mucho.
Este proceso de leer los artículos una y otra vez, con el beneficio del conocimiento
adquirido al desmontar circuitos, creó un círculo virtuoso lento.
Un gran avance llegó una Navidad, cuando mi papá me dio un kit que permitía a los
adolescentes a aprender sobre la electrónica. Cada componente se alojaba en un cubo
de plástico que se acoplaba magnéticamente con otros cubos, estableciendo una
conexión; El símbolo electrónico fue escrito en la parte superior. Poco sabía yo que el
juguete era también un hito del diseño alemán, porque Dieter Rams lo diseñó en los
años 60.
Con esta nueva herramienta, podría rápidamente montar circuitos y probarlos para ver
qué pasó. El ciclo de prototipado fue cada vez más corto.
He pasado mucho tiempo buscando una palabra en inglés que resumiría esa forma de
trabajar sin un plan específico, comenzando con una idea y terminando con un
resultado completamente inesperado. Finalmente, "juguetear" vino adelante. Reconocí
cómo esta palabra se ha utilizado en muchos otros campos para describir una forma de
operar y retratar a las personas que emprenden un camino de exploración. Por ejemplo,
la generación de directores franceses que dieron a luz a la "Nouvelle Vague" fueron
llamados los "tinkerers". La mejor definición de retoque que he encontrado viene de
una exposición que se llevó a cabo en el Exploratorium en San Francisco:
Bricolaje es lo que sucede cuando se intenta algo que no saben cómo hacer, guiado por
el capricho, la imaginación y la curiosidad. Cuando usted juguetea, no hay instrucciones,
pero tampoco hay fracasos, no hay formas correctas o incorrectas de hacer las cosas. Se
trata de averiguar cómo funcionan las cosas y volverlas a trabajar.
vi Introducción a Arduino
Contraptions, máquinas, wildly mismatched los objetos que trabajan en armonía - esto
es la materia del retoque.
El bricolaje es, en su forma más básica, un proceso que combina juego e investigación.
—www.exploratorium.edu/tinkering
Desde mis primeros experimentos sabía cuánta experiencia necesitarías para poder
crear un circuito que haría lo que querías a partir de los componentes básicos.
Otro gran avance llegó en el verano de 1982, cuando fui a Londres con mis padres y pasé
muchas horas visitando el Museo de la Ciencia. Acababan de abrir una nueva ala
dedicada a las computadoras, y siguiendo una serie de experimentos guiados, aprendí
los fundamentos de la matemática binaria y la programación.
Cuando volví empecé a ahorrar dinero, porque quería comprar una computadora y
aprender a programar.
Mi primer y más importante proyecto después de eso fue usar mi nueva computadora
ZX81 para controlar una máquina de soldar. Sé que no suena como un proyecto muy
emocionante, pero había una necesidad para él y era un gran desafío para mí, porque
acababa de aprender cómo programar. En este punto, quedó claro que escribir líneas de
código requeriría menos tiempo que modificar circuitos complejos.
Veinte años más tarde, me gustaría pensar que esta experiencia me permite enseñar a
la gente que ni siquiera recuerdo haber tomado ninguna clase de matemáticas y para
infundirlos con el mismo entusiasmo y la capacidad de juguetear que tuve en mi
juventud y tener Desde entonces.
—Massimo
Prefacio vii
Expresiones de gratitud
Gillian Crampton-Smith por darme una oportunidad y por todo lo que he aprendido de ella.
Brian Jepson por ser un gran editor y entusiasta partidario todo el tiempo.
Nancy Kotary, Brian Scot, Terry Bronson y Patti Schiendelman por convertir lo que escribí en un libro terminado.
Quiero agradecer a mucha más gente, pero Brian me dice que me estoy quedando sin espacio, así que voy a
enumerar un pequeño número de personas que tengo que agradecer por muchas razones:
Monico, Giorgio Olivero, Giovanna Gardi, Giovanni Battistini, Heather Martin, Jennifer Bove, Laura Dellamota,
Lorenzo
Prof. Salvioni, Raffaella Ferrara, Renzo Giusti, Sandi Athanas, Sara Carpentieri, Sigrid Wiederhecker, Stefano Mirti,
Ubi De Feo, Veronika Bucko.
Cómo contactarnos
Hemos verificado la información de este libro de la mejor manera posible,
pero puede que encuentre cosas que han cambiado (¡o incluso que hemos
cometido errores!). Como lector de este libro, puede ayudarnos a mejorar
futuras ediciones enviándonos sus comentarios. Por favor, háganos saber
acerca de cualquier error, inexactitud, declaraciones engañosas o confusas y
errores tipográficos que encuentre en cualquier parte de este libro.
También háganos saber qué podemos hacer para que este libro sea más útil
para usted. Tomamos en serio sus comentarios y trataremos de incorporar
sugerencias razonables en futuras ediciones.
Puede escribirnos a:
Media Maker
1005 carretera de gravenstein norte
Sebastopol, CA 95472
(800) 998-9938 (en los Estados Unidos o Canadá)
(707) 829-0515 (internacional / local)
(707) 829-0104 (fax)
Para obtener más información sobre este libro y otros, consulte el sitio web
de O'Reilly: www.oreilly.com.
Prefacio ix
1/ Introducción
»Se programa a través de un cable USB, no de un puerto serie. Esta característica es útil,
porque muchas computadoras modernas no tienen puertos serie.
Introducción 1
» El hardware es barato. La tarjeta USB cuesta unos 20 € (actualmente, unos 35 dólares)
y la sustitución de un chip quemado en la placa es fácil y cuesta no más de 5 € o 4 €. Así
que puedes permitirte cometer errores.
» Hay una comunidad activa de usuarios, por lo que hay muchas personas que pueden
ayudarte.
Este libro está diseñado para ayudar a los principiantes a comprender los beneficios que
pueden obtener al aprender a usar la plataforma Arduino y adoptar su filosofía
Audiencia deseada
Este libro fue escrito para los usuarios "originales" de Arduino: diseñadores y artistas.
Por lo tanto, trata de explicar las cosas de una manera que podría conducir a algunos
ingenieros locos. En realidad, uno de ellos llamó a los capítulos introductorios de mi
primer borrador "fluff". Ese es precisamente el punto. Seamos realistas: la mayoría de
los ingenieros no son capaces de explicar lo que hacen a otro ingeniero, y mucho menos
a un ser humano normal. Ahora vamos a profundizar en la pelusa.
________________________________________________________________________
NOTA: Arduino se basa en el trabajo de tesis que Hernando Barragan hizo en la
plataforma Wiring mientras estudiaba bajo Casey Reas y yo en IDII Ivrea.
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Después de que Arduino comenzó a ser popular, me di cuenta de cómo los
experimentadores, aficionados, y los hackers de todo tipo estaban empezando a
utilizarlo para crear objetos hermosos y locos. Me di cuenta de que todos ustedes son
artistas y diseñadores por derecho propio, así que este libro es para ustedes también.
Arduino nació para enseñar a Interaction Design, una disciplina de diseño que sitúa al
prototipo en el centro de su metodología. Hay muchas definiciones de Interaction
Design, pero la que yo prefiero es:
Computación física utiliza la electrónica para el prototipo de nuevos materiales para los
diseñadores y artistas.
Implica el diseño de objetos interactivos que pueden comunicarse con humanos usando
sensores y actuadores controlados por un comportamiento implementado como un
software que se ejecuta dentro de un microcontrolador (una computadora pequeña en
un solo chip).
En el pasado, usar la electrónica significaba tener que tratar con ingenieros todo el
tiempo, y construir circuitos un pequeño componente en ese momento; Estos temas
evitaban que las personas creativas jugaran con el medio directamente. La mayoría de
las herramientas estaban destinadas a los ingenieros y requerían un amplio
conocimiento. En los últimos años, los microcontroladores se han vuelto más baratos y
fáciles de usar, permitiendo la creación de mejores herramientas.
El progreso que hemos hecho con Arduino es acercar estas herramientas un paso más al
novicio, permitiendo a la gente comenzar a construir cosas después de sólo dos o tres
días de un taller.
Introducción 3
2/ El Camino del Arduino
La filosofía de Arduino se basa en hacer diseños en
lugar de hablar sobre ellos. Es una búsqueda
constante de formas más rápidas y más potentes de
construir mejores prototipos. Hemos explorado
muchas técnicas de prototipado y desarrollado
maneras de pensar con nuestras manos.
Este es el proceso de bricolaje que nos encanta-jugar con el medio de una manera
abierta y encontrar lo inesperado. En esta búsqueda de maneras de construir mejores
prototipos, también seleccionamos una serie de paquetes de software que permiten
el proceso de manipulación constante del software y del hardware.
El Camino a Arduino 5
Prototipos
El prototipado está en el corazón del Camino Arduino: hacemos cosas y construimos
objetos que interactúan con otros objetos, personas y redes. Nos esforzamos por
encontrar una manera más sencilla y rápida de prototipo en la forma más barata
posible.
Muchos de los principiantes que se acercan a la electrónica por primera vez piensan
que tienen que aprender a construir todo desde cero. Esto es una pérdida de energía:
lo que quieres es poder confirmar que algo está funcionando muy rápidamente para
que puedas motivarte para dar el siguiente paso o tal vez incluso motivar a alguien a
darte mucho dinero para hacerlo.
Es por eso que desarrollamos el "prototipado oportunista": ¿por qué gastar tiempo y
energía construyendo desde cero, un proceso que requiere tiempo y conocimiento
técnico profundo, cuando podemos tomar dispositivos ya hechos y hackearlos para
explotar el duro trabajo realizado por grandes Empresas y buenos ingenieros?
Nuestro héroe es James Dyson, quien hizo 5127 prototipos de su aspiradora antes de
que estuviera satisfecho de que lo había conseguido (www.international.
Dyson.com/jd/1947.asp).
Jugueteando
Creemos que es esencial jugar con la tecnología, explorando diferentes posibilidades
directamente en hardware y software, a veces sin una meta muy definida.
El Camino a Arduino 7
Parche
Siempre he sido fascinado por la modularidad y la capacidad de construir sistemas
complejos mediante la conexión de dispositivos simples. Este proceso está muy bien
representado por Robert Moog y sus sintetizadores analógicos. Los músicos
construyeron sonidos, intentando combinaciones interminables "juntando" diferentes
módulos con cables. Este enfoque hizo que el sintetizador parezca un viejo conmutador
telefónico, pero combinado con las numerosas perillas, era la plataforma perfecta para
mezclar música sonora e innovadora. Moog lo describió como un proceso entre
"testificar y descubrir". Estoy seguro de que la mayoría de los músicos al principio no
sabía lo que todos esos cientos de botones, pero lo intentaron y trataron, refinando su
propio estilo sin interrupciones en el flujo.
Esta técnica ha sido traducida al mundo del software por ambientes de "programación
visual" como Max, Pure Data o VVVV. Estas herramientas pueden visualizarse como
"cajas" para las diferentes funcionalidades que proporcionan, permitiendo al usuario
construir "parches" conectando estas cajas. Estos entornos permiten al usuario
experimentar con la programación sin la interrupción constante típica del ciclo habitual:
"tipo programa, compilación, maldición-hay un error, error de corrección, compilar,
ejecutar". Si usted es más visual mente, le recomiendo que probarlos.
El Camino a Arduino 9
Curvado del circuito
El Camino a Arduino 11
Teclado Hacks
Los teclados de computadora siguen siendo la principal forma de interactuar con
una computadora después de más de 60 años. Alex Pentland, director académico
del MIT Media Laboratory, comentó una vez: "Disculpe la expresión, pero los
urinarios de los hombres son más inteligentes que las computadoras. Las
computadoras están aisladas de lo que está a su alrededor ".
Camino a Arduino 15
Colaboración
La colaboración entre los usuarios es uno de los principios clave en el mundo
Arduino-a través del foro en www.arduino.cc, personas de diferentes partes del
mundo se ayudan mutuamente a aprender sobre la plataforma. El equipo de
Arduino alienta a las personas a colaborar a nivel local, así como ayudarles a crear
grupos de usuarios en cada ciudad que visiten. También creamos un Wiki llamado
"Playground" (www.arduino.cc/playground) donde los usuarios documentan sus
descubrimientos. Es tan asombroso ver cuánto conocimiento estas personas
vierten en la Web para que todos lo usen. Esta cultura de compartir y ayudarnos
mutuamente es una de las cosas que más me enorgullece de Arduino.
3/ La Plataforma Arduino
Arduino se compone de dos partes principales: el
tablero de Arduino, que es la pieza de hardware en
la que trabajas cuando construyes tus objetos; Y el
Arduino IDE, el software que ejecuta en su
computadora. Utilice el IDE para crear un boceto
(un pequeño programa de computadora) que
cargue en la tarjeta Arduino. El boceto le dice al
consejo qué hacer.
No hace mucho tiempo, trabajar en hardware significaba construir circuitos desde cero,
usando cientos de componentes diferentes con nombres extraños como resistencias,
condensadores, inductores, transistores, etc.
Cada circuito fue "cableado" para hacer una aplicación específica, y hacer cambios
necesarios para cortar cables, conexiones de soldadura, y más.
El hardware de Arduino
El tablero de Arduino es un pequeño tablero del microcontrolador, que es un pequeño
circuito (el tablero) que contiene una computadora entera en un pequeño
microprocesador (el microcontrolador). Este equipo es por lo menos mil veces menos
potente que el MacBook que estoy usando para escribir esto, pero es mucho más barato
y muy útil para construir dispositivos interesantes. Mira el tablero de Arduino: verás un
chip negro con 28 "piernas" - ese chip es el ATmega168, el corazón de tu tablero.
La Plataforma Arduino 19
Nosotros (el equipo de Arduino) hemos colocado en esta placa todos los componentes
que son necesarios para que este microcontrolador funcione correctamente y para
comunicarse con su computadora. Hay muchas versiones de este tablero; El que
usaremos a lo largo de este libro es el Arduino Duemilanove, que es el más sencillo de
usar y el mejor para aprender. Sin embargo, estas instrucciones se aplican a versiones
anteriores del tablero, incluyendo el más reciente Arduino Diecimila y el Arduino NG
más antiguo. La Figura 3-1 muestra el Arduino Duemilanove; La Figura 3-2 muestra el
Arduino NG.
En esas ilustraciones, ves la placa Arduino. Al principio, todos esos conectores podrían
ser un poco confusos. Aquí está una explicación de lo que hace cada elemento del
tablero:
Éstas pueden ser entradas o salidas, que se especifica mediante el croquis que se crea en
el IDE.
Estos pines de entrada analógicos dedicados toman valores analógicos (es decir, lecturas
de tensión de un sensor) y los convierten en un número entre 0 y 1023.
Estos son en realidad seis de los pines digitales que se pueden reprogramar para la salida
analógica utilizando el boceto que se crea en el IDE.
Ahora debe instalar los controladores que permiten que su computadora hable con su
tarjeta a través del puerto USB.
NOTA: Si está utilizando una Mac basada en Intel, como MacBook, MacBook Pro,
MacBook Air, Mac Pro o Intel Mini-Mac o iMac, asegúrese de instalar el controlador
con "Intel" en su nombre, como En FTDIUSBSerialDriver_v2_2_9_Intel.dmg. Si no está
utilizando una Mac basada en Intel, instale la que no tenga "Intel" en su nombre.
En la siguiente pantalla, elija "Instalar desde una lista o ubicación específica" y haga clic
en Siguiente.
La Plataforma Arduino 23
Marque la casilla "Incluir esta ubicación en la búsqueda", haga clic en Examinar,
seleccione la carpeta donde instaló Arduino y seleccione la carpeta Drivers \ FTDI USB
Drivers como ubicación. Haga clic en Aceptar y en Siguiente.
Pasará por este procedimiento dos veces, porque el equipo primero instala el
controlador de bajo nivel, luego instala un código que hace que la tarjeta se vea como
un puerto serie en el equipo.
Una vez instalados los controladores, puede iniciar el IDE de Arduino y comenzar a
utilizar Arduino.
A continuación, debe determinar qué puerto serie está asignado a su tarjeta Arduino:
necesitará esa información para programarla más tarde. Las instrucciones para obtener
esta información se encuentran en las siguientes secciones.
Identificación de puertos: Macintosh
En el menú Herramientas del IDE de Arduino, seleccione "Puerto serie" y seleccione el
puerto que comienza con /dev/cu.usbserial-; Este es el nombre que utiliza su computadora
para referirse a la placa Arduino. La Figura 3-3 muestra la lista de puertos
Figura 3-3.
La lista de puertos serie del IDE de Arduino
La Plataforma Arduino 25
Identificación del Puerto: Windows
En Windows, el proceso es un poco más complicado, al menos al principio. Abra el
Administrador de dispositivos haciendo clic en el menú Inicio, haga clic con el botón
secundario en Equipo (Vista) o Mi PC (XP) y seleccione Propiedades. En Windows XP,
haga clic en Hardware y elija Administrador de dispositivos. En Vista, haga clic en
Administrador de dispositivos (aparece en la lista de tareas a la izquierda de la ventana).
Busque el dispositivo Arduino en la lista bajo "Puertos (COM & LPT)". El Arduino
aparecerá como un puerto serie USB y tendrá un nombre como COM3, como se muestra
en la Figura 3-4.
Figura 3-4.
El Administrador de dispositivos de Windows muestra todos los puertos serie
disponibles
NOTA: En algunas máquinas Windows, el puerto COM tiene un número mayor que 9;
Esta numeración crea algunos problemas cuando Arduino trata de comunicarse con él.
Consulte el Capítulo 7, Solución de problemas para obtener ayuda sobre este
problema.
Una vez que haya descubierto la asignación de puerto COM, puede seleccionar ese
puerto en el menú Herramientas> Puerto serie en el IDE de Arduino.
La Plataforma Arduino 27
4/ Realmente empezando
con Arduino
Ahora aprenderá cómo crear y programar un
dispositivo interactivo.
Anatomía de un dispositivo interactivo
Todos los objetos que construiremos usando Arduino seguirán un patrón muy simple
que llamaremos "Interactive Device". El dispositivo interactivo es un circuito electrónico
que es capaz de detectar el ambiente utilizando sensores (componentes electrónicos
que convierten las mediciones del mundo real en señales eléctricas). El dispositivo
procesa la información que recibe de los sensores con un comportamiento que se
implementa como software. El dispositivo será capaz de interactuar con el mundo
utilizando actuadores, componentes electrónicos que pueden convertir una señal
eléctrica en una acción física.
Sentido / percepción
Sensores
Comportamien
to
(software )
Actuadores
Actuar /
Reaccionar
Figura 4-1.
El dispositivo interactivo
La Plataforma Arduino 29
Sensores y Actuadores
Los sensores y actuadores son componentes electrónicos que permiten que una pieza
de electrónica interactúe con el mundo.
Una vez que los sensores han sido leídos, el dispositivo tiene la información necesaria
para decidir cómo reaccionar. El proceso de toma de decisiones es manejado por el
microcontrolador, y la reacción es realizada por actuadores. En nuestros cuerpos, por
ejemplo, los músculos reciben señales eléctricas del cerebro y las convierten en un
movimiento. En el mundo electrónico, estas funciones podrían ser realizadas por un
motor eléctrico o un motor eléctrico.
Parpadeando un LED
El boceto de parpadeo de LED es el primer programa que debe ejecutar para comprobar
si su tarjeta Arduino funciona y está configurada correctamente. También suele ser el
primer ejercicio de programación que alguien hace cuando aprende a programar un
microcontrolador. Un diodo emisor de luz (LED) es un pequeño componente electrónico
que es un poco como una bombilla, pero es más eficiente y requiere voltajes más bajos
para operar.
Su tarjeta Arduino viene con un LED preinstalado. Está marcado con "L". También puede
agregar su propio LED-conectarlo como se muestra en la Figura 4-2.
Una vez que el LED está conectado, necesita decirle a Arduino qué hacer. Esto se hace a
través de código, es decir, una lista de instrucciones que le damos al microcontrolador
para que haga lo que queremos.
Figura 4-2.
Conexión de un LED a Arduino
En su computadora, abra la carpeta donde copió el IDE de Arduino. Haga doble clic en el
icono de Arduino para iniciarlo. Seleccione Archivo> Nuevo y se le pedirá que elija un
nombre de carpeta de boceto: aquí se almacenará su boceto Arduino. Asigne un
nombre a Blinking_LED y haga clic en Aceptar. A continuación, escriba el siguiente texto
(Ejemplo 01) en el editor de bocetos de Arduino (la ventana principal del IDE de
Arduino). También puede descargarlo desde www.makezine.com/ getstartedarduino.
Deberá aparecer como se muestra en la Figura 4-3.
Void setup () {
PinMode (LED, SALIDA); // establece el pin digital
como salida }
Void loop () {
DigitalWrite (LED, ALTA); // activa el retardo de encendido del LED (1000); // espera un
segundo digitalWrite (LED, LOW); // desactiva el LED (1000); // espera un segundo}
Figura 4-3.
El IDE de Arduino con el primer dibujo cargado
Ahora que el código está en su IDE, debe verificar que es correcto. Presione el botón
"Verificar" (la Figura 4-3 muestra su ubicación); Si todo está correcto, aparecerá el
mensaje "Done compilación" en la parte inferior del IDE de Arduino. Este mensaje
significa que el IDE de Arduino ha traducido su boceto en un programa ejecutable que
puede ejecutar la placa, un poco como un archivo .exe en Windows o un archivo .app en
una Mac.
La Plataforma Arduino 33
Verá que aparecen algunos mensajes en el área negra en la parte inferior de la ventana
y, justo encima de esa zona, aparecerá el mensaje "Finalizar la carga" para que sepa
que el proceso se ha completado correctamente. Hay dos LEDs, marcados RX y TX, en
el tablero; Estos parpadean cada vez que un byte es enviado o recibido por el tablero.
Durante el proceso de carga, siguen parpadeando.
Una vez que el código esté en tu tablero de Arduino, permanecerá allí hasta que
pongas otro dibujo en él. El boceto sobrevivirá si la tarjeta se reinicia o se apaga, un
poco como los datos en el disco duro de su computadora.
Suponiendo que el dibujo haya sido cargado correctamente, verá que el LED "L" se
enciende por un segundo y después se apaga durante un segundo. Si instaló un LED
separado como se muestra en la Figura 4-2, ese LED parpadeará también. Lo que acaba
de escribir y ejecutar es un "programa de computadora", o esbozo, como se llaman los
programas de Arduino. Arduino, como he mencionado antes, es una computadora
pequeña, y se puede programar para hacer lo que quieras. Esto se hace usando un
lenguaje de programación para escribir una serie de instrucciones en el IDE de
Arduino, que lo convierte en un ejecutable para su placa Arduino.
Pásame el Parmesano
Observe la presencia de corchetes, que se utilizan para agrupar líneas de código. Estos
son particularmente útiles cuando se desea dar un nombre a un grupo de instrucciones.
Si estás en la cena y le preguntas a alguien: "Por favor, pásame el queso parmesano",
esto inicia una serie de acciones que se resumen en la pequeña frase que acabas de
decir. Como somos humanos, todo viene naturalmente, pero todas las pequeñas
acciones individuales necesarias para hacer esto deben ser explicadas al Arduino,
porque no es tan poderoso como nuestro cerebro. Así que para agrupar una serie de
instrucciones, se pega un {antes de su código y un} después.
Puede ver que hay dos bloques de código que se definen de esta manera aquí. Ante
cada uno de ellos hay un extraño mandamiento:
void setup()
Esta línea da un nombre a un bloque de código. Si escribieras una lista de instrucciones
que enseñen a Arduino cómo pasar el parmesano, escribirías void passTheParmesan ()
al principio de un bloque, y este bloque se convertiría en una instrucción que puedes
llamar desde cualquier parte del código de Arduino. Estos bloques se llaman funciones.
Si después de esto escribes passTheParmesan () en cualquier parte de tu código,
Arduino ejecutará esas instrucciones y continuará donde lo dejó.
setup () es donde pone todo el código que desea ejecutar una vez al principio de su
programa y loop () contiene el núcleo de su programa, que se ejecuta una y otra vez.
Esto se hace porque Arduino no es como su computadora normal: no puede ejecutar
varios programas al mismo tiempo y los programas no pueden salir. Cuando se enciende
la tarjeta, el código se ejecuta; Cuando quieras parar, simplemente apágalo.
Es muy común (lo sé porque lo hago todo el tiempo) escribir un pedazo de código,
subirlo al tablero, y decir "Okay-yo nunca voy a tener que tocar a este chupón de
nuevo!" Sólo para Tenga en cuenta seis meses después que necesita actualizar el código
o corregir un error. En este punto, se abre el programa, y si no ha incluido ningún
comentario en el programa original, usted pensará: "Wow, ¡qué desastre! ¿Por dónde
empiezo? "A medida que avancemos, veremos algunos trucos para hacer que sus
programas sean más legibles y más fáciles de mantener.
void setup()
Esta línea indica a Arduino que el siguiente bloque de código se llamará setup ().
{
Con esta abrazadera de apertura, un bloque de código comienza.
}
Este cierre rizado significa el final de la función setup ().
void loop()
{
loop() es donde se especifica el comportamiento principal de su dispositivo interactivo.
Se repetirá una y otra vez hasta que apague el tablero.
Esta instrucción ahora apaga el LED que habíamos activado anteriormente. ¿Por qué
usamos HIGH y LOW? Bueno, es una vieja convención en electrónica digital. HIGH
significa que el pin está encendido, y en el caso de Arduino, se ajustará a 5 V. LOW
significa 0 V. También puede reemplazar mentalmente estos argumentos con ON y OFF.
}
Este cierre rizado marca el final de la función de bucle.
» Introduce un bucle
» Espera un segundo
» Desconecta el LED conectado a la clavija 13
» Espera un segundo
Antes de pasar a la siguiente sección, quiero que juegues con el código. Por ejemplo,
reduzca la cantidad de retardo, usando números diferentes para los pulsos de encendido
y apagado, de modo que pueda ver diferentes patrones de parpadeo. En particular,
usted debe ver lo que sucede cuando se hacen los retrasos muy pequeños, pero el uso
de diferentes retrasos para encendido y apagado. . . Hay un momento en que sucede
algo extraño; Este "algo" será muy útil cuando aprenda sobre la modulación de ancho
de pulso más adelante en este libro.
Lo que vamos a construir
Siempre he estado fascinado por la luz y la capacidad de controlar diferentes fuentes de
luz a través de la tecnología. He tenido la suerte de trabajar en algunos proyectos
interesantes que implican controlar la luz y hacerla interactuar con la gente. Arduino es
realmente bueno en esto. A lo largo de este libro, estaremos trabajando en cómo
diseñar "lámparas interactivas", usando Arduino como una forma de aprender los
conceptos básicos de cómo se construyen los dispositivos interactivos.
Si usted toma un ventilador aparte, usted verá que contiene una batería pequeña, un
par de alambres, y un motor eléctrico, y que uno de los alambres que van al motor es
interrumpido por un interruptor. Si tiene una batería nueva y encienda el interruptor, el
motor empezará a girar, proporcionando el frío necesario. ¿Como funciona esto? Bueno,
imagínese que la batería es un depósito de agua y una bomba, el interruptor es un grifo,
y el motor es una de esas ruedas que usted ve en los molinos de agua. Al abrir el grifo, el
agua fluye de la bomba y empuja la rueda en movimiento.
En este sencillo sistema hidráulico, que se muestra en la Figura 4-5, son importantes dos
factores: la presión del agua (que se determina por la potencia de la bomba) y la
cantidad de agua que fluirá en las tuberías (esto depende del tamaño De las tuberías y
la resistencia que la rueda proporcionará a la corriente de agua que la golpee).
Figura 4-5.
Un sistema hidráulico
Pronto se dará cuenta de que si desea que la rueda gire más rápido, necesita aumentar
el tamaño de las tuberías (pero esto sólo funciona hasta un punto) y aumentar la
presión que la bomba puede lograr. Aumentar el tamaño de las tuberías permite un
mayor flujo de agua para atravesarlas; Haciéndolos más grandes, hemos reducido
eficazmente la resistencia de las pipas al flujo del agua. Este enfoque funciona hasta
cierto punto, en el que la rueda no girará más rápido, porque la presión del agua no es
lo suficientemente fuerte. Cuando llegamos a este punto, necesitamos que la bomba
sea más fuerte. Este método de acelerar el molino de agua puede continuar hasta el
punto cuando la rueda se cae porque el flujo de agua es demasiado fuerte para él y se
destruye. Otra cosa que notará es que a medida que gira la rueda, el eje se calentará un
poco, porque no importa lo bien que hemos montado la rueda,
La fricción entre el eje y los orificios en los que está montado generará calor. Es
importante entender que en un sistema como este, no toda la energía que bombas en el
sistema se convertirá en movimiento; Algunos se perderán en una serie de ineficiencias
y generalmente se mostrará como el calor que emana de algunas partes del sistema.
¿Cuáles son las partes importantes del sistema? La presión producida por la bomba es
una; La resistencia que las tuberías y la rueda ofrecen al flujo de agua, y el flujo real de
agua (digamos que esto se representa por el número de litros de agua que fluyen en un
segundo) son los otros. La electricidad funciona un poco como el agua. Usted tiene una
especie de bomba (cualquier fuente de electricidad, como una batería o un enchufe de
pared) que empuja las cargas eléctricas (imagínelas como "gotas" de electricidad) hacia
abajo de las tuberías, que están representadas por los cables-algunos dispositivos
pueden utilizar Estos para producir calor (manta térmica de su abuela), luz (su lámpara
de dormitorio), sonido (su estéreo), movimiento (su ventilador), y mucho más.
Así que cuando lea que el voltaje de una batería es de 9 V, piense en este voltaje como
la presión del agua que potencialmente puede ser producida por esta pequeña
"bomba". El voltaje se mide en voltios, llamado así por Alessandro Volta, el inventor de
la primera batería.
Así como la presión del agua tiene un equivalente eléctrico, el caudal de agua también lo
hace. Esto se llama corriente, y se mide en amperios (después de André-Marie Ampère,
pionero del electromagnetismo). La relación entre tensión y corriente se puede ilustrar
volviendo a la rueda de agua: un voltaje más alto (presión) le deja girar una rueda más
rápidamente; Una mayor velocidad de flujo (corriente) le permite girar una rueda más
grande.
Esta es la única regla que realmente tienes que memorizar y aprender a usar, porque en
la mayoría de tu trabajo, ésta es la única que realmente necesitarás.
Uso de un pulsador para controlar el LED
Parpadeando un LED fue fácil, pero no creo que se quedaría sano si su lámpara de
escritorio continuamente parpadea mientras estaba tratando de leer un libro. Por lo
tanto, usted necesita aprender cómo controlarlo. En nuestro ejemplo anterior, el LED
era nuestro actuador, y nuestro Arduino lo estaba controlando. Lo que falta para
completar la imagen es un sensor.
En este caso, vamos a utilizar la forma más simple de sensor disponible: un pulsador.
Si desmontas un pulsador, verás que es un dispositivo muy simple: dos pedazos de metal
separados por un muelle, y un tapón de plástico que cuando se presiona pone en
contacto los dos trozos de metal. Cuando los trozos de metal están separados, no hay
circulación de corriente en el pulsador (un poco como cuando una válvula de agua está
cerrada); Cuando lo presionamos, hacemos una conexión.
Para supervisar el estado de un interruptor, hay una nueva instrucción de Arduino que
usted va a aprender: la función digitalRead().
digitalRead() comprueba si hay algún voltaje aplicado al pin que se especifica entre
paréntesis y devuelve un valor de HIGH o LOW dependiendo de sus resultados. Las otras
instrucciones que hemos usado hasta ahora no han devuelto ninguna información:
simplemente ejecutaron lo que les pedimos que hicieran. Pero ese tipo de función es un
poco limitada, porque nos obligará a seguir con secuencias de instrucciones muy
predecibles, sin la entrada del mundo exterior. Con digitalRead(), podemos "hacer una
pregunta" de Arduino y recibir una respuesta que puede ser almacenada en la memoria
en alguna parte y utilizada para tomar decisiones inmediatamente o más tarde.
Construya el circuito mostrado en la Figura 4-6. Para construir esto, necesitará obtener
algunas partes (estas serán útiles a medida que trabaje en otros proyectos también):
» Juego de cables de puenteo pre-cortado: Radio Shack 276-173, Hedge Maker KKN4
NOTA: en lugar de comprar alambre de puente, usted también puede comprar alambre
de conexión de sólidos de 22 AWG en pequeños carretes y cortar y pelar utilizando
cortadores de alambre y separadores de alambre.
Echemos un vistazo al código que vamos a utilizar para controlar el LED con nuestro
pulsador:
void setup() {
pinMode(LED, OUTPUT); // decir Arduino LED es una salida
pinMode(BUTTON, INPUT); // y BUTTON es una entrada
}
void loop(){
val = digitalRead(BUTTON); // leer el valor de entrada y almacenarlo
En Arduino, seleccione Archivo> Nuevo (si tiene otro boceto abierto, puede guardarlo
primero). Cuando Arduino le pide que nombre su nueva carpeta de boceto, escriba
PushButonControl. Escriba el código del ejemplo 02 en Arduino (o descárguelo desde
www.makezine.com/getstartedarduino y péguelo en el IDE de Arduino). Si todo es
correcto, el LED se encenderá al presionar el botónn.
He introducido dos nuevos conceptos con este programa de ejemplo: funciones que
devuelven el resultado de su trabajo y la instrucción if.
La sentencia if es posiblemente la instrucción más importante en un lenguaje de
programación, ya que permite que la computadora (y recuerde, el Arduino es un
pequeño ordenador) para tomar decisiones. Después de la palabra clave if, hay que
escribir una "pregunta" dentro de paréntesis, y si la "respuesta", o resultado, es
verdadera, se ejecutará el primer bloque de código; De lo contrario, se ejecutará el
bloque de código después de otro. Tenga en cuenta que he usado el símbolo == en lugar
de =. El primero se utiliza cuando se comparan dos entidades, y se devuelve TRUE o
FALSE; Este último asigna un valor a una variable. Asegúrese de que utiliza el correcto,
porque es muy fácil cometer ese error y usar sólo =, en cuyo caso su programa nunca
funcionará. Lo sé, porque después de 25 años de programación, todavía cometo ese
error.
Mantener el dedo en el botón durante el tiempo que necesita luz no es práctico. Aunque
te haría pensar en la cantidad de energía que estás desperdiciando cuando te alejas de
una lámpara que te quedaste en, tenemos que averiguar cómo hacer que el botón de
encendido "palo".
Para hacer esto, vamos a utilizar lo que se llama una variable. (Ya hemos usado uno,
pero no lo he explicado.) Una variable es un lugar en la memoria de Arduino donde
puedes almacenar datos. Piense en él como una de esas notas adhesivas que utiliza para
recordarse algo, como un número de teléfono: usted toma uno, usted escribe "Luisa 02
555 1212" en él, y se pega a su monitor de la computadora o su refrigerador. En el
lenguaje Arduino, es igualmente sencillo: sólo decide qué tipo de datos desea almacenar
(un número o un texto, por ejemplo), dale un nombre y cuando lo desee, puede
almacenar los datos o recuperarlos . Por ejemplo:
int val = 0;
NOTA: ¿Ha notado que en Arduino, todas las instrucciones, con una excepción
(#define), termina con un punto y coma? Esto se hace para que el compilador (la parte
de Arduino que convierte su boceto en un programa que el microcontrolador puede
ejecutar) sabe que su declaración ha terminado y una nueva está comenzando.
Recuerde usarlo todo el tiempo, excluyendo cualquier línea que comience con #define.
Los #define son reemplazados por el compilador antes de que el código se traduce en
un ejecutable de Arduino.
Ahora vamos a usar otra variable para recordar si el LED tiene que permanecer
encendido o apagado después de soltar el botón. El ejemplo 03A es un primer intento
de lograr:
// Ejemplo 03A: Encender el LED cuando se presiona el botón
// y mantenerlo encendido después de que se libere
void setup() {
pinMode(LED, OUTPUT); // decir Arduino LED es una salida
pinMode(BUTTON, INPUT); // y BUTTON es una entrada
}
void loop() {
val = digitalRead(BUTTON); // leer el valor de entrada y almacenarlo
if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON
} else {
digitalWrite(LED, LOW);
}
}
Ahora prueba este código. Usted notará que funciona. . . algo. Usted encontrará que la
luz cambia tan rápidamente que usted no puede fijarla confiablemente encendido o
apagado con una prensa del botón.
Veamos las partes interesantes del código: state es una variable que almacena 0 o 1 para
recordar si el LED está encendido o apagado. Después de soltar el botón, lo inicializamos
a 0 (LED apagado).
Más tarde, leemos el estado actual del botón, y si se presiona (val == HIGH), cambiamos
el estado de 0 a 1, o viceversa. Hacemos esto usando un pequeño truco, ya que el
estado puede ser solo 1 o 0. El truco que uso involucra una pequeña expresión
matemática basada en la idea de que 1 - 0 es 1 y 1 - 1 es 0:
state = 1 state;
Más adelante en el programa, puede ver que usamos el estado para averiguar si el LED
debe estar encendido o apagado. Como mencioné, esto conduce a resultados algo
escamosos.
Los resultados son escamosos debido a la forma en que leemos el botón. Arduino es
muy rápido; Ejecuta sus propias instrucciones internas a una tasa de 16 millones por
segundo, podría estar ejecutando unas pocas millones de líneas de código por segundo.
Así que esto significa que mientras tu dedo está presionando el botón, Arduino podría
estar leyendo la posición del botón unos miles de veces y cambiando de estado en
consecuencia. Así que los resultados terminan siendo impredecibles; Podría estar
apagado cuando usted lo quisiera encendido, o viceversa. Como incluso un reloj roto es
correcto dos veces al día, el programa puede mostrar el comportamiento correcto de
vez en cuando, pero la mayor parte del tiempo va a estar mal.
void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON,
INPUT); // and BUTTON is an input }
void loop(){
val = digitalRead(BUTTON); // read input value and store it // yum, fresh
if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON } else {
digitalWrite(LED, LOW);
}
Usted puede haber notado que este acercamiento no es enteramente perfecto, debido a
otro problema con los interruptores mecánicos. Los pulsadores son dispositivos muy
simples: dos pedazos de metal separados por un resorte. Cuando presiona el botón, los
dos contactos se unen y la electricidad puede fluir. Esto suena bien y simple, pero en la
vida real la conexión no es tan perfecta, especialmente cuando el botón no está
completamente presionado, y genera algunas señales espurias llamadas rebote.
Cuando el pulsador está rebotando, el Arduino ve una secuencia muy rápida de señales
de encendido y apagado. Hay muchas técnicas desarrolladas para hacer de-rebote, pero
en este pedazo simple del código he notado que es generalmente bastante para agregar
un retraso 10 - a 50 milisegundos cuando el código detecta una transición.
void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON,
INPUT); // and BUTTON is an input }
void loop(){
val = digitalRead(BUTTON); // read input value and store it // yum, fresh
if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON } else {
digitalWrite(LED, LOW);
}
}
5/ Entrada y salida
avanzadas
Lo que acabamos de aprender en el Capítulo 4
son las operaciones más elementales que
podemos hacer en Arduino: controlar la salida
digital y leer la entrada digital. Si Arduino fuera
algún tipo de lenguaje humano, éstas serían dos
letras de su alfabeto. Teniendo en cuenta que hay
sólo cinco letras en este alfabeto, se puede ver
cuánto más trabajo que tenemos que hacer antes
de que podamos escribir Arduino poesía.
Prueba de otros sensores de encendido / apagado
Ahora que ha aprendido a utilizar un pulsador, debe saber que hay muchos otros
sensores muy básicos que funcionan de acuerdo con el mismo principio:
Interruptores
Termostatos
Tiene dos contactos que se juntan cuando están cerca de un imán; Utilizado por las
alarmas antirrobo para detectar cuando se abre una ventana
Interruptores de alfombra
Pequeñas esteras que se pueden colocar debajo de una alfombra o un felpudo para
detectar la presencia de un ser humano (o gato pesado)
Interruptores de inclinación
Otro sensor que quizás quiera probar es el sensor de infrarrojos que se encuentra
en las alarmas antirrobo (también conocido como sensor infrarrojo pasivo o sensor
PIR, vea la Figura 5-2). Este pequeño dispositivo se activa cuando un ser humano (u
otro ser vivo) se mueve dentro de su proximidad. Es una forma sencilla de detectar
movimiento.
Figura 5-2.
Sensor PIR típico
Ahora debe experimentar mirando todos los dispositivos posibles que tienen dos
contactos que se cierran, como el termostato que fija la temperatura de la
habitación (use una vieja que ya no está conectada), o simplemente colocando dos
contactos uno al lado del otro y dejando caer agua sobre ellos.
Por ejemplo, usando el ejemplo final del Capítulo 4 y un sensor PIR, usted podría
hacer que su lámpara respondiera a la presencia de seres humanos, o podría usar
un interruptor de inclinación para construir uno que se apague cuando está
inclinado en un lado.
Control de luz con PWM
Con el conocimiento que usted ha ganado hasta ahora, podría construir una
lámpara interactiva que puede ser controlada y no sólo con un aburrido
interruptor de encendido / apagado, pero tal vez de una manera que es un poco
más elegante. Una de las limitaciones de los ejemplos de LED parpadeantes que
hemos utilizado hasta ahora es que sólo se puede encender y apagar la luz. Una
lámpara interactiva de fantasía necesita ser regulable. Para resolver este problema,
podemos usar un pequeño truco que hace posible muchas cosas como TV o cine:
la persistencia de la visión.
Esta técnica también funciona con dispositivos que no sean un LED. Por ejemplo,
puede cambiar la velocidad de un motor de la misma manera.
Nota: Tener tres canales es muy bueno, porque si usted compra LeDs rojo, verde y
azul, usted puede mezclar sus luces y hacer la luz de cualquier color que te gusta!
Vamos a probarlo. Construye el circuito que ves en la Figura 5-4. Tenga en cuenta
que los LED están polarizados: el pasador largo (positivo) debe ir a la derecha y el
pasador corto (negativo) a la izquierda. Además, la mayoría de los LED tienen un
lado negativo aplanado, como se muestra en la figura.
Figura 5-4.
LED conectado al pin PWM.
void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output }
void loop(){
for (i = 0; i < 255; i++) { // loop from 0 to 254 (fade in) analogWrite(LED, i); // set
the LED brightness delay(10); // Wait 10ms because analogWrite // is
instantaneous and we would
// not see any change }
Ahora usted tiene una copia de una característica de fantasía de una computadora
portátil (tal vez es un poco de un desperdicio para utilizar Arduino para algo tan
simple). Vamos a usar este conocimiento para mejorar nuestra lámpara.
Añada el circuito que usamos para leer un botón (en el Capítulo 4) a esta tabla de
pruebas. Vea si puede hacer esto sin mirar la siguiente página, porque quiero que
comience a pensar en el hecho de que cada circuito elemental que muestro aquí es
un "bloque de construcción" para hacer proyectos más grandes y más grandes. Si
necesita mirar hacia el futuro, no se preocupe; Lo más importante es que pases un
tiempo pensando en cómo podría verse.
Para crear este circuito, tendrá que combinar el circuito recién construido
(mostrado en la Figura 5-4) con el circuito de pulsador mostrado en la Figura 4-6. Si
lo desea, puede simplemente construir ambos circuitos en diferentes partes de la
placa de pruebas; Tienes un montón de espacio. Sin embargo, una de las ventajas
de la placa de pruebas (véase el apéndice A) es que hay un par de rieles que se
extienden horizontalmente a través de la parte inferior y superior. Uno está
marcado rojo (para positivo) y el otro azul o negro (para el suelo).
#define LED 9 // the pin for the LED #define BUTTON 7 // input
pin of the pushbutton
int old_val = 0; // stores the previous value of "val" int state = 0; // 0 = LED off while
1 = LED on
int brightness = 128; // Stores the brightness value unsigned long startTime = 0; // when did we
begin pressing?
void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON,
INPUT); // and BUTTON is an input }
void loop() {
val = digitalRead(BUTTON); // read input value and store it // yum,
fresh
// If the button is held for more than 500ms. if (state == 1 && (millis() -
startTime) > 500) {
if (state == 1) {
analogWrite(LED, brightness); // turn LED ON at the //
current brightness level } else {
analogWrite(LED, 0); // turn LED OFF }
}
Ahora inténtalo. Como puede ver, nuestro modelo de interacción está tomando
forma. Si presiona el botón y lo suelta inmediatamente, se enciende o apaga la
lámpara. Si mantiene pulsado el botón, el brillo cambia; Sólo deje ir cuando haya
alcanzado el brillo deseado.
Construya el circuito que viene con el Ejemplo 02 (vea "Uso de un botón pulsador
para controlar el LED" en el Capítulo 4), luego cargue el código del Ejemplo 02 en
su Arduino.
Ahora conecte el LDR en la placa de pan en lugar del botón. Usted notará que si
usted cubre el LDR con sus manos, el LED se apaga. Descubre el LDR, y la luz
continúa. Acabas de construir tu primer sensor LED impulsado por sensores. Esto
es importante porque, por primera vez en este libro, estamos utilizando un
componente electrónico que no es un simple dispositivo mecánico: es un sensor
real rico.
Entrada analógica
Como aprendió en la sección anterior, Arduino es capaz de detectar si hay un
voltaje aplicado a uno de sus pines e informarlo a través de la función
digitalRead() . Este tipo de respuesta está bien en muchas aplicaciones, pero el
sensor de luz que acabamos de usar es capaz de decirnos no sólo si hay luz, sino
también cuánta luz hay. Esta es la diferencia entre un sensor de encendido /
apagado (que nos dice si hay algo) y un sensor analógico, cuyo valor cambia
continuamente. Para leer este tipo de sensor, necesitamos un tipo de pin
diferente.
int val = 0; // variable used to store the value // coming from the
sensor void setup() {
pinMode(LED, OUTPUT); // LED is as an OUTPUT
void loop() {
Ahora, pruebe el Ejemplo 06B: pero antes de hacerlo, tendrá que modificar su
circuito. Eche un vistazo a la Figura 5-4 y engancha el LED hasta el pin 9 como se
muestra. Debido a que ya tienes algunas cosas en la tabla de pruebas, necesitarás
encontrar un punto en la placa de pruebas donde el LED, los cables y la resistencia
no se superpongan con el circuito LDR.
// Example 06B: Set the brightness of LED to
// a brightness specified by the
// value of the analogue input
int val = 0; // variable used to store the value // coming from the
sensor
void setup() {
void loop() {
Si trabaja con un termistor, tenga en cuenta que no existe una conexión directa
entre el valor que lee y la temperatura real medida. Si necesita una lectura exacta,
debe leer los números que salen del pin analógico mientras se mide con un
termómetro real. Usted podría poner estos números uno al lado del otro en una
tabla y elaborar una manera de calibrar los resultados analógicos a las
temperaturas del mundo real.
Hasta ahora, hemos utilizado un LED como dispositivo de salida, pero ¿cómo
podemos leer los valores reales que Arduino está leyendo desde el sensor? No
podemos hacer que la pizarra parpadee los valores en código Morse (bueno,
podríamos, pero hay una manera más fácil para que los humanos lean los valores).
Para ello, podemos hacer que Arduino hable con un ordenador a través de un
puerto serie, que se describe en la siguiente sección.
Comunicación serial
Usted aprendió al principio de este libro que Arduino tiene una conexión USB que
es utilizada por el IDE para cargar código en el procesador. La buena noticia es que
esta conexión también puede ser utilizada por los bocetos que escribimos en
Arduino para enviar datos de vuelta al ordenador o para recibir comandos de él.
Para este propósito, vamos a utilizar un objeto en serie (un objeto es una colección
de capacidades que se agrupan para la conveniencia de las personas que escriben
bocetos).
Este objeto contiene todo el código que necesitamos para enviar y recibir datos.
Ahora vamos a usar el último circuito que construimos con la fotorresistor y
enviamos los valores que se vuelven a leer en la computadora. Escriba este código
en un nuevo boceto (también puede descargar el código de www.makezine.com/
getstartedarduino):
// Example 07: Send to the computer the values read from
// analogue input 0
// Make sure you click on "Serial Monitor"
// after you upload
int val = 0; // variable to store the value coming // from the sensor
void setup() {
void loop() {
En la Figura 5-7, puede ver cómo usaría un MOSFET como el IRF520 para encender
y apagar un pequeño motor conectado a un ventilador. Usted también notará que
el motor toma su fuente de alimentación desde el conector de 9 V de la tarjeta
Arduino. Este es otro beneficio del MOSFET: nos permite conducir dispositivos cuya
fuente de alimentación difiere de la utilizada por Arduino. Como el MOSFET está
conectado al pin 9, también podemos usar analogWrite () para controlar la
velocidad del motor a través de PWM.
Sensores Complejos
Definimos sensores complejos como aquellos que producen un tipo de
información que requiere un poco más de un digitalRead() o una función
analogRead() para ser usada. Estos suelen ser pequeños circuitos con un pequeño
microcontrolador dentro que preprocesa la información.
Tom Igoe's Making Things Talk (O'Reilly) tiene amplia cobertura de estos sensores y
muchos otros sensores complejos.
Figura 5-7.
Un circuito de motor para Arduino
6/ Hablando con la nube
La lámpara, como se puede ver en la figura 6-1, es una esfera sencilla sentada en
una base con un gran agujero para evitar que la esfera ruede de su escritorio. Este
diseño le permite orientar la lámpara en diferentes direcciones.
Planificación
Echemos un vistazo a lo que queremos lograr y qué trozos y piezas necesitamos.
En primer lugar, necesitamos que Arduino sea capaz de conectarse a Internet.
Como la placa Arduino tiene sólo un puerto USB, no podemos conectarlo
directamente a una conexión a Internet, así que necesitamos averiguar cómo
conectar los dos. Por lo general, lo que la gente hace es ejecutar una aplicación en
una computadora que se conecte a Internet, procese los datos y envíe a Arduino un
poco de información destilada.
Arduino es una computadora sencilla con una pequeña memoria; No puede
procesar archivos grandes fácilmente, y cuando nos conectamos a un feed RSS,
obtendremos un archivo XML muy detallado que requeriría mucho más memoria
RAM. Implementaremos un proxy para simplificar el XML usando el lenguaje de
procesamiento.
Procesamiento
El procesamiento es el origen de Arduino. Nos encanta este lenguaje y lo usamos
para enseñar programación a principiantes, así como para crear código hermoso.
Procesamiento y Arduino son la combinación perfecta. Otra ventaja es que
Processing es de código abierto y se ejecuta en todas las plataformas principales
(Mac, Linux y Windows). También puede generar aplicaciones independientes que
se ejecutan en esas plataformas. Lo que es más, la comunidad de procesamiento es
animada y útil, y usted puede encontrar miles de programas de ejemplo premade.
El proxy hace el siguiente trabajo para nosotros: descarga el feed RSS de
makezine.com y extrae todas las palabras del archivo XML resultante. Luego,
pasando por todos ellos, cuenta el número de veces que "paz", "amor" y "Arduino"
aparecen en el texto. Con estos tres números, calcularemos un valor de color y lo
enviaremos a Arduino. El tablero enviará de vuelta la cantidad de luz medida por el
sensor y lo mostrará en la pantalla del ordenador.
En el lado del hardware, combinaremos el ejemplo del pulsador, el ejemplo del
sensor de luz, el control del LED PWM (multiplicado por 3!) Y la comunicación
serial.
Como Arduino es un dispositivo simple, tendremos que codificar el color de una
manera sencilla. Usaremos la forma estándar en la que los colores se representan
en HTML: # seguido de seis dígitos hexadecimales.
Los números hexadecimales son útiles, porque cada número de 8 bits se almacena
en exactamente dos caracteres; Con números decimales varía de uno a tres
caracteres. La previsibilidad también hace que el código sea más sencillo:
esperamos hasta que veamos un #, luego leemos los seis caracteres que siguen en
un buffer (una variable que se usa como área de espera temporal para los datos).
Por último, convierte cada grupo de dos caracteres en un byte que representa el
brillo de uno de los tres LED.
Codificación
Hay dos bocetos que se ejecutarán: un boceto de procesamiento y un boceto de
Arduino. Aquí está el código para el boceto de Procesamiento. Puede descargarlo
desde www.makezine.com/getstartedarduino.
// Example 08A: Arduino networked lamp
// parts of the code are inspired // by a blog post by Tod E. Kurt
(todbot.com)
"http://blog.makezine.com/index.xml";
int interval = 10; // retrieve feed every 60 seconds; int lastTime; // the last time we
fetched the content
Serial port; color c; String cs; String buffer = ""; // Accumulates characters coming from Arduino
PFont font;
lastTime = 0;
fetchData(); }
if (n <= 0) { fetchData();
lastTime = millis(); }
if (port.available() > 0) { // check if there is data waiting int inByte = port.read(); // read
one byte if (inByte != 10) { // if byte is not newline
buffer = buffer + char(inByte); // just add it to the buffer } else {
// clean the buffer for the next read cycle buffer = "";
}
void fetchData() { // we use these strings to parse the feed
String data;
String chunk;
// zero the counters love = 0; peace = 0; arduino = 0; try { URL url = new
URL(feed); // An object to represent the URL
// prepare a connection URLConnection conn =
url.openConnection(); conn.connect(); // now connect to the Website
StringTokenizer st =
new StringTokenizer(data,"\"<>,.()[] ");// break it down while (st.hasMoreTokens()) {
// each chunk of data is made lowercase chunk= st.nextToken().toLowerCase() ;
Hay dos cosas que debe hacer antes de que el boceto de procesamiento se ejecute
correctamente. En primer lugar, debe indicar a Processing que genere la fuente que
estamos utilizando para el boceto. Para ello, cree y guarde este boceto. A
continuación, con el boceto aún abierto, haga clic en el menú Herramientas de
procesamiento y, a continuación, seleccione Crear fuente. Seleccione la fuente
HelveticaNeue-Bold, elija 32 para el tamaño de fuente y, a continuación, haga clic
en Aceptar.
int val = 0; // variable to store the value coming from the sensor
byte r = 0; byte g = 0;
byte b = 0;
void loop() {
val = analogRead(SENSOR); // read the value from the sensor Serial.println(val); //
print the value to // the serial port
if (Serial.available() >0) {
// If the marker's found, next 6 characters are the colour if (inByte == '#') {
int hex2dec(byte c) { // converts one HEX character into a number if (c >= '0' && c <= '9') {
return c - '0'; } else if (c >= 'A' && c <= 'F') { return c - 'A' + 10; }
}
Montaje del Circuito
La figura 6-2 muestra cómo ensamblar el circuito. Es necesario usar resistores de
10K para todas las resistencias que se muestran en el diagrama, aunque se podría
escapar con valores más bajos para las resistencias conectadas a los LEDs.
Figura 6-2.
The “Arduino Networked Lamp” circuit
Construya el circuito como se muestra, usando un LED rojo, verde y azul. A
continuación, cargue los bocetos en Arduino y Processing, luego ejecute los
bocetos y pruébelo. Si tiene algún problema, consulte el Capítulo 7, "Solución de
problemas".
En lugar de utilizar tres LED separados, puede utilizar un solo LED RGB, que tiene
cuatro cables que salen de él. Usted lo conectará de la misma manera que los LEDs
mostrados en la Figura 6-2, con un cambio: en lugar de tres conexiones separadas
a la clavija de tierra en Arduino, tendrá un solo cable (llamado "cátodo común" ")
Va a la tierra.
Soldar los cables más largos al LED RGB y pegarlo donde la bombilla solía ser.
Conecte los cables que vienen del LED a la placa de pruebas (donde se conectó
antes de retirarla). Recuerde que sólo necesitará una conexión a tierra si está
utilizando un LED RGB de 4 conductores.
O bien encontrar una buena pieza de madera con un agujero que se puede utilizar
como un soporte para la esfera o simplemente cortar la parte superior de la caja de
cartón que viene con la lámpara en aproximadamente 5cm (o 2 ") y hacer un
agujero con un diámetro que Cunega la lámpara Refuerce el interior de la caja de
cartón usando el pegamento caliente a lo largo de los bordes interiores, que hará la
base más estable.
Coloque la esfera en el soporte y sacar el cable USB de la parte superior y
conectarlo al ordenador.
» Agregue un pequeño sensor PIR para detectar cuando alguien está alrededor y
apáguelo cuando no haya nadie para verlo.
» Crear diferentes modos para que pueda obtener control manual del color o hacer
que se desvanecen a través de muchos colores.
Comprensión
Trate de entender lo más posible cómo las partes que usted está usando el trabajo
y cómo se supone que deben contribuir al proyecto terminado. Este enfoque le
permitirá diseñar alguna forma de probar cada componente por separado.
Simplificación y segmentación
Los antiguos romanos solían decir divide et impera: dividir y gobernar. Trate de
descomponer (mentalmente) el proyecto en sus componentes utilizando la
comprensión que tiene y averigüe dónde empieza y termina la responsabilidad de
cada componente.
Exclusión y certidumbre
Mientras investiga, pruebe cada componente por separado para que pueda estar
absolutamente seguro de que cada uno funciona por sí mismo. Usted creará
gradualmente la confianza sobre qué partes del proyecto están haciendo su trabajo
y cuáles son dudosas.
Muchos de los insectos de hoy en día ya no son físicos: son virtuales e invisibles, al
menos en parte. Por lo tanto, requieren un proceso a veces largo y aburrido para
ser identificado.
Prueba de la Junta
¿Qué pasa si el primer ejemplo, "parpadea un LED", no funcionó? ¿No sería un
poco deprimente? Vamos a averiguar qué hacer.
» Asegúrese de que el equipo está encendido (sí, suena tonto, pero ha sucedido).
Si la luz verde marcada PWR se enciende, significa que la computadora está
alimentando la tarjeta. Si el LED parece muy débil, algo está mal con el poder:
pruebe con un cable USB diferente e inspeccione el puerto USB del ordenador
y el conector USB del Arduino para ver si hay algún daño. Si todo falla, pruebe
un puerto USB diferente en su computadora o un equipo diferente
completamente.
NOTA: Cuando tenga problemas con otros bocetos y necesite confirmar que el
tablero está funcionando, abra el primer ejemplo de "parpadeo de un LED" en el
IDE de Arduino y carguelo en la placa. El LED de a bordo debe parpadear en un
patrón regular.
Si ha superado todos estos pasos con éxito, puede estar seguro de que su Arduino
funciona correctamente.
Trabajar paso a paso y hacer una sola modificación a la vez es la regla número uno
para arreglar cosas. Esta regla fue martillada en mi joven cabeza por mi profesor de
la escuela y primer empleador, Maurizio Pirola. Cada vez que estoy depurando algo
y las cosas no se ven bien (y créanme, sucede mucho), su cara aparece en mi
cabeza diciendo "una modificación a la vez. . . Una modificación a la vez "y que
suele ser cuando lo arreglo todo. Esto es muy importante, porque sabrás lo que
arregló el problema (es muy fácil perder la pista de qué modificación realmente
resolvió el problema, por lo que es tan importante hacer uno a la vez).
Problemas de aislamiento
Otra regla importante es encontrar una manera confiable de reproducir un
problema. Si su circuito se comporta de manera divertida en momentos
aleatorios, intente realmente averiguar el momento exacto en que ocurre el
problema y lo que lo causa. Este proceso le permitirá pensar sobre una posible
causa. También es muy útil cuando necesitas explicar a alguien lo que está
pasando.
Describir el problema con la mayor precisión posible también es una buena manera
de encontrar una solución. Trate de encontrar a alguien para explicar el problema-
en muchos casos, una solución aparecerá en su cabeza mientras articula el
problema. Brian W. Kernighan y Rob Pike, en The Practice of Programming
(Addison-Wesley, 1999), cuentan la historia de una universidad que "guardaba un
oso de peluche cerca del mostrador de ayuda. Los estudiantes con bichos
misteriosos tenían que explicarles al oso antes de que pudieran hablar con un
consejero humano..
Busque los dispositivos serie en la lista bajo "Puertos (COM & LPT)". Busque un
dispositivo serie que no esté usando que esté numerado como COM9 o inferior.
Haga clic con el botón derecho en él y elija Propiedades en el menú. A
continuación, elija la ficha Configuración del puerto y haga clic en Avanzado.
Establezca el número de puerto COM a COM10 o superior, haga clic en Aceptar y
vuelva a hacer clic en Aceptar para cerrar el cuadro de diálogo Propiedades.
Ahora, haga lo mismo con el dispositivo USB Serial Port que representa Arduino,
con un cambio: asigne el número de puerto COM (COM9 o inferior) que acaba de
liberar.
Sus posibilidades aumentan si evita estas cosas a toda costa (estas reglas son
buenas para cualquier foro en línea, no sólo para Arduino):
» Escribiendo su mensaje en MAYÚSCULAS. Se molestan a la gente mucho y
es como caminar con "novato" tatuado en la frente (en las comunidades en
línea, escribiendo en todos los capitales se considera "gritando").
Debido a que la mayoría de los componentes tienen sus patas (conocidas por los
técnicos como "pernos") espaciadas a esa distancia estándar, las virutas con múltiples
patas encajan perfectamente. No todos los contactos en una tabla de paneles se crean
iguales, hay algunas diferencias. Las filas superior e inferior (coloreadas en rojo y azul y
marcadas con + y -) están conectadas horizontalmente y se utilizan para transportar la
alimentación a través de la placa de modo que cuando se necesita energía o tierra, se
puede proporcionar muy rápidamente con un puente Un pedazo corto de alambre
utilizado para conectar dos puntos en los circuitos). La última cosa que usted necesita
saber sobre breadboards es que en el medio, hay una abertura grande que sea tan
ancha como el tamaño de un pequeño chip. Cada línea vertical de agujeros se
interrumpe en el medio, de modo que cuando se conecta un chip, no se cortocircuitan
los pines que están en los dos lados del chip. Inteligente, ¿eh?p.
Appendix A 93
Figura A-1.
La plancha sin soldadura.
Apéndice B Resistores de
lectura y condensadores.
Con el fin de utilizar las piezas electrónicas, es necesario ser capaz de identificar, que
puede ser una tarea difícil para un principiante. La mayoría de las resistencias que se
encuentran en una tienda tienen un cuerpo cilíndrico con dos patas que sobresalen y
tienen marcas de colores extraños a su alrededor. Cuando se hicieron las primeras
resistencias comerciales, no había forma de imprimir números lo suficientemente
pequeños como para caber en su cuerpo, por lo que ingenieros inteligentes decidieron
que sólo podían representar los valores con tiras de pintura de color.
Los principiantes de hoy en día tienen que encontrar una manera de interpretar estos
signos. La "llave" es bastante simple: generalmente, hay cuatro rayas, y cada color
representa un número. Uno de los anillos es generalmente oro-coloreado; Éste
representa la precisión de esa resistencia. Para leer las rayas en orden, mantenga la
resistencia por lo que la banda de oro (o plata en algunos casos) está a la derecha.
A continuación, lea los colores y asignarlos a los números correspondientes. En la
siguiente tabla, encontrará una traducción entre los colores y sus valores numéricos.
Colour Value
Black 0
Brown 1
Red 2
Orange 3
Yellow 4
Green 5
Blue 6
Purple 7
Grey 8
White 9
Silver 10%
Gold 5%
Por ejemplo, las marcas marrones, negras, naranjas y doradas significan 1 0 3 ± 5%.
Fácil, ¿verdad? No bastante, porque hay un giro: el tercer anillo representa realmente el
número de ceros en el valor. Por lo tanto 1 0 3 es en realidad 1 0 seguido de 3 ceros, por
lo que el resultado final es 10.000 ohmios ± 5%. Los geeks de la electrónica tienden a
acortar los valores expresándolos en kilo ohmios (para miles
Apéndice B 95
De ohmios) y mega ohmios (para millones de ohmios), por lo que una resistencia de
10.000 ohm se acorta a 10k, mientras que 10.000.000 se convierte en 10M. Tenga en
cuenta que debido a que los ingenieros están aficionados a optimizar todo, en algunos
diagramas esquemáticos se pueden encontrar valores expresados como 4k7, lo que
significa 4.7 kilo ohmios, o 4700.
Los condensadores son un poco más fáciles: los condensadores en forma de barril
(condensadores electrolíticos) generalmente tienen sus valores impresos en ellos. El
valor de un condensador se mide en farads (F), pero la mayoría de los condensadores
que encuentre se medirán en micro farads (μF). Tan si usted ve un condensador
etiquetado 100 μF, es un condensador de 100 micro farad.
Por lo tanto, un condensador etiquetado 104 sería 100.000 pF o 0,1 μF. Un condensador
marcado 229 sería 2,2 pF.
Apéndice C / Referencia
rápida de Arduino.
Esta es una explicación rápida de todas las instrucciones estándar soportadas por
el lenguaje Arduino.
ESTRUCTURA
Un dibujo de Arduino se ejecuta en dos partes:
void setup()
configuran la placa antes de que comience el bucle principal del boceto. void
loop()
SÍMBOLOS ESPECIALES
Arduino incluye una serie de símbolos para delinear líneas de código, comentarios y
bloques de código.
; (punto y coma)
Cada instrucción (línea de código) se termina por un punto y coma. Esta sintaxis le
permite formatear el código libremente. Incluso podrías poner dos instrucciones en
la misma línea, siempre y cuando las separes con un punto y coma. (Sin embargo,
esto haría que el código sea más difícil de leer.)
Ejemplo: delay(100);
{} (Llaves)
Esto se utiliza para marcar bloques de código. Por ejemplo, cuando escribe código
para la función loop (), tiene que usar llaves antes y después del código.
Ejemplo:
void loop() { Serial.println("ciao");
}
Comentarios
Estas son porciones de texto ignoradas por el procesador Arduino, pero son
extremadamente útiles para recordar a usted mismo (u otros) de lo que hace un
pedazo de código.
Hay dos estilos de comentarios en Arduino:
// single-line: this text is ignored until the end of the line /* multiple-line: you can write a
whole poem in here */
CONTENIDOS
Arduino incluye un conjunto de palabras clave predefinidas con valores
especiales. HIGH y LOW se utilizan, por ejemplo, cuando se desea activar o
desactivar un pin Arduino. INPUT y OUTPUT se utilizan para establecer un pin
específico para ser y entrada o una salida
VARIABLES
Las variables se denominan áreas de la memoria del Arduino donde se pueden
almacenar datos que se pueden utilizar y manipular en el boceto. Como su nombre
indica, pueden ser cambiados tantas veces como quieras.
Debido a que Arduino es un procesador muy simple, cuando declara una variable,
debe especificar su tipo. Esto significa decirle al procesador el tamaño del valor que
desea almacenar.
boolean
Puede tener uno de dos valores: verdadero o falso.
char
Tiene un solo carácter, como A. Como cualquier computadora, Arduino lo almacena
como un número, aunque vea texto. Cuando los caracteres se utilizan para
almacenar números, pueden contener valores de -128 a 127.
byte
Contiene un número entre 0 y 255. Al igual que con los caracteres, los bytes utilizan
sólo un byte de memoria.
int
Utiliza 2 bytes de memoria para representar un número entre -32.768 y 32.767; Es
el tipo de datos más común usado en Arduino.
unsigned int
Como int, utiliza 2 bytes, pero el prefijo sin signo significa que no puede almacenar
números negativos, por lo que su rango va de 0 a 65.535.
long
Este es el doble del tamaño de un int y contiene números de -2.147.483.648 a
2.147.483.647.
unsigned long
Versión sin firmar de largo; Va de 0 a 4.294.967.295.
float
Esto es bastante grande y puede contener valores de punto flotante, una manera
elegante de decir que puede usarlo para almacenar números con un punto decimal
en ella. Se comen hasta 4 bytes de su memoria RAM precioso y las funciones que
pueden manejar que utilizan una gran cantidad de memoria de código también. Así
que usa flotadores con moderación.
double
Número de coma flotante de doble precisión, con un valor máximo de
1.7976931348623157 x 10308. Wow, eso es enorme!
string
Un conjunto de caracteres ASCII que se utilizan para almacenar información textual
(puede utilizar una cadena para enviar un mensaje a través de un puerto serie o
para mostrarlo en una pantalla LCD). Para el almacenamiento, utilizan un byte para
cada carácter en la cadena, además de un carácter nulo para decirle a Arduino que
es el final de la cadena. Los siguientes son equivalentes:
char string1[] = "Arduino"; // 7 chars + 1 null char char string2[8] = "Arduino"; //
Same as above
array
Una lista de variables a las que se puede acceder a través de un índice. Se utilizan
para construir tablas de valores que se pueden acceder fácilmente. Por ejemplo, si
desea almacenar diferentes niveles de brillo que se utilizarán al atenuar un LED,
podría crear seis variables denominadas light01, light02, etc. Mejor aún, usted
podría utilizar un arreglo simple como: int light[6] = {0, 20, 50, 75, 100};
ESTRUCTURAS DE CONTROL
Arduino incluye palabras clave para controlar el flujo lógico de su boceto.
if . . . else
Esta estructura toma decisiones en su programa. if debe ser seguido por una
pregunta especificada como una expresión entre paréntesis. Si la expresión es
verdadera, lo que sigue será ejecutado. Si es falso, se ejecutará el bloque de código
siguiente. Es posible utilizar sólo if sin proporcionar una cláusula else.
Ejemplo:
if (val == 1)
{ digitalWrite(LED,HIGH); }
for
Le permite repetir un bloque de código un número especificado de veces.
Ejemplo:
for (int i = 0; i < 10; i++)
{ Serial.print("ciao"); }
switch case
Las declaraciones if son como una bifurcación en el camino para su programa.
Switch case es como una enorme rotonda. Permite que su programa tome una
variedad de direcciones dependiendo del valor de una variable. Es muy útil
mantener su código ordenado, ya que reemplaza largas listas de declaraciones if.
Ejemplo:
switch (sensorValue) { case 23:
digitalWrite(13,HIGH); break; case
46: digitalWrite(12,HIGH); break;
default: // if nothing matches this is executed digitalWrite(12,LOW);
digitalWrite(13,LOW); }
while
Similar a if, Esto ejecuta un bloque de código mientras que una cierta condición es
verdadera.
Ejemplo:
// blink LED while sensor is below 512 sensorValue =
analogRead(1); while (sensorValue < 512)
{ digitalWrite(13,HIGH); delay(100);
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); }
do . . . while
Sólo como while, excepto que el código se ejecuta justo antes de que se evalúe la
condición. Esta estructura se utiliza cuando desea que el código dentro de su
bloque se ejecute al menos una vez antes de comprobar la condición.
Ejemplo:
do {
digitalWrite(13,HIGH); delay(100);
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); } while
(sensorValue < 512);
break
Este término le permite dejar un bucle y continuar la ejecución del código que
aparece después del bucle. También se utiliza para separar las diferentes secciones
de una declaración switch case.
Ejemplo:
// blink LED while sensor is below 512 do { // Leaves the loop
if a button is pressed if (digitalRead(7) == HIGH) break;
digitalWrite(13,HIGH); delay(100);
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); } while
(sensorValue < 512);
continue
Cuando se usa dentro de un bucle, continue le permite saltar el resto del código
dentro de él y forzar la condición para ser probado de nuevo.
Ejemplo:
return
Detiene la ejecución de una función y regresa de ella. También puede usar esto
para devolver un valor desde dentro de una función.
ARITMÉTICOS Y FÓRMULAS
Puede utilizar Arduino para realizar cálculos complejos utilizando una sintaxis
especial. + Y - funciona como lo has aprendido en la escuela, y la multiplicación se
representa con un * y la división con un /.
Hay un operador adicional llamado "módulo" (%), que devuelve el resto de una
división entera. Puede utilizar tantos niveles de paréntesis como sea necesario para
agrupar expresiones. Contrariamente a lo que usted pudo haber aprendido en la
escuela, los corchetes y los corchetes se reservan para otros propósitos (índices de
la matriz y bloques, respectivamente).
Ejemplos:
a = 2 + 2;
light = ((12 * sensorValue) - 5 ) / 2;
remainder = 3 % 2; // returns 2 because 3 / 2 has remainder 1
OPERADORES DE COMPARACIÓN
Cuando especifique condiciones o pruebas para if, while, y for declaraciones, estos
son los operadores que puedes usar:
== igual a
!= no igual a
< menos que
> mas grande que
<= menos que o igual a
>= mayor qué o igual a
OPERADORES BOOLEANOS
Estos se utilizan cuando se desea combinar varias condiciones. Por ejemplo, si
OPERADORES COMPUESTOS
Éstos son operadores especiales usados para hacer el código más conciso para
algunas operaciones muy comunes como incrementar un valor.
Por ejemplo, para incrementar el valor en 1, escribiría: value =
+= , –=, *= and /=
Esto hace más corto escribir ciertas expresiones. Las dos expresiones siguientes son
equivalentes:
a = a + 5; a += 5;
digitalWrite(pin, value)
Enciende o apaga un pin digital. Los pins deben convertirse explícitamente en una
salida usando pinMode antes de digitalWrite tendrá algún efecto.
int digitalRead(pin)
Lee el estado de un pin de entrada, devuelve HIGH si el pin detecta algún voltaje o
LOW si no hay voltaje aplicado.
Ejemplo:
val = digitalRead(7); // reads pin 7 into val
int analogRead(pin)
Lee el voltaje aplicado a un pin de entrada analógica y devuelve un número entre 0
y 1023 que representa las tensiones entre 0 y 5 V.
analogWrite(pin, value)
Cambia la frecuencia PWM en uno de los pines marcados PWM. Pin puede ser 11,
10, 9, 6, 5, 3. El valor puede ser un número entre 0 y 255 que representa la escala
entre 0 y 5 V de voltaje de salida.
Ejemplo:
time = pulsein(7,HIGH); // measures the time the next // pulse stays
high
Ejemplo:
duration = millis()-lastTime; // computes time elapsed since "lastTime"
delay(ms)
Pausa el programa por la cantidad de milisegundos especificado.
delayMicroseconds(us)
Detiene el programa por la cantidad dada de microsegundos.
Ejemplo:
delayMicroseconds(1000); // waits for 1 millisecond
FUNCIONES DE MATEMÁTICAS
Arduino incluye muchas funciones matemáticas y trigonométricas comunes:
min(x, y)
Devuelve el menor de x e y.
Ejemplo:
val = min(10,20); // val is now 10
max(x, y)
Devuelve el mayor de x e y.
Ejemplo:
val = max(10,20); // val is now 20
abs(x)
Devuelve el valor absoluto de x, que convierte los números negativos en positivos.
Si x es 5, devolverá 5, pero si x es -5, todavía retornará 5.
constrain(x, a, b)
Devuelve el valor de x, restringido entre a y b. Si x es menor que a, simplemente
devolverá a y si x es mayor que b, regresará b.
Ejemplo:
val = constrain(analogRead(0), 0, 255); // reject values bigger than 255
Ejemplo:
double sqrt(x)
Devuelve la raíz cuadrada de un número.
double sin(rad)
Devuelve el seno de un ángulo especificado en radianes.
double cos(rad)
Devuelve el coseno de un ángulo especificado en radianes.
double tan(rad)
Devuelve la tangente de un ángulo especificado en radianes.
Ejemplo:
double tangent = tan(2); // approximately -2.18503975868
FUNCIONES NUMÉRICAS DE RANDOM
Si necesita generar números aleatorios, puede usar el generador de números
pseudoaleatorios de Arduino.
randomSeed(seed)
Restablece el generador de números pseudoaleatorios de Arduino. Aunque la
distribución de los números devueltos por random() Es esencialmente aleatorio, la
secuencia es predecible. Por lo tanto, debe restablecer el generador a un valor
aleatorio. Si tiene un pin analógico no conectado, captará ruido aleatorio del
entorno (ondas de radio, rayos cósmicos, interferencias electromagnéticas de los
teléfonos celulares y luces fluorescentes, etc.).
long random(max)
long random(min, max)
Devuelve un valor entero largo pseudoaleatorio entre min y max - 1.
Si no se especifica min, el límite inferior es 0.
Ejemplo:
long randnum = random(0, 100); // a number between 0 and 99 long randnum = random(11);
// a number between 0 and 10
COMUNICACIÓN SERIAL
Como se vio en el Capítulo 5, puede comunicarse con dispositivos a través del
puerto USB mediante un protocolo de comunicación serie. Aquí están las funciones
en serie.
Serial.begin(speed)
Prepara Arduino para comenzar a enviar y recibir datos en serie. En general, usará
9600 bits por segundo (bps) con el monitor en serie IDE de Arduino, pero otras
velocidades están disponibles, generalmente no más de 115.200 bps.
Ejemplo:
Serial.begin(9600);
Serial.print(data)
Serial.print(data, encoding)
Envía algunos datos al puerto serie. La codificación es opcional; Si no se suministra,
los datos se tratan como texto plano como sea posible.
Ejemplos:
Serial.print(75); // Prints "75" Serial.print(75, DEC); // The same as above.
Serial.print(75, HEX); // "4B" (75 in hexadecimal)
Serial.print(75, OCT); // "113" (75 in octal)
Serial.print(75, BIN); // "1001011" (75 in binary)
Serial.print(75, BYTE); // "K" (the raw byte happens to
// be 75 in the ASCII set)
Serial.println(data)
Serial.println(data, encoding)
Igual que Serial.print(), Excepto que añade un retorno de carro y avance de línea (\
r \ n) como si hubiera escrito los datos y luego presionado Intro o Intro.
Ejemplos:
int Serial.available()
Devuelve cuántos bytes no leídos están disponibles en el puerto Serial para leer a
través de la función read(). Después tienes read() todo disponible,
Serial.available() devuelve 0 hasta que lleguen nuevos datos al puerto serie.
int Serial.read()
Obtiene un byte de los datos en serie entrantes.
Serial.flush()
Debido a que los datos pueden llegar a través del puerto serie más rápido de lo que
su programa puede procesar, Arduino mantiene todos los datos entrantes en un
búfer. Si necesita borrar el búfer y dejar que se llene con datos nuevos, use la
función flush().
Ejemplo:
Serial.flush();
Apéndice d / Diagramas
esquemáticos de lectura
Hasta ahora, hemos utilizado ilustraciones muy detalladas para describir cómo
ensamblar nuestros circuitos, pero como se puede imaginar, no es exactamente
una tarea rápida dibujar una de esas para cualquier experimento que quiera
documentar.
Los ingenieros, siendo gente práctica, han desarrollado una manera rápida de
capturar la esencia de un circuito para poder documentarlo y después reconstruirlo
o pasarlo a otra persona.
Esto es todo lo que necesita para comprender los esquemas básicos. Aquí está una
lista más completa de símbolos y sus significados:
ARDUINO
PIN 7
GND GND
Appendix D 111
Índice
56-62, 73 pines, placa Arduino, 20-21, 64-67
sensores, 64-68 sintetizadores, 8 analogWrite
función, 56-58, 65-67, 105 y operador, 103 Pines de
E / S analógicas Arduino, 20-21, 64-67 definidos, 1
; (Punto y coma), 46, 97 Placa Diecimila, 20, 88 pines digitales IO, 20-21 Placa
// (delimitador del comentario), 34-35, 36-37, 98 Duemilanove, 20-21 Extreme board, 88 forum, 91
-92 Pines GND, 60 hardware, 19-21 IDE, descarga, 22
- (operador de decremento), 104
IDE, descripción, 22
/ * (Delimitador de comentarios), 98
IDE, solución de problemas, 90-91 IDE, sitio web, 1
&& (y operador), 103
instalación, 22-27 Linux, 22 NG, 20-21, 88 vista
{} (Entre corchetes), 34-35, 97
general, 1-3
== (igual a), 44-45, 103
,,,,,,,,,,,,,,,,,,,,,,,,, 36 aritmética, 103 matriz variable,
= (Operador de igualdad), 44-45
100 ASCII, 99 lámpara de esfera de montaje, 84-85
> (Mayor que), 103
ATmega168, 19-21
> = (Mayor o igual que), 103
Lámpara Aton, 73
++ (operador de incremento), 104
segundo
<(Menor que), 103
Barragan, Hernando, 2 circuitos de curvatura, 10-11
<= (Menor o igual que), 103
El Betrothed, 36 bitOrder, 105 LED parpadeante, 30-
% (Módulo), 103
38, 64-67 Operadores booleanos, 103 variable, 98
! = (No igual a), 103
saltos, 49-51 soportes, rizado, 34-35 breadboard,
! (No operador), 103
43 , 60, 89-90, 93-94 estructura de control de rotura,
|| (U operador), 103 102 buffer, 76 byte variable, 99
() (Paréntesis), 36 do
LED RGB de 4 conductores, 84 C lenguaje, 22 cálculos, 103 condensadores de
UN lectura, 95-96 símbolo, 110, 111 conmutadores de
Ampère, André-Marie, 41 amperios, 41 alfombras, 53 char variable, 98 circuitos
analógicaLeer función, 64-67, 105 analógica (PWM), 58-60 LED controlado por pulsador, 42-43
analógicaLeer función, 64-67, 105 analogWrite lámpara de esfera, 83-84 símbolos, esquemas, 110-
función, 56-58, 65-67, 105 entrada, 64-67, 73 salida, 111 pruebas, 89 -90 clockPin, 105 código. Consulte
también programación de LED parpadeante, 32-38, marido
64-67 bloques, nombres, 34-35 LED controlado por Hacking circuit bending, 10-11 junk, 14 teclados, 12-
pulsador, 44-51 objetos en serie, 68-69 lámpara 13 juguetes, 15 Haque, Usman, 15 hardware,
esfera, 75-82 Arduino, 19-21 hexadecimal, 75-76 HIGH, 37, 98
Colaboración, 16 Colombo, Joe, 73 códigos de Hopper, Grace, 88 Codificación de colores HTML, 75-
colores, resistencias, 95-96 colores, codificación 76
HTML, 75-76 puertos COM, Windows, 26-27, 90-91 yo
comando, #define, 36, 46 comentarios, 35, 36 -37, I premessi sposi, 36
98 comunicación, serie, 25 - 27, 68 - 69, 73, IDE (entorno de desarrollo integrado) descarga, 22
90-91, 108-109 operadores de comparación, 103 información general, 22 solución de problemas, 90-
compilación de bocetos, 33, 46 sensores complejos, 91 sitio web, 1 si la estructura de control. Ver si
70-71 operadores compuestos, 103-104 conexiones, declaraciones si declaraciones, 44-45, 100, 103 si ...
símbolo, 110 constantes, 36 función de restricción, otra estructura de control, 100
106 información de contacto, ix continuar la Igoe, Tom, 71 IKEA lámpara, 84 iMac drivers, 23
estructura de control, 102 Estructuras de control, lámparas incandescentes, conductor, 70 incremento
100-102 función cos, 107 herrajes, 34-35, 97 operador, 104 inductor, símbolo, 110 infrarrojos, 70-
corriente, 41-42 protección de corriente, 89 71 sensores infrarrojos, 55, 56 INPUT, 36, 67, 73
re digital, 36 - 38, 73
Dante, 36 Funciones, 104-108 instalación
89-90, 88-90, 88-89, 87-90, 88-89, 68-69, 89-90, 68- Arduino, 22-27
69, data-serial, 68-69, data- 36, 46 función de Controladores de Macintosh, 23 controladores de
retardo, 37, 106 función delayMicroseconds, 106 Windows, 23-24 función analógicaRead, 105 int
delimitadores bloques de código, 34-35 función digitalRead, 104 int Función Serial.available,
Comentario, 35 109 int Serial.read, 109 int variable, 99
Diagramas, circuitos, 110-111 Diecimila placa, 20 Entorno de Desarrollo Integrado (IDE).
digital Consulte IDE (Integrated Development
42, 64, 104 digitalWrite función, 37, 104 diodo, Ambiente)
símbolo, 111 divide y impera, 87 Divina Commedia, Controladores Intel, 23
107 función doble de la función del pecado, 107 Interaction Design, 2-3 Interactive Device, 29
función doble del pecado, 107 función doble del tan, lámparas interactivas, 38 pines IO, placa Arduino, 20-
107 variable doble, 99 hacen ... mientras que 21, 64-67 problemas de aislamiento, 90
estructura de control, 101 Drenan el perno, J puente, selección de potencia, 20 puente de
transistores del MOSFET, 70 conductores, conexión, 43-44 basura, 14
Instalación, 23-24 conducción de grandes cargas, 70 K
Duemilanove bordo, 20-21 Dyson, James, 6 Kernighan, Brian W., 90 teclados, hacking, 12-13
mi L lámparas Aton, 73 de conducción, 70 interactivo,
Electricidad, 39-42 operador de igualdad, 44-45 esfera 38, 74-85
Errata, ix ejecución de bocetos, 34 energía externa, LDRs (resistencias dependientes de la luz), 30, 63,
20 Extreme board, 88 111
F FALSO, 45 falso, 98 variable flotante, 99 carpeta, LED de 4 conductores RGB, 84 parpadeo, 30-38
almacenamiento de boceto, fuente 32, generación, sensores de luz, 62-63 modulación de ancho de
80 para la estructura de control, 100 para pulso (PWM), 56-62 pulsador controlado, 42-51
instrucciones, 103 fórmulas, 103 foro, Arduino, 91-92 lámpara de esfera, 74-85 símbolos, 111 luz. Ver
106 analógica, 56-58, 65-67, 105 restricción, 106 cos, también lámparas; (LDRs), 30, 63 que juegan con, 38
107 retardo, 106 función de retardo, 37 modulación de la anchura de pulso (PWM), 56-62
retardoMicroseconds, 106 digitalRead, 42 amarillo que destella, 88 Linux, 22 cargas,
digitalWrite, 37, 104 loop, 35, 37 mapa, 107 conduciendo, función aleatoria larga de 70, 108
matemáticas, 106-107 largos Variable, función del lazo 99, 35, 37
108, 108, 108, 105, 105, 105, 105, 106, 109, 108, LOW, 37, 98
109, 108, 109 Serial.available, 109 Serial.begin, 108 Sensores y actuadores de baja tecnología, 15
Serial.flush, 109 Serial.print, 108-109 Serial.println, m
109 Serial.read, 109 configuración, 35, 36 shiftOut, 70 función de mapa, 107 funciones
105 sin, 107 tan, 107 tiempo, 105-106 tipo de vacío, matemáticas, 106-107 Máx, 8 función máxima,
36-37 106 transistor de efecto de campo de metal-
GRAMO óxido-semiconductor, función de 70
Puertas, transistores MOSFET, 70 milisegundos, 105 min función, 106 módulo,
Ghazala, Reed, 10 clavijas GND, 60 clavijas de tierra, 103
60 Interruptor pulsador momentáneo, 43
Moog, Robert, 8 transistores MOSFET, 70 Función aleatoria, 108 funciones de números
aceleradores de detección de movimiento, 70- aleatorios, 108 función de función aleatoria,
71 interruptores de alfombra, 53 interruptores 108 funciones serie, 108-109 objetos serie, 68-
magnéticos, 53 sensores infrarrojos pasivos, 55, 69, 73 Función de serie, 109
56 reed relés, 53 interruptores de inclinación, Función Serial.begin, 108
54, 56 motores, conducción, 70 comentarios de Función Serial.flush, 109 Función Serial.print,
varias líneas , 98 108-109
norte Función Serial.println, 109 función Serial.read,
Nombres, bloques de código, 34-35 NG bordo, 109 función de configuración, 35, 36 función
20-21, 88 no operador, 103 shiftOut, 105 función sin, 107 caracteres
Números aritmética y fórmulas, 103 funciones especiales, 97-98 esfera lámpara, estado 75-82,
matemáticas, 106-107 funciones aleatorias, estructura 47-48, función 97 tan, 107 76, 46-48
108 funciones trigonométricas, 106-107 variables, 45-46, 98-100 visual, 8 tipo de
variables, 98-100 función void, 36-37 prototipos, 6 proxy, 75
O generador de números pseudoaleatorios, 108
Objetos, serial, 68-69, 73 Ohm, Georg, 41 modulación de ancho de pulso (PWM), 56- 62
ohmios, 41 Ohm's Law, 41-42 pulsos, 105 Datos puros, 8 LEDs controlados
Olivetti, 14 sensores on / off, 53-56 ayuda en por pulsador, 42-51, 111
línea, 91-92 operadores booleanos, 103 PWM (modulación de ancho de pulso), 56-62
comparación, 103 compuestos, 103-104 PWR_SEL, 20
Prototipación oportunista, 6 u operador, 103 R
SALIDA, 36-37, 98 salida analógica, 56-62, 73 Reas, Casey, 2 datos de recepción, objetos en
digital, 36-38, 73 funciones, 104-108 serie, 68-69, 73 relés de lámina, 53 registros
pag (LDR), 30, 63 lectura, 95-96 símbolo, 111
30, 56, 85, 8, 9 Pentland, Alex, 13 persistencia variable, 41 estructura de control de retorno ,
de la visión, 56-62 filosofía, Arduino, 5-16 102 LED RGB, 4 conductores, 84
fotoresistores, 30. Ver también LDRs (light- Fuente RSS, control de la lámpara, 75
Resistencias dependientes) S
Computación física, definida, 3 Diagramas, símbolos, 110-111 selección de puertos,
Diseño de Interacción Física, 3 Pike, Rob, 25-27 punto y coma, 46, 97 envío de datos, objetos
función 90 pinMode, 36, 104 pines, placa en serie, 68-69, 73 sensores acelerómetros, 70-71
analógica IO Arduino, 20-21 IO digital, 20-21 analógico, 64-68 parpadeo LED, 64-67
tierra, 60 transistores MOSFET, 70 sensores PIR conmutadores de alfombra, 53 Circuitos infrarrojos,
(sensores infrarrojos pasivos), 55, 56 , 85 Pirola, 55, 56, 85 infrarrojos, 70-71 teclado cortar, 13 luz,
Maurizio, 89 62-63 interruptores magnéticos, 53 encendido /
80, 90-91 potenciómetro, símbolo, función de apagado, 53-56 resumen, 30 pulsador, 42 caña
111 pow, 107 fuentes de alimentación, 20, 70, Relés, 53 termistores, 68 termostatos, 53, 56
88, 89 La práctica de la programación, 90 El interruptores de inclinación, 54, 56, 85
procesamiento, 1, 22, 69, 75-82 función de guardabarros ultrasónicos, serie 70-71
programación de abs, 106 analógicaLeer Comunicación, 25 - 27, 68 - 69, 73, 90 - 91, 108 -
función, 64-67, 105 analogWrite función, 56- 109 objetos, 68 - 69, 73
58, 65-67, 105 argumentos, 36 parpadeo LED, Puertos, 25-27, 90-91 Función Serial.available, 109
30-38, 36-38 operadores booleanos, 103 Función Serial.begin, 108
103, 103, 35, 36-37 operadores de Función Serial.flush, 109
comparación, 103-104 constantes, 36, 98 Función Serial.print, 108-109
función de restricción, 106 estructuras de 105 función de desplazamiento, 105 función de
control, 100-102 función de cos, 107 entre desplazamiento, 105 cortocircuitos, 89 función sin,
corchetes, 34-35 , 97 ciclo, 22 tipos de datos, 107 comentarios de una sola línea, 98 bocetos
98-100 #define, 36, 46 función de retardo, 37, función abs, 106 función de lectura analógica, 67,
106 función delayMicroseconds, 106 función 105 función de analogWrite, 56-58, 65-67, 105
digitalRead, 42, 64, 104 función digitalWrite, argumentos, 36 LED parpadeante, 30-38, 64-67
37, 104 funciones, 34-35, 104-108 si 106 parpadear explicación del código del LED, 36-38
función de los milis, función de 105 minutos, operadores booleanos, 103 saltos, 49-51 cálculos,
función de 106 pinMode, 36, función de 104 103 comentarios, 35, 36-37 operadores de
pow, 107 modulación de la anchura de pulso comparación, 103 compilación, 33, 46 operadores
(PWM), 56-62 función de pulsación, 105 LED compuestos, 103-104 constantes, 36, 98 función de
controlado por pulsador, 42-51 restricción, 106 estructuras de control, 100-102
RAM, 46 función de cos, 107 corchetes, 34-35, 97 tipos de
datos, 98 -100 #define, 36, 46 función de retardo, 14 SV1, estructura del control del caso del
37, 106 delayMicroseconds función, 106 interruptor 88, 100-101
digitalRead función, 42, 64, 104 Conmutadores rebote, 49-51 alfombra, 53
Función de memoria, Función de memoria, magnéticos, 53 transistores MOSFET, 70 on / off, 53
Función de memoria, Función de memoria digital, pulsadores, 43 reed relés, 53 tilt, 54, 56, 85
Función de memoria digital, Función 105 min, 106 símbolos programación (Ver caracteres especiales)
sensores infrarrojos pasivos, 56-62 función esquemas 110-111 sintetizadores analógicos , 8
pinMode, 36, función 104 pow, 107 modulación de T
anchura de pulso (PWM), 56-62 función pulseln, Interruptor de pulsador táctil, 43 función de
105 LED pulsador controlado, 42-51 bronceado, 107 programa de prueba, Arduino, 88
RAM, 46 termistores, 68, 111 termostatos, 53, 56
Función aleatoria, 108 funciones de números interruptores de inclinación, 54, 56, 85 funciones
aleatorios, 108 función de función aleatoria, 108 de tiempo, 105-106 retoques, 7 juguetes, hacking,
funciones serie, 108-109 objetos serie, 68-69, 73 15 transistores MOSFET , 70 funciones
Función de serie, 109 trigonométricas, 106-107 solución de problemas,
Función Serial.begin, 108 Función Serial.flush, 109 88-89 circuitos integrados, 89-90 IDE (entorno de
Función Serial.print, 108-109 desarrollo integrado), 90-91 ayuda en línea, 91-92
Función Serial.println, 109 función Serial.read, 109 vista general, 87-88 problemas de reproducción, 90
función de configuración, 35, 36 función shiftOut, Windows, 91
105 función sin, 107 caracteres especiales, 97-98 Trucha, grande, 92
esfera lámpara, estado 75-82, estructura 47-48, VERDADERO, 45
función 97 tan, 107 Funciones de tiempo, 105-106 verdadero,98
carga, 33 val, 46-48
Variables, 45-46, 98-100 tipo de función vacía, 36- u
37 Guardabosques ultrasónicos, 70-71 UNICODE, 99
Somlai-Fischer, Adam, 15 sonidos, guardabosques Variable sin signo int, 99 sin signo de función milis
ultrasónicos, 70-71 Pines fuente, transistores largo, 105
MOSFET, 70 caracteres especiales; (Punto y coma), Cargando boceto, 33
46, 97 USB
// (delimitador del comentario), 34-35, 36-37, 98 Puertos, Windows, 26-27, 90-91 fuentes de
- (operador de decremento), 104 alimentación, 20 objetos en serie, pruebas 68-69, 88
/ * (Delimitador de comentarios), 98 V
&& (y operador), 103 Controladores de Windows, 24 identificación del
{} (Entre corchetes), 34-35, 97 puerto, 26-27, 90-91 solución de problemas, 90-91
== (igual a), 44-45, 103 programación visual, 8 función de vacío tipo, 36-37
> (Mayor que), 103 Volta, Alessandro, 41 tensión, 41-42 voltios, 41
> = (Mayor o igual que), 103 VVVV, 8
= (Si declaración), 44-45 W
++ (operador de incremento), 104 Agua analogía, electricidad, 39-42 mientras que la
<(Menor que), 103 estructura de control, 101 mientras que las
% (Módulo), 103 declaraciones, 103 Wiki, Patio, 16, 91
! = (No igual a), 103 Ventanas
! (No operador), 103 Drivers, instalación, 23-24 identificación de puerto,
|| (U operador), 103 () (paréntesis), 36 símbolos 25, 26-27 solución de problemas, 90-91 cable,
aritméticos, 103 ASCII, 99 puente, 43-44
UNICODE, 99 x
Lámpara de la esfera, estado 74-85, secuencia 47- XML, proxy, 75 XP, controladores de Windows, 23-24
48, estructura 99-100, bosquejo, 97, fuentes 100- identificación de puerto, 26-27, 90-91 solución de
102, edificio del circuito, excedente 42-44, puente problemas, 90-91
Y
Luz intermitente amarilla, 88