En esta sección publicaremos todos los tutoriales de todos los proyectos que se pueden hacer con el Kit Principiante en orden de menor a mayor dificultad.


Tabla de Contenidos


 

Introduccion a la Plataforma Arduino

 

Hoy vamos a explicar qué es exactamente el proyecto Arduino, así como las principales características que lo definen. Se trata de uno de los tipos de las placas más populares del mundo maker, pero que a diferencia de la Raspberry Pi no cuenta con un único modelo, sino que ofrece unas bases de hardware abierto para que otros fabricantes puedan crear sus propias placas.

Para ello, vamos a empezar explicando qué es Arduino, hablando de su concepto, lo que hace diferente al proyecto, y lo que se quiere conseguir con él. Después pasaremos a entrar en cómo funcionan estas placas, para terminar enseñando unos cuantos ejemplos de los proyectos que pueden realizarse con ellas.

 

Qué es Arduino

 

Arduino es una plataforma de creación de electrónica de código abierto, la cual está basada en hardware y software libre, flexible y fácil de utilizar para los creadores y desarrolladores. Esta plataforma permite crear diferentes tipos de microordenadores de una sola placa a los que la comunidad de creadores puede darles diferentes tipos de uso.

Para poder entender este concepto, primero vas a tener que entender los conceptos de hardware libre y el software libre. El hardware libre son los dispositivos cuyas especificaciones y diagramas son de acceso público, de manera que cualquiera puede replicarlos. Esto quiere decir que Arduino ofrece las bases para que cualquier otra persona o empresa pueda crear sus propias placas, pudiendo ser diferentes entre ellas pero igualmente funcionales al partir de la misma base.

El software libre son los programas informáticos cuyo código es accesible por cualquiera para que quien quiera pueda utilizarlo y modificarlo. Arduino ofrece la plataforma Arduino IDE (Entorno de Desarrollo Integrado), que es un entorno de programación con el que cualquiera puede crear aplicaciones para las placas Arduino, de manera que se les puede dar todo tipo de utilidades.

El proyecto nació en 2003, cuando varios estudiantes del Instituto de Diseño Interactivo de Ivrea, Italia, con el fin de facilitar el acceso y uso de la electrónico y programación. Lo hicieron para que los estudiantes de electrónica tuviesen una alternativa más económica a las populares BASIC Stamp, unas placas que por aquel entonces valían más de cien dólares, y que no todos se podían permitir.

El resultado fue Arduino, una placa con todos los elementos necesarios para conectar periféricos a las entradas y salidas de un microcontrolador, y que puede ser programada tanto en Windows como macOS y GNU/Linux. Un proyecto que promueve la filosofía ‘learning by doing’, que viene a querer decir que la mejor manera de aprender es cacharreando.

 

Cómo funciona Arduino

 

 

El Arduino es una placa basada en un microcontrolador ATMEL. Los microcontroladores son circuitos integrados en los que se pueden grabar instrucciones, las cuales las escribes con el lenguaje de programación que puedes utilizar en el entorno Arduino IDE. Estas instrucciones permiten crear programas que interactúan con los circuitos de la placa.

El microcontrolador de Arduino posee lo que se llama una interfaz de entrada, que es una conexión en la que podemos conectar en la placa diferentes tipos de periféricos. La información de estos periféricos que conectes se trasladará al microcontrolador, el cual se encargará de procesar los datos que le lleguen a través de ellos.

El tipo de periféricos que puedas utilizar para enviar datos al microcontrolador depende en gran medida de qué uso le estés pensando dar. Pueden ser cámaras para obtener imágenes, teclados para introducir datos, o diferentes tipos de sensores.

También cuenta con una interfaz de salida, que es la que se encarga de llevar la información que se ha procesado en el Arduino a otros periféricos. Estos periféricos pueden ser pantallas o altavoces en los que reproducir los datos procesados, pero también pueden ser otras placas o controladores.

 

 

Arduino es un proyecto y no un modelo concreto de placa, lo que quiere decir que compartiendo su diseño básico te puedes encontrar con diferentes tipos de placas. Las hay de varias formas, tamaños y colores para a las necesidades del proyecto en el que estés trabajando, las hay sencillas o con características mejoradas, Arduinos orientados al Internet de las Cosas o la impresión 3D y, por supuesto, dependiendo de estas características te encontrarás con todo tipo de precios.

 

 

Además, las placas Arduino también cuentan con otro tipo de componentes llamados Escudos (Shields) o mochilas. Se trata de una especie de placas que se conectan a la placa principal para añadirle una infinidad de funciones, como GPS, relojes en tiempo real, conectividad por radio, pantallas táctiles LCD, placas de desarrollo, y un larguísimo etcétera de elementos

 

Contenido del Kit Principiante

 

 

El Kit Principiante contiene los siguientes componentes:

  1. Arduino UNO (x1): Es una placa de microcontrolador que actúa como el cerebro de tu proyecto, proporcionando capacidad de procesamiento y control.
  2. Protoboard (x1): Una placa de pruebas que te permite conectar componentes electrónicos de manera temporal para prototipar circuitos.
  3. Cables Jumper (x65): Pequeños cables con conectores en ambos extremos que se utilizan para hacer conexiones entre los componentes en la protoboard.
  4. Pulsadores (x5): Interruptores momentáneos que se utilizan para enviar señales al Arduino cuando son presionados.
  5. Sensor de Ultrasonido (x1): Un sensor que utiliza ondas ultrasónicas para medir la distancia entre el sensor y un objeto.
  6. Display de 7 Segmentos (x1): Un tipo de pantalla que muestra números y algunas letras mediante la iluminación de segmentos individuales.
  7. Buzzer (x1): Un dispositivo que emite un sonido cuando se le aplica corriente eléctrica.
  8. LEDs 5mm (x5): Diodos emisores de luz que pueden emitir luz de diferentes colores cuando se les aplica corriente.
  9. Resistencias de 220 ohmios (x10): Componentes que limitan la corriente que pasa a través de los LEDs para evitar daños.
  10. Cable USB (x1): Se utiliza para conectar la placa Arduino a un ordenador para la programación y alimentación.
  11. Resistencias de 10K ohmios (x10): Se utilizan en diversos circuitos como divisores de voltaje o pull-down/pull-up.
  12. Potenciómetro (x1): Un tipo de resistor variable que permite ajustar la resistencia manualmente mediante un dial.
  13. LDR (x1): Un resistor cuya resistencia varía en función de la intensidad de luz incidente.
  14. Sensor DHT11 (x1): Un sensor de temperatura y humedad que proporciona lecturas digitales.
  15. LED RGB (x1): Un LED capaz de emitir luz en tres colores: rojo, verde y azul, lo que permite generar una amplia gama de colores.
  16. Tira de 40 Pines (x1): Una tira con 40 pines que se utiliza para facilitar la conexión de múltiples cables jumper a la protoboard o al Arduino.

 

Instalacion de Arduino IDE

 

Material necesario para usar Arduino IDE

Antes de comenzar el tutorial es importante que tengas lo siguiente:

  • Una PC con conexión a Internet
  • Sistema operativo Windows, Linux o Mac
  • Una placa compatible con Arduino IDE *
  • Un cable USB para conectar la placa al ordenador

 

¿Dónde descargar Arduino IDE?

 

Lo primero es descargar Arduino IDE. Para eso es necesario ir al sitio oficial de Arduino y hacer clic en el botón Software>Download.

 

Esto nos lleva a la página de descargas.

 

A la derecha de esta página te encuentras los enlaces para descargar Arduino IDE para diferentes arquitecturas y sistemas operativos.

Para descargar el software debes hacer clic sobre el enlace correspondiente a tu sistema operativo. Esto te envía a una página que permite descargar el software o realizar una donación antes de la descarga.

 

 

Ojo, no es necesario pagar para obtener el software. Pero realizar una pequeña donación no está de más si quieres contribuir al desarrollo de Arduino.

Bueno para descargar el software solo tienes que hacer clic en uno de los botones y listo la descarga comienza.

 

Instalar Arduino IDE en Windows

 

Veamos como instalar Arduino IDE en un ordenador con sistema operativo Windows.

Paso 1: descargar Arduino IDE para Windows

Para instalar el software Arduino IDE en Windows lo primero es descargar desde el sitio oficial tal y como se ve anteriormente. Para Windows existen dos versiones:

  • Windows Win 7 and newer
  • Windows ZIP file

La primera es un instalador (.exe) y la segunda es un archivo zip.

Mi sugerencia es utilizar la primera opción porque simplifica enormemente el proceso de instalación.

 

 

Paso 2: ejecutar el instalador

Ahora es necesario ejecutar el archivo descargado. Este se llama arduino-1.x.xx-windows, donde las x indican la versión del software.

 

 

Cuando se ejecute se mostrará una ventana con la licencia.

 

Es necesario hacer clic en el botón I Agree para continuar con la instalación y pasar a la ventana opciones de instalación.

 

En esta ventana es posible establecer algunos parámetros de la instalación:

  • Install USB Driver: instala los controladores necesarios para que el ordenador reconozca las placas Arduino.
  • Create Start Menu shortcut: crea un acceso directo a Arduino IDE en el menú inicio.
  • Create Desktop shortcut: crea un acceso directo a Arduino IDE en el escritorio.
  • Associate .ino files: asociar archivos .ino con Arduino IDE, es decir, que los archivos .ino se abrirán automáticamente con Arduino IDE.

Mi consejo es que los dejes todos activos, aunque si lo prefieres puedes desactivar la creación de los accesos directos.

Es importante que mantengas activa la opción Install USB Driver, ya que de lo contrario los controladores necesarios para las placas Arduino no serán instalados.

Para continuar haz clic en el botón Next>.

Ahora tienes la opción de indicar dónde instalar el software. Te recomiendo mantener la ruta predeterminada, pero si lo prefieres puedes cambiarla haciendo clic en el botón Browse.

 

 

Haciendo clic en Install comienza la instalación.

 

 

La instalación puede tardar algunos minutos. Durante este proceso es necesario permitir de forma manual la instalación de los drivers cuando el instalador lo indique.

 

Introducción al Arduino IDE

 

En este apartado del Curso vamos a describir las principales partes y funciones del IDE de Arduino, del que ya hemos visto su instalación en el punto anterior.

Cuando lanzamos por primera vez el IDE de Arduino o creamos un Nuevo sketch, con este nombre se conoce a los «Programas» en el Lenguaje de Programación de Arduino, obtendremos una imagen similar a una de las dos siguientes. Bien puede aparecer una estructura básica del sketck por defecto o bien puede aparecer completamente vacío.

 

IDE de Arduino al arrancar un Nuevo sketch (dos posibilidades)

 

En el editor del IDE puede aparecer una estructura básica del sketck, como se observa en la imagen de la izquierda o bien puede aparecer completamente vacío, como aparece en la imagen de la derecha. Esto suele depender la versión del IDE y del sistema operativo donde lo estemos ejecutando.

A continuación vamos a describir, en orden de mayor a menor uso, las principales partes o secciones que podemos ver en el IDE de Arduino y que se muestran en la siguiente imagen.

 


Partes del IDE de Arduino

Editor

 

Esta será la parte del IDE que más utilizaremos.


Editor del IDE de Arduino

En ella es donde vamos a escribir el código fuente de nuestros programas (recuerda que en Arduino los llamamos sketchs).

Se trata de un editor de textos sencillo, pero que nos resultará muy útil por que nos resaltará automáticamente con diferentes colores las palabras reservadas del lenguaje, opciones para el compilador, comentarios, …

 

Barra de Herramientas

 

Contiene los Botones o Iconos que lanzan las funciones más habituales que realizamos en el Entorno.


Barra de Herramientas del IDE Arduino

La función de cada uno de los Botones de izquierda a derecha es la siguiente:

  • Verificar / Compilar. Comprueba que la sintaxis del código fuente cargado en ese momento en el editor sea correcta. Si hay algún error sintáctico lo muestra en la Consola de Salida, además de indicar en color rojo en el Editor la línea que contiene el error. Por el contrario, si todo es correcto lo Compila mostrando dicho resultado positivo también en la Consola de Salida. En la imagen siguiente puedes ver (Imagen izquierda) el resultado de pulsar este Botón en una programa con un error sintáctico («voidd» en lugar de la instrucción correcta «void») y otro (Imagen derecha) con un resultado que si es correcto sintácticamente y, por lo tanto, la correspondiente compilación del código fuente.

 


IDE Arduino Resultado al Pulsar Botón Verificar (Izquierda con error / Derecha correcto)
  • Subir. Transfiere el programa cargado en esos momentos en el Editor, a la placa Arduino y lo graba en el microcontrolador. Este Botón incluye previamente las funciones del Botón Verificar/Compilar. Es decir, para cargar el programa directamente en Arduino no es necesario pulsar el primer botón y después éste. Bastará con pulsar simplemente este Botón que realizará las funciones de Verificar/Compilar/Subir.
  • Nuevo. Permite la creación de un nuevo sketch.
  • Abrir. Nos permite cargar un sketch grabado previamente.
  • Guardar. Nos permite grabar el sketch que tenemos actualmente en el Editor.
  • Monitor Serie. Se trata de una herramienta importante que nos permite la comunicación directa con la tarjeta Arduino. Lo trataremos con más profundidad en el punto 3.7 de este documento.

 

Barra de Menús

 

Esta sección nos permite realizar TODAS las funciones de las que dispone el IDE de Arduino.

Si desplegamos el Menú «Archivo« veremos una serie de opciones muy similar o igual (dependerá de la versión del IDE elegido) a las que aparecen en la imagen siguiente


IDE Arduino, Menú Archivo

Estas opciones, brévemente son

  • Nuevo. Nos permite crear un nuevo sketch.
  • Abrir… Nos permite cargar un sketch entre los disponibles (ejemplos disponibles del propio entorno, los realizados por nosotros o por otros programadores, …). El sketch cargado lo hace en una nueva ventana.
  • Abrir Reciente. Nos permite cargar los últimos sketch con los que hemos realizado alguna acción (creación, carga, …). Es una opción que suele resultar muy útil cuando trabajamos con nuestros Proyectos.
  • Proyecto. Nos muestra la librería de sketch guardados.
  • Ejemplos. Contiene muchos ejemplos de sketch que trae consigo la instalación del IDE de Arduino y que resultan muy útiles para ver la operativa con diferentes componentes electrónicos (sensores, actuadores, visores, etc) y funciones propias del lenguaje de programación Arduino, con ejemplos de su uso. Será interesante echar un vistazo a los mismos a lo largo de nuestro aprendizaje.
  • Cerrar. Cierra el sketch que actualmente tenemos en el Editor.
  • Salvar. Graba el sketch actual del Editor.
  • Guardar Como… Idéntico a la anterior opción, pero nos permite cambiar el nombre con el que queremos grabar el sketch.
  • Configurar Página. Nos permite configurar la página para la impresión.
  • Imprimir. Inicia la impresión el código fuente o sketch que actualmente tenemos en el Editor.
  • Preferencias. Desde esta pantalla podremos configurar algunas opciones que definirán el comportamiento del IDE. Estos ajustes podemos verlos en las imágenes siguientes (una pantalla por cada una de las dos lengüetas que hay en las Preferencias). Suelen ser comportamientos referentes al IDE (como por ejemplo, «Editor de Tamaño de Fuente» con la que elegimos el tamaño de letra de nuestro Editor) u opciones por defecto (como por ejemplo, «Localización de Proyecto» con la que definimos el directorio por defecto para trabajar con nuestros sketchs).

IDE Arduino Menu Archivo –> Preferencias –> Ajustes

IDE Arduino Menu Archivo –> Preferencias –> Red

  • Salir. Nos permite salir y cerrar el IDE Arduino de forma correcta y controlada.

Las opciones de los Menús, también pueden lanzarse directamente usando los atajos del teclado que figuran al lado de cada opción.
Por ejemplo, para crear un Nuevo Sketch podemos seleccionar la opción del Menú «Archivo –> Nuevo» vista anteriormente o pulsando la combinación del teclado «Control + N» (Tecla «Control» y tecla «n» o «N» simultáneamente).

 

Si desplegamos el Menú «Editar» veremos las opciones mostradas en la imagen siguiente

 


IDE Arduino, Menú Editar

 

En estas opciones del Menú no vamos a entrar al detalle en las diferentes acciones que contiene, pues son similares a las que podemos encontrar en cualquier editor de textos que estemos acostumbrados a utilizar y por lo tanto nos encontraremos familiarizados con las mismas.

Eligiendo el Menú «Programa« se muestran las opciones que figuran en la siguiente imagen

 


IDE Arduino, Menú Programa

A continuación, una breve descripción de algunas de las opciones que aparecen en este Menú. Por simplicidad, no vamos a detallar las opciones que no son relevantes para la realización de nuestros Proyectos.

  • Verificar / Compilar. Realiza la verificación sintáctica del programa o sketch cargado en el editor y su posterior compilación. Esta opción es la misma que la que vimos con anterioridad al explicar los Botones de la Barra de Herramientas.
  • Subir. Nos permite cargar nuestro sketch en la placa Arduino. De forma similar, esta opción es la misma que la que vimos en el Botón correspondiente de la Barra de Herramientas.
  • Mostrar Carpeta de Programa. Nos abre el Explorador de Archivos mostrando la Carpeta donde tenemos almacenado nuestro sketck.
  • Incluir Librería. Añade al código de nuestro sketch que tenemos cargado en el Editor las líneas de código necesarias para poder utilizar la librería seleccionada (los elementos #include). El empleo de las librerías nos permite reutilizar el código realizado por nosotros mismos o por un tercero y que en muchos casos sirve para facilitar el uso de ciertos componentes. De momento, no entraremos en más detalle en este punto, pero resulta muy útil a la hora de realizar nuestros Proyectos y lo veremos en profundidad en temas futuros del presente Curso.
  • Añadir fichero… Permite añadir el código de un fichero que contiene un sketch al sketch que tenemos actualmente en el Editor. Resulta una forma muy cómoda de reutilizar código de forma simple.

Eligiendo el Menú «Herramientas« veremos las siguientes opciones

 


IDE Arduino, Menú Herramientas
  • Auto Formato. Realiza una organización y ordenación del código fuente contenido en nuestro Editor, de tal forma que quede correctamente tabulado y por lo tanto más fácil de leer. Aunque es mejor construir el texto de forma metódica y organizada desde un inicio, a veces esta opción puede resultarnos útil cuando copiamos alguna rutina de la web o fichero con un formato estándar a nuestro Editor y el texto del mismo queda desorganizado. Prueba entonces con esta opción.
  • Archivo de Programa. Nos permite grabar el programa que tenemos en el Editor junto a todos los códigos fuente necesarios para el mismo en formato comprimido (.zip) de forma directa. Es una forma de archivar programas que no utilicemos mucho ocupando menos espacio o poderlos llevar a otro ordenador.
  • Administrar Bibliotecas… Nos mostrara el Gestor de Librerías desde donde podemos ver, borrar, actualizar, instalar las diferentes libreríaias disponibles para Arduino. Podemos ver una imagen de este Gestor de Librerías a continuación.

 


IDE Arduino, Menú Herramientas –> Administrar Bibliotecas (Gestor de Librerías)
  • Monitor Serie. Nos abre el Monitor Serie, que lo veremos con más detalle en el punto 3.7 de este mismo tema.
  • Serial Plotter. Nos permite una comunicación entre la placa Arduino y un Monitor Gráfico mediante el puerto Serie. Resulta similar al Monitor Serie, pero la comunicación en este caso no es bidireccional y en lugar de ser en Modo Texto, en esta ocasión es en Modo Gráfico. Fue incorporado a partir de la versión 1.6.6. del IDE de Arduino y mostraremos su uso en alguno de los Proyectos que realicemos.
  • Placa. Nos permite seleccionar el modelo de placa Arduino que tengamos conectado para nuestro Proyecto. Una vez seleccionado lo muestra en esta opción, como se ve en la Figura CAB3.11.
  • Puerto. Similar al anterior, pero para el puerto donde está conectada la placa Arduino.
  • Obtén información de la placa. Nos da información sobre la placa que tengamos conectada. Mostraría una pantalla similar a la siguiente

 


IDE Arduino, Menú Herramientas –> Obtén información de la placa
  • Programador. Si no utilizamos una placa o tarjeta Arduino y lo que queremos es grabar directamente el microcontrolador tendremos que seleccionar el programador que vamos a utilizar mediante esta opción. En nuestro caso no la vamos a utilizar para nuestros Proyectos, ya que trabajaremos siempre con una placa Arduino por comodidad.
  • Quemar Bootloader. Nos permite grabar la secuencia de inicio o Bootloader en el chip. Esta opción tampoco será relevante para nuestros Proyectos, pues no la utilizaremos.

Para finalizar, si elegimos el Menú «Ayuda« se nos mostrarán una serie de opciones de Ayuda que resultará interesante ir viendo para complementar nuestro aprendizaje. Os propongo que las vayáis investigando tranquilamente.

 


IDE Arduino, Menú Ayuda

 

Consola de Salida

 

La Consola de Salida nos muestra información importante y relevante mientras utilizamos y trabajamos con las opciones del IDE de Arduino.

Ya hemos visto algunas de las informaciones que se muestran por ella en la Figura 3.5 de este apartado, relativas a los errores sintácticos de nuestro sketch.

También información sobre su correcta compilación y subida a nuestra placa Arduino del sketch, así como posterior información de memoria usada, disponible, …

En definitiva es una zona que nos mostrará Información mientras operamos con el IDE.

De manera algo informal, podríamos decir, que es el área por la que el IDE se comunica con nosotros y debemos estar atentos a la información que se muestra en ella.

 

Barra de Información

 

Es otra parte informativa del IDE de Arduino, pero que nos da información sobre la placa Arduino, como por ejemplo el modelo que tenemos operativo y el puerto serie utilizado.

 

Monitor Serie

 

El Monitor Serie, como ya dijimos con anterioridad en el presente tema, nos permite la comunicación en tiempo real entre la placa Arduino y el dispositivo con el que estemos trabajando que normalmente será nuestro ordenador, portátil, Raspberri Py…

Además, esta comunicación es de carácter bidireccional, es decir, podremos mandar información desde el ordenador a la placa y también recibir información desde la placa al ordenador. Ambas acciones mediante el puerto serie por el que tengamos conectado el Arduino.

En la siguiente imagen podemos ver su aspecto

 


IDE Arduino, Monitor Serie

 

A continuación veremos las partes más relevantes del Monitor Serie y una breve explicación de las mismas

  • Arriba a la izquierda tenemos, con carácter informativo, el puerto donde se está conectada la placa Arduino, es decir, el puerto serie que vamos a utilizar para realizar la comunicación.
  • A continuación, disponemos de una línea de entrada, en la que podremos teclear los caracteres que queremos enviar a la placa Arduino mediante el Botón «Enviar» o directamente al pulsar la tecla ENTER.
  • La zona siguiente es la más amplia del Monitor Serie y nos mostrará los caracteres enviados desde la placa Arduino.
  • En la ultima sección del Monitor Serie vemos algunas acciones y configuraciones que podemos realizar, como elegir la velocidad de comunicación con el puerto serie de Arduino (por defecto, 9600 baudios pero tenemos la posibilidad de modificarla desplegando la lista y eligiendo otra velocidad entre las disponibles)…

Utilizaremos el Monitor Serie en muchos de nuestros Proyectos, ya que como verás, resulta muy útil esta comunicación bidireccional placa Arduino <<–>> PC.

 

Cargando Nuestro Primer Programa “Blink”

 

Es hora de comprobar que todo funciona correctamente. Para esto puedes ir al escritorio y ejecutar Arduino IDE desde el acceso directo.

 

 

Una vez termine de cargar conectas nuestra placa Arduino al ordenador y compruebas que el LED denotado como ON esté encendido.

Ahora abres el ejemplo blink, para esto es necesario ir a Archivos>Ejemplos>01.Basics>Blink.

 

Luego debes ir al menú Herramientas>Placa seleccionar el tipo de placa que vas a utilizar.

 

Lo siguiente es especificar el puerto empleado por el Arduino. Para esto tienes que ir al menú Herramientas>Puerto y seleccionar el puerto correspondiente al Arduino.

 

Ahora es necesario cargar el código al Arduino. Para esto haces clic en el botón subir y esperas unos pocos segundos a que el código se cargue.

 

 

Cuando el código se cargue totalmente se mostrará el mensaje Subido en la barra de estado. Ahora el LED del Arduino comenzará a pestañear dado que esto es lo que hace el ejemplo utilizado.

 

 


 

Proyecto 1 – Encender un LED

 

Este proyecto consiste en encender un LED conectado a una salida digital del Arduino y hacerlo parpadear a intervalos regulares. Es el proyecto más básico y fundamental para comenzar a trabajar con Arduino.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • 1 LED
    • Resistencia de 220 ohmios (para limitar la corriente del LED)
    • Cables macho-macho

Que es un led:

El LED está compuesto por dos partes, un material tipo N y un material tipo P; sin entrar mucho en detalles, el material tipo P lo podemos considerar como la parte positiva y el tipo N como la negativa (aunque no lo son realmente), entonces a la parte P le llamaremos Cátodo y a la parte N Ánodo:

 

 

Normalmente ubicamos las partes por el tamaño de las patitas, la más larga el positivo y la más corta el negativo, pero ¿qué pasaría si se cortan al mismo tamaño? Yo te recomiendo que te fijes en lo siguiente, todos los LEDs, tienen una muesca plana, esta indica la parte negativa (cátodo). O también puedes fijarte en el interior, la parte más grande es la negativa.

Cuando se le aplica una corriente en polarización en directa; es decir, de ánodo a cátodo, los electrones atraviesan la unión de ambos materiales desde el N al P, al ocurrir esto, los electrones liberan energía en forma de fotones, luz. Como la unión de ambos materiales está expuesta, se deja a la vista, por lo que siempre podrás observar que los LEDs tienen una capucha o cápsula transparente, entre más expuesta esté la unión, más luz podrá generar hacia el exterior. Este proceso se conoce como electroluminiscencia.

Entonces, para que un LED se comporte como conductor de electricidad, necesita que se le apliquen mas de 0.7 V en polarización directa, esto es, un voltaje de corriente directa, pero esto no significa que con esa cantidad de energía el LED desprenderá luz. Entonces, ¿cuánto voltaje necesita el LED para encender?

 

Cuánto voltaje necesitan los LEDs para encender:

 

Cuando se fabrican los LEDs, se manipulan los materiales tipo P y N para que cuando se le aplique una corriente específica, emitan luz en una longitud de onda específica, y esto para el ojo humano representa un color. Incluso se pueden fabricar LEDs que emitan luz en el rango no visible de la luz como el infrarrojo.

Entonces la cantidad de energía (voltaje) que se le debe aplicar a un LED para que emita luz va a depender del color. Puede variar entre 1.2 V y 3.2 V según el material, incluso hay LEDs que necesitan más. Es por esto que debemos averiguar si es posible, el fabricante y modelo para consultar su hoja de especificaciones técnicas y elegir correctamente el voltaje. Pero no te preocupes no es necesario ser tan preciso en nuestros diseños, ahorita te explico porqué.

La cantidad de luz que emite un LED depende no solo del voltaje, sino que depende de la corriente eléctrica que pasa a través de él. Si recibe más corriente, más luz; menos corriente, menos luz.

Aquí es importante hacer una pausa, ¿qué es voltaje y corriente? Quizá ya lo has escuchado, pero en términos básicos:

Voltaje es la cantidad de carga que se aplica a un circuito, y corriente es la velocidad con la que se aplica esa carga al circuito.

Volvamos al LED. ¿Cómo modifico la corriente para ajustar la luz? Bien fácil, con la ley universal de las ciencias eléctricas: la Ley de Ohm.

Esta ley dice que el voltaje es igual a la multiplicación de la corriente por la resistencia. Y la resistencia ya sabes que es la propiedad que tienen los materiales de oponerse a la corriente eléctrica. Esto se representa con la siguiente ecuación

 

 

donde V es el voltaje, I es la corriente y R es la resistencia

Por lo que si aumentamos el voltaje también aumentará la corriente si mantenemos la resistencia fija. O por el contrario, si mantenemos el voltaje fijo y bajamos la resistencia, la corriente aumenta.

Para controlar la corriente es necesario realizar algunos pequeños cálculos, ni te preocupes con la calculadora de tu celular es más que suficiente, nada del trinomio cuadrado perfecto de la escuela

Fíjate, necesitamos entonces dos cosas: una resistencia y una fuente de voltaje, normalmente la fuente de voltaje nosotros la proponemos.

Pero también tenemos que fijarnos si es de alta luminiscencia o baja, porque esto cambiará un poco. También tenemos que saber a cuánta corriente el LED emite la máxima luz. Puedes tomar como una referencia general, que el LED necesitará de 10mA (0.010 A) y alrededor de 2.5 V. Siguiendo el circuito mostrado en la imagen siguiente, es necesario agregar una resistencia y elegir su valor para asegurar los parámetros del LED.

Normalmente, nosotros elegimos el voltaje. Si estás alimentando tu circuito con una fuente de 5V (que es lo más típico) entonces la resistencia tendrá que ser:

 

 

La resta se debe a que en un circuito en serie, el voltaje de la fuente se reparte entre sus elementos, por lo tanto, el voltaje de la resistencia es 5 volts de la fuente «menos» 2.5 volts del LED.

Necesitamos una resistencia de 250 Ω (Ohms), pero esta resistencia no es tan fácil de conseguir, pero sí una de 220 Ω, que sería de los colores rojo, rojo y café. Esto nos dará una corriente real de

(11.36 mA), no importa que se pase un poco, no le pasará nada al LED, pero con esto aseguramos que el LED recibirá suficiente corriente para encender al máximo.

Si queremos que la intensidad del LED disminuya, entonces tendremos que aumentar la resistencia, para que disminuya la corriente.

Conexiones:

      1. Conecta el ánodo (el terminal más largo) del LED al pin digital 13 del Arduino.
      2. Conecta el cátodo (el terminal más corto) del LED a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

void setup() {
  pinMode(13, OUTPUT); // Configura el pin 13 como salida
}

void loop() {
  digitalWrite(13, HIGH);   // Enciende el LED
  delay(1000);               // Espera 1 segundo
  digitalWrite(13, LOW);    // Apaga el LED
  delay(1000);               // Espera 1 segundo
}

Explicación paso a paso del Código

    1. void setup(): Esta función se ejecuta una vez al inicio del programa. Configura el pin 13 como una salida digital, lo que significa que se utilizará para enviar señales de encendido o apagado.
    2. pinMode(13, OUTPUT);: Esta línea de código configura el pin 13 como una salida.
    3. void loop(): Esta función se ejecuta repetidamente después de que setup() ha finalizado. Aquí es donde se colocan las instrucciones que se repiten en bucle.
    4. digitalWrite(13, HIGH);: Esta línea de código establece el pin 13 en estado alto, lo que hace que el LED conectado a este pin se encienda.
    5. delay(1000);: Esta línea de código hace que el programa se detenga durante 1000 milisegundos (1 segundo).
    6. digitalWrite(13, LOW);: Esta línea de código establece el pin 13 en estado bajo, apagando el LED.
    7. delay(1000);: Esta línea de código hace que el programa se detenga durante otro segundo.
    8. Este ciclo se repite continuamente, encendiendo y apagando el LED a intervalos de un segundo.

Este proyecto es ideal para comenzar a familiarizarse con la programación de Arduino y es la base para proyectos más avanzados que implican el control de dispositivos electrónicos.

 

Proyecto 2 – Encender varios LEDs

 

En este proyecto, se conectarán varios LEDs a diferentes pines de salida del Arduino y se programarán para que parpadeen en secuencia. Es una extensión del proyecto anterior, pero esta vez con múltiples LEDs para crear efectos visuales más interesantes.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • 3 LEDs
    • Resistencias de 220 ohmios (una para cada LED)
    • Cables macho-macho

Conexiones:

    1. Conecta el ánodo (terminal largo) de cada LED a un pin digital diferente del Arduino (por ejemplo, pines 9, 10 y 11).
    2. Conecta el cátodo (terminal corto) de cada LED a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

void setup() {
  pinMode(9, OUTPUT); // Configura el pin 9 como salida para el primer LED
  pinMode(10, OUTPUT); // Configura el pin 10 como salida para el segundo LED
  pinMode(11, OUTPUT); // Configura el pin 11 como salida para el tercer LED
}

void loop() {
  digitalWrite(9, HIGH);   // Enciende el primer LED
  delay(500);               // Espera 0.5 segundos
  digitalWrite(9, LOW);    // Apaga el primer LED
  digitalWrite(10, HIGH);  // Enciende el segundo LED
  delay(500);               // Espera 0.5 segundos
  digitalWrite(10, LOW);   // Apaga el segundo LED
  digitalWrite(11, HIGH);  // Enciende el tercer LED
  delay(500);               // Espera 0.5 segundos
  digitalWrite(11, LOW);   // Apaga el tercer LED
}

Explicación paso a paso del Código:

    • void setup(): Configura los pines 9, 10 y 11 como salidas digitales en el Arduino.
    • pinMode(9, OUTPUT);, pinMode(10, OUTPUT);, pinMode(11, OUTPUT);: Estas líneas de código configuran los pines 9, 10 y 11 como salidas.
    • void loop(): En este bucle, se enciende y apaga cada LED en secuencia.
    • digitalWrite(9, HIGH);: Se enciende el primer LED conectado al pin 9.
    • delay(500);: Se espera medio segundo.
    • digitalWrite(9, LOW);: Se apaga el primer LED.
    • Este proceso se repite para los otros LEDs conectados a los pines 10 y 11, creando así una secuencia de parpadeo en los LEDs.

Este proyecto expande el concepto básico de encender un LED y te permite controlar múltiples LEDs en secuencia, lo que te brinda una mejor comprensión del control de salidas digitales en Arduino.

 

Proyecto 3 – Botón pulsador para encender y apagar un LED

 

En este proyecto, se utilizará un pulsador para controlar el encendido y apagado de un LED. Al presionar el pulsador, el LED se encenderá y permanecerá encendido hasta que se vuelva a presionar el pulsador, momento en el que se apagará.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • 1 LED
    • 1 Pulsador
    • Resistencia de 220 ohmios (para limitar la corriente del LED)
    • Resistencia de pull-down de 10k ohmios (para mantener el estado bajo del pin del pulsador cuando no se presiona)
    • Cables macho-macho

Conexiones:

    1. Conecta un extremo del pulsador a un pin digital del Arduino (por ejemplo, pin 2).
    2. Conecta el otro extremo del pulsador a tierra (GND) en la protoboard a través de una resistencia de pull-down de 10k ohmios.
    3. Conecta el ánodo (terminal largo) del LED a un pin digital del Arduino (por ejemplo, pin 13).
    4. Conecta el cátodo (terminal corto) del LED a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Para que sirve una resistencia de pull-down:

Una resistencia de pull-down es un componente electrónico que se utiliza para garantizar un valor de voltaje bajo (normalmente 0 voltios o “tierra”) en un pin de entrada digital cuando no está siendo activamente conducido por otro dispositivo.

Cuando un pin de entrada digital no está conectado a nada, puede flotar entre los estados alto (tensión alta, normalmente 5 voltios) y bajo (tensión baja, normalmente 0 voltios), lo que puede causar lecturas erráticas y comportamiento no deseado en el circuito.

La resistencia de pull-down se conecta entre el pin de entrada y tierra (GND). Cuando no hay ninguna otra fuente que active el pin, la resistencia de pull-down asegura que el pin esté en un estado bajo al proporcionar un camino hacia tierra para la corriente. Esto ayuda a estabilizar la lectura del pin y asegura un comportamiento predecible del circuito.

En el proyecto mencionado, la resistencia de pull-down se utiliza en conjunto con un pulsador para mantener el pin del Arduino en un estado bajo cuando el pulsador no está siendo presionado, evitando así que el pin flote y garantizando una lectura precisa cuando se presiona el pulsado

Código:

const int buttonPin = 2;     // Pin del pulsador
const int ledPin = 13;       // Pin del LED

int buttonState = 0;         // Variable para almacenar el estado del pulsador

void setup() {
  pinMode(ledPin, OUTPUT);   // Configura el pin del LED como salida
  pinMode(buttonPin, INPUT); // Configura el pin del pulsador como entrada
}

void loop() {
  buttonState = digitalRead(buttonPin); // Lee el estado del pulsador

  if (buttonState == HIGH) { // Si el pulsador está presionado
    digitalWrite(ledPin, HIGH); // Enciende el LED
  } else {
    digitalWrite(ledPin, LOW); // Apaga el LED
  }
}

Explicación paso a paso del Código:

    • const int buttonPin = 2;, const int ledPin = 13;: Declaramos dos constantes para los pines del pulsador y del LED.
    • int buttonState = 0;: Creamos una variable para almacenar el estado del pulsador.
    • void setup(): Configuramos el pin del LED como salida y el pin del pulsador como entrada.
    • pinMode(ledPin, OUTPUT);, pinMode(buttonPin, INPUT);: Configuramos los pines correspondientes.
    • void loop(): En cada iteración del bucle, leemos el estado del pulsador.
    • buttonState = digitalRead(buttonPin);: Leemos el estado del pin del pulsador.
    • if (buttonState == HIGH) { digitalWrite(ledPin, HIGH); }: Si el pulsador está presionado (estado alto), encendemos el LED; de lo contrario, lo apagamos.

Este proyecto demuestra cómo utilizar un pulsador para controlar el estado de un LED, lo que puede aplicarse a sistemas de control más complejos en proyectos futuros.

 

Proyecto 4 – Semáforo con LEDs

 

Este proyecto simula un semáforo de tráfico utilizando LEDs. Se programarán los LEDs para que sigan una secuencia típica de un semáforo: luz verde, luego amarilla y finalmente roja. Después de un tiempo, se repetirá la secuencia.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • 3 LEDs (verde, amarillo y rojo)
    • Resistencias de 220 ohmios (una para cada LED)
    • Cables macho-macho

Conexiones:

    1. Conecta el ánodo (terminal largo) del LED verde al pin digital 9 del Arduino.
    2. Conecta el ánodo del LED amarillo al pin digital 10.
    3. Conecta el ánodo del LED rojo al pin digital 11.
    4. Conecta el cátodo (terminal corto) de cada LED a través de su propia resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

void setup() {
  pinMode(9, OUTPUT); // Configura el pin 9 como salida para el LED verde
  pinMode(10, OUTPUT); // Configura el pin 10 como salida para el LED amarillo
  pinMode(11, OUTPUT); // Configura el pin 11 como salida para el LED rojo
}

void loop() {
  // Luz verde
  digitalWrite(9, HIGH);
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  delay(3000); // Espera 3 segundos

  // Luz amarilla
  digitalWrite(9, LOW);
  digitalWrite(10, HIGH);
  delay(1000); // Espera 1 segundo

  // Luz roja
  digitalWrite(10, LOW);
  digitalWrite(11, HIGH);
  delay(3000); // Espera 3 segundos
}

Explicación paso a paso del Código:

    • void setup(): Configura los pines 9, 10 y 11 como salidas digitales en el Arduino.
    • pinMode(9, OUTPUT);, pinMode(10, OUTPUT);, pinMode(11, OUTPUT);: Estas líneas de código configuran los pines correspondientes.
    • void loop(): En cada iteración del bucle, se establece una secuencia de luces para simular un semáforo.
    • En la secuencia:
      • El LED verde se enciende durante 3 segundos, mientras que los LEDs amarillo y rojo están apagados.
      • Luego, el LED amarillo se enciende durante 1 segundo, mientras que los LEDs verde y rojo están apagados.
      • Finalmente, el LED rojo se enciende durante 3 segundos, mientras que los LEDs verde y amarillo están apagados.
    • Después de la secuencia, el ciclo se repite indefinidamente, simulando así el funcionamiento continuo de un semáforo.

Este proyecto es un buen ejemplo de cómo usar Arduino para simular el funcionamiento de dispositivos del mundo real, como un semáforo, utilizando LEDs y controlando su estado con el código.

 

Proyecto 5 – Tutorial para el uso del Led RGB

 

En este proyecto, vamos a controlar un LED RGB para simular un efecto de arco iris, donde el color del LED cambia gradualmente a través de todo el espectro de colores.

Materiales:

  • Arduino Uno
  • Protoboard
  • LED RGB de ánodo común
  • Resistencias (para limitar la corriente del LED RGB)
  • Cables macho-macho

Conexiones:

  1. Conecta el ánodo común del LED RGB al pin digital 9 del Arduino.
  2. Conecta cada cátodo del LED RGB a través de una resistencia (por ejemplo, 220 ohmios) a los pines digitales 3, 5 y 6 del Arduino, que representarán los canales rojo, verde y azul, respectivamente.

Código:

#define RED_PIN 3
#define GREEN_PIN 5
#define BLUE_PIN 6
#define DELAY_TIME 10 // Tiempo de espera en milisegundos entre cada cambio de color

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  // Ciclo para cambiar gradualmente el color del LED RGB
  for (int i = 0; i < 256; i++) {
    analogWrite(RED_PIN, i);
    analogWrite(GREEN_PIN, 255 - i);
    analogWrite(BLUE_PIN, 0);
    delay(DELAY_TIME);
  }
  for (int i = 0; i < 256; i++) {
    analogWrite(RED_PIN, 255 - i);
    analogWrite(GREEN_PIN, 0);
    analogWrite(BLUE_PIN, i);
    delay(DELAY_TIME);
  }
  for (int i = 0; i < 256; i++) {
    analogWrite(RED_PIN, 0);
    analogWrite(GREEN_PIN, i);
    analogWrite(BLUE_PIN, 255 - i);
    delay(DELAY_TIME);
  }
}

 

Explicación del Código:

  • En el bucle principal loop(), utilizamos tres bucles for para cambiar gradualmente la intensidad de cada componente de color (rojo, verde y azul) del LED RGB.
  • Cada bucle incrementa o decrementa gradualmente la intensidad de uno de los componentes de color mientras el otro componente permanece apagado, lo que crea un efecto de cambio de color suave.
  • Utilizamos la función analogWrite() para controlar la intensidad de cada componente de color, con valores que van desde 0 (apagado) hasta 255 (máxima intensidad).
  • El tiempo de espera entre cada cambio de color está determinado por la variable DELAY_TIME, que se establece en 10 milisegundos en este caso.

Con este proyecto, el LED RGB simulará un efecto de arco iris cambiando gradualmente de color. Puedes ajustar el tiempo de espera o experimentar con diferentes patrones de cambio de color para obtener efectos interesantes.

 

Proyecto 6 – Usando el Potenciometro de 10K

 

Controlaremos el brillo de un LED utilizando un potenciómetro de 10K con Arduino.

Materiales:

  • Arduino Uno
  • Protoboard
  • LED
  • Resistencia (para limitar la corriente del LED)
  • Potenciómetro de 10K
  • Cables macho-macho

Conexiones:

  1. Conecta uno de los terminales del potenciómetro al pin analógico A0 del Arduino.
  2. Conecta el otro terminal del potenciómetro a GND del Arduino.
  3. Conecta el terminal central del potenciómetro a uno de los pines de la resistencia.
  4. Conecta el otro pin de la resistencia al pin digital 9 del Arduino.
  5. Conecta el cátodo (pin más corto) del LED al GND del Arduino.
  6. Conecta el ánodo (pin más largo) del LED a través de una resistencia (por ejemplo, 220 ohmios) al pin digital 9 del Arduino.

Código:

#define POTENTIOMETER_PIN A0
#define LED_PIN 9

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  int valorPotenciometro = analogRead(POTENTIOMETER_PIN);
  
  int brillo = map(valorPotenciometro, 0, 1023, 0, 255);
  
  analogWrite(LED_PIN, brillo);
}

 

Explicación del Código:

  • Leemos el valor del potenciómetro usando analogRead() para obtener un valor entre 0 y 1023.
  • Mapeamos este valor a un rango de 0 a 255, que es el rango de valores que podemos usar para el brillo del LED.
  • Luego, utilizamos analogWrite() para ajustar el brillo del LED según el valor del potenciómetro.

Con este proyecto, puedes controlar el brillo de un LED girando el potenciómetro y observar cómo cambia la intensidad de luz del LED.

 

Proyecto 7 – Controlar el Led RGB con el Potenciometro

 

Controlaremos un LED RGB con Arduino, permitiendo mezclar diferentes colores al ajustar la intensidad de cada componente rojo, verde y azul.

Materiales:

  • Arduino Uno
  • Protoboard
  • LED RGB de ánodo común
  • Resistencias (para limitar la corriente del LED)
  • Potenciómetro de 10K
  • Cables macho-macho

Conexiones:

  1. Conecta el ánodo común del LED RGB al pin digital 9 del Arduino.
  2. Conecta cada cátodo del LED RGB a través de una resistencia (por ejemplo, 220 ohmios) a los pines digitales 3, 5 y 6 del Arduino, que representarán los canales rojo, verde y azul, respectivamente.
  3. Conecta el potenciómetro al pin analógico A0 del Arduino.

Código:

#define RED_PIN 3
#define GREEN_PIN 5
#define BLUE_PIN 6
#define POTENTIOMETER_PIN A0

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  int valorPotenciometro = analogRead(POTENTIOMETER_PIN);
  
  int rojo = map(valorPotenciometro, 0, 1023, 0, 255);
  int verde = map(valorPotenciometro, 0, 1023, 0, 255);
  int azul = map(valorPotenciometro, 0, 1023, 0, 255);
  
  analogWrite(RED_PIN, rojo);
  analogWrite(GREEN_PIN, verde);
  analogWrite(BLUE_PIN, azul);
}

 

Explicación del Código:

  • Leemos el valor del potenciómetro usando analogRead() para obtener un valor entre 0 y 1023.
  • Mapeamos este valor a un rango de 0 a 255, que es el rango de valores que podemos usar para la intensidad de los colores.
  • Luego, utilizamos analogWrite() para ajustar la intensidad de cada color (rojo, verde y azul) en el LED RGB según el valor del potenciómetro.

Con este proyecto, puedes experimentar con diferentes colores ajustando el potenciómetro y ver cómo cambia la intensidad de cada componente de color en el LED RGB.

 

Proyecto 8 – Generador de tonos con buzzer

 

En este proyecto, utilizaremos un buzzer para generar diferentes tonos audibles controlados por Arduino. Esto nos permite crear efectos de sonido, alarmas o melodías simples según el código que escribamos.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Buzzer activo o pasivo
    • Resistencia de 220 ohmios (solo para buzzer pasivo)
    • Cables macho-macho

Conexiones:

    • Para un buzzer activo: Conecta el pin positivo del buzzer al pin digital 8 del Arduino y el pin negativo a tierra (GND) en la protoboard.
    • Para un buzzer pasivo: Conecta el pin positivo del buzzer al pin digital 8 del Arduino y el pin negativo a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

#define BUZZER_PIN 8 // Pin digital conectado al buzzer

void setup() {
  pinMode(BUZZER_PIN, OUTPUT); // Configura el pin del buzzer como salida
}

void loop() {
  tone(BUZZER_PIN, 1000); // Genera un tono de 1000 Hz en el buzzer
  delay(1000); // Espera 1 segundo
  noTone(BUZZER_PIN); // Detiene el tono
  delay(1000); // Espera 1 segundo
}

Explicación paso a paso del Código:

    • #define BUZZER_PIN 8: Definimos el pin digital al que está conectado el buzzer.
    • void setup(): Configura el pin del buzzer como una salida digital.
    • pinMode(BUZZER_PIN, OUTPUT);: Esta línea de código configura el pin del buzzer como salida.
    • void loop(): En cada iteración del bucle, se genera un tono y luego se detiene.
    • tone(BUZZER_PIN, 1000);: Esta función genera un tono en el buzzer con una frecuencia de 1000 Hz.
    • delay(1000);: Espera 1 segundo.
    • noTone(BUZZER_PIN);: Esta función detiene el tono en el buzzer.
    • Este ciclo se repite continuamente, generando un tono durante 1 segundo y luego deteniéndolo durante otro segundo.

Este proyecto es una introducción simple pero efectiva al uso de un buzzer con Arduino para generar tonos audibles. Puedes experimentar con diferentes frecuencias para crear una variedad de sonidos y melodías.

Melodias para probar:

Feliz Cumpleaños:

int melody[] = {
  NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_C5, NOTE_B4,
  NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_D5, NOTE_C5,
  NOTE_G4, NOTE_G4, NOTE_G5, NOTE_E5, NOTE_C5, NOTE_B4,
  NOTE_A4, NOTE_FS4, NOTE_FS4, NOTE_E4, NOTE_C5
};

int noteDurations[] = {
  4, 4, 2, 2, 2, 4,
  4, 4, 2, 2, 2, 4,
  4, 4, 2, 2, 2, 2,
  2, 2, 2, 2, 2
};

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  for (int i = 0; i < sizeof(melody) / sizeof(melody[0]); i++) {
    int duration = 1000 / noteDurations[i];
    tone(BUZZER_PIN, melody[i], duration);
    int pause = duration * 1.30;
    delay(pause);
    noTone(BUZZER_PIN);
    delay(50);
  }
  delay(10000); // Espera 10 segundos antes de reproducir la melodía nuevamente
}

La cucaracha:

int melody[] = {
  NOTE_C4, NOTE_E4, NOTE_G4, NOTE_C5, NOTE_C5, NOTE_C5,
  NOTE_A4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_E4, NOTE_G4,
  NOTE_A4, NOTE_A4, NOTE_G4, 0
};

int noteDurations[] = {
  8, 8, 8, 8, 8, 4,
  8, 8, 8, 8, 8, 4,
  8, 8, 8, 4
};

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  for (int i = 0; i < sizeof(melody) / sizeof(melody[0]); i++) {
    int duration = 1000 / noteDurations[i];
    tone(BUZZER_PIN, melody[i], duration);
    int pause = duration * 1.30;
    delay(pause);
    noTone(BUZZER_PIN);
    delay(50);
  }
  delay(10000); // Espera 10 segundos antes de reproducir la melodía nuevamente
}

Star Wars – Marcha Imperial:

int melody[] = {
  NOTE_G4, NOTE_G4, NOTE_G4, NOTE_DS5, NOTE_AS4, NOTE_G4, 0, NOTE_FS5,
  NOTE_FS5, NOTE_FS5, NOTE_F5, NOTE_DS5, NOTE_AS4, NOTE_F4, 0, NOTE_AS5,
  NOTE_AS4, NOTE_AS4, NOTE_A4, NOTE_FS5, NOTE_DS5, NOTE_AS4, NOTE_G4, 0,
  NOTE_G5, NOTE_G4, NOTE_G4, NOTE_G5, NOTE_FS5, NOTE_F5, NOTE_DS5, 0,
  NOTE_AS5, NOTE_A5, NOTE_G5, NOTE_FS5, NOTE_F5, NOTE_DS5, NOTE_AS4, NOTE_F4
};

int noteDurations[] = {
  8, 8, 8, 4, 8, 4, 4, 8,
  8, 8, 4, 8, 4, 4, 4, 8,
  8, 8, 4, 8, 4, 4, 4, 8,
  8, 8, 8, 4, 8, 4, 4, 4,
  8, 8, 8, 8, 8, 8, 8, 2
};

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  for (int i = 0; i < sizeof(melody) / sizeof(melody[0]); i++) {
    int duration = 1000 / noteDurations[i];
    tone(BUZZER_PIN, melody[i], duration);
    int pause = duration * 1.30;
    delay(pause);
    noTone(BUZZER_PIN);
    delay(50);
  }
  delay(10000); // Espera 10 segundos antes de reproducir la melodía nuevamente
}

Super Mario Bros – Tema Principal:

int melody[] = {
  NOTE_E7, NOTE_E7, 0, NOTE_E7, 0, NOTE_C7, NOTE_E7, 0,
  NOTE_G7, 0, 0,  0, NOTE_G6, 0, 0, 0,
  NOTE_C7, 0, 0, NOTE_G6, 0, 0, NOTE_E6, 0,
  0, NOTE_A6, 0, NOTE_B6, 0, NOTE_AS6, NOTE_A6, 0,
  NOTE_G6, NOTE_E7, NOTE_G7,
  NOTE_A7, 0, NOTE_F7, NOTE_G7, 0, NOTE_E7, 0, NOTE_C7, NOTE_D7,
  NOTE_B6, 0, 0,  NOTE_C7, 0, 0, NOTE_G6, 0,
  0, NOTE_E6, 0, 0, NOTE_A6, 0, NOTE_B6, 0,
  NOTE_AS6, NOTE_A6, 0, NOTE_G6, NOTE_E7, NOTE_G7,
  NOTE_A7, 0, NOTE_F7, NOTE_G7, 0, NOTE_E7, 0, NOTE_C7, NOTE_D7,
  NOTE_B6, 0, 0,  NOTE_C7, 0, 0, NOTE_G6, 0,
  0, NOTE_E6, 0, 0, NOTE_A6, 0, NOTE_B6, 0,
  NOTE_AS6, NOTE_A6, 0, NOTE_G6, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  NOTE_C4, NOTE_G3, NOTE_E3, NOTE_A3, NOTE_B3, NOTE_AS3, NOTE_A3, NOTE_G3,
  NOTE_E4, NOTE_G4, NOTE_A4, NOTE_F4, NOTE_G4, NOTE_E4, NOTE_C4, NOTE_D4,
  NOTE_B3, NOTE_G3, NOTE_E3, NOTE_A3, NOTE_B3, NOTE_AS3, NOTE_A3, NOTE_G3,
  NOTE_E4, NOTE_G4, NOTE_A4, NOTE_F4, NOTE_G4, NOTE_E4, NOTE_C4, NOTE_D4
};

int noteDurations[] = {
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4
};

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  for (int i = 0; i < sizeof(melody) / sizeof(melody[0]); i++) {
    int duration = 1000 / noteDurations[i];
    tone(BUZZER_PIN, melody[i], duration);
    int pause = duration * 1.30;
    delay(pause);
    noTone(BUZZER_PIN);
    delay(50);
  }
  delay(10000); // Espera 10 segundos antes de reproducir la melodía nuevamente
}

Proyecto 9 – Medidor de luz con LDR y LED

 

En este proyecto, utilizaremos un sensor de luz (LDR) para medir la intensidad de la luz ambiental y encenderemos un LED en función de la cantidad de luz detectada. Cuando la luz es intensa, el LED se apagará; cuando la luz es tenue, el LED se encenderá.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • LED
    • Sensor de luz LDR (Light Dependent Resistor)
    • Resistencia de 10k ohmios
    • Resistencia de 220 ohmios
    • Cables macho-macho

Conexiones:

    1. Conecta un extremo del LDR a 5V en la protoboard.
    2. Conecta el otro extremo del LDR a A0 en el Arduino.
    3. Conecta una resistencia de 10k ohmios desde A0 a GND en la protoboard.
    4. Conecta el ánodo (terminal largo) del LED a un pin digital del Arduino (por ejemplo, pin 9).
    5. Conecta el cátodo (terminal corto) del LED a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

const int ldrPin = A0; // Pin analógico conectado al LDR
const int ledPin = 9;  // Pin digital conectado al LED

void setup() {
  pinMode(ledPin, OUTPUT); // Configura el pin del LED como salida
}

void loop() {
  int lightLevel = analogRead(ldrPin); // Lee el valor analógico del LDR
  if (lightLevel < 500) { // Si la luz es tenue
    digitalWrite(ledPin, HIGH); // Enciende el LED
  } else { // Si la luz es intensa
    digitalWrite(ledPin, LOW); // Apaga el LED
  }
  delay(100); // Pequeña pausa para estabilizar las lecturas
}

Explicación paso a paso del Código:

    • const int ldrPin = A0;, const int ledPin = 9;: Definimos las constantes para los pines del LDR y del LED.
    • void setup(): Configuramos el pin del LED como salida digital.
    • pinMode(ledPin, OUTPUT);: Esta línea de código configura el pin del LED como salida.
    • void loop(): En cada iteración del bucle, leemos el valor analógico del LDR.
    • int lightLevel = analogRead(ldrPin);: Leemos el valor analógico del pin conectado al LDR.
    • Si la luz es tenue (lectura del LDR menor que 500), encendemos el LED; de lo contrario, lo apagamos.

Este proyecto te permite experimentar con la lectura de sensores analógicos y controlar dispositivos de salida (en este caso, un LED) en función de las lecturas del sensor.

Proyecto 10 – Temporizador con LED y botón

 

En este proyecto, utilizaremos un botón para controlar un temporizador que activará un LED durante un período específico de tiempo después de ser presionado el botón. Cuando se presione el botón, el LED se encenderá durante un tiempo determinado y luego se apagará automáticamente.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • LED
    • Botón pulsador
    • Resistencia de 10k ohmios
    • Resistencia de 220 ohmios
    • Cables macho-macho

Conexiones:

    1. Conecta un extremo del botón a un pin digital del Arduino (por ejemplo, pin 2).
    2. Conecta el otro extremo del botón a tierra (GND) en la protoboard.
    3. Conecta un resistor de 10k ohmios desde el pin del botón al voltaje de alimentación (5V).
    4. Conecta el ánodo (terminal largo) del LED a un pin digital del Arduino (por ejemplo, pin 9).
    5. Conecta el cátodo (terminal corto) del LED a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

const int buttonPin = 2; // Pin digital conectado al botón
const int ledPin = 9;    // Pin digital conectado al LED

void setup() {
  pinMode(buttonPin, INPUT);  // Configura el pin del botón como entrada
  pinMode(ledPin, OUTPUT);    // Configura el pin del LED como salida
}

void loop() {
  if (digitalRead(buttonPin) == HIGH) { // Si se presiona el botón
    digitalWrite(ledPin, HIGH); // Enciende el LED
    delay(5000); // Espera 5 segundos (temporizador)
    digitalWrite(ledPin, LOW); // Apaga el LED
  }
}

Explicación paso a paso del Código:

    • const int buttonPin = 2;, const int ledPin = 9;: Definimos las constantes para los pines del botón y del LED.
    • void setup(): Configuramos el pin del botón como entrada y el pin del LED como salida.
    • pinMode(buttonPin, INPUT);, pinMode(ledPin, OUTPUT);: Estas líneas de código configuran los pines correspondientes.
    • void loop(): En cada iteración del bucle, verificamos si se ha presionado el botón.
    • if (digitalRead(buttonPin) == HIGH) { ... }: Si se presiona el botón, encendemos el LED, esperamos 5 segundos y luego lo apagamos.

Este proyecto es un ejemplo de cómo utilizar un botón como disparador para activar una acción, en este caso, encender un LED durante un período de tiempo determinado. Puedes ajustar la duración del temporizador cambiando el valor en la función delay().

 

Proyecto 11 – Contador de pulsaciones de un botón

 

Este proyecto utiliza un botón para contar el número de veces que se presiona. Cada vez que se presiona el botón, se incrementa el contador y se muestra en el monitor serial.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Botón pulsador
    • Resistencia de 10k ohmios
    • Cables macho-macho

Conexiones:

    1. Conecta un extremo del botón a un pin digital del Arduino (por ejemplo, pin 2).
    2. Conecta el otro extremo del botón a tierra (GND) en la protoboard.
    3. Conecta un resistor de 10k ohmios desde el pin del botón al voltaje de alimentación (5V).

Código:

const int buttonPin = 2; // Pin digital conectado al botón
int buttonState = 0;     // Estado actual del botón
int buttonCounter = 0;   // Contador de pulsaciones

void setup() {
  pinMode(buttonPin, INPUT); // Configura el pin del botón como entrada
  Serial.begin(9600);        // Inicia la comunicación serial a 9600 baudios
  Serial.println("Presiona el botón para contar."); // Mensaje inicial en el monitor serial
}

void loop() {
  buttonState = digitalRead(buttonPin); // Lee el estado del botón

  // Si se detecta un flanco ascendente (presión del botón)
  if (buttonState == HIGH) {
    buttonCounter++; // Incrementa el contador
    Serial.print("Pulsaciones: "); // Imprime el número de pulsaciones
    Serial.println(buttonCounter);
    delay(250); // Pequeña pausa para evitar múltiples conteos por una sola pulsación
  }
}

Que es el monitor serial:

El monitor serial es una herramienta muy útil en el entorno de desarrollo de Arduino que te permite comunicarte con tu Arduino a través del puerto serial de tu computadora. Puedes enviar datos desde Arduino a tu computadora para su visualización y también enviar comandos desde tu computadora a Arduino

Como Acceder al monitor serial:

  1. Abrir el Entorno de Desarrollo de Arduino: Inicia el software de Arduino en tu computadora.
  2. Conectar Arduino a la Computadora: Asegúrate de que tu Arduino esté conectado a tu computadora a través del cable USB.
  3. Seleccionar el Puerto Serie: Ve al menú “Herramientas” y selecciona el puerto serie al que está conectado tu Arduino. En Windows, el puerto puede aparecer como COMx, y en macOS o Linux, puede aparecer como /dev/ttyUSBx o /dev/ttyACMx.
  4. Abrir el Monitor Serie: Ve al menú “Herramientas” nuevamente y selecciona “Monitor Serie” o presiona Ctrl + Mayús + M (en Windows) o Cmd + Mayús + M (en macOS). Esto abrirá una ventana en la que podrás ver los datos que tu Arduino envía a través del puerto serie.

Una vez que hayas abierto el monitor serial, verás los datos que tu Arduino envía. En el caso del proyecto anterior, verás el número de pulsaciones cada vez que presiones el botón.

El monitor serial es una herramienta invaluable para depurar y entender lo que está sucediendo en tu programa Arduino, ya que te permite ver datos en tiempo real mientras tu Arduino está en funcionamiento.

 

Explicación paso a paso del Código:

    • const int buttonPin = 2;: Definimos una constante llamada buttonPin y le asignamos el valor 2, que representa el pin al que está conectado el botón en el Arduino.
    • int buttonState = 0;, int buttonCounter = 0;: Declaramos dos variables, buttonState y buttonCounter, que utilizaremos para almacenar el estado actual del botón y contar el número de pulsaciones, respectivamente. Inicializamos buttonState con el valor 0 y buttonCounter con el valor 0.
    • void setup(): Esta función se ejecuta una vez al principio del programa. En esta parte del código:
      • pinMode(buttonPin, INPUT);: Configuramos el pin del botón como una entrada, lo que significa que estamos preparados para leer datos desde este pin.
      • Serial.begin(9600);: Iniciamos la comunicación serial a una velocidad de 9600 baudios. Esto establece una conexión entre el Arduino y el monitor serial en la computadora.
      • Serial.println("Presiona el botón para contar.");: Enviamos un mensaje inicial al monitor serial para indicar al usuario que debe presionar el botón para comenzar a contar las pulsaciones.
    • void loop(): Esta función se ejecuta continuamente en un bucle mientras el Arduino está encendido. En esta parte del código:
      • buttonState = digitalRead(buttonPin);: Leemos el estado del botón y almacenamos el resultado en la variable buttonState.
      • if (buttonState == HIGH) { ... }: Verificamos si el botón está siendo presionado. Si detectamos que el botón está presionado (es decir, si su estado es HIGH), ejecutamos el bloque de código dentro de los corchetes { ... }.
      • buttonCounter++;: Incrementamos el contador de pulsaciones.
      • Serial.print("Pulsaciones: ");, Serial.println(buttonCounter);: Imprimimos en el monitor serial el mensaje “Pulsaciones: ” seguido del valor actual del contador de pulsaciones.

 

Este proyecto es una introducción simple a la detección de pulsaciones de un botón y al uso de un contador para registrarlas. Puedes ampliar este proyecto agregando más funcionalidades, como la visualización del contador en un display LCD o la activación de acciones específicas al alcanzar cierto número de pulsaciones.

 

Proyecto 12 – Detector de obstáculos con sensor ultrasónico y LED

 

En este proyecto, utilizaremos un sensor ultrasónico para detectar la presencia de obstáculos en frente del Arduino. Cuando se detecta un obstáculo a una distancia cercana, un LED se encenderá para indicar la presencia del mismo.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • LED
    • Sensor ultrasónico HC-SR04
    • Resistencia de 220 ohmios
    • Resistencia de 10k ohmios
    • Cables macho-macho

Conexiones:

    1. Conecta el pin TRIG del sensor ultrasónico al pin digital 8 del Arduino.
    2. Conecta el pin ECHO del sensor ultrasónico al pin digital 9 del Arduino.
    3. Conecta el ánodo (terminal largo) del LED a un pin digital del Arduino (por ejemplo, pin 13).
    4. Conecta el cátodo (terminal corto) del LED a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Cómo funciona el sensor ultrasónico Arduino:

Para medir distancias con Arduino podemos hacerlo de diferentes maneras. Existen el sensor de infrarrojos, que utilizan las propiedades de la luz para calcular la distancia, y el sensor ultrasónico Arduino utiliza las propiedades de propagación del sonido para medir distancias. Más concreto utiliza los ultrasonidos. Este tipo de ondas sonoras se encuentran por encima del espectro audible por los seres humanos.

 

 

El funcionamiento es muy sencillo. El sensor envía una onda ultrasónica a través del disparador o trigger, rebota contra el objeto y el receptor o echo detecta la onda. Sabiendo cuánto ha tardado en viajar dicha onda, podemos saber la distancia.

 

Solo hace falta utilizar la famosa fórmula de la velocidad que aprendimos en el colegio.

v = \frac{s}{t}

Donde s es el espacio y t es el tiempo. Si despejamos es espacio que es lo que necesitamos saber, nos quedaría de la siguiente manera.

s = v \times t

La velocidad es conocida, el sonido viaja a 343 metros por segundo. El tiempo nos lo devolverá el propio sensor ultrasónico Arduino a través de la API de Arduino. Con todo esto ya podemos calcular a qué distancia se encuentra un objeto. [icon name=»lightbulb-o» class=»» unprefixed_class=»»] La velocidad del sonido es 343 m/s a una temperatura de 20ºC. La velocidad aumenta o disminuye 0,6 m/s por grado centígrado.

Código:

const int trigPin = 8;    // Pin digital conectado al pin TRIG del sensor ultrasónico
const int echoPin = 9;    // Pin digital conectado al pin ECHO del sensor ultrasónico
const int ledPin = 13;    // Pin digital conectado al LED

void setup() {
  pinMode(trigPin, OUTPUT); // Configura el pin TRIG como salida
  pinMode(echoPin, INPUT);  // Configura el pin ECHO como entrada
  pinMode(ledPin, OUTPUT);  // Configura el pin del LED como salida
  Serial.begin(9600);       // Inicia la comunicación serial a 9600 baudios
}

void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW);    // Establece el pin TRIG en bajo
  delayMicroseconds(2);          // Espera por lo menos 2 microsegundos
  digitalWrite(trigPin, HIGH);   // Establece el pin TRIG en alto
  delayMicroseconds(10);         // Espera por lo menos 10 microsegundos
  digitalWrite(trigPin, LOW);    // Establece el pin TRIG en bajo
  duration = pulseIn(echoPin, HIGH); // Lee la duración del pulso desde el pin ECHO
  distance = duration * 0.034 / 2;   // Calcula la distancia en centímetros
  if (distance < 20) {  // Si la distancia es menor a 20 cm
    digitalWrite(ledPin, HIGH); // Enciende el LED
    Serial.println("¡Cuidado! Obstáculo detectado."); // Muestra un mensaje en el monitor serial
  } else {
    digitalWrite(ledPin, LOW); // Apaga el LED
  }
  delay(200); // Pequeña pausa entre las lecturas
}

Explicación paso a paso del Código:

    • const int trigPin = 8;, const int echoPin = 9;, const int ledPin = 13;: Definimos las constantes para los pines del sensor ultrasónico (TRIG y ECHO) y del LED.
    • void setup() { ... }: En la función setup(), configuramos los pines TRIG y ECHO como salida y entrada respectivamente, el pin del LED como salida, y comenzamos la comunicación serial.
    • pinMode(trigPin, OUTPUT);, pinMode(echoPin, INPUT);, pinMode(ledPin, OUTPUT);, Serial.begin(9600);: Configuramos los pines y la comunicación serial.
    • void loop() { ... }: En la función loop(), realizamos la detección de obstáculos en un bucle continuo.
    • long duration, distance;: Declaramos variables para almacenar la duración del pulso ultrasónico y la distancia medida.
    • Se envía un pulso ultrasónico desde el pin TRIG y se mide el tiempo que tarda en recibir el eco a través del pin ECHO.
    • Se calcula la distancia en centímetros utilizando la fórmula adecuada.
    • Si la distancia es menor a 20 cm, se enciende el LED y se muestra un mensaje en el monitor serial indicando la detección del obstáculo. De lo contrario, el LED se apaga.

Este proyecto te permite construir un detector de obstáculos básico utilizando un sensor ultrasónico y un LED. El LED se encenderá cuando se detecte un obstáculo a una distancia inferior a 20 cm del sensor ultrasónico.

 

Proyecto 13 – Contador con display de 7 segmentos

 

En este proyecto, utilizaremos un display de 7 segmentos para mostrar un contador que aumenta su valor cada segundo. Este contador mostrará números de 0 a 9 y volverá a comenzar desde 0 cuando llegue a 9.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Display de 7 segmentos (cátodo común)
    • Resistencias de 220 ohmios (para limitar la corriente en los segmentos)
    • Resistencia de 1k ohmio (para limitar la corriente en el pin de habilitación)
    • Cables macho-macho

Que es un Display de 7 segmentos:

 

Un display 7 segmentos es un componente que tiene 7 segementos LEDs, más un LED que hará de punto. Este punto nos indica cómo hay que colocar el display, y siempre irá hacia abajo. Por lo tanto, debemos trabajar como si tuviéramos 7 LEDs conectados a nuestro Arduino.

 

 

Existen dos tipos de displays de 7 segmentos, los de ánodo común y los de cátodo común. Esto quiere decir que en los primeros, todos los LEDs comparten un mismo ánodo, y en los segundos, que todos los LEDs comparten un mismo cátodo. Veremos más adelante un esquema de cada uno de ellos y cómo identificarlos.

 

Relación pines del display de 7 segmentos con los LEDs

 

Dentro del datasheet del display de 7 segmentos que se descarga desde internet, encontrarás un dibujo parecido al que te muestro a continuación.

 

 

Identifica cada segmento LED con una letra. Así tenemos identificados cada uno de ellos. Este componente tiene 10 pines. Antes de hacer ninguna conexión debemos identificar los pines.

 

 

Ahora lo único que nos falta es asociar cada pin a cada segmento LED. En la siguiente imagen puedes ver esa relación.

 

 

Podemos resumir todo lo anterior en la siguiente tabla.

Pines Segmentos
1 e
2 d
4 c
6 b
7 a
9 f
10 g

¿Y qué pasa con el resto de pines? Nos quedan por saber qué hacer con los pines 3, 5 y 8. ¿Te acuerdas que hemos visto que hay un punto para indicar la orientación del display 7 segmentos?, pues este va conectado al pin número 5.

Los otros dos pines funcionarán como cátodo o ánodo, dependiendo del tipo de display de 7 segementos con el que estemos trabajando. Solo debemos utilizar una de esas dos conexiones, se trata de pines redundantes.

Al final, la tabla que relaciona los pines con los LEDs quedaría de la siguiente manera.

Pines Segmentos
1 e
2 d
3 ánodo/cátodo común
4 c
5 DP (punto)
6 b
7 a
8 ánodo/cátodo común
9 f
10 g

Bueno, pues ya tenemos relacionados los pines con los segmentos (circuito eléctrico interno), ahora vamos a ver cómo mostrar un número en el display de 7 segmentos.

 

Mostrando un número en el display 7 segmentos

 

Para poder mostrar un número en el display 7 segmentos, lo que tenemos que hacer es iluminar aquellos segmentos para formar dicho número. Por ejemplo, si queremos mostrar el 4, debemos activar los segmentos f, g, b y c y desactivar el resto de segmentos.

 

 

Como estos tienen una relación con los pines de Arduino, solo tendríamos que poner en estado alto (HIGH) o bajo (LOW) esos pines (en la siguiente sección veremos los tipos de displays que tenemos a nuestra disposición). Todo esto lo haremos a nivel de programación. En el ejemplo de código, podrás ver cómo se hace.

 

Ánodo común o cátodo común, los dos tipos de display de 7 segmentos

 

Un diodo funciona de una manera muy particular, solo permite fluir la corriente a través de él en un sentido, de ánodo a cátodo. Un LED no deja de ser un diodo con otra particularidad, que emite luz. Ya lo vimos en el ejemplo dónde creábamos un semáforo inteligente con múltiples LEDs.

Un display 7 segmentos funciona de la misma manera, vamos a tener ánodos y cátodos, en concreto 8. Veamos el esquema eléctrico de los dos tipos de displays.

 

 

En mi caso, tengo un display de cátodo común. Pero si no estamos seguros de qué tipo de display tenemos entre mano, podemos hacer una simple prueba.

 

¿Cómo saber el display 7 segmentos que tengo?

 

La prueba es sencilla. Para saber si es de ánodo común lo único que tenemos que hacer es poner el pin 3 o pin 8 a la alimentación de 3,3 V o 5 V (poner una resistencia de 220 Ω en serie, luego veremos porqué), y el pin número 5 (DP punto) a tierra (pin GND de nuestro Arduino).

Si lo que tenemos un display ánodo común, la corriente pasará y se iluminará el punto. Si tenemos un display del tipo cátodo común, no se encenderá el LED (recuerda que en un LED la corriente solo fluye en un único sentido).

 

Voltaje de operación del display de 7 segmentos

 

Ya por último, debemos conocer el voltaje de operación del componente. Esto deberíamos de verlo en la hoja de característica técnicas de cada modelo. Lo típico es que funcione entre 1,8 V y 2,2 V (funcionamiento normal de un LED). Utilizando la Ley de Ohm, podemos calcular la resistencia que necesitamos para los dos casos, el mínimo (1,8 V) y el máximo (2,2 V).

Para el voltaje de 1,8 V:

R = \frac{V}{I} = \frac{3,2V}{0,02A} = 160 \Omega

Para el voltaje de 2,2 V:

R = \frac{V}{I} = \frac{2,8V}{0,02A} = 140 \Omega

 

Conexiones:

    • Conecta cada pin del display de 7 segmentos a un pin digital del Arduino, utilizando resistencias de 220 ohmios en serie para limitar la corriente en los segmentos.
    • Conecta el pin de habilitación (común) del display a un pin digital del Arduino, utilizando una resistencia de 1k ohmio en serie para limitar la corriente.

Código:

// Define los pines del display de 7 segmentos
const int segmentA = 2;
const int segmentB = 3;
const int segmentC = 4;
const int segmentD = 5;
const int segmentE = 6;
const int segmentF = 7;
const int segmentG = 8;
const int segmentH = 9; // Habilitación (común) del display

// Define los patrones para cada dígito del display de 7 segmentos
byte digits[10] = {
  B11111100, // 0
  B01100000, // 1
  B11011010, // 2
  B11110010, // 3
  B01100110, // 4
  B10110110, // 5
  B10111110, // 6
  B11100000, // 7
  B11111110, // 8
  B11110110  // 9
};

int counter = 0; // Inicializa el contador en 0

void setup() {
  // Configura los pines del display de 7 segmentos como salida
  pinMode(segmentA, OUTPUT);
  pinMode(segmentB, OUTPUT);
  pinMode(segmentC, OUTPUT);
  pinMode(segmentD, OUTPUT);
  pinMode(segmentE, OUTPUT);
  pinMode(segmentF, OUTPUT);
  pinMode(segmentG, OUTPUT);
  pinMode(segmentH, OUTPUT);
}

void loop() {
  // Muestra el valor actual del contador en el display
  displayNumber(counter);
  // Incrementa el contador
  counter = (counter + 1) % 10;
  // Espera 1 segundo antes de mostrar el siguiente número
  delay(1000);
}

// Función para mostrar un número en el display de 7 segmentos
void displayNumber(int number) {
  // Apaga todos los segmentos
  digitalWrite(segmentA, LOW);
  digitalWrite(segmentB, LOW);
  digitalWrite(segmentC, LOW);
  digitalWrite(segmentD, LOW);
  digitalWrite(segmentE, LOW);
  digitalWrite(segmentF, LOW);
  digitalWrite(segmentG, LOW);
  // Habilita el display
  digitalWrite(segmentH, HIGH);
  // Muestra el patrón correspondiente al número
  byte pattern = digits[number];
  digitalWrite(segmentA, bitRead(pattern, 6));
  digitalWrite(segmentB, bitRead(pattern, 5));
  digitalWrite(segmentC, bitRead(pattern, 4));
  digitalWrite(segmentD, bitRead(pattern, 3));
  digitalWrite(segmentE, bitRead(pattern, 2));
  digitalWrite(segmentF, bitRead(pattern, 1));
  digitalWrite(segmentG, bitRead(pattern, 0));
}

 

Explicación paso a paso del Código:

    • Definimos los pines del Arduino a los que están conectados los segmentos del display de 7 segmentos y los patrones para cada dígito.
    • En la función setup(), configuramos los pines del display como salidas.
    • En el bucle loop(), mostramos el valor actual del contador en el display utilizando la función displayNumber() y luego incrementamos el contador.
    • La función displayNumber() enciende los segmentos correspondientes para mostrar el número dado en el display.

Este proyecto te permite crear un contador simple utilizando un display de 7 segmentos y el Arduino. El contador mostrará números del 0 al 9 y luego volverá a comenzar desde 0.

 

Proyecto 14 – Alarma de intrusión con sensor ultrasónico y buzzer

 

En este proyecto, crearemos una alarma de intrusión utilizando un sensor ultrasónico para detectar la presencia de intrusos. Cuando se detecte movimiento dentro de un rango específico, se activará un buzzer para emitir una señal de alarma.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Sensor ultrasónico HC-SR04
    • Buzzer activo o pasivo
    • Resistencia de 220 ohmios (si se usa un buzzer pasivo)
    • Resistencia de 10k ohmios
    • Cables macho-macho

Conexiones:

    1. Conecta el pin TRIG del sensor ultrasónico al pin digital 8 del Arduino.
    2. Conecta el pin ECHO del sensor ultrasónico al pin digital 9 del Arduino.
    3. Conecta el pin positivo del buzzer al pin digital 10 del Arduino.
    4. Conecta el pin negativo del buzzer a través de una resistencia de 220 ohmios a tierra (GND) en la protoboard.

Código:

const int trigPin = 8;    // Pin digital conectado al pin TRIG del sensor ultrasónico
const int echoPin = 9;    // Pin digital conectado al pin ECHO del sensor ultrasónico
const int buzzerPin = 10; // Pin digital conectado al buzzer

void setup() {
  pinMode(trigPin, OUTPUT); // Configura el pin TRIG como salida
  pinMode(echoPin, INPUT);  // Configura el pin ECHO como entrada
  pinMode(buzzerPin, OUTPUT); // Configura el pin del buzzer como salida
  Serial.begin(9600);       // Inicia la comunicación serial a 9600 baudios
}

void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW);    // Establece el pin TRIG en bajo
  delayMicroseconds(2);          // Espera por lo menos 2 microsegundos
  digitalWrite(trigPin, HIGH);   // Establece el pin TRIG en alto
  delayMicroseconds(10);         // Espera por lo menos 10 microsegundos
  digitalWrite(trigPin, LOW);    // Establece el pin TRIG en bajo
  duration = pulseIn(echoPin, HIGH); // Lee la duración del pulso desde el pin ECHO
  distance = duration * 0.034 / 2;   // Calcula la distancia en centímetros
  if (distance < 20) {  // Si la distancia es menor a 20 cm
    Serial.println("¡Intruso detectado!"); // Muestra un mensaje en el monitor serial
    // Activa el buzzer
    tone(buzzerPin, 1000); // Emite un tono de 1000 Hz
    delay(1000); // Espera 1 segundo
    noTone(buzzerPin); // Apaga el buzzer
    delay(1000); // Espera 1 segundo antes de volver a escanear
  }
}

 

Explicación paso a paso del Código:

    • Definimos los pines del Arduino a los que están conectados el sensor ultrasónico y el buzzer.
    • En la función setup(), configuramos los pines como entradas o salidas según corresponda y comenzamos la comunicación serial.
    • En el bucle loop(), realizamos la detección de intrusos.
    • Enviamos un pulso ultrasónico y medimos la distancia usando el sensor ultrasónico.
    • Si la distancia es menor a 20 cm (indicando la presencia de un intruso), emitimos un tono de alarma utilizando el buzzer durante 1 segundo.

Este proyecto te permite crear una alarma de intrusión simple utilizando un sensor ultrasónico y un buzzer con Arduino. Cuando se detecta movimiento dentro del rango especificado, el buzzer emite un tono de alarma para alertar sobre la presencia de un intruso.

 

Proyecto 15 – Secuencia de luces con LEDs y botones

 

En este proyecto, crearemos una secuencia de luces utilizando tres LEDs que parpadean en un patrón predefinido. Además, utilizaremos dos botones para controlar la dirección de la secuencia de luces.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • 3 LEDs de cualquier color
    • 3 resistencias de 220 ohmios (para limitar la corriente en los LEDs)
    • 2 pulsadores (botones)
    • Cables macho-macho

Conexiones:

    1. Conecta cada LED a un pin digital del Arduino a través de una resistencia de 220 ohmios en serie.
    2. Conecta los botones a dos pines digitales del Arduino.

Código:

// Define los pines de los LEDs y los botones
const int led1Pin = 2;
const int led2Pin = 3;
const int led3Pin = 4;
const int button1Pin = 5;
const int button2Pin = 6;

void setup() {
  // Configura los pines de los LEDs como salida
  pinMode(led1Pin, OUTPUT);
  pinMode(led2Pin, OUTPUT);
  pinMode(led3Pin, OUTPUT);
  // Configura los pines de los botones como entrada con resistencia pull-up
  pinMode(button1Pin, INPUT_PULLUP);
  pinMode(button2Pin, INPUT_PULLUP);
}

void loop() {
  // Lee el estado de los botones
  bool button1State = digitalRead(button1Pin);
  bool button2State = digitalRead(button2Pin);

  // Si se presiona el botón 1, activa la secuencia de luces hacia adelante
  if (!button1State) {
    forwardSequence();
  }
  // Si se presiona el botón 2, activa la secuencia de luces hacia atrás
  else if (!button2State) {
    backwardSequence();
  }
}

// Función para la secuencia de luces hacia adelante
void forwardSequence() {
  digitalWrite(led1Pin, HIGH);
  delay(100);
  digitalWrite(led1Pin, LOW);
  digitalWrite(led2Pin, HIGH);
  delay(100);
  digitalWrite(led2Pin, LOW);
  digitalWrite(led3Pin, HIGH);
  delay(100);
  digitalWrite(led3Pin, LOW);
}

// Función para la secuencia de luces hacia atrás
void backwardSequence() {
  digitalWrite(led3Pin, HIGH);
  delay(100);
  digitalWrite(led3Pin, LOW);
  digitalWrite(led2Pin, HIGH);
  delay(100);
  digitalWrite(led2Pin, LOW);
  digitalWrite(led1Pin, HIGH);
  delay(100);
  digitalWrite(led1Pin, LOW);
}

 

Explicación paso a paso del Código:

    • Definimos los pines del Arduino a los que están conectados los LEDs y los botones.
    • En la función setup(), configuramos los pines de los LEDs como salidas y los pines de los botones como entradas con resistencias pull-up internas.
    • En el bucle loop(), leemos el estado de los botones y ejecutamos la secuencia de luces correspondiente según el botón presionado.
    • Las funciones forwardSequence() y backwardSequence() controlan la secuencia de luces hacia adelante y hacia atrás respectivamente.

Este proyecto te permite crear una secuencia de luces controlada por dos botones. Al presionar un botón, la secuencia de luces avanza en una dirección, y al presionar el otro botón, la secuencia de luces retrocede en la dirección opuesta.

 

Proyecto 16 – Temporizador con botón y display de 7 segmentos

 

En este proyecto, utilizaremos un botón para iniciar un temporizador que mostrará el tiempo transcurrido en un display de 7 segmentos. El temporizador se detendrá cuando se presione nuevamente el botón.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Display de 7 segmentos (cátodo común)
    • Botón pulsador
    • Resistencia de 10k ohmios
    • Resistencias de 220 ohmios (para limitar la corriente en los segmentos)
    • Cables macho-macho

Conexiones:

    1. Conecta el pin de ánodo común del display de 7 segmentos a un pin digital del Arduino a través de una resistencia de 220 ohmios.
    2. Conecta cada pin de segmento del display a un pin digital del Arduino.
    3. Conecta un terminal del botón a un pin digital del Arduino y el otro terminal a tierra (GND) a través de una resistencia de 10k ohmios.

Código:

// Define los pines del display de 7 segmentos y el botón
const int segmentA = 2;
const int segmentB = 3;
const int segmentC = 4;
const int segmentD = 5;
const int segmentE = 6;
const int segmentF = 7;
const int segmentG = 8;
const int segmentH = 9; // Ánodo común del display
const int buttonPin = 10;

unsigned long startTime = 0; // Tiempo de inicio del temporizador
unsigned long elapsedTime = 0; // Tiempo transcurrido
boolean timerStarted = false; // Indicador de si el temporizador está en funcionamiento

void setup() {
  // Configura los pines del display como salida
  pinMode(segmentA, OUTPUT);
  pinMode(segmentB, OUTPUT);
  pinMode(segmentC, OUTPUT);
  pinMode(segmentD, OUTPUT);
  pinMode(segmentE, OUTPUT);
  pinMode(segmentF, OUTPUT);
  pinMode(segmentG, OUTPUT);
  pinMode(segmentH, OUTPUT);
  // Configura el pin del botón como entrada con resistencia pull-up
  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  // Lee el estado del botón
  boolean buttonState = digitalRead(buttonPin);

  // Si se presiona el botón, inicia o detiene el temporizador
  if (!buttonState) {
    if (!timerStarted) {
      startTime = millis(); // Guarda el tiempo de inicio
      timerStarted = true; // Marca el inicio del temporizador
    } else {
      timerStarted = false; // Detiene el temporizador
    }
  }

  // Si el temporizador está en funcionamiento, muestra el tiempo transcurrido
  if (timerStarted) {
    elapsedTime = millis() - startTime; // Calcula el tiempo transcurrido
    displayTime(elapsedTime); // Muestra el tiempo en el display de 7 segmentos
  }
}

// Función para mostrar el tiempo en el display de 7 segmentos
void displayTime(unsigned long time) {
  // Calcula los minutos y segundos
  unsigned long minutes = (time / 60000) % 60;
  unsigned long seconds = (time / 1000) % 60;

  // Muestra los minutos en el primer dígito y los segundos en el segundo dígito
  displayNumber(minutes, 1);
  displayNumber(seconds, 2);
}

// Función para mostrar un número en el display de 7 segmentos
void displayNumber(unsigned long number, int digit) {
  // Apaga todos los segmentos
  digitalWrite(segmentA, LOW);
  digitalWrite(segmentB, LOW);
  digitalWrite(segmentC, LOW);
  digitalWrite(segmentD, LOW);
  digitalWrite(segmentE, LOW);
  digitalWrite(segmentF, LOW);
  digitalWrite(segmentG, LOW);
  // Habilita el display
  digitalWrite(segmentH, HIGH);

  // Muestra el número en el display
  switch (number) {
    case 0:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentF, HIGH);
      break;
    case 1:
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      break;
    case 2:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 3:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 4:
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      break;
    case 5:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 6:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 7:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      break;
    case 8:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      break;
    case 9:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      break;
  }
  // Selecciona el dígito correspondiente
  digitalWrite(segmentH, digit == 1 ? LOW : HIGH);
}

 

Explicación paso a paso del Código:

    • Definimos los pines del Arduino a los que están conectados el display de 7 segmentos y el botón.
    • En la función setup(), configuramos los pines como entradas o salidas según corresponda y habilitamos las resistencias pull-up internas para el botón.
    • En el bucle loop(), leemos el estado del botón y controlamos el inicio y detención del temporizador.
    • Si el temporizador está en funcionamiento, calculamos el tiempo transcurrido y lo mostramos en el display de 7 segmentos utilizando la función displayTime().
    • La función displayTime() divide el tiempo transcurrido en minutos y segundos y muestra estos valores en el display utilizando la función displayNumber().

Este proyecto te permite crear un temporizador simple con un botón y un display de 7 segmentos. Al presionar el botón, el temporizador comenzará a contar, y al presionarlo nuevamente, el temporizador se detendrá y mostrará el tiempo transcurrido en el display.

 

Proyecto 17 – Contador de pulsaciones de un botón con display

 

En este proyecto, utilizaremos un botón para contar el número de veces que ha sido presionado. El número de pulsaciones se mostrará en un display de 7 segmentos.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Display de 7 segmentos (cátodo común)
    • Botón pulsador
    • Resistencia de 10k ohmios
    • Resistencias de 220 ohmios (para limitar la corriente en los segmentos)
    • Cables macho-macho

Conexiones:

    1. Conecta el pin de ánodo común del display de 7 segmentos a un pin digital del Arduino a través de una resistencia de 220 ohmios.
    2. Conecta cada pin de segmento del display a un pin digital del Arduino.
    3. Conecta un terminal del botón a un pin digital del Arduino y el otro terminal a tierra (GND) a través de una resistencia de 10k ohmios.

Código:

// Define los pines del display de 7 segmentos y el botón
const int segmentA = 2;
const int segmentB = 3;
const int segmentC = 4;
const int segmentD = 5;
const int segmentE = 6;
const int segmentF = 7;
const int segmentG = 8;
const int segmentH = 9; // Ánodo común del display
const int buttonPin = 10;

int buttonState = 0; // Estado actual del botón
int lastButtonState = 0; // Estado anterior del botón
int count = 0; // Contador de pulsaciones

void setup() {
  // Configura los pines del display como salida
  pinMode(segmentA, OUTPUT);
  pinMode(segmentB, OUTPUT);
  pinMode(segmentC, OUTPUT);
  pinMode(segmentD, OUTPUT);
  pinMode(segmentE, OUTPUT);
  pinMode(segmentF, OUTPUT);
  pinMode(segmentG, OUTPUT);
  pinMode(segmentH, OUTPUT);
  // Configura el pin del botón como entrada con resistencia pull-up
  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  // Lee el estado del botón
  buttonState = digitalRead(buttonPin);

  // Si el estado del botón ha cambiado
  if (buttonState != lastButtonState) {
    // Si el botón está presionado
    if (buttonState == LOW) {
      count++; // Incrementa el contador de pulsaciones
      displayNumber(count); // Muestra el contador en el display de 7 segmentos
    }
    delay(50); // Pequeña pausa para evitar rebotes
  }
  lastButtonState = buttonState; // Guarda el estado actual del botón para la próxima iteración
}

// Función para mostrar un número en el display de 7 segmentos
void displayNumber(int number) {
  // Apaga todos los segmentos
  digitalWrite(segmentA, LOW);
  digitalWrite(segmentB, LOW);
  digitalWrite(segmentC, LOW);
  digitalWrite(segmentD, LOW);
  digitalWrite(segmentE, LOW);
  digitalWrite(segmentF, LOW);
  digitalWrite(segmentG, LOW);
  // Habilita el display
  digitalWrite(segmentH, HIGH);

  // Muestra el número en el display
  switch (number) {
    case 0:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentF, HIGH);
      break;
    case 1:
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      break;
    case 2:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 3:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 4:
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      break;
    case 5:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 6:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      break;
    case 7:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      break;
    case 8:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentD, HIGH);
      digitalWrite(segmentE, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      break;
    case 9:
      digitalWrite(segmentA, HIGH);
      digitalWrite(segmentB, HIGH);
      digitalWrite(segmentC, HIGH);
      digitalWrite(segmentF, HIGH);
      digitalWrite(segmentG, HIGH);
      break;
  }
}

 

Explicación paso a paso del Código:

    • Definimos los pines del Arduino a los que están conectados el display de 7 segmentos y el botón.
    • En la función setup(), configuramos los pines como entradas o salidas según corresponda y habilitamos las resistencias pull-up internas para el botón.
    • En el bucle loop(), leemos el estado del botón y contamos las pulsaciones.
    • Si se detecta una pulsación del botón, incrementamos el contador y mostramos el número de pulsaciones en el display de 7 segmentos utilizando la función displayNumber().

Este proyecto te permite crear un contador de pulsaciones simple utilizando un botón y un display de 7 segmentos. Cada vez que se presiona el botón, el contador aumenta en uno y se muestra en el display.

 

Proyecto 18 – Distancia por el monitor Serial con el Ultrasonido

 

En este proyecto, utilizaremos un sensor ultrasónico para medir la distancia a un objeto y mostraremos esta distancia en centímetros en el monitor Serial de la computadora.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Sensor ultrasónico HC-SR04
    • Cables macho-macho

Conexiones:

    1. Conecta el pin TRIG del sensor ultrasónico al pin digital 8 del Arduino.
    2. Conecta el pin ECHO del sensor ultrasónico al pin digital 9 del Arduino.
    3. Conecta el pin VCC del sensor ultrasónico al pin 5V del Arduino.
    4. Conecta el pin GND del sensor ultrasónico al pin GND del Arduino.

Código:

// Definir pines del sensor ultrasónico
const int trigPin = 8;
const int echoPin = 9;

void setup() {
  // Inicializar el puerto serial
  Serial.begin(9600);
  
  // Configurar los pines del sensor ultrasónico
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  // Variables para almacenar la duración del pulso y la distancia
  long duration;
  int distance;

  // Generar un pulso corto en el pin TRIG
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Leer la duración del pulso desde el pin ECHO
  duration = pulseIn(echoPin, HIGH);

  // Calcular la distancia en centímetros
  distance = duration * 0.034 / 2;

  // Mostrar la distancia en el monitor Serial
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");

  // Esperar un breve periodo antes de la próxima lectura
  delay(100);
}

 

Explicación paso a paso del Código:

    • En el bloque setup(), inicializamos el puerto serial y configuramos los pines del sensor ultrasónico como entrada y salida según corresponda.
    • En el bucle loop(), generamos un pulso corto en el pin TRIG del sensor ultrasónico para activar la medición.
    • Luego, leemos la duración del pulso de eco desde el pin ECHO y calculamos la distancia en centímetros.
    • Finalmente, enviamos la distancia medida al monitor Serial para que sea visualizada en la computadora.

Este proyecto te permite medir y mostrar la distancia a un objeto utilizando un sensor ultrasónico y el monitor Serial. Cada vez que el Arduino realiza una medición, la distancia se muestra en centímetros en la ventana del monitor Serial.

 

Proyecto 19 – Cantidad de luz por el monitor serial con el LDR

 

En este proyecto, utilizaremos un Sensor de Resistor Dependiente de Luz (LDR) para medir la cantidad de luz en el entorno. Mostraremos esta cantidad de luz en el monitor Serial de la computadora.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Sensor de Resistor Dependiente de Luz (LDR)
    • Resistencia de 10k ohmios
    • Cables macho-macho

Conexiones:

    1. Conecta un extremo del LDR al pin A0 del Arduino.
    2. Conecta el otro extremo del LDR a 5V del Arduino.
    3. Conecta una resistencia de 10k ohmios del pin A0 a GND del Arduino.

Código:

// Definir el pin del LDR
const int ldrPin = A0;

void setup() {
  // Inicializar el puerto serial
  Serial.begin(9600);
}

void loop() {
  // Leer el valor del LDR
  int ldrValue = analogRead(ldrPin);

  // Mostrar el valor del LDR en el monitor Serial
  Serial.print("Valor del LDR: ");
  Serial.println(ldrValue);

  // Esperar un breve periodo antes de la próxima lectura
  delay(500);
}

 

Explicación paso a paso del Código:

    • En el bloque setup(), inicializamos el puerto serial.
    • En el bucle loop(), leemos el valor del LDR utilizando la función analogRead() que devuelve un valor entre 0 y 1023.
    • Luego, mostramos este valor en el monitor Serial utilizando Serial.print() y Serial.println().
    • Esperamos un breve período de tiempo antes de realizar la próxima lectura para evitar sobrecargar el puerto serial.

Este proyecto te permite medir la cantidad de luz en el entorno utilizando un Sensor de Resistor Dependiente de Luz (LDR) y el monitor Serial. Cada vez que el Arduino realiza una medición, el valor del LDR se muestra en la ventana del monitor Serial.

 

Proyecto 20 – Medir temperatura y humedad con el sensor DHT11

 

Utilizaremos el sensor DHT11 para medir la temperatura y la humedad del entorno y mostraremos estos valores en el monitor Serial.

Materiales:

    • Arduino Uno
    • Cable USB para Arduino
    • Protoboard 400 puntos
    • Sensor de temperatura y humedad DHT11
    • Cables macho-macho

Conexiones:

Conecta el pin de datos del DHT11 al pin digital 2 del Arduino.

Código:

#include <DHT.h>

#define DHTPIN 2     // Pin del sensor conectado al Arduino
#define DHTTYPE DHT11   // Definimos el tipo de sensor DHT

DHT dht(DHTPIN, DHTTYPE); // Inicializamos el sensor DHT

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  // Lectura de la humedad relativa
  float humedad = dht.readHumidity();
  // Lectura de la temperatura en grados Celsius
  float temperatura = dht.readTemperature();

  // Comprobamos si la lectura del sensor fue exitosa
  if (isnan(humedad) || isnan(temperatura)) {
    Serial.println("Fallo al leer el sensor DHT!");
    return;
  }

  // Mostramos la lectura en el monitor Serial
  Serial.print("Humedad: ");
  Serial.print(humedad);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print(temperatura);
  Serial.println(" *C");

  delay(2000); // Espera 2 segundos entre cada lectura
}

 

Explicación:

    • Incluimos la biblioteca DHT para facilitar la lectura del sensor DHT11.
    • Definimos el pin al que está conectado el sensor DHT11 y el tipo de sensor (DHT11 en este caso).
    • En la función setup(), iniciamos la comunicación serial y el sensor DHT11.
    • En el bucle loop(), leemos la humedad y la temperatura del sensor.
    • Verificamos si la lectura fue exitosa y, si lo fue, imprimimos los valores de humedad y temperatura en el monitor Serial.

Este proyecto te permite medir la temperatura y la humedad del entorno utilizando el sensor DHT11 y Arduino. Los valores se muestran en el monitor Serial, lo que te permite monitorear las condiciones del ambiente en tiempo real.

 

Proyecto 21 – Control de temperatura con el sensor DHT11

 

En este proyecto, utilizaremos el sensor DHT11 para medir la temperatura ambiente. Cuando la temperatura alcance un umbral específico, el buzzer emitirá un sonido para indicar que se ha alcanzado dicho nivel de temperatura.

Materiales:

  • Arduino Uno
  • Cable USB para Arduino
  • Protoboard 400 puntos
  • Sensor de temperatura y humedad DHT11
  • Buzzer
  • Resistencia de 220 ohmios (para limitar la corriente en el buzzer)
  • Cables macho-macho

Conexiones:

  1. Conecta el pin de datos del DHT11 al pin digital 2 del Arduino.
  2. Conecta el buzzer a un pin digital del Arduino (por ejemplo, pin 7).
  3. Conecta el otro pin del buzzer a través de una resistencia de 220 ohmios al GND del Arduino.

Código:

#include <DHT.h>

#define DHTPIN 2          // Pin del sensor DHT11 conectado al Arduino
#define DHTTYPE DHT11     // Definimos el tipo de sensor DHT
#define BUZZER_PIN 7      // Pin al que está conectado el buzzer

DHT dht(DHTPIN, DHTTYPE); // Inicializamos el sensor DHT

void setup() {
  Serial.begin(9600);
  dht.begin();
  pinMode(BUZZER_PIN, OUTPUT); // Configuramos el pin del buzzer como salida
}

void loop() {
  // Lectura de la temperatura en grados Celsius
  float temperatura = dht.readTemperature();

  // Comprobamos si la lectura del sensor fue exitosa
  if (!isnan(temperatura)) {
    Serial.print("Temperatura: ");
    Serial.println(temperatura);
    
    // Verificamos si la temperatura alcanza un umbral (por ejemplo, 25 grados Celsius)
    if (temperatura >= 25) {
      // Si se alcanza el umbral, hacemos sonar el buzzer
      digitalWrite(BUZZER_PIN, HIGH); // Encendemos el buzzer
      delay(500); // Mantenemos el sonido durante medio segundo
      digitalWrite(BUZZER_PIN, LOW); // Apagamos el buzzer
    }
  } else {
    Serial.println("Fallo al leer el sensor DHT!");
  }

  delay(2000); // Espera 2 segundos entre cada lectura
}

 

Explicación del Código:

  • El código inicializa el sensor DHT11 y el buzzer en el bloque setup().
  • En el bucle loop(), se lee la temperatura del sensor DHT11.
  • Si la lectura del sensor es exitosa y la temperatura alcanza el umbral (en este caso, 25 grados Celsius), el buzzer suena durante medio segundo.
  • Se utiliza digitalWrite() para encender y apagar el buzzer.

Con este proyecto, puedes utilizar únicamente un buzzer para indicar cuando la temperatura ambiente medida por el sensor DHT11 alcance un cierto umbral.

Proyecto 22 – Control de temperatura y humedad con el DHT11

En este proyecto, utilizaremos el sensor DHT11 para medir tanto la temperatura como la humedad ambiente. Vamos a controlar un dispositivo (por ejemplo, un ventilador o un humidificador) basado en los valores medidos de temperatura y humedad. Además, vamos a utilizar un buzzer para indicar cuando la temperatura alcanza un cierto umbral y un LED para indicar cuando la humedad supera otro umbral.

Materiales:

  • Arduino Uno
  • Cable USB para Arduino
  • Protoboard 400 puntos
  • Sensor de temperatura y humedad DHT11
  • Buzzer
  • LED
  • Resistencia de 220 ohmios (para limitar la corriente en el LED)
  • Cables macho-macho

Conexiones:

  1. Conecta el pin de datos del DHT11 al pin digital 2 del Arduino.
  2. Conecta el buzzer a un pin digital del Arduino (por ejemplo, pin 7).
  3. Conecta el LED a un pin digital del Arduino (por ejemplo, pin 13).
  4. Conecta el otro pin del buzzer a través de una resistencia de 220 ohmios al GND del Arduino.
  5. Conecta el cátodo (pin más corto) del LED al GND del Arduino.
  6. Conecta el ánodo (pin más largo) del LED a través de una resistencia de 220 ohmios a un pin digital del Arduino (por ejemplo, pin 13).

Código:

#include <DHT.h>

#define DHTPIN 2          // Pin del sensor DHT11 conectado al Arduino
#define DHTTYPE DHT11     // Definimos el tipo de sensor DHT
#define COMPONENT_PIN 8   // Pin al que está conectado el componente a controlar (por ejemplo, un ventilador)
#define BUZZER_PIN 7      // Pin al que está conectado el buzzer
#define LED_PIN 13        // Pin al que está conectado el LED

DHT dht(DHTPIN, DHTTYPE); // Inicializamos el sensor DHT

void setup() {
  Serial.begin(9600);
  dht.begin();
  pinMode(COMPONENT_PIN, OUTPUT); // Configuramos el pin del componente como salida
  pinMode(BUZZER_PIN, OUTPUT);    // Configuramos el pin del buzzer como salida
  pinMode(LED_PIN, OUTPUT);       // Configuramos el pin del LED como salida
}

void loop() {
  // Lectura de la temperatura y la humedad
  float temperatura = dht.readTemperature();
  float humedad = dht.readHumidity();

  // Comprobamos si la lectura del sensor fue exitosa
  if (!isnan(temperatura) && !isnan(humedad)) {
    Serial.print("Temperatura: ");
    Serial.print(temperatura);
    Serial.print(" °C, Humedad: ");
    Serial.print(humedad);
    Serial.println(" %");

    // Verificamos las condiciones de control para la temperatura
    if (temperatura >= 25) {
      digitalWrite(BUZZER_PIN, HIGH); // Encendemos el buzzer
    } else {
      digitalWrite(BUZZER_PIN, LOW); // Apagamos el buzzer
    }

    // Verificamos las condiciones de control para la humedad
    if (humedad >= 60) {
      digitalWrite(LED_PIN, HIGH); // Encendemos el LED
    } else {
      digitalWrite(LED_PIN, LOW); // Apagamos el LED
    }
  } else {
    Serial.println("Fallo al leer el sensor DHT!");
  }

  delay(2000); // Espera 2 segundos entre cada lectura
}

 

Explicación del Código:

  • El código inicializa el sensor DHT11, el buzzer y el LED en el bloque setup().
  • En el bucle loop(), se leen la temperatura y la humedad del sensor DHT11.
  • Si la temperatura supera los 25°C, se enciende el buzzer. Si no, se apaga.
  • Si la humedad supera el 60%, se enciende el LED. Si no, se apaga.

Con este proyecto, puedes controlar un dispositivo basado en la temperatura y la humedad ambiente medida por el sensor DHT11. Además, el buzzer y el LED te proporcionan indicaciones visuales y audibles cuando se alcanzan ciertos umbrales de temperatura y humedad.

 

Proyecto 23 – Dado electronico con Display de 7 Segmentos

 

En este proyecto, vamos a simular un dado electrónico utilizando un display de 7 segmentos y un Arduino Uno. Cada vez que se presione un botón, el Arduino generará un número aleatorio entre 1 y 6, y mostrará el resultado en el display de 7 segmentos.

Materiales:

  • Arduino Uno
  • Cable USB para Arduino
  • Protoboard 400 puntos
  • Display de 7 segmentos (cátodo común)
  • 7 resistencias de 220 ohmios
  • 1 botón pulsador
  • Cables macho-macho

Conexiones:

  1. Conecta el pin 2 del display de 7 segmentos (A) al pin digital 2 del Arduino.
  2. Conecta el pin 7 del display de 7 segmentos (B) al pin digital 3 del Arduino.
  3. Conecta el pin 6 del display de 7 segmentos (C) al pin digital 4 del Arduino.
  4. Conecta el pin 4 del display de 7 segmentos (D) al pin digital 5 del Arduino.
  5. Conecta el pin 3 del display de 7 segmentos (E) al pin digital 6 del Arduino.
  6. Conecta el pin 1 del display de 7 segmentos (F) al pin digital 7 del Arduino.
  7. Conecta el pin 5 del display de 7 segmentos (G) al pin digital 8 del Arduino.
  8. Conecta el pin 8 del display de 7 segmentos (punto decimal) al pin digital 9 del Arduino.
  9. Conecta un pin del botón pulsador a un pin digital del Arduino (por ejemplo, pin 10).
  10. Conecta el otro pin del botón pulsador a GND del Arduino.

Código:

// Definimos los pines del display de 7 segmentos
#define A 2
#define B 3
#define C 4
#define D 5
#define E 6
#define F 7
#define G 8
#define DP 9

// Pin del botón pulsador
#define BUTTON_PIN 10

void setup() {
  // Configuramos los pines del display como salida
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(DP, OUTPUT);
  
  // Configuramos el pin del botón como entrada
  pinMode(BUTTON_PIN, INPUT);
  
  // Inicializamos la comunicación serial
  Serial.begin(9600);
}

void loop() {
  // Verificamos si se presiona el botón
  if (digitalRead(BUTTON_PIN) == HIGH) {
    // Generamos un número aleatorio entre 1 y 6
    int numero = random(1, 7);
    mostrarNumero(numero);
    delay(1000); // Espera un segundo antes de mostrar el siguiente número
  }
}

void mostrarNumero(int numero) {
  // Configuramos los segmentos del display para mostrar el número correspondiente
  switch (numero) {
    case 1:
      mostrarSegmentos(0, 0, 1, 1, 0, 0, 0);
      break;
    case 2:
      mostrarSegmentos(1, 0, 0, 1, 1, 1, 1);
      break;
    case 3:
      mostrarSegmentos(0, 0, 0, 1, 1, 1, 1);
      break;
    case 4:
      mostrarSegmentos(1, 1, 0, 0, 1, 1, 0);
      break;
    case 5:
      mostrarSegmentos(0, 1, 0, 0, 1, 1, 1);
      break;
    case 6:
      mostrarSegmentos(1, 1, 0, 0, 0, 1, 1);
      break;
  }
}

void mostrarSegmentos(int a, int b, int c, int d, int e, int f, int g) {
  // Mostramos los segmentos correspondientes en el display
  digitalWrite(A, a);
  digitalWrite(B, b);
  digitalWrite(C, c);
  digitalWrite(D, d);
  digitalWrite(E, e);
  digitalWrite(F, f);
  digitalWrite(G, g);
}

 

Explicación del Código:

  • Se definen los pines del display de 7 segmentos y del botón pulsador.
  • En el setup(), se configuran los pines del display como salidas y el pin del botón como entrada.
  • En el loop(), se verifica si se presiona el botón. Si es así, se genera un número aleatorio entre 1 y 6 y se muestra en el display.
  • La función mostrarNumero() se encarga de mostrar el número correspondiente en el display de 7 segmentos.
  • La función mostrarSegmentos() se encarga de activar o desactivar los segmentos del display según el número a mostrar.

Con este proyecto, puedes simular un dado electrónico utilizando un display de 7 segmentos y un Arduino Uno. Cada vez que se presione el botón, se generará un número aleatorio entre 1 y 6 y se mostrará en el display.

 

Proyecto 24- Control de un LED RGB mediante el sensor de luz

 

En este proyecto, utilizaremos un sensor de luz (LDR) para detectar la intensidad de la luz ambiental y ajustar el brillo de un LED RGB en consecuencia. Cuando la luz ambiental es más intensa, el brillo del LED se atenuará, y cuando la luz ambiental es más tenue, el brillo del LED se incrementará.

Materiales:

  • Arduino Uno
  • Protoboard
  • LED RGB de ánodo común
  • Sensor de luz (LDR)
  • Resistencias (para limitar la corriente del LED RGB y del LDR)
  • Cables macho-macho

Conexiones:

  1. Conecta el ánodo común del LED RGB al pin digital 9 del Arduino.
  2. Conecta cada cátodo del LED RGB a través de una resistencia (por ejemplo, 220 ohmios) a los pines digitales 3, 5 y 6 del Arduino, que representarán los canales rojo, verde y azul, respectivamente.
  3. Conecta el LDR en una configuración de divisor de voltaje: un extremo del LDR se conecta a 5V, el otro extremo se conecta a GND a través de una resistencia (10k ohmios), y el punto medio se conecta al pin analógico A0 del Arduino.
  4. Conecta una resistencia (por ejemplo, 10k ohmios) entre el pin A0 y el GND del Arduino para evitar fluctuaciones de voltaje.

Código:

#define RED_PIN 3
#define GREEN_PIN 5
#define BLUE_PIN 6
#define LDR_PIN A0

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  int valorLDR = analogRead(LDR_PIN);
  
  // Mapear el valor del LDR a un rango de 0 a 255 (brillo del LED)
  int brillo = map(valorLDR, 0, 1023, 0, 255);
  
  analogWrite(RED_PIN, brillo);
  analogWrite(GREEN_PIN, brillo);
  analogWrite(BLUE_PIN, brillo);
}

 

Explicación del Código:

  • Leemos el valor del sensor de luz (LDR) utilizando analogRead() para obtener un valor entre 0 y 1023, que representa la intensidad de la luz ambiental.
  • Mapeamos este valor a un rango de 0 a 255, que es el rango de valores que podemos usar para el brillo del LED RGB.
  • Utilizamos analogWrite() para establecer el mismo brillo para los tres componentes de color (rojo, verde y azul) del LED RGB, lo que resulta en un cambio en la luminosidad general del LED según la intensidad de la luz ambiental.

Con este proyecto, el LED RGB ajustará automáticamente su brillo según la intensidad de la luz ambiental detectada por el sensor de luz (LDR).

Proyecto 25- Juego de memoria con LEDs

En este proyecto, vamos a crear un juego de memoria donde los LEDs se iluminarán en una secuencia aleatoria y el usuario deberá repetir esa secuencia presionando los botones correspondientes en el orden correcto. Cada vez que el usuario reproduce correctamente la secuencia, se agrega un nuevo LED a la secuencia y el juego continúa.

Materiales:

  • Arduino Uno
  • Protoboard
  • LEDs (al menos 4)
  • Resistencias (para limitar la corriente de los LEDs)
  • Botones pulsadores (al menos 4)
  • Cables macho-macho

Conexiones:

  1. Conecta los LEDs a los pines digitales del Arduino a través de resistencias para limitar la corriente.
  2. Conecta los botones pulsadores a los pines digitales del Arduino.

Código:

#define NUM_LEDS 4
#define NUM_BUTTONS 4

int leds[NUM_LEDS] = {2, 3, 4, 5};
int buttons[NUM_BUTTONS] = {6, 7, 8, 9};

int secuencia[NUM_LEDS];
int nivel = 0;
int indiceSecuencia = 0;

void setup() {
  for (int i = 0; i < NUM_LEDS; i++) {
    pinMode(leds[i], OUTPUT);
    digitalWrite(leds[i], LOW);
  }
  for (int i = 0; i < NUM_BUTTONS; i++) {
    pinMode(buttons[i], INPUT_PULLUP);
  }
  
  randomSeed(analogRead(0));
}

void loop() {
  if (nivel == 0) {
    generarSecuencia();
    nivel++;
  }
  
  mostrarSecuencia();
  reproducirSecuencia();
}

void generarSecuencia() {
  for (int i = 0; i < NUM_LEDS; i++) {
    secuencia[i] = random(0, NUM_LEDS);
  }
}

void mostrarSecuencia() {
  for (int i = 0; i <= nivel; i++) {
    digitalWrite(leds[secuencia[i]], HIGH);
    delay(500);
    digitalWrite(leds[secuencia[i]], LOW);
    delay(100);
  }
}

void reproducirSecuencia() {
  for (int i = 0; i <= nivel; i++) {
    while (digitalRead(buttons[secuencia[i]]) == HIGH) {}
    delay(100);
    while (digitalRead(buttons[secuencia[i]]) == LOW) {}
    delay(100);
  }
  nivel++;
}

 

Explicación del Código:

  • El juego tiene un número definido de LEDs y botones, especificados por las variables NUM_LEDS y NUM_BUTTONS.
  • En el bucle principal loop(), el juego genera una nueva secuencia si es el primer nivel, luego muestra la secuencia y espera a que el usuario la reproduzca.
  • La función generarSecuencia() crea una nueva secuencia aleatoria de LEDs que se iluminarán.
  • La función mostrarSecuencia() ilumina cada LED en la secuencia durante un breve período de tiempo para que el usuario pueda verla.
  • La función reproducirSecuencia() espera a que el usuario presione el botón correspondiente a cada LED en la secuencia, y avanza al siguiente nivel cuando el usuario reproduce correctamente la secuencia.

Con este proyecto, puedes crear un divertido juego de memoria utilizando LEDs y botones. ¡A medida que el jugador avanza en los niveles, la secuencia se vuelve más larga y desafiante!


Descubre más desde Electrogeek

Suscríbete y recibe las últimas entradas en tu correo electrónico.