import Tkinter as tk

import ttk
import subprocess
import re
import random

class WifiSignalAnalyzer:
def __init__(self, root):
self.root = root
self.root.title("Wifi Signal Analyzer")

self.network_list = tk.Listbox(self.root, width=50)

self.network_list.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)

self.detect_button = ttk.Button(self.root, text="Detect Networks",

command=self.detect_networks_and_start_measurement)
self.detect_button.pack(padx=10, pady=5)

self.signal_frame = ttk.Frame(self.root)
self.signal_frame.pack(pady=5)

self.signal_label = ttk.Label(self.signal_frame, text="Signal Strength:

0.00 dBm")
self.signal_label.pack(side=tk.LEFT)

self.classification_label = ttk.Label(self.signal_frame, text="")

self.classification_label.pack(side=tk.LEFT, padx=10)

self.canvas = tk.Canvas(self.root, bg="white", width=400, height=300)

self.canvas.pack()

self.output_text = tk.Text(self.root, width=50, height=10)

self.output_text.pack()

self.signal_strength = 0.0 # Initialize signal strength

self.previous_signal_strengths = [] # List to store previous signal
strengths

def detect_networks_and_start_measurement(self):
networks_found = self.detect_networks()
if networks_found:
self.start_measurement()

def detect_networks(self):
self.output_text.insert(tk.END, "Detecting networks...\n")
try:
networks_info = subprocess.check_output(['netsh', 'wlan', 'show',
'network']).decode('cp1252').encode('utf-8')
self.output_text.insert(tk.END, "Networks info: {}\
n".format(networks_info))
networks = re.findall(r'SSID \d+ : (.+?)\r', networks_info)
self.output_text.insert(tk.END, "Networks found: {}\
n".format(networks))
self.network_list.delete(0, tk.END)
for ssid in networks:
self.network_list.insert(tk.END, ssid)
self.classify_networks(networks) # Call classify_networks method
return True # Networks found
except subprocess.CalledProcessError as e:
 self.output_text.insert(tk.END, "Error: Unable to detect networks\n")
self.output_text.insert(tk.END, "Error Details: {}\n".format(e.output))
return False # No networks found

def start_measurement(self):
# Start updating signal strength every 5 seconds
self.update_signal()

def update_signal(self):
self.signal_strength = self.get_random_signal_strength()
self.signal_label.config(text="Signal Strength: {:.2f}
dBm".format(self.signal_strength))
classification = self.classify_signal(self.signal_strength)
self.classification_label.config(text=classification)
self.previous_signal_strengths.append(self.signal_strength)
self.draw_signal_graph()
# Record signal strength to file
self.record_signal_strength(self.signal_strength)
# Schedule next update after 5 seconds
self.root.after(5000, self.update_signal)

def get_random_signal_strength(self):
try:
# Simulating signal strength measurement with a random equation
return random.uniform(-80, -30)
except Exception as e:
self.output_text.insert(tk.END, "Error: Unable to measure signal
strength\n")
self.output_text.insert(tk.END, "Error Details: {}\n".format(str(e)))

def draw_signal_graph(self):
# Clear previous graph
self.canvas.delete("line")
# Draw the line graph
x_increment = 400 / len(self.previous_signal_strengths)
for i in range(len(self.previous_signal_strengths)):
x = x_increment * i
y = 300 - ((self.previous_signal_strengths[i] + 200) * 0.7) # Adjust
scaling for visualization
if i == 0:
self.canvas.create_oval(x, y, x + 2, y + 2, fill="blue") # Start
point
else:
prev_x = x_increment * (i - 1)
prev_y = 300 - ((self.previous_signal_strengths[i - 1] + 200) *
0.7)
self.canvas.create_line(prev_x, prev_y, x, y, fill="blue",
tags="line")

def classify_signal(self, signal_strength):

if signal_strength > -50:
return "Excellent"
elif signal_strength > -60:
return "Good"
elif signal_strength > -70:
return "Fair"
else:
return "Poor"
 def classify_networks(self, networks):
# Classify networks based on signal strength
classified_networks = {}
for ssid in networks:
signal_strength = self.get_random_signal_strength() # Simulate signal
strength for classification
classification = self.classify_signal(signal_strength)
classified_networks[ssid] = classification
self.output_text.insert(tk.END, "Network Classification:\n")
for ssid, classification in classified_networks.items():
self.output_text.insert(tk.END, "{}: {}\n".format(ssid,
classification))

def record_signal_strength(self, signal_strength):

try:
# Open the file in write mode
with open("signal_strengths.txt", "a") as file:
# Write the signal strength value to the file
file.write("{:.2f}\n".format(signal_strength))
except Exception as e:
self.output_text.insert(tk.END, "Error: Unable to record signal
strength\n")
self.output_text.insert(tk.END, "Error Details: {}\n".format(str(e)))

if __name__ == "__main__":
root = tk.Tk()
app = WifiSignalAnalyzer(root)
root.mainloop()