Qwiic OpenLog Hookup Guide

Introduction

The SparkFun Qwiic OpenLog is the smarter and better looking cousin to the extremely popular OpenLog. We’ve ported the original serial based interface to I²C. Now you can daisy chain multiple I²C devices and log them all without taking up your serial port. Pop in a microSD card, write some simple code, and your data will be recorded to a text file on the microSD card.

added to your cart!

SparkFun Qwiic OpenLog

In stock DEV-15164

The SparkFun Qwiic OpenLog can store, or "log", huge amounts of serial data and act as a black box of sorts all over I2C.

$18.50

Favorited Favorite 36

Wish List

SparkFun Qwiic OpenLog Kit

Retired KIT-18350

The Qwiic OpenLog kit includes everything you'll need to get up and running with the Qwiic OpenLog and the Qwiic Ecosystem.

Retired

Favorited Favorite 4

Wish List

Materials Required

In order to fully work through this tutorial, you will need the following parts. You may not need everything though, depending on what you have. Add it to your cart, read through the guide, and adjust the cart as necessary.

Recommended Reading

If you are not familiar or comfortable with the following concepts, we recommend reading through these before continuing on with the Qwiic OpenLog Hookup Guide.

Hardware Overview

Power

The Qwiic OpenLog runs at the following settings:

The Qwiic OpenLog's current draw is about 20mA to 23mA when writing to a microSD. Depending on the size of the microSD card and its manufacturer, the active current draw can vary when the OpenLog is writing to the memory card.

Register Map

The Qwiic Open Log implements a register map type set up if you'd like to create your own library.

Microcontroller

Like its predecessor, the Qwiic OpenLog runs off of an onboard ATmega328, running at 16MHz thanks to the onboard crystal. The ATmega328 has the Optiboot bootloader loaded on it, which allows the OpenLog to be compatible with the "SparkFun Redboard" board setting in the Arduino IDE.

Interface

Qwiic Connectors

The primary interface with the Qwiic OpenLog are the Qwiic connectors on either side of the board. If you aren't familiar with the Qwiic system, you are in for a treat! The Qwiic system utilizes I²C protocol to allow multiple “slave” digital integrated circuits (“chips”) to communicate with one or more “master” chips with a mere two wires. Check out all the benefits of the Qwiic System here.

FTDI Header Pins

While the Qwiic OpenLog retains the broken out FTDI header pins, they pins are used specifically for reprogramming the firmware. All logging communication happens through the Qwiic lines and associated broken out pins.

SPI

There are also six SPI test points broken out on the opposite side of the board. You can also use these to reprogram the bootloader on the ATmega328.

microSD Card

The final interface for communicating with the Qwiic OpenLog is the microSD card itself. To communicate, the microSD card requires SPI pins. Not only is this where the data is stored by the OpenLog, but you can also update the OpenLog's configuration via the config.txt file on the microSD card.

All data logged by the OpenLog is stored on the microSD card. The OpenLog works with microSD cards that involve the following features:

• 64MB to 32GB
• FAT16 or FAT32

Status LED

There are two LEDs on the OpenLog to help you with troubleshooting.

• STAT - This green LED is connected to Arduino D13 (Serial Clock Line/ ATmega328 PB5). This LED only blinks when the SPI interface is active. You will see it flash when the OpenLog records data to the microSD card.
• PWR - This red indicator LED is attached to Arduino D5 (ATmega328 PD5) and lights when the board is active and functioning.

Hardware Hookup

If you've purchased the SparkFun RedBoard Qwiic, hardware hookup is as simple as plugging in your Qwiic cable!

If, however, you are using an older SparkFun RedBoard, you'll need an assembled Qwiic Shield, so if you haven't done that yet, now would be the time to head on over to that tutorial.

Arduino Sketches

There are eleven examples in the Qwiic OpenLog Arduino Library that can be used when connected to a Qwiic OpenLog. These Arduino functions replace the serial command communication that occurred on the previous version of the OpenLog. These example files are named such that their functions should be self-explanatory, but in case you want more information, see the descriptions below. The easiest way to install the library is by searching SparkFun Qwiic OpenLog is within the Arduino library manager. To manually install, head on over to the GitHub Page or feel free to download the library here!

• Example1_WritingLog -- This example shows how to record various text and variables to Qwiic OpenLog.

• Example2_AppendFile -- Arduino sketch showing how to append text to the end of File. If File does not exist when this function is called, the file will be created.

• Example3_CreateFile -- This example shows how to create a new file named File in the current directory. Standard 8.3 filenames are supported. For example, "87654321.123" is acceptable, while "987654321.123" is not.

• Example4_ReadFileSize -- This example shows how to record some strings to a default log, check the size of a given file name, and if the given file doesn't exist, say so.

• Example5_ReadFile -- This example shows how to record some strings to a default log, check the size of a given file name, if that given file doesn't exist, create it with random characters, and read back the contents of the given file (containing random characters)

• Example6_MakeDirectory -- This example shows how to create a directory, move into that directory called MONDAY, create a sub directory within MONDAY called LOGS, and create and write to a file inside MONDAY.

• Example7_ReadDirectoryContents -- This example shows how to read the files in a given directory. You can use wildcards if desired. This is handy for listing a certain type of file such as .LOG or LOG01.TXT.

• Example8_RemoveDirectory -- This example shows how to create a directory, create some files there, delete a specific file, delete *.TXT, and remove the directory we created.

• Example9_ReadVersion -- This example shows how to read the firmware version of Qwiic OpenLog.

• Example10_CheckStatus -- This example shows how to read the status byte of the OpenLog.

• Example11_ChangeAddress -- This example shows how to change the I²C address of the Qwiic OpenLog from the default address 0x2A to 0x1E (or 42 and 30 in decimal, respectively. It's easy to change the I²C address. If you forget what the address is you can use the I2CScanner Example to re-discover it. You can also close the ADR jumper on the board. This will force the I²C address to 0x29 regardless of any other setting or command.

  • Valid I²C addresses are 0x08 to 0x77 (inclusive)
    
    
  Note: Example 11 is useful if there is another I²C device that uses the same address. For example, the Qwiic OpenScale uses the same address (0x2A). You would need to configure the I²C address of either the Qwiic OpenLog or OpenScale.
  
  For the scope of this tutorial, let's say you modified the address of the OpenLog using Example11_ChangeAddress.ino to 0x1E. To continue using the examples in the Qwiic OpenLog library, you will need to make sure to include the address as a parameter when making a connection to the OpenLog. The Qwiic OpenLog examples will default value of 0x2A if you do not provide an address. To include the new address you will need to change this function in the setup() function from:
  
  

  myLog.begin(); //Open connection to OpenLog (no pun intended)

  To:
  
  

  myLog.begin(0x1E); //Open connection to OpenLog (no pun intended)

Firmware

The Qwiic OpenLog has two primary pieces of software on board: the bootloader and the firmware.

Arduino Bootloader

You can treat the Qwiic OpenLog just like a SparkFun RedBoard when uploading example code or new firmware to the board. When uploading code, you will simply select the board in the Arduino IDE's menu under Tools > Board > Arduino/Genuino Uno.

Compiling and Loading Default Firmware onto the Qwiic OpenLog

If for any reason you need to update or reinstall the default firmware on your Qwiic OpenLog, the following process will get your board up and running. First, download the Qwiic OpenLog default firmware. You can go to the Qwiic OpenLog GitHub Page or download via the button here:

Once you have the firmware downloaded, you will need to also install the following libraries into Arduino. If you are unsure how to manually install the libraries in the IDE, please refer to the link above.

If you haven't yet, connect your Qwiic OpenLog to the computer via a 3.3V FTDI board using the silkscreen labels as reference. Please double check the example circuit if you are not sure how to do this properly. For a secure connection, you will need solder headers to the FTDI pins. See our soldering tutorial if you need help here. Otherwise, you can simply apply pressure to the male headers at an angle. As long as you have contact between the FTDI and Qwiic OpenLog, code can still be uploaded.

If you have not already, unzip the default firmware folder and open it in the Arduino IDE. It will probably be in your Downloads folder under the following path:

language:bash
...Downloads\Qwiic_OpenLog-master\Qwiic_OpenLog-master\Firmware\Qwiic_OpenLog\Qwiic_OpenLog.ino

Once open, select the board Tools > Board > Arduino/Genuino Uno and select the proper COM port for your FTDI board under Tools > Port. Upload the code by hitting the upload button.

That's it! Your Qwiic OpenLog is now programmed with new firmware.

Configuration File

The configuration file is not as relevant with the updated Qwiic OpenLog as it was with its predecessor. When you open the config file, you will see the I²C address, escape character, the number of escape characters, and the mode. You can edit the I²C address and the mode, but ignore the escape character and number of escape characters. Here's what you will see when opening the config.txt file in a text editor. As you can see, the i2c_address is 42. This is the default address of the Qwiic OpenLog in decimal form. Converting the value, this matches our default address which is 0x2A.

language:bash
42,26,3,0
i2c_address,escape,esc#,mode

Troubleshooting

There are several different options to check if you are having issues with your Qwiic OpenLog.

Check STAT1 LED Behavior

STAT1 LED shows different behavior for two different common errors.

• 3 Blinks: The microSD card failed to initialize. You may need to format the card with FAT/FAT16 on a computer.
• 5 Blinks: OpenLog has changed to a new baud rate and needs to be power cycled.

Double Check Subdirectory Structure

If you are using the default OpenLog.ino example, OpenLog will only support two subdirectories. You will need to change FOLDER_TRACK_DEPTH from 2 to the number of subdirectories you need to support. Once you've done this, recompile the code, and upload the modified firmware.

Verify the Number of Files in the Root Directory

OpenLog will only support up to 65,534 log files in the root directory. We recommend reformatting your microSD card to improve logging speed.

Verify the Size of your Modified Firmware

If you are writing a custom sketch for the OpenLog, verify that your sketch is not larger than 32,256. If so, it will cut into the upper 500 bytes of Flash memory, which is used by the Optiboot serial bootloader.

Double Check File Names

All file names should be alpha-numeric. MyLOG1.txt is ok, but Hi !e _.txt may not work.

Format your MicroSD Card

Remember to use a card with few or no files on it. A microSD card with 3.1GB worth of ZIP files or MP3s has a slower response time than an empty card.

If you did not format your microSD card on a Windows OS, reformat the microSD card and create a DOS filesystem on the SD card.

Swap MicroSD Cards

There are many different types of card manufacturers, relabeled cards, card sizes, and card classes, and they may not all work properly. We typically use a 16GB class 10 microSD card, which works well at 9600bps. If you are using an older card or anything less than class 6, you may want to try upgrading your SD card.

Add Delays Between Character Writes

By adding a small delay between Serial.print() statements, you can give OpenLog a chance to record its current buffer.

For example:

language:c
Serial.begin(115200);      
for(int i = 1 ; i < 10 ; i++) {
    Serial.print(i, DEC);     
    Serial.println(":abcdefghijklmnopqrstuvwxyz-!#");
}

may not log properly, as there are a lot of characters being sent right next to each other. Inserting a small delay of 15ms between large character writes will help OpenLog record without dropping characters.

language:c
Serial.begin(115200);      
for(int i = 1 ; i < 10 ; i++) {
    Serial.print(i, DEC);     
    Serial.println(":abcdefghijklmnopqrstuvwxyz-!#");
    delay(15);
}

Check with the Community

If you are still having issues with your Qwiic OpenLog, please check out the current and closed issues on our GitHub repository here. There is a large community working with the OpenLog, so chances are that someone has found a fix for the problem you are seeing.

Resources and Going Further

Now that you've successfully logged data with your Qwiic OpenLog, you can set up remote projects and monitor all the possible data coming in. Consider creating your own Citizen Science project, or even a pet tracker to see what Fluffy does when out and about!

For more information, check out the resources below:

• Eagle Files (ZIP)
• Schematic (PDF)
• Qwiic OpenLog GitHub
• Qwiic OpenLog Arduino Library GitHub
• SdFat GitHub
• SerialPort GitHub

Need some inspiration for your next project? Check out some of these related tutorials:

If you have any tutorial feedback, please visit the comments or contact our technical support team at TechSupport@sparkfun.com.