Agitando o Arduino Dice
Componentes e suprimentos
 |
| × | 1 | |||
| × | 1 | ||||
| × | 1 | ||||
 |
| × | 1 | |||
| × | 1 |
Ferramentas e máquinas necessárias
 |
| |||
 |
|
Aplicativos e serviços online
 |
| |||
 |
|
Sobre este projeto
Cerca de um ano atrás, meu filho e I construiu dados eletrônicos com um Arduino e alguns LEDs. Este ainda é um projeto ideal para iniciantes. Aprendemos muito este ano, então é hora de uma atualização.
Os dados ainda são um projeto inicial perfeito. A função é clara para todos e de fácil compreensão nas diferentes áreas:microcontrolador, eletrónica simples e codificação.
Versão 2.0
Os dados também são fantásticos, para dar um passo adiante:ligar outras áreas.
Hoje existe um componente pronto para quase tudo. Isso é melhor visto quando se procura um kit inicial para um Arduino ou Raspberry Pi. Componentes como LEDs, botões de pressão e qualquer tipo de sensor são construídos em uma placa de circuito e, portanto, podem ser conectados e usados com apenas alguns fios para GPIOs.
Simples, mas suficientes, as impressoras 3D estão disponíveis no ebay por menos de 140 €. Quase todas as variações de suporte, montagem ou revestimento podem ser criadas com ele.
Existem várias outras oportunidades para desenvolver seus próprios projetos. Um exemplo disso são nossos novos dados 2.0.
Sensores de inclinação
Implementamos os dados de uma maneira completamente diferente. Por dentro, um Arduino Nano está funcionando por questões de espaço. Ainda há um botão liga-desliga, mas nenhum botão. O dado é feito agitando todo o cubo.
Para isso, são usados sensores de inclinação ou sensores de vibração. Eles funcionam como um botão. Em um tubo de vidro, uma bola se move. Se atingir os contatos de conexão, o circuito é fechado. Este contato, às vezes muito curto, é usado como sinal.
O movimento da bola de metal pode ser ouvido muito bem se você sacudir o sensor.
Normalmente, a posição de instalação é decisiva para um sensor de inclinação. Ele deve disparar um sinal em uma determinada posição angular. No nosso caso, isso acontece sacudindo o case. Aqui a situação não é tão importante, porque ao balançar em qualquer direção um sinal é acionado. Para garantir a segurança, usamos dois sensores no projeto, que são dispostos deslocados de 90 ° um em relação ao outro. Portanto, sempre obtemos um sinal de vibração confiável.
Interrompe
Para ser capaz de reconhecer ao tremer, os pinos de entrada dos sensores de inclinação teriam que ser consultados no esboço. No entanto, dependendo de quando isso acontece no tempo e do que mais o esboço tem a fazer, sempre existe a possibilidade de que um ou mais eventos passem despercebidos.
Uma solução melhor é usar interrupções de hardware. Isso é definido pela função attachInterrupt. Como parâmetro, é especificado um subprograma que deve ser chamado no sinal.
O Arduino oferece duas interrupções de hardware:pinos D2 e D3.
Exibir
Claro, a exibição da imagem do dado poderia ser feita novamente com 7 LEDs individuais. Mas também é mais interessante usar um componente acabado aqui.
Nossa escolha para este projeto é em uma matriz de 8x8 LED com driver MAX7219 IC. Ocupa muito pouco espaço, custa apenas uma pequena quantia de dinheiro e é fácil de codificar.
Dependendo de onde você o compra, é necessário soldar e montar as peças individuais. Isso normalmente não é problema. O único erro que pode ser cometido é colocar a matriz de LED torcida nas tomadas.
Isso é mostrado pela imagem acima. Aqui, é suficiente puxar cuidadosamente a matriz para fora dos encaixes e girá-la 180 °.
Um pouco de física
A matriz de LED não deve apenas mostrar a imagem do dado como resultado. Deve oferecer alguns efeitos de show. Os seis olhos de dados se movem na matriz:eles ricocheteiam nas bordas e lentamente perdem velocidade.
Por meio dos dois sensores de inclinação, podemos ver o quanto o tremor foi feito. Esta informação damos aos olhos do dado como "velocidade" para o seu movimento.
Também usamos um efeito semelhante ao exibir o resultado dos dados. Os olhos rolam de sua posição aleatória para sua posição correta na imagem do cubo.
Fonte de alimentação
Primeiro, instalamos duas células-botão 3V CR2032 por motivos de espaço. No início parecia muito bom também. O Arduino e a matriz LED funcionaram bem e tudo funcionou. Após alguns minutos de operação, no entanto, a energia das células-botão é interrompida.
Se você desligar o Arduino após cada dado, poderá usá-lo dessa forma. Isso não é perfeito, então instalamos duas baterias AAA melhores. No entanto, eles fornecem apenas 3V juntos. Portanto, ainda precisamos de um conversor elevador, que aumenta a tensão para 5V. A conexão ainda ocorre no pino VIN do Arduino.
Projeto de Habitação
A melhor opção para um invólucro adequado é um projeto próprio e produção via impressão 3D. Existem muitos aplicativos para a construção. Usamos o Autodesk Fusion 360 para este projeto. Possui excelentes recursos e a impressão 3D está bem integrada com o software Print Studio. Se estiver interessado no Autodesk Fusion 360, você encontrará algumas sugestões no artigo do blog Enclosures paramétricos (somente em alemão).
Nossa caixa consiste em 3 partes:
- maiúsculas
- Caixa baixa com suporte de bateria para células AAA
- Capa de acrílico (não necessariamente tem que ser)
A matriz de LED fica ainda melhor com uma capa de acrílico leitoso na frente dela. Isso torna impossível reconhecer os LEDs apagados e a imagem fica mais nítida.
Sketch
Para controlar a matriz de LED, a biblioteca LedControl é necessária. Se ainda não estiver instalado, pode ser baixado de arduino.cc https://playground.arduino.cc/Main/LedControl.
Em seguida, fazemos as outras definições de variáveis. Primeiro, determinamos como os olhos dos dados são exibidos na matriz. Um olho de dados consiste em 4 pontos de LED. Na matriz, o canto superior esquerdo é especificado como a coordenada X / Y (-1 significa fora da tela).
int DicePic [8] [6] [2] ={… {// 1:{4,4}, // 1. Punkt {-1, -1}, // 2. Punkt {-1, -1}, // 3. Punkt {-1, -1}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt}, {// 2:{2,2}, // 1. Punkt {6,6}, // 2. Punkt {-1, -1}, // 3. Punkt {-1, -1}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt},… Claro, tudo é possível aqui. Deixe sua imaginação correr solta. Nem sempre tem que ser a imagem típica do olho.
Outras observações você encontrará diretamente no código.
Montagem
Colocamos nosso Arduino em uma régua de soquete, como uma espécie de escudo. Os cinco contatos da matriz de LEDs são conectados da mesma forma. Se o Arduino estiver centralizado, o espaço será melhor utilizado. Portanto, é melhor usar os pinos 5, 6, 7 para CS, CLK e DIN para a matriz. Nesse caso, apenas os pontos de solda devem ser conectados. A conexão a 5V e GND é feita por meio de um pequeno jumper.
Também conectamos os dois sensores de inclinação com fios curtos. Eles são conectados aos pinos 2 e 3 e 5V e GND.
Agora tudo pode ser montado. O plexiglass é primeiro fixado com cola quente. Fazemos o mesmo com a matriz de LED. Basta um pequeno ponto de cola quente.
Em seguida, a chave liga / desliga é instalada, fixada com cola quente e conectada aos fios apropriados.
Montagem da fonte de alimentação
A fonte de alimentação está um pouco modificada. Dependendo de quais opções e componentes você tem, os contatos de mais e menos podem ser corrigidos de acordo.
Usamos as molas e pinos de um compartimento de bateria usado. Para prender na parte inferior da carcaça usamos fios e um pouco de cola quente novamente.
O conversor de aumento de velocidade é melhor ajustado para aprox. 5V antes da instalação. Para isso a resistência tem que ser torcida um pouco.
Em seguida, maiúsculas e minúsculas são colocadas juntas. Devido ao ajuste de 0,1 mm, conectar-se sem outro tipo de fixação é suficiente. E eles ainda podem abrir novamente para uma troca de bateria.
E então acabou!
A diversão dos dados 2.0 pode começar!
O que você precisa
- Arduino Nano (ou ESP8266)
- 2 x sensores de inclinação (com resistores integrados)
- Matriz LED 8x8 com MAX7219 IC, SPC
- Tira de soquete
- Botão liga / desliga
- PCB
- 2 pilhas AAA
Mais informações
Se você quiser ler mais, verifique nosso site techpluscode.de/arduino-wuerfel-2-0.
Desculpe, este blog estendido está disponível apenas em alemão;-)
Código
- wuerfel8x8.ino
wuerfel8x8.ino Arduino
Código para os dados de agitação / * Blog-Artikel:Schttel-Wrfel mit LED Matrix und Bewegungssimulationhttps://techpluscode.de/schuettel-wuerfel-mit-led-matrix-und-bewegungssimulation/techpluscode.deCopyright 2019 de Thomas Angielsky * /// Bibliothek fr die Ansteuerung der 8x8 LED-Matrix einbinden // Inclui lib para a matriz de LED 8x8 # include "LedControl.h" int PinTiltX =2; // Pin fr Tiltsensor Xint PinTiltY =3; // Pino fr Tiltsensor Y // Pinos der LED-Matrix // Pinos da matriz LEDint PinCLK =7; int PinCS =6; int PinDIN =5; LedControl lc =LedControl (PinDIN, PinCLK, PinCS, 1); // Koordinaten der Wrfelaugen na matriz de LED // Coordenadas dos pontos de dados na matriz de LEDint DicePic [8] [ 6] [2] ={{// leere Matrix und Startposition:{9,9}, // 1. Punkt {9,8}, // 2. Punkt {9,7}, // 3. Punkt {9,6}, // 4. Punkt {9,5}, // 5. Punkt {9,4} // 6. Punkt}, {// 1:{4,4}, // 1. Punkt {-1, -1}, // 2. Punkt {-1, -1}, // 3. Punkt {-1, -1}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt}, {// 2:{2,2}, // 1. Punkt {6,6}, // 2. Punkt {-1, -1}, // 3. Punkt {-1, -1}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt}, {// 3:{2,6}, // 1. Punkt {6,2}, // 2. Punkt {4,4}, // 3. Punkt {-1, -1}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt}, {// 4:{2,2}, // 1. Punkt {2,6}, // 2. Punkt {6,2}, // 3. Punkt {6,6}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt}, {// 5:{2,2}, // 1. Punkt {2,6}, // 2. Punkt {6,2}, // 3. Punkt {6,6}, // 4. Punkt {4,4}, // 5. Punkt {-1, -1} // 6. Punkt}, {// 6:{2,1}, // 1. Punkt {2,4}, // 2. Punkt {2,7}, // 3. Punkt {6,1}, // 4. Punkt {6,4}, // 5. Punkt {6,7} // 6. Punkt}, {// Iniciar:{-1, -1}, // 1. Punkt {-1, -1}, // 2. Punkt {-1, -1}, // 3. Punkt {-1, -1}, // 4. Punkt {-1, -1}, // 5. Punkt {-1, -1} // 6. Punkt}}; // Variablen der Wrfelaugen:Position, Richtung, Geschwindigkeit fr X und Y // Variáveis do dado:posição, direção, velocidade para X e Yfloat DiceXpos [6]; float DiceXdir [6]; byte volátil DiceXspeed [ 6]; float DiceYpos [6]; float DiceYdir [6]; byte volátil DiceYspeed [6]; int DiceValue; carimbo de data / hora longo sem sinal; Modo de byte; int shakes voláteis; int ShakesPerSecond; int step; void InterruptChecks () {// Schttel -Anzahl zhlen // Contar Shakes Shakes =Shakes + 1; //Serial.println (millis ()); timestamp =millis ();} void SetSpeedX () {if (Mode ==0) {// alle Wrfel em X beschleunigen // Acelerar dados em X para (int i =0; i <6; i ++) {if (DiceXspeed [i] <255) {DiceXspeed [i] =DiceXspeed [i] +5;}}} InterruptChecks ();} void SetSpeedY () {if (Mode ==0) {// alle Wrfel in Y beschleunigen / / Dados de aceleração em Y para (int i =0; i <6; i ++) {if (DiceYspeed [i] <255) {DiceYspeed [i] =DiceYspeed [i] +5;}}} InterruptChecks (); } void ShowLed (int x, int y, bool onoff) {// LED nur anzeigen, wenn im sichtbaren Bereich // mostra apenas, quando x / y na matriz if ((x <8) e (y <8) e ( x> =0) e (y> =0)) {lc.setLed (0, x, y, onoff); }} void ShowDot (int x, int y, bool onoff) {// Wrfel-Auge anzeigen oder ausblenden // Mostrar ou ocultar pontos de dados ShowLed (x-1, y-1, onoff); ShowLed (x, y-1, onoff); ShowLed (x-1, y, onoff); ShowLed (x, y, onoff);} void ShowDicePic (int value) {// Wurf anzeigen // Mostra diceboolean done; // alle Punkte von der aktuellen Position aus zur Zielposition von DiceValue bewegen // mover todos os pontos da posição atual para o destino de DiceValue para (int i =0; i <6; i ++) {DiceXspeed [i] =100; DiceYspeed [i] =100; // Werte fr X berechnen // Valores de cálculo x DiceXdir [i] =0; if (int (DiceXpos [i])> DicePic [valor] [i] [0]) {DiceXdir [i] =- 1;} else if (int (DiceXpos [i]) DicePic [valor] [i] [1]) {DiceYdir [i] =- 1;} else if (int (DiceYpos [i]) 7) {pos =7; dir =dir * (-1); } if (pos <1) {pos =1; dir =dir * (-1); }} // Geschwindigkeit wird pro Schritt langsamer // A velocidade diminui a cada passo if (sp>
0) {sp =sp-1;}} void MoveDots () {// alle Wrfel einen Schritt weiter bewegen // move os dados em um passo posteriormente para (int i =0; i <6; i ++) {// neue Koordinaten berechnen // calc novas coordenadas DoStep (DiceXpos [i], DiceXdir [i], DiceXspeed [i], true); DoStep (DiceYpos [i], DiceYdir [i], DiceYspeed [i], verdadeiro); } // Wrfel-Augen anzeigen // mostra os pontos dos dados lc.clearDisplay (0); para (int i =0; i <6; i ++) {ShowDot (int (DiceXpos [i]), int (DiceYpos [i]), verdadeiro); }} void setup () {// Der MAX7219 ist beim Starten no Power-Saving Modus, // er muss aufgeweckt werden. // O MAX7219 está no modo de economia de energia na inicialização, // temos que fazer uma chamada de ativação lc.shutdown (0, false); // Helligkeit auf einen Mittelwert // Defina o brilho para valores médios lc.setIntensity (0, 8); // und Exibir lschen // e limpar a exibição lc.clearDisplay (0); randomSeed (analogRead (0)); DiceValue =0; para (int i =0; i <6; i ++) {DiceXpos [i] =DicePic [7] [i] [0]; DiceYpos [i] =DicePic [7] [i] [1]; DiceXdir [i] =random (3) -1; DiceYdir [i] =aleatório (3) -1; DiceXspeed [i] =aleatório (126) +120; DiceYspeed [i] =aleatório (126) +120; } // Pins einstellen // Configura os pinos pinMode (PinTiltX, INPUT_PULLUP); pinMode (PinTiltY, INPUT_PULLUP); attachInterrupt (digitalPinToInterrupt (PinTiltX), SetSpeedX, CHANGE); attachInterrupt (digitalPinToInterrupt (PinTiltY), SetSpeedY, CHANGE); lc.clearDisplay (0); carimbo de data / hora =milis (); Modo =1; ShowDicePic (6); atraso (1000); lc.clearDisplay (0); Modo =0; Serial.begin (9600); etapa =0; shakes =0;} loop vazio () {atraso (50); etapa =etapa + 1; if (step>
20) {// 1 sek ist vorbei // 1 s over step =0; ShakesPerSecond =shakes; agita =0; } if (Mode ==0) {MoveDots (); if (millis () - timestamp>
2000) {// seit 2 sek kein Schtteln mehr // não há vibração desde 2 seg Mode =1; DiceValue =random (6) +1; ShowDicePic (DiceValue); }} if (ShakesPerSecond> 5) {// Es wird wieder geschttelt // sacudindo novamente Mode =0; }} Peças personalizadas e gabinetes
Esquemas
Este é o meu esboço para o circuito.
Processo de manufatura