¿Cuáles son todos los tipos de placas de Arduino que existen a día de hoy y que podemos comprar? Lista 2024

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

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

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 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 M­INI 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,73×1,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

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