Cómo empezar
Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: translation-feedback@oreilly.com
1.0 Introducción
El entorno Arduino se ha diseñado para que sea fácil de usar para los principiantes que no tienen experiencia en software ni en electrónica. Con Arduino, puedes construir objetos que respondan y/o controlen la luz, el sonido, el tacto y el movimiento. Arduino se ha utilizado para crear una asombrosa variedad de cosas, como instrumentos musicales, robots, esculturas de luz, juegos, muebles interactivos e incluso ropa interactiva.
Arduino se utiliza en muchos programas educativos de todo el mundo, sobre todo por diseñadores y artistas que quieren crear prototipos fácilmente pero no necesitan un conocimiento profundo de los detalles técnicos que hay detrás de sus creaciones. Como está diseñado para que lo utilicen personas sin conocimientos técnicos, el software incluye abundante código de ejemplo para demostrar cómo utilizar las diversas funciones de la placa Arduino.
Aunque es fácil de usar, el hardware subyacente de Arduino funciona al mismo nivel de sofisticación que emplean los ingenieros para construir dispositivos integrados. Las personas que ya trabajan con microcontroladores también se sienten atraídas por Arduino por su capacidad de desarrollo ágil y su facilidad para poner en práctica ideas rápidamente.
Arduino es más conocido por su hardware, pero también necesitas software para programar ese hardware. Tanto el hardware como el software se llaman "Arduino". El hardware (Arduino y placas compatibles con Arduino) es barato de comprar, o puedes construir el tuyo propio (los diseños del hardware son de código abierto). El software es gratuito, de código abierto y multiplataforma. La combinación te permite crear proyectos que perciben y controlan el mundo físico.
Además, existe una comunidad Arduino activa y solidaria accesible en todo el mundo a través de los foros Arduino, los tutoriales y el centro de proyectos. Estos sitios ofrecen recursos de aprendizaje, ejemplos de desarrollo de proyectos y soluciones a problemas que pueden servirte de inspiración y ayuda en la realización de tus propios proyectos.
Software Arduino y bocetos
Los programas de software, llamados bocetos, se crean en un ordenador utilizando el entorno de desarrollo integrado (IDE) de Arduino. El IDE te permite escribir y editar código y convertir este código en instrucciones que el hardware Arduino entienda. El IDE también transfiere esas instrucciones, en forma de código compilado, a la placa Arduino (un proceso llamado carga).
Consejo
Puede que estés acostumbrado a referirte al código fuente del software como "programa" o simplemente "código". En la comunidad Arduino, el código fuente que contiene instrucciones informáticas para controlar la funcionalidad de Arduino se denomina "boceto". La palabra boceto se utilizará a lo largo de este libro para referirse al código del programa Arduino.
Las recetas de este capítulo te ayudarán a empezar, explicándote cómo configurar el entorno de desarrollo y cómo compilar y ejecutar un sketch de ejemplo.
El sketch Blink, que viene preinstalado en la mayoría de las placas Arduino y compatibles, se utiliza como ejemplo para las recetas de este capítulo, aunque la última receta del capítulo va más allá al añadir sonido y recoger entradas a través de algún hardware adicional, no sólo parpadeando la luz incorporada en la placa. El capítulo 2 trata de cómo estructurar un boceto para Arduino y proporciona una introducción a la programación.
Nota
Si ya conoces los conceptos básicos de Arduino, siéntete libre de pasar a capítulos posteriores. Si es la primera vez que utilizas Arduino, la paciencia en estas primeras recetas te compensará con resultados más fluidos más adelante.
Hardware Arduino
La placa Arduino es donde se ejecuta el código que escribas. La placa sólo puede controlar y responder a la electricidad, por lo que le acoplarás componentes específicos que le permitan interactuar con el mundo real. Estos componentes pueden ser sensores, que convierten algún aspecto del mundo físico en electricidad para que la placa pueda percibirlo, o actuadores, que obtienen electricidad de la placa y la convierten en algo que cambia el mundo. Ejemplos de sensores son los interruptores, los acelerómetros y los sensores de distancia ultrasónicos. Los actuadores son cosas como luces y LED, altavoces, motores y pantallas.
Hay una gran variedad de placas oficiales que puedes utilizar con el software Arduino y una amplia gama de placas compatibles con Arduino producidas por empresas y miembros individuales de la comunidad. Además de todas las placas del mercado, incluso encontrarás controladores compatibles con Arduino en el interior de todo tipo de productos, desde impresoras 3D hasta robots. Algunas de estas placas y productos compatibles con Arduino también son compatibles con otros entornos de programación, como MicroPython o CircuitPython.
Las placas más populares contienen un conector USB que se utiliza para proporcionar alimentación y conectividad para cargar tu software en la placa. La Figura 1-1 muestra una placa básica con la que empieza la mayoría de la gente, el Arduino Uno. Está alimentada por un procesador de 8 bits, el ATmega328P, que tiene 2 kilobytes de SRAM (memoria estática de acceso aleatorio, utilizada para almacenar variables de programa), 32 kilobytes de memoria flash para almacenar tus bocetos, y funciona a 16 MHz. Un segundo chip se encarga de la conectividad USB.
Nota
A pesar de llevar la palabra "estática" en su nombre, la RAM estática es una forma de memoria volátil. Esto contrasta con la RAM dinámica (DRAM), que necesita ser refrescada ocasionalmente para mantener una carga eléctrica. La SRAM mantiene su estado mientras se mantiene la alimentación sin necesidad de circuitos adicionales para refrescarla.
La placa Arduino Leonardo utiliza el mismo factor de forma (la disposición de la placa y sus patillas de conexión) que la Uno, pero utiliza un procesador diferente, el ATmega32U4, que ejecuta tus bocetos y también se encarga de la conectividad USB. Es ligeramente más barata que la Uno, y también ofrece algunas funciones interesantes, como la posibilidad de emular varios dispositivos USB, como ratones y teclados. Las placas Teensy y Teensy++ compatibles con Arduino de PJRC(http://www.pjrc.com/teensy) también son capaces de emular dispositivos USB.
Otra placa con una distribución de patillas similar y un procesador aún más rápido es el Arduino Zero. A diferencia del Arduino Uno y el Leonardo, no tolera tensiones en las patillas de entrada superiores a 3,3 voltios. El Arduino Zero tiene un procesador de 32 bits que funciona a 48 MHz y dispone de 32 kilobytes de RAM y 256 kilobytes de almacenamiento flash. El Metro M0 Express de Adafruit y la RedBoard Turbo de SparkFun tienen el mismo factor de forma que el Arduino Zero y también ofrecen compatibilidad con múltiples entornos, como el IDE de Arduino y CircuitPython.
Si quieres una placa para aprender que ejecute la mayoría de los sketches de este libro, la Uno es una gran elección. Si quieres más rendimiento que la Uno, pero quieres seguir utilizando el factor de forma Uno, entonces considera la Zero, o una placa similar como la Metro M0 Express o la RedBoard Turbo. Las series de placas MKR y Nano 33 también ofrecen un rendimiento excelente, pero en un factor de forma más pequeño que la Uno.
Precaución con algunas placas de 3,3 voltios
Muchas de las placas más nuevas funcionan con 3,3 voltios en lugar de los 5 voltios que utilizan las placas más antiguas, como la Uno. Algunas de estas placas pueden dañarse permanentemente si una patilla de entrada o salida recibe 5 voltios, incluso durante una fracción de segundo, así que comprueba la documentación de tu placa para ver si es tolerante a 5 voltios antes de cablear cosas cuando exista el riesgo de que los niveles de las patillas sean superiores a 3,3 voltios. La mayoría de las placas de 3,3 voltios se alimentan de una fuente de alimentación de 5 voltios (por ejemplo, a través del puerto USB), pero un regulador de voltaje la convierte a 3,3 voltios antes de que llegue a la electrónica de 3,3 voltios de la placa. Esto significa que no es raro ver una patilla de alimentación de 5 voltios en una placa cuyas patillas de entrada y salida no son tolerantes a 5 voltios.
Las placas Arduino tienen otros formatos,, lo que significa que las patillas de estas placas tienen una disposición diferente y no son compatibles con los escudos diseñados para Uno. La MKR1010 es una placa Arduino que utiliza un factor de forma mucho más pequeño. Sus patillas están diseñadas para E/S de 3,3 V ( no es tolerante a 5 V) y, al igual que la Zero, utiliza un chip ARM. Sin embargo, la MKR1010 también incluye WiFi y un circuito para funcionar y recargar una batería LIPO. Aunque la familia de placas MKR no es compatible con los escudos diseñados para el Uno, Arduino ofrece una selección de placas complementarias para el factor de forma MKR denominadas portadoras.
Puedes conseguir placas tan pequeñas como un sello de correos, como la Adafruit Trinket M0; placas más grandes que tienen más opciones de conexión y procesadores más potentes, como la Arduino Mega y la Arduino Due; y placas adaptadas a aplicaciones específicas, como la Arduino LilyPad para aplicaciones vestibles, la Arduino Nano 33 IoT para proyectos inalámbricos, y la Arduino Nano Every para aplicaciones integradas (proyectos autónomos que suelen funcionar con pilas).
También hay disponibles otras placas de terceros compatibles con Arduino, como las siguientes:
- Tablero Bare Bones (BBB)
- Las placas de bajo coste Bare Bones Boards están disponibles con o sin capacidad USB en Modern Device, y en Educato en una versión compatible con shield.
- Industrias Adafruit
- Adafruit tiene una amplia colección de placas y accesorios (módulos y componentes) Arduino y compatibles con Arduino.
- SparkFun
- SparkFun tiene montones de Arduino y accesorios compatibles con Arduino.
- Estudio Seeed
- Seeed Studio vende en placas Arduino y compatibles con Arduino, así como muchos accesorios. También ofrece un sistema de expansión flexible para Arduino y otras placas integradas llamado Grove, que utiliza un sistema de conectores modulares para sensores y actuadores.
- Teensy y Teensy++
- Estas diminutas placas de, pero extremadamente versátiles, están disponibles en PJRC.
Wikipedia tiene una lista exhaustiva de placas compatibles con Arduino. También puedes encontrar un resumen de las placas Arduino en el sitio web de Arduino.
1.1 Instalar el Entorno de Desarrollo Integrado (IDE)
Solución
Descarga el software Arduino para Windows, MacOS o Linux. Aquí tienes notas sobre la instalación del software en estas plataformas:
- Windows
-
Si utilizas Windows 10, puedes utilizar la Tienda Microsoft para instalar Arduino sin necesidad de privilegios de administrador. Pero para versiones anteriores de Windows necesitarás privilegios de administrador para hacer doble clic y ejecutar el instalador de Windows cuando se descargue. Alternativamente, puedes descargar el archivo ZIP de Windows, y descomprimirlo en cualquier directorio conveniente al que tengas acceso de escritura.
Al descomprimir el archivo se creará una carpeta llamada Arduino-<nn> (donde <nn> es el número de versión de la versión de Arduino que has descargado). El directorio contiene el archivo ejecutable (llamado Arduino.exe), junto con otros archivos y carpetas.
Nota
La primera vez que ejecutes Arduino en Windows, es posible que aparezca un cuadro de diálogo que dice "El Firewall de Windows Defender ha bloqueado algunas funciones de esta aplicación", especificando
javaw.exe
como origen de la advertencia. El IDE de Arduino es una aplicación basada en Java,, razón por la cual la advertencia procede del programa Java en lugar de Arduino.exe. Esto lo utilizan las placas que admiten la posibilidad de cargar bocetos a través de una red local. Si piensas utilizar este tipo de placa, debes utilizar este cuadro de diálogo para permitir el acceso de javaw.exe a la red.Cuando conectes la placa, asociará automáticamente el controlador instalado con la placa (esto puede tardar un poco). Si este proceso falla, o has instalado Arduino utilizando el archivo ZIP, ve a la página de la Guía de Arduino, haz clic en el enlace correspondiente a tu placa de la lista que hay allí, y sigue las instrucciones.
Si estás utilizando una placa anterior (cualquier placa que utilice controladores FTDI) y estás conectado a Internet, puedes dejar que Windows busque los controladores y se instalarán automáticamente. Si no tienes acceso a Internet, o utilizas Windows XP, deberás especificar la ubicación de los controladores. Utiliza el selector de archivos para navegar hasta el directorio Drivers USB drivers\FTDI, situado en el directorio donde descomprimiste los archivos de Arduino. Cuando este controlador se haya instalado, volverá a aparecer el Asistente para nuevo hardware encontrado, diciendo que se ha encontrado un nuevo puerto serie. Vuelve a seguir el mismo proceso.
Consejo
Puede que tengas que seguir la secuencia de pasos para instalar los controladores dos veces para asegurarte de que el software puede comunicarse con la placa.
- macOS
-
La descarga de Arduino para el Mac es un archivo ZIP. Si el archivo ZIP no se extrae automáticamente después de descargarlo, localiza la descarga y haz doble clic en ella para extraer la aplicación. Mueve la aplicación a un lugar conveniente: la carpeta Aplicaciones es un buen sitio. Haz doble clic en la aplicación. Aparecerá la pantalla de inicio de , seguida de la ventana principal del programa.
Las placas Arduino actuales, como la Uno, pueden utilizarse sin controladores adicionales. Cuando conectes la placa por primera vez, puede aparecer una notificación diciendo que se ha encontrado un nuevo puerto de red; puedes descartarla. Si utilizas placas anteriores que necesitan controladores FTDI, puedes obtenerlos de FTDI.
- Linux
-
Cada vez hay más versiones de Linux disponibles en el gestor de paquetes de tu distribución, pero estas versiones no suelen ser las más actuales, por lo que es mejor descargar la versión de http://arduino.cc/download. Está disponible para 32 o 64 bits, y ofrece una versión ARM que puede utilizarse en la Raspberry Pi y otras placas ARM de Linux. La mayoría de las distribuciones utilizan un controlador estándar que ya está instalado, y normalmente también tienen soporte FTDI. Consulta esta página de Arduino Linux para obtener instrucciones sobre la instalación de Arduino en Linux. Tendrás que seguir esas instrucciones para ejecutar el script de instalación, y puede que necesites hacerlo para permitir que tu cuenta de usuario acceda al puerto serie.
Para las placas compatibles con Arduino que no haya fabricado Arduino, puede que tengas que instalar los archivos de soporte utilizando el Gestor de placas (consulta la Receta 1.7). También debes consultar la documentación específica de la placa para conocer los pasos adicionales necesarios.
Cuando hayas instalado Arduino, haz doble clic en su icono y aparecerá la pantalla de inicio (véase la Figura 1-2).
A la pantalla inicial de bienvenida le sigue la ventana principal del programa (ver Figura 1-3). Ten paciencia, ya que el software puede tardar un poco en cargarse. Puedes encontrar el icono de Arduino en el menú Inicio (Windows), en la carpeta Aplicaciones (macOS), o posiblemente en el escritorio. En Linux, puede que tengas que ejecutar el ejecutable de Arduino desde el intérprete de comandos Terminal.
Debate
Si el software no se inicia, consulta la sección de resolución de problemas del sitio web de Arduino para que te ayuden a solucionar los problemas de instalación.
Ver también
Hay guías en línea para iniciarse en Arduino para Windows, para macOS y para Linux.
El IDE Arduino Pro es un entorno de desarrollo para Arduino orientado a las necesidades de los usuarios profesionales. En el momento de escribir esto, se encontraba en un estado inicial. Consulta el repositorio GitHub de Arduino Pro IDE.
El Arduino CLI es una herramienta de línea de comandos para compilar y cargar bocetos. También puedes utilizarla en lugar del Gestor de Bibliotecas y Placas. Consulta el repositorio GitHub de Arduino CLI.
Existe un entorno de edición online llamado Arduino Create. Para utilizarlo tendrás que crear una cuenta y descargar un plug-in que permite al sitio web comunicarse con la placa para cargar código. Dispone de almacenamiento en la nube donde se guardan tus bocetos y ofrece facilidades para compartir código. En el momento de escribir este libro, Arduino Create era un servicio bastante nuevo y aún en evolución. Si quieres tener la posibilidad de crear bocetos de Arduino sin tener que instalar un entorno de desarrollo en tu ordenador, echa un vistazo a Arduino Create.
Si utilizas un Chromebook, la Chrome App de Arduino Create requiere una suscripción mensual de 1 US$. Tiene una versión de prueba limitada en el tiempo para que puedas probarla. Existe otra alternativa para compilar y cargar código Arduino desde un Chromebook: Codebender es un IDE basado en web como Arduino Create, pero también es compatible con una serie de placas de terceros compatibles con Arduino. También hay planes de precios disponibles para aulas y escuelas. Consulta esta página de Codebender.
1.2 Configurar la placa Arduino
Solución
Conecta la placa a un puerto USB de tu ordenador y comprueba que el indicador LED de alimentación de la placa se ilumina. La mayoría de las placas Arduino tienen un indicador LED de alimentación que permanece encendido siempre que la placa está alimentada.
El LED de la placa (etiquetado en la Figura 1-4) debe encenderse y apagarse intermitentemente cuando se enciende la placa (la mayoría de las placas vienen de fábrica con el software precargado para hacer parpadear el LED como simple comprobación de que la placa funciona).
Nota
Las placas actuales del factor de forma Arduino Uno tienen algunos pines que no estaban presentes en placas anteriores, y puede que encuentres algunos escudos Arduino antiguos que no tengan estos pines. Afortunadamente, esto no suele afectar al uso de los escudos antiguos; la mayoría seguirán funcionando con las nuevas placas, igual que lo hacían con las placas anteriores (pero tu kilometraje puede variar).
Las nuevas conexiones proporcionan una patilla (IOREF) para que los escudos detecten la tensión de referencia analógica (de modo que los valores de entrada analógica puedan correlacionarse con la tensión de alimentación), y patillas SCL y SDA para permitir una ubicación coherente de las patillas para los dispositivos I2C. La ubicación de las patillas I2C había variado en algunas placas anteriores, como la Mega, debido a las diferentes configuraciones de los chips, y en algunos casos algunos escudos requerían soluciones alternativas, como añadir cables de puente para conectar las patillas I2C del escudo a las del Mega. Los escudos diseñados para la nueva disposición deberían funcionar en cualquier placa con las nuevas ubicaciones de las patillas. Un pin adicional (junto al pin IOREF) no se utiliza por el momento, pero permite implementar nuevas funciones en el futuro sin necesidad de volver a cambiar la disposición de los pines.
Debate
Si el LED de encendido no se ilumina cuando la placa está conectada a tu ordenador, es probable que la placa no esté recibiendo alimentación (prueba con una toma USB o un cable diferentes).
El LED parpadeante está siendo controlado por el código que se ejecuta en la placa (las nuevas placas vienen precargadas con el sketch de ejemplo Blink). Si el LED de la placa parpadea, el sketch se está ejecutando correctamente, lo que significa que el chip de la placa está funcionando. Si el LED de alimentación está encendido pero el LED de la placa (normalmente etiquetado como L) no parpadea, puede ser que el código de fábrica no esté en el chip; sigue las instrucciones de la Receta 1.3 para cargar el sketch Blink en la placa y verificar que ésta funciona. Si no utilizas una placa estándar, puede que no tenga un LED incorporado, así que consulta la documentación para conocer los detalles de tu placa.
Las placas Leonardo y Zero-class (Arduino Zero, Adafruit Metro M0, SparkFun RedBoard Turbo) tienen el mismo tamaño que la Uno (sus cabezales están en la misma posición, lo que permite conectar escudos). Son significativamente diferentes en otros aspectos. La Leonardo tiene un chip de 8 bits como la Uno, pero como no tiene un chip independiente para gestionar las comunicaciones USB, la Leonardo sólo acepta la carga de programas inmediatamente después de reiniciar la placa. Verás que el LED de la tarjeta Leonardo parpadea suavemente mientras espera una carga. El Leonardo es tolerante a 5V. La Zero tiene un chip ARM de 32 bits, con más memoria para almacenar tu programa y ejecutarlo. También hay un pin que proporciona un convertidor digital-analógico (DAC), lo que significa que puedes obtener de él un voltaje analógico variable. Esto se puede utilizar para generar señales de audio con mucha más calidad que una Uno. La Zero no es tolerante a 5 V, como tampoco lo son las placas similares de Adafruit (Metro M0 Express) o SparkFun (RedBoard Turbo).
La MKR1010 utiliza el mismo chip que la Zero (y al igual que ésta, no es tolerante a 5V), pero en un formato más pequeño. También incluye WiFi, por lo que es capaz de conectarse a Internet a través de una red WiFi. El factor de forma MKR no admite escudos diseñados para la disposición de patillas de Uno.
Todas las placas de 32 bits tienen más pines que admiten interrupciones que la mayoría de las placas de 8 bits, lo que resulta útil para aplicaciones que deben detectar rápidamente cambios de señal (ver Receta 18.2). La única excepción de 8 bits es el Arduino Uno WiFi Rev2, que admite interrupciones en cualquiera de sus pines digitales.
Ver también
Hay guías en línea para empezar con Arduino disponibles en para Windows, para macOS y para Linux. Consulta la Guía Arduino para obtener instrucciones específicas para cada placa .
Puedes encontrar una guía de solución de problemas en el sitio web de Arduino.
1.3 Utilizar el Entorno de Desarrollo Integrado para preparar un boceto de Arduino
Solución
El código fuente de Arduino se llama boceto. El proceso que toma un boceto y lo convierte en una forma que funcionará en la placa se llama compilación. Utiliza el IDE de Arduino para crear, abrir y modificar bocetos que definan lo que hará la placa. Puedes utilizar los botones de la parte superior del IDE para realizar estas acciones (mostrados en la Figura 1-6), o puedes utilizar los menús o los atajos de teclado (visibles en la Figura 1-5).
El área del Editor de Bocetos es donde puedes ver y editar el código de un boceto. Admite atajos comunes de edición de texto como como Ctrl-F (⌘+F en Mac) para buscar, Ctrl-Z (⌘+Z en Mac) para deshacer, Ctrl-C (⌘+C en Mac) para copiar el texto resaltado y Ctrl-V (⌘+V en Mac) para pegar el texto resaltado.
La Figura 1-5 muestra cómo cargar el boceto Blink (el boceto que viene precargado en una placa Arduino nueva).
Después de iniciar el IDE, ve al menú Archivo→Ejemplosy selecciona 01. Conceptos básicos→Blink.Básico→Parpadeo, como se muestra en la Figura 1-5. El código para hacer parpadear el LED incorporado aparecerá en la ventana del Editor de bocetos (consulta la Figura 1-6).
Antes de que puedas enviar el código a la placa, es necesario convertirlo en instrucciones que puedan ser leídas y ejecutadas por el chip controlador Arduino; a esto se le llama compilar. Para ello, haz clic en el botón verificar/compilar (el botón superior izquierdo con una marca de verificación dentro), o selecciona Sketch→Verificar/Compilar (Ctrl-R; ⌘+R en Mac).
Deberías ver un mensaje que diga "Compilando esquema..." y una barra de progreso en el área de mensajes situada debajo de la ventana de edición de texto. Al cabo de uno o dos segundos, aparecerá un mensaje que dice "Compilación finalizada". El área negra de la consola contendrá el siguiente mensaje adicional:
Sketch
uses
930
bytes
(
2
%
)
of
program
storage
space
.
Maximum
is
32256
bytes
.
Global
variables
use
9
bytes
(
0
%
)
of
dynamic
memory
,
leaving
2039
bytes
for
local
variables
.
Maximum
is
2048
bytes
.
El mensaje exacto puede variar en función de tu placa y de la versión de Arduino; te está indicando el tamaño del boceto y el tamaño máximo que puede aceptar tu placa.
Debate
El IDE utiliza una serie de herramientas de línea de comandos entre bastidores para compilar un sketch. Para más información al respecto, consulta la Receta 17.1.
El mensaje final que te indica el tamaño del boceto indica cuánto espacio de programa se necesita para almacenar las instrucciones del controlador en la placa. Si el tamaño del boceto compilado es mayor que la memoria disponible en la placa, aparece el siguiente mensaje de error :
Sketch
too
big
;
see
http
:
//www.arduino.cc/en/Guide/Troubleshooting#size for tips on reducing it.
Si esto ocurre, tienes que hacer tu boceto más pequeño para poder colocarlo en la placa, o conseguir una placa con mayor capacidad de memoria flash. Si tus variables globales están utilizando demasiada memoria, verás un error diferente:
Not
enough
memory
;
see
http
:
//www.arduino.cc/en/Guide/Troubleshooting#size
for
tips
on
reducing
your
footprint
.
En ese caso, tendrás que revisar tu código y reducir la cantidad de memoria que estás asignando a las variables globales, o conseguir una placa con mayor capacidad de SRAM (memoria dinámica).
Consejo
Para evitar que sobrescribas accidentalmente el código de ejemplo, el IDE Arduino no te permite guardar cambios en los bocetos de ejemplo incorporados. Debes renombrarlos utilizando la opción de menú Archivo→Guardarcomo. Puedes guardar los bocetos que escribas tú mismo con el botón Guardar (ver Receta 1.5).
Si hay errores en el código, el compilador imprimirá uno o varios mensajes de error en la ventana de la consola. Estos mensajes pueden ayudar a identificar el error: consulta el Apéndice D sobre errores de software para obtener consejos sobre la solución de problemas.
El compilador también puede generar advertencias si decide que hay algunas peculiaridades en tu boceto que podrían causar problemas. Estas advertencias pueden ser muy útiles para evitar problemas que podrían hacerte tropezar más adelante. Puedes configurar tu nivel de advertencias abriendo Archivo→Preferencias(Windows o Linux) o Arduino→Preferencias(macOS) y estableciendo Advertencias del compilador en Ninguna, Por defecto, Más o Todas. A pesar del nombre, Arduino pone por defecto Ninguno. Te sugerimos que lo configures como Por defecto o Más.
Nota
El código cargado en la placa no se puede volver a descargar en tu ordenador. Asegúrate de guardar el código del boceto en tu ordenador. No puedes guardar los cambios que hayas hecho en los archivos de ejemplo; tienes que utilizar Guardar como y dar otro nombre al archivo modificado.
Ver también
La receta 1.5 muestra un boceto de ejemplo. El Apéndice D contiene consejos para solucionar problemas de software.
1.4 Cargar y ejecutar el Blink Sketch
Solución
Conecta tu placa Arduino al ordenador mediante el cable USB. Carga el esquema Blink en el IDE eligiendo Archivo→Ejemplosy seleccionando 01. Básico→Blink. Básico→Blink.
A continuación, selecciona Herramientas→Placaen el menú desplegable y selecciona el nombre de la placa que has conectado (si es la placa estándar Uno, probablemente sea una de las primeras entradas de la lista de placas).
Ahora selecciona Herramientas→Puertoserie. Obtendrás una lista desplegable de los puertos serie disponibles en tu ordenador. Cada máquina tendrá una combinación diferente de puertos serie, dependiendo de qué otros dispositivos hayas utilizado con tu ordenador.
En Windows, aparecerán como entradas COM numeradas. Si sólo hay una entrada, selecciónala. Si hay varias entradas, tu placa será probablemente la última.
En el Mac, si tu placa es una Uno aparecerá como:
/dev/cu.usbmodem-XXXXXXX
(Arduino/Genuino Uno)
Si tienes una placa más antigua, aparecerá en la siguiente lista:
/dev/tty.usbserial-XXXXXXX
/dev/cu.usbserial-XXXXXXX
Cada tablero tendrá valores diferentes para XXXXXXX
. Selecciona cualquiera de las dos entradas.
En Linux, si tu placa es una Uno probablemente aparecerá como:
/dev/ttyACMX
(Arduino/Genuino Uno)
Si tienes una placa más antigua, puede que aparezca de la siguiente manera:
/dev/ttyUSB-X
X
suele ser 0, pero verás 1, 2, etc. si tienes varias placas conectadas a la vez. Selecciona la entrada que corresponda a tu Arduino.
Consejo
Si tienes tantas entradas en el menú Puerto que no puedes averiguar cuál va a tu Arduino, prueba esto: mira el menú con el Arduino desenchufado del ordenador, luego enchufa el Arduino y busca la opción del menú que antes no estaba. Otro método es seleccionar los puertos uno a uno, e intentar cargar hasta que veas que las luces de la placa parpadean para indicar que el código se está cargando.
Haz clic en el botón Cargar (en la Figura 1-6, es el segundo botón desde la izquierda), o elige Sketch→Cargar(Ctrl-U; ⌘+U en Mac).
El IDE compilará el código, como en la Receta 1.3. Una vez compilado el software, se carga en la placa. Si se trata de un Arduino recién salido de la caja y precargado con el sketch Blink, verás que el LED de la placa (etiquetado como LED de la placa en la Figura 1-4) deja de parpadear. Cuando comience la carga, dos LED (etiquetados como LED serie en la Figura 1-4) cercanos al LED de a bordo deberían parpadear durante un par de segundos mientras se carga el código. A continuación, el LED de la placa empezará a parpadear mientras se ejecuta el código. La ubicación del LED de la placa difiere en algunos modelos de Arduino, como el Leonardo, las placas MKR y los clones de Arduino de terceros.
Debate
Para que el IDE envíe el código compilado a la placa, ésta tiene que estar conectada al ordenador, y tú tienes que decirle al IDE qué placa y qué puerto serie estás utilizando.
Cuando se inicia una carga, se detiene cualquier sketch que se esté ejecutando en la placa (si estabas ejecutando el sketch Parpadeo, el LED dejará de parpadear). El nuevo sketch se carga en la placa, sustituyendo al sketch anterior. El nuevo sketch comenzará a ejecutarse cuando la carga se haya completado correctamente.
Nota
Algunas placas Arduino antiguas y compatibles no interrumpen automáticamente el boceto en ejecución para iniciar la carga. En este caso, tienes que pulsar el botón de Reinicio de la placa justo después de que el software informe de que ha terminado de compilar (cuando veas el mensaje sobre el tamaño del boceto). Pueden ser necesarios varios intentos para conseguir la sincronización correcta entre el final de la compilación y la pulsación del botón de Reinicio.
El IDE mostrará un mensaje de error si la carga no se realiza correctamente. Los problemas suelen deberse a que se ha seleccionado una placa o un puerto serie incorrectos, o a que la placa no está conectada. La placa y el puerto serie seleccionados se muestran en la barra de estado de la parte inferior de la ventana de Arduino.
Ver también
Para más información, consulta la página de resolución de problemas de Arduino.
1.5 Crear y guardar un boceto
Solución
Para abrir una ventana del editor preparada para un nuevo boceto, inicia el IDE (ver Receta 1.3), ve al menú Archivo y selecciona Nuevo. Elimina el código repetitivo que hay en la ventana del Editor de Sketches, y pega en su lugar el siguiente código (es similar al del sketch Parpadeo, pero los parpadeos duran el doble):
void
setup
()
{
pinMode
(
LED_BUILTIN
,
OUTPUT
);
}
void
loop
()
{
digitalWrite
(
LED_BUILTIN
,
HIGH
);
// set the LED on
delay
(
2000
);
// wait for two seconds
digitalWrite
(
LED_BUILTIN
,
LOW
);
// set the LED off
delay
(
2000
);
// wait for two seconds
}
Compila el código haciendo clic en el botón verificar/compilar (el botón superior izquierdo con una marca de verificación dentro), o selecciona Sketch→Verificar/Compilar(ver Receta 1.3).
Sube el código pulsando el botón de subir, o elige Sketch→Subir(ver Receta 1.4). Después de cargarlo, el LED debe parpadear, y cada parpadeo debe durar dos segundos.
Puedes guardar este croquis en tu ordenador haciendo clic en el botón Guardar, o seleccionando Archivo→Guardar. Puedes guardar un croquis con un nuevo nombre seleccionando la opción de menú Guardar como. Se abrirá un cuadro de diálogo en el que puedes introducir el nombre del archivo.
Debate
Cuando guardes un archivo en el IDE, se abrirá un cuadro de diálogo estándar del sistema operativo. Te sugiere que guardes el boceto en una carpeta llamada Arduino en tu carpeta Mis Documentos (o tu carpeta Documentos en un Mac). Puedes sustituir el nombre predeterminado del boceto por un nombre significativo que refleje el propósito de tu boceto. Haz clic en Guardar para guardar el archivo.
Nota
El nombre por defecto es la palabra boceto seguida de la fecha actual. Las letras secuenciales que empiezan por a se utilizan para distinguir los bocetos creados el mismo día. Sustituir el nombre por defecto por algo significativo te ayuda a identificar el propósito de un boceto cuando vuelvas a él más tarde.
Si utilizas caracteres que el IDE no permite (por ejemplo, el carácter espacio), el IDE los sustituirá automáticamente por caracteres válidos.
Los bocetos de Arduino se guardan como archivos de texto plano con la extensión .ino. Las versiones anteriores del IDE utilizaban la extensión .pde, también utilizada por Processing. Se guardan automáticamente en una carpeta con el mismo nombre que el boceto.
Puedes guardar tus bocetos en cualquier carpeta, pero si utilizas la carpeta por defecto (la carpeta Arduino de tu carpeta Documentos; ~/Arduino en Linux) tus bocetos aparecerán en el menú Sketchbook del software Arduino y serán más fáciles de localizar.
Si has editado uno de los ejemplos incorporados, no podrás guardar el archivo modificado en la carpeta de ejemplos, por lo que se te pedirá que lo guardes en una carpeta diferente.
Cuando hayas realizado cambios, verás un cuadro de diálogo que te preguntará si quieres guardar el boceto cuando se cierre un boceto. El símbolo § que aparece tras el nombre del boceto en la barra superior de la ventana del IDE indica que el código del boceto tiene cambios que aún no se han guardado en el ordenador. Este símbolo desaparece cuando guardas el boceto.
A medida que desarrolles y modifiques un esbozo, querrás tener una forma de hacer un seguimiento de los cambios. La forma más sencilla de hacerlo es utilizar el sistema de control de versiones Git (consulta esta página Tutorial de Git de Atlassian para obtener información sobre la instalación). Normalmente se accede a Git mediante una interfaz de línea de comandos (también existen clientes gráficos). El flujo de trabajo básico para poner un boceto bajo control de versiones en Git es:
-
Averigua en qué carpeta reside tu boceto. Puedes encontrarla utilizando Boceto→Mostrarcarpeta de bocetos. Esto abrirá la carpeta del boceto en el gestor de archivos de tu ordenador.
-
Abre una línea de comandos (en Windows, Símbolo del sistema; en Linux o macOS, abre un Terminal). Utiliza el comando
cd
para cambiar al directorio donde se encuentra tu sketch. Por ejemplo, si guardaste un sketch llamado Parpadeo en la ubicación predeterminada de la carpeta de sketches, podrías cambiar a ese directorio con lo siguiente en macOS, Linux y Windows, respectivamente:$ cd ~/Documents/Arduino/Blink $ cd ~/Arduino/Blink > cd %USERPROFILE%\Documents\Arduino\Blink
-
Inicializa el repositorio Git con el comando
git init
. -
Añade el archivo Sketch a Git con
git add Blink.ino
(sustituyeBlink.ino
por el nombre de tu sketch). Si añades algún archivo adicional a la carpeta de tu boceto, tendrás que añadirlo con el comandogit add filename
comando. -
Cuando hayas hecho cambios sustanciales, escribe
git commit -a -m "your comment here"
. Sustituye "tu comentario aquí" por algo que describa el cambio que has hecho.
Después de confirmar un cambio en Git, puedes utilizar git log
para ver un historial de tus cambios. Cada uno de esos cambios tendrá asociado un hash de confirmación:
commit 87e962e54fe46d9e2a00575f7f0d1db6b900662a (HEAD -> master) Author: Brian Jepson <bjepson@gmail.com> Date: Tue Jan 14 20:58:56 2020 -0500 made massive improvements commit 0ae1a1bcb0cd245ca9427352fc3298d6ccb91cef (HEAD -> master) Author: Brian Jepson <bjepson@gmail.com> Date: Tue Jan 14 20:56:45 2020 -0500 your comment here
Con estos hashes, puedes trabajar con versiones antiguas de archivos (no necesitas el hash completo, sólo lo suficiente para diferenciar entre versiones). Puedes restaurar una versión antigua con git checkout hash filename
como en git checkout 0ae1 Blink.ino
. Puedes comparar versiones con git diff firsthash..secondhash
como en git diff 0ae1..7018
. Consulta https://git-scm.com/doc para obtener documentación completa sobre Git.
La compilación frecuente a medida que modificas o añades código es una buena forma de comprobar si hay errores. Será más fácil encontrar y corregir cualquier error porque normalmente estará asociado a lo que acabas de escribir.
Nota
Una vez cargado un boceto en el tablero, no hay forma de volver a descargarlo en tu ordenador. Asegúrate de guardar cualquier cambio en tus bocetos que quieras conservar.
Si intentas guardar un archivo de boceto que no está en una carpeta con el mismo nombre que el boceto, el IDE te informará de que no se puede abrir tal cual y te sugerirá que hagas clic en Aceptar para crear la carpeta para el boceto con el mismo nombre.
Nota
Los bocetos deben ubicarse en una carpeta con el mismo nombre que el boceto. El IDE creará la carpeta automáticamente cuando guardes un nuevo boceto.
Los bocetos hechos con versiones anteriores del software Arduino tienen una extensión de archivo diferente (.pde). El IDE los abrirá, y cuando guardes el boceto creará un archivo con la nueva extensión (.ino). Es posible que el código escrito para las primeras versiones del IDE no pueda compilarse en la versión 1.0. La mayoría de los cambios para que el código antiguo funcione son fáciles de hacer.
1.6 Un primer proyecto Arduino fácil
Solución
Esta receta proporciona una muestra de algunas de las técnicas que se tratan en detalle en capítulos posteriores.
El esquema se basa en el código de parpadeo del LED de la receta anterior, pero en lugar de utilizar un retardo fijo, la velocidad la determina un sensor sensible a la luz llamado fotorresistencia o resistencia dependiente de la luz (abreviado LDR, ver Receta 6.3). Cablea la fotorresistencia como se muestra en la Figura 1-7.
Si no estás familiarizado con la construcción de un circuito a partir de un esquema, consulta el Apéndice B para ver ilustraciones paso a paso sobre cómo hacer este circuito en una protoboard.
Nota
Los fotorresistores contienen un compuesto (sulfuro de cadmio) que es una sustancia peligrosa. Puedes utilizar un fototransistor si vives en una jurisdicción donde es difícil obtener un fototransistor, o si simplemente prefieres no utilizar un fototransistor. Un fototransistor tiene un cable largo y otro corto, como un LED. Puedes conectarlo exactamente como se muestra en la figura, pero debes conectar el cable largo a 5 V y el cable corto a la resistencia y a la patilla 0. Asegúrate de comprar un fototransistor como el número de pieza 2831 de Adafruit, que pueda detectar la luz visible, para que puedas probarlo con una fuente de luz común.
El siguiente esquema lee el nivel de luz de una fotorresistencia conectada al pin analógico 0. El nivel de luz que golpea la fotorresistencia cambiará el retardo de parpadeo del LED interno de la placa:
/*
* Blink with photoresistor sketch
*/
const
int
sensorPin
=
A0
;
// connect sensor to analog input 0
void
setup
()
{
pinMode
(
LED_BUILTIN
,
OUTPUT
);
// enable output on the led pin
}
void
loop
()
{
int
delayval
=
analogRead
(
sensorPin
);
// read the analog input
digitalWrite
(
LED_BUILTIN
,
HIGH
);
// set the LED on
delay
(
delayval
);
// delay is dependent on light level
digitalWrite
(
LED_BUILTIN
,
LOW
);
// set the LED off
delay
(
delayval
);
}
El código de esta receta y de todo este libro utiliza la expresión const int
para proporcionar nombres significativos (sensorPin
) a las constantes en lugar de números (0
). Consulta la Receta 17.5 para saber más sobre el uso de constantes.
Debate
El valor de la resistencia que se muestra en la Figura 1-7 depende del rango de tu fotorresistencia: querrás una resistencia que esté en torno a la resistencia máxima (en la oscuridad) de tu fotorresistencia (puedes averiguarlo tapando la fotorresistencia mientras mides su resistencia en un multímetro). Por tanto, si tu fotorresistencia mide 10 K ohmios en la oscuridad, utiliza una resistencia de 10 K. Si utilizas un fototransistor, por lo general te bastará con un valor de entre 1K y 10K. El nivel de luz en el sensor cambiará el nivel de tensión en la patilla analógica 0. El comando analogRead
(ver Capítulo 6) proporciona un valor que oscila entre alrededor de 200 cuando el sensor está oscuro y 800 más o menos cuando está muy iluminado (la sensibilidad variará dependiendo del tipo de fotorresistencia y resistencia que utilices, y de si utilizas un fototransistor en lugar de la fotorresistencia). La lectura analógica determina la duración de los tiempos de encendido y apagado del LED, por lo que el retardo del parpadeo aumenta con la intensidad de la luz.
Puedes escalar la velocidad de parpadeo utilizando la función Arduino map
del siguiente modo:
/*
* Blink with photoresistor (scaled) sketch
*/
const
int
sensorPin
=
A0
;
// connect sensor to analog input 0
// low and high values for the sensor readings; you may need to adjust these
const
int
low
=
200
;
const
int
high
=
800
;
// The next two lines set the min and max delay between blinks.
const
int
minDuration
=
100
;
// minimum wait between blinks
const
int
maxDuration
=
1000
;
// maximum wait between blinks
void
setup
()
{
pinMode
(
LED_BUILTIN
,
OUTPUT
);
// enable output on the LED pin
}
void
loop
()
{
int
delayval
=
analogRead
(
sensorPin
);
// read the analog input
// the next line scales the delay value between the min and max values
delayval
=
map
(
delayval
,
low
,
high
,
minDuration
,
maxDuration
);
delayval
=
constrain
(
delayval
,
minDuration
,
maxDuration
);
digitalWrite
(
LED_BUILTIN
,
HIGH
);
// set the LED on
delay
(
delayval
);
// delay is dependent on light level
digitalWrite
(
LED_BUILTIN
,
LOW
);
// set the LED off
delay
(
delayval
);
}
Nota
Si no observas ningún cambio en los valores a medida que ajustas la luz, tendrás que jugar con los valores de low
y high
. Si utilizas un fototransistor y no obtienes cambios en la velocidad de parpadeo, prueba con un valor de 10 para low
.
Lareceta 5.7 ofrece más detalles sobre el uso de la función map
para escalar valores. La receta 3.5 tiene detalles sobre el uso de la función constrain
para garantizar que los valores no superan un rango determinado. Si, por alguna razón, tu valor de retardo está fuera del rango entre low
y high
, map
devolverá un valor fuera del rango entre minDuration
y maxDuration
. Si llamas a constrain
después de map
, como se muestra en el esquema, evitarás el problema de los valores fuera de rango.
Si quieres ver el valor de la variable delayval
en tu ordenador, puedes imprimirlo en el monitor serie del Arduino, como se muestra en el código revisado del bucle que sigue. El boceto mostrará el valor del retardo en el Monitor Serial. Para abrir la ventana del Monitor serie en el IDE de Arduino, haz clic en el icono situado a la derecha de la barra superior (para más información sobre el uso del Monitor serie, consulta el Capítulo 4 ):
/*
* Blink sketch with photoresistor (scaled with serial output)
*/
const
int
sensorPin
=
A0
;
// connect sensor to analog input 0
// Low and high values for the sensor readings. You may need to adjust these.
const
int
low
=
200
;
const
int
high
=
800
;
// the next two lines set the min and max delay between blinks
const
int
minDuration
=
100
;
// minimum wait between blinks
const
int
maxDuration
=
1000
;
// maximum wait between blinks
void
setup
()
{
pinMode
(
LED_BUILTIN
,
OUTPUT
);
// enable output on the led pin
Serial
.
begin
(
9600
);
// initialize Serial
}
void
loop
()
{
int
delayval
=
analogRead
(
sensorPin
);
// read the analog input
// the next line scales the delay value between the min and max values
delayval
=
map
(
delayval
,
low
,
high
,
minDuration
,
maxDuration
);
delayval
=
constrain
(
delayval
,
minDuration
,
maxDuration
);
Serial
.
println
(
delayval
);
// print delay value to serial monitor
digitalWrite
(
LED_BUILTIN
,
HIGH
);
// set the LED on
delay
(
delayval
);
// delay is dependent on light level
digitalWrite
(
LED_BUILTIN
,
LOW
);
// set the LED off
delay
(
delayval
);
}
Puedes utilizar el sensor para controlar el tono de un sonido conectando un pequeño altavoz a la clavija, como se muestra en la Figura 1-8.
Tendrás que aumentar la frecuencia de activación/desactivación de la clavija a una frecuencia del espectro de audio. Esto se consigue, como se muestra aquí, disminuyendo las duraciones mín. y máx:
/* * Speaker sketch with photoresistor */
const
int
outputPin
=
9
;
// Speaker connected to digital pin 9
const
int
sensorPin
=
A0
;
// connect sensor to analog input 0
const
int
low
=
200
;
const
int
high
=
800
;
const
int
minDuration
=
1
;
// 1 ms on, 1 ms off (500 Hz)
const
int
maxDuration
=
10
;
// 10 ms on, 10 ms off (50 Hz)
void
setup
(
)
{
pinMode
(
outputPin
,
OUTPUT
)
;
// enable output on the led pin
}
void
loop
(
)
{
int
sensorReading
=
analogRead
(
sensorPin
)
;
// read the analog input
int
delayval
=
map
(
sensorReading
,
low
,
high
,
minDuration
,
maxDuration
)
;
delayval
=
constrain
(
delayval
,
minDuration
,
maxDuration
)
;
digitalWrite
(
outputPin
,
HIGH
)
;
// set the pin on
delay
(
delayval
)
;
// delay is dependent on light level
digitalWrite
(
outputPin
,
LOW
)
;
// set the pin off
delay
(
delayval
)
;
}
Ver también
Para una discusión completa sobre la salida de audio con Arduino, consulta el capítulo 9.
1.7 Utilizar Arduino con placas no incluidas en la distribución estándar
Problema
Quieres utilizar una placa como la Arduino MKR 1010, pero no aparece en el menú de placas.
Solución
Para utilizar el MKR 1010 con Arduino, tienes que añadir sus datos al software Arduino que ya te has descargado. Para ello ve a Herramientas→Pizarra→Administradorde Pizarras(Figura 1-9).
Cuando se abra esta ventana, se comprobará la lista de definiciones de placa disponibles en Internet para asegurarse de que tienes las últimas versiones disponibles, así que espera a que termine.
Añadir otras Pizarras al Menú Pizarras
El procedimiento descrito aquí es similar para otras placas que quieras añadir al menú de placas. Consulta la documentación de tu placa para encontrar la ubicación de los archivos de definición.
La ventana que se abre(Figura 1-10) te muestra las definiciones de placa que ya están instaladas y las que están disponibles para descargar.
Para encontrar el MKR 1010 puedes desplazarte por la lista o escribir su nombre en el cuadro de filtro. Para el MKR 1010, tendrás que seleccionar la entrada Placas SAMD Arduino de la lista. Una vez que la hayas seleccionado, haz clic en instalar y se descargará y añadirá al IDE de Arduino. Esto puede llevar algún tiempo.
Una vez que haya terminado, puedes añadir otras placas, o hacer clic en Cerrar para terminar de utilizar el Gestor de Placas. Si abres Herramientas→Placa, ahora deberías tener la opción de seleccionar la MKR 1010, como se muestra en la Figura 1-11.
Debate
Los archivos que descargas cuando haces esto describen cómo asignar los conceptos de programación en Arduino que conectan con bits específicos de hardware en el chip microcontrolador de la placa, a dónde se encuentra ese hardware en un chip o familia de chips específicos.
Una vez que hayas añadido la descripción de un chip concreto, a menudo podrás trabajar con una familia de placas que utilicen ese chip. Por ejemplo, añadir compatibilidad con la placa MKR 1010 también proporciona compatibilidad con el Arduino Zero, ya que ambas placas utilizan el mismo chip microcontrolador.
Para facilitar la compatibilidad con el creciente número de placas Arduino y compatibles con Arduino, el IDE Arduino añadió un Gestor de placas en la versión 1.6. El Gestor de Placas se desarrolló para permitir a la gente añadir y eliminar fácilmente detalles de las placas de su instalación. También te permite actualizar los archivos de soporte de la placa si hay versiones más recientes disponibles, o elegir la versión que utilizas si necesitas utilizar una en particular. El IDE de Arduino ya no incluye los archivos de descripción de todas las placas Arduino, así que aunque te descargues el IDE más reciente es posible que no obtengas las descripciones de la placa que tienes.
El Gestor de tableros también permite a terceros añadir los detalles de sus tableros al sistema. Si las descripciones de sus tablones están disponibles en línea en el formato correcto, puedes añadir la ubicación como uno de los lugares que el Gestor de tablones utilizará para rellenar la lista que produce. Esto significa que esos archivos también se comprobarán cada vez que el Gestor de Placas actualice sus detalles, de modo que se te notifiquen las actualizaciones y puedas utilizar el mismo mecanismo para actualizarlas una vez instaladas. Para ello, ve a Arduino→Preferencias y haz clic en el icono a la derecha del campo URLs adicionales del Gestor de Placas, y aparecerá el diálogo URLs adicionales del Gestor de Placas, como se muestra en la Figura 1-12.
Si las personas que fabricaron la placa proporcionan una URL para añadir a Arduino, pégala en el cuadro de diálogo "URL adicionales" (en una línea aparte si hay otras entradas). Si no hay una URL explícita, haz clic en el texto que hay debajo del cuadro para ir a la página web que mantiene una lista de URL no oficiales de descripción de placas Arduino y ver si puedes encontrar un enlace allí.
Si quieres utilizar una placa Teensy, tienes que descargarte un programa instalador aparte del sitio web de Teensy. Es importante que utilices un instalador de Teensy que sea compatible con la versión del IDE que estés utilizando. Normalmente se produce una versión compatible una o dos semanas después de la publicación de una nueva versión de Arduino.
Ver también
Guías de inicio rápido para varias placas Arduino
1.8 Utilizar un Arduino de 32 bits (o compatible)
Problema
Quieres rendimiento de 32 bits en el factor de forma Uno.
Solución
El Arduino Zero (Figura 1-13) tiene la disposición de patillas familiar del Uno, pero tiene mucha más memoria y un procesador más rápido. Si tienes problemas para conseguir un Zero, el Metro M0 Express de Adafruit y la RedBoard Turbo de SparkFun son alternativas compatibles.
A pesar de que la disposición física de los pines es similar, hay una serie de diferencias. Lo que distingue a estas placas de la Uno es que utilizan un chip ARM de 32 bits, el Microchip SAMD21. El siguiente esquema, similar a la receta anterior, destaca algunas diferencias significativas entre las placas basadas en ARM y la Uno:
Nota
Si no oyes ningún cambio en los valores al ajustar la luz, tendrás que jugar con los valores de low
y high
. Si utilizas un fototransistor y no obtienes cambios en la velocidad de parpadeo, prueba con un valor de 10 para low
. Si tu luz ambiental procede de una fuente fluorescente o LED, es posible que oigas un claro alabeo en el sonido debido al parpadeo de dichas fuentes, que es visualmente imperceptible.
/*
* Zero wave sketch
*/
const
int
outputPin
=
A0
;
// headphones connected to analog 0
const
int
sensorPin
=
A1
;
// connect sensor to analog input 1
const
int
low
=
200
;
const
int
high
=
800
;
const
int
sampleCount
=
16
;
// number of samples used to render one cycle
const
int
minDur
=
1000000
/
(
sampleCount
*
500
);
// period in uS for 500 Hz
const
int
maxDur
=
1000000
/
(
sampleCount
*
50
);
// period for 50 Hz
// table of values for 16 samples of one sine wave cycle
static
int
sinewave
[
sampleCount
]
=
{
0x1FF
,
0x2B6
,
0x355
,
0x3C7
,
0x3FF
,
0x3C7
,
0x355
,
0x2B6
,
0x1FF
,
0x148
,
0x0A9
,
0x037
,
0x000
,
0x037
,
0x0A9
,
0x148
};
void
setup
()
{
analogWriteResolution
(
10
);
// set the Arduino DAC resolution to maximum
}
void
loop
()
{
int
sensorReading
=
analogRead
(
sensorPin
);
// read the analog input
int
duration
=
map
(
sensorReading
,
low
,
high
,
minDur
,
maxDur
);
duration
=
constrain
(
duration
,
minDur
,
maxDur
);
duration
=
constrain
(
duration
,
minDur
,
maxDur
);
for
(
int
sample
=
0
;
sample
<
sampleCount
;
sample
++
)
{
analogWrite
(
outputPin
,
sinewave
[
sample
]);
delayMicroseconds
(
duration
);
}
}
Antes de que puedas cargar bocetos en la Zero, la Adafruit Metro M0 o M4, o la SparkFun RedBoard, abre el Gestor de Placas Arduino e instala el paquete adecuado (consulta la Receta 1.7). Si utilizas una placa Adafruit o SparkFun, primero tendrás que añadir la URL de su gestor de placas al IDE de Arduino. Consulta Adafruit o SparkFun para más detalles. Cuando hayas instalado el soporte para tu placa SAMD, utiliza el menú Herramientas para configurar el IDE Arduino para que utilice esa placa y establece el puerto serie correcto para conectarte a ella. Conecta una resistencia, un potenciómetro y una fotorresistencia (también conocida como resistencia dependiente de la luz) como se muestra en la Figura 1-14. A continuación, carga el código utilizando el IDE de Arduino.
Debate
Aunque el cableado pueda parecer similar al de la Figura 1-8 a primera vista, la entrada del sensor y la salida de audio utilizan patillas diferentes. Estas placas tienen un convertidor digital-analógico (DAC) que puede crear un audio más realista que la salida binaria de las patillas digitales estándar. Sin embargo, el DAC sólo está disponible en la patilla analógica 0, por lo que la entrada del sensor se conecta aquí a la patilla analógica 1.
Otra diferencia que puede no resultar obvia en la figura es que estas placas sólo pueden suministrar hasta 7 mA a una patilla, frente a los 40 mA de la Uno. Y como el voltaje de las patillas oscila entre 0 y 3,3 voltios, frente al rango de 0 a 5 voltios de la Uno, la potencia máxima suministrada a una patilla es casi 10 veces menor que la de la Uno. Por este motivo, las patillas de salida deben conectarse a unos auriculares o a la entrada de un amplificador, ya que no alimentarán directamente un altavoz.
El esquema utiliza una tabla de consulta de 16 muestras por ciclo de onda sinusoidal, pero estas placas son lo bastante rápidas como para manejar resoluciones mucho mayores, y puedes aumentar el número de muestras para mejorar la pureza de la señal.
Get Libro de cocina Arduino, 3ª edición now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.