Arduino Datalogger

11,062

105

24

In this tutorial, we're going to make a simple data logger using Arduino. The point is to learn the very basics of using Arduino to capture information and print to the terminal. We can use this basic setup to complete a range of tasks.

To get started:

You will need a Tinkercad (www.tinkercad.com) account. Head over and sign up with your email or social media account.

Logging in takes you to the Tinkercad Dashboard. Click "Circuits" to the left and select "Create new Circuit". Let's get started!

You can find the complete file on TInkercad Circuits - Thanks for checking it out!

Supplies:

Step 1: Add Some Components

You'll need some basic components. These include:

  • Arduino board
  • Breadboard

Add those by searching for them and click-dragging them to the middle area.

Place the breadboard over the Arduino. It makes it easier to view the connections later.

Step 2: A Note About Breadboards

A breadboard is a super helpful device for rapid prototyping. We use it to connect components. Some things to note.

  1. The dots are connected vertically, but the line in the middle separates this connection from the top and bottom columns.
  2. Columns are not connected left to right, as in across the row. This means that all components should be connected across the columns rather than down them vertically.
  3. If you need to use buttons or switches, connect them across the break in the middle. We'll visit this in a later tutorial.

Step 3: Add Two Sensors

The two sensors we are using are a Photosensitive sensor and Temperature sensor.

These sensors evaluate light and temperature. We use Arduino to read the value and display it in the Serial monitor on the Arduino.

Search for and add the two sensors. Make sure they are positioned across the columns on the breadboard. Put enough space between them to make it easier to see them.

Step 4: Photosensitive Sensor

  1. For the photosensitive sensor, add a wire from the 5V pin on the Arduino to the same column as the right leg on the part in the breadboard. Change the wire colour to red.
  2. Connect the left leg via the pin in the same column to the A0 (A-zero) pin on the Arduino. This is the analog pin, which we will use to read the value from the sensor. Colour this wire yellow or something other than red or black.
  3. Place a resistor (search and click-drag) on the board. This completes the circuit and protects the sensor and pin.
    • Turn it around so it goes across the columns.
    • Connect one leg to the right leg column on the breadboard
    • Place a wire from the other end of the resistor to the ground
      • Change the wire colour to black.
  4. Double check all connections. If something isn't in the right place, this won't function correctly.

Step 5: Start the Code

Let's look at the code for this component.

First, look at the third image in this step. It contains some code with two functions:

void setup()

void loop()

In C++, all functions provide their return type, then the name, then the two round braces that can be used to pass in arguments, usually as variables. In this case, the return type is void, or nothing. The name is setup and the function takes no arguments.

The setup function runs once when Arduino boots (when you plug it in or attach batteries).

The loop function runs in a constant loop from the millisecond the setup function completes.

Everything you put in the loop function will run when Arduino runs. Everything outside that will only run when called. Like if we defined and called another function outside the loop.

Task

Open the Code panel with the button in Tinkercad. Change the Blocks dropdown to Text. Agree to the warning box that pops up. Now, delete everything you see except the text in the third image in this step.

Variables

To get started, we need to assign some variables so we make our code really efficient.

Variables are like buckets that can only hold one object (C++ is what we call object-orientated). Yes, we have arrays, but these are special variables and we'll talk about them later. When we assign a variable, we need to tell it what type it is, then give it a value. It looks like this:

int someVar = A0;

So, we assigned a variable and gave it type int. An int is an integer or a whole number.

"But you didn't use a whole number!", I hear you say. That's true.

Arduino does something special for us so we can use A0 as an integer, because in another file it defines A0 as an integer, so we can use the A0 constant to refer to this integer without having to know what it is. If we just typed 0, we would refer to the digital pin at position 0, which wouldn't work.

So, for our code we will write a variable for the sensor we have attached. Whilst I recommend giving it a simple name, that's up to you.

Your code should look like this:

int lightSensor = A0;
void setup() {
}

void loop() {
}

Now, let's tell Arduino how to handle the sensor on that pin. We'll run a function inside setup to set the pin mode and tell Arduino where to look for it.

int lightSensor = A0;
void setup() {
	pinMode(lightSensor, INPUT);
}
void loop() {
}

the pinMode function tells Arduino that the pin (A0) will be used as an INPUT pin. Note the camelCaseUsed (see each first letter is a capital, as in it has humps, hence... camel...!) for the variables and function names. This is a convention and good to get used to.

Finally, let's use the analogRead function to get some data.

int lightSensor = A0;
void setup() {
	pinMode(lightSensor, INPUT);
}
void loop() {
	int reading = analogRead(lightSensor);
}

You'll see we stored the reading in a variable. This is important as we need to print it. Let's use the Serial library (a library is code we can add to our code to make things faster for us to write, just by calling it by its definition) to print this to the serial monitor.

int lightSensor = A0;
void setup() {
	// Set pin modes
	pinMode(lightSensor, INPUT);
	// Add the serial library
	Serial.begin(9600);
}
void loop() {
	// Read the sensor
	int reading = analogRead(lightSensor);
	// Print the value to the monitor
	Serial.print("Light: ");
	Serial.println(reading);
	// delay the next loop by 3 seconds
	delay(3000);
}

A few new things! First, you'll see these:

// This is a comment

We use comments to tell other people what our code is doing. You should use these often. The compiler won't read these and convert them in to code.

Now, we also added the Serial library with the line

Serial.begin(9600)

This is an example of a function that takes an argument. You called the library Serial then ran a function (we know it's a function because of the round braces) and passed in an integer as an argument, setting the Serial function to operate at 9600baud. Don't worry why - just know it works, for now.

The next thing we did was print to the serial monitor. We used two functions:

// This one prints to the serial with no line break (an enter at the end)
Serial.print("Light: ");
// This one puts in the line break so each time we read and write, it goes on a new line
Serial.println(reading);

What's important to see is that each has a separate purpose. Make sure your strings use double-quote marks and that you leave the space after the colon. That helps readability for the user.

Finally, we used the delay function, to slow our loop down and make it only read once every three seconds. This is written in thousands of a second. Change it to read only once every 5 seconds.

Great! On we go!

Step 6: Simulation

Always check things work by running the simulation. For this circuit, you'll also need to open the simulator to check it works and check your values.

Start the simulation and check the serial monitor. Change the value of the light sensor by clicking it and changing the value using the slider. You should see the value change in the serial monitor, too. If it doesn't, or if when you press the Start Simulation button you get errors, carefully go back and check all your code.

  • Focus on the lines indicated in the red debugging window that will be presented to you.
  • If your code is right and the simulation is still not working, check your wiring.
  • Reload the page - you might have an unrelated system/server error.
  • Shake your fist at the computer, and check again. All programmers do this. All. The. Time.

Step 7: Wire Up the Temp Sensor

I am going to assume you're on the right track now. Go ahead and wire up the temperature sensor like the picture suggests. Note the placement of the 5V and GND wires in the same space as the ones for the light. This is ok. It is like a parallel circuit and won't cause issues in the simulator. In an actual circuit, you should use a breakout board or shield to provide better power management and connections.

Now, let's update the code.

The temp sensor code

This is a little more tricky, but only because we have to do some math to convert the reading. It's not too bad.

int lightSensor = A0;
int tempSensor = A1;

void setup() {
	// Set pin modes
	pinMode(lightSensor, INPUT);
	// Add the serial library
	Serial.begin(9600);
}
void loop() {
	// The temp sensor
	// Creating two variables on one line - oh efficiency!
	// Float var to store a decimal
	float voltage, degreesC;

	// Read the value of the pin and convert it to a reading from 0 - 5
	// Essentially voltage  = (5/1023 = 0.004882814);
	voltage = (analogRead(tempSensor) * 0.004882814);

	// Convert to Degrees C
degreesC = (voltage - 0.5) * 100; // Print to the serial monitor Serial.print("Temp: "); Serial.print(degreesC); Serial.println("oC"); // Read the sensor int reading = analogRead(lightSensor); // Print the value to the monitor Serial.print("Light: "); Serial.println(reading); // delay the next loop by 3 seconds delay(3000); }

I have made some updates to the code. Let's walk through them individually.

First, I added the line

int tempSensor = A1;

Just like the lightSensor, I need to store the value in a variable to make it easier later. If I had to change the location of this sensor (like rewiring the board) then I only have to change the one line of code, not search throughout the entire codebase to change the A0 or A1, etc.

Then, we added a line to store the reading and the temp in a float. Note two variables on one line.

float voltage, degreesC;

This is really helpful because it cuts down on the number of lines I have to write and speeds up the code. It can be harder to find errors, though.

Now, we'll do the reading and store it, then convert it to our output value.

voltage = (analogRead(tempSensor) * 0.004882814);
degreesC = (voltage - 0.5) * 100;

Those two lines look difficult, but in the first we are taking the reading and multiplying it by 0.004... because it converts 1023 (the analog reading returns this value) into a reading out of 5.

The second line there multiplies that reading by 100 to move the decimal point. That gives us the temperature. Neat!

Step 8: Testing and Checking

All things going to plan, you should have a working circuit. Test by running the simulation and using the serial monitor. If you have errors, check, check again and shake your fist.

Did you make it? Share and tell us your story!

This is the final circuit embedded for you so you can play/test the final creation. Thanks for completing the tutorial!

2 People Made This Project!

Recommendations

  • Party Challenge

    Party Challenge
  • Fandom Contest

    Fandom Contest
  • IoT Challenge

    IoT Challenge

24 Discussions

0
None
Animiles

2 months ago

But I'm still curious.. Now that you can print it to the serial, how do you turn it into a datalogger? I knew all of this already. I only came here because I actually need to log the data and read it back in some way (without leaving the serial communication open of course).

1 reply
0
None
mrmascorellaAnimiles

Reply 2 months ago

Hi! Thanks for your message. I am keen to look at this, but deciding the best way to display/log/save is a consideration. I think an online service using IoT is a good solution, but feel people might want something simpler. What's your preference?

0
None
ahp2267

2 months ago

Thank you for this tutorial. Please forgive my ignorance, but I'm a little bit confused as to why I need a TinkerCad account. Could you please expound on that a littlle more?
Thank you.

1 reply
0
None
mrmascorellaahp2267

Reply 2 months ago

Absolutely! I use the Tinkercad environment to create this circuit in a simulation. If you don’t have the hardware and would like to create the circuit you’ll need an account to access the environment to make the circuit too. Otherwise, if you have the hardware, the steps will work but you might find some little bits are different.
Hope that helps!

0
None
Chefmike66

2 months ago

I was looking for some help to figure out how to log data to a SD card. Although you Instructable didn't cover that, I'd like to commend you for your great clarity and accommodation to beginning users. Nice job!

1 reply
0
None
mrmascorellaChefmike66

Reply 2 months ago

Great, thank you for the feedback!
I am going to extend this tutorial in the coming week to cover logging data to an SD card and taking measurements over a greater period of time with crash recovery. This is a limited solution that relies on blocking calls and only collects data over short periods of time. I'll be sure to post it up as soon as I can!

0
None
mrmascorellaPospaPunk

Reply 2 months ago

Hey! In the absolute strictest sense, no, but it can be easily extended to save the data and track information over time. We use this in our school as a way to capture a small amount of data over a short period of time, so it is fit-for-purpose, I suppose.

By modifying the code to a more non-blocking version and storing the data on an SD card, it might be more fit-for-purpose for longer run data collections. I'd be happy to extend this after I finish a few other tutorials. In the mean time, if you complete this and take a look at the Arduino.cc tutorials on saving data to an SD, you might be able to get something working that suits your needs.

Thank you for the feedback! It would be great to know what sort of features you might need, too.

0
None
hcspinksmrmascorella

Reply 2 months ago

I'm looking forward to your extension which makes this a long term datalogger

0
None
mrmascorellahcspinks

Reply 2 months ago

Great! I'll try and get to that in the next little while.

0
None
gcollatz

Question 2 months ago

What is the nomenclature and source for the breadboard that you used. It is really cool! Could not find it on Amazon.

1 answer
0
None
mrmascorellagcollatz

Reply 2 months ago

Hi! It's just called a breadboard mini. I used it because we have similar ones for teaching and it helps students correlate simulated and real experiences. Anything like this will work: https://www.sparkfun.com/products/12043

For more complex projects, I recommend a Breadboard Small, because it has two sets of power rails that really helps provide power to the components without compromises.
All the best!

0
None
bekathwia

3 months ago

Awesome tutorial! Would you mind making your Circuit public and sharing the URL, so that we may feature it on Tinkercad? You can add a link to your Instructable in the public description. You can also embed your Circuit design in one of your steps by pasting the iframe embed code.

3 replies
0
None
bekathwiaMatlek

Reply 2 months ago

Thanks for your note, our team is aware of the issue and we're looking into it.

0
None
matthewscott7

3 months ago

I can't download the .PDF (I have the free teachers membership)...