Cúpula LED Geodésica Interativa: 15 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Construí uma cúpula geodésica composta por 120 triângulos com um LED e sensor em cada triângulo. Cada LED pode ser endereçado individualmente e cada sensor é ajustado especificamente para um único triângulo. A cúpula é programada com um Arduino para acender e produzir um sinal MIDI dependendo de qual triângulo você posiciona sua mão.

Eu projetei a cúpula para ser uma exibição divertida que faz as pessoas se interessarem por luz, eletrônicos e som. Como a cúpula se divide perfeitamente em cinco partes, projetei a cúpula para ter cinco saídas MIDI separadas, cada uma com um som diferente. Isso torna a cúpula um instrumento musical gigante, ideal para tocar música com várias pessoas ao mesmo tempo. Além de tocar música, também programei a cúpula para shows de luzes e para tocar uma versão de Simon e Pong. A estrutura final tem pouco mais de um metro de diâmetro e 70 cm de altura e é construída principalmente com madeira, acrílico e peças impressas em 3D.

Existem vários ótimos Instructables em mesas e cubos de LED que me inspiraram a iniciar este projeto. No entanto, eu queria tentar organizar os LEDs em uma geometria diferente. Eu não poderia pensar em uma estrutura melhor para o projeto do que uma cúpula geodésica, que também está bem documentada no Instructables. Portanto, este projeto é um remix / mashup de mesas de LED e domos geodésicos. Abaixo estão os links para a tabela de LED e cúpula geodésica Instructables que verifiquei no início do projeto.

Mesas e cubos de LED:

www.instructables.com/id/RGB-LED-Pixel-Touc…

www.instructables.com/id/Touch-LED-Table-Re…

www.instructables.com/id/Led-Cube-8x8x8/

www.instructables.com/id/500-LED-Pixel-RGB-…

Domo geodésico:

www.instructables.com/id/Folding-Geodesic-D…

www.instructables.com/id/Geodesic-dome-kit/

Etapa 1: Lista de suprimentos

Materiais:

1. Madeira para escoras da cúpula e base da cúpula (a quantidade depende do tipo e tamanho da cúpula)

2. Faixa de LED endereçável (16,4 pés / 5 m de cor endereçável LED Pixel Faixa 160leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - montado)

4. Placa protótipo (Penta Angel Double-Side Prototype PCB Universal (7x9cm))

5. Acrílico para difundir LEDs (Folha de acrílico fundido, transparente, tamanho 12 "x 12" x 0,118 ")

6. Fonte de alimentação (Aiposen 110 / 220V para DC12V 30A 360W Switch Power Supply Driver)

7. Conversor Buck para Arduino (RioRand LM2596 DC-DC Buck Converter 1,23 V-30 V)

8. Conversor Buck para LEDs e sensores (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 sensores IR (Módulo infravermelho do sensor de prevenção de obstáculos)

10. Cinco multiplexadores de 16 canais (Analógico / Digital MUX Breakout - CD74HC4067)

11. Seis multiplexadores de 8 canais (Multiplexer Breakout - 8 canais (74HC4051))

12. Cinco multiplexadores de 2 canais (MAX4544CPA +)

13. Fio para embrulhar (PCB de solda de 0,25 mm de diâmetro do cabo de cobre folheado a estanho Fio para embrulhar 305M 30AWG Vermelho)

14. Cabo de conexão (núcleo sólido, 22 AWG)

15. Cabeçalhos de pino (Gikfun 1 x 40 pinos 2,54 mm Cabeçalho de pino macho separável de linha única)

16. Cinco conectores MIDI (conector MIDI compatível com placa de ensaio (DIN de 5 pinos))

17. Dez resistores de 220 ohms para conectores MIDI

18. Espaçadores distantes para a montagem de componentes eletrônicos na cúpula (Espaçador distanciador Hex M3 Macho x M3 Fêmea)

19. Adaptadores de rosca para conectar espaçadores à madeira (inserção roscada E-Z Lok, latão, fio de faca)

20. Epóxi ou Gorila Supercola

21. Fita isolante

22. Solda

Ferramentas:

1. Estação de solda

2. Furadeira

3. Serra circular

4. Lixadeira orbital

5. Jig serra

6. Serra de esquadria

7. Transferidor

8. impressora 3D

9. Cortadores de fio

10. Ferramenta de enrolamento de arame

11. Cortador a laser para corte de placas de LED (opcional)

12. Shopbot CNC para base da cúpula (opcional)

Etapa 2: Projetando a Cúpula Geodésica

Como mencionei na introdução, existem várias fontes online para construir sua própria cúpula geodésica. Esses sites fornecem calculadoras de cúpula que determinam o comprimento de cada lado (ou seja, suporte) e o número de conectores necessários para qualquer tipo de cúpula que você deseja construir. A complexidade de uma cúpula geodésica (ou seja, a densidade dos triângulos) é especificada por sua classe (1V, 2V, 3V e assim por diante), com a maior complexidade se tornando uma melhor aproximação de uma superfície esférica perfeita. Para construir sua própria cúpula, você deve primeiro selecionar um diâmetro e uma classe de cúpula.

Usei um site chamado Domerama para me ajudar a projetar uma cúpula de 4V que foi truncada para 5/12 de uma esfera com raio de 40 cm. Para este tipo de cúpula, existem seis suportes de comprimentos diferentes:

30 X “A” - 8,9 cm

30 X “B” - 10,4 cm

50 X “C” - 12,4 cm

40 X “D” - 12,5 cm

20 X “E” - 13,0 cm

20 X “F” - 13,2 cm

Isso é um total de 190 escoras que somam 2.223 cm (73 pés) de material. Usei madeira de pinho 1x3 (3/4 "× 2-1 / 2") para as escoras nesta cúpula. Para conectar os struts, projetei conectores impressos em 3D usando o Autocad. Os arquivos STL estão disponíveis para download no final desta etapa. O número de conectores para uma cúpula 4V 5/12 é:

20 X 4 conectores

Conector 6 X 5

Conector 45 X 6

Na próxima etapa, descrevo como esta cúpula é construída com os suportes de madeira e os conectores impressos em 3D que projetei.

Etapa 3: Construindo uma cúpula com suportes e conectores

Usando os cálculos da Domerama para uma cúpula 4V 5/12, cortei as escoras com uma serra circular. As hastes 190 foram etiquetadas e colocadas em uma caixa após o corte. Os 71 conectores (20 quatro conectores, 6 cinco conectores e 45 seis conectores) foram impressos em 3D usando um Makerbot. As escoras de madeira foram inseridas nos conectores de acordo com o diagrama elaborado pela Domerama. Comecei a construção de cima e me movi radialmente para fora.

Depois que todas as escoras foram conectadas, removi uma escora de cada vez e adicionei epóxi à madeira e ao conector. Os conectores foram projetados para ter flexibilidade na forma como conectam as estruturas, por isso era importante verificar a simetria da cúpula antes de adicionar qualquer epóxi.

Etapa 4: Corte a laser e montagem de placas de base

Agora que o esqueleto da cúpula está construído, é hora de cortar as placas de base triangulares. Essas placas de base são fixadas na parte inferior dos suportes e são usadas para montar os LEDs na cúpula. Eu inicialmente cortei as placas de base de madeira compensada de 5 mm (3/16 ) de espessura medindo os cinco triângulos diferentes que estão na cúpula: AAB (30 triângulos), BCC (25 triângulos), DDE (20 triângulos), CDF (40 triângulos)) e EEE (5 triângulos). As dimensões de cada lado e a forma dos triângulos foram determinadas usando uma calculadora de cúpula (Domerama) e alguma geometria. Depois de cortar as placas de base de teste com uma serra de vaivém, desenhei o triângulo usando Coral Draw e cortei as placas de base restantes com um cortador a laser (muito mais rápido!). Se você não tiver acesso a um cortador a laser, pode desenhar as placas de base em madeira compensada usando uma régua e transferidor e cortá-las todas com um quebra-cabeças. Uma vez que as placas de base são cortadas, a cúpula é virada e as placas são coladas na cúpula com cola de madeira.

Etapa 5: Visão geral de eletrônicos

Na figura acima, é mostrado um esquema dos componentes eletrônicos da cúpula. Um Arduino Uno é usado para escrever e ler sinais para a cúpula. Para iluminar a cúpula, uma faixa de LED RGB é passada sobre a cúpula de forma que um LED seja posicionado em cada um dos 120 triângulos. Para obter informações sobre como funciona uma faixa de LED, verifique este instrutível. Cada LED pode ser endereçado separadamente usando o Arduino, que produz dados seriais e sinal de clock para a tira (veja o pino A0 e A1 no esquema). Com a faixa e esses dois sinais sozinhos, você pode ter uma incrível iluminação para cima. Existem outras maneiras de escrever sinais para muitos LEDs de um Arduino, como Charlieplexing e shift registers.

Para interagir com a cúpula, configurei um sensor IR acima de cada LED. Esses sensores são usados para detectar quando a mão de alguém está perto de um triângulo na cúpula. Como cada triângulo na cúpula tem seu próprio sensor de infravermelho e existem 120 triângulos, você terá que fazer algum tipo de multiplexação antes do Arduino. Decidi usar cinco multiplexadores de 24 canais (MUX) para os 120 sensores na cúpula. Aqui está uma instrução sobre multiplexação, se você não estiver familiarizado. Um MUX de 24 canais requer cinco sinais de controle. Escolhi os pinos 8-12 no Arduino para poder fazer a manipulação de portas (consulte a Etapa 10 para obter mais informações). A saída das placas MUX é lida usando os pinos 3-7.

Também incluí cinco saídas MIDI na cúpula para que ela pudesse produzir som (Etapa 11). Em outras palavras, cinco pessoas podem tocar a cúpula simultaneamente, com cada saída reproduzindo um som diferente. Há apenas um pino TX no Arduino, portanto, cinco sinais MIDI requerem demultiplexação. Como a saída MIDI é produzida em um momento diferente da leitura do sensor IV, usei os mesmos sinais de controle.

Depois que todas as entradas do sensor IR são lidas no Arduino, a cúpula pode acender e reproduzir sons independentemente da programação do Arduino. Eu tenho alguns exemplos na Etapa 14 deste instrutível.

Etapa 6: Montagem de LEDs na cúpula

Como a cúpula é muito grande, a faixa de LED precisa ser cortada para colocar um LED em cada triângulo. Cada LED é colado no triângulo com super cola. Em cada lado do LED, um orifício é feito na placa de base para que os cabos passem pela cúpula. Em seguida, soldei o fio de conexão em cada contato do LED (5 V, aterramento, relógio, sinal) e alimentei os fios pela placa de base. Esses fios são cortados de modo que sejam longos o suficiente para alcançar o próximo LED na cúpula. Os fios são puxados para o próximo LED e o processo continua. Eu conectei os LEDs em uma configuração que minimizaria a quantidade de fio necessária, mas ainda faria sentido para endereçar os LEDs usando o Arduino posteriormente. Uma cúpula menor eliminaria a necessidade de cortar a tira e economizaria muito tempo de soldagem. Outra opção é usar LEDS RGB separados com registradores de deslocamento.

A comunicação serial com a faixa é obtida usando dois pinos (um pino de dados e de clock) do Arduino. Em outras palavras, os dados para iluminar a cúpula são passados de um LED para o próximo à medida que sai do pino de dados. Aqui está um exemplo de código modificado neste fórum do Arduino:

// Faz com que a cúpula inteira aumente e diminua a intensidade de uma única cor

#define numLeds 120 // Número de LEDs // PINOS DE SAÍDA // int clockPin = A1; // define o pino do relógio int dataPin = A0; // define o pino de dados // VARIABLES // int red [numLeds]; // Inicializar array para faixa de LED int green [numLeds]; // Inicializar array para faixa de LED int blue [numLeds]; // Inicializar matriz para faixa de LED // CONSTANTE dupla escala A = {0, 0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9, 1, 0,9, 0,8, 0,7, 0,6, 0,5, 0,4, 0,3, 0,2, 0,1}; // fração da intensidade dos LEDs void setup () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); conjunto mems (vermelho, 0, numLeds); conjunto mems (verde, 0, numLeds); conjunto mems (azul, 0, numLeds); } void updatestring (int redA [numLeds], int greenA [numLeds], int blueA [numLeds]) {for (int i = 0; i <numLeds; i ++) {shiftOut (dataPin, clockPin, MSBFIRST, redA ); shiftOut (dataPin, clockPin, MSBFIRST, greenA ); shiftOut (dataPin, clockPin, MSBFIRST, blueA ); }} void loop () {for (int p = 0; p <20; p ++) // loop para aumentar a intensidade da luz da cúpula {double scale = scaleA [p]; atraso (20); for (int i = 0; i <numLeds; i ++) // percorre todos os LEDS {vermelho = 255 * escala; verde = 80 * escala; azul = 0; } cadeia de atualização (vermelho, verde, azul); // atualizar faixa de led}}

Etapa 7: Projeto e implementação da montagem do sensor

Decidi usar sensores infravermelhos para a cúpula. Esses sensores possuem um LED infravermelho e um receptor. Quando um objeto fica na frente do sensor, alguma radiação IR do LED IR é refletida em direção ao receptor. Comecei este projeto fazendo meus próprios sensores IR, que foram baseados nos instrutíveis de Richardouvina. Toda a soldagem demorou muito, então comprei 120 sensores infravermelhos do eBay, cada um produzindo uma saída digital. O limite do sensor é definido com um potenciômetro na placa de forma que a saída seja alta apenas quando uma mão estiver perto desse triângulo.

Cada triângulo consiste em uma placa de base de LED de compensado, uma folha de acrílico difusivo montada cerca de 2,5 cm acima da placa de LED e um sensor de infravermelho. O sensor para cada triângulo foi montado em uma folha de madeira compensada fina em forma de pentágono ou hexágono, dependendo da posição na cúpula (veja a figura acima). Fiz furos na base do sensor de infravermelho para montar os sensores de infravermelho e, em seguida, conectei o aterramento e os pinos de 5 V com fio de enrolamento e uma ferramenta de enrolamento (fios vermelho e preto). Depois de conectar o aterramento e 5 V, enrolei um fio longo em cada saída (amarelo), aterramento e 5 V para passar pelo dome.

As montagens do sensor IV hexágono ou pentágono foram então epóxidas para a cúpula, logo acima dos conectores impressos em 3D, para que o fio pudesse passar pela cúpula. Ao ter os sensores acima dos conectores, também fui capaz de acessar e ajustar os potenciômetros nos sensores IR que controlam a sensibilidade dos sensores. Na próxima etapa, descreverei como as saídas dos sensores IR são conectadas a multiplexadores e lidas no Arduino.

Etapa 8: Multiplexação de saída do sensor

Como o Arduino Uno tem apenas 14 pinos de E / S digitais e 6 pinos de entrada analógica e há 120 sinais de sensor que devem ser lidos, a cúpula requer multiplexadores para ler todos os sinais. Escolhi construir cinco multiplexadores de 24 canais, cada um lendo 24 dos sensores IR (veja a figura de visão geral da eletrônica). O MUX de 24 canais consiste em uma placa de breakout MUX de 8 canais, placa de breakout MUX de 16 canais e MUX de 2 canais. Cabeçalhos de pinos foram soldados a cada placa de breakout para que pudessem ser conectados à placa de protótipo. Usando uma ferramenta wire-wrap, eu então conectei o aterramento, 5 V, e os pinos de sinal de controle das placas de breakout MUX.

Um MUX de 24 canais requer cinco sinais de controle, que escolhi para conectar ao pino 8-12 no Arduino. Todos os cinco MUX de 24 canais recebem os mesmos sinais de controle do Arduino, então conectei o fio dos pinos do Arduino ao MUX de 24 canais. As saídas digitais dos sensores IR são conectadas aos pinos de entrada do MUX de 24 canais para que possam ser lidas em série para o Arduino. Como há cinco pinos separados para leitura em todas as 120 saídas do sensor, é útil imaginar a cúpula sendo dividida em cinco seções separadas consistindo de 24 triângulos (verifique as cores da cúpula na figura).

Usando a manipulação de porta do Arduino, você pode incrementar rapidamente os sinais de controle enviados pelos pinos 8-12 para os multiplexadores. Anexei alguns códigos de exemplo para operar os multiplexadores aqui:

int numChannel = 24;

// SAÍDAS // int s0 = 8; // controle MUX 0 - PORTbD int s1 = 9; // controle MUX 1 - PORTb int s2 = 10; // controle MUX 2 - PORTb int s3 = 11; // controle MUX 3 - PORTb int s4 = 12; // Controle MUX 4 - PORTb // ENTRADAS // int m0 = 3; // MUX input 0 int m1 = 4; // entrada MUX 1 int m2 = 5; // MUX input 2 int m3 = 6; // MUX input 3 int m4 = 7; // Entrada MUX 4 // VARIÁVEIS // int arr0r; // leitura digital de MUX0 int arr1r; // leitura digital de MUX1 int arr2r; // leitura digital de MUX2 int arr3r; // leitura digital de MUX3 int arr4r; // leitura digital de MUX4 void setup () {// coloque seu código de configuração aqui, para executar uma vez: DDRB = B11111111; // define os pinos 8 a 13 do Arduino como entradas pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, INPUT); pinMode (m1, INPUT); pinMode (m2, INPUT); pinMode (m3, INPUT); pinMode (m4, INPUT); } void loop () {// coloque seu código principal aqui, para executar repetidamente: PORTB = B00000000; // AJUSTE os pinos de controle para mux baixo para (int i = 0; i <numChannel; i ++) {// Saída de leitura digital de MUX0 - MUX4 para sensor IR i // Se o sensor IR for LO, o triângulo está sendo tocado pelo jogador. arr0r = digitalRead (m0); // leitura do Mux 0, sensor IR i arr1r = digitalRead (m1); // leitura do Mux 1, sensor IR i arr2r = digitalRead (m2); // leitura do Mux 2, sensor IR i arr3r = digitalRead (m3); // leitura do Mux 3, sensor IR i arr4r = digitalRead (m4); // lendo do Mux 4, sensor IR i // FAÇA ALGUMA COISA COM AS ENTRADAS DE MUX OU ARMAZENE AQUI EM UM ARRAY // PORTB ++; // incrementa os sinais de controle para MUX}}

Etapa 9: Difusão de luz com acrílico

Para difundir a luz dos LEDs, lixei acrílico transparente com uma lixadeira orbital circular. A lixadeira foi movida sobre os dois lados do acrílico em um movimento em forma de 8. Achei esse método muito melhor do que a tinta spray de “vidro fosco”.

Depois de lixar e limpar o acrílico, usei um cortador a laser para cortar triângulos para caber nos LEDs. É possível cortar o acrílico com uma ferramenta de corte de acrílico ou mesmo um quebra-cabeças se o acrílico não quebrar. O acrílico foi colocado sobre os LEDs por retângulos de madeira compensada de 5 mm de espessura, também cortados com um cortador a laser. Essas pequenas tábuas foram coladas às escoras da cúpula e os triângulos de acrílico foram colados com epóxi nas tábuas.

Etapa 10: Fazendo música com o Dome usando MIDI

Eu queria que a cúpula fosse capaz de produzir som, então configurei cinco canais MIDI, um para cada subconjunto da cúpula. Primeiro, você precisa comprar cinco conectores MIDI e conectá-los conforme mostrado no esquema (consulte este tutorial do suporte do Arduino para obter mais informações).

Como há apenas um pino serial de transmissão no Arduino Uno (pino 2 rotulado como pino TX), você precisa desmultiplexar os sinais enviados para os cinco conectores MIDI. Usei os mesmos sinais de controle (pino 8-12), porque os sinais MIDI são enviados em um momento diferente do que quando os sensores IR estão sendo lidos no Arduino. Esses sinais de controle são enviados a um demultiplexador de 8 canais para que você controle qual conector MIDI recebe o sinal MIDI criado pelo Arduino. Os sinais MIDI foram gerados pelo Arduino com a fantástica biblioteca de sinais MIDI criada por François Best. Aqui está um exemplo de código para produzir várias saídas MIDI para diferentes conectores MIDI com um Arduino Uno:

#include // inclui biblioteca MIDI

#define numChannel 24 // Número de IR por triângulo #define numSections 5 // número de seções na cúpula, número de 24 canais MUX, número de conectores MIDI // OUTPUTS // int s0 = 8; // controle MUX 0 - PORTbD int s1 = 9; // controle MUX 1 - PORTb int s2 = 10; // controle MUX 2 - PORTb int s3 = 11; // controle MUX 3 - PORTb int s4 = 12; // Controle MUX 4 - PORTb // ENTRADAS // int m0 = 3; // MUX input 0 int m1 = 4; // entrada MUX 1 int m2 = 5; // MUX input 2 int m3 = 6; // MUX input 3 int m4 = 7; // Entrada MUX 4 // VARIÁVEIS // int arr0r; // leitura digital de MUX0 int arr1r; // leitura digital de MUX1 int arr2r; // leitura digital de MUX2 int arr3r; // leitura digital de MUX3 int arr4r; // leitura digital de MUX4 int midArr [numSections]; // Armazena se uma nota foi ou não pressionada por um dos jogadores int note2play [numSections]; // Armazena a nota a ser tocada se o sensor for tocado nas notas [numChannel] = {60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83}; int pauseMidi = 4000; // tempo de pausa entre os sinais midi MIDI_CREATE_DEFAULT_INSTANCE (); void setup () {// coloque seu código de configuração aqui, para ser executado uma vez: DDRB = B11111111; // define os pinos 8 a 13 do Arduino como entradas MIDI.begin (MIDI_CHANNEL_OFF); pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, INPUT); pinMode (m1, INPUT); pinMode (m2, INPUT); pinMode (m3, INPUT); pinMode (m4, INPUT); } void loop () {// coloque seu código principal aqui, para executar repetidamente: PORTB = B00000000; // AJUSTE os pinos de controle para mux baixo para (int i = 0; i <numChannel; i ++) {// Saída de leitura digital de MUX0 - MUX4 para sensor IR i // Se o sensor IR for LO, o triângulo está sendo tocado pelo jogador. arr0r = digitalRead (m0); // leitura do Mux 0, sensor IR i arr1r = digitalRead (m1); // leitura do Mux 1, sensor IR i arr2r = digitalRead (m2); // leitura do Mux 2, sensor IR i arr3r = digitalRead (m3); // leitura do Mux 3, sensor IR i arr4r = digitalRead (m4); // leitura do Mux 4, sensor IV i if (arr0r == 0) // Sensor na seção 0 foi bloqueado {midArr [0] = 1; // O jogador 0 atingiu uma nota, defina HI para que haja saída MIDI para o jogador 0 note2play [0] = notas ; // Nota para jogar para o Jogador 0} if (arr1r == 0) // Sensor na seção 1 foi bloqueado {midArr [1] = 1; // O jogador 0 atingiu uma nota, defina HI para que haja saída MIDI para o jogador 0 note2play [1] = notas ; // Nota para jogar para o Jogador 0} if (arr2r == 0) // Sensor na seção 2 foi bloqueado {midArr [2] = 1; // O jogador 0 atingiu uma nota, defina HI para que haja saída MIDI para o jogador 0 note2play [2] = notas ; // Nota para jogar para o Jogador 0} if (arr3r == 0) // Sensor na seção 3 foi bloqueado {midArr [3] = 1; // O jogador 0 atingiu uma nota, defina HI para que haja saída MIDI para o jogador 0 note2play [3] = notas ; // Nota para jogar para o Jogador 0} if (arr4r == 0) // Sensor na seção 4 foi bloqueado {midArr [4] = 1; // O jogador 0 atingiu uma nota, defina HI para que haja saída MIDI para o jogador 0 note2play [4] = notas ; // Nota para jogar para o jogador 0} PORTB ++; // incrementa os sinais de controle para MUX} updateMIDI (); } void updateMIDI () {PORTB = B00000000; // AJUSTE os pinos de controle para mux low if (midArr [0] == 1) // Player 0 Saída MIDI {MIDI.sendNoteOn (note2play [0], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [0], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // incrementa MUX if (midArr [1] == 1) // Saída MIDI do jogador 1 {MIDI.sendNoteOn (note2play [1], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [1], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // incrementa MUX if (midArr [2] == 1) // Saída MIDI do jogador 2 {MIDI.sendNoteOn (note2play [2], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [2], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // incrementa MUX if (midArr [3] == 1) // Saída MIDI do jogador 3 {MIDI.sendNoteOn (note2play [3], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [3], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // incrementa MUX if (midArr [4] == 1) // Saída MIDI do Player 4 {MIDI.sendNoteOn (note2play [4], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [4], 127, 1); delayMicroseconds (pauseMidi); } midArr [0] = 0; midArr [1] = 0; midArr [2] = 0; midArr [3] = 0; midArr [4] = 0; }

Etapa 11: Ligar a cúpula

Existem vários componentes que precisam ser alimentados na cúpula. Portanto, você precisará calcular os amperes consumidos de cada componente para determinar a fonte de alimentação que você precisa comprar.

A tira de LED: Usei aproximadamente 3,75 metros da tira de LED Ws2801, que consome 6,4 W / metro. Isso corresponde a 24W (3,75 * 6,4). Para converter em amperes, use Potência = corrente * volts (P = iV), onde V é a tensão da faixa de LED, neste caso 5V. Portanto, a corrente consumida dos LEDs é 4,8 A (24 W / 5 V = 4,8 A).

Os sensores IR: cada sensor IR consome cerca de 25mA, totalizando 3A para 120 sensores.

O Arduino: 100mA, 9V

Os multiplexadores: Existem cinco multiplexadores de 24 canais, cada um composto por um multiplexador de 16 canais e um multiplexador de 8 canais. O MUX de 8 canais e 16 canais cada um consome cerca de 100 mA. Portanto, o consumo total de energia de todos os MUX é 1A.

Somando esses componentes, o consumo total de energia é esperado em cerca de 9A. A faixa de LED, sensores IR e multiplexadores têm tensão de entrada de 5 V, e o Arduino tem tensão de entrada de 9 V. Portanto, selecionei uma fonte de alimentação de 12 V 15 A, um conversor buck de 15 A para converter 12 V em 5 V e um conversor buck 3 A para converter 12 V em 9 V para o Arduino.

Etapa 12: Base de cúpula circular

A cúpula repousa sobre uma peça circular de madeira com um pentágono cortado no meio para facilitar o acesso aos componentes eletrônicos. Para criar esta base circular, uma folha de madeira compensada de 4x6 'foi cortada usando uma fresadora CNC de madeira. Um quebra-cabeça também pode ser usado para esta etapa. Depois que a base foi cortada, a cúpula foi presa a ela usando pequenos blocos de 2x3”de madeira.

Na parte superior da base, conectei a fonte de alimentação com epóxi e os conversores MUX e Buck com espaçadores de PCB. Os espaçadores foram fixados ao compensado usando adaptadores de rosca E-Z Lok.

Etapa 13: Base da cúpula do Pentágono

Além da base circular, também construí uma base em pentágono para a cúpula com uma janela de espelho na parte inferior. Esta base e janela panorâmica também foram feitas de madeira compensada cortada com uma fresadora CNC de madeira. Os lados do pentágono são feitos de pranchas de madeira e um dos lados tem um orifício para a passagem dos conectores. Usando suportes de metal e juntas de bloco 2x3, as pranchas de madeira são fixadas à base do pentágono. Um botão liga / desliga, conectores MIDI e conector USB são anexados a um painel frontal que criei usando um cortador a laser. Toda a base do pentágono é aparafusada à base circular descrita na Etapa 12.

Eu instalei uma janela na parte inferior da cúpula para que qualquer pessoa possa olhar para a cúpula e ver os componentes eletrônicos. O espelho é feito de acrílico cortado com um cortador a laser e é epóxi em uma peça circular de madeira compensada.

Etapa 14: Programando a cúpula

Existem infinitas possibilidades para programar a cúpula. Cada ciclo do código recebe os sinais dos sensores IR, que indicam os triângulos que foram tocados por alguém. Com essas informações, você pode colorir a cúpula com qualquer cor RGB e / ou produzir um sinal MIDI. Aqui estão alguns exemplos de programas que escrevi para a cúpula:

Pinte a cúpula: cada triângulo percorre quatro cores à medida que é tocado. Conforme as cores mudam, um arpejo é tocado. Com este programa, você pode colorir a cúpula de milhares de maneiras diferentes.

Música de cúpula: a cúpula é colorida com cinco cores, cada seção correspondendo a uma saída MIDI diferente. No programa, você pode escolher quais notas cada triângulo toca. Escolhi começar no dó médio no topo da cúpula e aumentar a inclinação conforme os triângulos se aproximavam da base. Como existem cinco saídas, este programa é ideal para que várias pessoas joguem na cúpula simultaneamente. Usando um instrumento MIDI ou software MIDI, esses sinais MIDI podem soar como qualquer instrumento.

Simon: Eu escrevi uma versão de Simon, o clássico jogo de iluminar a memória. Uma sequência aleatória de luzes é iluminada uma de cada vez em toda a cúpula. Em cada jogada, o jogador deve copiar a sequência. Se o player corresponder à sequência corretamente, uma luz adicional será adicionada à sequência. A pontuação mais alta é armazenada em uma das seções da cúpula. Este jogo também é muito divertido de jogar com várias pessoas.

Pong: Por que não jogar pong em uma cúpula? Uma bola se propaga pela cúpula até atingir a raquete. Quando isso acontece, um sinal MIDI é produzido, indicando que a raquete acertou a bola. O outro jogador deve então direcionar a raquete ao longo da parte inferior da cúpula de modo que acerte a bola de volta.

Etapa 15: fotos da cúpula concluída

Grande Prêmio no Arduino Contest 2016

Segundo prêmio no concurso de remix 2016

Segundo prêmio no Make it Glow Contest 2016