Saltar al contenido
Instagram Youtube Tiktok Facebook-f

Cómo hacer una lámpara floante - Sistema de levitación magnética

Hace varios años es posible que la levitación fuera simplemente un sueño en la cabeza de muchos, pero gracias al desarrollo de la tecnología hoy en día podemos desarrollar o comprar nuestro propio sistema de levitación magnética. No vamos a ser capaces de hacer flotar a una persona, porque sería mucho peso, pero si vamos a poder hacer levitar objetos de 150 o 300 gramos, que es más que suficiente para crear una lámpara flotante.

Lista de materiales

Respecto al kit de levitación magnética hay varias opciones. La primera es comprarlo ya montado o sin montar. Comprarlo montado es un poco más caro pero el proyecto es mucho más fácil de hacer. Si eres un entusiasta de la electrónica y te gusta soldar puedes comprarlo sin montar, como hemos hecho nosotros. Además es un poco más barato.

Por otro lado puedes elegir la versión de 150 gramos o la de 300 gramos. Realmente no hay ninguna diferencia, simplemente uno incluye 4 imanes permanentes y el otro 8. Para este proyecto nosotros te recomendamos el kit de 300 gramos, así te aseguras de que sea capaz de soportar el peso de la lámpara. 

Importante: la luna que hemos hecho y los imanes pesan en total 210 gramos, por lo que entra dentro del límite. Sin embargo, la luna es muy grande en cuanto a diámetro, y nos costaba mucho que aguantara flotando, así que tuvimos que comprar un imán más grande de 5 cm de diámetro. 

Consejos para montar el kit de levitación magnética

Estos consejos son principalmente para aquellos que compren el kit de levitación magnética sin montar. Si compras el levitrón montado, los únicos consejos que debes tener en cuenta son el número 2 y 3.

  1. Los imanes de la base del levitrón tienen que atraer al imán que levita. De repeler ya se encargan las bobinas.
  2. Trata los imanes con cuidado, se rompen con facilidad.
  3. Si el imán que levita es atraído hacia uno de los lados de la base, debes calibrar el levitrón modificando poco a poco la posición de los dos potenciómetros que tiene.
  4. El sensor de efecto hall del eje Z debes ponerlo lo más alto posible y doblarlo 90º para que quede paralelo a la base.
  5. Los sensores sirven para que la electrónica del proyecto sea capaz de medir la posición del imán que flota y modificar el campo magnético para que no se caiga, así que es muy importante que los coloques lo mejor posible.

Esquema eléctrico de la lámpara flotante

Para este proyecto es suficiente con utilizar leds de un solo color, pero si has visto el vídeo, sabrás que a nosotros no nos quedaban, así que hemos tenido que utilizar WS2811. Sin embargo, para utilizar este tipo de leds es necesario un controlador, como por ejemplo Arduino Nano, así que te vamos a dejar aquí el esquema eléctrico de ambas versiones, utilizando leds de un solo color y WS2811.

Esquema eléctrico lámpara flotante
Lámpara flotante con Arduino Nano

Código

Si vas a utilizar leds WS2811 como nosotros, necesitas programar el Arduino Nano. Puedes programarle los colores y efectos que tu quieras, pero te dejamos aquí nuestro código por si lo quieres utilizar. ¡Espero que te sea de ayuda!

#include <FastLED.h>

#define LED_PIN     3      //Pin de datos
#define NUM_LEDS    6      //Numero de LEDs
#define BRIGHTNESS  200    //Brillo máximo 1-255
#define LED_TYPE    WS2811 //Tipo de tira LED
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100


CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;


void setup() {
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );
    
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;
}


void loop()
{
    ChangePalettePeriodically();
    
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    
    FillLEDsFromPaletteColors( startIndex);
    
    FastLED.show();
    FastLED.delay(1000 / UPDATES_PER_SECOND);
}

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
    uint8_t brightness = 255;
    
    for( int i = 0; i < NUM_LEDS; ++i) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
        colorIndex += 3;
    }
}


void ChangePalettePeriodically()
{
    uint8_t secondHand = (millis() / 1000) % 90;
    static uint8_t lastSecond = 99;
    
    if( lastSecond != secondHand) {
        lastSecond = secondHand;
        
        if( secondHand ==  0)  { SetupYellow();}
        if( secondHand == 10)  { SetupYellow();}
        if( secondHand == 20)  { SetupWhite();}
        if( secondHand == 30)  { SetupWhite();}
        if( secondHand == 40)  { SetupWhite();}
        if( secondHand == 50)  { SetupGreen();}
        if( secondHand == 60)  { SetupGreen();}
        if( secondHand == 70)  { SetupBlue();}
        if( secondHand == 80)  { SetupBlue();}
        if( secondHand == 90)  { SetupBlue();}
    }
}

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 );
}


// This function fills the palette with totally random colors.
void SetupYellow()
{
    for( int i = 0; i < 16; ++i) {
        currentPalette[i] = CHSV( HUE_YELLOW, 255, 255);
    }
}
void SetupGreen()
{
    for( int i = 0; i < 16; ++i) {
        currentPalette[i] = CHSV( HUE_GREEN, 255, 255);
    }
}
void SetupWhite()
{
    for( int i = 0; i < 16; ++i) {
        currentPalette[i] = CRGB::White;
    }
}
void SetupBlue()
{
    for( int i = 0; i < 16; ++i) {
        currentPalette[i] = CHSV( HUE_BLUE, 255, 255);
    }
}

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;
    
}


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
};