Cubo de LED RGB com Bluetooth App + AnimationCreator: 14 etapas (com imagens)

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

Este é um instrutivo sobre como construir um cubo 6x6x6 RGB LED (ânodos comuns) controlado por um aplicativo Bluetooth usando um Arduino Nano. A construção inteira é facilmente adaptável a um cubo 4x4x4 ou 8x8x8. Este projeto é inspirado em GreatScott. Decidi ir para uma construção mais sofisticada usando leds maiores (8 mm), com menos distância + adição de comunicação Bluetooth que torna a adição de novas funções muito mais fácil e também adiciona a capacidade de construir um aplicativo para controlar o cubo. Isso também me permite, por exemplo, codifique um Snake Game (terceiro vídeo de demonstração no final). Além disso, adicionei um modo de visualização de áudio que permite ao cubo visualizar uma entrada AUX, por exemplo Música usando um MSGEQ7 (vídeo de demonstração no final). Além disso, escrevi um aplicativo AnimationCreator em Java com uma IU fácil de usar para criar e ajustar animações, para que qualquer pessoa possa construir animações personalizadas muito rapidamente. Portanto, o Sketch + Bluetooth App fornece uma estrutura para qualquer configuração de LED Cube e com o Animation Creator você não precisa se preocupar com a implementação de animações personalizadas.

Links para o aplicativo Arduino Sketch e Bluetooth:

RGBCube_Arduino Sketch (Github) + Animation Creator.jar

Aplicativo Cubo Bluetooth (Github)

Lista de peças para o cubo:

• LED RGB 216x (ânodo comum) (8 mm) (AliExpress / Ebay) -> 6x6x6 = 216
• Cabo de fita (1m 40Pin deve ser suficiente) (AliExpress / Ebay / Amazon)
• Cabeçalhos femininos e masculinos (pelo menos 4x40 pinos cada) (AliExpress / Ebay / Amazon)
• Fio de cobre / prata estanhado 0,8 mm (~ 25 metros) (AliExpress / Ebay / Amazon)
• Tubo encolhível (AliExpress / Ebay / Amazon)

Lista de peças para as placas de controle:

• 7 x driver LED TLC5940 (Ebay / AliExpress)
• 6 x IRF 9540 P-Channel MOSFETs (Amazon / Ebay / AliExpress)
• 8 x 10 capacitores uF (Amazon / Ebay / AliExpress)
• 3 x 1000 uF capacitores (Amazon / Ebay / AliExpress)
• 14x resistores de 2,2 kOhm (Amazon / Ebay / AliExpress)
• 1 x 1 kOhm Resistor (Amazon / Ebay / AliExpress)
• 7 x 28 pinos IC Sockets (Amazon / Ebay / AliExpress)
• 1 x Arduino Nano (Amazon / Ebay / AliExpress)
• 1 x diodo 1N4001 (qualquer diodo comum) (Amazon / Ebay / AliExpress)
• 8 x 0,1uF Capacitores (Ebay)
• 1 x DC Jack PCB Mount (Amazon / Ebay / AliExpress)
• 1 x Módulo Bluetooth HC-05 (Amazon / Ebay / AliExpress)

Etapa 1: Teoria

Se você não estiver interessado em teoria sobre multiplexação, pule para a Etapa 2 para o início da construção real

Como o hardware e o software são partes igualmente importantes deste projeto, vamos dar uma olhada na teoria primeiro.

O cérebro do cubo é um Arduino Nano. Ele fornece E / S suficiente para interagir com os drivers de LED usados, bem como estabelecer uma conexão Bluetooth com um módulo HC-05 e outro hardware de controle. Se você já olhou para outras construções de cubos de LED, você saberá que a maioria das pessoas usa registros Shift simples para armazenar os valores de brilho das cores dos LEDs individuais. Esta construção não usa registradores Shift, mas sim os chamados Drivers de LED "TLC5940". Como veremos mais tarde, isso nos economiza muito tempo, bem como toneladas de hardware adicional (por exemplo, resistores).

A funcionalidade básica de controle do cubo usa multiplexação. Neste caso, estamos multiplexando as 6 camadas do cubo, o que significa que todos os ânodos (+) de todos os LEDs em uma camada estão conectados, enquanto os cátodos individuais de todos os LEDs na mesma coluna estão conectados na parte inferior. Isso significa que se você quiser acender o LED na posição x = 1, y = 2, z = 3, cor: verde, você precisa fornecer 5 V no ânodo da camada 3 e conectar o GND ao cátodo da coluna correspondente a Pino verde de x = 1, y = 2. Então, na realidade, em um ponto no tempo, apenas uma camada do cubo está realmente ligada, mas como você verá mais tarde no Código, estamos desligando e ligando as camadas individuais tão rápido que nossos olhos pensam que o cubo inteiro está ligado.

Para controlar coisas como brilho, animações e assim por diante, usamos um módulo Bluetooth HC-05 conectado ao Arduino Nano. É muito simples usar o módulo com um Arduino, pois você só precisa de uma conexão de 4 pinos e pode simplesmente fazer a interface do módulo por meio da comunicação serial padrão do Arduino. No final deste manual, você verá como é fácil escrever seu próprio aplicativo Bluetooth para controlar o cubo.

NOTA

No meu esquema da placa de circuito do Arduino, você também pode ver um pequeno esquema para fazer a interface de um chip MSGEQ7 para processar a entrada de áudio, isso não é absolutamente necessário para o cubo real e é apenas uma funcionalidade adicional que adicionei, portanto, você pode simplesmente ignorar o esquema marcado com "MSGEQ7"

Etapa 2: Hardware: LED Cube Build

Então, vamos dar uma olhada em como construir o próprio Cube, antes de falar sobre o circuito de controle em torno do Arduino Nano.

Lista de peças para a construção do cubo:

• LED RGB 216x (ânodo comum) (AliExpress / Ebay) -> 6x6x6 = 216
• Cabo de fita (1m 40Pin deve ser suficiente) (AliExpress / Ebay / Amazon)
• Cabeçalhos femininos e masculinos (pelo menos 4x40pin) (AliExpress / Ebay / Amazon)
• Fio de cobre / prata estanhado 0,8 mm (~ 25 metros) (AliExpress / Ebay / Amazon)
• Tubo encolhível (AliExpress / Ebay / Amazon)

A primeira coisa a fazer, e agora é entediante, mas necessário, temos que testar os LEDs. Para fazer isso, basta conectar uma fonte de alimentação, por exemplo, bloco de bateria de 9V com clipe a um violador. Como você pode ver na figura 3 o pino mais longo dos LEDs é o ânodo (+), então você conecta este pino ao + 9V da bateria. Agora, antes de conectar o GND aos cátodos de cores individuais (vermelho, verde, azul), adicione um resistor de 220 ohm a cada cátodo para limitar a corrente. Agora divirta-se testando todas as cores de todos os 216 LEDs.

Na próxima etapa, prepararemos os LEDs testados para que possamos montá-los facilmente em colunas posteriormente.

Etapa 3: Linhas de LED

Antes de podermos soldar os LEDs em suas respectivas fileiras, precisamos dobrar e cortar os cabos.

Como você pode ver na primeira foto, eu simplesmente fiz um furo de 8 mm (para LEDs de 8 mm) em um pedaço de madeira e fiz 3 furos muito pequenos à esquerda do furo do LED e outra à direita do furo. Essas brocas são marcadores para dobrar os cabos corretamente e devem ter uma distância de cerca de 1cm do meio do orifício do LED.

Esta técnica é inspirada em Steve Manley, você pode encontrar um vídeo dele fazendo isso em uma pequena variação no YouTube.

Antes de cortar e dobrar os cabos em torno das brocas, como visto nas imagens 2 e 3, certifique-se de que a orientação dos cabos corresponde à imagem 1 (azul no topo à esquerda, depois verde, ânodo + à direita e vermelho à esquerda novamente). O círculo que você dobrou nas pontas deve ter um diâmetro grande o suficiente para caber no fio de cobre estanhado (0,8 mm). Esta etapa torna muito mais fácil soldar os LEDs no lugar.

Agora que todos os LEDs estão preparados, queremos montá-los em linhas de 6 onde os ânodos (+) estão conectados:

1. Construa um pequeno gabarito como mostrado na figura 6, faça 6 furos (diâmetro de 0,8 mm) com uma distância de 2,5 cm para o próximo furo. Isso nos permite colocar 6 LEDs por vez no gabarito
2. Para conectar os ânodos, precisamos de um pedaço de fio de cobre estanhado reto de aproximadamente 16 cm de comprimento (com alguma margem extra). Para obter o fio bem reto, você pode montar uma extremidade do fio, por exemplo, em uma furadeira elétrica, prender cerca de 2 m de fios por vez em uma mesa e, em seguida, segurar a furadeira de forma que o fio fique esticado e apertado e ligue a furadeira por alguns segundos com endireita o fio muito rápido. Você pode então cortar o fio exatamente onde prendeu a peça. Você também pode usar dois alicates e apertar pedaços menores de arame de cada vez, mas isso é muito mais tedioso
3. Assim que tiver fios de 16 cm de comprimento, você os direciona através dos orifícios do ânodo (+) dos LEDs no gabarito e solda os pinos do ânodo ao fio (Figura 7)

Para todo o cubo, precisaremos de 6x6 = 36 dessas linhas de LED

Etapa 4: Montagem da Camada

Como mencionei antes, iremos multiplexar as camadas do cubo, mas para a montagem é mais fácil construir 6 paredes de 6x6 LEDs e, em seguida, montá-los lado a lado e simplesmente executar um único fio de cobre estanhado conectando os ânodos do linhas em uma camada juntos.

Esteja ciente de que esta etapa exige muito tempo e paciência para fazê-la da maneira certa, no total você terá que soldar cerca de 1000 juntas de solda para a construção, então não tenha pressa!

Para construir uma parede de LED:

1. Para o gabarito: precisamos de um pedaço de madeira com 6 linhas esculpidas para encaixar 6 linhas uma acima da outra para construir uma parede. Você pode ver o gabarito na figura 2 (distâncias entre linhas: 2,5 cm)
2. Você encaixa as 6 filas de LEDs nas esculturas, com o fio do ânodo voltado para baixo na linha esculpida, de modo que os 3 cátodos (R, G, B) fiquem voltados para cima
3. Para conectar os cátodos posicionados um acima do outro (ver figura 2), precisamos de mais alguns fios (então, novamente, 6 colunas x 3 cátodos x 6 paredes = 108 peças de fio estanhadas conforme descrito na última etapa (2.) (mesmo comprimento também))
4. Deslize os pedaços de fio da parte inferior de uma coluna através dos orifícios dos cátodos para a linha superior e solde o fio no lugar em cada LED

Você faz isso 6 vezes para obter 6 paredes de LEDs.

Agora podemos realmente montar as paredes no próprio cubo. Mas para segurar o cubo, precisamos construir algum tipo de plano de chão. Para isso, simplesmente usei um compensado fino e fiz pequenos furos de 0,8 mm nele, para encaixar os fios pendurados nas fileiras de LED mais baixas (para todas as 6 paredes de LED). As medições para os furos de um único LED são documentadas na Etapa 3 e as distâncias entre cada LED é de 2,5 cm.

Com os orifícios no lugar, pegamos a primeira parede e a colocamos nos orifícios à esquerda do compensado. A fileira de LEDs na parte inferior deve ficar bem na madeira, de modo que no final todas as paredes fiquem alinhadas da mesma forma.

Continue fazendo a mesma coisa com o resto das paredes de LED, mas lembre-se de que os ânodos das paredes sempre estão voltados para a mesma direção. (na figura 3 todos os ânodos das paredes estão voltados para a esquerda)

Uma vez que todo o cubo está no lugar, precisamos soldar os ânodos de cada camada. Para fazer isso, pegamos outro pedaço de fio reto de ~ 16 cm e colocamos no topo da primeira camada, de modo que o fio toque todos os fios do ânodo das 6 paredes em uma camada. Observe que o novo fio não toque em nenhum dos cátodos. Solde o arame no lugar e repita o mesmo para as 5 camadas restantes.

Etapa 5: Fiação do cubo

Peças para a placa de driver de LED:

• 7 x TLC5940
• 6/7 x 10 uF Capacitores
• 2 x 1000 uF capacitores
• 7x resistores de 2,2 kOhm
• 7 x 28 pinos IC Sockets
• 7 x 0,1uF Capacitores
• Cabo de fita

Passando para os circuitos de controle, vamos primeiro dar uma olhada na placa de driver de LED. Como mencionado antes, precisamos de 7 TLC5940 conectados ao Arduino Nano. Todos os Chips TLC5940 são encadeados, o que significa que todos os pinos de controle dos drivers estão interconectados (por exemplo, o pino BLANK do primeiro TLC está conectado ao BLANK do segundo, terceiro, quarto, … TLC) e estão todos conectados ao Arduinowith os mesmos fios, exceto o Serial In que é conectado primeiro de um Pino Digital Arduino ao primeiro TLC, então o pino Serial Out deste primeiro TLC é conectado ao pino SIN do segundo TLC e assim por diante (veja a figura 4) …

Portanto, o esquema da placa TLC é bastante simples, como você pode ver no esquema em anexo.

(SE VOCÊ DESEJA GRAVAR A PLACA, SALTE PARA A ETAPA 8)

Também anexei uma captura de tela do esquema em frizz, que inclui rótulos de pinos e também arquivos.xcf do GIMP com camadas para cada conexão de pino de controle separada.

Comece soldando todos os soquetes de IC no lugar, em seguida, adicionando os capacitores de 100nF a cada TLC, seguido pelos resistores de 2,2 kOhm para IREF e GND e o cabeçalho de 7 pinos no canto superior direito. Depois disso, você pode simplesmente seguir o arquivo.xcf começando com a "camada SIN" no arquivo Gimp que mostra como conectar os pinos Serial IN / OUT dos Drivers usando cabos de fita, então habilitando a camada CLK no GIMP e assim por diante. Certifique-se de que você tenha boas conexões dos pinos + e - para o cabeçalho do pino no canto superior direito O resto do esquema deve ser autoexplicativo, mas certifique-se de adicionar capacitores de 1000uF e 10uF suficientes à placa, não é tão relevante onde exatamente você os posiciona.

Assim que esta placa estiver concluída, você pode passar para a placa Arduino na próxima etapa.

Etapa 7: Arduino + placa de controle Bluetooth

Peças para a placa de controle:

• 6 MOSFETs IRF 9540 P-Channel
• 1 x 10 uF capacitores
• 1 x 1000 uF capacitores
• 7 x resistores de 2,2 kOhm
• 1 x 1 kOhm resistor
• Cabeçalho de 2 x 14 pinos fêmea
• 1 x Arduino Nano
• 1 x diodo 1N4001
• Capacitores 1 x 0,1uF
• 1 x DC Jack PCB Mount
• 1 x HC-05 Módulo Bluetooth
• 1 x tomada de áudio de 3,5 mm

A placa de controle do Arduino está lidando principalmente com a multiplexação, bem como fornecendo a contraparte do cabeçalho do pino da placa de driver de LED.

Soldando no perfboard:

1. Coloque dois cabeçotes Pin fêmea para atuar como soquete para o Arduino no meio da placa.
2. Coloque os 6 MOSFETs em uma linha um ao lado do outro no lado direito do Arduino (o lado com os pinos analógicos) e adicione um resistor de 2,2 kOhm entre o primeiro e o último pino cada.
3. Agora coloque o cabeçalho de 6 pinos na frente dos MOSFETs (meio da linha) e conecte os 6 pinos DRAIN dos FETs (pino do meio) ao cabeçalho e os pinos GATE (pino esquerdo) dos FETs aos respectivos pinos analógicos do Arduino.
4. Em seguida, solde o conector de 7 pinos para a conexão LEDDriver no outro lado do Arduino, deixe algum espaço para os cabos e solde todas as conexões do Arduino ao conector de pino.
5. Adicione alguns capacitores (1-2 1000uF, 1 10uF, 100nF próximo ao Arduino) para possíveis drenos de corrente.
6. Solde um cabeçalho de 4 pinos próximo à parte traseira do Arduino para o módulo HC-05 e faça as 4 conexões para VCC, RX, TX, GND e não se esqueça de fazer um divisor de tensão do pino RX do HC-05 e o Pin TX do Arduino (veja aqui)
7. Coloque o conector DC em qualquer borda da placa com uma chave ao lado e conecte o pino direito da chave ao + pino do conector DC
8. Por fim, faça todas as conexões de alimentação necessárias do pino GND do conector DC e do pino direito da chave (VCC) ao Arduino, MOSFETs, capacitores e HC-05 como visto no esquema. Lembre-se de adicionar o Diodo apenas concedendo a energia do pino VCC da chave para fluir para o pino do Arduinos 5V, e não o contrário. (Isso protege o Arduino ao programá-lo via conexão USB)

Para a conexão de alimentação, usei um conector de alimentação DC com um interruptor simples, você também pode usar um conector USB se quiser. Terceirizei o conector de alimentação para outra pequena placa de circuito para encaixar perfeitamente em meu estojo de madeira, mas você pode simplesmente colocá-lo diretamente na placa Arduino. Conforme mencionado na primeira etapa, há também um Circuito de Conexão MSGEQ7 no esquema, mas simplesmente ignore-o se não usar um MSGEQ7. (Para obter mais informações sobre a funcionalidade MSGEQ7 clique aqui)

Não se esqueça de fazer outro cabo de fita de 7 pinos com conectores de pino macho em cada extremidade para conectar a placa Arduino à placa do driver

Etapa 8: Opcional: Gravação das placas de circuito

Portanto, se você não gosta de soldar muitos cabos, é claro, você também pode gravar os PCBs necessários, se preferir.

No meu cubo, a placa Arduino e a placa do conector de energia / áudio são ambas placas gravadas usando os arquivos esquemáticos / EAGLE anexados. A primeira vez que cometi um erro no esquema, tive que refazer a placa do driver de LED como fiz na última etapa. Não há grandes vantagens em gravar a placa em vez de usar perboard, então sinta-se à vontade para gravar a placa ou soldá-la na perfboard.

No arquivo.zip anexado, você pode encontrar um arquivo BOARD e um arquivo SCHEMATIC.

Observe que os traços da camada superior (vermelho) devem ser pontes de arame (já que não posso gravar placas de dois lados em casa). Os traços não roteados mostram as conexões a serem feitas por meio de cabos para os conectores de pino fêmea.

O esquema inclui o recurso MSGEQ7, que você pode simplesmente omitir excluindo a seção do esquema marcada "(MSGEQ7)" na captura de tela do esquema.pdf.

Etapa 9: Conectando o cubo

Para conectar todas as partes do cubo, comece conectando o cabo de 7 pinos à placa Arduino e à placa do driver (certifique-se de que a orientação esteja correta!). Em seguida, conecte o módulo HC05 ao conector de 4 pinos e conecte a placa de alimentação se ela estiver separada.

Para conectar os cabeçalhos de 7x16 pinos do cubo, certifique-se de iniciar com o primeiro TLC (aquele cujo pino SIN está conectado diretamente ao Arduino). Encontre o cabo de 16 pinos correto do cubo e conecte-o ao primeiro cabeçalho de pino do TLC (certifique-se de que o cabo para o cátodo Nr.0 se conecte ao primeiro pino TLC OUT0!). Vá em frente e conecte os outros cabos de 16 pinos aos cabeçalhos TLC correspondentes na ordem correta.

Por último, mas não menos importante, conecte o cabo de 6 pinos para os ânodos do cubo ao conector 6 pinos na placa de controle próximo aos MOSFETs.

Para terminar o cubo, acrescentei paredes à caixa com mais um pouco de madeira compensada com tinta preta e colei.

Agora terminamos com todo o hardware necessário para toda a construção!

Etapa 10: Software: Ciclo de Multiplexação

Agora, em teoria, o Arduino está executando constantemente o seguinte ciclo:

1. Se o LayerDuration tiver passado, carregue os valores da próxima camada para os TLCs, desligue a camada atual, ative a próxima camada, redefina o LayerDuration, comprometa os novos valores para os TLCs
2. Se o FrameDuration tiver passado, carregue o novo quadro da animação atual, armazenando os valores de todos os LEDs e cores no buffer ValueLed , redefina FrameDuration
3. Se os dados do Bluetooth estiverem disponíveis, reaja a eles (alterar animações, brilho, …) (mais informações posteriormente)

Como você pode ver, o foco principal do código é a velocidade. É importante que o tempo para alterar a camada seja mínimo.

Quanto mais rápido você liga / desliga as camadas, mais "Frames" obterá. para um cubo de LED RGB 6x6x6 como este, descobri que uma duração de camada de 1700 microSeg. é bom o suficiente para manter a oscilação no mínimo e deve ser deixado com este valor. O FrameDuration controla mais a velocidade da animação para que possa ser alterado para diferentes animações.

Na próxima etapa, veremos como podemos realmente escrever nossas próprias animações.

Etapa 11: animações personalizadas

Para implementar uma animação, temos que definir o buffer ValueLed para os Valores que queremos para o próximo Quadro toda vez que FrameDuration tiver passado. Fazemos isso chamando a função Macro "SETLED (x, y, z, COLOR, Brightness)"

x, y, z são as coordenadas do LED que queremos definir e COR (VERMELHO, VERDE ou AZUL) é a cor que queremos definir e Brilho é o valor real para esta cor específica que definimos.

Portanto, para, por exemplo, implementar uma animação que simplesmente exibe as cores vermelha, verde e azul aleatoriamente em todo o cubo, você pode simplesmente fazer isso:

void randomLedsFull () {

for (uint8_t j = 0; j <CUBE_SIZE; j ++) {for (uint8_t x = 0; x <CUBE_SIZE; x ++) {for (uint8_t y = 0; y <CUBE_SIZE; y ++) {uint8_t rand = random8 (3); SETLED (x, y, j, rand, maxBright); }}}}

Este método é chamado sempre que FrameDuration passou e é selecionado no comando switch-case no loop (). Se você escrever novas animações, poderá adicioná-las simplesmente adicionando-as à caixa do interruptor.

Etapa 12: Adicional: AnimationCreator

Além disso, escrevi um AnimationCreator usando JavaFX e Java3D.

Ele torna a criação e edição de animações personalizadas muito fácil, fornecendo uma IU de fácil compreensão.

Você pode criar, editar, renomear e reconfigurar animações para cubos de LED 4x4x4, 6x6x6 ou 8x8x8

Para criar uma nova animação basta clicar em Arquivo> Novo, em "Cubo" você pode selecionar o tamanho do cubo, para definir a cor de um LED selecione a cor desejada com o seletor de cores à esquerda e clique com o botão esquerdo nos LEDs que deseja aquela cor para aquele quadro. Para adicionar outro Frame, pressione "Próximo" ou "+". O resto dos Controles de IU é bastante autoexplicativo, as caixas de seleção próximas às Camadas de Cubos são para verificar quais Camadas devem ser afetadas por deslocamento e "Manter Quadro". Basta testar e você descobrirá tudo em nenhum momento.

Além disso, para simular a animação, você pode clicar no botão "Visualizar 3D" que abre outra janela com um modelo Java3D do cubo. Você pode girar a câmera enquanto mantém pressionado o botão esquerdo do mouse (pressione R para redefinir a câmera). Para reproduzir / pausar a animação, pressione a tecla P, para redefinir a animação, pressione Q. O campo de texto abaixo do botão "View 3D" denota o atual FrameTime, portanto, a velocidade de sua animação.

Quando você terminar com a Animação, dê um nome a ela e clique em Arquivo> Salvar Como … e salve a Animação na mesma pasta que o Cubo_Control.ino Sketch.

Para incluir sua nova animação no Sketch, abra o Cubo_Control.ino e adicione o seguinte código no topo do Sketch:

#include "RGBit.h" // Substitua

Role para baixo até BTEvent () e adicione a instrução case ao switch-case das animações

switch (curAnim) {

… Caso 10: animação = & ani_cubesmove [0] [0]; FRAME_TIME = ANI_CUBESMOVE_FRAMTIME; maxCount = ANI_CUBESMOVE_FRAMES; pausa; case 11: // SUA NOVA ANIMAÇÃO animação = & ani_rgbit [0] [0]; FRAME_TIME = RGBIT_FRAMETIME; maxCount = ANI_RGBIT_FRAMES; pausa; }

Etapa 13: aplicativo Bluetooth

Para realmente controlar o Cube, graças ao Módulo HC-05 é bastante simples construir um aplicativo Bluetooth para conectar seu telefone ao Cube.

Link para o aplicativo: Github

O aplicativo é de código aberto, então fique à vontade para adicionar animações / recursos você mesmo.

• Inicie o aplicativo, ele pede para você ligar o Bluetooth
• Clique em “Pesquisar” e uma lista de conexões Bluetooth disponíveis aparece. Identifique o Módulo HC-05 no Cubo e clique nele.
• Se houver um erro ao tentar conectar ao Cube, tente emparelhar o módulo HC-05 nas configurações de Bluetooth manualmente
• Uma vez conectado, o aplicativo muda para a tela de controle e a conexão Bluetooth foi estabelecida

Controles

• Velocidade e brilho: altere os valores do controle deslizante para acelerar / desacelerar a animação ou alterar o brilho
• Animações: Clique em um botão para alterar a animação, por padrão as animações são em loop (começando do canto superior esquerdo o botão corresponde a currAnim)
• Rolagem de texto: Clique no botão "Texto" que abre uma caixa de diálogo para inserir algum texto que será rolado pelo cubo
• Comando: você pode inserir comandos manualmente com o Command TextField (consulte o método BTEvent () de Cubo_Control.ino para obter a sintaxe)
• Snake: clássico Snake Game (vermelho: maçã, verde: snake Head, blue: sneak Tail) (controles: 4 botões direcionais, para cima e para baixo acionados girando o telefone para frente (para cima) ou para trás (para baixo))
• Visualizador de áudio: MSGEQ7 usado para visualizar 6 bandas de áudio do conector AUX (botão para animação 7)

Etapa 14: Demonstração