The ALog: Inexpensive, Open-Source, Automated Data Collection in the Field

Authors

  • Andrew D. Wickert

    1. Institute of Arctic and Alpine Research, and Department of Geological Sciences, University of Colorado, Boulder, Colorado USA
    2. Northern Widget LLC, Saint Paul, Minnesota, USA.
    Search for more papers by this author

A consistent problem in field measurements is that they are often too sparse, too infrequent, and too expensive. These are, of course, connected: scientific budgets are being squeezed at the same time as we increasingly recognize nonlinear interactions and nonlocal phenomena that defy simple statistics in our understanding of nature. While some advances in data logging technology have been made, by and large, automated field data collection still involves heavy, expensive equipment that is programmed in proprietary languages and connects primarily to branded sensors that can cost several times the amount of a generic equivalent.

Fortunately, a growing society of open-source enthusiasts (Open-source” describes software and hardware whose source code, schematics, and all other information required to run or build the program or device are made freely-available and accessible.) at-home do-it-yourself “makers” of technology (Banzi 2009, Margolis 2011), artists (Buechley et al. 2008), and educators (Jamieson 2010), have developed the vast majority of the hardware and software required to perform scientific data logging in the field— largely unintentionally. This work is centered around a small circuit board called the Arduino (Fig. 1B), a widely distributed, inexpensive, and easy-to-use prototyping platform aimed at making physical computing—hardware and software that can sense the outside world and take actions—accessible to anyone. The simplicity of programming the Arduino, in a well-documented C/C++ variant, and open access to all of the hardware and software source files, inspired the development of the ALog, an Arduino-style (hence “A”) board optimized for field work and data logging (hence “Log”), which maintains the open-source ideals, ease-of-use, and low cost of the original Arduino board. In adapting these advances created by the global community to the needs of science, we hope to develop momentum behind open-source technology that can stretch limited budgets, allowing scientists to construct field monitoring networks at the scales and resolutions necessary to answer questions about ongoing environmental change, researchers in lower-income areas to afford research-grade equipment, and citizen-scientists in wealthier regions to fully replicate professional endeavors (Wickert, 2013). The ultimate goal is an increased density of field measurements that improves awareness and appreciation of the dynamic world around us.

Figure 1.

Development of the ALog BottleLogger. Open-source ideals (A) were the inspiration behind the Arduino (B) (Banzi 2009). The Arduino and the data logging shield by Fried (2010), formed the basis for development (C) of the field-capable ALog data logger (Wickert, 2013), which ultimately led to data logging systems for terrestrial (D) and marine (E) applications. Panel (E) shows an early example of community collaboration, with Nick Evans (pictured) and Chris Paola of the University of Minnesota integrating the ALog into the Wax Lake Delta Observatory, study site for Mississippi River Delta restoration; Evans developed the watertight housing. (Panel B photo by Arduino team; Panel E photo by Antoinette Abeyta).

1. From development to the field

In 2011, I was in the midst of what was becoming an increasingly computer-based Ph.D. project to understand past glaciation and river systems in North America. As a field-trained Earth scientist with a desire to understand nature rooted in my love of the outdoors, I started to look for a way back outside. As a bit of an overachiever, I decided that my return to the field must be accompanied by something significant.

My experience with commercial data logging equipment was not always pleasant. Campbell Scientific data loggers were prohibitively expensive for science, heavy, and used a cumbersome proprietary programming language. Instruments by Onset Computer Corporation, while lighter and less expensive, were nonetheless a stretch for many budgets. Both companies sold instruments designed specifically for their products at costs much greater than an equivalent unbranded sensor. Furthermore, both companies' loggers typically included stringent memory limitations. I had found my problem to solve. Armed with some basic soldering skills from college and an unflappable notion that I would succeed, I did what any geologist in my position would do: I called my little sister.

Karen Wickert, a mechanical and software engineer in Boston, had guided me through earlier work in developing remotely triggered camera systems that I had deployed in flash-flooding tributaries to Grand Canyon (Wickert 2010) and the burned hillslopes in the aftermath of the Fourmile Fire in Colorado (Wickert et al. 2011). It was then that she introduced me to Arduino, but though I did not know it at the time, the complexity of these projects would pale in comparison to the new one. Karen pointed me towards the data logger shield of Fried (2010), an Arduino add-on that became the basis for portions of the ALog, and gave me her sibling's vote of confidence. (This is a combination of incredulity and unconditional support.)

I set to work. My first deployments, in the Boulder Creek Critical Zone Observatory, were a partial success—not as good as I wanted, but good enough to know that I was on the right path. Then, during Spring 2012, my officemate, Katy Barnhart, suggested that I build instruments to help with upcoming field work to study Kennicott Glacier in Alaska. I redesigned the circuit boards, improved the subsystems, and cleaned and rebuilt the source code. Finally, after soldering hundreds of components and fully testing each assembled logger—connected to sensors for snow depth, river stage, and air temperature—I sent them on their way and hoped to the heavens that they would not fail. They were mounted to the bridge over the river and on ablation stakes supporting GPS monuments (to measure glacier velocity), and some were left to overwinter. When Billy Armstrong (Armstrong et al. 2013) returned after the second field season, he told me that his GPS units had been frustrating, but that at least he knew that the whenever he pushed the “reset” button on one of the “AndyLoggers” (as he called them), it would flash out a pattern that told him that it was working perfectly. And that's when I knew that I really had done it.

My two best friends and I started a company, Northern Widget LLC, to manage the ALog data logger development and distribution. Since that time, I have improved on the prototype design used by Armstrong et al. (2013), and worked to help scientists on projects in Chile, Bangladesh, Greenland, Louisiana, Colorado. In September 2013, I visited Kennicott Glacier, the site of our first major success. By this time, these surprisingly rugged ALog prototypes had built a continuous record of over a year of streamflow—fed by glacier melt—along with the temperature and snow depth measurements necessary to model glacier mass balance.

2. How it works

The ALog is made up of an amalgamation of subsystems inspired by and based upon existing open-source hardware, with a few additions, subtractions, and modifications to make it a better data-collecting-and-storing machine. In essence, it comprises five components: a microcontroller as the “brain”, screw terminals that connect to sensors, a clock to keep the time and tell the ALog when to read and record data, a SD card (Secure Digital card: This is the type of memory device used often in digital cameras.) to save the data, and human interface components (USB port and LED) to interact with and program the ALog. These components work together in an intricate dance choreographed by the ALog software.

Software for the ALog is centered around a C++ software library, called “Logger,” which encapsulates two sets of functions and variables (Fig. 3). The first set defines the characteristics of the ALog—such as how the microcontroller connects with the other on-board devices—and core functionality—such as setting its clock, writing data to the SD card, and managing its power consumption. The second set of functions and variables interface the ALog to sensors; as users add functions for new sensors, they indirectly help numerous other scientists by saving them the time required to reproduce that effort.

Figure 3.

The ALog stands on the shoulders of a “giant”: the platform built by Arduino developers. The “Logger” software library, around which the ALog is programmed, is rooted in the Arduino core library (Banzi 2009) as well as a number of third-party libraries that permit data to be saved to an SD card (Greiman 2013), clock setting, and (full implementation to be released soon) the SDI-12 protocol for communicating with sensors (Kevin Smith: https://github.com/StroudCenter/Arduino-SDI-12). The Logger library itself comprises a core functionality managed by Northern Widget LLC, with community input, and sensor interfaces that can be built by anyone and incorporated into the Logger library to share with other researchers.

At the core of the ALog hardware is a microcontroller chip. This is a small computer that can be programmed to interact with its environment both by collecting inputs from the surrounding world and by taking actions of its own via electrical signals. The ALog uses the same chip (ATMega328) as the Arduino Uno, for full compatibility with the main line of Arduino boards.

This microcontroller chip interfaces with sensors that can be connected to the ALog through a set of screw terminals (Fig. 4). It can receive signals from sensors as analog voltages (common for temperature sensors), by reading the length of a voltage pulse, or by serial communication similar to a modem. The latter includes recent Arduino support for the SDI-12 protocol, which is popular in environmental sensing and allows multiple sensors to be read from a single connection to the logger (see https://github.com/StroudCenter/Arduino-SDI-12).

Figure 4.

ALog BottleLogger v. 1.0 with major components labeled. The ATMega328 microcontroller core, the same chip used on the Arduino Uno and its predecessors, runs at 8 MHz and communicates with the sensors and other components. The USB port powers the logger and, through the USB-to-serial converter, provides an avenue to program it and set its clock. References resistors may be plugged into the board for use with thermistors or other analog voltage-based sensors. Buttons to trigger the logger to take an immediate reading and to reset the logger (i.e. restart its logging program) are also mounted on the board. Switchable voltage regulators supply power to the SD card and provide a known voltage source for analog sensors.

An accurate real-time clock is essential to any data logging system. The clock integrated into the ALog is internally temperature-compensated, which reduces its drift—the rate at which it strays from an absolute time standard—to 1–2 minutes per year. Time is managed and recorded as Unix time, the number of seconds elapsed since midnight UTC on 1 January 1970. This is a standardized representation of time that can be converted to a calendar age, and using it sidesteps time zone and daylight savings time problems common to current commercial data loggers.

The ALog writes data files to an SD card in a standard comma-separated ASCII text format, which users can save to a computer to be imported to a spreadsheet or manipulated using other analysis routines. The large capacity of even low-end SD cards overcomes memory issues common in current commercial data logging systems. Data logging occurs either at a pre-set time interval (regulated by the clock) or when triggered by an event (e.g., a bucket tip of a rain gage).

The final major component of the ALog is its human interface. The ALog can be programmed over a standard USB cable, which also serves to set the clock and communicate with the logger. This USB interface is based upon the USB-to-serial interface boards of Sparkfun (2010), which in turn replicate the functionality of earlier Arduino boards (Banzi, 2009), and sets the ALog apart from many other data loggers, which use non-standard interface technologies such as infrared signals or outdated 9-pin serial cables. A LED on the ALog circuit board flashes patterns to tell the user whether or not it is correctly configured and recording data, and whether the clock needs to be set.

The parts that constitute the ALog were chosen with field applications in mind. All of its components are rated to an industrial −40°C to 85°C, meaning that the ALog can withstand most climates on Earth. Furthermore, the ALog board is entirely lead-free, making it safe to deploy in sensitive environments.

What makes the ALog more than a sum of its parts is that it combines its subsystems in a way designed to use as little power as possible. When the ALog is not recording data, it enters a low-power “sleep” mode that is analogous to the power save of a closed laptop computer and reduces power consumption by a factor of 30–80, depending on the sleep settings. It can receive power inputs of 3.7–5.0 volts, permitting the use of 4 V lead-acid batteries, 3.7 V lithium polymer batteries, or 3-packs of 1.5 V primary cells, such as AA or D cells, connected in series. Most applications use D cells (Fig. 1D) for their combination of long life and widespread availability. The standard lifetime of the ALog on D cells ranges from 1.5 to 6 years, depending on these sleep mode settings, the sensors attached, and the logging interval. This removes the need for solar panels, reducing weight, bulk, and cost, though solar panels can be used for long-term monitoring and more power-intensive applications than we and our collaborators have implemented thus far.

While we released the ALog v. 1.0 on 11 September 2013, feedback from users has helped us to improve the software, fix bugs, and start concept sketches of newer and more advanced data loggers. Work currently is underway to incorporate wireless networking and telemetry into a future version of the ALog, with the latter including cell phone and satellite phone networks. Consistent, community-driven improvement is at the heart of the open-source movement, and it is natural that the scientific community, defined by shared purpose and “standing on the shoulders of giants,” holds similar ideals.

3. Incorporating the ALog into your work

The current available version of the ALog is named the “BottleLogger” because it is slim enough to fit inside a Nalgene water bottle. Full schematics, parts lists, and source code are available from https://github.com/NorthernWidget. You may download these freely and build your own ALog BottleLogger, or you may contact Northern Widget info@northernwidget.com) about purchasing pre-made boards. At the time of writing (early 2014), it costs ~US$100 to purchase the components necessary to build one the boards. A major purpose of Northern Widget LLC is to accumulate orders such that the data loggers can be built in bulk, significantly reducing parts cost and replacing the painstaking task of hand-soldering them with contracted semi-automated construction.

Once you have ALog board in hand, the world is yours to monitor. Download the Arduino software from http://arduino.cc/en/main/software, and the data logging libraries and clock setting utility from https://github.com/NorthernWidget. Upload one of the example programs (“sketches”) to the data logger, set its clock, and off you go! If a walkthrough is helpful, a quick-start guide is available at http://northernwidget.com/alog/guide/. Please let us know (info@northernwidget.com) if you need any help setting up the data logger or building a housing for it, for recommendations on sensors, or if you would like to share your project with us to be featured on the Northern Widget website.

Past and ongoing projects have employed the ALog to monitor glacier mass balance (Fig. 2) and gage streams in Alaska, measure overland flow in Colorado, study flash floods in Chile, and record water depth and temperature to model water flow, sediment transport, and denitrification through the Wax Lake Delta in Louisiana. These collaborations have helped us to improve the quality of the ALog data loggers at the same time as we helped scientists to complete their projects.

Figure 2.

This prototype ALog BottleLogger 0.6.6 was deployed by Billy Armstrong, Katy Barnhart, and Bob Anderson, on the Kennicott Glacier in Alaska, where it reliably measured temperature and snow depth, contributing to a glacier mass balance (Armstrong et al. 2013). This deployment followed additional collaborations to study hillslope hydrology in Colorado (with Suzanne Anderson, Bob Anderson, and Nate Rock) and overland flow in Bangladesh (with Irina Overeem and Kimberly Rogers). It was followed by post-wildfire erosion and runoff studies in Colorado (with Sara Rathburn and Scott Shahverdian (Shahverdian et al., 2013), and Peter Nelson and Dan Brogan), stream gaging for flash floods in Chile (with Dylan Ward), and Mississippi River Delta restoration work (with Nick Evans and Chris Paola: Fig. 1E). These collaborative efforts have been crucial to the development and testing of the ALog BottleLogger v. 1.0; without this community support, the ALog project would not be on the path to success.

In order to maintain the integrity of this open-source project, the ALog is licensed under the Creative Commons 3.0 attribution share-alike license and the GNU General Public License version 3.0, where each apply. Both licenses are “copyleft” licenses, meaning that all derivative works must be distributed under licenses with the same freedom to use and requirement to share. These licenses do not inhibit commercialization, but favor a different kind of enterprise, in which users and companies share advances and work together, cooperating instead of competing, a model that has seen major recent success in the hobby electronics industry. In other words, if you want to improve the ALog, let us know and we will help each other!

4. Additional work with open-source data collection

The ALog is not the only effort to use open-source technology to create better data collection systems. Major efforts have been underway at the Christina River Basin Critical Zone Observatory, where Hicks et al. (2011, 2012) have combined pre-built open-source circuit boards and other readily-available components to monitor watersheds. Their research group also has recently developed an Arduino interface to the popular SDI-12 sensor communication protocol (Kevin Smith: https://github.com/StroudCenter/Arduino-SDI-12). Rolf Hut and others have coordinated an AGU session for the past several years on innovative technologies to monitor the world around us (see Hut 2013). Leeuw et al. (2013) incorporated an Arduino board into their low-cost fluorometer to study phytoplankton. Prior to developing the ALog, I built Arduino-triggered camera systems to monitor flash floods and overland flow (Wickert 2010, Wickert et al. 2011). Ham (2013) combined 3-D printing technology with open-source electronics to build components for weather stations, and Barnard and Findley (2013) used Arduino-based technology to measure sap flow in trees. Together, these and other community-driven instrumentation efforts have combined off-the-shelf components, an open-source attitude, and shared expertise—to measure nature.

5. Summary

The ALog data logger, built around the popular Arduino microcontroller platform, is an emerging technology to improve automated field data acquisition. It has been successfully deployed in field collaborations that have helped to guide its lightweight, low-power, and low-cost design. It is our hope that the ALog and other inexpensive, community-driven, open-source technologies foster a movement to collect field environmental data on a budget that permits citizen-scientists and researchers from low-income countries to obtain the same high-quality data as researchers in wealthy countries, improving worldwide awareness and understanding of global change.

6 About the author

Andy Wickert (ORCiD 0000-0002-9545-3365; ResearcherID C-2021-2014) is finishing his Ph.D. in geology at the Institute of Arctic and Alpine Research at the University of Colorado Boulder. He will be spending the 2014–2015 academic year at the GFZ Potsdam, after which he will be starting as an assistant professor in Earth-surface processes at the University of Minnesota–Twin Cities. His Ph.D. research has focused on the deglaciation of North America, while his broader work involves watershed-scale processes, modern glaciers, and numerical model development. He manages Northern Widget LLC (http://northernwidget.com) with his two best friends, Chad Sandell and Lorenzo Dandrea, to encourage scientific implementation of open-source technologies. (e-mail: wickert@colorado.edu; andy@northernwidget.com)

Ancillary