Wella: Crowd-Sourced Real-Time Weather Mapping

Smart Umbrella
Junhyoung Lee Michael Wymore Sangmin Lee Cesar Tirado
University of Washington University of Washington University of Washington University of Washington
Seattle WA USA Seattle WA USA Seattle WA USA Seattle WA USA
+1-206-786-8108 +1-206-678-7805 +1-425-501-7870 +1-954-254-5970
jhlee25@uw.edu mwymor@uw.edu slee1998@uw.edu tiraces@uw.edu

ABSTRACT

The Wella, an innovative smart umbrella,

integrates sensors and Bluetooth technology to
provide users with real-time weather insights.
Comprising two rain sensors, a light sensor, and a
temperature and humidity sensor, along with the
powerful SparkFun Thing Plus - ESP32
WROOM (USB-C), the Wella ensures accurate
and comprehensive weather data collection. Once
activated and connected to the user's smartphone
via Bluetooth, the Wella app provides the user
with helpful real-time weather information.

Keywords
Smart Umbrella, IoT, Real-time Weather
Monitoring, Google Map API, Bluetooth
Connectivity, Dynamic Mapping
Figure 1. Photo of Wella Final Product

1. INTRODUCTION
The Wella project represents a new approach to
weather monitoring, introducing a smart umbrella
equipped with sensors and an accompanying app
that provides users with real-time,
location-specific weather information. In contrast
to conventional weather tracking apps relying on
predictive algorithms for overall city forecasts,
Wella focuses on enhancing the user experience
by offering precise, on-the-spot data. This paper
delves into the key motivation behind the Wella
project, detailing its significance.
Traditional weather apps rely on predictive
algorithms that forecast general weather patterns
for entire cities. However, these predictions may
not accurately reflect the microclimates that can
vary significantly within a city. The Wella project
recognizes this limitation and aims to provide a
more localized and accurate solution for users
who seek precise weather information tailored to
their immediate surroundings.
In this paper, we will explore the components and
functionality of the Wella system, comprising two
rain sensors, a light sensor, a temperature and
humidity sensor, and the ESP32 Thing Plus C. By
connecting to the user's smartphone via
Bluetooth, Wella offers an intuitive app interface
that allows users to access real-time weather data.
The app not only presents dynamic mapping and
visual displays of the collected sensor data but
also includes a feature to monitor the battery life
of the smart umbrella. Additionally, we will
discuss how the Wella app enables users to view
and share weather conditions with other Wella
Figure 2. High-level architecture for Wella’s
users, fostering a community-driven approach to
tech stack.
weather tracking.

2. RELATED WORK
3.2 Theory of Operation
The Application Fishbrain provides a dynamic
The high-level architecture of the Wella system
map that indicates to its users exactly where other
starts with the ESP-32 microcontroller which
user’s have caught fish recently and how many
takes measurements from various sensors
fish were caught there. This application gave the
including a DHT22 Temperature/Humidity
Wella team inspiration on how to display its
sensor, LilyPad light sensor, and LM393 Rain
information on the application. The idea of
Drop Sensors. The circuit is powered by a 3.7V
crowdsourcing the data from the users for the
Lithium Ion Battery and all of the sensors feed
good of the users was done in a visually
into different GPIO pins on the ESP-32. The
satisfying way on the Fishbrain App that Wella
battery, microcontroller, and DHT22 are all
wanted to replicate. Wella uses the Google Maps
housed within a custom 3D-printed handle with
API in order to also create a dynamic map so that
wires routed up inside the umbrella pole to the
its users can click on a certain location that they
rest of the sensors that are mounted on the
would like to have information about similar to
canopy of the umbrella. Using BLE the
how Fishbrain does it.
microcontroller communicates to the phone that
the user is holding and the phone uses
3. TECHNICAL DETAILS cellular/WIFI to send data to the Wella database.

3.1 Overview
The Wella Umbrella uses multiple sensors to
collect data about the weather surrounding the
user. It then uses Bluetooth Low Energy (BLE)
to send this data to an Android app which would
be on the phone that the user is carrying. This
data is then stored on the Wella database and
using this crowd-sourced information real-time
weather data can be seen on the Wella app for
users who click on other Wella user’s pins.
3.3 Implementation Details
3.3.1 Hardware
A custom 3-D printed handle was designed to
house the bulk of the components and also act as
a way to feed the wires up through the umbrella
pole. A picture of the interior design of the
handle can be seen in Figure 3.
Figure 3. Three-dimensional model of the
customized handle.
Figure 4. Schematic of PCB.
Figure 5. Three-dimensional model of PCB,
with components.
The reasoning behind the PCB was to reduce the
amount of power and ground wires needed for
each sensor. The PCB would act as a central hub
for all the wires. Utilizing the pinouts as shown in
Figure 5, sensors would have easier connectivity,
which would make assembly of the Wella
simpler. Since the PCB arrived later than
expected the final product did not include the
PCB in its design. That being said, the PCB was
tested separately and worked with the sensors
being implemented. Thus if the PCB arrived on
time, its implementation would’ve led to an
overall same result.
Figure 6. (From top to bottom) DHT22,
LilyPad Light sensor, Rain sensor.
3.3.2 Microcontroller Firmware
The most important functionality that the Wella
implements is the sensing of weather data and
then the sending of that data to an Android
Application using Bluetooth Low Energy (BLE).
A custom protocol was implemented breaking the
necessary data into three separate packets. The
first of these packets contained the data for the
battery level of the device, the second contained
temperature and humidity readings, and the last
contained light sensor and rain sensor data. The
data was encoded as strings and ID tags were at
the beginning of each packet. Exact
implementation details can be seen in Code
Block 1. The ESP-32 Microcontroller takes
measurements and sends packets every two
seconds. On the App side, the phone is waiting
for this data and it is decoded and updates the UI
on the application in real-time.
3.3.3 Android App Software
The Wella Application was developed for
Android phones and has 5 primary features. The
first most fundamental feature of the Application
is that it collects data sent to it from the Wella
device and uploads it to a Firestore Database.
The application then queries the database for the
last 10 minutes of data. The second feature of the
Application uses the Google Maps API in order
to create dynamic mapping which updates in real
time based on the query returned from the
database. The third feature of the application is
that it provides a live updating battery life
indicator to show you the remaining battery of
the device. A fourth feature of the application is
the ability to display weather information based
on the last selected pin by the user, if the user
clicks on a pin that another Wella user left, the
app will display the weather information for that
pin. The last feature that the Wella Application
provides is notifications when the user gets out of
the Bluetooth range of the device or if the device
disconnects. These notifications will occur even
if the phone is locked and the screen is off.
Figure 7. Notification from the App
informing users that they have disconnected
from Wella.
4. EVALUATION AND RESULTS
Testing of the Wella’s results and performance
was cut short due to a lack of time, however,
some metrics were gathered. Firstly, the weather
information displayed on the app was compared
against the weather information from other
weather apps such as Apple Weather. Our
temperature data fell within ±5° F during brief
testing if the DHT22 sensor was not obstructed.
Humidity was within ±25% of what was reported
from other weather apps, while this margin isn’t
great we believe this is due to humidity varying
heavily depending on where the user is exactly
located. Finally, after some unofficial theoretical
calculations, the battery life for the Wella is
expected to last ~22 hours and charge from 0-100
within ~2 hours.
After conducting some user beta-testing and
observing that the pins worked both with
theoretical “fake” data inserted into the database
as well as live data from users walking around
with a Wella device. One challenge encountered
was the reliance on having an accurate Google
Maps Pin which requires a good service signal. It
was discovered during testing that as long as a
secure internet connection was established either
through WIFI or Cellular the pins would
accurately drop in the user’s location.
5. DISCUSSION
The Wella project has shown promising results in
providing users with real-time, location-specific
weather information through its smart umbrella
and accompanying app. Initial user feedback and
testing have indicated that the integration of rain
sensors, a light sensor, temperature, and humidity
sensors, along with the SparkFun Thing Plus -
ESP32 WROOM (USB-C), contributes to
accurate and reliable weather data collection.
Figure 9. Wella Android Application UI
Showing battery life and weather information.
The dynamic mapping and visual displays in the
app enhance the overall user experience, as well
allowing users to share and view weather
conditions with others in the Wella network. To
further enhance the solution, future work will
focus on refining the sensor technology for even
greater accuracy and expanding the app's
features. Integration with additional
environmental sensors, such as wind speed or UV
index, along with a way to detect snow, could
provide users with a more comprehensive
understanding of their surroundings. Further user
interface improvements and the incorporation of
machine learning algorithms for more precise
weather predictions represent potential avenues
for development.
The technology behind Wella extends beyond its
application in smart umbrellas. The sensor suite
and connectivity capabilities have broader
implications in fields such as agriculture,
environmental monitoring, and urban planning.
The same technology could be adapted to create
smart devices for monitoring soil conditions, air
quality, or even building health, opening doors to
diverse applications in various industries.
Throughout the development of Wella, insights
have been gained into the importance of
user-centric design in the realm of IoT devices.
The need for seamless integration and
user-friendly interfaces has been emphasized,
ensuring that technology serves the end user
effectively and intuitively. Additionally, the
collaborative aspect of sharing weather
conditions among users has highlighted the
potential for community-driven solutions in the
IoT space.
In future iterations, a focus on choosing more
appropriate sensors should be considered as the
current rain and light sensors, while they do
work, are not ideal for the type of information
that is required for fully informative weather
information. For example, the rain sensor
currently is only able to distinguish between
being wet or not. This binary data is functional
but a more analog signal that could accurately
give information about how hard the sensor was
being hit with rain would be much more useful.
Similarly, the light sensor chosen only uses
lumens to measure how bright it is relative to the
Wella. A light sensor with the capability of
detecting UV levels would be an interesting
consideration in order to give more accurate
information about the intensity of the sunlight,
which is what the umbrella was originally
intended to do.
6. CONCLUSION
In conclusion, the Wella project represents an
attempt to redefine how individuals engage with
weather information, offering an innovative
solution through its smart umbrella and
accompanying app. The integration of advanced
sensors, community-driven features, and
real-time data access has demonstrated the
effectiveness of the Wella system in providing
accurate, location-specific weather insights.
If the project were to evolve, there is a clear path
forward for further refinement and enhancement.
The ongoing focus on sensor technology, user
interface improvements, and expanded features
will ensure that Wella continues to meet the
ever-changing needs of users seeking reliable and
immediate weather information. The potential
applications of this technology extend beyond the
realm of personal weather tracking, promising
diverse uses in fields like agriculture,
environmental monitoring, and urban planning.
In summary, Wella not only provides a practical
solution to the challenge of obtaining accurate,
location-specific weather data but also sets the
stage for broader applications in sensor
technology and IoT. The journey of Wella serves
as a testament to the potential of combining
everyday objects with cutting-edge technology,
ultimately empowering individuals with timely
and relevant information for their daily lives.
7. REFERENCES
[1] Android BLE Tutorial: ESP32-S3 to Android Bluetooth
Communication: 2023.
https://docs.google.com/presentation/d/1BGj5Wa_vfsnBpk16
KsZyaw0EJB-TvAKMl6VdsYFTGdM/edit#slide=id.p.
Accessed: 2023-12-11.
[2] Arduino - Rain Sensor | Arduino getting started:
https://arduinogetstarted.com/tutorials/arduino-rain-sensor.
[3] Arduino - Rain Sensor | Arduino getting started:
https://arduinogetstarted.com/tutorials/arduino-rain-sensor.
[4] Maps SDK for Android Quickstart:
https://developers.google.com/maps/documentation/android-
sdk/start.
 Appendix

String data_string = "999 ";

String temp_string = String(f, 2);
String hum_string = String(h, 2);
data_string = data_string + temp_string + " " + hum_string;
uint8_t packet[CHARACTERISTIC_SIZE]; // initialize packet data array
data_string.getBytes(packet, CHARACTERISTIC_SIZE);
txCharacteristic.writeValue(packet, CHARACTERISTIC_SIZE);
Code Block 1. Firmware code illustrating the encoding of the sensor data to be sent to the App.

if (check_data.substring(0, 4).equals("111 ")) {

String solar = check_data.substring(4, 5);
TextView textView3 = (TextView) findViewById(R.id.SolarNum);
if (solar.equals("1")) {
solarText = "Dark";
} else if (solar.equals("2")) {
solarText = "Dim";
} else if (solar.equals("3")) {
solarText = "Nomal";
} else if (solar.equals("4")) {
solarText = "Bright";
} else if (solar.equals("5")) {
solarText = "Very Bright";
}
textView3.setText(solarText);
}
Code Block 2. Android App Decoding Solar Sensor Data to Update UI.
private final BroadcastReceiver bluetoothStateReceiver = new
BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (BluetoothDevice.ACTION_ACL_DISCONNECTED.equals(action)) {
updateBatteryLevel(0);
rangeText.setText("Wella is out of range, you may have
forgotten to bring it");
sendNotification();
Toast.makeText(MainActivity.this, "Wella is out of range,
you may have forgotten to bring it",
Toast.LENGTH_SHORT).show();
}
}
};
Code Block 3. Code to handle Disconnecting from Wella and Sending Notifications.

firestore.collection("test").add(data).addOnSuccessListener(new
OnSuccessListener<DocumentReference>() {
@Override
public void onSuccess(DocumentReference documentReference) {
Toast.makeText(getApplicationContext(), "Success uploading on
firebase", Toast.LENGTH_LONG).show();
}
}).addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Toast.makeText(getApplicationContext(), "Fail uploading on
firebase", Toast.LENGTH_LONG).show();
}
});

Code Block 4. Uploading data to Firestore database.

public void onMapReady(@NonNull GoogleMap googleMap) {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.MINUTE, -10);
Date limitTime = calendar.getTime();
CollectionReference collectionReference =
firestore.collection("test");
collectionReference.whereGreaterThan("timestamp",
limitTime).orderBy("timestamp", Query.Direction
.DESCENDING).get().addOnSuccessListener(new
OnSuccessListener<QuerySnapshot>() {
@Override
public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
int i = 1;
for (QueryDocumentSnapshot documentSnapshot :
queryDocumentSnapshots) {
Map<String, Object> data = documentSnapshot.getData();
Map<String, Object> coordinate = (Map<String, Object>)
data.get("coordinate");
LatLng latLng1 = new LatLng((Double)
coordinate.get("latitude"), (Double)
coordinate.get("longitude"));

MarkerOptions markerOptions = new MarkerOptions()

.position(latLng1).title(i + " location from firestore");
Marker marker = googleMap.addMarker(markerOptions);
marker.setTag(data);
i++;
}
}
}).addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Toast.makeText(getApplicationContext(), "Fail to fetch from
firestore", Toast.LENGTH_LONG).show();
}
});
Code Block 5. Fetching Last 10 Minutes of Data from Database.