Description as a Tweet:

Words are hard. Saying them to people? EVEN HARDER. Find it hard at social events to ask if someone’s single? To leave you alone? Or do you hate intros like What team or organization are you with? Then use moodLight! Let moodLight show others the things you don’t want to say/ask

Inspiration:

The initial inspiration for our project was to help prevent unwanted romantic advances during social gatherings. These can be uncomfortable for many people and, if unchecked, could become harassment which is even more distressing. As mentioned in our tweet, it can be just as uncomfortable to directly ask someone if they are open to romantic intentions. So we decided to create a way that you could wordlessly communicate such things: through images on an LED matrix. With images such as a green light for “ready for romantic encounters” or a do not enter sign for “leave me alone”, you can easily communicate this important information to others while avoiding the awkwardness of directly saying such things. Now with the uncomfortable (but necessary) part of a conversation communicated by your moodLight, you can begin to make more meaningful connections with other people at social events.
However, we soon realized that Moodlight had the potential to reach things far beyond this initial inspiration. Moodlight could be used to create teams at sporting events, put people in groups for team building, demonstrate what organization you are with at a networking event, and change your status on the fly. For example, what happens when you are a recruiter at a college event, but are packing up to leave when a student strikes up conversation with you? You might feel forced to engage with the student even though you are pressed for time, but with moodLight, this wouldn't happen in the first place. Essentially, moodLight has the promise to expedite communication in any social setting. So we set to work to allow users to create their own events and upload their own images.

What it does:

Our project is broken up into two basic parts: event creation and participant joining. The event creator end of the program works through a html web site. Here event creators can send a request to create their event to our server hosted on Google Cloud Platform. If all the data was entered correctly, a successful response is sent back to the event creator and the event is stored into our Google CloudSQL Postgres database. After this, everything on the event creator end is completed.
The participant end of the project, the moodLight itself, is where all of the hardware is located. Users complete all of their interactions through an LED matrix and two buttons to work through the setup. When Starting the moodLight, users use buttons to scroll through letters and choose those corresponding to the code for their gathering. Once that is submitted, the program sends a https request to the server which sends back all of the download links to the images for that given event. These images are downloaded and stored on the RPi. From here, the user simply uses the buttons to scrolls through which image is displayed on their LED screen. They can then hold down either button for 4 seconds to end the program and delete all images from this event

How we built it:

Most of the project was spent with the three of us on zoom working through our problems together, even if we were working on separate tasks. This helped us continually bounce ideas off one another and boosted our productivity. For what was feasible, we broke up into separate tasks to be done by each member by means of git/github which allowed us to speed up the process. For example, one of us worked on creating the server and database, one worked purely on the hardware coding for the Moodlight, and the other worked on connecting the moodLight to the server. Since we were all on zoom, it was easy for us to switch gears in order to pick up the slack when one of us needed help. Some tasks had to involve all of us like setting up the website and its communication to the server.

Technologies we used:

• HTML/CSS
• Javascript
• SQL
• Python
• Flask
• Raspberry Pi
• Microcontrollers
• Other Hardware

Challenges we ran into:

When we were designing the website we chose to go with bootstrap. We had never done any frontend coding, so combining HTML and JS (both of which we had basically no knowledge of) to do this was considerably difficult. We ran into significant problems while we were trying to have the website make http requests to the server. The website was hosted on github, which only allows for https domains, while the server was hosted on google cloud, which had an http domain. Basically, it did not allow us to make any requests between a website with a SSL and one without an SSL, which was core to the functionality of our project. Because of this we had to move our entire website over to the google cloud server. However, after we moved the website to the Google cloud server we had problems with our CSS code, which had been optimized for Github hosting. Because of this, we had to trace where the problems were and fix it, which took quite a while.

We also had some issues with hardware. Since we had a bonnet on our Raspberry Pi it was difficult to access the GPIO pins needed to hook up our buttons to the system. We ended up having to resort to some interesting workarounds and quick taping to get the button leads secured to the pins on the Raspberry Pi, while ensuring we did not get erroneous inputs from the buttons.

Accomplishments we're proud of:

We are most proud of how ambitious this hack was for us, we took on a lot of challenges that we had never done before. This was our first time using an LED matrix with the RaspberryPi so we had to read through lots of documentation to discover how best to use it with our project. This in itself was difficult enough but on top of that only one team member had functioning hardware, so all of our learning had to consist of constantly sending them code to test.
And as we stated above, we basically knew nothing of creating frontends before this hackathon, so it isn’t surprising that creating the website was the most troubling section for us. However, with each error we ran across we attacked it with research, testing, and whatever else we could throw at it until we were able to overcome each problem. This has given us a lot of confidence in our ability to learn on the fly and adapt to difficult situations.

What we've learned:

What we learned the most from this experience was the best way to interact with our teammates and delegate work. For one, doing most of our work together on a zoom was of huge importance to the success of our project. We found this was the easiest way to discuss structural problems and communicate our code to one another. Additionally, it helped increase our morale and spur us to be more productive. Perhaps more importantly, we learned that it is not always best to solely assign one person to one hacking task. Often during this project some unforeseen problem would arise that would be difficult for one person to solve. But by bringing it to the group we were able to combine our different perspectives to find a solution to the problem.

What's next:

We'd like to make this a far more practical design. Right now we are limited by our hardware, using a LED matrix that requires a Raspberry pi and shield in addition to power. There are smaller LED matrices out there, that are much thinner and require much less supporting hardware. In the future, we would like to expand to those and make this a truly wearable technology, embedding it in a t shirt or bracelet.

We'd like to add more content to the website, so it's more interactive and truly capable of supporting a community. For example, we would like to add a page to view other public events nearby.

Built with:

The Server was made using Google Cloud and accessed a database through postgreSQL. The server was written in Python and used Flask.
The website was made using HTML/CSS and javascript, and hosted on Google Cloud.
The Moodlight hardware consisted of a RaspberryPi board, adafruit rgb bonnet, an Adafruit LED matrix, and two buttons we wired in with a breadboard and some tape. The software was made of Python and adafruits led-matrix library.
All connections between website, server, and client were handled through http requests via the requests library of python.

Prizes we're going for:

• Best Beginner Hardware Hack
• Best Documentation
• Funniest Hack
• Best Beginner Software Hack
• Best Beginner Web Hack
• Best Hardware Hack
• Best Use of Google Cloud

Lorand Cheng
Evan Hashemi
Baran Cinbis

Table TBD