Design the CAD models
A little fix
Solder wires
Seeed Studio
Test the connections
Assemble the head
Assemble the body
Assemble the sensors
Ears and Hands
Conclusion

Published February 13, 2025 © GPL3+

Gus 2.0 - Uses Emotions To Indicate Room Health

This is version 2 of my previous project - Gus. This little guy uses eye emotions to show how good (or bad) your room health is.

IntermediateFull instructions provided8 hours2,417

Gus 2.0 - Uses Emotions To Indicate Room Health

Things used in this project

Hardware components

Seeed Studio XIAO ESP32S3 Sense

Seeed Studio Grove - OLED Display 1.12'' V2

Seeed Studio Grove - Air quality sensor v1.3

DHT22 Temperature Sensor

Software apps and online services

Arduino IDE

Autodesk Fusion

Hand tools and fabrication machines

Soldering iron (generic)

Story

Gus 2.0 is basically your adorable desktop buddy with these super expressive eyes. He even blinks randomly, just to make him feel more alive. Behind his head are a bunch of sensors that keep tabs on the temperature, humidity, and air quality around him.Gus 2.0 is basically your adorable desktop buddy with these super expressive eyes. He even blinks randomly, just to make him feel more alive. Behind his head are a bunch of sensors that keep tabs on the temperature, humidity, and air quality around him.

And here's the cool part: his eye levels actually tell you how comfy your room is. So, if the air quality's not great, or the humidity's off, or the temperature's just not right, his eyelids start to droop, and he gets a little gloomy.

And there's a hidden touch sensor on top of his head. Whenever you're wondering why he's feeling down, just give him a little tap, and he'll show you exactly what the sensors are reading. That way, you'll know if you need to crack a window, turn on the fan, or whatever it takes to get him feeling fresh again.

Design the CAD models

So the first step in bringing Gus to life was getting his body designed in Fusion 360.

Now, before diving into the details, I wanted to get a feel for his overall size. So, I started sketching out some really rough shapes of all the electronic components that will be going inside him.

To make absolutely sure everything would fit perfectly, I did a little online scavenging and downloaded CAD models of all the electronics from Grabcad.

My idea for Gus was a big head to house the larger components and a cute little body for the microcontroller. And you know what? This look actually turned out to be very cute!

I carefully positioned all those digital components within Gus's body, to make sure everything fit in perfectly. Unfortunately, I couldn’t find a CAD model for the air quality sensor, so I had to take my best guess at its size.

To add to the final look, I made some tiny hands and feet.

Finally, I exported the whole design and sent it off to be 3D printed. And honestly, for my very first time designing something specifically for 3D printing, it looks pretty good.

A little fix

The first thing I noticed after 3D printing was the air quality and temperature sensors weren't quite fitting into their designated slots.

Well, looks like my first design wasn’t perfect after all.

But thankfully, it was a pretty straightforward fix. I just used a hacksaw blade to carefully remove the lower sections of the slots, specifically below where the Grove connectors would go.

This also created some extra space for the sensor wires to bend back inside the housing.

Thinking about it, it might actually be more convenient if Seeed Studio had placed the Grove connectors on the opposite side of the PCB. That seems to make more sense.

Solder wires

Alright, let's get started with the soldering! First, I'm going to cut two of the grove connectors roughly in half. Then, using wire strippers, we'll expose the ends of all these wires.

For three of these connectors, we're going to snip off the white wire – it won't be required by our sensors. But for the last connector, the one for our OLED display, we need all four wires because it uses the I2C communication protocol.

Now, I know it looks like a lot of wires, but don't worry! We'll take it step by step. Let's start by soldering bare red and black wires to the VUSB and GND pins on the microcontroller.

Next, we'll grab the yellow wires from those three connectors where we removed the white wire, and solder them to D0, D1, and D2.

Then, for the OLED connector, we'll solder its white wire to D4 and its yellow wire to D5. Finally, we're going to connect all the red wires together and all the black wires together.

If you're feeling a bit lost, take a look at this circuit diagram while soldering.

To keep everything organized, I've labeled each connector with masking tape, indicating what component it will connect to later. Here's a reference diagram for you to do the same.

The good news is we don’t need to do any more soldering. We can simply plug in our components using the connectors, just matching them up with the labels.

Seeed Studio

Before we jump back into the build, I want to give a quick shoutout to Seeed Fusion.

I've genuinely been a fan of Seeed Studio products for a while now. If you’re a maker like me, you can find almost any electronics you need for your project from Seeed. Not just that, they even provide professional-grade PCBs and assembly services.

Test the connections

At this stage, I went ahead and uploaded the code to the microcontroller to test if everything worked as expected.

In a nutshell, the code's job is to figure out how "comfortable" the environment is. It does this by looking at the air quality, humidity, and temperature data from the sensors. The code has pre-set "comfortable ranges" for each of these readings.

Then, it checks how many of the sensor readings are currently outside of those comfortable zones.

Based on this, it calculates a "comfort score." This score ranges from 0 to 4. A score of 0 means the best comfort level, while a score of 4 indicates the worst comfort level.

Now, it might seem a bit backwards at first, but the score basically indicates the height of the eyelids in the downward direction. So a higher score will mean the eyelid is lower.

Assemble the head

Now that everything is working as expected, we can start to assemble everything. To get a cleaner look for the face and hide all the components we've tucked inside, I cut a small square from an old x-ray sheet.

Placing it on the display, you can see it instantly looks much cleaner. It does reduce the brightness of the display quite a bit. It's something I'm keeping in mind, and I might experiment with different materials in the future.

If you have any suggestions, I’d love to know about it in the comments.

To attach this x-ray sheet, I used rubber adhesive to glue it to the front of the head. And then, I stuck on the OLED display using double-sided tape.

Assemble the body

Now it's time to attach the legs to the body. Make sure you place the microcontroller inside the body first!

There's a perfectly sized opening at the back of the body that gives us easy access to the USB-C port. This will be useful for uploading code later and for powering the project.

With the body attached to the head, we can now start plugging in all our electronics. As you can see, I've used double-sided tape to stick the touch sensor right onto the top of the head.

Assemble the sensors

Moving right along, we can similarly plug in the Air Quality sensor and the DHT22 sensor. Then, we'll use double-sided tape again to stick these sensors into their slots on the back panel.

Now we'll use rubber adhesive to glue the back panel to the head. Make sure all the wires are tucked neatly inside and have enough space.

Make sure all the wires are tucked neatly inside and have enough space.

Ears and Hands

Finally, we can glue on the tiny hands and ears. I painted the ears with gray acrylic paint for some contrast. And now, plug in a USB c power cable, and Gus 2.0 is ready!

Conclusion

I have to say, he turned out absolutely adorable! There's something about that big head and those cute, expressive eyes that just gives him this wonderful cartoonish charm. And those random blinks really do bring him to life.

But honestly, my favorite part is still petting him on the head and instantly seeing that sensor data – it's incredibly satisfying! I find myself doing it way more often than I probably should!

Custom parts and enclosures

Sketchfab still processing.

Schematics

Code

Main code

#include <U8g2lib.h>
#include <DHT.h>
#include <SPI.h>
#include <Wire.h>
#include "Air_Quality_Sensor.h"

U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);

// Sensor pins
AirQualitySensor sensor(A0);

#define DHTPIN D1
#define DHTTYPE DHT22
#define TOUCH_PIN D2  // Touch sensor pin

DHT dht(DHTPIN, DHTTYPE);

int airQuality = 0;

// Blink parameters
unsigned long nextBlinkTime = 0;
bool isBlinking = false;
unsigned long blinkInterval = 120000; // Interval between blinks (2 minutes)
const unsigned long blinkDuration = 300;  // Duration of each blink (100 milliseconds)
const int blinkCount = 2;                 // Number of blinks per sequence
unsigned long lastBlinkTime = 0;
int currentBlink = 0;


void setup() {
  Serial.begin(115200);
  u8g2.begin();
  dht.begin();
  pinMode(TOUCH_PIN, INPUT);  // Set touch pin as input

  Serial.println("Waiting sensor to init...");
  u8g2.setDrawColor(1);
  u8g2.setFont(u8g2_font_helvB12_tr);

  int load = 0;
  while(load < 20)
  {
    u8g2.firstPage(); // Start the page drawing process
    do {
      u8g2.setCursor(10, 50);
      u8g2.print("Loading");
      u8g2.setCursor(10, 70);
      // Print dots dynamically within the page loop to update each frame
      for (int i = 0; i <= load; i++) {
        u8g2.print(".");
      }
    } while (u8g2.nextPage()); // Send the buffer to the display
    delay(1000);
    load++;
  }
  u8g2.clearBuffer(); // Clear buffer after loading is complete

  if (sensor.init()) {
        Serial.println("Sensor ready.");
  } else {
        Serial.println("Sensor ERROR!");
    }
}

void loop() {
  // Read sensor values
  int quality = sensor.slope();
  float temp = dht.readTemperature();
  float humidity = dht.readHumidity();

  if (quality == AirQualitySensor::FORCE_SIGNAL) {
      airQuality = 3; // very high pollution
  } else if (quality == AirQualitySensor::HIGH_POLLUTION) {
      airQuality = 2; // high pollution
  } else if (quality == AirQualitySensor::LOW_POLLUTION) {
      airQuality = 1; // moderate pollution
  } else if (quality == AirQualitySensor::FRESH_AIR) {
      airQuality = 0; // fresh air
  }
  
  if (isnan(temp) || isnan(humidity)) {
    Serial.println("DHT read error!");
    delay(2000);
    return;
  }

  // Check touch sensor
  bool isTouched = digitalRead(TOUCH_PIN);
  
  if (isTouched) {
    displaySensorData(temp, humidity, airQuality);
  } else {
    int comfortLevel = calculateComfortLevel(airQuality, temp, humidity);
    updateDisplay(comfortLevel);
  }

  // Serial output
  Serial.print("Touch: ");
  Serial.print(isTouched ? "ON | " : "OFF | ");
  Serial.print("Air: ");
  Serial.print(airQuality);
  Serial.print(" | Temp: ");
  Serial.print(temp);
  Serial.print("C | Hum: ");
  Serial.print(humidity);
  Serial.println("%");

  delay(500);
}

int calculateComfortLevel(int air, float temp, float humid) {
  int airLevel = air;
  int tempLevel = (temp >= 20 && temp <= 24) ? 0 : (temp >= 18 && temp <= 26) ? 1 : (temp >= 15 && temp <= 30) ? 2 : 3;
  int humidLevel = (humid >= 40 && humid <= 60) ? 0 : (humid >= 30 && humid <= 70) ? 1 : (humid >= 20 && humid <= 80) ? 2 : 3;
  
  return max(max(airLevel, tempLevel), humidLevel);
}

void updateDisplay(int comfortLevel) {
  unsigned long currentTime = millis();
  
  if (currentTime - lastBlinkTime >= blinkInterval && !isBlinking) {
    isBlinking = true;
    currentBlink = 0;
    
    
     = currentTime; // Start the blink sequence
    blinkInterval = random(60000, 180000); // make the blink interval a random number between 1 and 3 minutes
  }

  if (isBlinking) {
    if (currentBlink < blinkCount * 2) {
      if (currentTime - lastBlinkTime >= (currentBlink % 2 == 0 ? 0 : blinkDuration)) {
        // Toggle blink state
        bool blinkState = (currentBlink % 2 == 0);
        u8g2.firstPage();
        do {
          drawEyes(0, blinkState);
        } while (u8g2.nextPage());
        lastBlinkTime = currentTime;
        currentBlink++;
      }
    } else {
      isBlinking = false;
      lastBlinkTime = currentTime; // Reset for the next blink
    }
  }

  int eyelidHeight = isBlinking ? 60 : comfortLevel * 20;
  if (comfortLevel == 3) eyelidHeight = 54; // Almost closed

  u8g2.firstPage();
  do {
    drawEyes(eyelidHeight, false);
  } while (u8g2.nextPage());
}

void drawEyes(int eyelidHeight, bool isBlinking) {
  const int leftEyeX = 32;
  const int rightEyeX = 96;
  const int eyeY = 64;
  const int eyeRadius = 30;
  const int eyeVerticalRadius = eyeRadius * 1.4; // Make eyes longer vertically
  const int lineWidth = 30;  // Width of the blink line
  const int lineThickness = 4;  // Number of horizontal lines to draw for thickness

  u8g2.setDrawColor(0);
  u8g2.drawBox(0, 0, 128, 128);

  // eyes
  u8g2.setDrawColor(1);

  if (isBlinking) {
    // Draw horizontal lines (multiple for thickness)
    for(int i = 0; i < lineThickness; i++) {
      // Left eye line
      u8g2.drawHLine(leftEyeX - lineWidth/2, eyeY + eyeVerticalRadius - lineThickness/2 + i, lineWidth);
      // Right eye line
      u8g2.drawHLine(rightEyeX - lineWidth/2, eyeY + eyeVerticalRadius - lineThickness/2 + i, lineWidth);
    }
  }

  else{
    // Draw left eye as a filled ellipse, longer vertically
    u8g2.drawFilledEllipse(leftEyeX, eyeY, eyeRadius, eyeVerticalRadius);
    // Draw right eye as a filled ellipse, longer vertically
    u8g2.drawFilledEllipse(rightEyeX, eyeY, eyeRadius, eyeVerticalRadius);

    // pupils
    u8g2.setDrawColor(0);
    // Draw left pupil slightly to the right of the center for cartoonish effect
    u8g2.drawDisc(leftEyeX + 8, eyeY, 8);
    // Draw right pupil slightly to the left of the center for cartoonish effect
    u8g2.drawDisc(rightEyeX - 8, eyeY, 8);

    // eyelids
    u8g2.setDrawColor(0);
    // Top of the eyelid is based on the vertical radius
    int eyeTop = eyeY - eyeVerticalRadius;
    u8g2.drawBox(0, eyeTop, 128, eyelidHeight);
  }
}


void displaySensorData(float temp, float humid, int airQuality) {
  u8g2.firstPage();
  do {
    u8g2.setDrawColor(1);
    u8g2.setFont(u8g2_font_helvB12_tr);
    u8g2.setCursor(10, 15);
    u8g2.print("Temp: ");
    u8g2.setCursor(10, 35);
    u8g2.print(temp);
    u8g2.print(" C");

    u8g2.setCursor(10, 55);
    u8g2.print("Humidity: ");
    u8g2.setCursor(10, 75);
    u8g2.print(humid);
    u8g2.print(" %");

    String airQ = (airQuality == 0) ? "Clean air" : (airQuality == 1) ? "Low pollution" : (airQuality == 2) ? "High pollution" : "Extremely polluted";
    u8g2.setCursor(10, 95);
    u8g2.print("Air quality: ");
    u8g2.setCursor(10, 115);
    u8g2.print(airQ);
  } while (u8g2.nextPage());
}

Credits

Makestreme

9 projects • 10 followers

I make DIY projects that are fun and interesting! An engineer by profession :) youtube.com/@makestreme

Contact

Comments

Please log in or sign up to comment.

Gus 2.0 - Uses Emotions To Indicate Room Health