NanoLoggers #
See github for up-to-date information on this project.
This is an interdisciplinary project at the intersection of Biology and Computer Science aimed at developing sensor payloads below the weight and energy budgets of most low-energy devices – \(1g\) and \(1\mu W\) , respectively – that must survive challenging environments and collect useful data over many months. Our biology partners study the behavior and ecology of Dark-eyed Juncos, a small song-bird in the range of 20-25 grams. We are also developing data loggers for smaller birds such as the pine siskin, which is in the 12-18 gram range.

Junco with Tag
The small size of the subject animals necessarily constrains the size and weight of any tag that they carry. A widely accepted “weight budget” for such tags is 5% of body weight – \(1g\) and \(0.6g\) for Juncos and Pine Siskins, respectively. There is debate about this bound and it is clear that smaller is better. Designing tags at this scale using off the shelf components and commodity fabrication processes is a significant challenge – especially for smaller species. It is clear that tags should carry exactly the components (e.g. sensors) needed for a particular experiment and no more – a key project goal was to make support of custom tags “painless”. For example, our partners are currently monitoring “activity” with the goal of determining when the subjects are active.
Example Tag #

BitTags
Data Visualization #
In addition to the tags and their support hardware and software, we have built a separate visualization tool for BitTag activity data. This tool provides various ways to explore the data collected from a tag. There are two fundamental views – a graph of the raw data, and actograms.

Raw BitTag Data

BitTag Actogram
Data Validation #
It can be difficult to translate such a subjective idea “active” into a measurable quantity. In our work we use accelerometers to measure movements and, based upon thresholds, determine whether or not an animal is active. This raises an important experimental question – how are the thresholds selected ? We have developed two tags, one capable of storing full-bandwidth accelerometer data in an external flash for 100-200 hours and another that only stores activity “bits” in internal flash. We use the larger tag to validate, with concurrently collected video, the decision process used to to determine “activity.”
Energy #

BitTag with 5mAh Battery
As we shall see, the choice of battery depends upon the tag hardware – the BitTags operate with LiMn batteries while some tags, notably those with external flash memories, require LiPo batteries which have significantly different operating parameters. In [link] we discuss the various energy storage options and their architectural requirements. In this document we do not consider energy harvesting – at the scale we explore, the added weight and complexity of any energy harvesting devices is likely to exceed their potential benefit.
Tag Infrastructure #

Programmer for BitTags

Tagbase Adapter and Tools

Tag Charger Array
The adjacent image illustrates three such chargers (only one USB connector is used per ‘gang’). These chargers can be built relatively inexpensively (under $50/each in small quantities).
Tag Configuration #
The tags that we build are highly configurable. For example, the BitTags can be configured with various “thresholds” for determining when the animal is active, different data aggregation choices (from 1 bit/second to active second counts per 5-minutes), and complex schedules including hibernation periods.
This tab also provides various control actions and provides for data download.

Avian Tag Monitor

Avian Tag Monitor
The Tag Monitor provides access to these configuration options.

Avian Tag Monitor
The Tag Monitor software is highly configurable and is designed so that it can be extended to support additional types of sensors and data storage strategies. The specific options shown are automatically customized to the tag being configured. In addition, we provide support for batch testing and configuration of tags through separate command-line tools.
Flexible System Architecture #
The design of the tag hardware is really only a small piece of the system design problem – indeed, we can develop the hardware for a new tag (e.g. one with a different sensor) in a few hours. Integrating the new tag into the larger system consisting of the tag firmware, programming bases, and host software is the most significant challenge for customization. Thus, it is helpful to step back and consider a “generic tag” in the context of a larger system as illustrated below. The overall (hardware) system consists of a tag, a base, and a host computer. We assume that a tag has a a processor, sensors, (real-time) clock, storage, and power management. The base provides host access to program and configure the tag and download data, as well as (chemistry specific) battery charging.
In any such system, the most important architectural aspect is the definition of the interfaces between the major components.
Standardizing these interfaces enables component reuse. For example, the tag/base (physical) interface utilizes
the ARM standard SWD (serial wire debug) protocol for communication. By utilizing this interface, our architecture
can, in principle, support tags built with any ARM Cortex embedded processor. The
physical host/base communication utilizes the ST Microelectronics stlink protocol over USB. By leveraging
these existing interfaces, we can exploit off-the-shelf tools to program and debug tags. For example,
we use openocd, an open source package that supports the stlink protocol, for programming and debugging the
tag firmware. The only host device driver required is libusb, which is supported on large number of operating
systems including linux, windows, and OS X.
Our system
architecture leverages these physical and link-layer protocols (swd/stlink/usb) to support host-tag communication.
Host-tag communication is implemented
with a simple remote procedure call (RPC) protocol that communicates through the SWD debugger interface with the tag processor
and utilizes a feature of Cortex-M3 and Cortex-M4 based processors that supports “debug monitor” interrupts.
The RPC messages are encoded with the
Google Protocol Buffers message format. Leveraging Google Protocol Buffers enables the use of significant
existing software libraries for communicating with the tag firmware. Furthermore, the protocol buffers standard
enables (relatively) easy extension to support features of new tags. For example, to support configuration of
a new sensor, it is only necessary to extend the configuration message with new data fields. By following Google design
recommendations, it is possible to extend message formats while remaining backwards compatible.
Thus, our tag firmware architecture limits the software fallout from adding or removing sensors and storage devices,
and from creating experiment specific data collection protocols.