Week 10

Output devices

Week assignment

1. Group assignment:
   • Measure the power consumption of an output device. Document your work on the group work page and reflect on your individual page what you learned. ✔
2. Individual assignment:
   • Add an output device to a microcontroller board you’ve designed and program it to do something. ✔

Group assignment

In my final project, I will use an LED matrix to represent the bending moment diagrams corresponding to the loads applied to a simply supported beam with cantilevers.

At this stage, the design consists of a rectangular frame with dimensions of 2000 x 1000 mm. On Monday, March 24, I confirmed the order of 14 units of 50pcs DC 5V WS2811 Full Color LED Pixel Light Module 12mm 10cm Wires IP68 Waterproof RGB Color Digital LED strings, which will arrive in a couple of weeks.

It will be essential for me to determine the power consumption of each module. Therefore, as part of the group assignment, I prepared a test to measure it. The power consumption will vary depending on the intensity and the number of LEDs turned on.

The test consisted of simulating three static LEDs in the center of the module, representing the neutral axis. Then, the LEDs positioned above and below the neutral axis were sequentially and consecutively activated.

Additional information about the materials I used is available on the group page. The code has been uploaded to the Files week-10 section of this page.

Link to week 10 group assignment

Individual assignment

This week, I organized my work to conduct a test in which, after determining the weight of an object placed on the load cell, the measured value would be displayed on an OLED screen.

After discussing it with my instructor Luis, we decided it would be appropriate to design a new PCB that allows simultaneous connection of an OLED screen via I2C, an HX711 ADC amplifier, an LED module, and four additional pins for future functionalities. Since my final project requires controlling more than ten LED modules, each with 50 LEDs, Luis recommended designing the PCB with an independent 5V Vcc and GND input, separate from the USB-C input. The LED modules will be powered with 5V, while the rest of the pins will receive 3.3V from the MCU.

To protect the MCU from overcurrent, I added a diode SCHOTTKY 100V 1A between the external Vcc input and the XIAO ESP32-C3.

I designed the circuit using KiCad, as shown in the schematic and PCB layout images below:

I encountered a minor issue when placing the external 5V and GND inputs. The Fab TermBlock connector in KiCad did not have an associated footprint. I searched the repository and updated the KiCad master libraries to the latest version, following the process I documented in Week 6, but I could not find the footprint. To solve this, Luis recommended manually drawing a solder pad in KiCad for the 5V input and another for the GND. Below is the final PCB design. Initially, I included two spaces for screws to mount the PCB onto a support. However, I later decided they were unnecessary, so I did not execute the inner cuts of the circles, though I left them in the design in case they are needed in the future.

Following the steps I had documented in Week 8, I exported the F.Cu and Edge Cuts SVG files from KiCad, imported them into GIMP, increasing their resolution to 1000 pixels per inch, and then prepared the PNG files, following all the steps explained in Week 8 of my documentation. Next, I milled the PCB without any issues using our Roland PNC-2500 CAMM-3. I then started soldering all the components. As Luis recommended, I first applied a small amount of solder to each component to facilitate their proper placement.

I also placed the 100V 1A Schottky Diode, paying special attention to its orientation. This diode will prevent the 5V from the MCU from reaching the external power source.

OLED I2C Display

In Week 4, I had prepared a code in Wokwi to display the reading from a beam-type load cell on an OLED screen.
Wokwi Load Cell Week 4
This week, I wanted to complete the code to automate the weighing process. But before that, I had to understand the communication with the OLED. In this case, Luis provided us with a 0.96-inch OLED screen with a 128x64 pixel resolution using the I2C SSD1306 driver.
To test its functionality, I first installed the following libraries in the Arduino IDE: Adafruit GFX and Adafruit SSD1306. Tools > Manage libraries > install
After installing them, I tested a couple of examples to verify their correct operation.

On the morning of Saturday, March 29, I spent some time exploring different configuration possibilities for the display. I wanted to send my logo, so I searched for options to generate the image code. The first tool I tried was LCD Assistant but I preferred the configuration options offered by Image2cpp. To send the logo, I needed to convert it into a monochrome BMP image. In GIMP Image > mode > grayscale and then Image > Mode > Indexed I selected the Black and White palette and clicked Convert. Finally, I resized the image to 64x64 pixels before exporting it as a BMP file. However, this adjustment was not strictly necessary since I could modify it later in the image2cpp settings.

As mentioned earlier, I experimented with different background and positioning configurations and ended up preparing a code to create a scrolling effect with the logo on the screen.

On Saturday afternoon, I focused on improving the load cell reading code to achieve automatic taring. I also tested different configurations for displaying the weighing results on the OLED screen. This process involved adapting a code I had previously developed in Week 9 through an iterative approach. With the help of FabAcademy’s ChatGPT, the implementation became much easier. This work kept me busy on Saturday and Sunday afternoon until I was satisfied with the program’s behavior.

I encountered some issues when trying to store the scale value in the XIAO ESP32C3’s memory. Initially, ChatGPT suggested using the EEPROM library, but the scale would reset every time I closed the Arduino IDE or disconnected the USB from the PCB.

Eventually, I solved the problem by using the Preferences library instead of EEPROM, ensuring that the scale value remained stored even after powering off the ESP32. The scale value is retrieved in setup() and stored in performcalibration().

I also implemented the option for a new taring process by pressing the T or t key and an automatic scale value calibration by pressing the S or s key and simply inputting the actual weight of the object placed on the load cell.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "HX711.h"
#include <Preferences.h>

// HX711 pins
const int LOADCELL1_DOUT_PIN = D8;
const int LOADCELL_SCK_PIN = D7;

HX711 load1;

#define SCREEN_WIDTH 128  // OLED display width in pixels
#define SCREEN_HEIGHT 64  // OLED display height in pixels

// OLED display I2C address
#define OLED_ADDR 0x3C

// Preferences instance
Preferences preferences;

// Display object declaration
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

float reading = 0;
float scale = 1.0; // Default scale factor

void setup() {
  Serial.begin(115200);
  preferences.begin("scaleData", false); // Open Preferences with namespace "scaleData"

  // Load scale factor from Preferences
  scale = preferences.getFloat("scale", 1.0);
  Serial.print("Loaded scale factor: ");
  Serial.println(scale, 6);

  // Initialize OLED display
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) { 
    Serial.println(F("Error: OLED display not detected"));
    for (;;);  // Stop execution if the display is not responding
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 10);
  display.println("Fab Academy 2025");
  display.println("Pepe Vazquez");
  display.println("Initializing scale...");
  display.display();

  // Initialize HX711
  load1.begin(LOADCELL1_DOUT_PIN, LOADCELL_SCK_PIN);
  delay(500);

  Serial.println("Initializing scale...");

  // Wait until HX711 is ready before taring
  while (!load1.is_ready()) {
    Serial.println("Waiting for HX711...");
    delay(1000);
  }

  performTare(); // Perform initial tare

  delay(100);
}  

void loop() {
  // Check if the user pressed 'T' or 't' to perform a new tare
  if (Serial.available()) {
    char key = Serial.read();
    if (key == 'T' || key == 't') {
      performTare();
    } else if (key == 'S' || key == 's') {
      performCalibration();
    }
  }

  // Read weight
  if (load1.is_ready()) {
    reading = load1.get_units(10) * scale; // Apply the scale factor
    Serial.print("Weight: ");
    Serial.print(reading, 2);
    Serial.println(" kg");
  } else {
    Serial.println("LoadCell 1 HX711 not detected.");
  }

  delay(500);

  // Display on OLED screen
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 5);
  display.println("Fab Academy 2025");

  display.setCursor(0, 20);
  display.setTextSize(1);
  display.print("Weight: ");
  display.print(reading, 2); // Display weight with 2 decimals
  display.println(" kg");

  display.display(); // Update screen

  delay(500); // Small delay to avoid excessive refresh
}

// Function to perform tare
void performTare() {
  Serial.println("Performing new tare...");
  load1.tare(20); // Take 20 readings to calculate the new tare
  Serial.println("New tare completed.");
}

// Function to calibrate the scale
void performCalibration() {
  Serial.println("Place a known object on the scale...");
  delay(3000); // Wait a few seconds to stabilize the reading
  
  float displayedWeight = load1.get_units(20); // Take the average of 20 readings
  Serial.print("Displayed weight: ");
  Serial.println(displayedWeight, 2);
  
  Serial.println("Enter the actual weight of the object and press ENTER:");
  float actualWeight = 0.0;
  while (actualWeight == 0.0) {
    if (Serial.available() > 0) {
      actualWeight = Serial.parseFloat();
      while (Serial.available() > 0) Serial.read(); // Clear buffer
    }
  }

  if (displayedWeight != 0) {
    scale = actualWeight / displayedWeight;
    preferences.putFloat("scale", scale);
    Serial.print("New scale factor saved: ");
    Serial.println(scale, 6);
  } else {
    Serial.println("Error: Displayed weight cannot be zero.");
  }
}

BOM PCB Week 10

Bill of Materials

Final Thoughts

This week has helped me connect the learnings from previous weeks, linking the simulations performed in Wokwi during week four with the knowledge acquired in the design, production, and input devices weeks. Designing and manufacturing a new PCB has been a much easier task, although I still have a lot to learn. Understanding the role of a diode as a protection component has been a challenge for me, but thanks to Luis’s explanations, I now have a clear grasp of its basic operation.

Regarding my final project, this week I have focused particularly on designing the code to implement a scaling option for the load cell readings, especially their storage in the MCU. This operation will be crucial for the future functionality of the bending bench. Next week, I will need to send the load cell readings to the LED matrix to visualize the structure’s bending moment diagram. For now, I have both operations working separately, so the next step will be integrating them to achieve their combined functionality.

Files week 10

LEDs Group Assignment
50LEDs from central Blue

PCB
PCB Output KiCad.zip
PCB Output-F_Cu.svg
PCB Output-Edge_Cuts.svg
PCB Output-F_Cu_Tracks.png
PCB Output-Edge_Cuts.png
PCB Output Vcarve Pro

OLED
Initial test OLED I2C ino zip
Logo 128x64 ino zip
Scroll Logo ino zip

LOAD CELL and OLED
Load cell tare, calibration. Saving scale preferences ino zip