Living in the UK with a varied climate it is difficult to predict the weather. It can be sunny one day and rainy the next making an umbrella an indispensable item. By designing and building an interactive umbrella this could improve this experience. As well as sheltering the user from the rain the umbrella would be brought to life through responding to raindrops. As raindrops hit the surface LEDs will light up in various patterns. To create a cheap and affordable solution the electric properties of water are used. The change in voltage potential completes the circuit allowing the LEDs to be triggered.

Project Brief:

Conventional and common umbrellas have one purpose of either sheltering you from the rain or protecting you from burning sunrays (not really an issue while living here!). Can you bring umbrellas to life by letting them light in different patterns through LEDs responding to rain drops? You can use pressure sensors to sense raindrops and light up the specific LEDs cluster. Or maybe you can use less expensive solutions understanding that water has high dielectric constant and hence resistance, which means it can change the voltage potential in a circuit such as our hand changing the flow of current in any electronic circuit.

Project Plan

To ensure the project was completed within the given amount of time several methods were employed. To begin, tasks were outlined and listed. Next, deadlines were set for each major task. This was all graphically represented in a gantt chart to make following the plan easier and to make it more clear how much progress had been made. Balancing time on this project and others was made easier by the use of a project plan. All tasks were distributed equally within the group, all work was done when the whole group was present to allow collaboration and to make sure the workload was distributed evenly.

Task List:

• Group meetings
• Research
• Brainstorm
• Decide on components
• Order components
• Storyboard
• Low-fi prototype
• Pseudo code
• Test code
• Test components
• Code
• Assemble components
• Test end product
• Design Blog
• Presentation
• Maker Manual

Research

There were three main areas where it was found that research and exploration was needed. These three areas were: umbrellas, sensing water and LED’s.

It became clear after reading the brief that an Arduino and electrical components were going to need to be attached to the umbrella. It was therefore necessary to find an umbrella that would allow this. It was found that there were two main types of umbrellas: classic umbrellas and foldable umbrellas. Initially it was desired to use a folding umbrella however, the folding arms would not allow the LED strips to be fitted. For this reason a classic umbrella would need to be found.

One of the main requirements of the project was to detect when rain was falling and hitting the umbrella. Different sensor types were researched. Research was done into using humidity sensors, water levels sensors and pressure sensors. These solutions would have been costly and complicated. However, after seeing a youtube video simply using the conductivity of water to allow current to flow it was decided that this would in fact be the simplest and most cost effective solution.

The group had only ever used single LEDs in circuits. Little was known about the use of LED strips. For this reason, extensive research was done to get a clearer understanding of how these could be used in the project. It was found that there are strips available that allow each individual LED on the strip to be addressed. This is done using shift registers which are inbuilt to the strip. There are various libraries available which make using these LED strips very simple.

Brainstorm

Based on the research it was known what tools were available to carry out the task. With this in mind, ideas and thoughts were organised into a mind map. From here it was possible to tackle the brief creatively. The strengths and weaknesses of each idea were assessed and evaluated then the process of idea generation was repeated over until a refined design idea was created.

 

Story Board

Hypothetical scenarios were created to mimic scenarios in which the umbrella would be used, this helped to create a conceptual model for the product. The storyboard was an illustrated representation of one of these real life scenarios.

This storyboard shows a user called Jasper who is happy because it is sunny. Suddenly, rain begins and he becomes sad. Thankfully, he has an LED umbrella which makes him feel happy again.

In the process of developing the concept, a graphical representation of the scenario was made to create a story. It layed a foundation for how the game would be used. The storyboard made it easier to share and explain the vision for the game. It was made up of squares with simple illustrations representing the storyline of the end-user. Four key scenes were chosen and put in order as a timeline. For each scene a small description was written to describe the actions and emotions. The first key scene represents a stressed person facing a challenge of having a lot of work to do. The second scene introduces a solution to the user, an email with a game. Throughout the third and fourth scene the user plays the game and the result is a happy, relaxed person, ready to do more work.

Low-Fi Prototype

Two low-fi prototypes were created out of paper. A cone shaped umbrella was created from two large sheets of paper while a smaller origami prototype was created out of smaller pieces of paper. For each of these LED’s were used to simulate the LED strips.

The low-fi prototypes allowed exploration of the conceptual model and the user interaction with the product.

 

Pseudo Code

Umbrella needs to respond to change in potential difference caused by water droplet.

Initialise LED pins.
Initialise analog sensor pins.
Initialise LED strips in an array of type Adafruit_NeoPixel.
Voltage is mapped from 0 to 1023.

Create variable (target) as the lower limit for the voltage reached when wires are in water.
Create variable to store sensor value for each pair of LED strips.

Compare sensor value to target.
If sensor value is greater than target call light show function.
Corresponding pair of LED strips will display light show.
Then switch off.

References:
Light show functions taken from Adafruit Neopixel library (open source).

Building Process

During the design process a concept was drawn up for how the presence of water could be detected. This concept was tested with a simple circuit. The test was successful so the concept was given the go ahead to be included in the design.

 

Next, it was crucial to test the LED strips. After some research on the internet it became clear that the simplest way to do this would be using the open source Neopixel library from Adafruit. As a part of this library Adafruit also provide example code for operating the LED’s. The example code was used to test if the strips worked.

 

 

Once it was determined that the strips were working they were cut using scissors into 0.5m lengths. Wires were then soldered onto each 0.5m section of the LED strips. The strips were again tested using example code. They didn’t light up. After some time it was determined that this was due to the wires being soldered onto the wrong end of the strips. The soldering had to be removed and done at the other end. The strips then worked as expected.

                             

Next, code was written and a small test circuit made to test again the functionality of the water sensing part of the umbrella. The serial monitor was used to check the input from the analog pin when the wires were connected via the water. An if statement was then written to activate the LED lights when a certain analog signal was read.

 

 

 

With the prototype working using breadboards and an Arduino Uno the process of executing the design with the umbrella and using the Arduino Nano could begin. The Arduino Nano had to be tested first. Some difficulty was had with getting the Arduino Nano to work since a non-genuine one was being used. Once a driver had been installed allowing the computer to communicate with the board the software could be uploaded. The same code as was previously tested was then tested on the Arduino Nano board.

Small holes were poked through the top of the umbrella fabric to allow the wires of the LED strips to pass through. The strips were then stuck onto the umbrella, while it was fully open, using double sided sticky tape.

The wires were then soldered onto the Arduino in situ. Additionally, the battery wires were soldered onto the board as well as wires to connect to the breadboard and the water detector wires. Once the wires were soldered onto the board they could be attached to the umbrella pole. The breadboard was also attached to the pole. This was all done using electrical tape.

Holes were also poked for the water sensor pins. These were poked through and stuck down using hot glue from the inside.

Finally, the code was uploaded to the board and the umbrella was tested.

 

Discussion of Testing Conducted

Initial testing consisted of constructing example circuits which could potentially be used in our high fidelity prototype. It was essential to perform many tests using water as the stimulus to complete the circuit and verify that this method would work, which it did as it produced a voltage above a logical high.

Furthermore, the LED strips were tested several times both before and after they had been cut into sections and soldered. When the cut pieces were tested it was found that they no longer switched on; the solution to this was to re-solder them in the opposite direction. After this they worked as before.

Extensive testing was conducted on the final product to ensure optimal performance in an everyday scenario.

After the umbrella was completed, it was brought outside in rainy conditions to confirm the LEDs would respond to the stimuli as expected. The LED strips were able to light up as the rain fell on the exposed ends of the jumper wires, positioned on the canopy of the umbrella.

One of the main problems which was encountered was that the LED strips did not always switch off as water would often remain on the wires due to the water resistant canopy rather than drying or being absorbed by the fabric. This is something to overcome in future iterations of the product through further testing.

Maker Manual

Build your own rain responsive umbrella! Using an Arduino Nano board and LED strips you can program your umbrella to display beautiful light shows in response to raindrops falling on it. Just follow these instructions and then you will be ready to enjoy the rain.

Parts

• Arduino Nano microcontroller board
• 2×30 Breadboard
• Male-to-male jumper wires
• A stick umbrella
• 4m of LED strips
• Soldering kit
• Glue gun
• Double sided tape
• 9V Battery

Instructions

Step 1 – Cut up the 4 metres of LED strips into 8 sections of 0.5 metres.

Step 2 – Solder the end of each LED strip to the ends of 3 jumper wires. Make sure to check for arrows on the LED strips to check which way the current flows through them.

Step 3 – Fill the ends of the open LED strips with hot glue using the glue gun.

Step 4 – Attach the Arduino Nano and the breadboard on the inside of the umbrella to the top of the umbrella stick.

Step 5 – Cut small holes for the wires at the top of the umbrella. Pull the wires from the LED strips through the hole to access them from the inside.

Step 6 – Stick the LED strips onto the outside of the umbrella along the metal frame going down the sides using double sided tape.

Step 7 – Put the wires for ground and 5V coming from the LED strips into the negative and positive sides of the breadboard.

Step 8 – Put the pin wires from the LED strips into the pins 2-9.

Step 9 – Put four wires into the analog pins 1-4.

Step 10 – Put four wires into the positive side of the breadboard.

Step 11 – Create four pairs made out of one wire connected to an analog pin and one wire connected to the positive side of the breadboard. The end of these wires goes on the outside of the umbrella to sense the water.

Step 12 – Use glue to attach the wires to the umbrella so that they will not move out of position.

Step 13 – Connect the Arduino Nano to your computer via USB cable and upload the code provided.

Step 14 – Disconnect your computer and attach the battery to the circuit.

Step 15 – Your umbrella is now ready to take out into the rain and enjoy!

 

Circuit Diagram

 

Code

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif

#define PIN2 2
#define PIN3 3
#define PIN4 4
#define PIN5 5
#define PIN6 6
#define PIN7 7
#define PIN8 8
#define PIN9 9

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:

Adafruit_NeoPixel strip [8];

int sensorPin1 = A1;
int sensorPin2 = A2;
int sensorPin3 = A3;
int sensorPin4 = A4;
int target = 1010;

 

void setup() {

 for (int i = 0; i < 8; i++) {
   strip[i] = Adafruit_NeoPixel(30, i + 2 , NEO_GRB + NEO_KHZ800);
   strip[i].begin();
   strip[i].show();
 }

}//end void setup

 

void loop() {

 int sensorValue1 = analogRead(sensorPin1);
 int sensorValue2 = analogRead(sensorPin2);
 int sensorValue3 = analogRead(sensorPin3);
 int sensorValue4 = analogRead(sensorPin4);

 Serial.begin(9600);
 Serial.println(sensorValue2);

 if (sensorValue1 >= target) {
   theaterChaseRainbow(50, 0, 1);
 }//end if

 if (sensorValue2 >= target) {
   theaterChaseRainbow(50, 2, 3);
 }//end if

 if (sensorValue3 >= target) {
   theaterChaseRainbow(50, 4, 5);
 }//end if

 if (sensorValue4 >= target) {
   theaterChaseRainbow(50, 6, 7);
 }//end if

 delay(100);

}//end void loop

 

void theaterChaseRainbow(uint8_t wait, int stripNum1, int stripNum2 ) {

 for (int j = 0; j < 256; j++) {   // cycle all 256 colors in the wheel
   for (int q = 0; q < 3; q++) {
for (uint16_t i = 0; i < strip[stripNum1].numPixels(); i = i + 3) {

strip[stripNum1].setPixelColor(i + q, Wheel( (i + j) % 255, stripNum1)); //turn every third pixel on
strip[stripNum2].setPixelColor(i + q, Wheel( (i + j) % 255, stripNum2));
}

     strip[stripNum1].show();
     strip[stripNum2].show();

     delay(wait);

     for (uint16_t i = 0; i < strip[stripNum1].numPixels(); i = i + 3) {
      strip[stripNum1].setPixelColor(i + q, 0);      //turn every third pixel off
      strip[stripNum2].setPixelColor(i + q, 0);      //turn every third pixel off
     }
   }
 }

 strip[stripNum1].show();
 strip[stripNum2].show();
}// endtheaterChaseRainbow

// Input a value 0 to 255 to get a color value.
// The colours are a transition r – g – b – back to r.
uint32_t Wheel(byte WheelPos, int stripNum) {

 WheelPos = 255 – WheelPos;

 if (WheelPos < 85) {
   return strip[stripNum].Color(255 – WheelPos * 3, 0, WheelPos * 3);
 }

 if (WheelPos < 170) {
  WheelPos -= 85;
   return strip[stripNum].Color(0, WheelPos * 3, 255 – WheelPos * 3);
 }

 WheelPos -= 170;
 return strip[stripNum].Color(WheelPos * 3, 255 – WheelPos * 3, 0);
}//end Wheel