Final project inspiration
My original idea was a mood ring, but then after many nights struggling with electronics, I decided NOT to go so small. I could mood ARTWORK but make it more *vibey*. My idea consists of two steps: 1) A token that you carry with you that tracks your "mood" via the motion throughout your day, and 2) a visual display much like what you see below that would not be static by dynamically change to reflect the "mood" of the day. Giving a new definition to mood lighting. :)
Originally, my idea was a remake of the 90s mood rings - I decided to go with this instead since I think I would actually use this and it would be more realistic to produce for my skill level.
See a preview iteration here
Since the end of the semester will be VERY busy, I mapped out time to tasks (trying to give WAY more time than needed to each task) because stuff always comes up last minute or goes wrong. I really like blocking whole days to just think about the task at hand, large swaths of time instead of an hour here and an hour there - works much better for my focus.
I also outlined an overall system diagram with a list of my components for each:
Each assembly above has a deeper dive on the assembly below. I know I didn't need to go into that much detail, but does this saves me time when I open Fusion Eagle to design the schematics.
I decided to go with the ESP32-S3 Sense. It will allow the visual display to have MODES. One mode would display the info collected throughout the day, one mode would be a "live" display where a camera would influence the display, and finally a static display.
After chatting with a few TAs (Anthony and Yuval), I thought maybe the ESP32-S3 WROOM-2 was the best choice, but as you can see the busyness of my board would be overkill, which the ESP32-S3 Sense would get the job done and be less complicated to produce.
Mode set up
If you compare the "planned" schedule versus "how it actually went" schedule, things took longer than expected. It was also partially drive by me changing the design / housing for the neopixels after my first prototype.
I must call out how much help I got from the class TA's. Anthony helped me with debugging and when I couldn't figure out the issue myself (I've been working with Anthony for several weeks, and every time I have a debug session I learn something new!). Same goes for Quentin, he helped me really make my code run smoothly the night before the presentation
So lets get into the work!
Here is my initial ideation for the shape of token that communicates with my display. I decided to make the production of my token my wildcard week! You can see more details there on the milling process.
My iterations of potential displays
I originally really wanted to do a funky shape, but since I was trying to keep the universal product mindset, I decided to keep it simple
Then I went for more of a circle-y, simple shape in mind.. but the neopixel matrices were limiting and with the time constraint, I decided to keep it simple with a square shape
I even printed and cut the entire frame, but didn't like the look of it. So I abandoned it for another design
I decided to go for more of a square space here with rounded corners.
I needed to create some space between the neopixel panel and my diffusing material... Speaking of diffusing, I tried all kinds of material and especially liked milk acrylic.
The only problem with milk acrylic is there was NONE in a 5 mile radius from MIT. I tried Home Depot and both Blick Art stores with no luck. I thought I would have to spray paint clear acrylic. Luckily after some scavenging, I found some dope HDPU that was an 0.5 inch thick and it diffused even better than acrylic. This eventually led me to export the waterjet!
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.
Display PCB - I ended up not using the pads on the right but they were reserved for an SD card in case I needed them.
As you can see, there are three modes! I decided to use the ESP32S3 Sense (with a tiny camera) to also add a mode with a pseudo mirror.
Here is the display PCB schematic ^^
Token PCB - this simply has an MPU6050 (accelerometer that tracks motion) and a small LED strip
Production of individual systems felt simple and straightforward, but as warned, INTEGRATION was a nightmare!
Thankfully I got the bones of my network set up (used Firebase) and individual scripts working, AND a webapp, but getting it all to work in one giant script was so painful..
Getting the camera to work - and then making it only black and white threshold to then translate to my neopixel panel
Getting one panel to work (Adafruit matrix library is limited to 8x8 grid but I had 16 x 16 so I needed to transition to Fast LED)
Neopixel panels working - I then had to get them to work as one grid
My printed corner supports, adding heat inserts to catch the bolts properly 3d file for top corners here 3d file for bottom corners here.
Setting up the backend for the mood logging and communication
I wanted there to be a cool webapp to go with the Mood Board that showed you your past *moods* - unfortunately I ran out of time to make the UI pretty but javascript behind this page was great to also send the classified mood back to the database.
Feel free to check out the supporting webapp here: https://jhd-test.firebaseapp.com/
I used Google's Firebase Realtime Database as a backend server. It was impossible to set up without using this tutorial and this tutorial that Yuval shared with me to get Firebase working.
But nothing was as hard as getting my ESP32S3 to fetch the "current" mood from the Firebase database. It was almost an entire day of debugging- eventually I realized my javascript could create a separate folder that updated the current mood and kept it live. See code below for webapp and javascript
////// index.html \\\\\\
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Mood Board</title>
<!-- The core Firebase JS SDK is always required and must be listed first -->
<script src="https://www.gstatic.com/firebasejs/8.10.0/firebase-app.js"></script>
<!-- TODO: Add SDKs for Firebase products that you want to use
https://firebase.google.com/docs/web/setup#available-libraries -->
<script src="https://www.gstatic.com/firebasejs/8.8.1/firebase-database.js"></script>
<script>
// REPLACE WITH YOUR web app's Firebase configuration
var firebaseConfig = {
apiKey: "x",
authDomain: "x",
databaseURL: "x",
projectId: "jhd-test",
storageBucket: "x",
messagingSenderId: "x",
appId: "x"
};
// Initialize Firebase
firebase.initializeApp(firebaseConfig);
var database = firebase.database();
</script>
<script src="app.js" defer></script>
<!-- <script type="module" src="app.js"></script> -->
</head>
<body>
<div class="container">
<!-- Current Mood -->
<div class="current-mood">
<h2>Current Mood</h2>
<div id="current-mood-circle" class="mood-circle">Loading...</div>
</div>
<!-- Past Moods -->
<div class="past-moods">
<h2>Past Moods</h2>
<ul id="past-moods-list">
<!-- Mood logs will be dynamically added here -->
</ul>
</div>
</div>
</body>
</html>
////// app.js \\\\\\\
// Initialize Firebase (firebaseConfig is already defined in HTML)
const appDatabase = firebase.database();
// DOM elements
const currentMoodCircle = document.getElementById("current-mood-circle");
const pastMoodsList = document.getElementById("past-moods-list");
// Function to calculate standard deviation
function calculateStandardDeviation(values) {
const n = values.length;
const mean = values.reduce((a, b) => a + b, 0) / n; // Calculate mean
const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / n; // Variance
return Math.sqrt(variance); // Standard deviation
}
// Function to categorize mood based on standard deviation
function categorizeMood(dataArray) {
const xValues = dataArray.map((point) => point.x);
const yValues = dataArray.map((point) => point.y);
const zValues = dataArray.map((point) => point.z);
const sdX = calculateStandardDeviation(xValues);
const sdY = calculateStandardDeviation(yValues);
const sdZ = calculateStandardDeviation(zValues);
const avgSD = (sdX + sdY + sdZ) / 3;
if (avgSD < 20) {
return "Calm";
} else if (avgSD >= 20 && avgSD <= 50) {
return "Happy";
} else {
return "Anxious";
}
}
// Function to map mood to colors
function getMoodColor(mood) {
switch (mood) {
case "Calm":
return "#1E90FF"; // Blue
case "Happy":
return "#32CD32"; // Green
case "Anxious":
return "#FF4500"; // Red
default:
return "#ccc"; // Default gray
}
}
// Listen for the latest log in Firebase
const moodRef = appDatabase.ref("mood_data");
moodRef.on("child_added", (snapshot) => {
const log = snapshot.val();
console.log(snapshot.toJSON());
const dataArray = log.data;
// Categorize the mood
const mood = categorizeMood(dataArray);
const oldmood = currentMoodCircle.textContent;
// New 2 - Write the current mood to Firebase (overwrites previous value)
const classifiedMoodRef = appDatabase.ref("moods_classified/current_mood");
classifiedMoodRef.set({
mood: mood,
timestamp: Date.now(),
})
.then(() => {
console.log("Current mood written to Firebase:", mood);
})
.catch((error) => {
console.error("Error writing current mood:", error);
});
// Update the current mood circle
currentMoodCircle.textContent = mood;
currentMoodCircle.style.backgroundColor = getMoodColor(mood);
if (oldmood !== "Loading...") {
// Add to the past moods list
const listItem = document.createElement("li");
listItem.innerHTML = `
<span class="mood-label">${oldmood}</span>
<span>${new Date().toLocaleTimeString()}</span>
`;
listItem.style.backgroundColor = getMoodColor(oldmood);
pastMoodsList.prepend(listItem);
}
});
Final pieces
Waterjetting the HDPE - the lasercutter couldn't handle the half inch.
Adding a small hole to the side of my token housing for the USB-c port
<< My first time using the metal mill !
SO here I am with all the pieces! Let's get it working.
SO MUCH DEBUGGING to get the board to work!
Here is my NASA approved soldering :)
We needed to add a barrel jack to help power my neos! The grid was about 256 * 4 pixels = 1024 neopixels. It consumed 8 amps at 5v power.
Ok so code - I'm running out of time to show you ALL of the iterations of code but here is the final working code. I had to move from Ardiuno IDE to Platformio because the script was so big (thus the hours of debugging) and the code worked way better when it was nicely partitioned. Here is the main (I think of this as an index?) that pulls from the old headers and code folders. Also HUGE shout out to Quentin and Jake for helping me do this. I am a BEGINNER at code and so I had a really hard time integrating multiple scripts that I created with the help of Chatgpt and other code on Reddit etc.
// Main.cpp (Display device)
#include <Arduino.h>
// Data pull from Firebase to update mood
#include <WiFi.h>
#include <Firebase_ESP_Client.h>
#include "display_moods.h"
#include "display_mirror.h"
#include "addons/TokenHelper.h" //Provide the token generation process info.
#include "addons/RTDBHelper.h" //Provide the real-time database payload printing info and other helper functions
// Insert Firebase project API Key
#define API_KEY "AIzaSyC6hZ5ZfPHQaIxAIpfq5xGlefPS4Aqwxe4"
// Insert RTDB URLefine the RTDB URL */
#define DATABASE_URL "https://jhd-test-default-rtdb.firebaseio.com"
// WiFi credentials
const char* ssid = "EECS_Labs";
const char* password = "";
// Firebase objects
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;
int state = STATE_MOODS;
void setup() {
Serial.begin(115200);
delay(500);
Serial.println("hello setup");
setup_hardware();
setup_camera();
// Connect to WiFi
Serial.print("Connecting to Wi-Fi");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Serial.println("\nConnected to Wi-Fi");
// Configure Firebase
config.api_key = API_KEY;
config.database_url = DATABASE_URL;
if (Firebase.signUp(&config, &auth, "", "")) {
Serial.println("Firebase sign in complete");
}
else {
Serial.printf("Firebase sign-up error: %s\n", config.signer.signupError.message.c_str());
}
config.token_status_callback = tokenStatusCallback;
Firebase.begin(&config, &auth);
Firebase.reconnectWiFi(true);
Serial.println("Firebase initialized");
}
uint32_t last_firebase_update = 0;
uint32_t firebase_interval = 3000;
uint32_t hue_counter = 0;
uint8_t hue = 0;
#define HUE_COUNTER_MAX 10
void loop() {
int state_new = state;
if (state == STATE_MOODS) {
display_loop();
if (last_firebase_update + firebase_interval < millis()){
last_firebase_update = millis();
Serial.println("Fetching current mood...");
// Fetch the current mood from Firebase
if (Firebase.RTDB.getJSON(&fbdo, "/moods_classified/current_mood")) {
if (fbdo.dataType() == "json") {
FirebaseJsonData moodData;
fbdo.jsonObject().get(moodData, "mood");
if (moodData.success) {
String mood = moodData.to<String>();
Serial.println("Current mood: " + mood);
// Update NeoPixels based on mood
displayMood(mood);
} else {
Serial.println("Failed to parse mood.");
}
}
} else {
Serial.println("Failed to fetch mood: " + fbdo.errorReason());
}
}
//displayRGB(CRGB(255, 0, 0));
} else if (state == STATE_MIRROR) {
camera_loop();
} else if (state == STATE_SEQUENCE) {
// update the hue
hue_counter++;
if (hue_counter >= HUE_COUNTER_MAX) {
hue_counter = 0;
// goes back to 0 automatically! (overflow)
hue++;
}
// convert to RGB
CRGB col(CHSV(hue, 200, 200));
displayRGB(col);
}
// update buttons
if (digitalRead(PIN_BTN1) == LOW) {
state_new = STATE_MOODS;
}
if (digitalRead(PIN_BTN2) == LOW) {
state_new = STATE_MIRROR;
}
if (digitalRead(PIN_BTN3) == LOW) {
state_new = STATE_SEQUENCE;
}
if (state_new != state) {
// state just changed! Announce it
Serial.print("NEW STATE: ");
Serial.println(state_new);
}
state = state_new;
}
Header for moods mode
// Display moods header
#ifndef DISPLAY_MOODS_H_
#define DISPLAY_MOODS_H_
#include <Arduino.h>
#include <Adafruit_GFX.h>
#include <FastLED.h>
#include <FastLED_NeoMatrix.h>
// NeoPixel configuration
#define PIN_LED_SIGNAL 3
#define PIN_BTN1 4
#define PIN_BTN2 5
#define PIN_BTN3 6
#define MATRIX_WIDTH 16 // Width of one matrix
#define MATRIX_HEIGHT 16 // Height of one matrix
#define BRIGHTNESS 80
#define COLOR_ORDER GRB
#define LED_TYPE WS2812B
#define NUM_MATRICES_X 2 // Number of matrices horizontally
#define NUM_MATRICES_Y 2 // Number of matrices vertically
// Total width and height of the combined display
#define TOTAL_WIDTH (MATRIX_WIDTH * NUM_MATRICES_X)
#define TOTAL_HEIGHT (MATRIX_HEIGHT * NUM_MATRICES_Y)
#define STATE_MOODS 0
#define STATE_MIRROR 1
#define STATE_SEQUENCE 2
// Total number of LEDs
#define NUM_LEDS (MATRIX_WIDTH * MATRIX_HEIGHT * NUM_MATRICES_X * NUM_MATRICES_Y)
void setup_hardware(void);
void displayMood(String mood);
void display_loop(void);
void displayRGB(CRGB color);
void drawPixel(int16_t x, int16_t y, CRGB c);
void drawPixel(int16_t x, int16_t y, uint8_t red, uint8_t green, uint8_t blue);
void showPixels(void);
#endif// display moods cpp
#include "display_moods.h"
CRGB leds[NUM_LEDS];
FastLED_NeoMatrix* matrix = new FastLED_NeoMatrix(
leds, MATRIX_WIDTH, MATRIX_HEIGHT, NUM_MATRICES_X, NUM_MATRICES_Y,
NEO_MATRIX_BOTTOM + NEO_MATRIX_LEFT +
NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG +
NEO_TILE_BOTTOM + NEO_TILE_LEFT + NEO_TILE_PROGRESSIVE);
void drawPixel(int16_t x, int16_t y, CRGB color) {
matrix->drawPixel(x, y, color);
}
void drawPixel(int16_t x, int16_t y, uint8_t red, uint8_t green, uint8_t blue) {
matrix->drawPixel(x, y, matrix->Color(red, green, blue));
}
void showPixels(void) {
matrix->show();
}
void displayRGB(CRGB color) {
for (int i = 0; i < NUM_LEDS; i++) {
leds[i] = color;
}
FastLED.show();
}
DEFINE_GRADIENT_PALETTE(calmPalette) {
0, 0, 0, 139, // Deep Blue
64, 70, 130, 180, // Light Steel Blue
192, 255, 160, 122, // Light Salmon (orange-pink accents)
128, 0, 255, 255, // Aqua
255, 255, 255, 255 // White
};
CRGBPalette16 palette = calmPalette;
DEFINE_GRADIENT_PALETTE(joyfulVibrantPalette) {
0, 255, 50, 0, // Bright Red-Orange
64, 255, 128, 64, // Soft Orange-Green
128, 255, 200, 0, // Vibrant Yellow-Orange
192, 200, 50, 255, // Soft Purple-Blue
255, 128, 0, 255 // Deep Magenta
};
CRGBPalette256 happyPalette = joyfulVibrantPalette;
DEFINE_GRADIENT_PALETTE(rainbowPalette) {
0, 255, 0, 0, // Red
32, 255, 127, 0, // Orange
64, 255, 255, 0, // Yellow
96, 0, 255, 0, // Green
128, 0, 255, 255, // Cyan
160, 0, 0, 255, // Blue
192, 139, 0, 255, // Violet
224, 255, 0, 255, // Pink
255, 255, 0, 0 // Back to Red
};
CRGBPalette32 rainbowpalette = rainbowPalette;
void setup_hardware(void){
pinMode(PIN_BTN1, INPUT_PULLUP);
pinMode(PIN_BTN2, INPUT_PULLUP);
pinMode(PIN_BTN3, INPUT_PULLUP);
// Initialize NeoPixels
FastLED.addLeds<LED_TYPE, PIN_LED_SIGNAL, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
FastLED.setBrightness(BRIGHTNESS);
FastLED.clear();
}
String current_mood = "none";
// Function to set NeoPixel colors based on mood
void displayMood(String mood) {
current_mood = mood;
}
void display_loop(void){
if(current_mood == "Calm"){
static uint16_t noiseX = 0; // X-axis movement for Perlin noise
static uint16_t noiseY = 0; // Y-axis movement for Perlin noise
static uint32_t time = 0; // "Time" axis for wave movement
//Serial.println("Drawing wavy aura...");
// Generate Perlin noise-based waves
for (int x = 0; x < TOTAL_WIDTH; x++) {
for (int y = 0; y < TOTAL_HEIGHT; y++) {
// Create noise values based on position and time
uint16_t noiseValue = inoise16(x * 9000UL + noiseX, y * 9000UL + noiseY, time * 1024UL);
// Map the noise value to the palette for smooth colors
uint8_t colorIndex = noiseValue >> 8; // Map noise to palette
CRGB color = ColorFromPalette((CRGBPalette16)palette, colorIndex, 255, LINEARBLEND);
drawPixel(x, y, color);
}
}
showPixels(); // Refresh the display
// Move the Perlin noise "wave"
time += 1; // Increment "time" axis for wave motion
noiseX += 1; // Slight horizontal movement
noiseY += 1; // Slight vertical movement
// delay(1); // Controls the overall animation speed
//Serial.println("Frame updated!");
}
//// HAPPY
else if(current_mood == "Happy"){
static uint8_t time = 0; // Animation timing for smooth outward growth
// Define the center of the display
int centerX = TOTAL_WIDTH / 2;
int centerY = TOTAL_HEIGHT / 2;
// Serial.println("Drawing outward radial gradient...");
// Generate the radial gradient
for (int x = 0; x < TOTAL_WIDTH; x++) {
for (int y = 0; y < TOTAL_HEIGHT; y++) {
int dx = x - centerX;
int dy = y - centerY;
uint8_t distance = sqrt(dx * dx + dy * dy); // Radial distance from center
// Create an outward-growing effect
uint8_t colorIndex = (time - distance * 8) % 255; // Time-based outward growth
CRGB color = ColorFromPalette((CRGBPalette256)happyPalette, colorIndex, 255, LINEARBLEND);
drawPixel(x, y, color);
}
}
showPixels(); // Refresh the display
time += 1; // Increment time for outward growth effect
delay(50);
}
/// ANXIOUS
else if(current_mood == "Anxious"){
static uint16_t noiseX = 0; // Horizontal motion variable
static uint16_t time = 0; // Time for vertical movement
// Generate the Rainbow Northern Lights effect
for (int x = 0; x < TOTAL_WIDTH; x++) {
for (int y = 0; y < TOTAL_HEIGHT; y++) {
// Generate Perlin noise based on position and time
uint16_t noiseValue = inoise16(x * 5000UL + noiseX * 256UL, y * 5000UL, time << 9);
// Map noise value to the Rainbow palette
uint8_t colorIndex = noiseValue >> 8;
CRGB color = ColorFromPalette((CRGBPalette32)rainbowPalette, colorIndex, 255, LINEARBLEND);
// Draw the pixel with a vertical fade effect
uint8_t brightness = map(y, 0, TOTAL_HEIGHT - 1, 50, 255); // Fade vertically
drawPixel(x, y, color.nscale8(brightness));
}
}
showPixels(); // Refresh the display
// Update motion variables for smooth animation
noiseX += 1; // Horizontal drift
time += 2; // Slow vertical motion
}
}Display mirror mode (camera used here)
// Display mirror header
#ifndef DISPLAY_MIRROR_H_
#define DISPLAY_MIRROR_H_
#include <math.h>
#include "esp_camera.h"
#include "display_moods.h"
#define PWDN_GPIO_NUM -1
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 10
#define SIOD_GPIO_NUM 40
#define SIOC_GPIO_NUM 39
#define Y9_GPIO_NUM 48
#define Y8_GPIO_NUM 11
#define Y7_GPIO_NUM 12
#define Y6_GPIO_NUM 14
#define Y5_GPIO_NUM 16
#define Y4_GPIO_NUM 18
#define Y3_GPIO_NUM 17
#define Y2_GPIO_NUM 15
#define VSYNC_GPIO_NUM 38
#define HREF_GPIO_NUM 47
#define PCLK_GPIO_NUM 13
#define INTENSITY_THRESHOLD 64 // Black/White threshold value
void setup_camera(void);
void camera_loop(void);
#endif #include "display_mirror.h"
void setup_camera(void) {
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.fb_location = CAMERA_FB_IN_PSRAM;
config.pixel_format = PIXFORMAT_RGB565;
config.frame_size = FRAMESIZE_QVGA; // 320x240
config.jpeg_quality = 10;
config.fb_count = 2;
esp_camera_init(&config);
}
void camera_loop(void) {
camera_fb_t *framebuffer = esp_camera_fb_get();
if (!framebuffer) {
Serial.println("Camera capture failed");
return;
}
uint16_t width = framebuffer->width;
uint16_t height = framebuffer->height;
uint8_t *buf = framebuffer->buf;
for (int y = 0; y < TOTAL_HEIGHT; ++y) {
for (int x = 0; x < TOTAL_WIDTH; ++x) {
// Flip the image vertically and horizontally
int flipped_x = TOTAL_WIDTH - 1 - x;
int flipped_y = TOTAL_HEIGHT - 1 - y;
// Scale coordinates from NeoPixel matrix to camera frame
int cam_x = flipped_x * width / TOTAL_WIDTH;
int cam_y = flipped_y * height / TOTAL_HEIGHT;
// Get pixel intensity (grayscale)
int index = (cam_y * width + cam_x) * 2; // RGB565 format
uint8_t r = buf[index] & 0xF8;
uint8_t g = ((buf[index] & 0x07) << 5) | ((buf[index + 1] & 0xE0) >> 3);
uint8_t b = (buf[index + 1] & 0x1F) << 3;
uint16_t intensity = (r * 3 + g * 6 + b * 1) / 10;
// updated line to tweak intensity
// Map intensity to colors
if (intensity > INTENSITY_THRESHOLD) {
drawPixel(x, y, 144, 238, 144); // White -> Light Green
} else {
drawPixel(x, y, 0, 0, 139); // Black -> Dark Blue
}
}
}
showPixels();
esp_camera_fb_return(framebuffer);
}
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.
Here is the "joyful" mood
Here is the active mood
Fully integrated token
