Did you know hundreds of tiny earthquakes travel across the Earth’s surface daily, many too small to be felt? In this project, we design and test our own high-resolution digital seismometer. It can pick up the smallest vibrations in the surface below, and relay the data to our computer for viewing and analysis!
- by Liam Davies.
Seismometers are not a new thing - there is evidence of their creation and use in Ancient Egypt, and they were set up to fill up pots of water when a significant vibration was detected. However, with the ability to use precision-manufactured mechanical setups and very sensitive electronics, the 21st century concept of a seismometer goes beyond just detection. We can delve into much deeper analysis, allowing us to make predictions about location, frequency and the exact tectonic movement of an earthquake, even if it’s not detectable by humans.
We’re not pretending that we’re seismologists here - but we do think the project we’re showing off has a big potential to teach many about the amazing uses and information that can be derived from seismology.
How It Works
There are many different configurations that a seismometer can be set up in, and all vary in complexity, accuracy and component count. However, all have a common method of detection - having some target object that can move relative to the sensors when ground movement is present. If we can measure this movement, it’s a seismometer. Measuring this movement over time makes it a seismograph. Simple stuff!
The real possibilities come from what we can do with this information! By analysing seismic activity, we can deduct information about the location, scale, time, and geography of any particular event.
The first wave to arrive at a seismometer from any particular event is the P-wave, which is a compressional wave. It’s the fastest travelling, and the rock vibrations travel in the direction of propagation.
The second wave to arrive is the S-wave, which is a shear wave travelling perpendicularly to the direction of propagation. It’s slower travelling than the P-wave, but both eventually arrive at seismometers.
Why is this important? It turns out that we can derive the distance of a particular seismic event using this information! Once we know the difference between the times the P and S waves arrive, we can use well-documented wave speeds to figure out how far away the event was.
Knowing how far a seismic wave is away is useful, but it would be even more helpful if we knew where it was exactly. We can solve this problem with more seismometers, placed in other locations.
Two seismometers allow us to triangulate the possible positions to two potential solutions, assuming that both found the distances to the same seismic event. In the real world, these distances could be thousands of kilometres apart, perhaps over other continents or countries.
Once we introduce a third, we are now able to pinpoint our event down to an exact location - hence the famous term ‘epicentre’! With more sensors, we can even resolve further information such as the 3D position of the earthquake (the ‘focus’) and geological composition. It’s pretty amazing stuff!
One aspect to recognise is that seismic activity rarely happens in one direction; a combination of horizontal and vertical movement is usually present. Many scientific-grade seismometers will use a variety of different sensors and axes to gather as much information as possible. Here is some of the most common channels used:
RaspberryShake
However, for the sake of simplicity, we’re only measuring the vertical axis, or SHZ/EHZ as the table suggests.
Popular Setups
The simplest configuration is a magnet suspended from a spring, which is surrounded by a tightly wound coil as closely as possible. Whenever the magnet moves relative to the coil, tiny currents will be induced into the coil windings, which we can detect as an analogue signal.
The magnet should be fairly heavy so that its inertia is high. Why would we want this? Shouldn’t the magnet be as light as possible so it can move as freely as possible?
Counterintuitively, the frame of our whole contraption will be moving around the magnet, not the magnet itself. This means that our magnet should be mechanically isolated from the movement of the Earth below. Remember, all we need is relative movement between the magnet and the coil!
There are, of course, other configurations. Maker Mirko Pavleski made this design with a needle, magnet and disassembled transformer:
Coil Voltage
The coil that’s wrapped closely around our magnet will be generating tiny voltages whenever there is relative movement between them. How do we convert this voltage into a usable digital signal for our analysis? We’ll be using a precision 16-bit Analog to Digital Converter, which includes its own differential amplifier.
In other words, it’s both able to amplify the tiny differences in the voltage across the coil, and convert that into a digital output with a very reasonable degree of precision.
We’ll also need some way of dampening the Seismometer whenever a vibration is detected. Since we’re designing our system to be as sensitive as possible, the system will continue to move for a long period of time after detection. There are a few ways of slowing down the magnet in the centre, but we’re choosing to use a shorted Copper coil.
Minimising Inaccuracy
There are a number of sources of inaccuracy our project can be affected by, so however you choose to build a seismometer, you’ll need to minimise as many of these as possible. Of course, since we’re only interested in building this as an experiment, you don’t need to be as diligent as a scientific observatory would be.
The first source of problems comes from the environment, which will be local disturbances and vibrations in the surface - basically, people walking or talking near it. It’ll be sensitive enough that this will cause some serious issues. Local vibrations from the base of the seismometer won’t be the only issue, though. Many professional seismometers are protected from the environment, both to prevent damage, and to prevent wind and thermal air currents affecting readings.
Mounting the unit properly is also extremely important. While we recognise most people building this project won’t be mounting this project directly to the bedrock under their house (although, if you are, let us know!), it’s still important to put it somewhere that has a stable connection to the Earth underneath.
RaspberryShake
Before we get into the project build, we wanted to check out a currently existing project platform.
The biggest Earth Monitoring system currently available for makers is the RasperryShake platform. We looked into this quite a lot, as it provides an awesome insight into how earthquake data is collected and used.
RaspberryShake offers pre-made kits available for individuals, schools and professionals that uses, as the name suggests, a Raspberry Pi coupled with a geophone to monitor seismic activity.
The data isn’t closed-sourced to customers, either - the currently online data sources and detected earthquakes are visible 24/7 at stationview.raspberryshake.org! There are thousands of these units worldwide, all working to plot real-time seismic activity.
It’s also possible to directly view the seismic activity at dataview.raspberryshake.org:
Our project won’t quite be compatible with this setup, as our sensor isn’t really ready to use with RaspiShake - it’s just another option if you’re interested!
We’ll delve more into the software setup in our fundamental build.
Build 1: The Fundamental Build
| Parts Required: | Jaycar | Altronics |
|---|---|---|
| 1 x CA3130 Op-Amp^ | ZL3860 | - |
| 3 x 1kΩ Resistor* | RR0572 | R0558 |
| 1 x 100kΩ 25-Turn Trimpot | RT4656 | R2388A |
| 1 x Solenoid Winding or Spool | WW4016 | W0405 |
| 2 x 1N4004 Diodes or equivalent* | ZR1004 | Z0109 |
| 1 x ADS1115 16-bit ADC board (Adafruit: 1085) | - | Z6221 |
| 1 x Arduino Uno or compatible board | XC9202 | Z6240 |
| Circular Magnets | Bunnings: 3690089 | - |
Breadboarding hardware also required. ^ Exact model not needed
For our Fundamental Build, we’re testing the performance of our seismometer with our coil, magnet and ADC board.
Amplifier Board
Our ADC has an inbuilt amplifier, however, there are some other issues that we need to consider with our coil! Our ADS1115 ADC can only safely read voltages between -0.3V and 5.3V, assuming that we’re powering our ADC with 5V.
Our coil can generate both positive and negative voltages, especially when there are sudden movements. Even though we plan to operate our ADC in differential mode (i.e. measuring the voltage difference between two inputs), we must stay within the maximum voltage range.
To fix this problem, we’ll need to set our coil voltage above 0V - say, 2.5V - and amplify any differences the coil generates with an Op Amp.
Here is the first step of our coil circuit. We’ve included a diode facing both ways, which normally should never be forward-biased (i.e. conducting). However, if the coil generates a voltage above the forward voltage of any diode in either direction (typically 0.6-0.7V), it will cause the current to short-circuit through the diode.
We can then hook up our op-amp, in an inverting configuration. Notice here that we are connecting a voltage divider to the bottom side of the coil to set it to 2.5V. The other side of the coil is connected to the amplifier’s input.
For those who are not comfortable working with op-amps, all this circuit does is amplify the difference the voltage the coil generates from 2.5V. Our output voltage could also be described like this:
We also added an adjustable gain, which can be changed by altering the potentiometer Rf. Ideally, when we finish our build, we will induce small oscillations into the seismometer and adjust the gain to suit our desired sensitivity.
Finally, we can connect our ADC to our Op Amp circuit. One input is connected to the Op Amp’s output, and the other to our voltage divider generating 2.5V. Let’s build our circuit.
We built our circuit on a breadboard with a CA3130 Op Amp. You can see our feedback resistors in the photo above.
We added a 100kΩ potentiometer for controlling the gain of our op-amp, and two diodes for clamping the voltage of the coil.
Finally, we connected our circuit to the coil and plugged in some oscilloscope probes to test the circuit.
Immediately, we noticed some rather large oscillations appearing on our Op Amp's output - we should be hovering at a stable 2.5V, however, the output is continuously oscillating by nearly 2V above and below.
We suspect this is due to the Op Amp struggling to amplify the difference between the signals - perhaps the CMRR (common-mode rejection ratio) isn’t high enough to prevent the op-amp amplifying the common 2.5V at the input. Unfortunately, we didn’t have time to isolate this problem, so we had to simplify the circuit.
Our revised circuit is much simpler, only using the diodes in conjunction with the ADS1115 ADC. This means that, normally, our coil voltage will stay at 0V. When the magnets induce voltages in the signal coil, we’ll find that the voltage will be large enough to damage the Op-Amp, as it’ll go above 5V and below 0V. This will only occur with large movements though; and if it’s a significant enough seismic wave to set this off, there are much bigger concerns than temporary overvoltage of an ADC - i.e. it’s a serious earthquake.
Software
Our seismometer is, fundamentally, pretty simple when it comes to the software side of things. Our data is a “time series” signal, where a set of points is ordered by time, usually spaced in equal steps. This is not a complex task - if you continuously grab data from an Analog input on an Arduino, this is a Time Series signal. Oscilloscopes use analog voltage signals to analyse features of the waveforms in the same way.
The complexity of the software side of this project comes from analysing that time series signal. We can do this in a variety of ways, as we discussed in our introduction. From analysing S-waves and P-waves to comparing our data with other scientific seismometers, we can do a lot with our available data.
For our fundamental build, though, let’s just get a basic version of our code running. We used the ADS1115 library written by Rob Tillaart, which includes an example called ‘ADS_read_async_rdy.ino’ that we adapted.
void setup()
{
Serial.begin(9600);
ADS.begin();
ADS.setGain(16);
ADS.setDataRate(4);
ADS.requestADC(0);
ADS.setComparatorThresholdLow(0x0000);
ADS.setComparatorThresholdHigh(0x0200);
ADS.setComparatorQueConvert(0);
ADS.setComparatorLatch(0);
}
Our initialization code is pretty important, as it sets our sample rate and gain values. We set our gain to 16x, which gives us a voltage range of +/-0.256V. Since our ADC is 16-bit, we have 2^16 = 65,536 unique values in that range, equating to a resolution of 3.9uV per count!
We also set our sampling rate to 128Hz, which seems to be within the acceptable range of 50-200Hz given for most amateur seismometers. The noise and gain performance decreases when increasing the sampling rate according to the ADS1115, so it's in our best interest to keep it as low as possible.
void loop()
{
if (ADS.isReady())
{
int16_t val_0 = ADS.getValue();
ADS.requestADC(0);
Serial.print(val_0);
Serial.println();
}
}
Finally, our loop code just continuously tests whether a new data point is available. If it is, it outputs it onto the Serial console, ready for the Serial plotter to display.
And that’s it! Pretty simple, right?
We wanted to do a quick test of how sensitive our seismometer is. We held a magnet in front of the coil with our hands, and tried to be as still as possible.
Turns out that humans aren’t great at being still! It’s good to see our coil is very sensitive to the magnet’s movement. It was so sensitive that we could move the magnet 30cm away from the coil and still see discernable movement appearing on the graph.
You may have noticed the two extra lines on the graph above at y = -1000 and y = 1000. These do not serve any functional purpose, and we added them to prevent the Arduino’s serial plotter from auto-ranging constantly. We find the autoranging quite confusing when it constantly changes scales with any form of differing input.
In any case, we’re happy with our fundamental build performance, so let’s really tie this project together and build our 3D printed design!
Build 2: The Main Build
| Parts Required: | Jaycar | Altronics |
|---|---|---|
| 2 x 1N4004 Diodes or equivalent* | ZR1004 | Z0109 |
| 1 x Arduino Uno or compatible board | XC9202 | Z6240 |
| 1 x ADS1115 16-bit ADC board | - | Z6221 |
| 1 x Spool of Enameled Copper Wire | WW4016 | W0405 |
| 3 x M3 10mm Screws* | HP0403 | H3120A |
| 3 x M10 Balljoint Feet* | Bunnings: 0078248 | - |
| 14 x M3 Nuts* | HP0425 | H3175 |
| 3 x 500mm x 12mm Aluminium Rods | Bunnings: 1067750 | - |
| 3 x 10mm M3 Couplers* | HP0900 | - |
| 11 x 15mm M3 Screws* | HP0406 | H3130A |
| 8 - 12 x 21mm Magnets* | Bunnings: 3690089 | - |
| 1 x Breadboard Layout Perfboard | HP9570 | H0701 |
| 2 x 6-long Female Headers* | HM3230 | P5374 |
| 1 x 4-long Male Header* | HM3212 | P5430 |
| 1 x 2-long Male Header* | HM3212 | P5430 |
| 1 x 38mm Metal Slinky | - | - |
| Jumper Wires | - | - |
| 1 x 487mm Acrylic Tube (58mm ID, 63mm OD) | - | - |
* Quantity required, may only be sold in packs.
Sourcing Parts
The final version of our seismometer has been designed to be assembled as easily as possible, with commonly available parts from hardware and craft stores. The first parts we’ll need are three Aluminium poles, with a minimum length of 500mm each. Ideally, the diameter to choose will be 12mm, however, we’ve provided adjustable clamping for the poles, so a small tolerance outside of this dimension will still work.
Probably the most expensive part of this build is the acrylic tube. Our tube has an inner diameter of 58mm, and an outer diameter of 63mm. We picked up ours from a local plastic supplier, at a discounted price of $45 for 1.3m. However, don’t feel that you need to use acrylic, or even a clear tube for that matter - we chose ours for the cool internal looks.
As long as a suitably sized tube is used, it’ll work the same. You can even skip the tube, and just use the aluminium rods for holding up our Seismometer. However, bear in mind that the project will be much more susceptible to atmospheric disturbances.
We’ll also need to find a metal Slinky! While they are a kids toy, it turns out that they’re excellent for making high-quality seismometers thanks to the elastic springs. Make sure to find a good quality slinky around 35mm in diameter, and check that it’s symmetrical. We bought a few at a local games store.
Another important selection to make in our build is the magnets we’re using.
We recommend using some high-quality neodymium magnets, however, some cheap fridge magnets should work reasonably well too.
3D Printing
There are a few 3D printed parts that are required for our seismometer build. The two most important are the top and bottom bracket sections. These will hold our aluminium and acrylic tubes in place, as well as acting as supports for everything else to mount onto. We recommend printing these models with more infill than usual to increase their weight and rigidity - it’s important everything in this build is stable. We did ours in yellow PLA.
The other six parts are used for mounting and securing springs, electronics, and the coils. We printed these parts in orange PLA to add a cool accent colour.
Putting It All Together
Let’s assemble our seismometer. To get started, we cut down our acrylic and aluminium tubes, which we can do with a drop saw.
We cut our 1m aluminium tubes into 500mm pieces, and the acrylic tube to 487mm. These measurements don’t need to be exact, however, the Aluminium tubes do need to be longer than the Acrylic by at least 10mm.
We also added rubber feet to our bottom yellow base print, which we’re hoping will both stabilise the seismometer and allow us to level everything if the magnet makes contact with anything. The rubber feet also have M10 threads on the top side of the print, so we can secure the levelling setting with nuts once we’re done building.
We can then push our aluminium tubes into our yellow base prints. We found that our aluminium poles were very snug in the slots. Three 15mm x M3 screws and nuts were used to hold them in place.
Before we insert our acrylic tube, we’ll need to insert our slinky into the top yellow base part. We’ve designed a special slot in the part so that the slinky can be inserted without bending the spring. You’ll see later on that we’ll need to adjust the number of coils that support the magnet carrier, so don’t coil it up too much.
The acrylic tube should click into the circular recesses on the top and bottom. Don’t force it! You may need to recut your tube straighter if it doesn’t want to pop into the slots.
The next part we’re working on is the coil holder. This simply acts as two spools of copper wire, one of which will be used for sensing, and the other will be used for dampening the seismometer.
We’ve wound our own coils many times in the past at DIYODE. Take it from us - it’s a pain doing it manually, especially with coils that require hundreds or thousands of turns. We made this process easier with a simple 3D print and a hand drill. A small cylinder we printed will friction-fit to the internal section of the coil holder.
Once that’s done, we can slide it onto one of our left-over aluminium tubes and lock it into the chuck of a hand drill. We also had to use some Gorilla Glue and some Blu-Tak to make sure everything stays put while we’re winding the coil.
To get the coil started, we grabbed a full roll of enamelled copper wire and taped it onto the top coil section. We can then lightly hold the wire with our left hand, and rotate the hand drill with our right hand. Do it slowly at first, and ensure that the wires are compact while moving slowly across. We went back and forth across the coil 5-6 times for maximum sensitivity.
Once we’ve fed the wires through the included spool holes, we can repeat the process with the bottom spool section. Be sure to keep taping everything down and ensure that all wires are taut. At this point, the copper wire spool should be relatively empty.
The wires of our top spool can be left hanging, but we’ll need to do something extra to the wires of the bottom spool - solder the wires together! Since it’s acting as a dampener, shorting the coil closed will cause current to flow through it whenever a magnet is moved nearby. Due to Lenz’s Law, this current that flows will oppose the initial magnetic field, slowing down the magnet as a result. This should reduce the continuous oscillation behaviour we see when letting the slinky fly free by itself.
You may need to grab a file and sandpaper to expose the ends of the enamelled copper wire, before securely soldering it together. Great, our coil holder is done!
Before we insert it into our seismometer, though, let’s build our magnetic carrier to actually allow it to sense oscillations! The magnet carrier consists of two 3D-printed parts which both secure to the other side of the slinky and hold the magnets in place.
To get started, grab your magnets of choice - ours were 21mm in diameter - and carefully insert them into both of the top and bottom slots. We’ve designed two slots to allow some magnets to act on the dampener coil, and some to act on the detection coil.
We had to print this part a few times - it’s designed to be as compact as possible, so it can be fragile when trying to assemble and push the magnets in.
Here is one of our broken attempts, which snapped after we tried to push too many magnets in at once. After we got it to work though, the magnets sat comfortably into the holder.
Next comes the tricky bit: we need to attach our magnet carrier to our seismometer’s slinky! Like the yellow top part, it’s been designed to easily slot into the spring.
Grab the top part of the magnet carrier and wind the spring through a few times, until it sits comfortably. You should also ensure that the spring sits as horizontally as possible when vertically positioned.
We then sandwiched the spring between the top part of the carrier with three 15mm x M3 screws, making sure that we screwed them down at equal rates so the spring isn’t dramatically stressed on one side. Our magnet carrier is now fully attached to the seismometer, however, we need to make adjustments before we insert our coil holder. You may notice that, after attaching the carrier, the slinky doesn’t have enough sufficient force to raise the magnets and their carrier off the ground. To fix this, we’ll need to raise the spring above the top base until the carrier lifts to an appropriate height.
We should be aiming for something like the photo above. You can adjust the spring by rotating it like a screw until the carrier lifts off the ground to the desired position. Finally, you may need to bend or deform the spring until it sits as vertically as possible - if it hangs on an angle, it will foul against the coil holder, reducing sensitivity.
Speaking of which, we can finally insert our coil holder. It should slide into the acrylic tube with a satisfying ‘thunk’, at which point it should surround the magnet carrier. Use three M3 screws to securely attach it to the yellow base.
At this point, our seismometer chamber should be fairly airtight, with the exception of the bottom hole where the magnet carrier can be accessed if necessary. Use a rubber plug if you’d like to close this up.
To mount the circuit which we’ll be building next, we also screwed on our board holder to the bottom base section with more M3 screws.
To do a quick preliminary test, we hooked up our Fundamental Build circuit to the coil, and ensured that it was outputting a signal the way we expected it to. After running the same test code as our Fundamental Build and checking that it outputs data correctly, we can now work on our finished circuit!
Final Circuit
Our final circuit is exactly the same as our fundamental build, however, we’re soldering everything onto a breadboard layout perfboard. This lets us make everything a bit more compact, too!
To start off, we added two six-long header strips and soldered them into the board, which lets us remove the ADS1115 board if we run out of room.
We then added a four-long male header for external connections to the SDA, SCL, ALERT and READY pins on our ADS1115. We also added wire bridges to connect the board to our 5V and Ground connections, with a two-wide male header for power. Finally, we added two 1N4004 diodes to the Ground rail, in opposite directions to each other.
IMPORTANT NOTE: You’ll notice the two orange wires connecting the diodes to Ground change to shorter red links later. These orange links are incorrect - refer to the Fritzing for further reference.
We can then connect the other side of our diodes to the A0 input of our ADS1115. This can be done in any way desired, however, we did ours with two simple wires linked across the diodes.
We then snapped off the unused area of the board, and used a third hand to hold the board near our seismometer. We soldered the seismometer coil to the high and low side of the diodes, ensuring that the enamel on the wires burn off - make sure good contact is present! We’ve provided a small hole for the coil wires to be routed through on the board holder part.
Finally, grab some double-sided tape and stick the board to the holder!
We also stuck down the Arduino Uno, with the USB port facing downwards. After making sure the seismometer is sitting on a level surface, plug it into a computer so we can load up our software!
Software
We’re carrying over the code we used for the fundamental build, so we won’t need to reprogram the Arduino. For our final build, we’ll be using a piece of purpose built software called jAmaSeis, written by IRIS in Java. It’s a simple but very powerful software. It’s essentially a recording software for seismometers, which converts readings into histories of seismic events.
After downloading jAmaSeis from the link in our project resources, we can install it with most of the default settings.
A cool aspect of this software is that you don’t need your own seismometer to explore seismic data from around the world! On the installer screen, we can select up to six seismograph sources from around the world to monitor concurrently.
We selected a seismograph in Keiraville, Wollongong, Australia to compare with our readings of our DIY seismometer. You can hold Ctrl on your keyboard to select multiple sources.
Once the software is initialised, it may take a few minutes to source the last few days of data from the remote sources you have selected.
To add our own seismometer, we can add a new source in the Source menu. We can simply add it as a SEP type seismometer, which supports simple new-line separated serial data. As soon as you add it to the source list, it should be recognised immediately and new data will be available on the screen.
If you want to get serious about seismic monitoring, we suggest using some form of always-on PC, such as a “stick PC” to continuously plot the seismic data onto jAmaSeis.
Testing
Now comes the fun part! We tested just how sensitive our seismometer is in the jAmaSeis software. The answer? Very! It’s easily able to detect people walking around the DIYODE workshop, and when trucks park or brake outside the office, small peaks appear too.
However, this is also a good point to talk about environmental problems related to the seismometer - we can’t detect the difference between an earthquake and a delivery truck!
We have seen some enthusiasts on the internet bury their DIY seismometers underground to mitigate local vibrations, but that’s a bit out of our project scope.
As we’re located in NSW, real earthquakes of any significance, even with Richter magnitudes less than 2, are fairly rare. Therefore, we weren’t able to pick up any earthquakes and correlate them to other observations.
In any case, the jAmaSeis tool includes full analysis of P-waves and S-waves built in, which is extremely fascinating.
We experimented with calculating theoretical epicentre distances, and correlating them with other sources.
It’s awesome stuff, and if you’re a maker that lives in earthquake-prone areas, there is a genuine possibility of contributing to citizen science with a project like this!
Where To From Here?
Our seismometer has been a really interesting experiment with high-sensitivity electronics, and taught us a lot about Earthquake detection and measurement techniques. However, there are a number of improvements and changes that can be made to our project to further improve its performance.
Our Slinky-based design isn’t the most sensitive. Many higher-tech devices use more sensitive methods of detecting seismic waves, such as load cells and multi-axis sensing.
It’s worth noting though, that even in our prototype, we were able to detect and plot very small vibrations around our office, so with further tuning, it’s possible to go a lot further with this!
If you want a turnkey hardware solution for seismic activity monitoring - maybe you’re not so interested in DIY-ing the electronics - the RaspberryShake platform we previously talked about is an awesome starting point.
There is huge amounts of data present for citizen scientists and curious tinkerers to work with. It’s easy to experiment with P and S waves with real-time wave data from around the world.
Let us know what you come up with at @diyodemag