🎨 Visual Design Logic
**The "Copper Coin" (Tong Qian
The "Yayoi Kusama" Layout
⚙️ How It Works (The Code
1. The Breath Trigger (Temperature
2. The "Jackpot" Trigger (Accelerometer
3. Anti-Flicker Rendering
🚀 Usage and Demonstration
🔮 Future Improvements

Published February 24, 2026

Raining Wealth" on UNIHIKER K10

# Interactive Digital Art: "Raining Wealth" on UNIHIKER K10

BeginnerFull instructions provided2 hours24

Things used in this project

Hardware components

DFRobot UNIHIKER K10 AI Coding Board

USB Cable, USB Type C Plug

Software apps and online services

Microsoft VS Code

PlatformIO IDE

Story

Welcome to a digital art project that combines traditional Chinese culture with modern interactive technology! This project, running on the **DFRobot UNIHIKER K10**, displays a screen full of ancient Chinese Copper Coins (*Tian Yuan Di Fang* - Square inside, Circle outside).

Inspired by the density and composition of Yayoi Kusama's "Infinity Nets", the coins are arranged in a mesmerizing, organic pattern. But this isn't just a static image—it's alive!

Using the onboard sensors, the artwork interacts with the real world:

Blow directly onto the screen (Heat):The temperature sensor detects your breath, causing coins to drop one by one.

Shake the device (Motion):The accelerometer detects the force, causing ALL coins to cascade down rapidly like a sudden windfall of wealth!

Button A:Instantly resets the canvas with a brand new random layout.

It is a perfect festive desktop gadget for Chinese New Year or a fun interactive art piece to show off the capabilities of the K10.

🎨 Visual Design Logic

**The "Copper Coin" (Tong Qian)

Instead of using bitmap images, every coin is drawn mathematically using the `canvas` API to ensure smooth performance.

1. Outer Circle: Gold filled circle (`canvasCircle`).

2. Inner Square: A square hole drawn in the background color (`canvasRectangle`), representing the ancient philosophy of "Heaven is round, Earth is square".

3. Color Depth: Alternating shades of Gold and Dark Gold to create depth.

The "Yayoi Kusama" Layout

The coins aren't placed on a strict grid. The algorithm uses:

1. Offset Grid:*Hexagonal/Honeycomb offsets.

2. Perspective Scaling:Coins in the center are larger, while those at the edges are smaller, creating a 3D "fish-eye" effect.

3. Random Jitter:Slight random positions to make it look organic rather than mechanical.

⚙️ How It Works (The Code)

The logic is divided into three main interaction loops:

1. The Breath Trigger (Temperature)

The onboard AHT20 sensor reads the ambient temperature.

```cpp

// Logic for detecting breath

if (current_temp >= next_trigger_temp) {

drop_needed++; // Drop a coin

next_trigger_temp += 0.02; // sensitivity 0.02°C

}

```

When you blow on the sensor, the temperature rises rapidly. The code sets a very sensitive threshold (0.02°C). As the temp climbs, coins start to fall.

2. The "Jackpot" Trigger (Accelerometer)

The K10 has a built-in IMU. We monitor the total strength of the G-force.

```cpp

// Logic for shaking

int strength = k10.getStrength();

if (strength > 1250 || strength < 800) {

// Shake detected!

// Set all coins to falling state and double their speed

drop_all_coins(speed * 2);

}

```

A threshold of `1250` ensures that a firm shake triggers the event. The coins drop at **2x speed** for a satisfying visual effect.

3. Anti-Flicker Rendering

To ensure the animation is smooth without flashing (a common issue on MCU screens), we use a specific rendering strategy:

* Instead of `clear()`, we draw a solid background rectangle every frame.

* We limit the total object count to ~80 to maintain high FPS.

---

🚀 Usage and Demonstration

1. Power On:The device initializes and generates a random "Infinity Net" of gold coins on a festive red background.

2. Gentle Interaction:Blow warm air onto the top-left corner (sensor area). Watch coins drop one by one.

3. Aggressive Interaction:Shake the device hard! Watch the entire screen clear out in a "money rain."

4. Reset:** Press the A Button to refill the screen.

🔮 Future Improvements

* Add sound effects (coin clinking) when they hit the bottom using the buzzer.

* Add a "score" counter to see how much wealth you collected.

Interactive Digital Art: "Raining Wealth" on UNIHIKER K10

#include <Arduino.h>
#include "unihiker_k10.h"

// 
UNIHIKER_K10 k10;
AHT20 aht20;

// 
const int SCREEN_W = 240;
const int SCREEN_H = 320;

// 
// 
const uint32_t COLOR_BG = 0xB00000;       
//  ()
const uint32_t COLOR_COIN_1 = 0xFFD700;       // 
const uint32_t COLOR_COIN_2 = 0xDAA520;       //  (GoldenRod)
const uint32_t COLOR_COIN_OUTLINE = 0xB8860B; //  (DarkGoldenRod)

// 
struct Coin {
    int x;
    float y;
    int r;
    uint32_t color; 
    bool is_falling;
    float speed;
};

// 
const int MAX_COINS = 80; // +
Coin coins[MAX_COINS];
int coin_count = 0;

// 
float base_temp = 0.0;
float next_trigger_temp = 0.0;
bool first_reading = true;

// ---------------------------------------------------------
//  ()
// ---------------------------------------------------------

void drawCoin(const Coin& item) {
    // 
    if (item.r < 3 || item.y > SCREEN_H + item.r + 10) return;

    int x = item.x;
    int y = (int)item.y;
    int r = item.r;
    
    // 1.  ()
    // x, y, r, , , 
    // 
    k10.canvas->canvasCircle(x, y, r, item.color, item.color, true);
    
    // 2.  ()
    k10.canvas->canvasCircle(x, y, r, COLOR_COIN_OUTLINE, 0, false);
    
    // 3.  ()
    //  0.5  0.6 
    int hole_size = r * 0.6;
    int half_hole = hole_size / 2;
    
    // 
    k10.canvas->canvasRectangle(x - half_hole, y - half_hole, hole_size, hole_size, COLOR_BG, COLOR_BG, true);
    
    // 4.  ()
    // k10.canvas->canvasRectangle(x - half_hole, y - half_hole, hole_size, hole_size, COLOR_COIN_OUTLINE, 0, false);
}

// 
void addCoin(int x, int y, int r, uint32_t color) {
    if (coin_count >= MAX_COINS) return;
    
    coins[coin_count].x = x;
    coins[coin_count].y = y;
    coins[coin_count].r = r;
    coins[coin_count].color = color;
    coins[coin_count].is_falling = false;
    coins[coin_count].speed = random(6, 12); 
    
    coin_count++;
}

// ---------------------------------------------------------
//  (/)
// ---------------------------------------------------------

void generateLayout() {
    coin_count = 0; 
    
    // 1
    for (int i = 0; i < 35; i++) {
        int x = random(0, SCREEN_W);
        int y = random(0, SCREEN_H);
        int size = random(6, 12); 
        uint32_t color = (random(0, 2) == 0) ? COLOR_COIN_2 : COLOR_COIN_1;
        addCoin(x, y, size, color);
    }

    // 2 ()
    int grid_size = 55;
    for (int y = 25; y < SCREEN_H + 20; y += grid_size) {
        for (int x = 25; x < SCREEN_W + 20; x += grid_size) {
            // 
            int pos_x = x + random(-12, 12);
            int pos_y = y + random(-12, 12);
            
            // 
            int size = random(16, 26); 
            uint32_t color = (random(0, 2) == 0) ? COLOR_COIN_1 : COLOR_COIN_2;
            
            if (pos_x > -20 && pos_x < SCREEN_W + 20 && pos_y > -20 && pos_y < SCREEN_H + 20) {
                 addCoin(pos_x, pos_y, size, color);
            }
        }
    }

    // 3
    for (int i = 0; i < 3; i++) {
        int x = random(40, SCREEN_W - 40);
        int y = random(40, SCREEN_H - 40);
        int size = random(32, 42); 
        addCoin(x, y, size, COLOR_COIN_1);
    }
}

// ---------------------------------------------------------
// 
// ---------------------------------------------------------

void setup() {
    k10.begin();
    k10.initScreen(2); 
    k10.creatCanvas();
    
    generateLayout();
    
    // 
    k10.canvas->canvasRectangle(0, 0, SCREEN_W, SCREEN_H, COLOR_BG, COLOR_BG, true);
    for(int i=0; i<coin_count; i++) drawCoin(coins[i]);
    k10.canvas->updateCanvas();
}

// ---------------------------------------------------------
// 
// ---------------------------------------------------------

void loop() {
    //  A 
    if (k10.buttonA->isPressed()) {
        generateLayout(); 
        k10.canvas->canvasRectangle(0, 0, SCREEN_W, SCREEN_H, COLOR_BG, COLOR_BG, true);
        for(int i=0; i<coin_count; i++) drawCoin(coins[i]);
        k10.canvas->updateCanvas();
        delay(200); 
        return; 
    }

    // 
    float current_temp = aht20.getData(AHT20::eAHT20TempC);
    
    if (first_reading && current_temp > 0) {
        base_temp = current_temp;
        next_trigger_temp = base_temp + 0.02; 
        first_reading = false;
    }

    int drop_needed = 0;

    // 
    if (!first_reading) {
        int safety = 0;
        while (current_temp >= next_trigger_temp && safety < 5) {
            drop_needed++;
            next_trigger_temp += 0.02;
            safety++;
        }
        if (current_temp < next_trigger_temp - 0.05) {
             next_trigger_temp = current_temp + 0.02;
        }
    }

    //  ()
    static uint32_t last_shake_time = 0;
    //  (10001g)
    int strength = k10.getStrength();
    
    // 1500delay(30)
    //  1200 (1.2g)
    // 800 (0.8g)
    bool is_shaking = (strength > 1250) || (strength < 800);

    if (is_shaking && (millis() - last_shake_time > 800)) { // 
        // 
        for(int i=0; i<coin_count; i++) {
            coins[i].is_falling = true;
            // 
            if (coins[i].speed < 20) { // 
                coins[i].speed *= 2.0; 
            }
        }
        last_shake_time = millis();
    }

    // 
    if (drop_needed > 0) {
        int found = 0;
        int attempts = 0;
        while (found < drop_needed && attempts < 50) {
            int idx = random(0, coin_count);
            if (!coins[idx].is_falling) {
                coins[idx].is_falling = true;
                found++;
            }
            attempts++;
        }
    }

    bool animation_active = false;
    for (int i = 0; i < coin_count; i++) {
        if (coins[i].is_falling) {
            coins[i].y += coins[i].speed;
            animation_active = true;
        }
    }

    //  ()
    if (animation_active) {
        k10.canvas->canvasRectangle(0, 0, SCREEN_W, SCREEN_H, COLOR_BG, COLOR_BG, true);
        
        for (int i = 0; i < coin_count; i++) {
             drawCoin(coins[i]);
        }
        
        k10.canvas->updateCanvas();
    }
    
    delay(30);
}