ESP32 Fluid simulation on 16x16 Led Matrix

This is a simple visually interesting toy for describing fluid dynamics.

Feb 20, 2025

•

12225 views

•

7 respects

•

GPL3+

Lights

Tools

Games

Devices & Components

LED Matrix Panel

MPU6050 Accelerometer

ESP32

Push Button

Hardware & Tools

Soldering kit

Software & Tools

Arduino IDE

Project description

Code

CODE Color palette

cpp

...

1#include <FastLED.h>
2#include <Wire.h>
3#include <MPU6050.h>
4
5// Pin definitions
6#define LED_PIN     5
7#define SDA_PIN     21
8#define SCL_PIN     22
9
10#define NUM_LEDS    256
11#define MATRIX_WIDTH 16
12#define MATRIX_HEIGHT 16
13#define FLUID_PARTICLES 64
14#define BRIGHTNESS  100
15
16// Structures
17struct Vector2D {
18    float x;
19    float y;
20};
21
22struct Particle {
23    Vector2D position;
24    Vector2D velocity;
25};
26
27// Global variables
28CRGB leds[NUM_LEDS];
29MPU6050 mpu;
30Particle particles[FLUID_PARTICLES];
31Vector2D acceleration = {0, 0};
32
33// Mutex for synchronization
34portMUX_TYPE dataMux = portMUX_INITIALIZER_UNLOCKED;
35
36// Adjusted constants for smoother motion
37const float GRAVITY = 0.3f;    //0.03f
38const float DAMPING = 0.60f;   //   0.98f
39const float MAX_VELOCITY = 0.7f;  //0.3f
40const float MIN_MOVEMENT = 0.001f;  //0.001f
41
42// Function prototypes
43void initMPU6050();
44void initLEDs();
45void initParticles();
46void updateParticles();
47void drawParticles();
48void MPUTask(void *parameter);
49void LEDTask(void *parameter);
50
51// Function to convert x,y coordinates to LED index
52int xy(int x, int y) {
53    x = constrain(x, 0, MATRIX_WIDTH - 1);
54    y = constrain(y, 0, MATRIX_HEIGHT - 1);
55    return (y & 1) ? (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x)) : (y * MATRIX_WIDTH + x);
56}
57
58void drawParticles() {
59    FastLED.clear();
60    
61    // Create occupancy grid
62    bool occupied[MATRIX_WIDTH][MATRIX_HEIGHT] = {{false}};
63    
64    // Get and smooth gravity direction
65    static Vector2D lastGravityDir = {0, 1};
66    Vector2D currentGravityDir;
67    
68    portENTER_CRITICAL(&dataMux);
69    currentGravityDir = acceleration;
70    portEXIT_CRITICAL(&dataMux);
71    
72    const float GRAVITY_SMOOTHING = 0.95f;
73    lastGravityDir.x = lastGravityDir.x * GRAVITY_SMOOTHING + currentGravityDir.x * (1 - GRAVITY_SMOOTHING);
74    lastGravityDir.y = lastGravityDir.y * GRAVITY_SMOOTHING + currentGravityDir.y * (1 - GRAVITY_SMOOTHING);
75    
76    // Normalize gravity vector
77    float gravMagnitude = sqrt(lastGravityDir.x * lastGravityDir.x + lastGravityDir.y * lastGravityDir.y);
78    Vector2D gravityDir = {0, 1}; // Default down direction
79    
80    if (gravMagnitude > 0.1f) {
81        gravityDir.x = lastGravityDir.x / gravMagnitude;
82        gravityDir.y = lastGravityDir.y / gravMagnitude;
83    }
84
85    // Calculate heights and prepare for drawing
86    float heights[FLUID_PARTICLES];
87    float minHeight = 1000;
88    float maxHeight = -1000;
89    
90    for (int i = 0; i < FLUID_PARTICLES; i++) {
91        heights[i] = -(particles[i].position.x * gravityDir.x + 
92                      particles[i].position.y * gravityDir.y);
93        minHeight = min(minHeight, heights[i]);
94        maxHeight = max(maxHeight, heights[i]);
95    }
96    
97    float heightRange = max(maxHeight - minHeight, 1.0f);
98
99    // Draw particles
100    int visibleCount = 0;
101    for (int i = 0; i < FLUID_PARTICLES; i++) {
102        int x = round(constrain(particles[i].position.x, 0, MATRIX_WIDTH - 1));
103        int y = round(constrain(particles[i].position.y, 0, MATRIX_HEIGHT - 1));
104        
105        if (!occupied[x][y]) {
106            int index = xy(x, y);
107            if (index >= 0 && index < NUM_LEDS) {
108                float relativeHeight = (heights[i] - minHeight) / heightRange;
109                 uint8_t hue = relativeHeight * 160;  // Map from 0 (red) to 160 (blue)
110                  uint8_t sat = 255;  // Full saturation for vibrant colors
111                   uint8_t val = 220 + (relativeHeight * 35);  // Slightly brighter at top;
112                
113                leds[index] = CHSV(hue, sat, val);
114                occupied[x][y] = true;
115                visibleCount++;
116            }
117        } else {
118            // Find nearest empty position
119            for (int dx = -1; dx <= 1; dx++) {
120                for (int dy = -1; dy <= 1; dy++) {
121                    if (dx == 0 && dy == 0) continue;
122                    
123                    int newX = x + dx;
124                    int newY = y + dy;
125                    
126                    if (newX >= 0 && newX < MATRIX_WIDTH && 
127                        newY >= 0 && newY < MATRIX_HEIGHT && 
128                        !occupied[newX][newY]) {
129                        int index = xy(newX, newY);
130                        if (index >= 0 && index < NUM_LEDS) {
131                            float relativeHeight = (heights[i] - minHeight) / heightRange;
132                        uint8_t hue = relativeHeight * 160;  // Map from 0 (red) to 160 (blue)
133                        uint8_t sat = 255;  // Full saturation for vibrant colors
134                        uint8_t val = 220 + (relativeHeight * 35);  // Slightly brighter at top
135
136                            
137                            leds[index] = CHSV(hue, sat, val);
138                            occupied[newX][newY] = true;
139                            visibleCount++;
140                            goto particleDrawn;
141                        }
142                    }
143                }
144            }
145            particleDrawn: continue;
146        }
147    }
148    
149    // Debug output
150    static unsigned long lastDebugTime = 0;
151    if (millis() - lastDebugTime > 1000) {
152        Serial.printf("Visible particles: %d of %d\n", visibleCount, FLUID_PARTICLES);
153        lastDebugTime = millis();
154    }
155    
156    FastLED.show();
157}
158    
159
160
161void updateParticles() {
162    Vector2D currentAccel;
163    portENTER_CRITICAL(&dataMux);
164    currentAccel = acceleration;
165    portEXIT_CRITICAL(&dataMux);
166
167    // Reduce acceleration sensitivity
168    currentAccel.x *= 0.3f;
169    currentAccel.y *= 0.3f;
170
171    // Update and constrain each particle
172    for (int i = 0; i < FLUID_PARTICLES; i++) {
173        // Update velocity with acceleration
174        particles[i].velocity.x = particles[i].velocity.x * 0.95f + (currentAccel.x * GRAVITY);
175        particles[i].velocity.y = particles[i].velocity.y * 0.95f + (currentAccel.y * GRAVITY);
176
177        // Hard constrain velocity
178        particles[i].velocity.x = constrain(particles[i].velocity.x, -MAX_VELOCITY, MAX_VELOCITY);
179        particles[i].velocity.y = constrain(particles[i].velocity.y, -MAX_VELOCITY, MAX_VELOCITY);
180
181        // Calculate new position
182        float newX = particles[i].position.x + particles[i].velocity.x;
183        float newY = particles[i].position.y + particles[i].velocity.y;
184
185        // Strict boundary checking with bounce
186        if (newX < 0.0f) {
187            newX = 0.0f;
188            particles[i].velocity.x = fabs(particles[i].velocity.x) * DAMPING;
189        } 
190        else if (newX >= (MATRIX_WIDTH - 1.0f)) {
191            newX = MATRIX_WIDTH - 1.0f;
192            particles[i].velocity.x = -fabs(particles[i].velocity.x) * DAMPING;
193        }
194
195        if (newY < 0.0f) {
196            newY = 0.0f;
197            particles[i].velocity.y = fabs(particles[i].velocity.y) * DAMPING;
198        } 
199        else if (newY >= (MATRIX_HEIGHT - 1.0f)) {
200            newY = MATRIX_HEIGHT - 1.0f;
201            particles[i].velocity.y = -fabs(particles[i].velocity.y) * DAMPING;
202        }
203
204        // Ensure positions are always within bounds
205        particles[i].position.x = constrain(newX, 0.0f, MATRIX_WIDTH - 1.0f);
206        particles[i].position.y = constrain(newY, 0.0f, MATRIX_HEIGHT - 1.0f);
207
208        // Additional safety check
209        if (isnan(particles[i].position.x) || isnan(particles[i].position.y)) {
210            particles[i].position.x = MATRIX_WIDTH / 2;
211            particles[i].position.y = MATRIX_HEIGHT / 2;
212            particles[i].velocity.x = 0;
213            particles[i].velocity.y = 0;
214        }
215    }
216
217    // Particle collision detection and resolution
218    for (int i = 0; i < FLUID_PARTICLES; i++) {
219        for (int j = i + 1; j < FLUID_PARTICLES; j++) {
220            float dx = particles[j].position.x - particles[i].position.x;
221            float dy = particles[j].position.y - particles[i].position.y;
222            float distSquared = dx * dx + dy * dy;
223
224            if (distSquared < 1.0f && distSquared > 0.0f) {
225                float dist = sqrt(distSquared);
226                float nx = dx / dist;
227                float ny = dy / dist;
228
229                // Push particles apart
230                float pushDistance = (1.0f - dist) * 0.5f;
231                float pushX = nx * pushDistance;
232                float pushY = ny * pushDistance;
233
234                // Update positions while ensuring they stay in bounds
235                particles[i].position.x = constrain(particles[i].position.x - pushX, 0.0f, MATRIX_WIDTH - 1.0f);
236                particles[i].position.y = constrain(particles[i].position.y - pushY, 0.0f, MATRIX_HEIGHT - 1.0f);
237                particles[j].position.x = constrain(particles[j].position.x + pushX, 0.0f, MATRIX_WIDTH - 1.0f);
238                particles[j].position.y = constrain(particles[j].position.y + pushY, 0.0f, MATRIX_HEIGHT - 1.0f);
239
240                // Exchange velocities with damping
241                float tempVelX = particles[i].velocity.x;
242                float tempVelY = particles[i].velocity.y;
243                particles[i].velocity.x = particles[j].velocity.x * DAMPING;
244                particles[i].velocity.y = particles[j].velocity.y * DAMPING;
245                particles[j].velocity.x = tempVelX * DAMPING;
246                particles[j].velocity.y = tempVelY * DAMPING;
247            }
248        }
249    }
250}
251
252
253
254
255void initMPU6050() {
256    Serial.println("Initializing MPU6050...");
257    mpu.initialize();
258    
259    if (!mpu.testConnection()) {
260        Serial.println("MPU6050 connection failed!");
261        while (1) {
262            delay(100);
263        }
264    }
265    
266    mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_2);
267    Serial.println("MPU6050 initialized");
268}
269
270void initLEDs() {
271    Serial.println("Initializing LEDs...");
272    FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
273    FastLED.setBrightness(BRIGHTNESS);
274    FastLED.clear(true);
275    Serial.println("LEDs initialized");
276}
277
278void initParticles() {
279    Serial.println("Initializing particles...");
280    int index = 0;
281    
282    for (int y = MATRIX_HEIGHT - 4; y < MATRIX_HEIGHT; y++) {
283        for (int x = 0; x < MATRIX_WIDTH && index < FLUID_PARTICLES; x++) {
284            Serial.printf("Initializing particle %d at x=%d, y=%d\n", index, x, y);
285            particles[index].position = {static_cast<float>(x), static_cast<float>(y)};
286            particles[index].velocity = {0.0f, 0.0f};
287            index++;
288        }
289    }
290    
291    Serial.printf("Total particles initialized: %d\n", index);
292    Serial.println("Particles initialized");
293}
294
295void MPUTask(void *parameter) {
296    while (true) {
297        int16_t ax, ay, az;
298        mpu.getAcceleration(&ax, &ay, &az);
299        
300        portENTER_CRITICAL(&dataMux);
301        acceleration.x = -constrain(ax / 16384.0f, -1.0f, 1.0f);
302        acceleration.y = constrain(ay / 16384.0f, -1.0f, 1.0f);
303        portEXIT_CRITICAL(&dataMux);
304        
305        vTaskDelay(pdMS_TO_TICKS(10));
306    }
307}
308
309void LEDTask(void *parameter) {
310    TickType_t xLastWakeTime = xTaskGetTickCount();
311    const TickType_t xFrequency = pdMS_TO_TICKS(16);
312    
313    while (true) {
314        updateParticles();
315        drawParticles();
316        vTaskDelayUntil(&xLastWakeTime, xFrequency);
317    }
318}
319
320void setup() {
321    Serial.begin(115200);
322    delay(1000);
323    Serial.println("Starting initialization...");
324
325    Wire.begin(SDA_PIN, SCL_PIN);
326    Wire.setClock(400000);
327
328    initMPU6050();
329    initLEDs();
330    initParticles();
331
332    xTaskCreatePinnedToCore(
333        MPUTask,
334        "MPUTask",
335        4096,
336        NULL,
337        2,
338        NULL,
339        0
340    );
341
342    xTaskCreatePinnedToCore(
343        LEDTask,
344        "LEDTask",
345        4096,
346        NULL,
347        1,
348        NULL,
349        1
350    );
351
352    Serial.println("Setup complete");
353}
354
355void loop() {
356    vTaskDelete(NULL);
357}

#include <FastLED.h>
#include <Wire.h>
#include <MPU6050.h>

// Pin definitions
#define LED_PIN     5
#define SDA_PIN     21
#define SCL_PIN     22

#define NUM_LEDS    256
#define MATRIX_WIDTH 16
#define MATRIX_HEIGHT 16
#define FLUID_PARTICLES 64
#define BRIGHTNESS  100

// Structures
struct Vector2D {
    float x;
    float y;
};

struct Particle {
    Vector2D position;
    Vector2D velocity;
};

// Global variables
CRGB leds[NUM_LEDS];
MPU6050 mpu;
Particle particles[FLUID_PARTICLES];
Vector2D acceleration = {0, 0};

// Mutex for synchronization
portMUX_TYPE dataMux = portMUX_INITIALIZER_UNLOCKED;

// Adjusted constants for smoother motion
const float GRAVITY = 0.3f;    //0.03f
const float DAMPING = 0.60f;   //   0.98f
const float MAX_VELOCITY = 0.7f;  //0.3f
const float MIN_MOVEMENT = 0.001f;  //0.001f

// Function prototypes
void initMPU6050();
void initLEDs();
void initParticles();
void updateParticles();
void drawParticles();
void MPUTask(void *parameter);
void LEDTask(void *parameter);

// Function to convert x,y coordinates to LED index
int xy(int x, int y) {
    x = constrain(x, 0, MATRIX_WIDTH - 1);
    y = constrain(y, 0, MATRIX_HEIGHT - 1);
    return (y & 1) ? (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x)) : (y * MATRIX_WIDTH + x);
}

void drawParticles() {
    FastLED.clear();
    
    // Create occupancy grid
    bool occupied[MATRIX_WIDTH][MATRIX_HEIGHT] = {{false}};
    
    // Get and smooth gravity direction
    static Vector2D lastGravityDir = {0, 1};
    Vector2D currentGravityDir;
    
    portENTER_CRITICAL(&dataMux);
    currentGravityDir = acceleration;
    portEXIT_CRITICAL(&dataMux);
    
    const float GRAVITY_SMOOTHING = 0.95f;
    lastGravityDir.x = lastGravityDir.x * GRAVITY_SMOOTHING + currentGravityDir.x * (1 - GRAVITY_SMOOTHING);
    lastGravityDir.y = lastGravityDir.y * GRAVITY_SMOOTHING + currentGravityDir.y * (1 - GRAVITY_SMOOTHING);
    
    // Normalize gravity vector
    float gravMagnitude = sqrt(lastGravityDir.x * lastGravityDir.x + lastGravityDir.y * lastGravityDir.y);
    Vector2D gravityDir = {0, 1}; // Default down direction
    
    if (gravMagnitude > 0.1f) {
        gravityDir.x = lastGravityDir.x / gravMagnitude;
        gravityDir.y = lastGravityDir.y / gravMagnitude;
    }

    // Calculate heights and prepare for drawing
    float heights[FLUID_PARTICLES];
    float minHeight = 1000;
    float maxHeight = -1000;
    
    for (int i = 0; i < FLUID_PARTICLES; i++) {
        heights[i] = -(particles[i].position.x * gravityDir.x + 
                      particles[i].position.y * gravityDir.y);
        minHeight = min(minHeight, heights[i]);
        maxHeight = max(maxHeight, heights[i]);
    }
    
    float heightRange = max(maxHeight - minHeight, 1.0f);

    // Draw particles
    int visibleCount = 0;
    for (int i = 0; i < FLUID_PARTICLES; i++) {
        int x = round(constrain(particles[i].position.x, 0, MATRIX_WIDTH - 1));
        int y = round(constrain(particles[i].position.y, 0, MATRIX_HEIGHT - 1));
        
        if (!occupied[x][y]) {
            int index = xy(x, y);
            if (index >= 0 && index < NUM_LEDS) {
                float relativeHeight = (heights[i] - minHeight) / heightRange;
                 uint8_t hue = relativeHeight * 160;  // Map from 0 (red) to 160 (blue)
                  uint8_t sat = 255;  // Full saturation for vibrant colors
                   uint8_t val = 220 + (relativeHeight * 35);  // Slightly brighter at top;
                
                leds[index] = CHSV(hue, sat, val);
                occupied[x][y] = true;
                visibleCount++;
            }
        } else {
            // Find nearest empty position
            for (int dx = -1; dx <= 1; dx++) {
                for (int dy = -1; dy <= 1; dy++) {
                    if (dx == 0 && dy == 0) continue;
                    
                    int newX = x + dx;
                    int newY = y + dy;
                    
                    if (newX >= 0 && newX < MATRIX_WIDTH && 
                        newY >= 0 && newY < MATRIX_HEIGHT && 
                        !occupied[newX][newY]) {
                        int index = xy(newX, newY);
                        if (index >= 0 && index < NUM_LEDS) {
                            float relativeHeight = (heights[i] - minHeight) / heightRange;
                        uint8_t hue = relativeHeight * 160;  // Map from 0 (red) to 160 (blue)
                        uint8_t sat = 255;  // Full saturation for vibrant colors
                        uint8_t val = 220 + (relativeHeight * 35);  // Slightly brighter at top

                            
                            leds[index] = CHSV(hue, sat, val);
                            occupied[newX][newY] = true;
                            visibleCount++;
                            goto particleDrawn;
                        }
                    }
                }
            }
            particleDrawn: continue;
        }
    }
    
    // Debug output
    static unsigned long lastDebugTime = 0;
    if (millis() - lastDebugTime > 1000) {
        Serial.printf("Visible particles: %d of %d\n", visibleCount, FLUID_PARTICLES);
        lastDebugTime = millis();
    }
    
    FastLED.show();
}
    


void updateParticles() {
    Vector2D currentAccel;
    portENTER_CRITICAL(&dataMux);
    currentAccel = acceleration;
    portEXIT_CRITICAL(&dataMux);

    // Reduce acceleration sensitivity
    currentAccel.x *= 0.3f;
    currentAccel.y *= 0.3f;

    // Update and constrain each particle
    for (int i = 0; i < FLUID_PARTICLES; i++) {
        // Update velocity with acceleration
        particles[i].velocity.x = particles[i].velocity.x * 0.95f + (currentAccel.x * GRAVITY);
        particles[i].velocity.y = particles[i].velocity.y * 0.95f + (currentAccel.y * GRAVITY);

        // Hard constrain velocity
        particles[i].velocity.x = constrain(particles[i].velocity.x, -MAX_VELOCITY, MAX_VELOCITY);
        particles[i].velocity.y = constrain(particles[i].velocity.y, -MAX_VELOCITY, MAX_VELOCITY);

        // Calculate new position
        float newX = particles[i].position.x + particles[i].velocity.x;
        float newY = particles[i].position.y + particles[i].velocity.y;

        // Strict boundary checking with bounce
        if (newX < 0.0f) {
            newX = 0.0f;
            particles[i].velocity.x = fabs(particles[i].velocity.x) * DAMPING;
        } 
        else if (newX >= (MATRIX_WIDTH - 1.0f)) {
            newX = MATRIX_WIDTH - 1.0f;
            particles[i].velocity.x = -fabs(particles[i].velocity.x) * DAMPING;
        }

        if (newY < 0.0f) {
            newY = 0.0f;
            particles[i].velocity.y = fabs(particles[i].velocity.y) * DAMPING;
        } 
        else if (newY >= (MATRIX_HEIGHT - 1.0f)) {
            newY = MATRIX_HEIGHT - 1.0f;
            particles[i].velocity.y = -fabs(particles[i].velocity.y) * DAMPING;
        }

        // Ensure positions are always within bounds
        particles[i].position.x = constrain(newX, 0.0f, MATRIX_WIDTH - 1.0f);
        particles[i].position.y = constrain(newY, 0.0f, MATRIX_HEIGHT - 1.0f);

        // Additional safety check
        if (isnan(particles[i].position.x) || isnan(particles[i].position.y)) {
            particles[i].position.x = MATRIX_WIDTH / 2;
            particles[i].position.y = MATRIX_HEIGHT / 2;
            particles[i].velocity.x = 0;
            particles[i].velocity.y = 0;
        }
    }

    // Particle collision detection and resolution
    for (int i = 0; i < FLUID_PARTICLES; i++) {
        for (int j = i + 1; j < FLUID_PARTICLES; j++) {
            float dx = particles[j].position.x - particles[i].position.x;
            float dy = particles[j].position.y - particles[i].position.y;
            float distSquared = dx * dx + dy * dy;

            if (distSquared < 1.0f && distSquared > 0.0f) {
                float dist = sqrt(distSquared);
                float nx = dx / dist;
                float ny = dy / dist;

                // Push particles apart
                float pushDistance = (1.0f - dist) * 0.5f;
                float pushX = nx * pushDistance;
                float pushY = ny * pushDistance;

                // Update positions while ensuring they stay in bounds
                particles[i].position.x = constrain(particles[i].position.x - pushX, 0.0f, MATRIX_WIDTH - 1.0f);
                particles[i].position.y = constrain(particles[i].position.y - pushY, 0.0f, MATRIX_HEIGHT - 1.0f);
                particles[j].position.x = constrain(particles[j].position.x + pushX, 0.0f, MATRIX_WIDTH - 1.0f);
                particles[j].position.y = constrain(particles[j].position.y + pushY, 0.0f, MATRIX_HEIGHT - 1.0f);

                // Exchange velocities with damping
                float tempVelX = particles[i].velocity.x;
                float tempVelY = particles[i].velocity.y;
                particles[i].velocity.x = particles[j].velocity.x * DAMPING;
                particles[i].velocity.y = particles[j].velocity.y * DAMPING;
                particles[j].velocity.x = tempVelX * DAMPING;
                particles[j].velocity.y = tempVelY * DAMPING;
            }
        }
    }
}




void initMPU6050() {
    Serial.println("Initializing MPU6050...");
    mpu.initialize();
    
    if (!mpu.testConnection()) {
        Serial.println("MPU6050 connection failed!");
        while (1) {
            delay(100);
        }
    }
    
    mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_2);
    Serial.println("MPU6050 initialized");
}

void initLEDs() {
    Serial.println("Initializing LEDs...");
    FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
    FastLED.setBrightness(BRIGHTNESS);
    FastLED.clear(true);
    Serial.println("LEDs initialized");
}

void initParticles() {
    Serial.println("Initializing particles...");
    int index = 0;
    
    for (int y = MATRIX_HEIGHT - 4; y < MATRIX_HEIGHT; y++) {
        for (int x = 0; x < MATRIX_WIDTH && index < FLUID_PARTICLES; x++) {
            Serial.printf("Initializing particle %d at x=%d, y=%d\n", index, x, y);
            particles[index].position = {static_cast<float>(x), static_cast<float>(y)};
            particles[index].velocity = {0.0f, 0.0f};
            index++;
        }
    }
    
    Serial.printf("Total particles initialized: %d\n", index);
    Serial.println("Particles initialized");
}

void MPUTask(void *parameter) {
    while (true) {
        int16_t ax, ay, az;
        mpu.getAcceleration(&ax, &ay, &az);
        
        portENTER_CRITICAL(&dataMux);
        acceleration.x = -constrain(ax / 16384.0f, -1.0f, 1.0f);
        acceleration.y = constrain(ay / 16384.0f, -1.0f, 1.0f);
        portEXIT_CRITICAL(&dataMux);
        
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

void LEDTask(void *parameter) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xFrequency = pdMS_TO_TICKS(16);
    
    while (true) {
        updateParticles();
        drawParticles();
        vTaskDelayUntil(&xLastWakeTime, xFrequency);
    }
}

void setup() {
    Serial.begin(115200);
    delay(1000);
    Serial.println("Starting initialization...");

    Wire.begin(SDA_PIN, SCL_PIN);
    Wire.setClock(400000);

    initMPU6050();
    initLEDs();
    initParticles();

    xTaskCreatePinnedToCore(
        MPUTask,
        "MPUTask",
        4096,
        NULL,
        2,
        NULL,
        0
    );

    xTaskCreatePinnedToCore(
        LEDTask,
        "LEDTask",
        4096,
        NULL,
        1,
        NULL,
        1
    );

    Serial.println("Setup complete");
}

void loop() {
    vTaskDelete(NULL);
}

CODE Colors Button

cpp

...

1// colors:   0 = Red, 32 = Orange, 64 = Yellow, 96 = Green, 128 = Aqua, 160 = Blue, 192 = Purple, 224 = Pink
2
3
4#include <FastLED.h>
5#include <Wire.h>
6#include <MPU6050.h>
7
8// Pin definitions
9#define LED_PIN     5
10#define SDA_PIN     21
11#define SCL_PIN     22
12#define BUTTON_PIN  4   // Button for color switching
13
14#define NUM_LEDS    256
15#define MATRIX_WIDTH 16
16#define MATRIX_HEIGHT 16
17#define FLUID_PARTICLES 64  //80/64
18#define BRIGHTNESS  30
19#define NUM_COLORS  3   // Number of color options
20
21// Structures
22struct Vector2D {
23    float x;
24    float y;
25};
26
27struct Particle {
28    Vector2D position;
29    Vector2D velocity;
30};
31
32// Global variables
33CRGB leds[NUM_LEDS];
34MPU6050 mpu;
35Particle particles[FLUID_PARTICLES];
36Vector2D acceleration = {0, 0};
37
38// Color switching variables
39uint8_t currentColorIndex = 0;
40unsigned long lastDebounceTime = 0;
41const unsigned long debounceDelay = 200;
42
43// Define the colors (you can change these hue values)
44const uint8_t COLORS[NUM_COLORS] = {
45    160,  // Blue
46    0,    // Red
47    96    // Green
48};
49
50// Mutex for synchronization
51portMUX_TYPE dataMux = portMUX_INITIALIZER_UNLOCKED;
52
53// Constants for physics
54const float GRAVITY = 0.08f;  //0.3f /098f
55const float DAMPING = 0.92f;   //0.99f /0.9f
56const float MAX_VELOCITY = 0.6f; //0.6f /2.9f
57
58// Function prototypes
59void initMPU6050();
60void initLEDs();
61void initParticles();
62void updateParticles();
63void drawParticles();
64void MPUTask(void *parameter);
65void LEDTask(void *parameter);
66void checkButton();
67
68// Function to convert x,y coordinates to LED index
69int xy(int x, int y) {
70    x = constrain(x, 0, MATRIX_WIDTH - 1);
71    y = constrain(y, 0, MATRIX_HEIGHT - 1);
72    return (y & 1) ? (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x)) : (y * MATRIX_WIDTH + x);
73}
74
75void checkButton() {
76    static bool lastButtonState = HIGH;
77    bool buttonState = digitalRead(BUTTON_PIN);
78
79    if (buttonState == LOW && lastButtonState == HIGH) {  // Button pressed
80        if ((millis() - lastDebounceTime) > debounceDelay) {
81            currentColorIndex = (currentColorIndex + 1) % NUM_COLORS;
82            lastDebounceTime = millis();
83        }
84    }
85    lastButtonState = buttonState;
86}
87
88void drawParticles() {
89    FastLED.clear();
90    
91    bool occupied[MATRIX_WIDTH][MATRIX_HEIGHT] = {{false}};
92    
93    struct ParticleIndex {
94        int index;
95        float position;
96    };
97    
98    ParticleIndex sortedParticles[FLUID_PARTICLES];
99    for (int i = 0; i < FLUID_PARTICLES; i++) {
100        sortedParticles[i].index = i;
101        sortedParticles[i].position = particles[i].position.y * MATRIX_WIDTH + particles[i].position.x;
102    }
103    
104    for (int i = 0; i < FLUID_PARTICLES - 1; i++) {
105        for (int j = 0; j < FLUID_PARTICLES - i - 1; j++) {
106            if (sortedParticles[j].position > sortedParticles[j + 1].position) {
107                ParticleIndex temp = sortedParticles[j];
108                sortedParticles[j] = sortedParticles[j + 1];
109                sortedParticles[j + 1] = temp;
110            }
111        }
112    }
113
114    for (int i = 0; i < FLUID_PARTICLES; i++) {
115        int particleIndex = sortedParticles[i].index;
116        int x = round(particles[particleIndex].position.x);
117        int y = round(particles[particleIndex].position.y);
118        
119        x = constrain(x, 0, MATRIX_WIDTH - 1);
120        y = constrain(y, 0, MATRIX_HEIGHT - 1);
121        
122        if (!occupied[x][y]) {
123            int index = xy(x, y);
124            if (index >= 0 && index < NUM_LEDS) {
125                float speed = sqrt(
126                    particles[particleIndex].velocity.x * particles[particleIndex].velocity.x + 
127                    particles[particleIndex].velocity.y * particles[particleIndex].velocity.y
128                );
129                
130                uint8_t hue = COLORS[currentColorIndex];
131                uint8_t sat = 255;
132                uint8_t val = constrain(180 + (speed * 50), 180, 255);
133                
134                leds[index] = CHSV(hue, sat, val);
135                occupied[x][y] = true;
136            }
137        } else {
138            for (int r = 1; r < 3; r++) {
139                for (int dx = -r; dx <= r; dx++) {
140                    for (int dy = -r; dy <= r; dy++) {
141                        if (abs(dx) + abs(dy) == r) {
142                            int newX = x + dx;
143                            int newY = y + dy;
144                            if (newX >= 0 && newX < MATRIX_WIDTH && 
145                                newY >= 0 && newY < MATRIX_HEIGHT && 
146                                !occupied[newX][newY]) {
147                                int index = xy(newX, newY);
148                                if (index >= 0 && index < NUM_LEDS) {
149                                    leds[index] = CHSV(COLORS[currentColorIndex], 255, 180);
150                                    occupied[newX][newY] = true;
151                                    goto nextParticle;
152                                }
153                            }
154                        }
155                    }
156                }
157            }
158            nextParticle:
159            continue;
160        }
161    }
162    
163    FastLED.show();
164}
165
166void updateParticles() {
167    Vector2D currentAccel;
168    portENTER_CRITICAL(&dataMux);
169    currentAccel = acceleration;
170    portEXIT_CRITICAL(&dataMux);
171
172    currentAccel.x *= 0.3f;
173    currentAccel.y *= 0.3f;
174
175    for (int i = 0; i < FLUID_PARTICLES; i++) {
176        particles[i].velocity.x = particles[i].velocity.x * 0.9f + (currentAccel.x * GRAVITY);
177        particles[i].velocity.y = particles[i].velocity.y * 0.9f + (currentAccel.y * GRAVITY);
178
179        particles[i].velocity.x = constrain(particles[i].velocity.x, -MAX_VELOCITY, MAX_VELOCITY);
180        particles[i].velocity.y = constrain(particles[i].velocity.y, -MAX_VELOCITY, MAX_VELOCITY);
181
182        float newX = particles[i].position.x + particles[i].velocity.x;
183        float newY = particles[i].position.y + particles[i].velocity.y;
184
185        if (newX < 0.0f) {
186            newX = 0.0f;
187            particles[i].velocity.x = fabs(particles[i].velocity.x) * DAMPING;
188        } 
189        else if (newX >= (MATRIX_WIDTH - 1)) {
190            newX = MATRIX_WIDTH - 1;
191            particles[i].velocity.x = -fabs(particles[i].velocity.x) * DAMPING;
192        }
193
194        if (newY < 0.0f) {
195            newY = 0.0f;
196            particles[i].velocity.y = fabs(particles[i].velocity.y) * DAMPING;
197        } 
198        else if (newY >= (MATRIX_HEIGHT - 1)) {
199            newY = MATRIX_HEIGHT - 1;
200            particles[i].velocity.y = -fabs(particles[i].velocity.y) * DAMPING;
201        }
202
203        particles[i].position.x = constrain(newX, 0.0f, MATRIX_WIDTH - 1);
204        particles[i].position.y = constrain(newY, 0.0f, MATRIX_HEIGHT - 1);
205
206        particles[i].velocity.x *= 0.95f;
207        particles[i].velocity.y *= 0.95f;
208    }
209
210    for (int i = 0; i < FLUID_PARTICLES; i++) {
211        for (int j = i + 1; j < FLUID_PARTICLES; j++) {
212            float dx = particles[j].position.x - particles[i].position.x;
213            float dy = particles[j].position.y - particles[i].position.y;
214            float distanceSquared = dx * dx + dy * dy;
215
216            if (distanceSquared < 1.0f) {
217                float distance = sqrt(distanceSquared);
218                float angle = atan2(dy, dx);
219                
220                float repulsionX = cos(angle) * 0.5f;
221                float repulsionY = sin(angle) * 0.5f;
222
223                particles[i].position.x -= repulsionX * 0.3f;
224                particles[i].position.y -= repulsionY * 0.3f;
225                particles[j].position.x += repulsionX * 0.3f;
226                particles[j].position.y += repulsionY * 0.3f;
227
228                Vector2D avgVel = {
229                    (particles[i].velocity.x + particles[j].velocity.x) * 0.5f,
230                    (particles[i].velocity.y + particles[j].velocity.y) * 0.5f
231                };
232
233                particles[i].velocity = avgVel;
234                particles[j].velocity = avgVel;
235            }
236        }
237    }
238}
239
240void initMPU6050() {
241    Serial.println("Initializing MPU6050...");
242    mpu.initialize();
243    
244    if (!mpu.testConnection()) {
245        Serial.println("MPU6050 connection failed!");
246        while (1) {
247            delay(100);
248        }
249    }
250    
251    mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_2);
252    Serial.println("MPU6050 initialized");
253}
254
255void initLEDs() {
256    Serial.println("Initializing LEDs...");
257    FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
258    FastLED.setBrightness(BRIGHTNESS);
259    FastLED.clear(true);
260    Serial.println("LEDs initialized");
261}
262
263void initParticles() {
264    Serial.println("Initializing particles...");
265    int index = 0;
266    
267    for (int y = MATRIX_HEIGHT - 4; y < MATRIX_HEIGHT; y++) {
268        for (int x = 0; x < MATRIX_WIDTH && index < FLUID_PARTICLES; x++) {
269            particles[index].position = {static_cast<float>(x), static_cast<float>(y)};
270            particles[index].velocity = {0.0f, 0.0f};
271            index++;
272        }
273    }
274    
275    Serial.printf("Total particles initialized: %d\n", index);
276}
277
278void MPUTask(void *parameter) {
279    while (true) {
280        int16_t ax, ay, az;
281        mpu.getAcceleration(&ax, &ay, &az);
282        
283        portENTER_CRITICAL(&dataMux);
284        acceleration.x = -constrain(ax / 16384.0f, -1.0f, 1.0f);
285        acceleration.y = constrain(ay / 16384.0f, -1.0f, 1.0f);
286        portEXIT_CRITICAL(&dataMux);
287        
288        vTaskDelay(pdMS_TO_TICKS(10));
289    }
290}
291
292void LEDTask(void *parameter) {
293    TickType_t xLastWakeTime = xTaskGetTickCount();
294    const TickType_t xFrequency = pdMS_TO_TICKS(16);
295    
296    while (true) {
297        checkButton();
298        updateParticles();
299        drawParticles();
300        vTaskDelayUntil(&xLastWakeTime, xFrequency);
301    }
302}
303
304void setup() {
305    Serial.begin(115200);
306    delay(1000);
307    Serial.println("Starting initialization...");
308
309    // Initialize button pin
310    pinMode(BUTTON_PIN, INPUT_PULLUP);
311
312    Wire.begin(SDA_PIN, SCL_PIN);
313    Wire.setClock(400000);
314
315    initMPU6050();
316    initLEDs();
317    initParticles();
318
319    xTaskCreatePinnedToCore(
320        MPUTask,
321        "MPUTask",
322        4096,
323        NULL,
324        2,
325        NULL,
326        0
327    );
328
329    xTaskCreatePinnedToCore(
330        LEDTask,
331        "LEDTask",
332        4096,
333        NULL,
334        1,
335        NULL,
336        1
337    );
338
339    Serial.println("Setup complete");
340}
341
342void loop() {
343    vTaskDelete(NULL);
344}

// colors:   0 = Red, 32 = Orange, 64 = Yellow, 96 = Green, 128 = Aqua, 160 = Blue, 192 = Purple, 224 = Pink


#include <FastLED.h>
#include <Wire.h>
#include <MPU6050.h>

// Pin definitions
#define LED_PIN     5
#define SDA_PIN     21
#define SCL_PIN     22
#define BUTTON_PIN  4   // Button for color switching

#define NUM_LEDS    256
#define MATRIX_WIDTH 16
#define MATRIX_HEIGHT 16
#define FLUID_PARTICLES 64  //80/64
#define BRIGHTNESS  30
#define NUM_COLORS  3   // Number of color options

// Structures
struct Vector2D {
    float x;
    float y;
};

struct Particle {
    Vector2D position;
    Vector2D velocity;
};

// Global variables
CRGB leds[NUM_LEDS];
MPU6050 mpu;
Particle particles[FLUID_PARTICLES];
Vector2D acceleration = {0, 0};

// Color switching variables
uint8_t currentColorIndex = 0;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 200;

// Define the colors (you can change these hue values)
const uint8_t COLORS[NUM_COLORS] = {
    160,  // Blue
    0,    // Red
    96    // Green
};

// Mutex for synchronization
portMUX_TYPE dataMux = portMUX_INITIALIZER_UNLOCKED;

// Constants for physics
const float GRAVITY = 0.08f;  //0.3f /098f
const float DAMPING = 0.92f;   //0.99f /0.9f
const float MAX_VELOCITY = 0.6f; //0.6f /2.9f

// Function prototypes
void initMPU6050();
void initLEDs();
void initParticles();
void updateParticles();
void drawParticles();
void MPUTask(void *parameter);
void LEDTask(void *parameter);
void checkButton();

// Function to convert x,y coordinates to LED index
int xy(int x, int y) {
    x = constrain(x, 0, MATRIX_WIDTH - 1);
    y = constrain(y, 0, MATRIX_HEIGHT - 1);
    return (y & 1) ? (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x)) : (y * MATRIX_WIDTH + x);
}

void checkButton() {
    static bool lastButtonState = HIGH;
    bool buttonState = digitalRead(BUTTON_PIN);

    if (buttonState == LOW && lastButtonState == HIGH) {  // Button pressed
        if ((millis() - lastDebounceTime) > debounceDelay) {
            currentColorIndex = (currentColorIndex + 1) % NUM_COLORS;
            lastDebounceTime = millis();
        }
    }
    lastButtonState = buttonState;
}

void drawParticles() {
    FastLED.clear();
    
    bool occupied[MATRIX_WIDTH][MATRIX_HEIGHT] = {{false}};
    
    struct ParticleIndex {
        int index;
        float position;
    };
    
    ParticleIndex sortedParticles[FLUID_PARTICLES];
    for (int i = 0; i < FLUID_PARTICLES; i++) {
        sortedParticles[i].index = i;
        sortedParticles[i].position = particles[i].position.y * MATRIX_WIDTH + particles[i].position.x;
    }
    
    for (int i = 0; i < FLUID_PARTICLES - 1; i++) {
        for (int j = 0; j < FLUID_PARTICLES - i - 1; j++) {
            if (sortedParticles[j].position > sortedParticles[j + 1].position) {
                ParticleIndex temp = sortedParticles[j];
                sortedParticles[j] = sortedParticles[j + 1];
                sortedParticles[j + 1] = temp;
            }
        }
    }

    for (int i = 0; i < FLUID_PARTICLES; i++) {
        int particleIndex = sortedParticles[i].index;
        int x = round(particles[particleIndex].position.x);
        int y = round(particles[particleIndex].position.y);
        
        x = constrain(x, 0, MATRIX_WIDTH - 1);
        y = constrain(y, 0, MATRIX_HEIGHT - 1);
        
        if (!occupied[x][y]) {
            int index = xy(x, y);
            if (index >= 0 && index < NUM_LEDS) {
                float speed = sqrt(
                    particles[particleIndex].velocity.x * particles[particleIndex].velocity.x + 
                    particles[particleIndex].velocity.y * particles[particleIndex].velocity.y
                );
                
                uint8_t hue = COLORS[currentColorIndex];
                uint8_t sat = 255;
                uint8_t val = constrain(180 + (speed * 50), 180, 255);
                
                leds[index] = CHSV(hue, sat, val);
                occupied[x][y] = true;
            }
        } else {
            for (int r = 1; r < 3; r++) {
                for (int dx = -r; dx <= r; dx++) {
                    for (int dy = -r; dy <= r; dy++) {
                        if (abs(dx) + abs(dy) == r) {
                            int newX = x + dx;
                            int newY = y + dy;
                            if (newX >= 0 && newX < MATRIX_WIDTH && 
                                newY >= 0 && newY < MATRIX_HEIGHT && 
                                !occupied[newX][newY]) {
                                int index = xy(newX, newY);
                                if (index >= 0 && index < NUM_LEDS) {
                                    leds[index] = CHSV(COLORS[currentColorIndex], 255, 180);
                                    occupied[newX][newY] = true;
                                    goto nextParticle;
                                }
                            }
                        }
                    }
                }
            }
            nextParticle:
            continue;
        }
    }
    
    FastLED.show();
}

void updateParticles() {
    Vector2D currentAccel;
    portENTER_CRITICAL(&dataMux);
    currentAccel = acceleration;
    portEXIT_CRITICAL(&dataMux);

    currentAccel.x *= 0.3f;
    currentAccel.y *= 0.3f;

    for (int i = 0; i < FLUID_PARTICLES; i++) {
        particles[i].velocity.x = particles[i].velocity.x * 0.9f + (currentAccel.x * GRAVITY);
        particles[i].velocity.y = particles[i].velocity.y * 0.9f + (currentAccel.y * GRAVITY);

        particles[i].velocity.x = constrain(particles[i].velocity.x, -MAX_VELOCITY, MAX_VELOCITY);
        particles[i].velocity.y = constrain(particles[i].velocity.y, -MAX_VELOCITY, MAX_VELOCITY);

        float newX = particles[i].position.x + particles[i].velocity.x;
        float newY = particles[i].position.y + particles[i].velocity.y;

        if (newX < 0.0f) {
            newX = 0.0f;
            particles[i].velocity.x = fabs(particles[i].velocity.x) * DAMPING;
        } 
        else if (newX >= (MATRIX_WIDTH - 1)) {
            newX = MATRIX_WIDTH - 1;
            particles[i].velocity.x = -fabs(particles[i].velocity.x) * DAMPING;
        }

        if (newY < 0.0f) {
            newY = 0.0f;
            particles[i].velocity.y = fabs(particles[i].velocity.y) * DAMPING;
        } 
        else if (newY >= (MATRIX_HEIGHT - 1)) {
            newY = MATRIX_HEIGHT - 1;
            particles[i].velocity.y = -fabs(particles[i].velocity.y) * DAMPING;
        }

        particles[i].position.x = constrain(newX, 0.0f, MATRIX_WIDTH - 1);
        particles[i].position.y = constrain(newY, 0.0f, MATRIX_HEIGHT - 1);

        particles[i].velocity.x *= 0.95f;
        particles[i].velocity.y *= 0.95f;
    }

    for (int i = 0; i < FLUID_PARTICLES; i++) {
        for (int j = i + 1; j < FLUID_PARTICLES; j++) {
            float dx = particles[j].position.x - particles[i].position.x;
            float dy = particles[j].position.y - particles[i].position.y;
            float distanceSquared = dx * dx + dy * dy;

            if (distanceSquared < 1.0f) {
                float distance = sqrt(distanceSquared);
                float angle = atan2(dy, dx);
                
                float repulsionX = cos(angle) * 0.5f;
                float repulsionY = sin(angle) * 0.5f;

                particles[i].position.x -= repulsionX * 0.3f;
                particles[i].position.y -= repulsionY * 0.3f;
                particles[j].position.x += repulsionX * 0.3f;
                particles[j].position.y += repulsionY * 0.3f;

                Vector2D avgVel = {
                    (particles[i].velocity.x + particles[j].velocity.x) * 0.5f,
                    (particles[i].velocity.y + particles[j].velocity.y) * 0.5f
                };

                particles[i].velocity = avgVel;
                particles[j].velocity = avgVel;
            }
        }
    }
}

void initMPU6050() {
    Serial.println("Initializing MPU6050...");
    mpu.initialize();
    
    if (!mpu.testConnection()) {
        Serial.println("MPU6050 connection failed!");
        while (1) {
            delay(100);
        }
    }
    
    mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_2);
    Serial.println("MPU6050 initialized");
}

void initLEDs() {
    Serial.println("Initializing LEDs...");
    FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
    FastLED.setBrightness(BRIGHTNESS);
    FastLED.clear(true);
    Serial.println("LEDs initialized");
}

void initParticles() {
    Serial.println("Initializing particles...");
    int index = 0;
    
    for (int y = MATRIX_HEIGHT - 4; y < MATRIX_HEIGHT; y++) {
        for (int x = 0; x < MATRIX_WIDTH && index < FLUID_PARTICLES; x++) {
            particles[index].position = {static_cast<float>(x), static_cast<float>(y)};
            particles[index].velocity = {0.0f, 0.0f};
            index++;
        }
    }
    
    Serial.printf("Total particles initialized: %d\n", index);
}

void MPUTask(void *parameter) {
    while (true) {
        int16_t ax, ay, az;
        mpu.getAcceleration(&ax, &ay, &az);
        
        portENTER_CRITICAL(&dataMux);
        acceleration.x = -constrain(ax / 16384.0f, -1.0f, 1.0f);
        acceleration.y = constrain(ay / 16384.0f, -1.0f, 1.0f);
        portEXIT_CRITICAL(&dataMux);
        
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

void LEDTask(void *parameter) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xFrequency = pdMS_TO_TICKS(16);
    
    while (true) {
        checkButton();
        updateParticles();
        drawParticles();
        vTaskDelayUntil(&xLastWakeTime, xFrequency);
    }
}

void setup() {
    Serial.begin(115200);
    delay(1000);
    Serial.println("Starting initialization...");

    // Initialize button pin
    pinMode(BUTTON_PIN, INPUT_PULLUP);

    Wire.begin(SDA_PIN, SCL_PIN);
    Wire.setClock(400000);

    initMPU6050();
    initLEDs();
    initParticles();

    xTaskCreatePinnedToCore(
        MPUTask,
        "MPUTask",
        4096,
        NULL,
        2,
        NULL,
        0
    );

    xTaskCreatePinnedToCore(
        LEDTask,
        "LEDTask",
        4096,
        NULL,
        1,
        NULL,
        1
    );

    Serial.println("Setup complete");
}

void loop() {
    vTaskDelete(NULL);
}

Downloadable files

Libraries

Libraries.zip

Documentation

Schematic

...

Schematic.jpg

Comments

Only logged in users can leave comments

mircemk

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content