Python 
 import numpy as np
 import tflite_micro_runtime.interpreter as tflite
 import sounddevice as sd
 import pygame
 import PySimpleGUI as sg
 import threading
 import time
 import os

 class BullyingDetectionSystem：
  def __init__(self, model_path)：
  self.is_running = False
  self.log_file_path = 'bullying_log.txt'
  self.progress_meter = None
  self.threshold_slider = None
  self.timer_start = None
 self.model_path = model_path
  self.threshold = 0.5
 
  # Use TensorFlow Lite for Microcontrollers
    self.interpreter = tflite.Interpreter(model_path=model_path)
  self.interpreter.allocate_tensors()

 def reset_status(self)：
 self.is_running = False
 self.progress_meter.update(0)
 self.timer_start.update('00：00')
   self.threshold_slider.update(value=self.threshold)
 self.window['Status'].update('')
 self.window['Output'].update('')

 def playback_audio(self, file_path)：
 pygame.init()
 pygame.mixer.init()
 pygame.mixer.music.load(file_path)
 pygame.mixer.music.play()
 while pygame.mixer.music.get_busy()：
 pygame.time.Clock().tick(10)
 pygame.quit()

 def view_log(self)：
 layout_log_viewer = [[sg.Multiline("", size=(60, 10), key='log_viewer', autoscroll=True)],
 [sg.Button("Close")]]
 window_log_viewer = sg.Window("Log Viewer", layout_log_viewer, finalize=True)


 # Read and display log file content
 try：
 with open(self.log_file_path, 'r') as log_file：
 log_content = log_file.read()
 window_log_viewer['log_viewer'].update(log_content)
 except FileNotFoundError：
 sg.popup_error("Log file not found.")

 while True：
 event_log_viewer, _ = window_log_viewer.read()

 if event_log_viewer == sg.WIN_CLOSED or event_log_viewer == "Close"：
 break

 window_log_viewer.close()

 def simulate_smartwatch_gui(self)：
 layout = [[sg.Text("Smartwatch Bullying Detection", size=(40, 1), justification="center", font=("Helvetica", 15), key="Title")],
 [sg.Button("Start", key="Start"), sg.Button("Stop", key="Stop"), sg.Button("Reset", key="Reset"), sg.Button("Exit", key="Exit")],
 [sg.Text("", size=(30, 1), key="Status", text_color="red")],
 [sg.ProgressBar(100, orientation='h', size=(20, 20), key='progress_meter')],
 [sg.Text("Recording Time：", size=(15, 1)), sg.Text("00：00", size=(5, 1), key='timer_start')],
 [sg.Slider(range=(0, 1), orientation='h', resolution=0.01, default_value=0.5, key='threshold_slider', enable_events=True)],
 [sg.Button("Playback", key="Playback"), sg.Button("View Log", key="View Log")],
 [sg.Canvas(size=(400, 200), background_color='white', key='canvas')],
 [sg.Output(size=(60, 10), key="Output")]]

 self.window = sg.Window("Smartwatch Simulation", layout, finalize=True)
 self.progress_meter = self.window['progress_meter']
 self.timer_start = self.window['timer_start']
 self.threshold_slider = self.window['threshold_slider']

 while True：
 event, values = self.window.read(timeout=100)


 if event == sg.WIN_CLOSED or event == "Exit"：
 break
 elif event == "Start"：
 self.is_running = True
 threading.Thread(target=self.run_detection_system).start()
 elif event == "Stop"：
 self.is_running = False
 elif event == "Reset"：
 self.reset_status()
 elif event == "Playback"：
 selected_file = sg.popup_get_file("Choose a file to playback", file_types=(("Audio files", "*.wav"), ("All files", "*.*")))
 if selected_file：
 self.playback_audio(selected_file)
 elif event == "View Log"：
 self.view_log()
 elif event == "threshold_slider"：
 self.threshold = values['threshold_slider']
 self.window['Output'].update(f"Threshold adjusted to： {self.threshold}\n")

 self.update_gui()

 self.window.close()

 def update_gui(self)：
 if self.is_running：
 self.window['Status'].update('System is running', text_color='green')
 else：
 self.window['Status'].update('System is stopped', text_color='red')

 self.window['threshold_slider'].update(value=self.threshold)

 def run_detection_system(self)：
 while self.is_running：
 start_time = time.time()
 audio_data = self.record_audio()
 self.bullying_detected = self.predict_bullying(audio_data)
 end_time = time.time()

 elapsed_time = end_time - start_time
 self.timer_start.update(f"{int(elapsed_time // 60)：02d}：{int(elapsed_time % 60)：02d}")

 if self.bullying_detected：
 try：
 with open(self.log_file_path, 'a') as log_file：
 log_file.write(f"Bullying detected at {time.strftime('%Y-%m-%d %H：%M：%S')}\n")
 except Exception as e：
 sg.popup_error(f"Error writing to log file： {e}")

 self.progress_meter.update_bar(10)

 def record_audio(self)：
 # Implement audio recording logic using sounddevice
 # Replace the following code with your actual audio recording implementation
 duration = 5 # seconds
 sample_rate = 44100
 recording = sd.rec(int(duration * sample_rate), samplerate=sample_rate, channels=1, dtype='int16')
 sd.wait()
 return recording.flatten()

 def predict_bullying(self, audio_data)：
 # Implement model inference logic using TensorFlow Lite for Microcontrollers
 # Replace the following code with your actual model inference implementation
 input_tensor_index = self.interpreter.input_details[0]['index']
 output_tensor_index = self.interpreter.output_details[0]['index']

 input_data = np.array(audio_data, dtype=np.int16) # Assuming int16 audio data
 input_data = np.expand_dims(input_data, axis=0)

 self.interpreter.set_tensor(input_tensor_index, input_data)
 self.interpreter.invoke()
 output_data = self.interpreter.get_tensor(output_tensor_index)

 # Replace this with your actual logic for determining bullying detection
 return output_data[0] > self.threshold

 if __name__ == "__main__"：
 model_path = 'your_model.tflite'
 detection_system = BullyingDetectionSystem(model_path)
   detection_system.simulate_smartwatch_gui()