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.

Placa base: el Arduino Uno

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)

Problema

Quieres instalar el entorno de desarrollo Arduino en tu ordenador.

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).

Pantalla de inicio de Arduino (Arduino 1.8.9 en Windows 10)

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.

Ventana principal del IDE (Arduino 1.8.9 en Mac)

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

Problema

Quieres encender una placa nueva y comprobar que funciona.

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).

Placa Arduino básica, la Uno Rev3
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

Problema

Te conviene familiarizarte con el proceso de compilación de Arduino y comprender los mensajes de estado y de error que puede producir.

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).

Menú IDE (seleccionando el sketch de ejemplo Blink) en Windows 10

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.

IDE Arduino en macOS

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.5 Crear y guardar un boceto

Problema

Quieres crear un boceto y guardarlo en tu ordenador.

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 (sustituye Blink.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 comando git 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 filenamecomo en git checkout 0ae1 Blink.ino. Puedes comparar versiones con git diff firsthash..secondhashcomo 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

Problema

Quieres empezar con un proyecto que sea fácil de construir y divertido de usar.

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.

Arduino con fotorresistencia

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.

Conexiones para un altavoz con el circuito de fotorresistencia

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).

Seleccionando el Gestor de Placas (se muestra la versión Linux del IDE Arduino)

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.

El Gestor de Juntas

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.

El MKR 1010 ya está instalado y se puede programar con el IDE Arduino

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.

Preferencias tras hacer clic en el icono situado a la derecha de la entrada URLs adicionales del Gestor de Salas

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.

La placa Arduino/Genuino Zero

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.

Conexiones para la salida de audio con el circuito de fotorresistencia para la placa Zero

Estas placas basadas en SAMD no son tolerantes a 5 voltios

No debes conectar más de 3,3 voltios a sus patillas de E/S, ¡o puedes dañar la placa!

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.

Ver también

Guía de inicio rápido de Arduino Zero

Más sobre audio con Arduino en el capítulo 9

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.

Start your free trial