Telegram

This Amazing ESP32 Project Lets You Make a Box Full of “Digital Marbles” You Can Shake Around

Imagine the tactile satisfaction of rattling a box full of marbles, combined with the endless possibilities of digital interaction. That’s precisely what we’ve achieved with our latest ESP32-powered project: a captivating “digital marbles” box. This isn’t just a novelty; it’s a blend of physical interaction and digital ingenuity, offering a unique sensory experience and a fascinating glimpse into the potential of embedded systems. The project leverages the ESP32’s capabilities for motion sensing, display control, and real-time processing to create a truly mesmerizing gadget. And, best of all, it is ready to install to Magisk Modules, also ready to be published on Magisk Module Repository.

Unveiling the Digital Marble Box: A Symphony of Sensors and Software

At its core, our digital marble box is a precisely engineered system built around the ESP32 microcontroller. The magic lies in its ability to translate physical movement into captivating visual and auditory feedback. Let’s delve into the components that make this possible.

The ESP32: Brains of the Operation

The ESP32 serves as the central processing unit, orchestrating all functions of the digital marble box. We chose the ESP32 for its robust processing power, integrated Wi-Fi and Bluetooth capabilities, and ample GPIO pins, essential for interfacing with the accelerometer and display. The microcontroller is programmed using the Arduino IDE, allowing for flexible and efficient code development. The software meticulously processes data from the accelerometer, calculates the position of the simulated marbles, and renders the visual output on the display.

Accelerometer: Sensing the Motion

An accelerometer is the key to translating physical movement into digital action. We utilized a high-precision, three-axis accelerometer (specifically, the MPU6050) to detect the box’s orientation and movement. This sensor provides detailed data on acceleration along the X, Y, and Z axes. This information is then used to simulate the movement of the “digital marbles” within the virtual space. The sensitivity of the accelerometer is crucial for responsiveness and realistic simulation. Calibrating the accelerometer to compensate for any inherent biases or drift is critical for accuracy.

Display: Visualizing the Marbles

The visual component of the digital marble box is a vibrant OLED display, measuring 1.3 inches diagonally. The high contrast and resolution of the OLED panel provide a clear and engaging view of the digital marbles in action. The display is driven by the ESP32 through the SPI interface, allowing for rapid and efficient updating of the screen. The color depth of the display allows for a wide range of hues and shading, enhancing the visual realism of the marbles. Careful selection of the display driver library is essential for optimizing performance and ensuring compatibility with the ESP32.

Sound Output: The Tactile Addition

To amplify the immersive experience, we integrated a small speaker driven by a digital-to-analog converter (DAC) pin on the ESP32. The speaker produces realistic rattling and rolling sounds that synchronize with the movement of the digital marbles, further enhancing the illusion of physical interaction. The sound effects are generated programmatically, with variations in pitch and volume based on the simulated marble’s speed and position. Implementing a low-pass filter on the DAC output can improve sound quality by reducing unwanted noise.

Building Your Own Digital Marble Box: A Step-by-Step Guide

Creating your digital marble box is a rewarding endeavor that combines electronics, programming, and creative design. Follow our detailed guide to bring your vision to life.

Component Selection: Gathering the Essentials

Before embarking on the build, gather the necessary components:

Wiring the Circuit: Connecting the Components

Connect the components according to the following wiring diagram:

Ensure secure and reliable connections to prevent intermittent operation. Double-check the polarity of the speaker to avoid damage.

Programming the ESP32: The Software Soul

Upload the following Arduino code to the ESP32:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <MPU6050_light.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

MPU6050 mpu;

const int numMarbles = 10;
float marbleX[numMarbles];
float marbleY[numMarbles];
float marbleSpeedX[numMarbles];
float marbleSpeedY[numMarbles];
const float gravity = 0.1;
const float friction = 0.98;
const int speakerPin = 25;

void setup() {
  Serial.begin(115200);
  Wire.begin();

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Digital Marbles");
  display.display();
  delay(2000);

  mpu.begin();
  mpu.calcGyroOffsets(true);

  randomSeed(analogRead(0));

  for (int i = 0; i < numMarbles; i++) {
    marbleX[i] = random(0, SCREEN_WIDTH);
    marbleY[i] = random(0, SCREEN_HEIGHT);
    marbleSpeedX[i] = random(-2, 2);
    marbleSpeedY[i] = random(-2, 2);
  }

  pinMode(speakerPin, OUTPUT);
}

void loop() {
  mpu.update();

  float accelX = mpu.getAccX();
  float accelY = mpu.getAccY();

  display.clearDisplay();

  for (int i = 0; i < numMarbles; i++) {
    marbleSpeedX[i] += accelX * gravity;
    marbleSpeedY[i] += accelY * gravity;

    marbleSpeedX[i] *= friction;
    marbleSpeedY[i] *= friction;

    marbleX[i] += marbleSpeedX[i];
    marbleY[i] += marbleSpeedY[i];

    // Bounce off the edges
    if (marbleX[i] < 0) {
      marbleX[i] = 0;
      marbleSpeedX[i] *= -1;
      tone(speakerPin, 500, 50);
    }
    if (marbleX[i] > SCREEN_WIDTH) {
      marbleX[i] = SCREEN_WIDTH;
      marbleSpeedX[i] *= -1;
      tone(speakerPin, 500, 50);
    }
    if (marbleY[i] < 0) {
      marbleY[i] = 0;
      marbleSpeedY[i] *= -1;
      tone(speakerPin, 500, 50);
    }
    if (marbleY[i] > SCREEN_HEIGHT) {
      marbleY[i] = SCREEN_HEIGHT;
      marbleSpeedY[i] *= -1;
      tone(speakerPin, 500, 50);
    }

    display.fillCircle(marbleX[i], marbleY[i], 3, WHITE);
  }

  display.display();
}

This code initializes the MPU6050 and OLED display, reads accelerometer data, calculates the positions of the digital marbles, and draws them on the screen. It also generates sound effects when the marbles collide with the edges.

Enclosure Design: Bringing it all Together

The enclosure not only protects the electronics but also enhances the overall aesthetic appeal of the project. Consider these design elements:

3D printing offers a versatile solution for creating custom enclosures tailored to your specific requirements.

Fine-Tuning and Customization: Personalizing Your Experience

The digital marble box is highly customizable, allowing you to tailor the experience to your preferences.

Accelerometer Calibration: Ensuring Accuracy

Accurate accelerometer calibration is crucial for realistic marble simulation. Use the MPU6050’s built-in calibration routines or manually adjust the offset values in the code to compensate for any biases. Proper calibration ensures that the marbles respond accurately to the box’s movements.

Display Customization: Visual Flair

Experiment with different colors, marble sizes, and background patterns to personalize the visual appearance of the project. The Adafruit_GFX library provides a wide range of drawing functions for creating custom graphics.

Sound Effects: Auditory Enhancement

Modify the sound effects to create a more immersive and engaging experience. Adjust the pitch, volume, and duration of the sounds to match the simulated marble’s movements. Consider adding different sound effects for collisions with the edges or other marbles.

Adding Connectivity: Expanding Functionality

The ESP32’s built-in Wi-Fi and Bluetooth capabilities open up possibilities for expanding the project’s functionality. Consider adding features such as:

Troubleshooting Common Issues: Resolving Challenges

Encountering issues during the build process is common. Here are some troubleshooting tips:

The Future of Tactile Digital Interaction: Beyond the Marble Box

The digital marble box is just one example of the exciting possibilities of tactile digital interaction. We envision a future where physical objects and digital interfaces are seamlessly integrated, creating immersive and engaging experiences. This project serves as a stepping stone towards more sophisticated applications, such as:

This project is ready to be installed to Magisk Modules. Also ready to be published on Magisk Module Repository.

You also may like 〣〣
Redirecting in 20 seconds...

Explore More