Agitando dados Arduino

Acerca de este proyecto

Hace aproximadamente un año, mi hijo y Yo construyó un dados electrónicos con un Arduino y algunos LED. Este sigue siendo un proyecto ideal para principiantes. Hemos aprendido mucho este año, por lo que es hora de actualizarnos.

Los dados siguen siendo un proyecto de inicio perfecto. La función es clara para todos y es fácil comprender las diferentes áreas:microcontrolador, electrónica simple y codificación.

Versión 2.0

Los dados también son fantásticos, para ir un paso más allá:vincular otras áreas.

Hoy en día hay un componente listo para usar para casi todo. Esto se ve mejor cuando se busca un kit de inicio para Arduino o Raspberry Pi. Los componentes como LED, botones pulsadores y cualquier tipo de sensor están integrados en una placa de circuito y, por lo tanto, se pueden conectar y usar con solo unos pocos cables a los GPIO.

Las impresoras 3D simples, pero suficientes, están disponibles en eBay por menos de 140 €. Casi todas las variaciones de soporte, montaje o carcasa se pueden crear con él.

Hay varias oportunidades más para desarrollar sus propios proyectos. Un ejemplo de esto es nuestro nuevo dado 2.0.

Sensores de inclinación

Implementamos los dados de una manera completamente diferente. En el interior, un Arduino Nano funciona por motivos de espacio. Todavía hay un interruptor de encendido y apagado, pero ningún botón. El corte en cubitos se realiza agitando todo el cubo.

Para ello, se utilizan sensores de inclinación o sensores de vibración. Funcionan como un botón. En un tubo de vidrio, se mueve una bola. Si golpea los contactos de conexión, el circuito se cierra. Este contacto, a veces muy corto, se utiliza como señal.

El movimiento de la bola de metal se puede escuchar bastante bien si agita el sensor.

Normalmente, la posición de instalación es decisiva para un sensor de inclinación. Se supone que dispara una señal en una determinada posición angular. En nuestro caso, esto sucede sacudiendo el estuche. Aquí la situación no es tan importante, porque al temblar en cualquier dirección se dispara una señal. Para estar seguros, utilizamos dos sensores en el proyecto, que están dispuestos con un desfase de 90 ° entre sí. Por lo tanto, siempre obtenemos una señal de vibración confiable.

Interrupciones

Para poder reconocer cuando se agita, los pines de entrada de los sensores de inclinación deberían consultarse en el boceto. Sin embargo, dependiendo de cuándo suceda en el tiempo y qué más tiene que hacer el boceto, siempre existe la posibilidad de que uno o más eventos pasen desapercibidos.

Una mejor solución es utilizar interrupciones de hardware. Esto está definido por la función attachInterrupt. Como parámetro se especifica un subprograma que se llamará en la señal.

El Arduino proporciona dos interrupciones de hardware:pines D2 y D3.

Pantalla

Por supuesto, la visualización de la imagen de los dados se podría volver a realizar con 7 LED individuales. Pero también es más interesante usar un componente terminado aquí.

Nuestra elección para este proyecto se basa en una matriz LED de 8x8 con controlador IC MAX7219. Ocupa muy poco espacio, cuesta solo una pequeña cantidad de dinero y es fácil de codificar.

Dependiendo de dónde lo compre, debe soldar y ensamblar las partes individuales. Normalmente no hay problema. El único error que se puede cometer es colocar la matriz LED torcida en los conectores.

Esto se muestra en la imagen de arriba. Aquí es suficiente sacar con cuidado la matriz de los enchufes y girarla 180 °.

Un poco de física

La matriz de LED no solo debe mostrar la imagen del dado como resultado. Debería ofrecer algunos efectos de espectáculo. Los seis ojos de los dados se mueven en la matriz:rebotan en los bordes y pierden velocidad lentamente.

A través de los dos sensores de inclinación, podemos ver cuánto temblor se hizo. Esta información la damos a los ojos de los dados como "velocidad" para su movimiento.

También usamos un efecto similar al mostrar el resultado de los dados. Los ojos giran desde su posición aleatoria a su posición correcta en la imagen del cubo.

Fuente de alimentación

Primero, hemos instalado dos pilas de botón CR2032 de 3V por motivos de espacio. Al principio también se veía bastante bien. El Arduino y la matriz LED siguieron el juego y todo funcionó. Sin embargo, después de unos minutos de funcionamiento, la energía de las pilas de botón se interrumpe.

Si apaga el Arduino después de cada dado, puede usarlo de esa manera. Eso no es perfecto, así que instalamos mejores dos baterías AAA. Sin embargo, estos solo entregan juntos 3V. Entonces todavía necesitamos un convertidor elevador, que aumenta el voltaje a 5V. La conexión aún tiene lugar en el pin VIN del Arduino.

Diseño de viviendas

La mejor opción para una carcasa adecuada es un diseño y producción propios mediante impresión 3D. Hay muchas aplicaciones para la construcción. Hemos utilizado Autodesk Fusion 360 para este proyecto. Tiene excelentes funciones y la impresión 3D está bien integrada con el software Print Studio. Si está interesado en Autodesk Fusion 360, encontrará algunas sugerencias en el artículo del blog Cajas paramétricas (solo en alemán).

Nuestra carcasa consta de 3 partes:

• Mayúsculas
• Estuche inferior con soporte para pilas AAA
• Cubierta de plexiglás (no necesariamente tiene que ser así)

La matriz de LED se ve aún mejor con una cubierta de plexiglás lechoso enfrente. Esto hace que sea imposible reconocer los LED apagados y la imagen es más clara.

Bosquejo

Para controlar la matriz de LED, se requiere la biblioteca LedControl. Si aún no está instalado, puede descargarlo de arduino.cc https://playground.arduino.cc/Main/LedControl.

Luego hacemos las otras definiciones de variables. Primero, determinamos cómo se muestran los ojos de los dados en la matriz. Un ojo de dado consta de 4 puntos LED. En la matriz, la esquina superior izquierda se especifica como la coordenada X / Y (-1 significa fuera de la pantalla).

  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},…  

Por supuesto, aquí todo es posible. Deje volar su imaginación. No siempre tiene que ser la imagen típica del ojo.

Otras observaciones las encontrará directamente en el código.

Ensamblaje

Colocamos nuestro Arduino en una regleta de enchufes, como una especie de escudo. Los cinco contactos de la matriz de LED están conectados de la misma forma. Si el Arduino está centrado, es mejor utilizar el espacio. Por lo tanto, es mejor utilizar los pines 5, 6, 7 para CS, CLK y DIN para la matriz. Aquí, entonces, solo deben conectarse los puntos de soldadura. La conexión a 5V y GND se realiza mediante un pequeño puente.

También conectamos los dos sensores de inclinación con cables cortos. Estos están conectados a los pines 2 y 3 y 5V y GND.

Ahora todo se puede montar. El plexiglás se fija primero con pegamento caliente. Hacemos lo mismo con la matriz LED. Un pequeño punto de pegamento caliente es suficiente.

A continuación, se instala el interruptor de encendido / apagado, se asegura con pegamento caliente y se conecta a los cables apropiados.

Montaje de la fuente de alimentación

La fuente de alimentación está un poco modificada. Dependiendo de las opciones y componentes que tenga, los contactos para más y menos pueden ajustarse en consecuencia.

Usamos los resortes y los pasadores de un compartimiento de batería usado. Para sujetarlo a la parte inferior de la carcasa usamos cables y un poco de pegamento caliente nuevamente.

El convertidor elevador elevador se ajusta mejor a aprox. 5V antes de la instalación. Para eso hay que torcer un poco la resistencia.

Luego se juntan mayúsculas y minúsculas. Debido al ajuste de 0,1 mm, basta con enchufarlos sin asegurar más. Y aún pueden abrirse nuevamente para un cambio de batería.

¡Y luego está terminado!

¡La diversión de los dados 2.0 puede comenzar!

Qué necesitas

• Arduino Nano (o ESP8266)
• 2 sensores de inclinación (con resistencias integradas)
• Matriz de LED 8x8 con MAX7219 IC, SPC
• Regleta de enchufes
• Interruptor de encendido / apagado
• PCB
• 2 pilas AAA

Más información

Si desea leer más, visite nuestro sitio web techpluscode.de/arduino-wuerfel-2-0.

Lo sentimos, este blog extendido solo está disponible en alemán;-)

Código

• wuerfel8x8.ino

wuerfel8x8.ino Arduino

Código para los dados temblorosos

 / * Blog-Artikel:Schttel-Wrfel mit LED Matrix und Bewegungssimulationhttps://techpluscode.de/schuettel-wuerfel-mit-led-matrix-und-bewegungssimulation/techpluscode.de Copyright 2019 de Thomas Angielsky * /// Bibliothek fr die Ansteuerung der 8x8 LED-Matrix einbinden // Incluye lib para la matriz de 8x8 LED # include "LedControl.h" int PinTiltX =2; // Pin fr Tiltsensor Xint PinTiltY =3; // Pin fr Tiltsensor Y // Pines der LED-Matrix // Pines de la matriz LEDint PinCLK =7; int PinCS =6; int PinDIN =5; LedControl lc =LedControl (PinDIN, PinCLK, PinCS, 1); // Koordinaten der Wrfelaugen in der LED-Matrix // Coordenadas de los puntos Dice en la matriz 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}, {// Inicio:{-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 // Variables de los dados:posición, dirección, velocidad 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; marca de tiempo larga sin firmar; modo byte; int vibraciones volátiles; int ShakesPerSecond; int paso; void InterruptChecks () {// Schttel -Anzahl zhlen // Count Shakes shakes =shakes + 1; //Serial.println (millis ()); timestamp =millis ();} void SetSpeedX () {if (Mode ==0) {// alle Wrfel in X beschleunigen // Acelera los dados en 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 / / Acelerar los dados en 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 // mostrar solo, cuando x / y en la matriz if ((x <8) y (y <8) y ( x> =0) y (y> =0)) {lc.setLed (0, x, y, onoff); }} void ShowDot (int x, int y, bool onoff) {// Wrfel-Auge anzeigen oder ausblenden // Muestra u oculta el punto de dados ShowLed (x-1, y-1, onoff); ShowLed (x, y-1, onoff); ShowLed (x-1, y, onoff); ShowLed (x, y, onoff);} void ShowDicePic (valor int) {// Wurf anzeigen // Mostrar diceboolean hecho; // all Punkte von der aktuellen Position aus zur Zielposition von DiceValue bewegen // mueve todos los puntos desde la posición actual al destino de DiceValue para (int i =0; i <6; i ++) {DiceXspeed [i] =100; DiceYspeed [i] =100; // Werte fr X berechnen // Calc x valores 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); } si (pos <1) {pos =1; dir =dir * (- 1); }} // Geschwindigkeit wird pro Schritt langsamer // La velocidad disminuye en cada paso if (sp>
 0) {sp =sp-1;}} void MoveDots () {// alle Wrfel einen Schritt weiter bewegen // mueve los puntos de los dados un paso más para (int i =0; i <6; i ++) {// neue Koordinaten berechnen // calcula nuevas coordenadas DoStep (DiceXpos [i], DiceXdir [i], DiceXspeed [i], true); DoStep (DiceYpos [i], DiceYdir [i], DiceYspeed [i], verdadero); } // Wrfel-Augen anzeigen // muestra los puntos de los dados lc.clearDisplay (0); for (int i =0; i <6; i ++) {ShowDot (int (DiceXpos [i]), int (DiceYpos [i]), verdadero); }} void setup () {// Der MAX7219 ist beim Starten im Power-Saving Modus, // er muss aufgeweckt werden. // El MAX7219 está en modo de ahorro de energía al inicio, // tenemos que hacer una llamada de activación lc.shutdown (0, false); // Helligkeit auf einen Mittelwert // Establece el brillo en valores medios lc.setIntensity (0, 8); // y mostrar lschen // y borrar la pantalla 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] =aleatorio (3) -1; DiceYdir [i] =aleatorio (3) -1; DiceXspeed [i] =aleatorio (126) +120; DiceYspeed [i] =aleatorio (126) +120; } // Pines einstellen // Configurar los pines pinMode (PinTiltX, INPUT_PULLUP); pinMode (PinTiltY, INPUT_PULLUP); attachInterrupt (digitalPinToInterrupt (PinTiltX), SetSpeedX, CHANGE); attachInterrupt (digitalPinToInterrupt (PinTiltY), SetSpeedY, CHANGE); lc.clearDisplay (0); marca de tiempo =milis (); Modo =1; ShowDicePic (6); retraso (1000); lc.clearDisplay (0); Modo =0; Serial.begin (9600); paso =0; sacude =0;} bucle vacío () {retraso (50); paso =paso + 1; if (paso> 20) {// 1 segundo ist vorbei // 1 segundo ha terminado paso =0; ShakesPerSecond =batidos; batidos =0; } si (Modo ==0) {MoveDots (); if (millis () - timestamp>
 2000) {// seit 2 sek kein Schtteln mehr // no hay sacudidas desde 2 seg Mode =1; DiceValue =aleatorio (6) +1; ShowDicePic (DiceValue); }} if (ShakesPerSecond> 5) {// Es wird wieder geschttelt // temblando de nuevo Mode =0; }} 

Piezas y carcasas personalizadas

Esquemas

Este es mi boceto del circuito.

Brazo robótico de cartón grabable Desinfectante de manos automático