Project development

The bending bench

System diagram

• One single beam, b x h: 140 x 90 mm.
• General estimate for maximum load capacity.
  2kN/m x 1.5 =3 kN/m
• Symmetrical cantilevers: yes
• Board height: 600 mm.
• Define the shape of the supports.
  Draft design Final design

Seats

• Define the pressure sensors: plattform type 4 x 50 kg per seat
• Define the shape of the individual seats: WildcardWeek
• Nine seats will be arranged along the beam.

Load Cells

Problem-solving steps

• I will use scales of 50 kg each, four units are grouped in a Wheatstone bridge and should work at a maximum of 60/70% of their maximum capacity so the estimated load will be 1'2 kN per seat

• Collecting the data from each of the load cells. Week 09

• I will use this data to calculate the bending stress on the beam. I’ll determine the values at n points for each section.

• Once I have the key values, I’ll map them so they can be displayed on the LED matrix.

• These values will be sent via WIFI to the microprocessor installed in the LED frame to evaluate the bending moment diagram.

LED Matrix

• Objective: drawing the bending moment diagram.
• Frame dimensions: 1000x500 mm 17 rows and 32 columns. Number of cells: 544.
  Cell dimension: 30x30 mm
• The neutral fiber will be drawn in the center row.The number of rows must be odd.
• The graph must be proportional to the applied forces. In a later development
• Maximum load alarm.
• Possibility of significant values information.
• Calculation of support reactions? In a later development
• Shear force diagrams.

Bench parametric design

For the parametric design of a wooden bench for bending tests I have used the Grasshopper software in Rhinoceros to design an algorithm that allows the creation of a parametric model of the bench. I will gradually define in more detail the constructive and formal characteristics of the overall design. The advantages of parametric design is that the proposals can be updated dynamically over time.

I have divided the model into the following parts and for each one I have defined the following parameters:

Final project development week by week

Week 9

I solved the connection issue of multiple load cells using a single CLK signal.
Now, I need to tackle the reading problem for nine groups of four load cells each. Each group will be placed under a seat.
Following Luis’ recommendation, I’ve decided to organize the readings so that I’ll have:

• One PCB collecting data from the three seats on the left.
• Another similar PCB collecting data from the three seats on the right.
• A central PCB with the XIAO ESP32C3 MCU, which will not only gather data from the three middle seats but also consolidate the readings from the other two PCBs.

Week 10

During week 10, I was able to resolve several critical issues related to the functionality of my final project:

• Persistent load cell calibration
  On the bending bench side of the system, I developed the necessary code for storing the load cell scaling data directly on the microcontroller using the Preferences library. This ensures that calibration values are not lost when disconnecting the PCB or closing the Arduino IDE, preserving accurate readings across power cycles.

• LED control PCB
  I prepared one of the most essential components for my project: the PCB that controls the LED frame. I plan to use 11 LED modules of 50 LEDs each, which operate at 5V and require an external power supply. To safely integrate this with the 3.3V components on the PCB, I incorporated a dedicated external power input in the design, including a protection diode to prevent potential damage to the MCU or other components.

  

  In line with the idea of enabling future developments, I designed the PCB to include additional connectivity options beyond controlling the LED modules.

  Besides the LED control line, DATALED the board features:

  • A connector for an OLED display, SCL and SDA, useful for debugging, displaying real-time data, or showing logo effects on the panel.
  • Five additional data inputs, DATA1 to DATA5, that can be used to control other functionalities that may be required later on.

  

  This approach ensures the PCB remains versatile and expandable, allowing for future iterations or improvements in my final project without the need for a complete redesign.

  You can consult the full Bill of Materials (BOM) for this PCB on the Week 10 assignment page, which includes all components used, their values, reference codes, and suppliers.

• Power consumption tests
  I conducted power consumption tests on the 50-LED modules. These tests confirmed that each module draws a maximum of 0.9 A, which is essential information for correctly dimensioning the external power supply. I also defined the geometry of one of the beam supports for my final project.

Week 11

In addition to the assignments scheduled for this week, I worked on the design and fabrication of the frame that will hold the LEDs. I also made significant progress in the development of the code, both on the server and client sides. On the server side, I prepared it to scale up to reading nine load cells. On the client side, I learned how to remap the LED modules in order to define the lighting criteria, including color and intensity, based on the values evaluated by the server.

Week 13

System Diagram

Week 15 & 16

Under Luis’s guidance, I have moved forward with the design of the PCBs for my final project to use them during the System Integration week. I am also preparing the PCBs that will collect the load cell data.

In the beam structure design, I will place a board under the seats. On this board, I will mill the necessary spaces to house the PCBs corresponding to each load cell, create cable pathways, and allocate space for the box that will contain the central control PCB.

Central PCB Bench side

Individual PCBs for HX711
These PCBs will be placed under the seats according to the numbering shown. It will be necessary to manufacture three units of each of them.

Weekend Progress

On Friday, May 9, I decided to make a significant change after simulating the bending moment diagram in Rhinoceros using 50 x 50 mm cells. I found that the resulting representation was too pixelated. To resolve this, I reduced the cell size to 30 x 30 mm. Thanks to the Grasshopper strategy I had prepared, the modification was straightforward. I created a new frame with 3 rows and 3 columns to evaluate its appearance.

At the same time, I designed the covers to be placed on each cell. These covers will be 3D printed. To optimize the printing process, I developed a strategy in Grasshopper, defining the nozzle diameter and layer height as the main geometric control parameters. This approach ensured the perfect execution of the covers.

On Saturday, May 10, exactly one month before the final presentation, I prepared tests to verify the intensity of the colors I will use to represent the bending moment diagram. I used the PCB prepared during week 6 Electronic design and wrote this code to make the LED colors change cyclically with each button press on the PCB.

On Sunday morning, I made the laser cutting machine work hard. Early in the morning, I exported the paths from Grasshopper and imported them into CorelDraw to manufacture the frame for the LEDs. I used a 5 mm thick MDF board, and after performing a couple of tests, I adjusted the cutting speed to 550 mm/min and the power to 95% for linear movement and 85% for curved paths. The cutting process for the bottom board of the frame took a bit more than 1 hour and 40 minutes.

In the afternoon, I dedicated my time to defining the shape of the seats that I will place on the beam. I had been thinking for a while about using a shape similar to the tall stools I have in my kitchen, which I bought at Zara Home. I scanned one with Scaniverse, exported the points in PLY format, and in Rhinoceros, I cleaned and adjusted the points before generating a mesh that I later discretized and adjusted to obtain a symmetrical and smooth piece. I intended to use this design the week after, yet I modified this design and the fabrication method as we will see later.

On Tuesday 13th, I left the assembly of the frame which will hold all the LED modules almost finished .

Week 17

Weekly Progress Report

This week has been truly productive; I believe I have made significant progress in my final project. On Thursday, May 15th, I milled the central board that will control the load cells and the PCBs that will be placed under each cell, integrating the HX711 amplifier. Then, I soldered all the components and modified the EdgeCut design of the small PCBs to fit the size of the HX711 board. I think this way the whole set will be better integrated.

That same Thursday, I also inserted all the LEDs into the frame I had prepared the previous day. There are 11 modules of 50 LEDs, 17 rows, and 32 columns, making a total of 544 LEDs in the frame, plus six more that I will use to signal the system’s operation in the control box of the frame. Initially, I had started placing the front covers of the squares, but Luis wisely advised me to first install the LED modules to begin the system programming tests.

Non Stop LEDs

After inserting them, I prepared the connections from the power supply so that each 50-unit module receives enough power for its operation. I also shared the same GND between the board and the power supply and connected the data wire to the correct MCU pin. For safety, I performed partial power-ups as I finished the bridges from the power supply to each module.

Finally, the LED garden is planted and running.

The next step was to prepare the supports for the back panel, which I finished printing early Saturday morning.

Then, I placed inserts so that the back panel could be screwed onto these supports, facilitating its removal in case of any unforeseen events.

New seat design

I dedicated the entire weekend, both Saturday and Sunday, to designing and cutting the new seat model. The process is documented in Week 17. I am very satisfied with the result and now waiting for the arrival of the flexible foam I purchased in order to carry out the final cut of the nine seats.

Load cell PCB case

On Monday, May 19th, I dedicated the day to designing, printing, and testing the placement of the box that will house the load cells and the PCB with the HX711 amplifier.

I simulated the bottom board with foam to speed up its manufacturing, reducing execution time and facilitating any minor adjustments to the initial design. The initial design underwent several changes and adjustments until reaching a final solution that minimized printing times while ensuring the rigidity of the assembly.

For testing, I reused some foam board scraps, and after adjusting their dimensions, I machined them on our large-format Alarsys FRH210 router and preliminarily tested the system’s operation.

In the images below, we can see the cable channels that will lead to the load cell control PCB.

This would be the appearance of the case with the lid in place, leaving the load cells positioned to support the seat. I will likely adjust the placement of the cases by raising them above the board to provide more space between the seat and the panel housing the load cells.

On Tuesday, May 20th, before installing the back cover of the LED panel, I thought it would be a good idea to place all the missing front covers. I spent a short while fitting them, and since I had adjusted their dimensions correctly, they were installed completely press-fit without the need for adhesives.

Non Stop Caps

And this is the final result with the LEDs turned on.

Week 18

Week 18 has been somewhat special for several reasons. The first is my stay in Valencia and the award my colleagues gave me in recognition of my professional career in the BIM field. Upon returning to Coruña, everything was going well until Francisco informed me that last Friday the CNC machine had stopped working. On Monday, I contacted Alarsys support and it seems the power supply has failed. The manufacturer will send a replacement, which should arrive in a couple of days.

Hot wire robot tool

In the meantime, I have a lot of work to do. First, I prepared the cutting paths for the foam seats and got everything ready to begin cutting them early on Tuesday morning. I made sure the workspace was properly ventilated, using both natural and forced ventilation.

Robotic arm milling

While waiting for the new power supply, I will use the spindle motor to mill the beam supports. The robot is not as precise as the CNC machine, but it will be sufficient to fabricate thes components. However, I must adjust the feed and spindle speeds. I will use straight two-flute end mills with diameters of 6 mm and 8 mm. The machining parameters I plan to use are listed below, although I will fine-tune them depending on how the milling progresses.

After running some speed tests with the robot and the spindle, the milling of the boards is progressing. Once Neil’s class finishes this afternoon, I hope there will be enough time to have all the beam support components ready for assembly.

Week 19

Beam assembly

On Thursday, I finished fabricating all the components of the bench structure using the robotic arm.

With all the parts ready, I proceeded with a test assembly.

At that moment, I was satisfied with the result; however, my opinion later changed regarding the use of the foam seats.

The next step was to position the wooden boards that will hold the boxes containing the load cells. Everything fit together properly.

On the morning of Saturday, May 30th, I dedicated my time to soldering, wiring, and assembling the boxes that house the PCBs. Special attention was required to correctly connect the load cell wires and properly configure the Wheatstone bridge. Fortunately, I had clearly documented this process back in week 9.
Soldering

As I assembled each group of three load cells, I verified their operation using a test code—identical to the one used during the Networking and Communications week, with only the data pin changed for each load cell.
Wiring organization example at load cell number 9. Testing received data Later that Saturday afternoon, from home, I focused on developing the code to control the LED matrix. Luis provided me with a flexible LED matrix of 8 rows by 32 columns, which greatly simplified my work, as I didn’t need to use the custom matrix built for the final project and could carry out all necessary tests with ease.

I organized the code to simulate different values in order to represent various load scenarios. The final matrix has 17 rows by 32 columns, and the test matrix is 8x32, so all tests are easily scalable.

Test 1: Point load on the cantilever tip and another in the middle of the span.

Test 2: Uniformly distributed load—equal load on every seat.

Test 3: Point loads on the two outermost seats located at the ends of the cantilevers.

The diagrams still need some refinement, but they already convey the structural concept I aim to demonstrate with my final project.

On Sunday, I spent the entire morning at the ETSAC Coruña FabLab preparing another group of three load cells. After verifying their operation, I installed the six load cells I had already prepared in their final positions.

I also prepared the enclosure that will house the PCB responsible for receiving data from all nine load cells; this box will be mounted at the end of the wooden beam.

On Monday morning, I completed the installation of all the electronics on the beam. I verified the electrical continuity of all connections and had to re-solder the Data channel pin for load cell 3 on the central PCB. Aside from this issue—which I was able to fix easily—everything worked flawlessly.

Beam perspective

On Monday afternoon, the new CNC power supply arrived, special thanks to Alarsis for their prompt service and fast shipping. Replacing the damaged unit was a very straightforward task; within half an hour, the CNC machine was fully operational again.

With the CNC machine back in operation, I was able to prepare the seat platform, including the necessary recesses to ensure proper contact with the load cells. Although I could have done this with the robotic arm, the CNC provides greater precision, especially thanks to its ability to automatically probe the Z0 on the top surface of the material. With the robot, this process still has to be done manually until I develop a semi-automatic referencing system.

Between Monday night and Tuesday morning, I finalized the design of the control enclosure for the LED matrix. This box will house the power supply, the PCB, and the status LEDs that will later indicate the operational state of the system.

The control box was attached to the LED frame using cable ties, which remain completely hidden from view. This solution will allow me to easily modify or replace the enclosure in the future, depending on any new requirements that may arise.

However, I did have to apply adhesive to the white PLA printed parts in order to attach them to the wooden perimeter boards of the frame. These printed components include threaded inserts that allow each of the rear panels, into which the back cover has been subdivided, to be fastened with four M3 screws.

These covers not only conceal and protect the wiring of the LED modules, but also apply slight pressure on the LEDs to prevent unwanted movement. It’s important to note that the entire frame assembly is press-fit, and the LEDs are tightly inserted into dedicated holes designed for each one.

To mount the PCB, I designed a small 3D-printed podium that securely holds the board I fabricated during week 10. In the future, I plan to design a dedicated PCB specifically for the LED frame. For now, thanks to the features of the current PCB, I can power the microcontroller externally, so there is no need for it to remain permanently connected via USB. The USB connection will only be used for programming the Xiao ESP32-C3.

Stress diagrams

With all the frame components already in place, on Wednesday, June 4th I focused on completing the program that would represent the bending moment diagrams based on the values sent by the load cells. For the initial tests, I prepared a series of static values that should be correctly represented on the frame. This allowed me to fine-tune the code so that the diagrams were displayed correctly according to the laws of statics.

Once I completed the code for interpreting and displaying the bending moment diagrams, the next step was to set up communication between the bench and the LED frame. To do this, I relied on the concepts I had learned during the Networking and Communications week and prepared both the client and server code before uploading them to the MCUs. I encountered a small issue with the reading from load cell three. After disassembling it and checking all the connections, with Luis’s help we identified a faulty solder joint on the DATA channel of the PCB. By applying a small amount of solder, the problem was resolved without major difficulty, and all readings are now correctly detected.

The next step was to set up the tare conditions for the load cells and the individual scaling of each one. I carried this out using a 10 kg weight. The code is configured so that, by entering the command s1, s2, …, s9 into the serial monitor, the system prompts for the real weight of a known object, calculates the correct scale factor, and stores it in the MCU’s memory using the Preferences library. An automatic tare is performed at system startup, and if a new tare is required later, entering t will tare all nine load cells, while t1, t2, …, t9 will tare them individually.

At this point, I thought it would be interesting to represent not only the bending moment diagram on the frame, but also a simulation of the beam showing the position of the supports and the points of load application that produce the displayed bending moment diagram. I modified the client code, and after several tests, I approved the resulting visualization.

The final task of the day was to prepare small custom-cut wooden cleats, screwed in place to secure the LED frame in its final position.

With Luis’s help, on Thursday I installed the mounting points for the seat boards onto the load cells. I had planned four attachment points, and I fixed each seat in its final position using 60 mm long screws. There is no issue with tightening the board against the load cells, since a taring process is performed at the beginning of the program, which sets the measurement values to zero and eliminates any preload introduced by this method of seat fixation.

LED Frame Testing

The next step was to place the LED frame in its final position. It was secured using two plastic-coated metal wires wrapped around the columns and fastened to the connectors I had prepared on the frame the previous day.
The frame rests on the table I built during Week 7.

Under Luis’s watchful eye, I worked on solving some fine adjustments in the remapping logic required to represent the bending moment diagram correctly. Since I receive data from nine load cells and need to display it over 30 columns, careful calibration is essential.

In the image below, it can be seen that the negative bending moment is not displayed in the column corresponding to the right support. After investigation, I identified the issue: it was caused by rounding errors in the remapping process for the 30-column display.

In the physical layout of the frame, the first LED is located in the bottom-right corner, row 0, column 0. The display logic across columns 1 to 30 is organized as follows:

• Row 0: symbolic representation of supports
• Row 1: beam outline
• Row 2: dynamic display of active load positions
• Row 3: unused
• Row 4: unused
• Rows 5 to 9: area for positive bending moments
• Row 10: neutral axis
• Rows 11 to 16: area for negative bending moments

Once the mapping structure was established, I dedicated several hours to resolving the rounding and remapping issues affecting the accurate placement of maximum bending moments derived from the load cell readings. I introduced a set of code refinements, thanks OpenAI, to ensure that the peak moment always aligns precisely with the correct column for cantilever moments, this should always occur in vertical alignment with the support; for central spans, it should align with the load causing the maximum moment in that segment.

It was a long and intense day, on Thursday, June 5th, I left the Fablab at 3:00 a.m. on Friday after having arrived at 8:30 a.m. the previous morning. But in the end, I succeeded: the bending moment diagrams now display correctly for any combination of loads.

Visit from the Structural Team

On Friday, June 6th, after a mid-morning coffee around 11:00 a.m., I invited my colleagues from the Department of Architectural Structures to come down to the Fablab and verify the correct behavior of The Bending Bench. I hadn’t turned the system back on since the night before, so this felt like a real trial by fire.

Juan Pérez Valcárcel, full professor of Structural Engineering, along with Marilo Otero and Félix Suárez, both associate professors at the University of A Coruña, and above all, colleagues and friends, joined me and actively tested the system.

Uncut Video Test

It was a really fun moment where The Bending Bench performed flawlessly, correctly visualizing all the load cases applied. A total success!
Thank you, friends.

As soon as they left, I think the tension from all these intense days finally caught up with me, my energy dropped to zero. I went home for lunch and ended up spending most of the afternoon asleep on the couch, before deciding to just call it a day and go to bed.

On Saturday, I dedicated the day to updating this section, preparing the summary slide for the final project, and editing the presentation video for next Tuesday.

Coding

I will explain in this section the most relevant aspects of the code I have developed to link the load cell readings with the representation of the bending moment diagram on the LED matrix.

Server side

On the server side, the code enables sequential reading of the nine load cells by using a single pin for the clock signal, which is shared across all load cells.

// ------------ HX711 CONFIGURATION ------------
#define CLK_PIN D7
const int dataPins[9] = { D3, D2, D1, D6, D5, D4, D10, D9, D8 };

HX711 load;
float scales[9];
float readings[9];
long offsets[9];  // NEW: offset array for each load cell

Preferences preferences;

unsigned long lastRead = 0;
const unsigned long interval = 400;
int currentIndex = 0;

During the Networking and Communications week, I carried out a series of tests to read two load cells. Based on that development, I scaled up the system until I was able to continuously display the raw values from all cells on the serial monitor.

// ------------ MAIN LOOP ------------
void loop() {
  server.handleClient();
  handleSerialCommands();

  if (millis() - lastRead >= interval) {
    lastRead = millis();
    readNextCell();
  }
}

Sequential reading with safe CLK handling

To avoid simultaneous use of multiple instances, the code dynamically the code performs a sequential reading and adds a delay between readings to prevent interference:

// ------------ SEQUENTIAL READING ------------
void readNextCell() {
  load.begin(dataPins[currentIndex], CLK_PIN);
  delay(50);
  load.set_scale(scales[currentIndex]);
  load.set_offset(offsets[currentIndex]);  // apply correct offset

  if (load.wait_ready_timeout(500)) {
    readings[currentIndex] = load.get_units(10);
  } else {
    readings[currentIndex] = 0.0;
  }

  currentIndex = (currentIndex + 1) % 9;
}

Tare and calibration of each load cell

The code performs an initial tare to zero out the starting values of the program. As I had implemented during the Input and Output Devices weeks, pressing the t key in the serial monitor allows me to perform a new tare at any time.

Additionally, each cell can be calibrated individually from the serial monitor by typing s1, s2, …, s9. To set the scale factor, the following prompt appears in the serial monitor:

Serial.printf("Place a known weight on A%d and enter its weight (kg):\n", index + 1);
Serial.print("Weight (kg): ");

Once the known weight has been entered, the scale factor is calculated and stored in the non-volatile memory of the MCU using the Preferences library.

Plain-text HTTP response

Initially, in the first tests, I sent the readings from the nine load cells as a JSON object. This required using additional libraries to parse the JSON on the client side, which increased memory usage and unnecessarily complicated the code.

Following Luis’s recommendation and with his help, I opted to use a simple plain-text format, where the server composes a single string containing all the values in a compact, fixed-width format.

Each value consists of three digits, padded with leading zeros if necessary, and separated by semicolons. This format is easy to debug and visualize through the serial monitor and requires no external libraries on the ESP32.

// ------------ PRINTING AND SENDING ------------
void sendReadings() {
  String output = "";
  for (int i = 0; i < 9; i++) {
    int value = (int)readings[i];
    if (value < 0) value = 0;

    if (value < 10) output += "00" + String(value);
    else if (value < 100) output += "0" + String(value);
    else output += String(value);

    if (i < 8) output += ";";
  }
  Serial.println(output);
  server.send(200, "text/plain", output);
}

Client side

Reading data from the server
The client connects to the server, retrieves a compact plain-text string containing the nine load values separated by semicolons (e.g., 000;045;043;075;065,000,000,000;102), and parses them into the array cargas[9]. This is done using the standard sscanf function, which directly extracts the values into each index of the array as floating-point numbers (float). These values represent the load measured on each of the nine seats and are used in subsequent calculations to generate the bending moment diagram.

void obtenerCargas() {
  HTTPClient http;
  http.begin(serverUrl);
  int httpCode = http.GET();

  if (httpCode == 200) {
    String payload = http.getString();
    sscanf(payload.c_str(), "%f;%f;%f;%f;%f;%f;%f;%f;%f",
           &cargas[0], &cargas[1], &cargas[2],
           &cargas[3], &cargas[4], &cargas[5],
           &cargas[6], &cargas[7], &cargas[8]);

    Serial.print("Loads: ");
    for (int i = 0; i < 9; i++) {
      Serial.print(cargas[i], 2);
      Serial.print(" ");
    }
    Serial.println();
  } else {
    Serial.println("Error retrieving data from server");
  }
  http.end();
}

Bending moment calculation

Moments are calculated based on the forces and their position along the beam (total length: 4.20 m; distribution: 1.10 + 2.00 + 1.10 m):

void calcularMomentos() {
  const int N_FINE = 300;
  float momentos_finos[N_FINE] = {0};
  for (int i = 0; i < 30; i++) momentos[i] = 0;

  float L = 4.2;
  float l_v = 1.1;
  float l_c = 2.0;
  float dx_fino = L / float(N_FINE);

  for (int i = 0; i < 9; i++) {
    float P = cargas[i] < umbral ? 0.0 : cargas[i] * 9.81;
    if (P == 0.0) continue;

    float x_carga = 0.5 + i * 0.4;
    for (int j = 0; j < N_FINE; j++) {
      float x = dx_fino * j;
      float M = 0;

      if (x_carga < l_v && x <= l_v) {
        M = -P * x * (l_v - x_carga) / l_v;
      }
      else if (x_carga > L - l_v && x >= L - l_v) {
        M = -P * (L - x) * (x_carga - (L - l_v)) / l_v;
      }
      else if (x >= l_v && x <= (L - l_v)) {
        float a = x_carga - l_v;
        float b = (L - l_v) - x_carga;
        float Lc = l_c;
        if (x <= x_carga)
          M = P * a * b / Lc * (x - l_v) / a;
        else
          M = P * a * b / Lc * ((L - l_v) - x) / b;
      }

      momentos_finos[j] += M;
    }
  }

Remapping of forces to LED matrix

Each seat is mapped to its physical column on the LED frame (from right to left), with rounding to ensure visual stability.
To achieve a correct representation, I had to solve a series of issues:

• Horizontal reflection: initially, seat 9 (left side) appeared on the right side of the screen. Fixed by inverting the column mapping.
• Asymmetries: when applying symmetric loads (e.g., seats 2 and 8), the diagram was not symmetric. This was corrected by rewriting the moment and remapping logic.
• Incorrect moment alignment on cantilevers: the peak moment should appear above the corresponding support (columns 7 and 24). This was fixed by adjusting the bending diagram generation logic.
• Adjust the values to represent the diagrams between columns 1 and 30 and rows 5 to 16.

void dibujarMomentos() {
  float scale = 0.8;

  for (int col = 1; col <= 30; col++) {
    float m = momentos[col - 1];
    int height = int(abs(m) * (NUM_ROWS - FIBRA_NEUTRA - 1) * scale);

    for (int i = 1; i <= height; i++) {
      int row = (m < 0) ? (FIBRA_NEUTRA + i) : (FIBRA_NEUTRA - i);
      if (row >= 5 && row < NUM_ROWS) {
        int idx = getLEDIndex(row, col);
        leds[idx] = (m < 0) ? COLOR_NEGATIVO : COLOR_POSITIVO;
      }
    }
  }
}

To complement the information displayed on the LED matrix, I decided to use the three bottom rows (0, 1, and 2) to include a symbolic representation of the structure, showing proportionally the location of the supports and the position of the loads applied on each seat.

BOM

Hardware

Electronics

Schedule for remaining task

Month	Day	Days	Topic	Final Project
April	21		Mechanical design, machine design	Meet with local and global instructors	✔
	23	2	Molding and casting	Designing and milling Final projects PCBs	✔
	30	7	Interface and application programming	Milling and mounting the beam supports	✔
May	7	7	System integration	Cutting and mounting the LED panel	✔
	14	7	Wildcard Week	Finalise design of seats. Construction and installation of the nine seats. Soldering PCBs	✔
	21	7	Applications and implications, project development	Placement of load cells. Developing the code for the reading of the load cells and the representation of the bending moment diagram	✔
	28	7	Invention, intellectual property and income	Testing and trials. Test publication of a presentation design and final video production	✔
Jun	4	7	Weekly assignments deadline	Completed the code for load cell reading, server and client design, and the bending moment calculation program with remapped representation on the 17-row by 32-column frame. Updating project development. publication of final slide and video for the project presentation	✔
	5	nueval Academany	Local and Global evaluation		95%
	10		Final project presentations	Slot: 09:14’ Jun 10th	✔
	16		Local and Global Evaluation Completed		✔

Schedule updated 16.07.2025

Files

PCB Loadcell control. KiCAD. PepeVazquezLoadCellPCB.zip
PCB HX711. KiCAD. PepeVazquezHXPCB.zip

Bending Bench. CAD definition. Rhinoceros v8. 20250603_MillingSupport_v11.zip
Board under seats. Vcarve. BoardsUnderSeat.zip
HX711 Load cells case. stl.v8_Case.zip
HX711 Load cells lib. stl. B8_Lid.zip
Central PCB case. stl.CentralCaseLoadCell.zip
Central PCB Lid. stl. CentralLidLoadCell.zip

PCB Frame LED. KiCAD. PCBPepe_Output.zip
PCB Frame LED. Vcarve. Pepe_Output.crv

Frame LED. CAD definition. Rhinoceros v8. FrameLeds_v06.zip
Lid for LED frame. Grasshopper. LidForLEDFrame.gh
Lid for LED frame. Stl. Lidx30x30_LidLEDs.stl

Code Server side. Manage load cells. ino. BendingBenchServer_v02.zip
Code Client side. Manage bending moments representation. ino. BendingBenchClient.zip