Archive for Toolbox

Build Your Own Data Logger – The Software, Telling the Logger to Log

790px-Kaffeetasse_Milchkaffee_Cafe-au-Lait_CoffeeOkay, with the arduino, shield, wiring and sensor complete, we’ve got our stuff together and can get our logger to log. To do that, we need to tell the arduino what it has to do. This is done with the arduino coding language. Now, what’s that and why do we need it?

As we have seen in the last part, an arduino itself is not very intelligent. To every ordinary person you can say “Would you be so kind and fetch me a cup of coffee?” and he or she will be able to execute that task without further ado, given he or she knows where the kitchen is and all necessary tools are available. If you want the same thing from a machine, you have to speak its language (or have a translator, which is called a “compiler”) and you have to think about the task you give it in a way as if that thing doesn’t know anything about this world. Which is, in fact, true for any machine. So, to stay in the example, to code a machine you have to say:

When hearing the command “Would you be so kind and fetch me a cup of coffee?” do the following:

1. Go to the kitchen
2. If the door is locked, open it to go into the kitchen
3. Go to cupboard
4. Open door of cupboard
5. Take out 1 cup
6. Close door of cupboard
7. Put cup under the coffee machine
8. Press first button
9. Wait until fluid has filled cup
10. Take cup in an upright position
11. Bring cup to person who spoke command

Silly, isn’t it? You would go mad with an assistant asking for such precise commands. That’s why some people find it hard to code – it’s very complicated to think so basic. But, anyway, we want our logger to log, so let’s take a look at the necessary code step by step (the complete code can be copied from our Quick Start Guide):

The part that is introduced by /* and ended by */ is a comment, something that is written for humans to read, not for the arduino to understand. Think of it like spelling out certain words so the kids don’t understand. Well, we never can be sure with kids and spelling, but we can be quite sure with /* */ and arduino.

You use this comments to make sure that another human being is able to understand what you wanted to achieve with a section of code. Chances are that human being is you because after some time you won’t remember why you coded some things that way. Comments are a part of good documentation, something we collections folk like, right?

Next up we have a couple of so called “libraries” we include in our code.

We have seen what an arduino mind needs to fetch you some coffee. Well, someone has already defined all the steps beginning with “1. Go to the kitchen…” in a library, so if you want your specific arduino assistant to be able to fetch coffee for you, you just have to write “#include <coffee.h>” at the beginning of your code and whenever you write “Would you be so kind and fetch me a cup of coffee?”, your assistant will be able to do all the necessary steps to bring you a nice, hot cup of coffee. It will also include what to do if the coffee machine is turned off, the water tank is empty, there is no coffee…

Now, I have to admit that I don’t understand all those libraries that are included here, of some I only know as much as that I do need them, and I know that I need them because I saw that they were used in some example codes. I think of it like when we need a conservator – of course we have to know which specific conservator we need, but we don’t have to fully understand what she or he does. Although, of course, the better we understand what she or he does, the more effectively we can cooperate.

For our logger we have included some libraries so it:

  • understands some functions you might need from the programming language C (stdlib.h)
  • knows how to handle time, that is, knowing that there are seconds, minutes, hours, days… (Time.h)
  • knows how to read the Real Time Clock on the logger board (DS1307RTC.h)
  • knows how to communicate with I2Cs (Wire.h)
  • understands what our sensor tells it (DHT.h)
  • knows how to communicate with peripheral devices like the SD card reader (SPI.h)
  • knows how to read from and write to a SD card (SD.h).

Next up we have to define where our sensor is and what type of sensor we use. The DHT library we included is able to handle DHT11, DHT21 and DHT22, so we have to specify that we connected a DHT22 and we connected it to our pin 9. The notations behind the “//” are again comments to be read by humans, not the arduino:

Next our sensor gets a name so we can order it to do something.

To keep things simple, we called it just “dht” in small letters, but we also could have called it “Walter”, “Gretchen” or “sensor1”. It’s only important that it is named consistently and that we are careful in using upper and lower case. For an arduino “Gretchen” is something other than “gretchen”, so the program won’t run if you make a mistake here.

The next line makes sure that we can communicate with the SD-Card although we used a logger shield. In the library, pin 4 is defined for a certain action, but this is already taken by the shield, so the arduino should use pin 10 instead.

So far, we have just made sure that our arduino knows what it needs to know. Next up we enter the “setup”. Think of it as your new assistant walking through the door. Before you can order her/him to do anything for you, you have to show her/him around. Where is the toilet? Where is the kitchen? Where is the coffee machine… This all will happen in the curly brackets after “void setup”.

Actually, the very first thing we do is we tell our imaginary assistant how s/he should communicate with us. Our arduino will be able to tell us what it does when it is connected to a computer using a thing called “serial communication”. It will be able to send information via the USB cable which we can read in the Serial Monitor of our arduino software. The line Serial.begin(9600) is like telling our assistant that s/he should communicate with us in English.

Next up, we tell our arduino that it should use pin 7 and 8 as output. This is where our two LEDs are connected, but our arduino only knows this if we tell it so. There are two possibilities for a pin: it can be an output or an input. If we define it as an output we can send signals to it that will do something with the thing that is connected to said pin. In our case, if we send that pin a “HIGH” signal it will switch the LED on, if we send it a “LOW” signal, it will turn it off.
If we define a pin as an input our arduino will “listen” to what happens on said pin instead. If the arduino receives a signal there, it can do something according to that signal. But in this case, we only need an output for our LEDs.

Next up, we do a couple of checks to see if our SD card works properly. It prints “Initializing SD card…” to the serial monitor so we can see it.
There is again a pin, pin 10, we define as an output, because our SD-Card-Reader needs this (we know this from the example code).

Now, the arduino checks if it can read the SD-Card. If it can’t read it, it sends a message to the serial monitor saying “Card failed, or not present”.
But “in the field” we won’t have an USB cable connected to a computer, only the logger itself. So we use our red LED on pin 7 to send us the same message. If the arduino doesn’t find the SD card reader or the SD card, it switches the red LED on for 5 seconds. In the arduino language this time span is given in milliseconds. So you see that we send the LED a “HIGH” signal, then wait (delay) for 5000 milliseconds until we send it a “LOW” signal to turn it off.
This is a mission for the Q-Tip: If the red light indicates that the SD card is missing or not properly inserted, you can put your SD card in the slot and press the q-tip, which reaches to the reset button inside the case to restart your arduino and try again.

If the arduino can read the SD-Card it will send the message “card initialized.” to the serial monitor. Next it sends “DHTxx test!”. Again, we have no idea if it can read the SD card, so if this is the case, we switch the green LED on pin 8 on for 5 seconds.

With the simple statement “dht.begin();” we tell our sensor that it should start reading.

Now our setup is finished, we can now tell our assistant what s/he shall do all day long. We do this in a function that is called “loop”. This function will repeat itself forever, if we don’t code anything that make it stop (or the plug is pulled).

What we want to do repeatedly is to read how high the humidty and the temperature in our room is, right? To read from our sensor, we call “dht.readHumidity” for the humidity and “dht.readTemperature” for the temperature.
If we want to use these values repeatedly in our code we use a thing called “variables”. A variable is something like a bag. We can store a value in it and carry it around. In our case we call our variables “h” for humidity and “t” for temperature. Bags come in all sorts and sizes, so do variables. You would choose your small, black handbag for a dinner invitation and your rucksack for your day trip so you always got the bag that fits your storage needs. Our sensor readings will come in a form like 14.5 or 34.8, they come as floating point numbers. So we choose the variable type “float” for it. There are a lot of other variable types, but for now, we just learn that “float” is the right type for our sensor values.
To sum up, the following lines of code store our sensor readings in the variables “h” and “t”. Whenever we call those variables in the fllowing parts of the code, they will repeat the sensor values.

But what will happen when the sensor returns something that isn’t a valid value for humidity or temperature? The next part of our code checks exactly this and reacts accordingly.

If either the value for humidity which we stored in “h” or temperature which we stored in “t” is not a number, the arduino will inform us by writing “Failed to read from DHT sensor!” on the serial monitor. The expression for something not being a valid number is called “isnan” (for IS Not A Number. Instead of writing “or” between the conditions, we have to use wording the arduino understands, which are the two upright strokes || (there are a few of these, like “and” which is &&, “greater than” which is > or “smaller than” which is < ).

Again, with a free standing logger we won’t see a message on our computer, so we let our red LED blink frantically if the sensor values are nonsense. There might be more elegant ways to code this, but I’m just a collections manager, not an IT professional.

Next up we print our values to the serial monitor for check, in case we have a computer connected. Right now you should be able to understand what happens:

Now, we need the time that comes from our Real Time Clock. Note that to use the Real Time Clock properly, you have to set it to the correct time first, using the example provided with the RTC library. Basically here we say “look at the clock and remember anything you saw in a variable called “tm”). We will be able to call the specific day, month, hour, minute, second… that way later in the code.

What follows next is perhaps a little weird to explain and to look at. We want to store our data on the SD card later, in a form that each data point is separated by a comma. That way, we can use any old spreadsheet software, import the data in a form that is called “comma separated values” (CSV) and process it further. The thing is, our data are numbers. You remember how we defined our sensor readings to be floats? Yep.

What we need to process it further is charcaters, in other words, we need a string. To be more exact, we need a string that incorporates all the data we want to be stored when we read our sensor. We want to have something that looks like this:
“34.8, 14.5, 2017, 04, 14, 2, 45, 23,” that we can have in our spreadsheet software to process a reading of 34.8 % relative humidity, 14.5 degrees Celsius on the 14th of April 2017 at 2:45 p.m (and 23 seconds).

To achieve this, we first open up an new bag called “dataString” to store our values in. I must admit I don’t get what line 116 really does, but it has something to do with defining the size that is available for our values.

What happens next is that we put all our values that we want to store into our “bag” called “dataString”. We do this one by one, as if we open up our bag, put the tape measure in, put the gloves in, put the lipstick in… The tricky thing is that whatever we take, we first need to convert something that is a number into a string. Hmmm… perhaps like if you want to put a fluid into your bag. You first have to put it into a container. Well, perhaps not exactly so, but along these lines.

So, we put our humidity value into a container. We call this container “stringH”. The function “dtostrf” does this with our variable h, which is, as we know a float number of our relative humidity reading. Then we put our container “stringH” into our bag “dataString”:

We said we wanted to have comma separated values in the end, so what we do have to do now is to add a comma. We take our “dataString” bag and put a comma in, useing “+=” as the order to do so. Here we go:

The same goes with our temperature reading:

What does our bag now contain? Something that looks like that: “34.8, 14.5, “. You can make sure by ordering your code to let you know on the serial monitor by adding this line:

We didn’t do that here. Instead we are putting in our bag one by one the values for the day, month, year, hour, minute and second of the reading, each separated by a comma. Note: I later discovered that I wouldn’t have had to separate them all with a comma, but we will discuss this later in the series. For now, we just know it works.

Whew, that’s a lot of code. Our “bag” dataString now looks like that: “34.8, 14.5, 2017, 04, 14, 2, 45, 23,”. Next up, we want to write it to our SD card. To do that, we have to open the file the string should be written to:

If the arduino finds the file called “Mylogger.csv” on the card, it openes it, writes the content of dataString to it (at the end of all other data that is already stored there) and closes the file again. Mission accomplished!

What’s great about this is that if there is no file called “Mylogger.csv” on the SD card, the arduino will automatically create it. Only in the occasions where there is such a file, but it can’t be opened or if the SD card is missing, we will need an error coding which informs us on the serial monitor and lights up the red LED until the next loop:

Finally, we have to define how long the arduino should wait between measurements. The more often you read, the more data you get, which is a plus in detail, but also needs more storage space. In our example, we wait 5 minutes between readings, which are 300000 milliseconds. For 10 minutes, set it to 600000 milliseconds and so forth.

That’s it, that’s the whole code. There is, of course, room for improvements, for example if you need the temperature in Fahrenheit or want to calculate the dew point. But this will be another part of the series…

More posts on this topic:
A thing that can do things – Taking a look at the Arduino from the perspective of a collections specialist
Build Your Own Data Logger – Quick Start Guide
Build Your Own Data Logger – The Sensor, Heart of the Logger
Build Your Own Data Logger – The Shield and the Wiring


Two Questions For Registrars/Collections Managers

Dear colleagues,

I sure would like to be warned if humidity rises from 27 % to 43 % within 10 minutes!

I sure would like to be warned if humidity rises from 27 % to 43 % within 10 minutes!

I like to pick your brains, experience, gut feelings… It has to do with the data loggers I’m currently building and testing.
We all have our set temperatures and humidity levels we don’t want the values to drop beyond or go above. We sure want to know if the humidity level in our storage for metal objects exceeds 55% or the temperature drops beyond 11 °C (51.8 °C). So it’s quite logical that we want our device to send us a warning when this happens.

But there is something other we sure would like to know about: we all know that the most harm is done to objects by sudden change in the climate. Sudden drops or rises in temperature and/or humidity. Those changes might stay well between our given ranges but happen so fast we sure want to hear about as soon as it happens. On the other hand: if we get warnings too often we will grow numb towards them. So, I try to find a good middle ground and that’s why I’m asking you to state your opinion:

Imagine you had a device that warns you about sudden climate changes within a 10 minutes time span on your prefered channel (email, twitter, cell phone), what would you pick as trigger value?

What would you choose as a trigger value for relative humidity change within 10 minutes in your storage?

View Results

Loading ... Loading ...

What would you choose as a trigger value for temperature change within 10 minutes in your storage?

View Results

Loading ... Loading ...

Build Your Own Data Logger – Arduino, the Datalogger-Shield and the Wiring

Sorry for the delay continuing this series. Actually, part of the delay had to do with developing an hands-on for explaining how gears work on a bicycle together with a colleague, using an arduino…

So, the basis of the logger is an arduino, which we presented lately as the “thing that can do things“. There are several arduino platforms depending on what you want to do. For our project we chose an arduino uno:
Photo by Clic17 via Wikipedia, CC-BY-SA 4.0Photo by Clic17 via Wikipedia, CC-BY-SA 4.0

Now, an arduino uno can do much more than just reading sensor data like we want to do, but it’s rather easy to make projects real without having to solder anything, it comes with a quite easy to understand coding language and there is a broad international community experimenting with it, so you probably find answers to your questions at the official arduino forum or somewhere else on the web.

To work with an arduino you will connect the sensor and other devices you need to the ports of the arduino. You got digital ports (0 to 13), analog ports (A0 to A5) and some ports for connecting to power (marked 3.3 V, 5 V and GND). We take a close look on what we connect how later on.

First, we need another useful device, a data logger shield. So, what is a shield you ask? Well, as your arduino comes out of the box, it is a generalist. It can do anything, from showing the bike speed to logging your climate data. You connect it to all the parts you need for your specific project. Depending on the project, this can be a lot of wires, resistors, capacitors, switches… So, for some specific tasks you need for certain projects some fine people have developed boards that have everything you need on them and which you can connect to the arduino by simply “clicking” it on. So, the shield sits on the arduino like a backpack, is ready to perform certain tasks and you still have a reasonable amount of ports for your specific task, although some ports are now used for the connection.

And what is a data logger shield? Well, look here:

Taken from Adafruit website

Taken from Adafruit website

A data logger shield has two very useful devices: a SD card reader to log your data for further use and a real time clock (RTC). We need a real time clock because an arduino is incredibly dumb. When we tell it what time it is, it just remembers it as long as it got power. When we disconnect it from the power source it immediately assumes that it’s 0 o’ clock. The RTC has a small battery on board that safeguards the arduino remembers the time even when disconnected.

When we clicked the data logger shield to the arduino we can start wiring our logger. We can do that by soldering the wires directly to the shield, which comes with a convenient hole matrix for this task, or we can use a little breadboard and breadboard cables to do the wiring like in our example. For long-term use, I’d prefer soldering because it is less vulnerable to bad contacts. You can see the exact wiring in this scheme:


The data pin of the sensor is connected to digital port 9, the green LED over a 100 Ohm resistor to digital port 8, the red LED over a 200 Ohm resistor to digital port 7. The “buckled (short) legs” of the LEDs, which are the minus pole, and the ground pin of the DHT22 are connected to the GND port. The power pin of the DHT22 and the data pin over a 10 K Ohm resistor are connected to the 5 V power port.

For our logger, we mounted the breadboard with the sensor and the two LEDs on the outside of the casing, while arduino and shield are inside of the casing. You can see the breadboard wires being connected from the inside to the outside:


Finally, we need something that allows us to push the reset button in case we want to restart the arduino. In our case we used a q-tip with a broad plastic peg on one end.

Next up, we will take a look at the coding for our logger.

Angela Kipp

More Posts on this topic:
A thing that can do things – Taking a look at the Arduino from the perspective of a collections specialist
Build Your Own Data Logger – Quick Start Guide
Build Your Own Data Logger – The Sensor, Heart of the Logger
Build Your Own Data Logger – The Software, Telling The Logger to Log

This post is also available in Russian translated by Helena Tomashevskaya.


Build Your Own Data Logger – The Sensor, Heart of the Logger

The first thing that can do things that actually DOES things for the TECHNOSEUM: A data logger that records the climate in a certain area of our museum.

The “Q-Tip-Logger”, a simple logger that writes temperature and humidity to a SD card

Quite to my surprise the last post about building a data logger caused quite a discussion. As I mentioned, this is not concurring with professional solutions. It’s an alternative for people who like to build things or who are searching for ideas for projects when cooperating with schools and STEM classes. For someone who isn’t keen on learning something new, maybe a bit unusual and building something, this project is not interesting. For someone who has a sufficient collections care budget to buy professional loggers and send them in for calibration regularly it might be interesting anyway to compare the professional loggers with the DIY versions. For someone with a collections management budget next to zero who sees a chance to find sponsors for buying the parts if he or she initializes a cooperation project with a school group, it opens up the possibility to have an alternative to the cheap loggers from the hardware store and spark interest for collections care in young people at the same time.

The critical questions – which I really appreciated – made me switch the order of this guide: instead of starting with the main parts, the arduino and the data logger shield, I start with the very heart of the logger: the sensor.

The sensor is the part that decides how good or bad the logger is suited for its purpose. No matter how careful you are building your project, if the sensor is bad, the results will not be satisfying. On the other hand, good sensors have their price. Like often it’s up to you to weigh the pro’s and con’s and decide how good your sensor has to be for your purpose. What helped me a lot were the tests conducted by Robert Smith with the most used sensors in the hobbyist sector, the DHT11, DHT22 and SHT71: This comparison, together with his previous analysis of six DHT22 sensors made me use the DHT22/AM2302 which measures temperature and relative humidity for my projects.

Der DHT22, auch unter der Bezeichnung AM2302 zu finden.

The DHT22, also named AM2302.

Under real testing conditions it doesn’t reach the +/- 2% accuracy in measuring relative humidity mentioned in the data sheet on page 3 (which would have been a real surprise as only really high-prized loggers reach that accuracy in real life) but they bring good enough value for the money invested in my opinion. It can be found in electronic stores, in the adafruit store or on ebay and is easy to integrate into a project.

Sensors are generally not built for eternity. That’s why you have to send in the professional loggers for calibration. Fortunately, there is a method for testing loggers for accuracy by using saturated salt solutions described by Samantha Alderson and Rachael Perkins on the website of Connecting to Collections Care:
That’s what you should do with your homebrew loggers, too. You can even built a little testing device so you only have to expose the sensors to the test, not the whole logger.

Before you let your logger log the first time you should check it against a reliable professional device. In two occasions I found linear differences between my own logger and the other device (for example one was always 1% below the reference device), which I could correct in the software. Then it’s important like I already mentioned to check your sensor regularly. If the sensor is not reliable anymore you should replace it. That’s where the price of about 9 USD comes in handy.

So much for the sensor. The next part will be about the arduino and the logger shield.

Angela Kipp

More Posts on this topic:
A thing that can do things – Taking a look at the Arduino from the perspective of a collections specialist
Build Your Own Data Logger – Quick Start Guide
Build Your Own Data Logger – The Shield and the Wiring
Build Your Own Data Logger – The Software, Telling The Logger to Log

This post is also available in Russian translated by Helena Tomashevskaya.


Build Your Own Data Logger – Quick Start Guide

The first thing that can do things that actually DOES things for the TECHNOSEUM: A data logger that records the climate in a certain area of our museum.

The “Q-Tip-Logger”, a simple data logger that logs temperature and humidity to a SD card.

Like I promised before, here I show you how to build a data logger with the arduino. I want to do this step-by-step so you can follow the development and considerations that led to “our” logger. Many considerations had to do with the necessities of everyday museum work and so they might be of interest even if you don’t plan to build your own logger but want to hand the project over to your STEM group or your museum’s DIY club. For the impatient reader who has already did some building or raises a technology nerd, here comes the parts list, wiring scheme and code and some considerations for a good head start.

First of all: of course there are commercial products for this task and I don’t want to concur with those. But often I see that colleagues can’t afford the professinal solutions and therefore buy cheaper loggers that are not suitable for the task. Here, building it yourself can be an interesting alternative. Because it’s you who decides on which components to use you are the one who decides on the quality. And because you built it yourself you can maintain and repair it yourself.

Another remark: Wiring and code worked well in our setup but I can’t take responsibility for any damage that is done because you built your logger according to this guide.

What the device does:
This logger logs the current temperature in degrees Celsius and the relative humidity in percentage, then writes this data along with the date and the time as comma separated values to the file MyLogger.csv. This file can be imported into a spreadsheet software for further processing.

Needed Components:

  • 1 Arduino Uno
  • 1 Logging Recorder Shield with SD-Card reader and clock
  • 1 Temperature and humidity sensor (used here DHT 22 / AM 2302)
  • 1 Minibreadboard
  • 1 LED red
  • 1 LED green
  • 1 resistor 200 ohm
  • 1 resistor 100 ohm
  • 1 resistor 10 kiloohm
  • Breadboard cables
  • 1 SD-Card (because only small data is stored this is quite deliberate, I used a 2 GB card)
  • 1 power adapter (230 V AC to 9 V DC)
  • Case according to personal preferences

Wiring scheme:


Arduino Code:

The code is based mainly on examples provided with the libraries used. It might be that I have drawn certain solutions from the web and haven’t noted the source. Should someone discover his/her code used here, please drop me a line so I can give propper credit.

The Casing:
Unleash your creativity here. I used a cardboard box that was roughly the right size and cut openings for the cables and the SD Card into it with a cutter. The only really important thing is that you can operate the reset button on the shield. You can spare it in the casing, we used a q-tip with a broad plastic peg on one end so the reset button is pressed reliably.

By looking close you realize that this project was an emergency response, designed to be quickly available. So, there is room for a couple of improvements.
Instead of the mini breadboard it is logical to solder the components to the logger shield wihich has already a built in prototype board. The only thing to think about is that the sensor has to be outside of the casing because the outside climate should be monitored.
Then, the logger remains comparably numb. To know about your climate, you have to read the SD card or plug in your laptop ans see what the serial monitor tells you. A LCD shield would be a comfortable solution to this issue – and you could skip the LEDs and print the error messages on that LCD monitor.
Last but not least a LAN or WiFi shield could send the data to the web.

Have fun experimenting!
Angela Kipp

More posts on this topic:
A thing that can do things – Taking a look at the Arduino from the perspective of a collections specialist
Build Your Own Data Logger – Quick Start Guide
Build Your Own Data Logger – The Sensor, Heart of the Logger
Build Your Own Data Logger – The Shield and the Wiring
Build Your Own Data Logger – The Software, Telling The Logger to Log

This post is also available in Russian translated by Helena Tomashevskaya.


Awesome Picture of the Day: Box Construction

I work with a lot of awesome people. Of course I know that, but every now and then I even get a reminder. While tidying our packing space I found a piece of paper where one of our assistants has carefully constructed a custom box for one of our vacuum tubes. I couldn’t bring myself to just throw it away, I had to share it with all you packing nerds out there:

kiste roehren


Collection Storage Tips and Tricks #reorgtips

By Simon Lambert

We collections professionals are a creative bunch. Because of our great passion, we do not let limited resources get in the way of our commitment to preserve our collections and make them accessible to our community. Tonnes of innovative ideas on how to store different types of objects are developed in museums, libraries and archives all the time. Sadly, these amazing ideas are rarely shared with the rest of the world. In your collection storage area, there are ideas that could benefit others who may be facing similar challenges as you.

If you work with collections, at some point, you have found solutions that you or your colleagues are particularly proud of, no matter how simple and modest it may be. You have found new ways to optimize space, to re-use existing materials and to make sensible use of resources. This is your opportunity to share your ideas with colleagues around the world and to learn from theirs.

Send us one or two photos of your storage solution with a short descriptive sentence that tells us:

  • The type of object
  • The materials used or re-used to create your storage solution
  • Why this system is better than before

There are several options for sharing your photos:

  • On the RE-ORG International Facebook page:
  • On Twitter, Instagram or Facebook using the hashtag #reorgtips
  • By email : reorgstorage (at) gmail (dot) com

You have until 31 March 2016 to send us your submission. The results will be posted on a Tumblr blog and hosted on the ICCROM website.

Important notice: By sending your images, you acknowledge that they are yours and that you have the permission to send them, but that you’re willing share them under a Creative Commons Attribution-NonCommercial 4.0 International licence.

Here are some examples:
storing oars and spears
“We adapted a shelving unit to store our collection of oars and spears. We are able to use up less shelf space than before. We’ve gained more room for other objects.”
storing masks in used crate
“We re-used large wooden crates. We fixed secured chains on the crates to hang the masks. Now they are off the floor, so we will no longer risk stepping on them.”
pen storage
“We created compartments in a box with cardboard folded in zigzags. Now we can take each pen easily. Also, they don’t rub against each other.”

This is a RE-ORG International initiative launched by ICCROM in collaboration with the Canadian Conservation Institute (CCI).

This post is also available in Italian, translated by Marzia Loddo and in Russian translated by Helena Tomashevskaya.


Storage Solutions: A Home For The Barcode Scanner

Motivated by the experiences of Sheila Perry (See “If it moves, barcode it“) we are at the moment in the process of implementing barcoding in our collections management at the TECHNOSEUM. We need the scanners portable and protected from all the dangers the storage of a science museum hold. We bought standard aluminium cases in red, so we can easily spot them in the storage (the color already proved useful for clipboards and cutters). Then I handed the task to think of a good protection for scanner and accessoires to my student assistant, Linda. Here is the first beauty she created:


The material is a black polypropylene foam we use for creating mounts in exhibitions. Can you see she even carved little fingerholes so one can remove all the acccesoires like the USB stick easily? Definitely the best housed tool we have at the moment! Now, Linda entered serial production as we have some more scanners…


Birds in collections

One single bird can keep a registrar occupied for quite a while.(c) Hans Bleh

One single bird can keep a registrar occupied for quite a while.
(c) Hans Bleh

We talked about #registrardreams lately and I have a special one: I wish that only one time when my director shows up he finds me all dressed up in a clean working dress with a tidy desk and reporting “no serious incidents”. Alas, it never happened in the last 10 years. Whenever he meets me I’m for some reason or another all dirty with dust and/or machine oil and some colleagues swear that I once told him to hurry up because I had work to do. Be that as it may, I’m really glad he didn’t show up the other day when I was running up and down the storage, swinging a broom and shouting, all in the attempt to shoo a bird out of the hall. Not only did I behave like an idiot, I also looked like a contemporary artwork made out of spider webs, because the bird flew in the most distant corners that haven’t seen a broom in ages. Standing there looking up at the bird who constantly ignored the wide open gate I asked myself if I was the only collection manager on earth mocked by a bird and if I could do better.

Obviously, if you ask yourself the answers are limited, so I asked my colleagues from the RCAAM listserv. I received a whole bunch of enlightening hints and some fabulous stories about birds in collections. So, now I’m able to provide a step-by-step guide on how to handle birds in collections (if they are not dead and taxidermies, that is):

  1. Close all inside doors to the room the bird is in.
  2. Open all gates and windows that lead outside.
  3. Turn out the lights in the room, so the escapes appear lit for the bird.
  4. Clap hands, swing brooms, shout, behave like an idiot, do everything to shoo the bird towards the openings. The higher the open window/gate, the more likely the bird will get out.
  5. When the bird flies out, close all doors and windows.
  6. Search for holes that made it possible for the bird to come in and seal them (like Elizabeth Alberding put it: “Unless you can seal your building you are soon to be known as the “bird whisperer” of your museum.”)

Kara Vetter pointed out that there are sonic deterrence devices that can be installed near gates if that’s where they come in.

Anne T. Lane provided a true MacGyver story:

It's a good idea to inform the colleagues with a sign.

If you closed the door to a room because there is a bird inside it’s always a good idea to inform your colleagues

“We used to have this problem in a very open building in which I worked, where there was no way to close off between floors. They didn’t get into collections storage, but they could and did weaken and die in crevices around the windows high up on the mezzanine level. We caught one once by making a sort of fish landing net out of a wire hoop, a broom handle, and some light plastic sheeting. Oh, and blue tape. My registrar got up on a tall ladder under one of the rotundas and took wild swings at the bird – I was terrified that he’d swing himself right off the ladder onto the ceramic tile floor. But dang if he didn’t catch the poor thing. I took it outside and released it, and it flew off.”

No bird, but a bat mocked Janice Klein when she was a director in a small museum:

“The museum had a wide open plan and (other than the rest rooms) my office was the only space with a door, so when a little brown-nosed bat appeared late one afternoon when everyone else had gone home, that was where I had to chase him. Once I got him in the room he started panicking and echo-locating (and frankly, I also made some of those little squeaky noises, since I didn’t know anything about bats). I managed to trap him under a box top, but then didn’t know what to do next. It was freezing cold outside, which was probably why he found a way in to the nice warm building, so I didn’t want to just show him the door. I called one of my board members (it always pays to have a naturalist on the board who is willing to give wild creatures refuge in his basement) and while we were waiting, I finally realized why one of my motion detectors had gone off the night before.”

And Suzanne Quigley provided hands-on advice on what to do if woodpeckers are an issue:

Of course, there are birds in collections that are not an issue.

Of course, there are birds in collections that are not an issue.

“I am also in a rural area (a recent change of lifestyle). After living my whole life in big cities, there has been a lot to learn. But germane to this discussion, I have learned a bit about woodpeckers. This has become important as I live in a wood-clad house. Once we figured out what that horrible noise was, and saw what the little devils were doing to the side of the house – it was war. The battle was won in a rather bizarre, but funny way. No one notices (cause they aren’t looking for it), but scattered around the exterior in more or less discreet spots we have pinned (with clear pushpins) about a dozen 10-inch long shiny, strips of silver mylar ribbon (the kind used to wrap presents) made into curls over the edge of a pair of scissors – this was three years ago and no more woodpeckers!”

Well, I learned much more than I thought. Thanks to Kara Vetter, Anne Lane, Elizabeth Alberding, Julie Blood, Suzanne Quigley and Janice Klein for the responses and Maria O’Malley for convincing me to write a Registrar Trek post about it.

Oh, by the way, I finally managed to usher that little fellow out of my storage, securing my colleague on call a good night sleep. Chasing a bird is one thing but being called in the middle of the night because the burglar alarm went off is much, much worse.


Silica gel – it’s not magic, it’s physics

I sometimes run into wrong assumptions concerning how silica gel works. One is that silica gel in a display case keeps absorbing water until either the silica gel runs out of capacity or the the interior of the display case reaches 0% RH, which isn’t true.

Probably the most helpful thing to know is that the physics laws that govern how silica gel works are the same ones that govern the behaviour of paper, leather, wood, photographs and a great many other things found in museums. What happens when you put a piece of paper into a new environment? Depending on the condition that the paper was stored at before, it will lose or gain water until it reaches some kind of equlibrium with the new environment. If we now raise the RH, the paper will increase in water content until a new equilibrium is reached. Similarly, if we drop the RH, the paper will lose water until it reaches equilibrium with the new environment.

So this is all about an equilibrium between the water in the object and water vapor in the air around the object. One last little detail is that in all of these “dry” materials, the water is aDsorbed (with a “d”) and not aBsorbed (with a “b”) In aBsorption, the absorbate is held within the body of the absorbant. Fill a sponge with water and if was possible to cross-section the sponge without the water running out, we would see large and small holes filled with water. This is also a relatively large scale event. With aDsorption, individual molecules of adsorbate are stuck to molecule surfaces in the adsorbant like little refrigerator magnets. They stick on relatively easily and they come off relatively easily.

Adsorbed gases are considered to be in a condensed phase. More common condensed phases for water are liquid and ice. so what we have is a phase equilibrium between the adsorbed phase and the vapor phase.

Most likely we want to maintain some given RH so we’ll condition the silica gel to our desired relative humidity. We pour the silica gel into the display case and if the case condition and the silica gel are at equilibrium, then nothing happens. If they aren’t at equlibrium, then the silica gel, just like paper, will adsorb or desorb water until equilibrium is reached. This follows Le Chatelier’s principle which says that if a system is at equlibrium and we impose and change on it , (in out case, we might change the RH, temperature, or atmospheric pressure), then the equilibrium will shift in the direction that opposes the imposed change. So if the RH in the case goes down, then silica gel will desorb water and the RH will rise again (although not quite back to where it was.) If you want to put on your lab coat and safety glasses, then you can tell people that it’s obeying the first law of thermodynamics: the conservation of energy.

Douglas Nishimura
Image Permanence Institute
Rochester institute of Technology .

This post is also available in French translated by Aurore Tisserand.