Este es el primer mueble con resina epoxi que hemos hecho, un taburete. Además, le he hemos añadido LEDs para que el resultado sea aún mejor. ¿Y cómo controlamos los LEDs? Pues con un Arduino Nano. En este post te voy a contar todo el proceso de creación de este proyecto, incluyendo el diseño, la programación, la electrónica y mucho más. ¡Espero que lo disfrutes!
La idea del proyecto es muy simple. Le vamos a hacer un agujero al taburete, le añadiremos los LEDs y la cara de una pantera para decorar, y por último, lo cubriremos todo con la resina epoxi. ¿Por qué una pantera? Pues básicamente porque este taburete va a estar en un bar llamado Pantera.
Cómo hacerle el agujero al taburete
El primer paso de este proyecto es hacerle el agujero al taburete. ¿Cómo lo hemos hecho? Con una fresadora. Es probable que no tengas esta herramienta en casa. Sin embargo, si quieres hacer este tipo de proyectos, es necesario tener una. Tampoco tiene por qué ser muy cara. La que estoy utilizando yo solo ha costado 50 euros.
El agujero tiene que ser mínimo de 12 mm de profundidad para poder poner una tira LED en el borde del agujero que hemos hecho. En nuestro caso ha sido de 14 mm, aunque podría ser más profundo. Ten en cuenta que conforme más profundo lo hagas, más resina epoxi necesitarás.
Decorar el mueble con resina epoxi - Diseño e impresión 3D de la pantera
Puedes decorar el mueble como más te guste. Ten en cuenta que todo lo que le pongas dentro del agujero va a estar cubierto por la resina epoxi, así que no hay ningún problema en ponerle lo que sea. Simplemente asegúrate de que la decoración no sea más alta que la profundidad del agujero. Nosotros hemos elegido una pantera porque como ya te he dicho el bar donde se va a utilizar este taburete se llama así.
El diseño de la pantera lo hemos encontrado en Internet. Cómo queremos imprimirlo, primero hay que pasarlo de 2D a 3D. Para ello lo abrimos con Photoshop y dejamos la imagen en blanco y negro. En nuestro caso solo ha sido necesario borrar los ojos de la pantera con un pincel blanco.
Al mismo pincel, le bajamos el flujo y la opacidad al 15% y dibujamos por encima de los bordes de la pantera. Este paso es necesario para que una vez convertido el dibujo 2D a 3D, no existan cambios bruscos en los bordes. Una vez hecho esto exportamos la imagen en formato PNG.
Lo siguiente es abrir la imagen exportada con la aplicación Cura. Hay que asegurarse de que el lado más largo de la pantera quepa en la impresora. El parámetro base lo dejamos a 0, y la altura la hacemos de 5 mm. Ajustamos el suavizado aproximadamente a la mitad y bajamos el modelo medio milímetro para que la base desaparezca.
Una vez termine la impresión, cogemos la pantera y la ponemos en el taburete para dibujar su silueta. También marcamos los puntos donde irán colocados los LEDs y sus líneas de conexión. Si tu también vas a realizar el proyecto, debes hacer lo mismo con tu objeto u objetos de decoración.
Esquema eléctrico del proyecto
En la siguiente imagen puedes ver el esquema eléctrico y todas las conexiones que hay que hacer. En nuestro caso hemos dividido los LEDs en 4 grupos. Cada uno de ellos va a un pin digital de Arduino. Nosotros hemos utilizado los pines 9, 10, 11 y 12. Acuérdate de que las tierras deben estar en común con la de Arduino y de que los LEDs deben estar colocados de forma que los datos entren por Din y salgan por Dout.
En cuanto a la alimentación del proyecto, la idea inicial era utilizar varias baterías de litio. Sin embargo, estas no han llegado a tiempo, así que por ahora voy a conectar el taburete a una power bank.
Como puedes ver en el esquema eléctrico, hemos colocado un interruptor en la línea de tensión, para poder encender y apagar el proyecto. En el caso de utilizar una power bank no es muy útil, ya que ésta ya tiene un botón integrado de encendido y apagado.
Por último, en el pin digital 3 conectamos un botón táctil que nos servirá para cambiar entre los 4 modos de funcionamiento que tiene el taburete y que más adelante te enseñaré. En este caso si es muy importante que te asegures de conectar el botón a un pin digital que pueda hacer saltar una interrupción. En Arduino Nano y Arduino Uno estos pines son el 2 y el 3.
Para poder pasar los cables hemos hecho 2 agujeros en el taburete con un taladro. Después hemos pegado los LEDs en los puntos que habíamos dibujado previamente. Una vez hecho esto hay que soldar todas las conexiones.
Otro paso fundamental antes de echar la resina epoxi es tapar todos los agujeros para que no se filtre. También puedes colocar una bandeja debajo del taburete para no manchar el suelo o la mesa si se filtra la resina.
Mezclar y echar la resina - Mueble con resina epoxi
Ya ha llegado el momento de poner la resina. Nosotros estamos utilizando la de la de marca icrystal. Para aplicarla, debemos mezclar 2 a 1 el componente A con el componente B. Es decir, si utilizas 1 litro de resina, necesitas 0,5 litros de endurecedor. Ten en cuenta que estas medidas no son iguales para las resinas de todas las marcas. Lo mejor es que leas las instrucciones de tu propia resina epoxi.
También le podemos poner colorante. En nuestro caso hemos probado con distintos tonos de azul. Al principio el color ha sido muy clarito, por lo que también le hemos puesto colorante negro. En la primera capa de resina solo hemos puesto la boca y los bordes de la cara de la pantera.
Después de esperar 2 días para que la resina se seque, hemos pegado el resto de la pantera. De esta forma el efecto 3D es más notable. Una vez hecho esto ya echamos toda la resina necesaria para tapar todo el agujero.
Para dar el acabo final hay que lijar la resina. Tienes que empezar con el grano más grueso y terminar con el más fino. Una vez lijada la resina, ya puedes pulirla. La manera más sencilla de hacerlo es comprando un kit de pulido de faros de coche.
Controlar los LEDs con Arduino
Aquí abajo te voy a dejar el código para que tu también lo puedas utilizar. Además ahora veremos como funciona, pero antes de ello me gustaría recomendarte esto proyecto: Torres de Iluminación Inteligentes.
Lo primero que me gustaría comentarte es que en aquellas líneas del programa en las que encuentres asteriscos, significa que tienes que cambiarles algo dependiendo de las características de tu proyecto. Te pongo un ejemplo. La variable NUM_EXT_LEDS guarda el número de LEDs que he puesto en el borde del taburete, que en mi caso son 29. Si tu por ejemplo pones 45, pues tendrás que poner dicho número.
En la función void setup(), simplemente configuro las 4 tiras LEDs que estoy utilizando, establezco el brillo, inicializo el pin digital del botón como INPUT_PULLUP y creo la interrupción que saltará cuando pulse el botón.
La función void loop() es básicamente una sentencia switch con 4 casos, que son los 4 modos de funcionamiento del taburete. En el primer modo todos los LEDs están encendidos. Los del borde del taburete con un efecto y los de la pantera con un color fijo. Este es el modo que más energía consume.
El segundo modo de funcionamiento hace que solo se enciendan los LEDs de la pantera con un color y brillo determinado. Después de esto Arduino entra en modo sueño, lo cual es muy útil, ya que el proyecto es inalámbrico. En el tercer modo solo se encienden los ojos de la pantera, y el brillo va subiendo y bajando.
Por último, el 4 modo de funcionamiento solo enciende los LEDs de los ojos con un color y brillo fijos, es decir, no cambian. Gracias a esto, en este caso también es posible entrar en modo sueño. Esta es la función con la que más energía se ahorra y que hará que tus baterías o pilas duren más tiempo.
#include <FastLED.h>
#include "LowPower.h"
#define NUM_EXT_LEDS 20 //********************
#define NUM_LFACE_LEDS 3 //********************
#define NUM_CFACE_LEDS 2 //********************
#define NUM_RFACE_LEDS 3 //********************
#define PIN_EXT_LEDS 9 //********************
#define PIN_LFACE_LEDS 10 //********************
#define PIN_CFACE_LEDS 11 //********************
#define PIN_RFACE_LEDS 12 //********************
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
#define MAX_BRIGHTNESS 4 //********************
const int BUTTON = 3;
const int threshold = 500;
volatile int mode = 1;
volatile int lastTime = 0;
int brightness = MAX_BRIGHTNESS;
bool brightness_direction = false;
CRGB ext_leds[NUM_EXT_LEDS];
CRGB lface_leds[NUM_LFACE_LEDS];
CRGB cface_leds[NUM_CFACE_LEDS];
CRGB rface_leds[NUM_RFACE_LEDS];
//ColorPalette Variables
CRGBPalette16 currentPalette;
TBlendType currentBlending;
extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
void setup(){
Serial.begin(9600);
//Configuración de las tiras LEDs
FastLED.addLeds<LED_TYPE, PIN_EXT_LEDS, COLOR_ORDER>(ext_leds, NUM_EXT_LEDS);
FastLED.addLeds<LED_TYPE, PIN_LFACE_LEDS, COLOR_ORDER>(lface_leds, NUM_LFACE_LEDS);
FastLED.addLeds<LED_TYPE, PIN_CFACE_LEDS, COLOR_ORDER>(cface_leds, NUM_CFACE_LEDS);
FastLED.addLeds<LED_TYPE, PIN_RFACE_LEDS, COLOR_ORDER>(rface_leds, NUM_RFACE_LEDS);
//Configuración del brillo
FastLED.setBrightness(MAX_BRIGHTNESS);
//Configuración efecto ColorPalette
currentPalette = RainbowColors_p;
currentBlending = LINEARBLEND;
pinMode(BUTTON, INPUT_PULLUP);
//Interrupción para usar el botón
attachInterrupt(digitalPinToInterrupt(BUTTON), modesController, RISING);
}
void loop(){
switch(mode){
case 1:
allLedsOn();
delay(20);
break;
case 2:
onlyFaceLedsOn();
LowPower.idle(SLEEP_FOREVER, ADC_OFF, TIMER2_ON, TIMER1_ON, TIMER0_ON,
SPI_OFF, USART0_ON, TWI_OFF);
break;
case 3:
onlyEyesLedsOn();
delay(200);
break;
case 4:
safeEnergy();
LowPower.idle(SLEEP_FOREVER, ADC_OFF, TIMER2_ON, TIMER1_ON, TIMER0_ON,
SPI_OFF, USART0_ON, TWI_OFF);
break;
}
FastLED.show();
}
void allLedsOn(){
//Brillo al máximo
brightness = MAX_BRIGHTNESS;
FastLED.setBrightness(brightness);
//Efecto ColorPalette - LEDs externos
ChangePalettePeriodically();
static uint8_t startIndex = 0;
startIndex = startIndex + 1; // motion speed
FillLEDsFromPaletteColors( startIndex);
//Cara de la pantera
//Encendemos los leds de la cara color amarillo - Puedes cambiar el color
for(int i=0; i<NUM_LFACE_LEDS; i+=2){
lface_leds[i].setRGB(255,255,0); //*******************
rface_leds[i].setRGB(255,255,0); //*******************
}
for(int i=0; i<NUM_CFACE_LEDS; i++){
cface_leds[i].setRGB(255,255,0); //*******************
}
//Ojos de color rojo - Puedes cambiar el color
lface_leds[1].setRGB(255,0,0); //*****************
rface_leds[1].setRGB(255,0,0); //*****************
}
void onlyFaceLedsOn(){
//Brillo al máximo
brightness = MAX_BRIGHTNESS;
FastLED.setBrightness(brightness);
//Apagamos los LEDs externos
for(int i = 0; i < NUM_EXT_LEDS; i++){
ext_leds[i].setRGB(0,0,0);
}
//Encendemos los leds de la cara color amarillo - Puedes cambiar el color
for(int i=0; i<NUM_LFACE_LEDS; i+=2){
lface_leds[i].setRGB(255,255,0); //*******************
rface_leds[i].setRGB(255,255,0); //*******************
}
for(int i=0; i<NUM_CFACE_LEDS; i++){
cface_leds[i].setRGB(255,255,0); //*******************
}
//Ojos de color rojo - Puedes cambiar el color
lface_leds[1].setRGB(255,0,0); //*****************
rface_leds[1].setRGB(255,0,0); //*****************
}
void onlyEyesLedsOn(){
//Apagamos los LEDs externos
for(int i = 0; i < NUM_EXT_LEDS; i++){
ext_leds[i].setRGB(0,0,0);
}
//Apagamos los leds de la cara
for(int i=0; i<NUM_LFACE_LEDS; i+=2){
lface_leds[i].setRGB(0,0,0);
rface_leds[i].setRGB(0,0,0);
}
for(int i=0; i<NUM_CFACE_LEDS; i++){
cface_leds[i].setRGB(0,0,0);
}
//Encendemos los ojos de color rojo - Puedes cambiar el color
lface_leds[1].setRGB(255, 0, 0); //********************
rface_leds[1].setRGB(255, 0, 0); //********************
//Modificamos el brillo de los ojos
if(brightness_direction == false){
if(brightness > 0){
brightness -=1;
}
else{
brightness_direction = true;
}
}
else{
if(brightness < MAX_BRIGHTNESS){
brightness +=1;
}
else{
brightness_direction = false;
}
}
FastLED.setBrightness(brightness);
}
void safeEnergy(){
//Brillo al máximo
brightness = MAX_BRIGHTNESS;
FastLED.setBrightness(brightness);
for(int i = 0; i < NUM_EXT_LEDS; i++){
ext_leds[i].setRGB(0,0,0);
}
//Apagamos los leds de la cara
for(int i=0; i<NUM_LFACE_LEDS; i+=2){
lface_leds[i].setRGB(0,0,0);
rface_leds[i].setRGB(0,0,0);
}
for(int i=0; i<NUM_CFACE_LEDS; i++){
cface_leds[i].setRGB(0,0,0);
}
//Encendemos los ojos de color rojo - Puedes cambiar el color
lface_leds[1].setRGB(255, 0, 0); //********************
rface_leds[1].setRGB(255, 0, 0); //********************
}
void modesController(){
if((millis()-lastTime) > threshold){
lastTime = millis();
if(mode > 3){
mode = 1;
}
else{
mode++;
}
}
}
//FUNCIONES EFECTO COLORPALETTE
void FillLEDsFromPaletteColors( uint8_t colorIndex){
uint8_t brightness = 255;
for( int i = 0; i < NUM_EXT_LEDS; ++i) {
ext_leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
colorIndex += 3;
}
}
void ChangePalettePeriodically(){
uint8_t secondHand = (millis() / 1000) % 60;
static uint8_t lastSecond = 99;
if( lastSecond != secondHand) {
lastSecond = secondHand;
if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
}
}
void SetupTotallyRandomPalette(){
for( int i = 0; i < 16; ++i) {
currentPalette[i] = CHSV( random8(), 255, random8());
}
}
void SetupBlackAndWhiteStripedPalette(){
// 'black out' all 16 palette entries...
fill_solid( currentPalette, 16, CRGB::Black);
// and set every fourth one to white.
currentPalette[0] = CRGB::White;
currentPalette[4] = CRGB::White;
currentPalette[8] = CRGB::White;
currentPalette[12] = CRGB::White;
}
void SetupPurpleAndGreenPalette(){
CRGB purple = CHSV( HUE_PURPLE, 255, 255);
CRGB green = CHSV( HUE_GREEN, 255, 255);
CRGB black = CRGB::Black;
currentPalette = CRGBPalette16(
green, green, black, black,
purple, purple, black, black,
green, green, black, black,
purple, purple, black, black );
}
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
CRGB::Red,
CRGB::Gray, // 'white' is too bright compared to red and blue
CRGB::Blue,
CRGB::Black,
CRGB::Red,
CRGB::Gray,
CRGB::Blue,
CRGB::Black,
CRGB::Red,
CRGB::Red,
CRGB::Gray,
CRGB::Gray,
CRGB::Blue,
CRGB::Blue,
CRGB::Black,
CRGB::Black
}; Resultado final del Mueble con Resina Epoxi y LEDs
Estamos muy contentos con el resultado final porque ha quedado bastante bien para ser nuestro primer mueble con resina epoxi. Además esto abre un nuevo mundo de posibilidades sobre nuevos proyectos que podemos hacer.
Aun así, no hay que olvidar que siempre se puede mejorar. Si tuviéramos que destacar algún fallo, sería el color de la resina, que al final ha sido demasiado oscuro y la pantera no se ve como esperábamos. En el siguiente proyecto no cometeremos el mismo error y ¡esperamos que te haya gustado!
