Engineering 100-950

Lab 3: Creating a Standalone Arduino and Adding Sensors

Contents

• Lab 3: Creating a Standalone Arduino and Adding Sensors
  • Contents
  • Introduction
    • Arduino Power Requirements
    • Data Logging
  • Procedure
    • Materials
    • 1. Powering the Arduino
    • 2. Measuring Battery Voltage
    • 3. Adding the BME680 Temperature, Pressure, Humidity, VOC Sensor
    • 4. Adding the TMP36
    • 5. Adding the Accelerometer
    • 6. Calibrating the Accelerometer
    • 7. Adding the MicroSD Card Adapter Module
    • 8. Collecting Data
    • 9. Analyzing the Data in MATLAB
  • Submission

Introduction

So far, every time we have used our Arduino to log data, we have read the data through Arduino’s Serial monitor, and have powered the Arduino via our computer’s USB port. While this has worked so far, our end goal is to send these Arduinos on weather ballons! We cannot use a computer for power and data logging for that!

This lab can be broken down into two main sections, one in which we learn to power the board via a battery and estimate the battery’s capacity or charge, and one where we record Arduino sensor data onto a microSD card. At the end of this lab, you should have all the knowledge you need to make a fully portable temperature, pressure, humidity, and acceleration logger.

Arduino Power Requirements

The Arduino Nanos that we use in this class operate at 5V logic. This means the pins coming off of it, like the digital pins, are all at 5Vs. The Arduino, however, has circuitry inside it that lets it take a range of voltages as input. This is called the Vin pin, and takes a voltage between 7-12V. The Arduino then internally converts that down to a safer 5V level for its own operations. For this lab, we will be powering our Arduino Nano with a 9V battery.

Data Logging

Our Arduino has some memory on it, but reading and writing to this memory is a rather complicated procedure, which is why we need the Arduino IDE to handle writing the code to the Arduino’s memory for us. Writing variables to the Arduino’s memory is not user-friendly and is difficult to read back. Therefore, we elect to instead use a microSD card, which has a far higher data capacity and allows us to easily read data on our computer. This lab will use a pre-built data logging module to write data to the microSD card in a similar way you write data out to the Arduino’s Serial Monitor.

Procedure

• Link to Group A Lab Manual
• Link to Group B Lab Manual

Materials

• 1 Arduino Nano
• 1 Breadboard
• 1 Programming Cable (and adapters if necessary)
• 1 TMP36 Temperature Sensor
• 1 BME680 Temperature, Pressure, Humidity, VOC Sensor
• 1 Accelerometer
• 1 MicroSD Card
• 1 Data Logger
• 1 MicroSD Card - USB Adapter
• 2 1k\(\Omega\) resistors
• A handful of jumper wires
• 1 9V battery
• 1 9V battery connector
• A computer with the Arduino IDE installed and setup.
• ENGR100-950 Arduino Library

1. Powering the Arduino

To start, we want to power our Arduino with the 9V battery. Plug your Arduino into your breadboard, and plug the 9V into it’s connection clip. It should only fit one way, since the terminals are different shapes.

Notice that one wire coming out of the battery is red, and one is black. Common practice says that red will be positive, in this case +9V, and the black will be what we connect to our Arduino’s GND.

Take these wires and plug them into your Arduino via your breadboard. Red should go to the Arduino’s Vin, and black should go to any GND pin.

Once you’ve plugged the 9V in, the Arduino should light up - even though it isn’t plugged into your computer! If it does, congrats, your external power is working! If not, check your connections again.

As one last check that everything is working before we move on, upload the File → Examples → Basics → Blink code that the Arduino IDE comes with, to your Arduino. After it finishes uploading, unplug your computer and verify that the onboard LED on the Arduino continues to blink on only the 9V’s power.

2. Measuring Battery Voltage

Most modern electronics, from your smartphone to even rockets, have some way of reporting back the charge of any internal batteries. While we don’t use the battery for very long at any one time in this lab, other people are using the same batteries, and so we do want to verify they are charged.

To measure battery voltage, we can use the analog pins on the Arduino, similar to how we did in lab 1. The caveat of this, however, is that the analog pins can only take up to 5V!! So, before reading the battery in, we need to build a voltage divider to step the battery voltage down to 5V max.

Using our voltage divider (see the resources page for more), we can take 2 1k\(\Omega\) resistors and step ~9V down to ~4.5V. Go ahead and build this voltage divider.

When you are done, your 9V battery should have the black wire going to GND, and the red wire going to both Vin on the Arduino and a voltage divider.

Now, let’s test that the voltages look realistic. Go to File → Examples → Basics → AnalogReadSerial and change the analogRead() function called in loop() to be the pin you plugged your voltage divider into. Run this code and make note of the values it returns.

You know on the Arduino Nano this value will be between 0-1023, and that your max voltage, as reported by the Arduino, is 5V. Convert your raw value to the voltage by dividing it by 1023 and multiplying it by 5V. This is the voltage your Arduino recorded.

Your battery, however, has a higher voltage than that. We now need to undo the effects of the voltage divider to determine the battery’s original voltage. Since we used the same resistance on either side of the voltage divider, the voltage is being cut in half. Therefore, we can simply multiply the Arduino’s recorded voltage by 2 to get the 9V battery’s voltage. It should be somewhere between 8 and 10V.

3. Adding the BME680 Temperature, Pressure, Humidity, VOC Sensor

• Link to BME680 Adafruit Breakout Spec Sheet
• Link to BME680 Sensor Spec Sheet

In Lab 2, you wired up the BME680. If you do not remember how to wire it up, open up the breakout spec sheet and look at the section tittled SPI Wiring.

To make sure that the BME680 is working you can again use the BME680_Example_Code by navigating to File → Examples → ENGR100-950 → BME680_Example_Code. Check all of the outputs and ensure they are plausible before proceeding. If they seem extraordinarily different from expected values, ask an instructor for help.

4. Adding the TMP36

• Link to TMP36 Spec Sheet

Just like we did in the last lab, we now need to plug in the TMP36 to an analog pin on the Arduino, and read it using analogRead() and Serial.println(). Add this to the code used for measuring the battery voltage with comma-separated values. (Hint: You can use Serial.print() to print values without a newline character between them, which may help you print CSV integers to the serial monitor for testing. Then you can just use Serial.print(","); to add a comma between the values. The last line you print, which will be the last sensor column of your CSV matrix, should use Serial.println() in order to make a new line for the next data sample). Convert these raw values to voltages using the equations used in previous labs, then print the voltages in the aforementioned format.

// The "|" represents where you are after printing to the serial monitor
Serial.print("firstVal");
//firstVal|

Serial.print(",");
//firstVal,|

Serial.println("secondVal");
//firstVal,secondVal
//|

Serial.print("I am in a new line because of println");  
//firstVal,secondVal
//I am in a new line because of println|

Here is the wiring diagram again for your reference:

Once you have your TMP36 connected, it’s time to make a calibration curve. You can do this in the same manner as in the last lab using the cold chamber or going outside. Enter these calibration curves into your Arduino code by modifying the temperature variables with a slope-intercept equation, and verify that the serial monitor is producing realistic temperature values. Save these calibration curves (slope and intercept values) somewhere for later use! It may be less annoying to calibrate all of the sensors at the end once you have all the sensors connected but before you have the data logger plugged in. This is up to you! In whatever case, make sure to clearly record your slope and intercept values from the curves.

5. Adding the Accelerometer

• Link to ADXL335 Spec Sheet

Begin by skimming over the provided spec sheet and become familiar with the pin layout. Connect the sensor to the Arduino, based on the pin-out provided and using the 3.3V pin as the power supply. Each of the axes (x, y, and z) will be connected to its own analog pin. You will not have anything connected to the ST pin.

Add code to the program you’ve been working with to read the voltage values from each of the three axes.

6. Calibrating The Accelerometer

To calibrate your accelerometer, you will have to go through the same procedure that you did in lab 2, for all 3 axes of the accelerometer. This means that for each axis, you will need at least 2 known values of acceleration that you can subject the sensor to while reading the voltage.

In order to find 2 known values of acceleration, we must understand what exactly is it that the accelerometer measures. The name “accelerometer” is kind of misleading in this case, since it doesn’t actually measure total acceleration. Internally, the sensor has a tiny object (usually silicon) that is connected to the rest of the sensor via a spring-like connection. This connection has electrical properties that change based on the tension that the connection experiences. This is a simplified explanation, but the actual sensors don’t differ too much.

If a force is applied to the outside of the sensor, the tension in the connection increases to keep the small internal object accelerating at the same rate as the sensor. This means that the sensor can only detect acceleration from forces that are applied only to the outside of the package, since if a force was applied equally to the internal object, the tension in the connection would not have to increase to keep the object accelerating with the rest of the sensor. Usually this isn’t a problem, since most forces we’re concerned with are fall into this category, however, there is one major force that doesn’t: gravity. Recall from physics that gravity acts in a way that makes all objects accelerate at the same rate (\(9.8\,\frac{m}{s^2}\)). This is the exact type of force that accelerometers cannot measure, since the internal connection does not have to apply any force to the internal object to keep it accelerating with the sensor - in the absence of external forces, everything accelerates at \(9.8\,\frac{m}{s^2}\).

Now let’s try to figure out what the accelerometer would measure in 2 different situations: in free-fall, and sitting stationary on a lab table. Start by drawing a free-body diagram for each situation, and then remove the gravitational force. The acceleration from the remaining forces is what the sensor would measure. In the situation of free-fall, since gravity is the only force (in the absence of air resistance), the accelerometer measures nothing. In the situation of the sensor sitting stationary, the normal force opposes gravity and is exactly equal to the force from gravity. The accelerometer will only measure the acceleration from the normal force, and since the normal force is equal to gravity in this case, it will measure \(9.8\,\frac{m}{s^2}\), or 1 G, upwards. You will use this fact to calibrate the accelerometer.

In this orientation, the Z-axis is straight up, and from our previous findings it should measure 1G. X and Y are both perpendicular to the force of gravity and would be recording 0Gs. If you turn your board upside down, the Z axis should read -1G. Rotate your sensor around as needed so that each axis has at least two data-points where it is (anti-)parallel to the force of gravity and make sure to take note of the voltage value for both points.

With this calibration process completed, each axis will have a calibration value of 1G and -1G. Record the voltage values in your spreadsheet, and calculate the calibration curve for each axis.

Now update the code to print the new calibrated values in the same comma seperated values (CSV) format as before. Save these calibration curves (slope and intercept values)!

7. Adding the MicroSD Card Adapter Module

The SD logger connects to the Arduino using the same pins as the BME680. This is ok to do since they both use a protocol called SPI. This is a very common protocol used to connect different digital chips together. SPI uses 3 pins to transfer data, and 1 pin to select which chip to communicate with, called chip select (CS for short). This CS pin tells the device (the SD logger or BME680) to either pay attention to the 3 data pins, or ignore them. Both the SD logger and the BME680 will connect the 3 data pins to the same 3 pins on the Arduino, however the CS pin for the BME680 will not connect to the same pin as the CS pin on the SD logger, it will instead connect to a different digital pin on the Arduino. The goal is for the Arduino to be able to “select” which chip it wants to communicate using the CS pins.

Wire the SD logger by following the below table.

While your Arduino is powered off and disconnected from the 9V, plug your module in as shown above. The Arduino pins (D11-D13) for this DO matter and cannot easily be changed, unlike the analog pins and the CS pin.

Teams working in two separate groups can skip this paragraph. Once everything is wired up and power is disconnected from the Arduino, put your microSD card into the adapter module, plug in your Arduino, and connect the 9V battery. Upload the code found in File → Examples → ENGR100-950 → Lab3-SDtester. This script will throw an error statement in the serial monitor if the SD logger is not working properly. Once this script runs and appears to have worked for a few moments, go ahead and disconnect power, remove the SD card, and open the contents on your computer. You should see a file titled DATALOG.CSV which should be a CSV file with sample headers (names of the sensors we are using) and rows of data that are numbered 0-7 for each column. If this appears correct, then congratulations, you have successfully connected your SD logger.

At this point you should modify and upload the code found in File → Examples → ENGR100-950 → Lab3_SensorIntegration. Read through the code carefully and modify all of the ”?” to have accurate values relavent to your setup. This includes slope and intercept values from calibration curves you made previously, and pin numbering for your specific wiring. Run this code and ensure it’s working as expected. There is a boolean variable that allows you to toggle the serial monitor printing on/off. If you are logging only to the SD card, turn this off by setting it to false to increase the sampling rate substantially. If you want to debug the system, set this to true.

There is a delay statement at the end of the loop. Think about how many data points will be taken if you take data for 5 minutes. Will you need data this often? More often? Less often? Adjust the delay accordingly. The current default is set to read once every second (accounting for sampling delays that may occur), but you can set this to a simpler value, such as delay(500); to delay 500 ms before proceeding to the next iteration.

Note: The code used above, Lab3_SensorIntegration, is “heavier” than others we’ve used so far. To fully break it down, we’ve created a separate manual for this code linked below if you’re curious or are experiencing difficulties and need to debug it.

• Link to Lab3_SensorIntegration Code Manual

8. Collecting Data

With everything plugged into the 9V and running, unplug the Arduino from your computer. Enjoy the portability of your new breadboard and walk around the building a little bit. Get the temperature to change dramatically by putting your sensor board into the cold chamber or walking outside. Wait for about 1-2 minutes to allow the temperature to adjust. Try rotating your circuit in different orientations so that each axis experiences some acceleration due to gravity, and walk outside to watch humidity change. This should provide plenty of data for all of your sensors!

Go back to the lab and unplug the 9V now (unplug the battery and leave the wires connected to your board). Carefully remove the microSD from the adapter module, and plug it into your computer. You should see a DATALOG.CSV file. If you do not, or the file seems corrupted or very small, delete the file, plug the microSD card back into the arduino, and watch what the Serial monitor on your computer says while running the code.

Once you have a sufficiently long test (2-3 minutes) and can see that there are clear changes in the data in the file created, you are done with the hardware portion of this lab!

Then, delete the datalog file and any other .csv files off of the microSD card so that other teams in future labs have to actually do the lab themselves, and don’t just steal your data!

9. Analyzing the Data in MATLAB

You should have a MATLAB script saved from an in-class exercise. Use this MATLAB script to process and analyze the data you collected earlier in the lab. You should create plots for battery voltage, two temperature sensors, a humidity sensor, a pressure sensor, and each axis from the accelerometer. These plots should be titled, axes labeled, and calibration curves applied so that they contain the proper units. Make sure to use legends if you have more than one line on a single graph (such as if you put the temperature sensors together). Consider using subplots to organize the data better!

Submission

On Canvas, you will submit ONE PDF that will include all of the following:

• A picture of your complete circuit with proper color conventions.
• A screenshot of your datalog.csv file (screenshot of the file opened) once all sensors are printing values.
• Exported images of the finished plots from MATLAB (with labels and calibrations!).
• Screenshot of a schematic created in KiCAD of your entire completed circuit.
  • Link to the required KiCAD libraries here: link

To put said content into a PDF, it is suggested you create a new Google Doc (docs.new) and paste your images and write any text in the document. Export/Download this document as a PDF and upload it. DO NOT SUBMIT A GOOGLE DOC FILE OR SPREADSHEET FILES.