Espelho Infinito Caleidoscópio DIY – Construa um Display de Luz LED Incrível

Componentes e Materiais

Arduino 101	×	1
1m LEDs Endereçáveis Não Vedados (60)	×	1
Pequena Seção de Fio Sólido ou Pinos Jumper	×	1
Tubo Termorretrátil	×	1
Conector Barril Fêmea com Terminais de Parafuso	×	1
Conector Barril Macho com Terminais de Parafuso	×	1
Suporte para 3 Pilhas AA com Interruptor	×	1
Regulador Step-Up Pololu	×	1
Pilhas AA	×	1
Moldura "Shadow Box" Quadrada de 12"	×	1
Espelho Quadrado de 12"	×	1
Cavalete para Foto de 11"	×	1
Película Espelhada para Privacidade	×	1
FoamCore	×	1

Ferramentas e Máquinas Necessárias

Ferro de Solda (genérico)

Estilete com Lâmina Nova

Pistola de Cola Quente (genérica)

Alicate de Decapar Fios

Aplicativos e Serviços Online

Arduino IDE – Você precisará da biblioteca Adafruit NeoPixel. Instruções de instalação. Se for novo no Arduino 101, precisará instalar o Curie Core para acessar os sensores de posição. Guia do Arduino 101

Sobre o Projeto

Uma mistura entre um Caleidoscópio e um Espelho Infinito! À medida que você altera a rotação do espelho, as luzes mudam em resposta. Este projeto é construído com um espelho e moldura prontos, e alguns outros componentes. A placa de desenvolvimento Arduino 101 possui sensoriamento de posição integrado que podemos usar para detectar o ângulo e controlar o display de luz.

Nota: Este projeto usa a mesma configuração eletrônica do Holiday Shadow Theater, basicamente apenas um Arduino 101, uma fita de LED e um pack de baterias. Uso um regulador de tensão de $4 para que o mesmo pack de baterias alimente tanto os LEDs quanto o Arduino 101. Alternativamente, você pode usar uma bateria 9V para alimentar o Arduino e pular o regulador.

Parte Um: Construa o Espelho

Passo 1: Usando um estilete afiado ou faca de hobby, corte um quadrado de 12" x 12" de FoamCore e marque o centro com lápis. Você pode usar o papelão traseiro da moldura como referência.

Passo 2: Usando uma ferramenta de desenho de círculos ou barbante e lápis, desenhe um círculo perfeito com raio de 5.25" centrado no quadrado 12x12. Use uma régua para marcar 0.75" da borda do 12x12 como ponto de referência inicial.

Passo 3: Com estilete ou faca de hobby com lâmina nova, corte cuidadosamente o círculo. Este corte será visível no produto final, então corte o mais limpo possível.

Passo 4: Uma vez cortado o furo, escolha o lado mais bonito e coloque-o com o lado bom voltado para baixo sobre uma superfície de trabalho limpa.

Passo 5: Corte uma tira separada de ½ polegada de FoamCore, com cerca de 36" de comprimento. Pode ser emendada de segmentos menores com fita se necessário. Use régua e mantenha o tamanho o mais uniforme possível em 0.5".

Passo 6: Deite a tira completada horizontalmente sobre uma mesa e corte ranhuras verticais uniformes através da folha de papel superior a cada 2" ao longo de todo o comprimento.

Passo 7: Vire a tira e, usando cola quente, fixe a fita de LED ao longo do comprimento da tira de FoamCore.

Passo 8: Dobre a tira completada em um círculo aproximado usando as ranhuras que cortou na parte de trás do FoamCore como pontos de dobra.

Passo 9: Coloque a fita de LED em um anel sobre o furo no seu quadrado 12x12" de FoamCore. A fita completa será longa demais. Ajuste seu círculo de LED para ser ligeiramente maior que o furo e corte os LEDs extras (cerca de 6 LEDs). Você ainda pode usar esses LEDs sobressalentes para outro projeto.

Passo 10: Coloque a fita de LED em um anel na superfície superior (lado ruim) do seu quadrado 12x12", e cole com cola quente na borda do furo circular. Certifique-se de que a parte de trás do anel de LED esteja a pelo menos 0.25" da borda do quadrado 12x12". (Caso contrário, os espaçadores pretos da moldura não caberão ao redor.)

Passo 11: Se usar a película semi-espelhada, retire o vidro da moldura shadowbox e aplique a película no vidro seguindo as instruções do fabricante. Achei este o passo mais complicado. Certifique-se de limpar o vidro primeiro e use água (ou solução de sabão) para facilitar a remoção de bolhas de ar. A película espelhada cria uma ilusão muito mais forte e esconde os LEDs, mas não é 100% necessária (e você pode adicioná-la depois se desejar!) Se usar película, coloque o vidro de volta na moldura com o lado da película voltado para cima/para dentro da moldura.

Passo 12: Com a moldura voltada para baixo e o vidro limpo, posicione o foam sobre o vidro, com o lado bom para baixo e o anel de LED para cima. Adicione dois dos espaçadores que vieram na moldura, depois adicione seu espelho 12x12" com a face para baixo. Os fios do LED devem sair pela parte de trás da moldura passando pelo espelho. Se o encaixe do espelho estiver muito apertado para os fios, pode ser necessário esculpir cuidadosamente um entalhe para os fios na borda da moldura usando estilete ou faca de hobby.

Se houver espaço, adicione o papelão traseiro da moldura, ou se não, apenas segure o espelho no lugar com as abas da moldura. Pronto! Agora a mágica da eletrônica.

Parte Dois: Configurando a Eletrônica

Passo 1: Encontre os 6 LEDs extras que cortou da ponta anteriormente. Recolha o chicote da extremidade, cortando cerca de 1 cm das luzes. Desencape as pontas dos fios.

Passo 2: Separe os pinos de header dobrados que vieram com seu regulador de tensão, e solde dois deles nas pontas dos fios verde e amarelo. Isso permitirá conectá-los facilmente nos pinos do Arduino 101.

Passo 3: Em seguida, solde o fio vermelho no terminal VIN do Regulador de Tensão, e solde dois headers retos nos pinos GND e VOUT como mostrado.

Passo 4: Agora conecte os adaptadores de conector barril. Primeiro desencape as pontas dos fios vindos do suporte de pilhas, depois monte-os nos terminais do conector barril macho e aperte com chave de fenda. VERMELHO vai no terminal (+), PRETO vai no terminal (-).

Em seguida, conecte o adaptador de conector barril fêmea nos fios soltos vindos do início da fita de LED (vindos da parte de trás do seu espelho). Nesta fita, AMARELO vai no terminal (-), e VERMELHO vai no terminal (+).

Passo 5: Agora conecte seu chicote ao Arduino 101. O fio VERDE vai no PINO 6, o fio AMARELO vai no pino GND próximo ao #13.

Com os dois pinos de header no regulador de tensão, GND vai no GND e VOUT vai no pino "Vin" do Arduino 101. Não erre isso! Conectar invertido causa cheiro de queimado e danos. Eu sei por experiência.

Passo 6: Conecte os chicotes de fios no Arduino 101 e na fita de LED, depois conecte o conector barril do pack de baterias no conector barril da fita de LED e está tudo ligado!

Passo 7: Agora que sua eletrônica está pronta, posicione o Arduino 101 na parte de trás do espelho com sua orientação paralela a qualquer lado do espelho. Fixe com Velcro, fita dupla face ou cola quente. Monte o pack de baterias próximo e prenda quaisquer fios soltos com fita ou cola.

Faça upload do código de exemplo usando um computador, cabo USB e o Arduino IDE. Alternativamente, você pode acessar, editar e fazer upload do código de exemplo usando o Arduino Web Editor.

Teste!

O código de exemplo muda as cores dos LEDs baseando-se no ângulo do espelho, lido do acelerômetro no Módulo Intel Curie. Atualmente, uma posição apaga todas as luzes, e um ângulo cria um efeito de luz perseguindo com a última cor usada. Sinta-se à vontade para mergulhar no código e criar efeitos de iluminação malucos! O excelente Guia Uberguide Adafruit NeoPixel é um ótimo ponto de partida.

IMPORTANTE! Se quiser instalar permanentemente este espelho, pode usar uma fonte de alimentação plug-in em vez do pack de baterias, mas certifique-se de que a saída seja 3.5V - 5V! Qualquer tensão maior (como bateria 9V quadrada) pode sobrecarregar a fita de LED.

Código

Sketch Arduino 101 Infinity Mirror Arduino

Sketch simples que lê o ângulo do Arduino 101 pelo acelerômetro interno e usa o ângulo para controlar as cores de uma fita LED NeoPixel.

/* Copyright (c) 2016 Intel Corporation. All rights reserved. See license notice at end of file. 
Arduino 101 "Infinity Mirror." A rotação do Arduino 101 muda as luzes em uma fita Neopixel. 
Este código usa a biblioteca Adafruit Neopixel. 
Instruções de instalação: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-installation 
Se usar a versão desktop do Arduino IDE, certifique-se de ter o Intel Curie Core mais recente instalado. 
Para mais info, visite https://www.arduino.cc/en/Guide/Arduino101 */ 
#include "CurieIMU.h" 
#include <Adafruit_NeoPixel.h> 
#define PIN 6 //// em que pino os NeoPixels estão conectados? 
Adafruit_NeoPixel strip = Adafruit_NeoPixel(54, PIN, NEO_GRB + NEO_KHZ800); 
/// a fita tem 54 pixels. Altere para o número de pixels da sua fita. 
int tr = 0; // variáveis para "cor-alvo" e "cor-atual" para suavização... 
int tg = 0; 
int tb = 0; 
int r = 0; 
int g = 0; 
int b = 0; 
int rawX = 0; ///// para guardar valores do acelerômetro do Curie 
int rawY = 0; 
//int rawZ = 0; 
float angle = 0.0; 

void setup() { 
  //Serial.begin(9600); //para debug. 
  CurieIMU.begin(); 
  CurieIMU.setAccelerometerRange(2); // Define alcance do acelerômetro para 2g. 
  strip.begin(); // inicializa fita neopixel 
  strip.show(); // Inicializa todos os pixels como 'desligados' 
} 

void loop() { 
  // lê acelerômetro: 
  int rawX = CurieIMU.readAccelerometer(X_AXIS); 
  int rawY = CurieIMU.readAccelerometer(Y_AXIS); 
  int rawZ = CurieIMU.readAccelerometer(Z_AXIS); 
  angle = atan2(rawX, rawY); // a função atan2() converte forças x e y em ângulo em radianos. Legal! Saída -3.14 a 3.14 
  if (abs(angle) > 2.5) { // pinos digitais para baixo 
    /// apaga luzes nesta posição 
    tr = 0; tg = 0; tb = 0; 
    runlights(); 
  } 
  if ((angle > 1.5) && (angle < 2.5)) { // luzes brancas nesta posição (r, g e b iguais.) Valores de cor até 255, mas acho brilho suficiente em 100. 
    tr = 100; tg = 100; tb = 100; 
    runlights(); 
  } else if ((angle < 1.5) && (angle > 0.5)) { // luzes vermelhas nesta posição 
    tr = 100; tg = 0; tb = 0; 
    runlights(); 
  } else if ((angle < 0.5) && (angle > -0.5)) { // luzes verdes nesta posição 
    tr = 0; tg = 100; tb = 0; 
    runlights(); 
  } else if ((angle < -1.5) && (angle > -2.5)) { // luzes azuis nesta posição 
    tr = 0; tg = 0; tb = 100; 
    runlights(); 
  } else if ((angle < -0.5) && (angle > -1.5)) { 
    //// escolhendo um ângulo de canto para algo divertido! 
    theaterChase(); /// estas funções estão escritas no final do sketch. 
    //rainbowCycle(2); 
  } else { 
    //// em caso de ângulo inesperado, apaga luzes. 
    tr = 0; tg = 0; tb = 0; 
    runlights(); 
  } 
} 

void runlights() { 
  /// suavização de cor. Cor atual move em direção à cor alvo... 
  // Se alvo maior que atual, incrementa, se menor, decrementa. 
  if (tr > r + 1) { r++; } 
  if (tg > g + 1) { g++; } 
  if (tb > b + 1) { b++; } 
  if (tr < r) { r--; } 
  if (tg < g) { g--; } 
  if (tb < b) { b--; } 
  // liga todos os LEDS com os valores atuais r, g, b. 
  for (int i = 0; i < strip.numPixels(); i++) { 
    strip.setPixelColor(i, r, g, b); 
  } 
  strip.show(); 
  delay(10); // atraso para temporização de fade simples. 
} 

///////////////Funções especiais de luz do Adafruit Strandtest Example Code 
// Arco-íris! Nota- esta função bloqueia novas entradas de posição até terminar. 
void rainbowCycle(uint8_t wait) { 
  uint16_t i, j; 
  for(j=0; j<256*5; j++) { // 5 ciclos de todas as cores na roda 
    for(i=0; i< strip.numPixels(); i++) { 
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); 
    } 
    strip.show(); 
    delay(wait); 
  } 
} 

//////Luzes Theater Chase do código de exemplo Adafruit strandtest. 
// Pega o valor RGB atual e faz efeito "theatre chase" com ele. 
void theaterChase(){ 
  for (int j = 0; j < 3; j++) { // 3 ciclos de perseguição 
    for (int q = 0; q < 3; q++) { 
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) { 
        strip.setPixelColor(i + q, r, g, b); // liga cada terceiro pixel 
      } 
      strip.show(); 
      delay(50); 
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) { 
        strip.setPixelColor(i + q, 0); // desliga cada terceiro pixel 
      } 
    } 
  } 
} 

// Entrada valor 0 a 255 para obter valor de cor. Usado para efeito arco-íris acima. 
// As cores são transição r - g - b - de volta a r. 
uint32_t Wheel(byte WheelPos) { 
  WheelPos = 255 - WheelPos; 
  if(WheelPos < 85) { 
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3); 
  } 
  if(WheelPos < 170) { 
    WheelPos -= 85; 
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3); 
  } 
  WheelPos -= 170; 
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0); 
} 

//////////////////////////////////////////////////////////////////////////////////////////// 
/* This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */