Our Goal – Make A Better Bridge Crusher!
This year Bob and I decided to upgrade our bridge project. We wanted to create an improved device for measuring the load on the model bridges created by the students. Specifically, we wanted to design a way for the students to collect meaningful performance data.
The problem with our old method (filling a bucket with sand until the bridge catastrophically failed) was that it didn’t allow for the students to collect evidence about where and why the bridge failed. In many cases, the bridge actually experienced a significant failure, but because the bridge collapsed around the loading plate, the loading plate actually acted as a support for the bridge.
We had seen other “bridge testers” from vendors (http://www.pitsco.com/Structures_Testing_Instrument, http://kelvin.com/kelvin-bridge-material-tester-w-cpad/, http://www.vernier.com/products/sensors/vsmt/) but we had the idea that perhaps we could create one that might be better, or at least it might be fun to try. In this post, we are going to share with you what we created and why we think it actually turned out really well, but we also point out some room for improvement.
The frame of the entire device is really based on the Vernier Structures and Materials Tester. We thought this frame was probably the best, and we wanted to make our tester from extruded aluminum tubing as well. We went about designing the bridge tester in our favorite CAD program, Fusion360 by Autodesk. We sent our CAD file to the company 8020 and they precut all our t-slotted aluminum frame members to size. This was awesome because it made assembly super easy and it saved us on shipping too! Our experience with this company was amazing – they were super helpful and even gave us some really helpful advice. If you are thinking about making anything requiring t-slotted aluminum, definitely order from them.
The Load Sensors
We wanted a a bridge tester that actually gave us data that allowed us to figure out how and why the student bridges failed. That meant that we needed more data and we needed data that could be connected to the design and fabrication of the bridge. We noticed that all the vendors’ designs had only one load sensor, and some also had a way to detect overall deflection. We suspected that we could get better data if we had four independent load sensors – one for each abutment where the bridges were supported. The four sensors would (theoretically) give the students a way to analyze how the load was being distributed, and thus tell us something about the torsional behavior of the bridge.
I set out to learn a bit about load sensors and I came across a fantastic tutorial at Sparkfun (https://learn.sparkfun.com/tutorials/getting-started-with-load-cells). We ordered four load sensors (see picture above) from Sparkfun. Our design (shown below) has the four load sensors fitted with 3D printed “shoes” as the bridge abutments.
The sensors are mounted on custom fabricated aluminum plates that can be moved laterally to accommodate slightly different bridge widths. The load sensors had to be connected to load amplifiers that were then connected to an Arduino (more on that below). The load sensors were mounted to the frame of the bridge tester on custom laser cut plates:
The load amplifiers have to be used with the load sensors in order to amplify the signal so that the Arduino can read the data correctly.
The Loading Mechanism
Bob designed and fabricated the loading mechanism that was based on many of the designs we had seen online. It consists of a block that is free to move vertically up or down a threaded rod which is then connected to a spoked wheel.
When the wheel is turned, the block moves up or down the threaded rod. This bar is connected to a loading plate via a metal cable that hooks into the loading plate and the block:
The loading plate is placed on the loading plane of the bridge (the “roadway”), and then the bridge is loaded by spinning the wheel, which lowers the block, which pulls the bridge downwards:
Collecting The Data: The Software
The software responsible for collecting the data is made up of two programs – one that runs on the Arduino micro-controller that is connected to the load sensors, and the other is a Processing sketch that runs on a computer/laptop connected to the Arduino via USB. The code is pretty simple, and it was mostly written using code from other sources and then modified for our specific purposes.
The Arduino code just collects the data from the four load sensors and then sends the data serially as a comma delimited package. The Processing code reads the serial port and then essentially dumps the data into a csv file. It does have some flourishes like a graphical display of the individual sensor loads as well as a display of the total load and whether or not the bridge has met the minimum load requirement set in the project descriptor.
You can view and download all the code here on GitHub.
The Performance Report
When the data is displayed in a graphing program, it looks like this:
You can see that the four sensors do not read equal values, and that the bridge begins distributing the load unevenly. The blue and orange lines show that these two load sensors were equally loading and were taking on a larger load than the green and red values from the other two load sensors. Later inspection of the bridge showed that this bridge failed at the load sensors that were recording a higher load value. Also, these sensors were located diagonally from one another, and once again showed that the bridge was being twisted.
You can also see that around 80 seconds (the 800 data sample) that the bridge experienced a sudden decrease in load – this was the point of failure. The data clearly shows a point at which the bridge failed and thus gives us a clear metric for performance.
The student teams were each given the results and were asked to answer these questions:
- What was the maximum load that your bridge sustained before failure?
- Calculate the load to weight ratio of your bridge.
- What were the individual maximum force values on each load sensor before failure?
- Identify on your bridge where the bridge failed. Take a picture of this point of failure and note its location.
- Based on the load data for the four sensors, describe why your bridge may have failed.
- What could you have done to increase the performance of your bridge?
The data really allowed for some rich analysis and the students were able to make some really informed critiques of their design and fabrication quality. We have been very happy with the results!
For version 2.0 we hope to add these improvements:
- Add the ability to measure deflection. We think that this might be done by measuring the angular displacement of the loading wheel, but we aren’t sure just yet.
- Some way for the software to detect a failure – perhaps a way to detect a significant decrease in the load data. It would have to allow for some downward movement of the load data because there is some settling and deforming that can occur that might not be catastrophic.
- It would be nice to clean up the code – especially the Processing code. I’d like to add some fancy GUI elements too so that it is a bit more attractive.
If you would like to build your own advanced bridge tester for your classroom, we can send you all our CAD files, software files and even answer questions. Its not easy to build, but its fun, and we spent about $350 dollars on this project as opposed to the $1000 to $1300 that the vendors are selling theirs for.
Amazing. Such a fantastic project.
I wonder if applying strain sensors to the student’s bridge itself would be useful. I saw a bridge building game Android game once that showed the bridge’s stress as it was getting a load and I thought it was great to see which members were receiving the most load. It would produce a lot of data though which might be laborious for students to process and visualize.
I’d be happy to help with your processing code.