Dust Collection Monitor Details

This article will go over in detail how to get this project started.

Also, check out my detailed YouTube video.

As far as support, I’ll do my best to answer questions, but I am not going to be providing unlimited free support. Remember, Google is your friend, there are tons of articles and videos on setting the Arduino up and getting started with the IDE. However, please let me know if you spot bugs, problems in this article, or have good ideas for improvements, I’d love to hear about those.

One place you can start is to get an Arduino starter kit, and play with some of the pieces that come with it. One of the first sketches (as they call the programs), just blinks the internal LED once per second. You can modify the pulse by adjusting the delay(milliseconds) statement, and changing the milliseconds, then seeing the different blink pattern on the LED. Go from there, and check out further projects. Some of them are interesting, and it can be fun to learn about the software and hardware. The kit comes with a breadboard and some jumper wires, to help you hook up projects. It’s a great point to start learning about Arduinos.

First of all, I grabbed the Arduino IDE. The only way to take the software I have and load it to the Arduino is with the IDE. It compiles the software and will install it to the Arduino. This is available for Windows, Mac and Linux. Get this installed, then under the Tools menu, set your Board type to “Arduino Mega 2560”. Set your processor type to Mega2560, and after plugging your Arduino into the USB, set your COM port under the Tools menu also.

It is unlikely that this project would work with other Arduino models. I picked the Mega 2560 for its extra IO pins, and the extra memory it has on board. I’m already over most of the other models of the Arduino memory size, except the Zero or Due. These two models run at 3.3v, and would need some changes to get things to work. So stick with the Mega2560 board for this project. One library that takes a lot of memory is the Ethernet library, which I am currently using to sync the time and date with, but I have some more plans for that later.

Download my source file to get the code for this project.

On Windows, there is an Arduino folder in the Documents area. Under that there is a Projects folder, you can unzip my source file into the Projects folder. Open the project in the IDE. You should only have to look at the very top portion of the code, from approximately line 50 to 150. You will be modifying the #define statements to include the hardware you will be using. I’ll go over each of these below. They are very simple, and usually are followed by a 0 (zero) or 1. One means you want that option, zero is when you won’t be using that option. Only options currently needing to be changed will be gone over below.

Hardware #define Options

#define INCLUDE_ETHERNET 1 : Set to a 1 if you want to use an Ethernet board, or a 0 if you won’t be using this. Currently this supports a wired Ethernet Shield. So far, I am using this to help set the time using a NTP server. Not only does it set the time, it keeps the time synced for the utmost in accuracy, and also does daylight savings time adjustments.

I may add a wireless shield option in the future, if there is interest.

#define INCLUDE_NTP 1 : Set this to 1, if you have the INCLUDE_ETHERNET also set to 1, and you wish to use NTP to get, set, and sync the time. If you use this, you don’t even need a RTC module, you can use the internal timers on the Arduino.

#define DISPLAY_INVERT 1 : For my display, the colors were all inverted, and didn’t look correct. Change this from whatever it is (1 or 0) to try the other setting, for example if your hamburger menu at the top left isn’t white with a black background.

#define INCLUDE_REALTIME_CLOCK 0 : Change to 1 if you want to use the DS3231 RTC module. You can still sync and set this from the NTP server option, or you can set this from a set clock screen under from the hamburger menu. Remember from my general article, try to get one that does NOT use the DS3231M chip. Mine has a DS3231SN chip, and runs great. The DS3231M chip is off minutes per day. This still works if you sync it with NTP, but then what’s the point of buying this, if you have a perfectly accurate clock without it.

#define CLOCK_HOUR_FORMAT 12 : Can be set to 12 or 24. However, you can set this under the SETUP screen under the hamburger menu after you have this running on the Arduino. Once set, this setting overrides what this value is in future updates, so don’t worry about this in an update, you’ve already set it.

#define INCLUDE_BME280 1 : This is the optional temperature, humidity and barometric pressure module. This is optional. You can either have the BME280, or the BMP280, but not both.

#define INCLUDE_BMP280:  This is the optional temperature and barometric pressure module. This is optional. This one is cheaper and doesn’t include the humidity.

#define INCLUDE_ADS1X15 1 : Set this to one if you are using either the ADS1115 (16 bit, but slower) or ADS1015 Analog (12 bit) input module. These give more precision for the pressure sensors for cartridge pressure and DC vacuum. You can still use the internal Analog inputs on the Arduino, which are 10 bit inputs, and not as precise. Since the cartridge pressure is so close to the pressure when off, I decided to get the ADS1115 to get the most precise value as I could.

#define TEMPS_IN_FARENHEIT 1 : Set to 1 or 0, although this is optional and can be set in the Setup screen under the hamburger menu. Once set, this setting overrides what this value is in future updates, so don’t worry about this in an update, you’ve already set it.

#define CARTRIDGE_SENSOR 1 : While technically required, you can even turn this sensor off with a 0. Important are the next three variables, set which port on the Arduino or ADS1X15 board you’ve plugged the cartridge sensor into. Set the InternalAnalog variable to show if it’s internal on the Arduino, a ADS1015, or ADS1115. Set the sensor type to the one you bought. The MPX5010 should be good for this sensor, it is more precise, and you should not encounter any cartridge pressures above 10kPa.

#define VACUUM_SENSOR 1: 1 or 0 if you have a sensor on the vacuum side. Same three settings afterwards that the Cartridge sensor had. The MPX5010 works for me, without exceeding the 10kPa limit of the sensor, however, will this be the case for all DC’s? I don’t know, it is possible some may have a vacuum pressure larger than this. If in doubt, use the MPX5050 sensor.

#define DC_AMPERAGE_SENSOR 1 : Set to a 1 or 0. It’s better to use this sensor, however, you could try it without. I had trouble determining if the DC was on or off just using the cartridge pressure sensor. Determining if it os off or on, changes the screen, and also is how I keep track of time of use for the DC, the filter, and the filter since last cleaned. The DCAmpSensorANum should be set to the Arduino port you are plugged into. InternalAnalog should be set to 0 for internal (suggested), as this reads the sensor many times to get an amperage rating, and the internal sensor is the fastest. DCAmpCalibration I have set to 30, to calibrate the DC Amperage value with my Kill A Watt meter I calibrated it with. Are these all the same, will you need a different value? I don’t know.

#define BME280_ADDRESS (0x77) : Set to the address of your BME280 (if you have one), 0x77 is the default and probably won’t need to be changed.

#define BMP280_ADDRESS (0x77) : Set to the address of your BMP280 (if you have one), 0x77 is the default and probably won’t need to be changed.

#define RTC_ADDRESS (0x68) : Set to the address of your DS3231SN RTC module, if you have one. You probably won’t need to change this.

Setup Libraries: 

Starting at about line 180 through around line 400 are the library includes. You don’t need to change amy of these lines of cose, but you need to load these so your IDE can find them. I’ve included the links to each of these, but you shouldn’t need them.  I’ve included all the libraries in the zip file you downloaded. Copy all these libraries into the libraries folder, which on a Windows system is in Documents/arduino/libraries. You can follow these directions for “Manual Installation” https://www.arduino.cc/en/guide/libraries

Once you’ve downloaded the libraries, you may need to stop and restart the IDE so it sees the new libraries. Then press the round check mark icon at the upper left, which says Verify if you hover over it. Verify compiles the code without loading it to an Arduino, and it should compile with no errors if you’ve loaded all the libraries needed.


If you haven’t soldered wires before, this takes some practice. Maybe search on YouTube for some good videos to learn this. There’s several tricks, you need to heat the joint up hot enough for solder to flow into the wires, and if on a circuit board, down through the hole the wire is in. But you don’t want to overheat the joint and work it too much, you can damage the component you are soldering, and damage the insulation on the wire. You don’t want to put too much solder onto the joint, where it has a heavy blob of solder.

I still use the lead/tin solder, as that’s what I’ve always used, and I have a lifetime supply of that at this point. If you are using lead/tin solder, don’t breath the fumes, solder in an area where you have some ventilation. Wash your hands afterwards.

I’ve never used any flux until on this project (and I’ve soldered 10’s of thousands of connections). Solder comes with flux inside it, solder comes as a thin tube, with a tiny amount of flux inside the tube. This helps clean the wires which makes the solder stick well. Some of the jumper wires I was cutting in half, as I needed a connection on one end, and I soldered the other end. These jumper wires aren’t high quality wire, and have some sort of dark goop on them, and the solder doesn’t want to stick. If you are soldering and the wire itself gets black, then the solder isn’t going to stick. I have to cut that off and start over. I purchased a small container of flux, and these wires I just stick into the flux (after stripping off the insulation) and get a small amount on the end of the wire, then I solder them. This has increased my success at solder the small jumper wires.

When you strip off the wire insulation, only strip off as much as needed. Stripping off too much just makes another place where that wire can short against something else.

I frequently use heat shrink tubing. This is great for insulating and protecting two wires soldered together. Put a small piece over the wire you will solder, solder the wires, then slide the heat shrink tubing over the wires. You could use a heat gun, but I use my fireplace lighter to hold the flame under the tubing to shrink it around the soldered connection. This protects it from shorting out against other wires. If I am soldering a cable with several small wires, I put a piece of heat shrink tubing on each wire, then a larger piece over the entire bundle. One trick is to remember to put the heat shrink tubing on first, before you connect the wires (I often mess up here!). Once you solder them, it’s usually too late, as a lot of times it isn’t possible to slide the heat shrink tubing on any more.

Try to keep the jumper pins to a minimum. I had problems pretty quickly from these connections. I also had breadboard issues. If things aren’t working on a breadboard, move them to a different area of the board. I do need some jumper pins on my board, I want to be able to remove the Arduino from the shop and bring it to my office to reprogram it. I put connectors on the power leads, and to the sensors, so I can unplug the Arduino and bring it in my office to reprogram it.

I ended up soldering the 5v and ground wires to the back of the Arduino. With the Ethernet shield and the display, there was no where to plug in the 5v wire from my regulated power supply. I dabbed a little silicone over the wires to “glue” them to the back of the Arduino, so the wires moving wouldn’t be pulling at the soldered connection.


The TFT touch display you get is just the bare display, with a touch screen over the top of that. Be careful with it, it seems like the touch screen is a bit delicate. I used the Kuman 3.5″ touch display. The library I am using supports many displays, so perhaps other displays could work – however – my software is setup for a 480 x 320 display size.

The way the library displays text, I need to clear the area the text was displayed in with the same color as whatever background color was used. Then I need to redraw the new text in the same area. For example, if the temperature changed from 75.1 to 75.3, it erases the entire 75.1, then draws 75.3. This tends to give it a flicker effect. I try not to change text that hasn’t changed, and I also try to erase the smallest area I can that will erase all the text drawn. If you happen to notice any area where the text didn’t completely get erased, please let me know. It is possible I didn’t get everything correct, with all the different units I am trying to support.

Ethernet Shield

If you decide to get the Ethernet shield, this board plugs in right on top of the Arduino board. You’ll have one issue, the plug for the Ethernet cable is too tall, and now the TFT display won’t plug into the Ethernet shield. I used a set of headers, and plugged them into the Arduino board, these raised up the headers, then I could plug the display into the Ethernet shield. That worked great, no soldering needed.

Normally the display would plug into A7 (Analog input 7), but the Ethernet shield leaves 6 and 7 free. That’s how I was able to use A7 for the amperage sensor. If you aren’t using the Ethernet shield, you can use any other Analog pin that is unused, A8 through A15. Just change the #define DCAmpSensorANum line to the number you are using. Don’t put the “A”, just the number itself.

Schematic & Breadboard:

This is my first time creating the Arduino breadboard drawing and schematic. The schematic makes it look way more complex than it is. Red is always 5v, black is always ground. The two I2C lines: SDA is always orange, and SCL is always yellow. The black, red, orange and yellow are always the same and can be connected together at any point. Any other color is a data line, and these are separate.

On the breadboard drawing, my circuit board looks like a jumble of black, red, orange and yellow wires on the left side. I’ve read the breadboard drawing isn’t very good at conveying information, like the schematic is, and as I was creating it, I could see why. I think it’s great for very simple schematics, but the more parts that are being attached, the harder it is to decipher. The rows of  header pins, in vertical columns starting from the left, are red (5v), black (Gnd), orange (SDA), and yellow (SCL), with ribbon cables you can plug the same 4 colored wires in each row, and it’s very simple and easy to do.

On the schematic, a dot where two lines cross means they connect. No dot means they don’t. Wires of different colors never connect. There are some cases where a ground or power wire cross over another ground or power where and there is no dot. There could be, if the two wires are black, or both are red – however, I just didn’t see how to make a dot there on the schematic, there doesn’t need to be one in that case, as they do connect to the right places in the end. When it doubt, check the schematic. Also most of the wiring is actually very simple. Maybe the most complex thing is wiring up the two resistors and capacitor for the amperage sensor. For that, double check the separate diagram just for that circuit below.

Also, it was hard for me to place pieces on my little circuit board I made, on the breadboard drawing I made on the computer. Lay that out however it makes sense to you, it doesn’t need to be precisely like I made it on the breadboard drawing, or even like my actual circuit board.

My Circuit Board:

Your circuit board can be in whatever order it makes sense for you. It doesn’t have to be an exact copy of mine, whatever gets the job done will work. If you see an easier way, or would rather keep the rows of pins further apart so it’s easier to solder without making a bad solder bridge in the wrong spot, go for it. One possible issue with separating those is, when I plug all 4 wires in, I hold all 4 connectors together and plug in all 4 at one time. If you separate each row with an empty row in between, it will be more difficult to plug the 4 wires in for each I2C device possibly. Basically the little circuit board holds and area for power and ground pins, the two I2C wires so multiple board can hook up, the little bit of circuitry for the amperage sensor, and a pullup resistor for each of the I2C lines. Oh, and a couple capacitors on power lines. That’s basically it. It’s more an area to plug other parts in than it is a lot of circuitry parts.

Because of the shields attached to the Arduino, this left no way to put a jumper wire in for some of the pins. I went ahead and soldered the wires directly to the back of the Arduino for those wires. Right now, I just have the ground and 5v soldered to the back of the Arduino board.

The I2C lines, which are pins 20 and 21 on the Arduino Mega, need pullup resistors. I used 20K resistors for each line, to 5 volts. While they do not show any pullup resistors on these lines when you look up most projects online, they also only show one board on the I2C lines usually. They are using an internal pullup resistor which works OK for one board, but will start failing for multiple I2C boards (they are too weak). In the software, I’ve turned off the internal pullup resistors, since I added my own.

I used the jumper wires to run power, ground and the two I2C lines to my circuit board, then ran 4 rows of jumper headers, joining each row with solder under the board. It is easier if you have a very thin wire to stretch between the pads, which makes it easier to connect all the power pins together, all the grounds, all the SDA and all the SCL together. If you don’t have a wire between the power pins for example, you can blob enough solder on each pin to make it run over to the next pin, but this makes it more difficult, and then there’s the possibility of the solder blobbing from a 5v pin to the ground, which is bad and you’d need to remove excess solder to clean that up. It can get difficult to solder, especially if you haven’t done it before. Be patient, you can get a solder sucker to remove excess solder. Then I can plug in multiple I2C boards with the 4 wires easily. Don’t make the ribbon cable wires too long. Wires with signals will get crosstalk if you have long runs with ribbon cable or other flat cables. Six or ten inches long is fine. Several feet, or 20 feet would be too long.

The amperage sensor is an SCT013-030, a 30 amp sensor that uses a split ferrite core to determine how much amperage a device is taking. You can unclip half of the core, open it up, and clip it back around the hot wire. Do not clip both the common and hot wire, only the hot wire. The advantage to this part is you don’t need to modify the tool (as long as you can get to the hot wire separately). The other type of sensor I’ve seen used needs the hot wire cut, and soldered onto a sensor, which feeds into the part. If something goes wrong, you’ve got a huge voltage and amperage going through a tiny little sensor board, and if it fails, your tool could quit working also. I didn’t like that idea at all, so used these sensors which are so intrusive. Just make sure and unplug your dust collector. I removed a plate where the power came in, and was able to easily clip the sensor around the hot wire (black), and even fit the sensor back inside the DC and screw the metal plate back on. I drilled a small hole for the low voltage wire to come out, so I can hook it up to the Arduino. This sensor has shielded wire. It wasn’t long enough to reach the Arduino, so I added on twisted pair cable. I used two pairs, and one wire of each pair is ground, and I soldered those to the wire shielding from the sensor. I hook the red wire from the sensor into the small circuit board with the resistors, and the white wire goes to the Analog input on the Arduino (where ever you have a free Analog pin, I used pin 7).

Circuit diagram for SCT013-030

The SCT013-030 does not need a burden resistor. The SCT013-100 does, as it is a current transformer, and its output is current. The SCT013-030 is a voltage output type, and from what I read, does not need a burden resistor. Note that the upper limit for this amperage sensor is 30 amps. You may need to change to a SCT013 100A if you need to read more amps. If you have a 240v circuit, you can just put the sensor around one of the hot wires. I think this would result in an amperage reading of half the actual amps, but for this, we’re just interested in seeing if the DC is off or on mostly. If you have a 240v  DC, let me know, maybe I can make a change in the software so it reads correctly.

I never saw anything that suggested there was a difference between the red and white wires on the SCT013-030, I just hooked them up as per the diagram above, and it worked for me.

Another way to be able to hook up the amperage sensor is to make a power box, using a power box receptacle, and a short extension cord, and wire an outlet into the power box. Have the extension cord go into the power box so that you can also snap the SCT013-030 around a how wire inside the power box. Then plug in the extension cord and plug the tool into the new outlet. That way, you haven’t had to even open up any panels on your power tool. Be careful to follow the rules on wiring up the outlet. In the US, there’s a hot wire and a common white wire, these need to be on the correct sides of the outlet. This is usually marked on the back of the outlet.  I’m not sure how other countries do it, so you will have to have knowledge on how to do this. It should be pretty simple.

My circuit board, most a place to connect more power and ground wires, and the I2C wires, with a small amount of components for pullup resistors, and the components for the amperage sensor

In the picture above, each column is labeled at the top A-X. Starting with A on the left, I am using A-D as ground, power, and the I2C lines. Column A is all ground pins, B is 5 volt, C is SDA (orange), and D is SCL (yellow). If you notice, the third wire down in column D is orange – this is confusing, but just because I ran out of the jumper wires for another 4 wire set in those same colors. Oops. Basically I have the top set of wires being incoming wires from the Arduino. Then I plugged the ADS1115 and the BME280 into other rows to get them the 4 wires they needed to work.

Rows F and H are more ground and power connectors. F is ground, H is power. Again, not all the wires match the schematic colors – I only had so many red and black wires.

The red wire coming in at column M is the red wire from the amperage sensor. You can see the resistors to each side of that to give make the off amperage come in at around 2.5 volts (splitting the 0 to 5 volt range).

The capacitors all the way to the left are .01 uF and 1 uF going from 5 volts to ground. I added these in based on what the pressure sensors data sheet said to do. But I should only need one of each, no matter how many pressure sensors. You could probably do without them, it’s up to you, I just followed the recommend circuit for those pressure sensors. I got the capacitors from eBay.

I left room (hopefully enough room), for more amperage sensor components in the future, for my idea of adding automatic dust gates based on which tool you are using.

Project Box

When making an enclosure for this project, if you have the optional temperature sensor, you’ll probably want this in a separate area from the Arduino and power supply, so the heat from these won’t be affecting the temperature sensor. The best would be in a separate area, that has good airflow to the shop, so the temperature stays close to correct as possible. I’ll put mine to the left or right side. The Arduino and power supply will also have vent holes to prevent overheating, but hopefully keep most of the sawdust out.

Since I don’t have a laptop to do software updates, I need to be able to bring the entire Arduino back inside the house to reprogram it at my computer. Everything has a connector, so I can remove the hardware. The power supply wires coming in are connected.

I am using one 4S Li-Po battery connector for the two pressure sensors, I use the red/black wires for power and ground, then one more wire each for the two sensors, leaving one wire unused at this time. I’m using a Cat 3 cable I had to run the wires to the sensors, which I attached to the 4″ PVC pipe near the dust collector.

The amperage sensor is connected with twisted pair wire that I added onto the shielded wire to make it long enough to reach the Arduino. I soldered regular jumper wires onto those. The wire I soldered onto the shield on the amperage sensor I went ahead and connected to ground, then the red and white wires to the resistors as per the schematic. I can pull these three wires since they have the jumper ends. I used female jumper ends for the ground and the red wire. The white wire (or the wire used on the twisted pair that connects to the white wire) I put a male jumper end on it and plugged it directly into the Arduino on A7.

Anyway, the idea is I can unplug those connectors, and bring the Arduino, my little circuit board I made, and the ADS1115, and BME280 all into the house in one piece. If you have a laptop to make software updates right in the shop, you may not need the connectors, and may just solder the wires.

Some of these connectors came in a pack with multiple parts. I just order that, as I’ll be using more of them in future projects, if you can see if you can find a smaller pack, for whatever you need.

Installing sensors

I installed the amperage sensor under the electric panel on my dust collector. The amperage collector easily clipped around the hot wire (only), and fit inside the electric box area on the DC. I drilled a small hole in that area to run the wire out for the sensor. I ended up cutting the plug off in my case, although you could keep this on and buy a part the plug would fit into and wire it that way.

For the vacuum and cartridge pressure sensors, I bought two brass hose barbs at the local hardware store. These barbs had about the same size barb as on the sensor, which made it easy to hook up tubing: Everbuilt LFA-85, 1/8″ ID, 1/4″ MIP. I drilled a hole in the top of the cartridge filter, and screwed that in, I’ll put some silicone sealant around the threads just to make sure it isn’t leaking.

How the cartridge pressure sensor is attached to the filter cartridge

For the vacuum sensor, I just drilled a hole in the PVC pipe near the DC, and screwed in the hose barb, just enough to be tight, but not enough to protrude inside the pipe. I’ll seal this with some silicone also.

The vacuum sensor attachment point

I worry about dust getting inside the sensors. I’ll use a longer piece of hose to connect these, to help keep the sensor away from the dust. I might get a little cotton from a q tip end or a cotton ball, and put inside the tubing, as a bit of a filter to keep dust out of the sensor.

I had some silicone tubing laying around from another project. It’s actually the type tubing used for aquariums, and is called Top Fin silicone airline tubing. This fit the brass barb and the barb on the pressure sensor perfectly. I don’t see that brand on Amazon any more, but there’s this airline tubing which looks like the same stuff. The added bonus – it’s non toxic to your fish!

Power Supplies:

If you use a 5 volt regulated power supply, input this on the Arduino 5v pin (and the ground pin for the second wire). The barrel receptacle is for unregulated higher voltages (7-9 volts).  The VIN pin is also for unregulated power (not for 5 v regulated power). I bought some nice small wire, in several colors to hook things like this up.

If you plan on moving on with this project with me for the planned upgrade to control the dust gates automatically, you will need a larger power supply to run all the servos.  I am using a 10 amp 5v regulated supply. You may use a 1 or 2 amp power supply if you don’t plan on moving on to the servo project (using this same Arduino). If you are going to move on, please allow room for another small circuit board, and a lot of wires in the box you mount this project in. I’ll be adding an amperage sensor on each tool, and having a servo on each gate. Servos use three wires, as do the amperage sensors.

I was having some issues using a 9 volt power supply using the barrel connector. The Arduino would freeze up, I quit using this power supply. I am not sure what was happening. Since I quit using the 9v power supply, the Arduino quit freezing. A second Arduino with a 7″ TFT display (for another fun project) was also getting the display messed up with that same power supply in the barrel connector (completely different hardware and software).


I hope you enjoy the project, please comment if you have ideas, or find a bug, or any shortcomings in the article – I will get these fixed up. Like I said I will try to reply to questions also, but for more generic questions about the Arduino, please try Google also.

This project is at your own risk. You are building the hardware, you are installing it. Be careful, and be safe. I even changed out the amperage sensor one person suggested using, and going with the ferrite core that goes around one hot wire – so no direct connection to high voltage, high amperage power, and you should be able to do this without modifying any of your power tool wiring directly.

I spent a lot of time on this project. Using the affiliate Amazon links below will help fund more projects like this in the future (the Amazon purchase price remains the same to you).

In the parts list below, please note that some of the parts are one or the other, for example the power supply, I’m listing a smaller one and a larger one. You only need one of these. Same with the Arduino, there’s a clone, the original, and the starter kit which also contains an Arduino, you only need one.


Download my source file to get the code for this project.

Parts Used:

Arduino Mega: https://amzn.to/2HpwopC
Genuine Arduino Mega: https://amzn.to/2JAdGQY
Arduino Mega starter kit with all kinds of samples to try: https://amzn.to/2xMpzin
TFT Touch Display: https://amzn.to/2kWKSnP
Amperage sensor: https://amzn.to/2Lv07jp
5 volt 10 amp power supply (if you add further higher power options): https://amzn.to/2xOBBYf
5 volt power supply (if you don’t want to do the next project): https://amzn.to/2JAP8rh
Jumper wires: https://amzn.to/2xOsNSn
Solder Station: https://amzn.to/2xUSEIb
Solder 60/40: https://amzn.to/2kUICO2
Solder (lead free): https://amzn.to/2HBbtjy
MPX5010DP sensor: eBay from user jiudi33-3
MPX5050 sensor: eBay from user specspecialty
Airline tubing: https://amzn.to/2JE62SF

Power supply connectors https://amzn.to/2Kdtz16

Optional Pieces:
BMP280 Temperature, Barometric pressure: https://amzn.to/2JnsVtt
or BME280 Temperature, humidity, barometric pressure: https://amzn.to/2JeJ5ZX
RTC Clock: No reliable sources known
Ethernet Board: https://amzn.to/2M49CqN
Header pins (needed with Ethernet shield) https://amzn.to/2LYPiHn
Bread Board (comes with the starter kit above if you get that): https://amzn.to/2HubKEU
Kill A Watt Meter: https://amzn.to/2sJfygN
Wire strippers: https://amzn.to/2Jtj3y5
Solder Flux: https://amzn.to/2Jqsy5p
Shrink tubing: https://amzn.to/2LA1hKw