Library Chair

From ESE205 Wiki
Jump to navigation Jump to search


It's a Wednesday night. You're sitting in your room watching Netflix, putting off studying for your exam next week. You're cozy in bed, and it's cold and dark outside, plus your suite-mate just said he's ordering Domino's and there might be a slice or two left over for you. Every fiber of your being is willing you to stay home, eat, and watch TV, but that nagging voice in the back of your head tells you that you're a Wash U student damnit, and you'd better take this exam seriously! So you muster up some energy and get the kid on your floor who is in the class with you to walk to the library and study for a bit. When you guys get there, though, you see that every seat in the library is taken! ARGH!!

Few things are more annoying than when you decide to actually go study but then can't because there isn't an open spot for you in the library. Enter the Library Chair. In simple terms the Library Chair system consists of an interactive chair and a web interface. The chair can detect when someone is sitting in it, and this information is then relayed (via a few arduinos and a raspberry pi) to a website which displays a map of all the chairs in the library and which ones are occupied. You can check this website from the safety and comfort of your own room; no more cold walks to the library that end up being futile!

For more specific information on how the system operates, please look at the "Design and Solutions" section of this wiki.

Library Chair Log

Team Members

Nick Blenko
Tom Howe
Josh Zucker
Our wonderful TA, Mo Wu
And our adviser, Professor Morley


Our group's main objective was to create an interface that library goers could use to see which seats in the library are available, and which are occupied. This interface is dependent on voltage data obtained from a circuit hooked up to an arduino and affixed to the bottom of a library chair. When a human body moves close to the circuit, i.e when someone sits down in the chair, the output voltage changes and chair occupancy can thus be determined. This circuit then communicates occupancy and location data to another arduino connected to a raspberry pi. The raspberry pi will in turn communicate this data to a web server. We aim for the circuit/arduino device to be accurate, low energy, and completely powered by solar panels.

As individuals we are simultaneously working on a few different smaller goals. These include: finalizing the circuit that will detect when someone is sitting in the chair, figuring out how to communicate effectively between the arduinos and how to generate the wave function necessary for the circuit to operate from an arduino, integrating a solar power source into the circuit, communicating data from the raspberry pi to a web server, and designing and implementing an aesthetically pleasing web interface.


  • Learning how to use the TI microcontrollers. This proved to be too difficult, so we adapted and used arduinos instead.
  • Rebuilding the circuit after someone burned it in the lab
  • Getting accurate current and voltage readings from solar panels/batteries
  • Needing to find a new ADC solution after realizing the built in arduino ADC was not powerful enough

Gantt Chart

An outline for the breakdown of duties and the timeline of the library chair project.


  • Chair: Cost Varies - (donated by Professor Morley)
  • Raspberry Pi: $35.00

  • Solar cells: $8.69

  • Resistors/Capacitors/Diodes: (provided by school)
  • Wire: (provided by school)
  • Web Server: $12/Year

  • Bluehost Account $3.99/Month

  • RF Link Receiver (433 MHz) $4.95

  • RF Link Transmitter (433 MHz) $3.95

  • 2x Arduino Uno - one provided by school, one bought at link below for $27.95

  • External 16 bit ADC converter 14.95

  • Rechargeable Batteries $19.98

Total: $139.44 (Total assumes 1 year subscription to web server and 3 month subscription to bluehost account)

Group Presentation

Link to the presentation

Design and Solutions

Module #1: Detect whether someone is in the chair

1.1 Construct RC circuit that outputs variable voltage depending on total capacitance

We first have a regular RC circuit with one metal plate acting as a parallel plate capacitor, where the other plate is effectively the rest of the universe. When a human body comes close to the circuit, its electric field increases the capacitance of this plate. This increased capacitance increases the time constant of the RC circuit, which means that in the same interval of time this altered circuit does not output a voltage as close to its peak voltage as it did before. In other words, when a human body is close to the circuit, it outputs a lower voltage.

Figure 1.1 - The circuit used to detect occupancy based on peak voltage in the circuit.

Figure 1.1 - The circuit used to detect occupancy based on peak voltage in the circuit.

1.2 Manage voltage flow going into circuit

After prototyping on the NI Elvis, we determined that the best form of input voltage to the circuit would be a 5V square wave with a frequency of around 800kHz and a duty cycle of 50%. (For help prototyping on an NI Elvis board see our tutorial Since a square wave is always either ‘on’ or ‘off’, this input means that the capacitor is always either charging or discharging, which lets us get more consistent output voltage readings from the circuit. We determined the optimal frequency through trial and error and striking a balance between signal magnitude and signal noise: using a higher input frequency led to a noisier output voltage signal, but using a lower frequency led to less of a change in voltage.

800kHz is an extremely high frequency, though, considering that the arduino uno cpu has a clock speed of 16MHz, so we searched for a library that could be of use and found this: . However, we struggled to implement it correctly, and further testing showed that we would only need a frequency of around 50-70 kHz.

We used pulse width modulation on the arduino's digital pin number 6 (as seen in Figure 1.1) to supply this square wave. The default frequency for pulse width modulation on digital pin 6 is 976.56 Hz, and the default voltage is 5V. In order to increase this frequency, we reduced the PWM prescaler value on the TCCR0B timer register to 1 from a default of 64, thereby increasing the frequency by a factor of 64. (For reference see:

Here is the code we used to generate the 5V 63kHz square wave input:

void setup() {
pinMode(6,OUTPUT); //initializes function generator pin
TCCR0B = TCCR0B & B11111000 | B00000001; // sets timer 0 divisor to 1, freq=62.5kHz

void loop() {
analogWrite(6,128); //sets up square wave with duty=50%

1.3 Measure voltage flow exiting circuit, and analyze to determine occupancy

We initially tried to use the arduino's built in 10-bit analog-to-digital converter to detect changes in output voltage from the circuit. Using the minimum reference voltage of 1.1V and 1023 'steps' of specificity (2^10 = 1024), gave us a step size of ~1mV. Since we were dealing with changes in voltage (voltage when chair is occupied vs voltage when chair is vacant) on the order of microvolts, we needed another solution. We found a compatible 16-bit external ADC converter ( and wired it up as shown in Figure 1.2. This converter has about 65,000 'steps' of specificity (2^16~65000), enabling detection of voltage changes as small as 0.0002V. We wired in a differential connection to the external converter, which is more favorable than a single-ended connection when trying to reduce noise. In order to accurately interpret this very noisy data, we had to implement a multi-tiered rolling average filter to smooth the data. The exact voltage cutoff values signifying either occupancy or vacancy are dependent on the composition and the environment of the chair, and as such need to be tested for and updated whenever the circuit is affixed to a new chair or the chair is moved.

The code to read in voltages using the external converter and then determine vacancy/occupancy using multi-tiered filters can be found here:

Figure 1.2 - The external 16-bit analog-to-digital converter used to take voltage readings from the circuit.

Figure 1.2 - The external 16-bit analog-to-digital converter used to take voltage readings from the circuit

1.4 Integrate arduino and circuit and attach to chair

We used a solderless breadboard to connect the Arduino to the RC circuit, the external ADC converter, and an RF transmitter. We made these connections as shown in Figure 1.1, Figure 1.2, and Figure 2.1. The circuit-arduino system is shown in Figure 1.3. In order to improve the aesthetics of the system, we designed and 3D printed a case (Figure 1.4) to cover up all the wires and circuitry. We then screwed this case to the underside of the chair, and put the metal plate from the RC circuit inside the stuffing of the chair in order to get readings most effectively.

The circuit/arduino system

A rendering of the case for the Arduino and circuit.

Link to Thingiverse with Case CAD files

Figure 1.3 The circuit/arduino system. Figure 1.4: A rendering of the case for the Arduino and circuit.

1.5 Power the Arduino/circuit with solar power and batteries

In order to power the Arduino our plan was to use a system of batteries and solar panels. The batteries are the main source of power to the Arduino and the solar panels recharge the batteries.

We ended up using 6 1.2V 2400mAh batteries (, wired in series to create a 7.2V 2400mAh system (the recommended input voltage for the arduino uno is 7V-12V). We also connected 7 680 Ohm resistors wired in parallel to avoid overheating and to regulate the supply of current to the arduino. When testing with the NI Elvis and an ammeter the system was drawing around 70mA of current but according to information from various datasheets, we had estimated that powering the ADC converter, the RF transmitter, and the square wave for the circuit would draw around 100mA of current. To be safe, we aimed to supply around 90mA of current.

We attached 5 4V 80mA solar panels, wired in parallel to create a 4V 400mA system, to the batteries at the junction between the batteries and Arduino. The positive end of the solar panels was wired with a diode to prevent current from the batteries flowing the wrong way into the panels. The way the panels were wired they would provide energy to either the circuit, if it needed it, or to recharging the batteries.

There were two main issues with the power. The first issue was the fact that the voltage supplied from the batteries was 7.2V while the power supply we had been using to run tests on the arduino had been producing 9V. Although the Arduino functions fine on 7.2V, testing indicated that the output ADC voltage values we were getting from the circuit were different when running on 7.2V Since there was no way to directly check the values coming out of the ADC, we struggled to establish the appropriate threshold values to discern when the chair was occupied or not.

The second issue with the power was the fact that the solar panels that we got were not powerful enough to recharge the batteries in a timely manner. The current supplied by the panels meant that the batteries would end up draining faster than they could be recharged. In the future more powerful solar panels could prevent this from happening.

The system of batteries and Solar Panels used to power the Arduino. Figure 1.5 - The battery and solar panel system used to power the Arduino.

Module #2: Relay occupancy data to Arduino in format for easy processing on Pi

2.1 use RF communication to send data from one Arduino to another

In order to relay data between the arduino on the bottom of the chair and the arduino attached to the raspberry pi we purchased a pair of 433Hz transmitter/receiver modules ( and We encoded transmission and reception using the virtualWire library ( We started out using sample code from , and for our final code borrowed from as well. We wired up the modules with help from . The final code we used to transmit and receive occupancy data can be found here on page 3. We designed a protocol whereby the chair number and the occupancy data relating to that chair can be sent in 1 byte: if the chair is unoccupied we transmit the chair number, and if the chair is occupied we transmit the chair number plus 128.

The wiring of the receiver to the arduino can be seen in Figure 2.2 (and also at

Figure 2.1 - The RF Transmitter used to send data from the Arduino that detects occupancy to the Arduino connected to the Raspberry Pi.

Figure 2.1 - The RF Transmitter used to send data from the Arduino on the chair to the Arduino connected to the Raspberry Pi

Exhibit B - the wiring of the receiver module

Figure 2.2 - the wiring of the receiver module

2.2 communicate from the Arduino to the raspberry pi

Communication from the 'receiver' arduino to the raspberry pi was done through a serial connection using code from .

Receiver python code on raspberry pi:

import serial

ser = serial.Serial('/dev/ttyACM0',9600) s = [0] while True: read_serial=ser.readline() s[0] = str(int (ser.readline(),16)) ]

Transmitter code on arduino

void setup() { Serial.begin(9600); //Starts serial communication }

void loop() { a++; // a value increase every loop sprintf(dataString,"%02X",a); // convert a value to hexa Serial.println(dataString); // send the data delay(1000); // give the loop some break }

Module #3: Use data input to create user-friendly web interface

3.1 Acquiring a domain

The first step was acquiring the domain. We chose for our domain. In order to directly upload HTML code, we needed a subdomain so we could directly post the code to have the output displayed on the website. To accomplish this, we created the subdomain We then uploaded the html code (link to code), and the website, which was static at this point, was displayed.

3.2 Coding using HTML

HTML was a completely new language for us, so we used tutorials by ( to get a general understanding. After tinkering around with creating boxes with text and uploading images, we realized it may be difficult to completely build a website from scratch.

After researching online ways to easily create a clean user interface, we found bootstrap templates. Bootstrap is a free resource, that provides templates with accompanying HTML code. We used a bootstrap template to shape our website. This is the link to the bootstrap template we used:

We stripped away all unnecessary parts of the bootstrap code, and then replaced their color scheme and images to create a map of our prototype library layout. To do so we also added a box image for the “front desk”, replaced their icon with our chair images, changed the text, and added a front door to the library. We then created two different text boxes, one that was green and read “vacant” and another that was red and read “occupied”. The occupied box was hidden for our static site at this point. This is the code for the final interface (insert code), and this is the final webpage display (

3.3 Making a dynamic webpage

We found the easiest way to have the Pi communicate with the online server was to use an online database as the middleman. We used a service called Firebase, where we could type code to differentiate the different state of each chair - when it received a signal indicating the chair was seated in, the database would change the chair with the matching ID to have a value “true”, and the website would read “Occupied” in a red box above the chair. If it received information saying otherwise, the database would set the value to “false”, and the website would read “Vacant” in green box above the chair.

In order to have the database change the website, it first needed an input. To do so, we created a python program that could pull in input from the arduino. The arduino would send in a number which corresponded to a specific chair ID, and the state of the chair. Our program took in that number, and had the Pi transmit the information to the database by opening a corresponding URL that altered the database. The URLs had the following format:* chair ID */* chair state*. The astrics represent where the chair specific

A shortcoming of our project was that anyone who typed in the specific URL could access the database and alter its information. We didn’t see this as too much as a problem, though, because each chair’s state was rewritten with the correct information every few seconds.


We successfully demoed our project and accomplished the most important goals that we set for ourselves. The circuit/Arduino accurately detected when people were sitting in the chair. The arduino on the chair communicated with the arduino connected to the pi, and the raspberry pi accurately and dynamically updated an attractive web interface.

There was a lag of 15-30 seconds between the occupancy status of the chair changing and that change being registered on the website due to the rolling average filter on the arduino taking time to register the change in voltage. We feel that the lag is not an issue because in a real-world application of our project

given that someone looking on the website to see if there are any open chairs in the library will take more than 30 seconds to get to the library in the first place.

The first goal that our group failed to accomplish was the use of solar power/batteries to power the circuit. We got the solar panels and batteries hooked up and were able to run the Arduino on the power from the batteries and panels but the values that we were getting from the proximity detector circuit were different as the voltage feeding into the Arduino was different than when it was plugged in. Given more time we would have been able to find the correct range of voltages for the Arduino to be run off of battery power, but as we could not have the Arduino connected to the computer to give us a display of the voltage values while being powered off of the batteries it would have taken a long time to find the correct window.

The other goal that we were not able to accomplish was using the TI board provided by Professor Morley.

Other than the lag and power source there were no issues with the chair, and other than the power source and TI board we met all of our goals. The circuit consistently was able to detect proximity, the Arduino was consistently able to tell what voltages represented occupation and non-occupation and transmit that to the Arduino connected to the Raspberry Pi, the Pi was consistently able to update the server which in turn was constantly able to update the website. Although there were a lot of independent parts in the project, they all came together and worked to produce a consistent working chair.


Our final poster on display at the demo.