Distance Buzzer Warning

This project centers around creating a distance-based feedback system using the ACROME Smart Motion Device (SMD) platform. The system incorporates a distance sensor, RGB LED lights, and a buzzer to provide real-time feedback based on the distance of an object from the sensor. The system also includes a graphical user interface (GUI) for users to monitor the sensor readings and adjust distance settings. The RGB lights and buzzer provide visual and auditory signals, respectively, based on the proximity of the object to the sensor.

Key Components:

1. SMD (Smart Motion Device) The SMD acts as the communication hub, connecting and controlling the distance sensor, RGB lights, and buzzer. It processes sensor data and translates it into corresponding RGB and buzzer feedback, ensuring that the system functions in real-time.

2. Ultrasonic Distance Sensor The distance sensor measures the distance between itself and nearby objects. This data is continuously sent to the SMD, which then determines the appropriate feedback to provide based on predefined distance thresholds.

3. RGB LED Module The RGB LED Module displays different colors depending on the distance between the sensor and the object. Colors such as green, yellow, and red are used to indicate different proximity ranges, providing users with an intuitive visual cue for the distance.

4. Buzzer Module The buzzer module emits sound at varying frequencies based on the object's distance from the sensor. Lower frequencies indicate a larger distance, while higher frequencies signal closer proximity, adding an auditory layer to the feedback.

Project Key Features:

1. Distance-Based RGB and Buzzer Feedback The system defines three key distance ranges: far, medium, and near. These ranges are associated with different RGB colors and buzzer frequencies.

   1. Far Distance: When an object is far (above a certain threshold), the system shows a green LED and the buzzer is silent.

   2. Medium Distance: As the object gets closer, the LED changes to yellow, and the buzzer emits a low-frequency sound.

   3. Near Distance: For very close objects, the LED turns red, and the buzzer produces a higher-pitched sound.

2. Real-Time Distance Monitoring The distance sensor continuously measures the object’s proximity, sending this data to the SMD. The system processes this information and updates the RGB lights and buzzer in real time, ensuring immediate feedback for the user.

3. Customizable Distance Thresholds Users can customize the distance thresholds through a user-friendly GUI. The GUI allows them to input values for the far and medium distance thresholds, which directly affect when the LED and buzzer change states. These settings can be saved and loaded for future use.

4. User-Friendly Graphical Interface (GUI) The GUI is created using Tkinter, providing real-time updates on distance, RGB color, and buzzer frequency. It also offers fields where users can enter new distance thresholds, ensuring that the system is flexible and adaptable to different environments or applications.

5. Threaded Operation for Continuous Monitoring The system runs the distance monitoring process in a separate thread, allowing the GUI to remain responsive while the sensor continuously collects data. This ensures smooth operation even as the user interacts with the interface.

Project Wiring Diagram

Workflow:

1. Distance Monitoring: The system continuously monitors the distance of an object using the distance sensor, and the data is processed in real time.

2. Feedback Response: Based on the object's distance, the RGB LED and buzzer are activated with corresponding colors and frequencies.

3. GUI Interaction: The user can view the real-time data in the GUI and adjust the distance thresholds for the far and medium ranges.

4. Threshold Customization: Users can input new values for the distance thresholds, apply them, and save these settings for future use.

Python Code

import keyboard
from smd.red import *
import time
import logging
import json
import tkinter as tk
from threading import Thread
from serial.tools.list_ports import comports
from platform import system
# Constants
FAR_DISTANCE = 50
MEDIUM_DISTANCE = 20
GREEN = (0, 255, 0)
YELLOW = (255, 255, 0)
RED = (255, 0, 0)

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def USB_Port():
	ports = list(comports())
	usb_names = {
		"Windows": ["USB Serial Port"],
		"Linux": ["/dev/ttyUSB"],
		"Darwin": [
			"/dev/tty.usbserial",
			"/dev/tty.usbmodem",
			"/dev/tty.SLAB_USBtoUART",
			"/dev/tty.wchusbserial",
			"/dev/cu.usbserial",
            		"/dev/cu.usbmodem",
			"/dev/cu.SLAB_USBtoUART",
			"/dev/cu.wchusbserial",
		]
	}
	
	os_name = system()
	if ports:
		for port, desc, hwid in sorted(ports):
			if any(name in port or name in desc for name in usb_names.get(os_name, [])):
				return port
		print("Current ports:")
		for port, desc, hwid in ports:
			print(f"Port: {port}, Description: {desc}, Hardware ID: {hwid}")
	else:
		print("No port found")
	return None
	
port = USB_Port()
m = Master(port)
m.attach(Red(0))
print(m.scan_modules(0))


def set_rgb_and_buzzer(rgb, buzzer_freq):
    """
    Sets the RGB color and buzzer frequency on the smart motion device.
    
    Args:
        rgb (tuple): A tuple of three integers representing the red, green, and blue color values (0-255).
        buzzer_freq (int): The frequency of the buzzer in Hz.
    
    Raises:
        Exception: If there is an error setting the RGB color or buzzer frequency on the smart motion device.
    """
    try:
        m.set_rgb(0, 1, *rgb)
        m.set_buzzer(0, 1, buzzer_freq)
    except Exception as e:
        logger.error(f"Error setting RGB and buzzer: {e}")

def load_settings():
    """
    Loads the distance settings from a JSON file, if it exists. If the file is not found, it uses the default values for FAR_DISTANCE and MEDIUM_DISTANCE.
    
    Raises:
        FileNotFoundError: If the settings.json file is not found.
    """
    global FAR_DISTANCE, MEDIUM_DISTANCE
    try:
        with open('settings.json', 'r') as f:
            settings = json.load(f)
            FAR_DISTANCE = settings.get("FAR_DISTANCE", 50)
            MEDIUM_DISTANCE = settings.get("MEDIUM_DISTANCE", 20)
    except FileNotFoundError:
        logger.info("Settings file not found, using default values.")

def save_settings():
    """
    Saves the current distance settings to a JSON file named 'settings.json'.
    
    The function creates a dictionary containing the current values of `FAR_DISTANCE` and `MEDIUM_DISTANCE`, and then writes this dictionary to a JSON file named 'settings.json' using the `json.dump()` function.
    
    This function is typically called after the user updates the distance settings through the GUI, in order to persist the new settings for future use.
    """
    settings = {
        "FAR_DISTANCE": FAR_DISTANCE,
        "MEDIUM_DISTANCE": MEDIUM_DISTANCE
    }
    with open('settings.json', 'w') as f:
        json.dump(settings, f)

load_settings()

distance_settings = {
    (FAR_DISTANCE, float('inf')): (GREEN, 0),
    (MEDIUM_DISTANCE, FAR_DISTANCE): (YELLOW, 10),
    (float('-inf'), MEDIUM_DISTANCE): (RED, 20)
}

# Create a Tkinter window
window = tk.Tk()
window.title("Distance Sensor Feedback")
window.geometry("400x400")

# Create labels to display distance, RGB color, and buzzer frequency
distance_label = tk.Label(window, text="Distance: ", font=("Helvetica", 14))
distance_label.pack(pady=10)

rgb_label = tk.Label(window, text="RGB Color: ", font=("Helvetica", 14))
rgb_label.pack(pady=10)

buzzer_label = tk.Label(window, text="Buzzer Frequency: ", font=("Helvetica", 14))
buzzer_label.pack(pady=10)

# Entry fields for FAR_DISTANCE and MEDIUM_DISTANCE
far_distance_label = tk.Label(window, text="FAR Distance (cm):", font=("Helvetica", 12))
far_distance_label.pack(pady=5)
far_distance_entry = tk.Entry(window)
far_distance_entry.pack(pady=5)
far_distance_entry.insert(0, str(FAR_DISTANCE))

medium_distance_label = tk.Label(window, text="MEDIUM Distance (cm):", font=("Helvetica", 12))
medium_distance_label.pack(pady=5)
medium_distance_entry = tk.Entry(window)
medium_distance_entry.pack(pady=5)
medium_distance_entry.insert(0, str(MEDIUM_DISTANCE))

def update_distances():
    """
    Updates the distance settings based on the values entered in the GUI, and saves the updated settings to a JSON file.
    
    This function is called when the user clicks the "Apply Distances" button in the GUI. It retrieves the new values for `FAR_DISTANCE` and `MEDIUM_DISTANCE` from the corresponding entry fields, updates the `distance_settings` dictionary accordingly, and then saves the new settings to a file named `settings.json` using the `save_settings()` function.
    
    If the user enters an invalid value (e.g. non-numeric) for either distance setting, the function logs an error message and does not update the settings.
    """
    global FAR_DISTANCE, MEDIUM_DISTANCE, distance_settings
    try:
        FAR_DISTANCE = int(far_distance_entry.get())
        MEDIUM_DISTANCE = int(medium_distance_entry.get())
        distance_settings = {
            (FAR_DISTANCE, float('inf')): (GREEN, 0),
            (MEDIUM_DISTANCE, FAR_DISTANCE): (YELLOW, 500),
            (float('-inf'), MEDIUM_DISTANCE): (RED, 1000)
        }
        save_settings()
        logger.info(f"Updated distances - FAR: {FAR_DISTANCE}, MEDIUM: {MEDIUM_DISTANCE}")
    except ValueError:
        logger.error("Invalid input for distance settings")

# Button to apply the new distance settings
apply_button = tk.Button(window, text="Apply Distances", command=update_distances)
apply_button.pack(pady=10)

def update_gui(distance, rgb, buzzer_freq):
    """
    Updates the GUI to display the current distance, RGB color, and buzzer frequency.
    
    This function is called from the `distance_monitor()` function to update the labels and background color of the main window to reflect the current state of the distance sensor and buzzer.
    
    Args:
        distance (float): The current distance measured by the sensor, in centimeters.
        rgb (tuple): A tuple of three integers (0-255) representing the RGB color to display.
        buzzer_freq (int): The current frequency of the buzzer, in Hertz.
    """
    distance_label.config(text=f"Distance: {distance} cm")
    rgb_label.config(text=f"RGB Color: {rgb}")
    buzzer_label.config(text=f"Buzzer Frequency: {buzzer_freq} Hz")
    window.configure(bg=f'#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}')  # Set background color

def distance_monitor():
    """
    Continuously monitors the distance sensor and updates the GUI and buzzer accordingly.
    
    This function runs in a separate thread and is responsible for the core functionality of the distance monitoring system. 
    It continuously reads the distance from the sensor, compares it to the configured distance thresholds, and updates the GUI and buzzer to reflect the current state.
    
    The function also checks for the 'q' key press, which allows the user to exit the program. When the exit command is detected, 
    the function sets the RGB LED and buzzer to their default state and destroys the main window.
    
    If any exceptions occur during the monitoring process, the function logs an error message and continues running.
    """
    try:
        while True:
            distance = m.get_distance(0, 1)
            logger.info(f"Distance: {distance}")

            for (min_dist, max_dist), (rgb, buzzer_freq) in distance_settings.items():
                if min_dist < distance <= max_dist:
                    set_rgb_and_buzzer(rgb, buzzer_freq)
                    update_gui(distance, rgb, buzzer_freq)
                    break

            # Exit command check
            if keyboard.is_pressed('q'):
                confirm_exit = input("Are you sure you want to exit? (y/n): ")
                if confirm_exit.lower() == 'y':
                    logger.info("Exiting...")
                    set_rgb_and_buzzer((0, 0, 0), 0)
                    window.destroy()
                    break
            
            time.sleep(0.5)  # Sleep to control polling rate

    except Exception as e:
        logger.error(f"An error occurred in the monitoring thread: {e}")

# Start the distance monitoring thread
monitor_thread = Thread(target=distance_monitor)
monitor_thread.daemon = True  # Daemonize thread
monitor_thread.start()

# Run the Tkinter main loop
window.mainloop()

Arduino Code

#include <Acrome-SMD.h>  // ACROME SMD kütüphanesini ekliyoruz

#define ID         0           // SMD için ID
#define BAUDRATE   115200      // Seri haberleşme için baud rate

Red master(ID, Serial, BAUDRATE);    // Ana modülü tanımlıyoruz

int distance_module_id = 1;          // Mesafe sensörü modül ID'si
int rgb_module_id = 1;               // RGB LED modül ID'si
int buzzer_module_id = 1;            // Buzzer modül ID'si

// Mesafe aralıkları
int FAR_DISTANCE = 50;               // Uzak mesafe
int MEDIUM_DISTANCE = 20;            // Orta mesafe

void setup() {
    Serial.begin(115200);            // Seri haberleşmeyi başlatıyoruz
    master.begin();                  // ACROME-SMD ana modülünü başlatıyoruz
    master.scanModules();            // Bağlı modülleri tarıyoruz
}

void loop() {
    int distance = master.getDistance(distance_module_id);  // Mesafeyi alıyoruz

    // Mesafeye göre RGB LED ve buzzer'ı kontrol et
    if (distance > FAR_DISTANCE) {
        // Uzak mesafede yeşil LED ve buzzer kapalı
        master.setRGB(rgb_module_id, 0, 255, 0);           // Yeşil
        master.setBuzzer(buzzer_module_id, 0);             // Buzzer kapalı
    } 
    else if (distance > MEDIUM_DISTANCE) {
        // Orta mesafede sarı LED ve düşük frekanslı buzzer
        master.setRGB(rgb_module_id, 255, 255, 0);         // Sarı
        master.setBuzzer(buzzer_module_id, 500);           // Düşük frekans (500 Hz)
    } 
    else {
        // Yakın mesafede kırmızı LED ve yüksek frekanslı buzzer
        master.setRGB(rgb_module_id, 255, 0, 0);           // Kırmızı
        master.setBuzzer(buzzer_module_id, 1000);          // Yüksek frekans (1000 Hz)
    }

    delay(500);  // 0.5 saniyelik bir gecikme
}

Conclusion: This project showcases the versatility of the ACROME SMD platform in integrating a distance sensor with RGB lights and a buzzer to provide real-time feedback. The combination of distance-based RGB feedback, customizable thresholds, and a user-friendly GUI makes the system both practical and adaptable. Whether used for safety, automation, or interactive installations, this project highlights the potential of the SMD platform in creating dynamic, sensor-driven environments.