Serene Sync

Serene Sync is a simple two-part system that helps keep your space calm. The first device listens for loud noises, such as when your roommate gets too noisy, and uses an LED light and an LCD screen to alert her that she is being loud. When a disturbance is detected, the device sends a signal to the second unit, which then plays soothing nature sounds to restore calm. Once things quiet down, the relaxing sounds gradually fade away, leaving you with a peaceful atmosphere.

In the video, two devices are placed on the table. Loud music is played, which is detected by the microphone in the first device. This triggers the LED to turn on and changes the LCD screen to display a distressed expression, indicating that the environment is too loud. In response, the second device activates and begins playing soothing nature sounds. The nature sounds continue as long as the LED remains on. Once the noise subsides, the LED turns off, the LCD screen returns to a calm expression, and the nature sounds gradually stop. When the loud music is played again, the entire sequence repeats, demonstrating the interaction between the two devices.

The first step in building the device was testing the radio sensors to ensure they worked, as the entire system depended on successful communication between the two devices. However, the radio sensors were unreliable. At one point, I managed to get them working with an ultrasonic sensor, but when I tried to set them up again, I couldn’t get them to work consistently. To avoid further delays, I moved all my other sensors to that board, though I still don’t fully understand what made the radio sensors function correctly in the first place.

Setting up the DF Mini Player also proved to be more complicated than expected. It required completely erasing the SD card, which led to unexpected errors. This forced me to open Terminal after a very long time to troubleshoot. The silver lining was that I learned how to properly set it up, and now I feel confident doing it again.

This project was also my first experience with laser cutting. Initially, a lot of wood was wasted because the laser didn’t cut all the way through, I hadn’t set it up correctly. Additionally, precise measurements were essential to ensure all the electronics fit neatly inside the enclosure.

After assembling the device, I made adjustments to the code to accommodate the final placement of the electronics within the structure. Each step of the process came with challenges, but overcoming them helped me gain valuable skills and a better understanding of both hardware and software integration.

"I love that you used the radio to communicate between two isolated components." This was a core goal of the project, so I’m really happy it stood out. Getting the radio sensors to work was frustrating, but ultimately worth it because it enables the devices to interact wirelessly, making them feel more connected. That said, if I were to do another version, I might explore alternatives like Bluetooth or WiFi for more stability. One of the biggest challenges was dealing with the radio sensors’ unreliability. Even though I got them working, I still don’t fully understand their inconsistencies, which highlighted a gap in my knowledge of RF communication.

"If the light is meant to alert your roommate, could it be using a brighter LED?" This is a great point. The LED is meant to bring awareness to the person causing the noise, but if it’s too dim, it may not be effective. I could increase the brightness, add a second LED that changes color based on noise levels, or make the alert more dynamic by pulsing or blinking to grab attention.

I’m quite happy with how the project turned out, especially given the challenges I faced. The system successfully detects loud sounds and responds with calming feedback, and the interaction between devices feels intuitive. However, there’s room for improvement. Setting up the DF Mini Player was more complex than expected due to formatting issues with the SD card, requiring troubleshooting through Terminal. While frustrating, it reinforced my ability to problem-solve under pressure. I also learned the importance of precision in both hardware and software. Small measurement errors in laser cutting led to material waste, and I realized I should have done more test cuts before finalizing the design. On the software side, I struggled with making the system respond to real-time inputs without unnecessary resets. Initially, the audio track restarted every time a loud sound was detected, which wasn’t ideal. Fixing this taught me a lot about structuring my code more efficiently.

If I could advise my past self, I’d say: test early and often, and don’t assume things will work just because they should. Debugging took up more time than necessary due to a lack of upfront testing. I also should have been more patient with the radio sensors and had a backup plan in case they didn’t work as expected. Despite these challenges, the project was a rewarding learning experience, strengthening both my technical skills and my understanding of interactive system design.

Moving forward, my main priority is stabilizing the microphone. Currently, it picks up too much background noise, causing unnecessary activations. I plan to experiment with different microphone sensitivity settings, explore noise-filtering alternatives, and refine the software threshold to better distinguish between ambient noise and actual disturbances. Additionally, I’ll improve the LED alert system by adjusting brightness, adding a second LED, or making it more dynamic. These refinements will help enhance the system’s precision and effectiveness.

Device 2 Schematic Diagram

DEVICE 1

/*******************************************************

* Project: Serene Sync - Noise Awareness and Calming System

* Author: Aishwarya Shetty

*

* Description:

* This project consists of two devices that communicate wirelessly.

* The first device (this code) detects loud noises using a microphone

* and alerts both the person making the noise and the second device.

* It does this by lighting up an LED, displaying a reaction on an LCD screen,

* and sending a signal via radio communication.

* The second device receives the signal and plays calming sounds

* to create a more peaceful environment.

* Hardware Pin Mapping:

* - MAX4466 Microphone Sensor: A0 (Analog Input)

* - LED Indicator: Digital Pin 7

* - nRF24L01 Radio Transceiver:

*   - CE: Pin 9

*   - CSN: Pin 8

* - I2C LCD Display:

*   - SDA: A4 (default for Arduino Uno)

*   - SCL: A5 (default for Arduino Uno)

*

* Dependencies:

* - Adafruit MAX4466 microphone module

* - nRF24L01 radio module for wireless communication

* - I2C Liquid Crystal Display (16x2)

* - RF24 Library (for radio communication)

* - LiquidCrystal_I2C Library (for LCD display)

*

* Credit:

* Some portions of the radio communication and LCD handling logic

* are inspired by open-source examples from the RF24 and LiquidCrystal_I2C libraries.

*******************************************************/

#include <SPI.h>

#include <nRF24L01.h>

#include <RF24.h>

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// ----- Pin Definitions -----

#define MIC_PIN A0           // MAX4466 Microphone

#define LED_PIN 7            // LED Indicator

#define SOUND_THRESHOLD 540  // Threshold for loud noise

// ----- Radio Communication Setup -----

RF24 radio(9, 8);                    // CE, CSN

const byte address[10] = "ADDRESS01"; // Address for communication

// ----- LCD Setup -----

LiquidCrystal_I2C screen(0x27, 16, 2);

// ----- State Tracking -----

bool prevNoiseState = false; // Tracks if noise was previously detected

void setup() {

 pinMode(LED_PIN, OUTPUT);

 Serial.begin(9600);

 // Initialize Radio Module

 radio.begin();

 radio.openWritingPipe(address);

 radio.setPALevel(RF24_PA_MIN);

 radio.stopListening(); 

 // Initialize LCD Display

 Wire.begin();

 screen.init();

 screen.backlight();

 // Initial Display Messages

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("Hello, Im Boba");

 delay(3000);

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("Im easily scared");

 delay(3000);

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("Please be calm");

 delay(3000);

 showCalmFace();

}

// ----- Display Functions -----

void showCalmFace() {

 digitalWrite(LED_PIN, LOW);

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("   ___    ___   ");

}

void showLoudReaction() {

 digitalWrite(LED_PIN, HIGH);

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("  ( . )  ( . )'' ");

 delay(2000);

 screen.clear();

 screen.setCursor(3, 0);

 screen.print("It is Loud");

 delay(2000);

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("  ( . )  ( . )'' ");

}

void showTransmitting() {

 screen.clear();

 screen.setCursor(0, 0);

 screen.print("Transmitting...");

}

void loop() {

 int soundLevel = analogRead(MIC_PIN);

 Serial.print("Sound Level: ");

 Serial.println(soundLevel);

 bool noiseDetected = (soundLevel > SOUND_THRESHOLD);

 // If noise is detected and state changed, send radio signal

 if (noiseDetected && !prevNoiseState) {

   prevNoiseState = true; // Update state

   // Send the signal and check if successful

   bool success = radio.write(&noiseDetected, sizeof(noiseDetected));

   if (success) {

     Serial.println("Transmission SUCCESS: LOUD detected!");

     showTransmitting();

   } else {

     Serial.println("Transmission FAILED!");

   }

   showLoudReaction();

 }

 // If noise stops, update state but do NOT send a signal

 else if (!noiseDetected && prevNoiseState) {

   prevNoiseState = false; // Update state

   showCalmFace();

 }

  delay(50); // Short delay to prevent rapid flickering

}

DEVICE 2

/*******************************************************

* Project: Serene Sync - Noise Awareness and Calming System

* Component: Receiver (DFPlayer Mini & Speaker)

* Author: Aishwarya Shetty

*

* Description:

* This code runs on the second device of the Serene Sync system.

* It receives a wireless signal from the first device when loud

* noise is detected and plays a calming sound using the DFPlayer Mini module.

*

* The system ensures that:

* - The sound gradually fades in when noise is detected.

* - The song plays continuously but does not restart unnecessarily.

* - Every 5 seconds, it checks if loud noise is still present.

* - If the noise stops, the sound gradually fades out and stops.

*

* Hardware Pin Mapping:

* - DFPlayer Mini:

*   - RX: Pin 6 (Arduino receives data)

*   - TX: Pin 5 (Arduino transmits data)

* - nRF24L01 Radio Transceiver:

*   - CE: Pin 9

*   - CSN: Pin 8

*

* Dependencies:

* - nRF24L01 radio module for wireless communication

* - DFPlayer Mini for audio playback

* - RF24 Library (for radio communication)

* - DFRobotDFPlayerMini Library (for DFPlayer functionality)

*

* Credit:

* Some portions of the radio communication and DFPlayer handling logic

* are inspired by open-source examples from the RF24 and DFPlayer libraries.

*******************************************************/

#include <SPI.h>

#include <nRF24L01.h>

#include <RF24.h>

#include <SoftwareSerial.h>

#include <DFRobotDFPlayerMini.h>

// ----- DFPlayer Setup -----

SoftwareSerial mySerial(6, 5); // Arduino RX = 6, TX = 5

DFRobotDFPlayerMini myDFPlayer;

// ----- RF24 Setup -----

RF24 radio(9, 8);                    // CE = 9, CSN = 8

const byte address[10] = "ADDRESS01"; // Must match the transmitter

// ----- Fade & Volume Parameters -----

const int fadeInTime = 4000;  // 4 seconds fade-in

const int fadeOutTime = 4000; // 4 seconds fade-out

const int maxVolume = 30;     // Maximum volume (0-30)

const int minVolume = 8;      // Minimum volume for fade-in/out

// ----- Receiver State Variables -----

bool isPlaying = false;                   // Tracks if DFPlayer is playing

unsigned long lastSignalTime = 0;         // Last time a "loud" signal was received

unsigned long checkTimer = 0;             // Timer for 5-second interval checks

const unsigned long signalTimeout = 2000; // 2 seconds timeout to consider the signal lost

const unsigned long checkInterval = 5000; // Check every 5 seconds

void setup() {

 Serial.begin(9600);

 mySerial.begin(9600);

  // Initialize DFPlayer Mini

 Serial.println("Initializing DFPlayer Mini...");

 if (!myDFPlayer.begin(mySerial)) {

   Serial.println("DFPlayer Mini not detected. Check wiring.");

   while (true); // Halt if DFPlayer is not found

 }

 Serial.println("DFPlayer Mini ready!");

  myDFPlayer.volume(minVolume); // Start at minimum volume

  // Initialize RF24 receiver

 radio.begin();

 radio.openReadingPipe(0, address);

 radio.setPALevel(RF24_PA_MIN);

 radio.startListening();

  lastSignalTime = millis();

 checkTimer = millis();

}

void loop() {

 bool noiseDetected = false;

 static unsigned long lastPrintTime = 0;

  // Check if a radio signal is available

 if (radio.available()) {

   radio.read(&noiseDetected, sizeof(noiseDetected));

   lastSignalTime = millis(); // Update timestamp on receiving a signal

   Serial.print("RF24 Signal: ");

   Serial.println(noiseDetected ? "LOUD" : "CALM");

 } else {

   if (millis() - lastPrintTime > 1000) {

     Serial.println("No loud sound.");

     lastPrintTime = millis();

   }

 }

  // If a loud signal is detected and the DFPlayer isn't playing yet, fade in and start playback.

 if (noiseDetected && !isPlaying) {

   Serial.println("Starting fade-in and playback...");

   myDFPlayer.play(1); // Play track 1 (e.g., 0001.mp3)

   isPlaying = true;

   // Gradually increase volume for fade-in

   for (int vol = minVolume; vol <= maxVolume; vol++) {

     myDFPlayer.volume(vol);

     Serial.print("Volume Increasing: ");

     Serial.println(vol);

     delay(fadeInTime / (maxVolume - minVolume));

   }

   // Start the 5-second check timer

   checkTimer = millis();

 }

 // If already playing, check every 5 seconds if the loud signal is still present.

 if (isPlaying && (millis() - checkTimer >= checkInterval)) {

   // If no signal was received within the timeout period, fade out and stop.

   if (millis() - lastSignalTime > signalTimeout) {

     Serial.println("No signal for a while. Starting fade-out...");

     for (int vol = maxVolume; vol >= minVolume; vol--) {

       myDFPlayer.volume(vol);

       Serial.print("Volume Decreasing: ");

       Serial.println(vol);

       delay(fadeOutTime / (maxVolume - minVolume));

     }

     myDFPlayer.stop();

     isPlaying = false;

     Serial.println("Playback stopped.");

   } else {

     Serial.println("Signal still present. Continuing playback...");

   }

   // Reset the check timer after each 5-second interval.

   checkTimer = millis();

 }

  delay(100);  // Small delay for stability

}