Lo Último en IP@P
- Stellar Data Recovery revoluciona la recuperación de archivos perdidos en discos duros externos
- Goblin Mine: La Estrategia Económica Detrás del Juego de Minería que está Fascinando a Todos
- Estos son los nuevos Cargadores UGREEN: potencia y portabilidad en dos versiones que no te puedes perder
- UGREEN Nexode Pro: El Cargador Ultradelgado que revoluciona la carga de dispositivos móviles
- La computación en la nube está transformando los juegos Online y estas son sus grandes ventajas
Hoy en día son muchos los avances que se han creado referentes al área de electrónica y programación, uno de ellos es Arduino.
Arduino es creado en el 2003, y es un dispositivo que está siendo utilizado por estudiantes de las carreras: electrónica, programación y mecatrónica para poner en práctica sus conocimientos.
Son extraordinarios todos los avances que han tenido hasta el día de hoy y los que van a seguir teniendo, ya que, por ser un software y hardware libre, los estudiantes o aficionados de esta área están en la libertad de modificar el código y la placa Arduino, adaptándola de esta manera a los requerimientos de sus proyectos.
Conoce todas las placas Arduino desarrolladas hasta hoy que puedes comprar para aprender a desarrollar tus propios dispositivos
Antes de entrar al tema de las diferentes placas de Arduino que existen, es necesario, dar a conocer los conceptos básicos para familiarizarse de manera más rápida con el tema, ya que, a medida que avancemos lo veremos reflejado en la característica de cada placa.
Entre ellos se encuentran los siguientes:
- Microcontrolador: es un circuito integrado capaz de procesar información. Tiene diversas funciones, entre ellas controlar los elementos de entrada/salida, como en el caso de las computadoras.
- Voltaje de entrada: debería ser de 7 a 12V.
- Pines digitales: este tipo de pines reciben valores ya sea de 0v ó 5v.
- Pines analógicos: se pueden utilizar para leer valores de tensión de 0 a 5v, En Arduino cuenta con una notación de A0 a A5.
- Reloj de velocidad: las placas Arduino tienen una velocidad interna, a medida que se agregan más funciones, la velocidad del reloj va disminuyendo.
- Memoria flash: es la memoria del programa, su tamaño varía dependiendo del microcontrolador, unos pueden ser de 16kb mientras otros son de 32 kb. Al momento de desarrollar un programa hay que tomar en cuenta los tipos de variables, para utilizar la menor cantidad de memoria posible.
- Canales PWM: los canales de modulación de ancho pulso se utilizan para obtener resultados analógicos mediante medios digitales.
- Regulador de voltaje: estabiliza la corriente de salida, cumpliendo la función de convertir el voltaje para que pueda ser usado en los componentes electrónicos.
Placas Arduino desarrolladas hasta la actualidad
Conociendo lo que mencionamos anteriormente, procedemos a visualizar la lista de las diferentes placas Arduino desarrolladas hasta la actualidad:
ARDUINO UNO R3
![Original Arduino Uno Rev3 [A000066] Produced in Italy](https://m.media-amazon.com/images/I/41gu1v7dOsL._SL160_.jpg)
Es una de las placas más conocidas, y se caracteriza por contar con un microcontrolador ATmega328, su voltaje de entrada es igual o mayor que siete y puede llegar a un tope de doce voltios. También, la placa Arduino UNO se integra con 6 entradas analógicas, y 14 pines digitales de I/O. Entre todas sus cualidades las que más destacan es su memoria de 32 KB y su velocidad de 16 MHz en el reloj.
ARDUINO MEGA 2560 R3
Esta placa de Arduino, a diferencia de la anterior nos ofrece una mayor capacidad llegando hasta las 256 KB de memoria flash. Los voltajes de los controladores se mantienen, pero la cantidad de pines es mayor, siendo 54 de entrada/salida, donde 14 de ellos son PWM.
ARDUINO LEONARDO
LEONARDO es la placa Arduino, cuenta con un controlador adecuado para muchas programaciones, siendo su versión el ATmega32u4. Solo cuenta con 20 pines digitales de entrada/salida, del cual siete se utilizan como canales PWM y doce para ADCs. La velocidad de su reloj, permite la correcta ejecución de tareas sencillas, al igual que la capacidad de memoria flas de 32 KB. Esta placa puede ser la ideal para ti, si deseas poner en práctica tus conocimientos en programación.
ARDUINO DUE
![Arduino Due [A000062]](https://m.media-amazon.com/images/I/41HjT4c3QdL._SL160_.jpg)
Su micro controlado es AT91SAM3X8E, y cuenta con una memoria flas de 512 KB excelente para el uso de aplicaciones del usuario SRAM, esta capacidad puede ser amplificada debido que está integrada con dos bancos de seguridad, uno de 64 KB y otro de 32 KB. Esta placa Arduino Due es una de las más rápidas, ya que, su reloj cuenta con una velocidad de 84 MHz. En cuanto a pines, se integra con 54, del cual 12 son de salida PWM.
ARDUINO YÚN
![Arduino YUN REV2 [ABX00020]](https://m.media-amazon.com/images/I/4178Xzj+sJL._SL160_.jpg)
Arduino YÚN es una de las placas integradas con entradas de Micro USB y PoE 802.3af, siendo esta una de las tantas características que la convierte en una placa altamente recomendada para cualquier tipo de programación. Doce de cincuenta y cuatro pines de entrada y salida son PWM, y su memoria flash es de 32 KB, pero solo pueden utilizarse 28 KB, debido que 4 KB es de uso exclusivo para el bootloader.
ARDUINO PRO MINI 328, 5V, 16 MHz
Al igual que la placa Arduino mostrada anteriormente, cuenta con una conexión USB de placa, sumándole como característica única una tolerancia del 0.5% debido a su resonador externo de 16 HMz. El voltaje de salida es de máximo cinco voltios. Se recomienda por ser una placa protegida antes los peligros de voltaje o sobre intensidad, al igual que mantiene un escudo contra la inversión de polaridad.
ARDUINO ETHERNET
Esta placa Arduino cuenta con un micro controlador ATmga328, y un voltaje de cinco voltio para su correcta operación, su salida tiene de 7-12 voltios de conexión, y en su entrada de 6-20 voltios. Cada pin de entrada o salida debe usar cuando máximo 40 mA, y los pines de 3.3 50mA. Debido que es una placa que va orientada a las conexiones de Ethernet, se integra con un controlado W 5100 TCP/IP, con una memoria programable de 2 KB, y un 1 KB para el EEPROM.
ARDUINO NANO
Arduino NANO, contiene un micro controlador ATMega328, permitiéndonos utilizar una memoria de capacidad de 1 KB, aunque, su memoria flash es de solo 32 KB. Su reloj trabaja con una velocidad de frecuencia de 16 MHz, y sus dimensiones es de 0,73x1,70 pulgadas.
ARDUINO FIO
La estructura técnica de esta placa Arduino nos permite trabajar cómodamente cualquier programación. Su controlador o procesador trabaja a una frecuencia de 8 MHz, y resulta ser completamente compatible con baterías de polímero de litio. Se compone con un botón de Reset en caso de necesitar un reinicio de la placa, al igual que botones de encendido y apagado.
ARDUINO LYLIPAD 328
Más en Informática
- Plataformas Mobile ¿Qué son, para qué sirven y cuáles son las principales y más importantes a tener en cuenta?
- ¿Cómo escribir un texto al revés y girar las palabras y letras para darles un efecto espejo? Guía paso a paso
- Driver o controlador de dispositivos ¿Qué es, para que sirve y cómo funciona en informática?
- Memoria ROM ¿Qué es, para que sirve y que tipos hay en informática?
- ¿Cómo hacer una memoria USB Roba Datos para extraer información y contraseñas de un ordenador? Guía paso a paso
SÍGUENOS EN 👉 YOUTUBE TV
Para terminar con la lista de placas Arduino dejamos a Arduino LYLIPAD 328. Su nombre contiene los dígitos 328 debido que el micro controlador es el ATMega328V, el cual opera correctamente con una frecuencia de 8MHz. En cuanto a dimensiones, este tiene de diámetro externo 50 mm, y de espesor 0,8 mm. Es una de las placas más nuevas, por lo que integra un reset automático al detectar un colapso del sistema.
Los mejores proyectos Arduino que puedes hacer tu mismo para aprender a crear hardware libre
Crear un hardware libre no es una tarea imposible, lo primero es conocer cuál va a hacer la función del mismo, y el algoritmo para la programación.
Si todavía no tienes en cuenta qué proyecto hacer para aprender a crear en Arduino, a continuación te dejamos algunos proyectos sencillos y reconocidos:
Pulsador simple
Si estás iniciando en el área de la electrónica, puedes empezar con este proyecto, se basa en pulsar un interruptor para encender un led. De todos los proyectos que puedas encontrar, este es el más sencillo y fácil de utilizar. Un pulsador aunque parezca inútil, es el inicio de toda programación electrónica. Aprender a crear un pulsador como este, es la base iniciar adecuadamente en el mundo Arduino. Necesitarás una placa UNO, seis leds y seis interruptores para crear un pequeño piano de un octavo.
Los códigos que tendrás que escribir son:
#include "pitches.h"
const int buttonPin1 = 13 ; //C
const int buttonPin2 = 12 ; // CS
const int buttonPin3 = 11 ; //D
const int buttonPin4 = 10 ; // DS
const int buttonPin5 = 9 ; // E
const int buttonPin6 = 8 ; //F
const int buttonPin7 = 7 ; // FS
const int buttonPin8 = 6 ; //GRAMO
const int buttonPin9 = 5 ; // GS
const int buttonPin10 = 4 ; //A
const int buttonPin11 = 3 ; //COMO
const int buttonPin12 = 2 ; //B
const int buttonPin13 = 1 ; //C
const int dip1 = A0 ; // LSB, 1
const int dip2 = A1 ; // 2
const int dip3 = A2 ; // 3
const int dip4 = A3 ; // 4
const int dip5 = A4 ; // 5
const int dip6 = A5 ; // MSB, 6
int dip1state = 0 ;
int dip2state = 0 ;
int dip3state = 0 ;
int dip4state = 0 ;
int dip5state = 0 ;
int dip6state = 0;
int buttonState1 = 0;
int buttonState2 = 0;
int buttonState3 = 0;
int buttonState4 = 0;
int buttonState5 = 0;
int buttonState6 = 0;
int buttonState7 = 0;
int buttonState8 = 0;
int buttonState9 = 0;
int buttonState10 = 0;
int buttonState11 = 0;
int buttonState12 = 0;
int buttonState13 = 0;
void setup() {
pinMode(buttonPin1, INPUT);
pinMode(buttonPin2, INPUT);
pinMode(buttonPin3, INPUT);
pinMode(buttonPin4, INPUT);
pinMode(buttonPin5, INPUT);
pinMode(buttonPin6, INPUT);
pinMode(buttonPin7, INPUT);
pinMode(buttonPin8, INPUT);
pinMode(buttonPin9, INPUT);
pinMode(buttonPin10, INPUT);
pinMode(buttonPin11, INPUT);
pinMode(buttonPin12, INPUT);
pinMode(buttonPin13, INPUT);
pinMode(dip1, INPUT);
pinMode(dip2, INPUT);
pinMode(dip3, INPUT);
pinMode(dip4, INPUT);
pinMode(dip5, INPUT);
pinMode(dip6, INPUT);
}
void loop(){
// read the state of the pushbutton value:
buttonState1 = digitalRead(buttonPin1);
buttonState2 = digitalRead(buttonPin2);
buttonState3 = digitalRead(buttonPin3);
buttonState4 = digitalRead(buttonPin4);
buttonState5 = digitalRead(buttonPin5);
buttonState6 = digitalRead(buttonPin6);
buttonState7 = digitalRead(buttonPin7);
buttonState8 = digitalRead(buttonPin8);
buttonState9 = digitalRead(buttonPin9);
buttonState10 = digitalRead(buttonPin10);
buttonState11 = digitalRead(buttonPin11);
buttonState12 = digitalRead(buttonPin12);
buttonState13 = digitalRead(buttonPin13);
dip1state = digitalRead(dip1);
dip2state = digitalRead(dip2);
dip3state = digitalRead(dip3);
dip4state = digitalRead(dip4);
dip5state = digitalRead(dip5);
dip6state = digitalRead(dip6);
if (dip1state == LOW //00 or 19 in HEX; C4
&& dip2state == LOW
&& dip3state == LOW
&& dip4state == LOW
&& dip5state == LOW
&& dip6state == LOW
|| dip1state == HIGH
&& dip2state == LOW
&& dip3state == LOW
&& dip4state == HIGH
&& dip5state == HIGH
&& dip6state == LOW )
{ if (buttonState1 == LOW) {
tone(0, NOTE_C4);}
else if (buttonState2 == LOW) {
tone(0, NOTE_CS4);}
else if(buttonState3 == LOW) {
tone(0, NOTE_D4);}
else if(buttonState4 == LOW) {
tone(0, NOTE_DS4);}
else if(buttonState5 == LOW) {
tone(0, NOTE_E4);}
else if(buttonState6 == LOW) {
tone(0, NOTE_F4);}
else if(buttonState7 == LOW) {
tone(0, NOTE_FS4);}
else if(buttonState8 == LOW) {
tone(0, NOTE_G4);}
else if(buttonState9 == LOW) {
tone(0, NOTE_GS4);}
else if(buttonState10 == LOW) {
tone(0, NOTE_A4);}
else if(buttonState11 == LOW) {
tone(0, NOTE_AS4);}
else if(buttonState12 == LOW) {
tone(0, NOTE_B4);}
else if(buttonState13 == LOW) {
tone(0, NOTE_C5);}
else {
noTone(0); }
}
else if (dip1state == HIGH //01 in HEX; C2
&& dip2state == LOW
&& dip3state == LOW
&& dip4state == LOW
&& dip5state == LOW
&& dip6state == LOW)
{ if (buttonState1 == LOW) {
tone(0, NOTE_C2);}
else if (buttonState2 == LOW) {
tone(0, NOTE_CS2);}
else if(buttonState3 == LOW) {
tone(0, NOTE_D2);}
else if(buttonState4 == LOW) {
tone(0, NOTE_DS2);}
else if(buttonState5 == LOW) {
tone(0, NOTE_E2);}
else if(buttonState6 == LOW) {
tone(0, NOTE_F2);}
else if(buttonState7 == LOW) {
tone(0, NOTE_FS2);}
else if(buttonState8 == LOW) {
tone(0, NOTE_G2);}
else if(buttonState9 == LOW) {
tone(0, NOTE_GS2);}
else if(buttonState10 == LOW) {
tone(0, NOTE_A2);}
else if(buttonState11 == LOW) {
tone(0, NOTE_AS2);}
else if(buttonState12 == LOW) {
tone(0, NOTE_B2);}
else if(buttonState13 == LOW) {
tone(0, NOTE_C3);}
else {
noTone(0); }
}
else if (dip1state == LOW //02 in HEX; CS2
&& dip2state == HIGH
&& dip3state == LOW
&& dip4state == LOW
&& dip5state == LOW
&& dip6state == LOW)
{if (buttonState1 == LOW) {
tone(0, NOTE_CS2);}
else if (buttonState2 == LOW) {
tone(0, NOTE_D2);}
else if(buttonState3 == LOW) {
tone(0, NOTE_DS2);}
else if(buttonState4 == LOW) {
tone(0, NOTE_E2);}
else if(buttonState5 == LOW) {
tone(0, NOTE_F2);}
else if(buttonState6 == LOW) {
tone(0, NOTE_FS2);}
else if(buttonState7 == LOW) {
tone(0, NOTE_G2);}
else if(buttonState8 == LOW) {
tone(0, NOTE_GS2);}
else if(buttonState9 == LOW) {
tone(0, NOTE_A2);}
else if(buttonState10 == LOW) {
tone(0, NOTE_AS2);}
else if(buttonState11 == LOW) {
tone(0, NOTE_B2);}
else if(buttonState12 == LOW) {
tone(0, NOTE_C3);}
else if(buttonState13 == LOW) {
tone(0, NOTE_CS3);}
else {
noTone(0); }
}
//realiza los mismos pasos hasta llegar al 15 in GS3
else if (dip1state == HIGH // 15 in HEX; GS3
&& dip2state == LOW
&& dip3state == HIGH
&& dip4state == LOW
&& dip5state == HIGH
&& dip6state == LOW)
{ if (buttonState1 == LOW) {
tone(0, NOTE_GS3);}
else if (buttonState2 == LOW) {
tone(0, NOTE_A3);}
else if(buttonState3 == LOW) {
tone(0, NOTE_AS3);}
else if(buttonState4 == LOW) {
tone(0, NOTE_B3);}
else if(buttonState5 == LOW) {
tone(0, NOTE_C4);}
else if(buttonState6 == LOW) {
tone(0, NOTE_CS4);}
else if(buttonState7 == LOW) {
tone(0, NOTE_D4);}
else if(buttonState8 == LOW) {
tone(0, NOTE_DS4);}
else if(buttonState9 == LOW) {
tone(0, NOTE_E4);}
else if(buttonState10 == LOW) {
tone(0, NOTE_F4);}
else if(buttonState11 == LOW) {
tone(0, NOTE_FS4);}
else if(buttonState12 == LOW) {
tone(0, NOTE_G4);}
else if(buttonState13 == LOW) {
tone(0, NOTE_GS4);}
else {
noTone(0); }
}
else if (dip1state == LOW
&& dip2state == HIGH
&& dip3state == HIGH
&& dip4state == LOW
&& dip5state == HIGH
&& dip6state == LOW)
{ if (buttonState1 == LOW) {
tone(0, NOTE_A3);}
else if (buttonState2 == LOW) {
tone(0, NOTE_AS3);}
else if(buttonState3 == LOW) {
tone(0, NOTE_B3);}
else if(buttonState4 == LOW) {
tone(0, NOTE_C4);}
else if(buttonState5 == LOW) {
tone(0, NOTE_CS4);}
else if(buttonState6 == LOW) {
tone(0, NOTE_D4);}
else if(buttonState7 == LOW) {
tone(0, NOTE_DS4);}
else if(buttonState8 == LOW) {
tone(0, NOTE_E4);}
else if(buttonState9 == LOW) {
tone(0, NOTE_F4);}
else if(buttonState10 == LOW) {
tone(0, NOTE_FS4);}
else if(buttonState11 == LOW) {
tone(0, NOTE_G4);}
else if(buttonState12 == LOW) {
tone(0, NOTE_GS4);}
else if(buttonState13 == LOW) {
tone(0, NOTE_A4);}
else {
noTone(0); }
}
else if (dip1state == HIGH
&& dip2state == HIGH
&& dip3state == HIGH
&& dip4state == LOW
&& dip5state == HIGH
&& dip6state == LOW)
{ if (buttonState1 == LOW) {
tone(0, NOTE_AS3);}
else if (buttonState2 == LOW) {
tone(0, NOTE_B3);}
else if(buttonState3 == LOW) {
tone(0, NOTE_C4);}
else if(buttonState4 == LOW) {
tone(0, NOTE_CS4);}
else if(buttonState5 == LOW) {
tone(0, NOTE_D4);}
else if(buttonState6 == LOW) {
tone(0, NOTE_DS4);}
else if(buttonState7 == LOW) {
tone(0, NOTE_E4);}
else if(buttonState8 == LOW) {
tone(0, NOTE_F4);}
else if(buttonState9 == LOW) {
tone(0, NOTE_FS4);}
else if(buttonState10 == LOW) {
tone(0, NOTE_G4);}
else if(buttonState11 == LOW) {
tone(0, NOTE_GS4);}
else if(buttonState12 == LOW) {
tone(0, NOTE_A4);}
else if(buttonState13 == LOW) {
tone(0, NOTE_AS4);}
else {
noTone(0); }
}
else if (dip1state == LOW
&& dip2state == LOW
&& dip3state == LOW
&& dip4state == HIGH
&& dip5state == HIGH
&& dip6state == LOW)
{ if (buttonState1 == LOW) {
tone(0, NOTE_B3);}
else if (buttonState2 == LOW) {
tone(0, NOTE_C4);}
else if(buttonState3 == LOW) {
tone(0, NOTE_CS4);}
else if(buttonState4 == LOW) {
tone(0, NOTE_D4);}
else if(buttonState5 == LOW) {
tone(0, NOTE_DS4);}
else if(buttonState6 == LOW) {
tone(0, NOTE_E4);}
else if(buttonState7 == LOW) {
tone(0, NOTE_F4);}
else if(buttonState8 == LOW) {
tone(0, NOTE_FS4);}
else if(buttonState9 == LOW) {
tone(0, NOTE_G4);}
else if(buttonState10 == LOW) {
tone(0, NOTE_GS4);}
else if(buttonState11 == LOW) {
tone(0, NOTE_A4);}
Dado electrónico
Si eres aficionado a los juegos de mesa, este proyecto es para ti, ya que, se trata de crear un dado electrónico, con una placa de Arduino UNO. El dado está formado por 7 leds, que a medida que el usuario presione el pulsador, se van a poder visualizar los numero del 1 al 6, de manera aleatoria.
Las instrucciones que tendrás que agregar al IDE son:
// Definición de pines LED
int ledPins [ 7 ] = { 2 , 3 , 4 , 5 , 6 , 7 , 8 };
int dicePatterns [ 7 ] [ 7 ] = {
{ 0 , 0 , 0 , 0 , 0 , 0 , 1 }, // 1
{ 0 , 0 , 1 , 1 , 0 , 0 , 0 }, // 2
{ 0 , 0 , 1 , 1 , 0 , 0 , 1 }, // 3
{ 1 , 0 , 1 , 1 , 0 , 1 , 0 }, // 4
{ 1 , 0 , 1 , 1 , 0 , 1 , 1 }, // 5
{ 1 , 1 , 1 , 1 , 1 , 1 , 0 }, // 6
{ 0 , 0 , 0 , 0 , 0 , 0 , 0 } // En blanco
};
int switchPin = 9 ; // Definición de pin de botón
int blanco = 6 ;
configuración vacía ()
{
para ( int i = 0 ; i < 7 ; i ++ )
{
pinMode ( ledPins [ i ], SALIDA );
digitalWrite ( ledPins [ i ], BAJO );
}
randomSeed(analogRead(0));
}
void loop()
{
if (digitalRead(switchPin))
{
rollTheDice();
}
delay(100);
}
void rollTheDice()
{
int result = 0;
int lengthOfRoll = random(15, 25);
for (int i = 0; i < lengthOfRoll; i++)
{
result = random(0, 6);
show(result);
delay(50 + i * 10);
}
for (int j = 0; j < 3; j++)
{
show(blank);
delay(500);
show(result);
delay(500);
}
}
void show(int result)
{
para ( int i = 0 ; i < 7 ; i ++ )
{
digitalWrite ( ledPins [ i ], dicePatterns [ resultado ] [ i ]);
}
}
Rastreador de luz
Este proyecto se base en un rastreador/seguidor de luz simple, está compuesto por dos fotorresistencias (componente sensible a la luz) que tiene un papel fundamental en el proyecto. Si este detecta la luz, se moverá por medio de un servo.
Para que funcione tendrás que programar la placa Nano R3 con las siguientes instrucciones:
#include <Servo.h>
Servo myServoEW ;
Servo myServoNS ;
int farkNS ;
int farkEW ;
int degNS ;
int degEW ;
int ldrN ;
int ldrW ;
int ldrS ;
int ldrE ;
configuración vacía () {
// Escribe a continuación tu código de configuración
begin ( 115200 ) ;
attach ( 5 ) ;
attach ( 4 ) ;
retraso ( 500 ) ;
degNS=90;
degEW=90;
write(degNS);
write(degEW);
}
void loop() {
ldrN=analogRead(A0);
ldrW=analogRead(A1);
ldrS=analogRead(A2);
ldrE=analogRead(A3);
print("ldrN:");
print(ldrN);
print(" ldrW:");
print(ldrW);
print(" ldrS:");
print(ldrS);
print(" ldrE:");
print(ldrE);
print(" degEW");
print(degEW);
print(" degNS");
println(degNS);
delay(100);
if (ldrN>ldrS)
{
farkNS=ldrN-ldrS;
if (farkNS>5)
{
degNS++;
write(degNS);
}
}
if (ldrS>ldrN)
{
farkNS=ldrS-ldrN;
if (farkNS>5)
{
degNS--;
write(degNS);
}
}
if (ldrW>ldrE)
{
farkEW=ldrW-ldrE;
if (farkEW>5)
{
degEW++;
write(degEW);
}
}
if ( ldrE> ldrW )
{
farkEW = ldrE-ldrW ;
si ( farkEW> 5 )
{
degEW-- ;
write ( degEW ) ;
}
}
}
Comprueba la luz del ambiente
Si quiere saber el nivel de sonido y de luz que hay en lugar podrás elegir Arduino. Este tipo de proyecto es el indicado para conocer si el ruido y la iluminación son óptimas para los parámetros establecidos. Se enciende el led verde, y a medida que van disminuyendo se encenderá el led amarillo y rojo.
Configura tu Arduino UNO con los siguientes códigos:
const int ledCount = 12; // numero de leds
int sensorReading; // lectura del ADC 0-1024
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
void setup() {
begin(9600); //inicamos el puerto Serial
for (int thisLed = 0; thisLed < ledCount; thisLed++) {pinMode(ledPins[thisLed], OUTPUT);}
}
void loop() {
sensorReading = analogRead(A1);
println(sensorReading);
int ledLevel = map(sensorReading, 200,500, 0, ledCount);
for (int thisLed = 0; thisLed < ledCount; thisLed++) {
if (thisLed < ledLevel) {
digitalWrite(ledPins[thisLed], HIGH);// encendemos los LED segun la intensidad de la señal
}
else {
digitalWrite(ledPins[thisLed], LOW);// apagamos los LED segun la intensidad de la señal
}
}
delay(10);
}
Proyecto Halloween
Una calavera para divertirse en el día de halloween muy sencillo y entretenido, los componentes a utilizar son: 1 servomotor en el interior de la caja, 1 sensor infrarrojos, este último se encarga de detectar se existe algún objeto en la caja, en caso de ser afirmativo la caja se cerrará con la ayuda del servomotor.
Para llevar adelante este proyecto necesitarás agregar las siguientes órdenes en el IDE de Arduino:
importar transmisiones
de floyd.rtttl importar rtttl
importar subprocesos
# importar módulo toishield
de toishield importar toishield
# importar módulo neopixel
de neopixel importar ledstrips como neo
arroyos . serial ()
# establecer detección habilitada y calabaza inactiva de forma predeterminada
toishield . micrófono . detecciónEnabled = Verdadero
toishield . micrófono . activePumpkin = Falso
# establecer alguna variable para la detección de sonido
toishield . micrófono . staticMin = 4096
toishield . micrófono . staticMax = - 4096
toishield . micrófono . resetMinMaxCounter = 0
# ¡Declare que los leds parpadeen!
leds = neo . ledstrip ( toishield . led_pin , 16 )
setall(0,0,0)
on()
# semaphore initialized to 0 -> red: if a thread tries to acquire the semaphore
# it blocks if the semaphore has not been turned 'green' (released)
semaphore = threading.Semaphore(0)
# define a RTTTL Halloween melody to be played by passing it the RTTTL string.
hsong = rtttl.tune('Halloween:d=4,o=5,b=180:8d6,8g,8g,8d6,8g,8g,8d6,8g,8d#6,8g,8d6,8g,8g,8d6,8g,8g,8d6,8g,8d#6,8g,8c#6,8f#,8f#,8c#6,8f#,8f#,8c#6,8f#,8d6,8f#,8c#6,8f#,8f#,8c#6,8f#,8f#,8c#6,8f#,8d6,8f#')
# toishield.buzzer_pin=D9.PWM
def blink():
# blink while the pumpkin is active
while toishield.microphone.activePumpkin:
setall(255,0,0)
on()
sleep(500)
setall(255,140,0)
on()
sleep(500)
setall(0,0,0)
on()
release()
def playHalloween():
# plays halloween song two times, then disables pumpkin, but also waits
# at the semaphore to synchronize with blinking thread
for i in range(2):
play(toishield.buzzer_pin)
microphone.activePumpkin = False
acquire()
sleep(1000)
print("enabled again")
microphone.detectionEnabled = True
def scare():
# this is called when the sound exceeds the threshold, waits one second
# and starts scaring!
sleep(1000)
thread(playHalloween)
thread(blink)
# define a function that takes a sensor object as parameter and checks the
# maximum peak to peak extension of the signal in a preset window
# look at this
# example for details on how the sound detector works
def detectSound(obj):
if (obj.resetMinMaxCounter == obj._observationWindowN):
extension = obj.staticMax - obj.staticMin
if (extension > 1000):
if obj.detectionEnabled:
detectionEnabled = False
activePumpkin = True
thread(scare)
staticMax, obj.staticMin = -4096, 4096
resetMinMaxCounter = 0
else:
c = obj.currentSample()
if (c > obj.staticMax):
staticMax = c
elif (c < obj.staticMin):
staticMin = c
resetMinMaxCounter += 1
# establecer 'detectSound' como la función que se aplicará al objeto en cada paso de muestreo
toishield . micrófono . doEverySample ( detectar sonido )
toishield . micrófono . startSampling ( 1 , 50 , "raw" )
