A veces para hacer realidad ideas , actualmente no hace falta grandes desarrollos o un despliegue de recursos desorbitado, porque como vamos a ver, realizar un dispensador de caramelos , una hucha o incluso un alimentador para animales puede ser realmente casi una tarea relativamente sencilla.

En Internet, se pueden ver dispensadores de caramelos con un motor lineal y piezas de la impresora 3D. En muchas paginas también se muestra una colección de chatarra con viejas unidades de CD/DVD donde tanto el cajón como el cabezal de lectura se mueven de esta manera. Así que diseccionar una unidad antigua puede ser emocionante, pero al final no parece adecuado para los nuevos tiempos, por lo que la alternativa es un servomotor.

En efecto para llevar a cabo el nuevo proyecto con tecnología actual , todo lo que necesita es un microcontrolador, LED y botones, así como un potente servomotor, además de algunos retoques y muchas dosis de creatividad.

Hardware

1	Microcontrolador Uno
1	Prototyping Shield, alternativamente Mini Breadboard
2	RGB LEDs
1	Servo de engranajes metálicos MG90S, MG995, MG996R
1	Botón (aquí botón arcade con LED)
Optar.	Zumbador activo (zumbador)
	Cable de puente y fuente de alimentación: 4 pilas AA
aprox. 1 m	Canal de cables 60x40mm de la ferretería, cinta adhesiva

En primer lugar, aquí está el componente más importante, el

Dispensador de caramelos

Quizas la tarea mas compleja es la caja donde ira el dispensador de caramelos que queremos qeu se pueda abrir o cerrar automaticamente

El dispensador de caramelos se puede realizar con un canal de cables 60×40 mm y el servobrazo extendido con tubo retráctil unido al baston del servo.

Desafortunadamente, no está en la gama AZ-Delivery el botón iluminado, ya que se usa en las consolas arcade. Por supuesto, también puedes usar otros botones.

Li dea es sencilla: los niños presionan la nariz roja de una cara de payaso ligeramente espeluznante, los ojos rojos se vuelven verdes, después de 2,5 segundos los ojos parpadean dos veces y el servomotor gira 90° para empujar un pequeño paquete de dulces.

Se puede pintar el cuadro, imprimirlo o pegarlo como un patchwork.

Toda la configuración no está pensada para durar para siempre, por lo que los componentes electrónicos y las baterías están en una caja de cartón.

Se utilizan LEDs RGB con un cátodo común. Este tiene la pata más larga del LED RGB, la pata única de un lado es para el componente rojo, las dos patas del otro lado son para el verde y el azul.

Se utilizan los pines del microcontrolador Arduino usando el GPIO 3 para el rojo, el GPIO 4 para GND, el GPIO 5 para el verde y el GPIO 6 para el azul, en primer lugar para poder atenuar opcionalmente los LED (3, 5 y 6 tienen PWM) y en segundo lugar para activar tanto el guiño como el zumbador opcional ajustando brevemente el GPIO 4 a HIGH. 

Se conectan los dos «ojos» (LED RGB) en paralelo. Opcionalmente, se podrían controlar individualmente usando un pin adicional del GPIO .

Todo el conjunto cabe en una caja de cartón que podemos cerrar para que no se vea el mecanismo. En la imagen , a la derecha vemos el aspecto del Arduino Uno con Escudo de Prototipos ( para el buzzer ). En la parte de la derecha vemos los 2 LED RGB y el botón iluminado (igual que los usados en consolas de juegos)

Esquemático

El circuito como vemos en la imagen es bastante simple usando sólo pines digitales :

• El GPIO 8 lo conectamos al pulsador ( y el otro a masa)
• El GPIO 3 lo conectamos al pin rojo de cada led RGB.
• El GPIO 4 lo conectamos a la masa de cada led
• El GPIO 5 lo conectamos al pin verde de cada led RGB.
• El GPIO 9 lo conectamos al led interno del pulsador
• El GPIO 10 conectamos al pin de datos del servo ( también necesitará 5v DC para los otros dos terminales)
• El GPIO 5 también lo conectamos al zumbador.

Este es el aspecto del conjunto al que ha añadido la alimentación consistente en 4 pilas AA que nos dan una tensión final de unos 6 Voltios.

Código Arduino

El código controla un rostro de payaso con LEDs RGB como ojos y un botón grande con un LED como nariz. El comportamiento es el siguiente:

1. Operación normal: Los ojos (LEDs) están en rojo y el botón tiene un LED rojo encendido.
2. Cuando se presiona el botón:
   • Los ojos se vuelven verdes y el LED del botón se apaga durante 6 segundos.
   • Después de 2.5 segundos, los ojos verdes parpadean y suena un zumbador dos veces.
   • Un servo se activa para empujar dulces.

Explicación del código:

Inclusión de la librería Servo:

#include <Servo.h>
Servo myservo;  // Crear objeto servo para controlar un servo
int pos = 0;    // Variable para almacenar la posición del servo

Definición de pines:

const int buttonPin = 8; // Pin del botón
const int redledPin = 3; // Pin del LED rojo
const int gndledPin = 4; // Pin de tierra común para LEDs
const int greenledPin = 5; // Pin del LED verde
const int blueledPin = 6; // Pin del LED azul
const int ledPin = 9; // Pin del LED en el botón

Variables:

int buttonState = 0; // Variable para leer el estado del botón

Configuración inicial:

void setup() {
 pinMode(redledPin, OUTPUT);
 pinMode(gndledPin, OUTPUT);
 digitalWrite(gndledPin, LOW);
 pinMode(greenledPin, OUTPUT);
 pinMode(blueledPin, OUTPUT);
 pinMode(ledPin, OUTPUT);
 pinMode(buttonPin, INPUT_PULLUP);
 myservo.attach(10); // Conectar el servo al pin 10
 myservo.write(130);
 delay(500);
}

Función para mover el servo:

void servoturn() {
 for (pos = 130; pos >= 20; pos -= 1)
 {myservo.write(pos);
  delay(10);
 }
 for (pos = 20; pos <= 130; pos += 1) 
  { myservo.write(pos);
  delay(10); 
  }
}

Bucle principal:

void loop() {
 buttonState = digitalRead(buttonPin);
 if (buttonState == LOW) {
  digitalWrite(redledPin, LOW);
  digitalWrite(ledPin, LOW);
  digitalWrite(greenledPin, HIGH);
  delay(2500);
  digitalWrite(gndledPin, HIGH);
  delay(250);
  digitalWrite(gndledPin, LOW);
  delay(250);
  digitalWrite(gndledPin, HIGH);
  delay(250);
  digitalWrite(gndledPin, LOW);
  servoturn();
  delay(2500);
 } else {
  digitalWrite(greenledPin, LOW);
  digitalWrite(ledPin, HIGH);
  digitalWrite(redledPin, HIGH);
 }
}

Por cierto , en la secuencia descrita en el código, el zumbador se activa después de que los ojos (LEDs verdes) han estado encendidos durante 2.5 segundos. Aquí está el detalle:

1. Después de 2.5 segundos de que los ojos se vuelven verdes, el zumbador suena brevemente dos veces.
2. Esto se logra mediante el parpadeo del LED común a tierra (gndledPin), que simula el sonido del zumbador.

El código para esto es:

delay(2500);  // Espera 2.5 segundos
digitalWrite(gndledPin, HIGH);  // Activa el zumbador (simulado)
delay(250);  // Espera 0.25 segundos
digitalWrite(gndledPin, LOW);  // Desactiva el zumbador
delay(250);  // Espera 0.25 segundos
digitalWrite(gndledPin, HIGH);  // Activa el zumbador nuevamente
delay(250);  // Espera 0.25 segundos
digitalWrite(gndledPin, LOW);  // Desactiva el zumbador

Este parpadeo del LED común a tierra (gndledPin) simula el sonido del zumbador, creando un efecto de sonido breve dos veces.

Funcionamiento general

• Estado normal: Los ojos (LEDs) están en rojo y el LED del botón está encendido.
• Al presionar el botón:
  1. Los ojos se vuelven verdes y el LED del botón se apaga.
  2. Después de 2.5 segundos, los ojos verdes parpadean y el zumbador suena brevemente dos veces.
  3. El servo motor se activa para empujar dulces.

RESUMEN Y CODIGO COMPLETO

En resumen, el código controla LEDs y un servo para crear un efecto de cara de payaso interactiva para Halloween o lo que se quiera.

En las siguientes líneas podemos ver el código completo Arduino para probar el montaje anterior.

#include <Servo.h>
Servo myservo; // create servo object to control a servo
int pos = 0; // variable to store the servo position

// constants won’t change. They’re used here to set pin numbers:
const int buttonPin = 8;      // the number of the pushbutton pin
const int redledPin =  3;     // the number of the red LED pin
const int gndledPin =  4;     // the number of the common ground LED pin
const int greenledPin =  5;   // the number of the green LED pin
const int blueledPin =  6;    // the number of the blue LED pin
const int ledPin =  9;       // the number of the LED pin in button

// variables will change:
int buttonState = 0;          // variable for reading the pushbutton status

void setup() {
 // initialize the LED pin as an output:
 pinMode(redledPin, OUTPUT);
 pinMode(gndledPin, OUTPUT);
 digitalWrite(gndledPin, LOW);    
 pinMode(greenledPin, OUTPUT);
 pinMode(blueledPin, OUTPUT);
 pinMode(ledPin, OUTPUT);  
 // initialize the pushbutton pin as an input:
 pinMode(buttonPin, INPUT_PULLUP);
 myservo.attach(10); // attaches the servo on Pin 10 to the servo object
 myservo.write(130);
 delay(500);  
}  // end setup

void servoturn()   {    // adjust angles acc. to your setup
   for (pos = 130; pos >= 20; pos -= 1) {
   // goes from 120 degrees to 20 degrees
   // in steps of 1 degree
   Serial.println(pos);
   myservo.write(pos);
   delay(10);
   }
 for (pos = 20; pos <= 130; pos += 1) {
   // goes from 20 degrees to 120 degrees
   Serial.println(pos);  
   myservo.write(pos);
   delay(10);
   }
}  // end servoturn

void loop() {
 // read the state of the pushbutton value:
 buttonState = digitalRead(buttonPin);
 // check if the pushbutton is pressed. If it is, the buttonState is LOW:
 if (buttonState == LOW) {
   // turn green LED on, red LED off:
   digitalWrite(redledPin, LOW);
   digitalWrite(ledPin, LOW);    
   digitalWrite(greenledPin, HIGH);
   delay(2500);
   digitalWrite(gndledPin, HIGH);     
   delay(250);
   digitalWrite(gndledPin, LOW);
   delay(250);
   digitalWrite(gndledPin, HIGH);     
   delay(250);
   digitalWrite(gndledPin, LOW);
   servoturn();      
   delay(2500);        
 } else {
   // turn green LED off red LED on:
   digitalWrite(greenledPin, LOW);
   digitalWrite(ledPin, HIGH);      
   digitalWrite(redledPin, HIGH);    
 }
}  // end loop