Lo Último en IP@P
- 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
- Actualizaciones del Programa de Afiliados de TEMU: ¡Hasta MX$500,000 al mes!
Para que aproveches al máximo las herramientas de Arduino será conveniente que tu aprendizaje no pare de crecer día a día. Para poner en práctica todo lo sabes es recomendable que conozcas los mejores kits de expansión que se adaptan a ti.
Esta información la encontrarás a continuación. Te mostraremos, de manera detallada, los kits más completos que te ayudarán a progresar y a conocer más trucos de la placa Arduino.
¡No te pierdas de nada!, al final verás una lista con los proyectos que puedes llevar adelante con Arduino. Te presentaremos los componentes y los códigos que debes usar en cada uno.
Lista de los mejores kits de expansión de Arduino para seguir aprendiendo
Mira a continuación los mejores kits de expansión de Arduino para conocer más sobre este mundillo de programación:
Conjunto Avanzado ELEGOO ES-EL-KIT-001
Este kit incluye un manual en español para realizar diferentes proyectos con tu placa de Arduino. Incluye el modelo Arduino UNO Rev3, un módulo de fuente de alimentación, en la pantalla LCD de 16x2 (este elemento te permitirá crear relojes, indicadores de temperatura y más), un motor paso a paso y una breadboard. Sus más de 200 piezas de sus 63 componentes son ideales para trabajar en proyectos de corriente continua de 6.5v a 9v. Su coste es de 50 €.
UNIROI Kit de expansión UA005-DE-FBA
Por solo 29,99 € tendrás un kit para Arduino muy útil para los que recién comienzan en el mundillo de Arduino. Está pesado para realizar cualquier proyecto que sea compatible con una placa UNO. Incluye 45 componentes que también pueden ser usados en modelos Mega 2560 y Raspberry Pi. Entre los elementos que se destacan se encuentran, una pantalla de un dígito de 7 segmentos, una pantalla LCD 16x02, un motor paso a paso y una gran variedad de conectores.
Kit ELEGOO ES-EL-KIT-003
Con este conjunto de elemento podrás realizar cualquier plan de nivel medio, ya que contarás con una placa Arduino UNO R3, un lote de relés de 5v y un módulo de alimentación de corriente externa. También dispondrás de un servomotor para realizar brazos robóticos y de una guía en español para programar dentro del IDE Arduino. El precio de este conjunto es de 17 € y podrás combinarlo con otros tips que te ayudarán aumentar la dificultad de desarrollo.
Arduino Starter INVEN
El kit de INVEN está pensado para cualquier persona que desee realizar trabajos con las placas de Arduino, por lo que no importará si recién estás comenzando. Dispone de un Arduino UNO, un servomotor SG90, un sensor de sonido y otro de temperatura y humedad, un motor paso a paso y una protoboard 830 de puntos. Además, podrás encontrar tres sensores fotovoltaicos, un potenciómetro de 10 kΩ y un display de LCD1602. Sus más de 40 piezas te permitirán realizar cualquier tipo de trabajo. Su precio en las tiendas más importantes es 77,95 €.
Conjunto de Octopus Electronic Bricks
En este caso se trata de un conjunto de 24 piezas pensado para un nivel principiante. Encontrarás una tarjeta Arduino UNO, sensores de inclinación y de sonido, un zumbador, un relé de un canal, una caja plástica y un ladrillo LED Octopus de 5 mm. Incluye un manual en español con el cual te podrás guiar para realizar las conexiones y no cometer errores en el proceso de armado. Su precio es de 75 €.
Kit para Arduino Kuman K4-UK
En este conjunto encontrarás más de 40 piezas que te servirán para aprender electrónica con Arduino. Dispone de una placa de pruebas, un motor paso a paso, varios sensores y una pantalla de cuatro dígitos y 8 cm. También se incluye en este kit un módulo LED, diferentes resistencias y un par de zumbadores pasivos y activos. Por solo 39,99 € tendrás uno de los mejores conjuntos del mercado.
Freenove Starter Kit FNK0047 for ESP32-WROVER
Podrás encontrar este conjunto de elementos para Arduino en las mejores tiendas online a tan solo 49,95 €. Incluye una carpeta con códigos para programación de la placa en IDE, cables puentes, resistencias, pantalla de un dígito de 7 segmentos, una pantalla LCD de 1602 y un conjunto de LEDs de diferentes colores. De esta manera podrás elegir cualquier tipo de proyecto y descargar manuales de programación desde la página oficial de Arduino.
Conjunto Smraza para Arduino S19s
Si estás interesado en comenzar el camino en Arduino, entonces podrás elegir este kit de expansión con el cual vas a realizar proyectos básicos de electrónica. Este grupo de componentes lo podrás conseguir por alrededor de 20 €. Incluye un potenciómetro de precisión, un zumbador de tipo activo, diferentes leds de colores, cables, adaptadores para baterías de 9v y un cable USB.
Quimat Kit de Arduino para principiantes modelo QK4-US
Es uno de los kits más baratos que podrás conseguir en las tiendas especializadas de electrónica, su precio promedio es de 30 €. Incluye, además del tutorial en español, una placa de Arduino UNO R3, un grupo de cables para realizar las conexiones y una placa de prueba. También se destaca en este conjunto un motor paso a paso, una pantalla LCD, un interruptor de tecla y un potenciómetro ajustable.
SUNFOUNDER UK-Vincent para Arduino Mega2560
Este kit de dispersión se caracteriza por tener una placa Arduino 2560, lo cual lo convierte en un conjunto de componentes muy versátiles para llevar adelante cualquier proyecto de electrónica. Deberás pagar alrededor de 51 € para tener en tus manos una pantalla LCD, una protoboard genérica, kits de cables, transistores y resistencias, pines de led de varios colores y sensores de movimiento y humedad. Es ideal para empezar en Arduino.
Conoce los mejores proyectos Arduino para aprender a desarrollar tus propios dispositivos
Para que puedas poner en práctica tus conocimientos de Arduino podrás desarrollar los proyectos que te mostramos a continuación:
Alarma para estacionamiento
Con este proyecto de Arduino podrás estacionar tu coche de forma tranquila porque cada vez que pongas reversa se activará el dispositivo alertando la distancia que existe entre tu automóvil y un objeto. Su desarrollo es muy simple, solo debes conseguir una placa de la versión UNO, un sensor ultrasónico del tipo HC-SR04, tres luces LED, una protoboard genérica y un zumbador. No te olvides de una resistencia de 220 Ohmios y de los cables para la conexión.
Más en Hardware
- ¿Cuáles son todos los tipos de placas base que existen para laptops y ordenadores? Lista 2024
- Disco duro: ¿Qué es, para qué sirve y cuáles tipos existen?
- ¿Cuáles son las cosas más útiles para imprimir en 3D y empezar a crear proyectos de impresión? Lista 2024
- Historia y evolución de los microprocesadores del iPhone - Lista 2024
- Raspberry Pi 3: ¿Qué es, para qué sirve y cuáles son las características más interesantes de este hardware?
SÍGUENOS EN 👉 YOUTUBE TV
Una vez que tengas todos los elementos vas a tener que unir el pin de 5V de la placa con el VCC del sensor, luego deberás conectar los GND entre sí y desde el pin 9 tendrás que sacar un cable para el TRIG. Por último, vas a tener que unir los pines digitales de la placa Arduino los leds. Este esquema lo podrás ver en la imagen que te presentamos.
Cuando hayas realizado las conexiones de forma correcta, deberás ingresar al entorno de programación de Arduino y escribir estos comandos:
intl1 = 5 ; // led verde
intl2 = 4 ; // led naranja
intl3 = 3 ; // led rojo
intzumbador = 6 ; // timbre
inttrig = 9 ;
intecho = 7 ;
configuración vacía ()
{
Serial . comenzar ( 9600 );
pinMode ( l1 ,SALIDA );
pinMode ( l2 ,SALIDA );
pinMode ( l3 ,SALIDA );
pinMode ( zumbador ,SALIDA );
pinMode ( trig ,SALIDA );
pinMode ( eco ,ENTRADA );
}
bucle vacío ()
{
digitalWrite ( trig ,LOW );
delayMicroseconds ( 5 );
digitalWrite ( trig ,HIGH );
delayMicroseconds ( 10 );
digitalWrite ( trig ,LOW );
inta = pulseIn ( eco , ALTO );
intdistancia = a * 0343 / 2 ;
Serial . print ( "Valor del sensor de España" );
Serial . println ( distancia );
si( distancia < 50 )
{
escritura digital ( l1 ,ALTA );
escritura digital ( l2 ,BAJA );
digitalWrite ( l3 ,BAJO );
digitalWrite ( zumbador ,BAJO );
}
si( distancia < 30 )
{
escritura digital ( l2 ,ALTA );
escritura digital ( l1 ,BAJA );
}
si( distancia < 10 )
{
escritura digital ( l2 ,BAJA );
escritura digital ( l1 ,BAJA );
escritura digital ( l3 ,ALTA );
digitalWrite ( zumbador ,ALTO );
retraso ( 150 );
digitalWrite ( zumbador ,BAJO );
retraso ( 150 );
digitalWrite ( zumbador ,ALTO );
retraso ( 150 );
digitalWrite ( zumbador ,BAJO );
retraso ( 150 );
}
}
Sistema de riego automático
Este proyecto consiste en crear un sistema automático de riego por medio de tres aspersores. Para ello necesitarás una placa Arduino UNO, un reloj de tiempo real DS3231, un módulo LED, un controlador de cuatro canales, dos botones (uno rojo y el otro negro), una caja de plástico impermeable, una protoboard y cables de puentes. También usarás una electroválvula de 12v, una fuente de alimentación de 12v, un sensor de flujo de agua y elementos necesarios para las de los grifos.
Utiliza el esquema de la gráfica para unir todos los materiales, después escribe estás instrucciones en el IDE de Arduino:
#include <DS3232RTC.h>
#include "Constants.h"
#define AWAKE_INDICATION_PIN DEEP_SLEEP_SCHEDULER_AWAKE_INDICATION_PIN
#define DEEP_SLEEP_DELAY 100
#define SUPERVISION_CALLBACK
#include <DeepSleepScheduler.h>
#define EI_NOTPORTC
#define EI_NOTPORTD
#include <EnableInterrupt.h>
#include <EEPROMWearLevel.h>
#include "WaterManager.h"
#include "SerialManager.h"
SerialManager *serialManager;
WaterManager *waterManager;
void setup() {
if (!superviseCrashResetCount()) {
return;
}
serialManager = new SerialManager(BLUETOOTH_ENABLE_PIN);
waterManager = new WaterManager();
serialManager->setWaterManager(waterManager);
initRtc();
pinMode(START_AUTOMATIC_PIN, INPUT_PULLUP);
enableInterrupt(START_AUTOMATIC_PIN, isrStartAutomatic, FALLING);
pinMode(MODE_PIN, INPUT_PULLUP);
enableInterrupt(MODE_PIN, isrMode, FALLING);
serialManager->startSerial();
}
void loop() {
execute();
}
#define MAX_RESET_COUNT 100
class SupervisionCallback: public Runnable {
void run() {
int resetCount = 0;
get(EEPROM_INDEX_WATCHDOG_RESET_COUNT, resetCount);
put(EEPROM_INDEX_WATCHDOG_RESET_COUNT, resetCount + 1);
}
};
/**
return false if not too many crash resets, true if system should stop.
*/
inline bool superviseCrashResetCount() {
begin(EEPROM_VERSION, EEPROM_INDEX_COUNT, EEPROM_LENGTH_TO_USE);
int resetCount = 0;
get(EEPROM_INDEX_WATCHDOG_RESET_COUNT, resetCount);
if (resetCount > MAX_RESET_COUNT) {
// too many crashes, prevent execution
pinMode(COLOR_LED_GREEN_PIN, OUTPUT);
digitalWrite(COLOR_LED_GREEN_PIN, LOW);
pinMode(COLOR_LED_RED_PIN, OUTPUT);
digitalWrite(COLOR_LED_RED_PIN, HIGH);
pinMode(COLOR_LED_BLUE_PIN, OUTPUT);
digitalWrite(COLOR_LED_BLUE_PIN, LOW);
begin(9600);
// wait for serial port to connect
while (!Serial);
println(F("too many resets"));
return false;
} else {
// no problem, execute as normal
setSupervisionCallback(new SupervisionCallback());
return true;
}
}
inline void initRtc() {
// reset alarms if active
alarm(ALARM_1);
alarm(ALARM_2);
delay(1000);
pinMode(RTC_INT_PIN, INPUT_PULLUP);
enableInterrupt(RTC_INT_PIN, isrRtc, FALLING);
}
void modeScheduled() {
waterManager->modeClicked();
serialManager->startSerial();
// simple debounce
delay(200);
removeCallbacks(modeScheduled);
}
void isrMode() {
if (!scheduler.isScheduled(modeScheduled)) {
schedule(modeScheduled);
}
}
void startAutomaticRtc() {
println(F("startAutomaticRtc"));
waterManager->startAutomaticRtc();
serialManager->startSerial();
}
void rtcScheduled() {
// println(F("rtcScheduled"));delay(150);
if (RTC.alarm(ALARM_1)) {
schedule(startAutomaticRtc);
}
if (RTC.alarm(ALARM_2)) {
schedule(startAutomaticRtc);
}
}
void isrRtc() {
schedule(rtcScheduled);
}
void startAutomatic() {
println(F("startAutomatic"));
waterManager->startAutomatic();
serialManager->startSerial();
// simple debounce
delay(200);
removeCallbacks(startAutomatic);
}
void isrStartAutomatic() {
schedule(startAutomatic);
}
Encendido de luz a través de un sensor de movimientos
Vas a poder encender luces de forma automática cuando el sensor de movimientos, creado por una placa de Arduino entre en acción. Para este proyecto vas a necesitar una placa Arduino UNO, un sensor de movimientos de tipo PIR, una protoboard, una fuente de alimentación de 12 volts y 29 amperes, una tira de led sparkfun y cables de puente. Su unión la deberás hacer teniendo en cuenta el diagrama que te presentamos en la imagen.
Escribe las siguientes secuencias en el IDE:
/ * # define Bpin 8;
# definir Rpin 9;
# definir Gpin 10; * /
/ * int Bpin = analogRead (A0);
int Rpin = analogRead (A1);
int Gpin = analogRead (A2); * /
int Bpin = A0 ;
int Rpin = A1 ;
int Gpin = A2 ;
int Motion = 2 ; // sensor PIR
int estado = BAJO ;
int val = 0 ;
configuración vacía () {
pinMode ( movimiento , ENTRADA );
pinMode ( Bpin , SALIDA );
pinMode ( Rpin , SALIDA );
pinMode ( Gpin , SALIDA );
//Serial.begin(9600);
}
bucle vacío ()
{
val = digitalRead ( movimiento );
if ( val == ALTO )
{
Serial . println ( "Menyala" );
if (state == LOW)
{
state = HIGH;
}
// Ingresa tu código aquí
for(int fade = 0; fade <=255; fade +=5)
{
analogWrite(Bpin,fade);
}
for(int fade = 255; fade >= 0; fade -=5)
{
analogWrite(Bpin,fade);
delay(10);
}
for(int fade = 0; fade <=255; fade +=5)
{
analogWrite(Rpin,fade);
delay(1000);
}
for(int fade = 255; fade >= 0; fade -=5)
{
analogWrite(Rpin,fade);
delay(1000);
}
for(int fade = 0; fade <=255; fade +=5)
{
analogWrite(Gpin,fade);
delay(1000);
}
for(int fade = 255; fade >= 0; fade -=5)
{
analogWrite(Gpin,fade);
delay(1000);
}
}
else
{
println("Tidak Menyala");
if (state == HIGH)
{
estado = BAJO ;
}
int dim = BAJO ;
analogWrite ( Bpin , tenue );
analogWrite ( Rpin , tenue );
analogWrite ( Gpin , tenue );
}
}
Reloj despertador
Con un kit de Arduino Micro vas a poder crear tu propio reloj despertador y agregar la función de temporizador. Su programación y armado no es difícil, ya que necesitarás una placa SparkFun de 5 V y de 16 MHz, un mini reproductor de MP3, una tarjeta Micro SD y una pantalla LCD de 12x16.
También deberás tener un chip de reloj Pi RTC, un altavoz de 4 ohmios y 3 watts, un interruptor de botón, una fuente de alimentación y un stripboard. Si deseas, imprimir en 3D una caja plástica o bien comprar una para contener al dispositivo electrónico. Su instalación es un poco complicada en cuanto al cableado, por lo que deberás guiarte de la imagen que te mostramos para que no cometas errores.
A continuación, vas a tener que escribir estos códigos en IDE de Arduino para programar tu reloj:
#include "RTClib.h"
// LCD I2C
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Tarjeta de sonido DFPlayer
#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
SoftwareSerial mySoftwareSerial ( 8 , 9 ); // RX, TX
DFRobotDFPlayerMini myDFPlayer ;
#define ALARM_SECONDS 10 // segundos
#define ALARM_REPEAT_DELAY 2000 // milisegundos
#define ALARM_VOLUME 15 // 0 a 30
#define SESSION_TIME 30 // minutos
// botones de ajuste de tiempo más / menos. BAJO cuando se presiona Conectado para interrumpir entradas, software antirrebote.
#define TPLUS_PIN 0
#define TMINUS_PIN 1
volatile int TPLUS_button = falso ;
volatile int TMINUS_button = false ;
RTC_DS1307 rtc ;
LiquidCrystal_I2C lcd(0x27, 20, 4);
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
void playalarm() {
volume(ALARM_VOLUME); //Set volume value. From 0 to 30
play(1); //Play the first mp3
}
void setup () {
begin(57600);
//while (!Serial); // for Leonardo/Micro/Zero
println("Shoni's Clock");
pinMode(TPLUS_PIN, INPUT_PULLUP);
pinMode(TMINUS_PIN, INPUT_PULLUP);
init();
backlight();
setCursor(0, 0);
print(" Shoni's Clock");
delay(1000);
begin(9600);
if (! rtc.begin()) {
println("Couldn't find RTC");
clear();
setCursor(0, 0);
print("RTC error!");
delay(3000);
}
if (! rtc.isrunning()) {
println("RTC is NOT running!");
clear();
setCursor(0, 0);
print("Clock time error!");
delay(3000);
}
// following line sets the RTC to the date & time this sketch was compiled
adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
//rtc.adjust(DateTime(2019, 10, 12, 11, 59, 50));
if (!myDFPlayer.begin(mySoftwareSerial)) { //Use softwareSerial to communicate with mp3.
println(F("Unable to begin:"));
println(F("1.Please recheck the connection!"));
println(F("2.Please insert the SD card!"));
while (true) {
delay(0); // Code to compatible with ESP8266 watch dog.
}
}
volume(ALARM_VOLUME); //Set volume value. From 0 to 30
playalarm();
attachInterrupt(digitalPinToInterrupt(TPLUS_PIN), TPLUS_button_interrupt, LOW);
attachInterrupt(digitalPinToInterrupt(TMINUS_PIN), TMINUS_button_interrupt, LOW);
}
void TPLUS_button_interrupt() {
TPLUS_button = true;
}
void TMINUS_button_interrupt() {
TMINUS_button = true;
}
void check_buttons() {
int dir;
if (TPLUS_button | TMINUS_button) {
if (TPLUS_button) {
dir = 1;
//Serial.println("Adjust time -1 minute");
delay(50);
TPLUS_button = false;
}
if (TMINUS_button) {
dir = -1;
//Serial.println("Adjust time -1 minute");
delay(50);
TMINUS_button = false;
}
DateTime newtime = rtc.now() + (60 * dir);
adjust(newtime);
}
}
char d[16];
int prevmin = 99;
int alarmplaying;
void loop () {
int minleft;
int updateDisplay = true;
check_buttons();
DateTime now = rtc.now();
// update display only if the minute has changed
if (prevmin == now.minute()) {
updateDisplay = false;
}
else {
updateDisplay = true;
prevmin = now.minute();
}
if (now.minute() == 0) {
minleft = 0;
}
else if (now.minute() > 30) {
minleft = 60 - now.minute();
}
else {
minleft = 30 - now.minute();
}
// Display current time
if (updateDisplay) {
sprintf(d, "%2d:%02d", TwentyFourToTwelve(now.hour()), now.minute());
println(d);
clear();
setCursor(5, 0);
print(d);
}
// Display time left in session
if (minleft == 0) {
if ((now.second() < ALARM_SECONDS)) {
if (!alarmplaying) {
playalarm();
alarmplaying = true;
}
setCursor(0, 1);
print("--Session over--");
println("--Session over--");
delay(ALARM_REPEAT_DELAY);
}
else {
minleft = SESSION_TIME;
alarmplaying = false;
}
}
setCursor(0, 1);
sprintf(d, "minutes left: %2d", minleft);
print(d);
//Serial.println(d);
delay(500);
}
int TwentyFourToTwelve(int hour) {
int h = hour % 12;
if (h == 0) {
h = 12;
}
return h ;
}
Control de sistema de iluminación
Gracias a este proyecto vas a poder controlar una tira de LEDs que se moverá de acuerdo a la música o a cualquier otro parámetro. Necesitarás el modelo UNO de Arduino, cables dmx, un adaptador para la interfaz Grove a la dmx, focos LED y cable puentes. La conexión deberás realizar la teniendo en cuenta el diagrama de conexión de la imagen.
Accede al entorno de programación de Arduino y escribe las siguientes órdenes:
#include <DmxSimple.h>
configuración vacía () {
usePin ( 3 ) ;
//DmxSimple.maxChannel ( 6 ) ;
write ( 1 , 255 ) ;
}
bucle vacío () {
{
write ( 1 , 12 ) ; // Canal 1 - Selección de función - encender
write ( 1 , 151 ) ; // Canal 1 - Selección de función - sonido para cambiar
write ( 3 , 151 ) ; // Canal 3 - Selección de función - sonido para cambiar ajuste de velocidad
write ( 2 , 48 ) ; // Canal 2 - Coincidencia de color de los leds - pudrición
retraso ( 5 ) ;
write ( 2 , 52 ) ; // Canal 2 - Coincidencia de color de los leds - verde
retraso ( 5 ) ;
write ( 2 , 62 ) ; // Canal 2 - Coincidencia de color de los leds - azul
retraso ( 5 ) ;
}
}
