Smart LED Hourglass

#Smart LED Hourglass Project
#demo3-ece.cpp
#This demo is an interesting demo for sand flow simulation. (limited by both the edge of displayer and the edge of words)

#ifndef ARDUINO // Arduino IDE sometimes aggressively builds subfolders

#include "Adafruit_PixelDust.h"
#include "led-matrix-c.h"
#include "lis3dh.h"
#include 

#include "ECElogo.h" // Cornell ece logo bitmaps

#define N_GRAINS (8 * 5 * 64) ///< Number of grains of sand on 64x64 matrix

struct RGBLedMatrix *matrix = NULL;
Adafruit_LIS3DH lis3dh;
volatile bool running = true;
int nGrains = N_GRAINS; // Runtime grain count (adapts to res)

uint8_t colors[][3] = {
    255, 255, 255,    //  white
};

#define BG_RED 0 // Background color (r,g,b)
#define BG_GREEN 0
#define BG_BLUE 0

// Signal handler allows matrix to be properly deinitialized.
int sig[] = {SIGHUP,  SIGINT, SIGQUIT, SIGABRT,
                SIGKILL, SIGBUS, SIGSEGV, SIGTERM};
#define N_SIGNALS (int)(sizeof sig / sizeof sig[0])

void irqHandler(int dummy) {
    if (matrix) {
    led_matrix_delete(matrix);
    matrix = NULL;
    }
    for (int i = 0; i < N_SIGNALS; i++)
    signal(sig[i], NULL);
    running = false;
}

int main(int argc, char **argv) {
    struct RGBLedMatrixOptions options;
    struct LedCanvas *canvas;
    int width, height, i, xx, yy, zz;
    Adafruit_PixelDust *sand = NULL;
    dimension_t x, y;

    for (i = 0; i < N_SIGNALS; i++)
    signal(sig[i], irqHandler); // ASAP!

    // Initialize LED matrix defaults
    memset(&options, 0, sizeof(options));
    options.rows = 64;
    options.cols = 64;
    options.chain_length = 1;

    // Parse command line input.  --led-help lists options!
    matrix = led_matrix_create_from_options(&options, &argc, &argv);
    if (matrix == NULL)
    return 1;

    // Create offscreen canvas for double-buffered animation
    canvas = led_matrix_create_offscreen_canvas(matrix);
    led_canvas_get_size(canvas, &width, &height);
    fprintf(stderr, "Size: %dx%d. Hardware gpio mapping: %s\n", width, height,
            options.hardware_mapping);

    if (lis3dh.begin()) {
    puts("LIS3DH init failed");
    return 2;
    }

    // Initialize PixelDust simulation
    sand = new Adafruit_PixelDust(width, height, nGrains, 1, 64, false);
    if (!sand->begin()) {
    puts("PixelDust init failed");
    return 3;
    }

    // Set up the Cornell "C" logo as an obstacle
    int x1 = (width - LOGO_WIDTH) / 2;
    int y1 = (height - LOGO_HEIGHT) / 2;
    for (y = 0; y < LOGO_HEIGHT; y++) {
    for (x = 0; x < LOGO_WIDTH; x++) {
        uint8_t c = ece_logo_mask[y][x / 8];
        if (c & (0x80 >> (x % 8))) {
        sand->setPixel(x1 + x, y1 + y);
        }
    }
    }
    

    while (running) {
    // Read accelerometer
    lis3dh.accelRead(&xx, &yy, &zz);

    // Update sand simulation
    sand->iterate(-xx, -yy, zz);

    // Clear background with transparency logic
    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x++) {
        int logo_x = x - x1;
        int logo_y = y - y1;

        // Skip background pixels if part of the logo
        if (logo_x >= 0 && logo_x < LOGO_WIDTH && logo_y >= 0 && logo_y < LOGO_HEIGHT) {
            uint8_t mask_byte = ece_logo_mask[logo_y][logo_x / 8];
            uint8_t mask_bit = mask_byte & (0x80 >> (logo_x % 8));
            if (mask_bit) {
            continue; // Leave logo pixels untouched
            }
        }

        led_canvas_set_pixel(canvas, x, y, BG_RED, BG_GREEN, BG_BLUE);
        }
    }

    // plot a white ECE logo for test
    // for (y = 0; y < LOGO_HEIGHT; y++) {
    //   for (x = 0; x < LOGO_WIDTH; x++) {
    //     if (ece_logo_mask[y][x / 8] & (0x80 >> (x & 7))) {
    //       led_canvas_set_pixel(canvas, x1 + x, y1 + y, 255, 255, 255);  /
    //     }
    //   }
    // }

    // Draw sand particles
        for (i = 0; i < nGrains; i++) {
        sand->getPosition(i, &x, &y);
        led_canvas_set_pixel(canvas, x, y, colors[0][0], colors[0][1], colors[0][2]);
    }
    

    // Swap canvas
    canvas = led_matrix_swap_on_vsync(matrix, canvas);
    }

    return 0;
}

#endif // !ARDUINO
                                
                            

#Smart LED Hourglass Project
#demo5-clock.cpp
#This demo is a sand flow simulation. (this demo can be used as a 5 min timer with shaking to reset.) When the time is ran out, the displayer will flash and shut down)

#ifndef ARDUINO

#include "Adafruit_PixelDust.h"
#include "led-matrix-c.h"
#include "lis3dh.h"
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "./digits.h" 

#define N_GRAINS 600  
#define TIMER_DURATION 300  
#define BLINK_COUNT 6      
#define BLINK_DELAY 200000
#define SHAKE_THRESHOLD 10000 
#define SHAKE_COUNT 3        
#define SHAKE_INTERVAL 100000 

struct RGBLedMatrix *matrix = NULL;
Adafruit_LIS3DH lis3dh;
volatile bool running = true;
time_t startTime;

struct Config {
    struct Display {
        const int digitWidth = 10;   // width of digits
        const int digitHeight = 18;  // height of digits 
        const int spacing = 2;       // space between numbers
        const int startX = 4;        // x coordinate
        const int startY = 22;       // y coordinate
    } display;

    
    static const int DEFAULT_ROWS = 64;
    static const int DEFAULT_COLS = 64;
    static const int DEFAULT_CHAIN_LENGTH = 1;
    
    // color them(gold)
    struct {
        uint8_t r = 255;  
        uint8_t g = 180;  
        uint8_t b = 30; 
    } sandColor;
    
    struct {
        uint8_t r = 15;   
        uint8_t g = 15;
        uint8_t b = 60;  
    } borderColor;
    
    struct {
        uint8_t r = 20;
        uint8_t g = 20;
        uint8_t b = 80;
    } glowColor;

    //Color for dogits
    struct {
        uint8_t r = 255;
        uint8_t g = 255;
        uint8_t b = 255;
    } digitColor;
};


Config config;

int sig[] = {SIGHUP, SIGINT, SIGQUIT, SIGABRT,
                SIGKILL, SIGBUS, SIGSEGV, SIGTERM};
#define N_SIGNALS (int)(sizeof sig / sizeof sig[0])

void irqHandler(int dummy) {
    if (matrix) {
        led_matrix_delete(matrix);
        matrix = NULL;
    }
    for (int i = 0; i < N_SIGNALS; i++)
        signal(sig[i], NULL);
    running = false;
}

// draw numbers
void drawDigit(struct LedCanvas* canvas, int digit, int x, int y) {
    if(digit < 0 || digit > 9) return;
    
    for(int dy = 0; dy < config.display.digitHeight; dy++) {
        for(int dx = 0; dx < config.display.digitWidth; dx++) {
            if(DIGITS[digit][dy][dx]) {
                led_canvas_set_pixel(canvas, x + dx, y + dy, 
                    config.digitColor.r, config.digitColor.g, config.digitColor.b);
            }
        }
    }

int main(int argc, char **argv) {
    struct RGBLedMatrixOptions options;
    struct LedCanvas *canvas;
    int width, height;
    Adafruit_PixelDust *sand = NULL;
    int xx, yy, zz;

    // process signal
    for (int i = 0; i < N_SIGNALS; i++)
        signal(sig[i], irqHandler);

    // initial LED displayer
    memset(&options, 0, sizeof(options));
    options.rows = config.DEFAULT_ROWS;
    options.cols = config.DEFAULT_COLS;
    options.chain_length = config.DEFAULT_CHAIN_LENGTH;

    matrix = led_matrix_create_from_options(&options, &argc, &argv);
    if (!matrix) return 1;

    canvas = led_matrix_create_offscreen_canvas(matrix);
    led_canvas_get_size(canvas, &width, &height);

    if (lis3dh.begin()) {
        fprintf(stderr, "LIS3DH initial failed\n");
        return 2;
    }

    while (running) 
        lis3dh.accelRead(&xx, &yy, &zz);
        
        // check shaking
        if (detectShake(xx, yy, zz)) {
            printf("Restarting timer due to shake...\n");
            // reset timer
            restartTimer(startTime, sand, width, height);
    
            //flash
            for(int i = 0; i < 3; i++) {  
                led_canvas_clear(canvas);
                canvas = led_matrix_swap_on_vsync(matrix, canvas);
                usleep(100000);  // 100ms
                
                for(int y = 0; y < height; y++) {
                    for(int x = 0; x < width; x++) {
                        led_canvas_set_pixel(canvas, x, y, 
                            config.sandColor.r, config.sandColor.g, config.sandColor.b);
                    }
                }
                canvas = led_matrix_swap_on_vsync(matrix, canvas);
                usleep(100000);  // 100ms
            }
            
            continue;  
        }
        sand->iterate(-xx, -yy, zz);

        time_t currentTime = time(NULL);
        int elapsed = difftime(currentTime, startTime);
        int remaining = TIMER_DURATION - elapsed;
        
        if (remaining <= 0) {
            blinkScreen(canvas, width, height);
            running = false;
            continue;  //
        }

        // clear canvas
        led_canvas_clear(canvas);

        // draw sand and hourglass
        drawHourglass(canvas, width, height);
        drawSand(canvas, sand, N_GRAINS);

        // draw time
        drawTime(canvas, remaining);

        // update canvas
        canvas = led_matrix_swap_on_vsync(matrix, canvas);
        usleep(20000);  
    }

    // clear sources
    delete sand;
    if (matrix) {
        led_matrix_delete(matrix);
    }

    return 0;
}

#endif // !ARDUINO