開發2

pip install opencv-python pyautogui Pillow

https://www.tightvnc.com/download.php→開源

https://remoteripple.com/→開源

https://www.realvnc.com/en/connect/download/viewer/→付費，viewer免費

簡單說明

https://ithelp.ithome.com.tw/articles/10315092

使用繁體中文，在w11下，使用python語言及UI界面，區域網路的中電腦，新增螢幕廣播的功能，主要是廣播伺服端電腦的螢幕主畫面

，伺服端電腦要如何在10台clinet端電腦上能做到螢幕廣播的功能？

伺服端：

，在UI界面下，區網中的client端電腦在程式執行後，要先跟伺服端電腦報到，伺服端電腦要在程式啟動時用現在的使用的IP，先進行區網的廣播，持續時間30秒，並要有手動廣播的按鈕可以再次廣播伺服端電腦的ip位置，等client端電腦報到後呈現在ui畫面上，需要呈現有client端電腦的ip位置、MAC位置、電腦名稱、狀態(online或offline)，此列表中，如果使用者手動按下重新廣播按鈕後，在UI界面上，clinet端資料進行重整，client電腦離線就顯示offline，如果還連線就顯示online，

當有clinet的電腦報到後，伺服端電腦使用者要先選定列表中已報到的clinet端電腦後(要有可能選擇多台電腦的功能)，接著選定好clinet端電腦(可以一次選多台client端電腦)要被接收伺服端的螢幕廣播的畫面，伺服端使用者在選定好client端電腦後，伺服端電腦使用者，要有一個廣播螢幕的按鈕按下後，才進行伺服端的電腦螢幕主畫面，伺服端同時也要通知clinet端準備接收伺服端的螢幕廣播的畫面，

client端：

client端電腦，在程式動後，要先向區域網路中的伺服端電腦報到，等到接到伺服端傳來準備螢幕廣播的訊號後，開始準備用全視窗大小的螢幕畫面展示，client端使用者可以手動調整呈現的畫面大小

使用繁體中文，在winn1環境下，使用python語言，區域網路中，，

 使用者在伺服端電腦，想要點選資料夾或是檔案(可以是一個以上)，就能自動傳輸檔案到client端執行接收程式的電腦，

，在UI界面下，區網中的client端電腦要先跟伺服端電腦報到，伺服端電腦要在程式啟動時用現在的使用的IP，先進行區網的廣播，持續時間30秒，並要有手動廣播的按鈕可以再次廣播伺服端電腦的ip位置，等client端電腦報到後呈現在ui畫面上，需要呈現有client端電腦的ip位置、MAC位置、電腦名稱、狀態(online或offline)，此列表中，如果使用者手動按下重新廣播按鈕後，在UI界面上，clinet端資料進行重整，client電腦離線就顯示offline，如果還連線就顯示online，

1131004-01-test

使用繁體中文，在win11下，區域網呫中, 使用python語言，使用UI界面，要如何設計出，如"https://veyon.io/en/"這個網站提供的監控區網路的30台電腦，並可以有廣播黑屏暫停畫面被使用的功能，預設分成伺服端電腦程式及clinet端電腦程式，伺服端電腦程式啟後動進行網路廣播，持續30秒，而client端電腦程式啟動後，找到區網中的伺服端電腦自動報到？謝謝

伺服端

-8*4

-黑屏

功能說明：

2. 基本功能設計

a. 獲取網絡上所有電腦的列表

使用 socket 庫來獲取局域網內的 IP 地址。可以使用 arp 命令來查找在線設備。

b. 設計 UI

使用 tkinter 設計一個簡單的界面，讓使用者可以看到網絡中的所有電腦，並選擇需要監控的電腦。

c. 截圖和顯示功能

使用 opencv 或 Pillow 截取選中電腦的屏幕。這可能需要在被監控的電腦上運行客戶端代碼，以便能夠捕獲屏幕並發送到主控端。

d. 廣播黑屏

設計一個功能來向選中的電腦發送指令，讓它們顯示黑屏。這需要在被監控的電腦上運行一個小程序，能夠接收命令並執行。

4. 完善功能

接下來，您需要：

• 實作截圖和廣播功能的具體邏輯。

• 確保所有電腦上有適當的客戶端程式在運行，並能處理來自主控端的命令。

• 添加錯誤處理和安全性設計，確保只有授權的用戶能使用這些功能。

5. 測試與部署

在局域網環境中測試系統的穩定性與效率，根據需要進行調整和優化

-pip install pillow opencv-python

import socket

import pickle

import tkinter as tk

from PIL import Image, ImageTk

import threading

class MonitorApp:

    def __init__(self, master):

        self.master = master

        self.master.title("區域網監控系統")

        self.client_data = {}  # 儲存客戶端的截圖和名稱

        self.frames = []

        self.checkbuttons = []  # 儲存勾選框狀態

        for i in range(8):  # 行

            row = []

            checkboxes = []

            for j in range(4):  # 列

                frame = tk.Frame(master, width=160, height=120)

                frame.grid(row=i, column=j, padx=5, pady=5)

                label = tk.Label(frame, text=f"Client {len(self.client_data) + 1}", bg="lightgrey")

                label.pack()

                var = tk.BooleanVar()

                checkbox = tk.Checkbutton(frame, variable=var)

                checkbox.pack(side=tk.BOTTOM)

                row.append((frame, label, checkbox, var))

                checkboxes.append(var)

            self.frames.append(row)

            self.checkbuttons.append(checkboxes)

        control_frame = tk.Frame(master)

        control_frame.grid(row=8, columnspan=4)

        self.blackout_button = tk.Button(control_frame, text="廣播黑屏", command=self.broadcast_blackout)

        self.blackout_button.pack()

        threading.Thread(target=self.receive_screenshot, daemon=True).start()

    def receive_screenshot(self):

        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        sock.bind(('0.0.0.0', 12345))

        sock.listen(5)

        print("等待客戶端連接...")

        while True:

            conn, addr = sock.accept()

            print(f"連接來自 {addr}")

            client_name = f"Client {len(self.client_data) + 1}"

            self.client_data[addr] = (client_name, conn)

            threading.Thread(target=self.handle_client, args=(addr, conn, client_name), daemon=True).start()

    def handle_client(self, addr, conn, client_name):

        while True:

            try:

                screenshot_data = conn.recv(4096)

                if not screenshot_data:

                    break

                screenshot = pickle.loads(screenshot_data)  # 反序列化

                self.update_display(addr, screenshot, client_name)

            except Exception as e:

                print("接收截圖失敗:", e)

                break

    def update_display(self, addr, screenshot, client_name):

        img = ImageTk.PhotoImage(screenshot)

        for i, row in enumerate(self.frames):

            for j, (frame, label, checkbox, var) in enumerate(row):

                if (addr,) in self.client_data.keys():

                    label.config(text=client_name)

                    label.config(image=img)

                    label.image = img  # 避免圖片被垃圾回收

                    return  # 更新完成後退出

    def broadcast_blackout(self):

        for addr, (client_name, conn) in self.client_data.items():

            row = self.checkbuttons

            for checkboxes in row:

                for var in checkboxes:

                    if var.get():  # 如果勾選框被選中

                        self.send_blackout_command(addr)

    def send_blackout_command(self, target_ip):

        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        sock.connect((target_ip[0], 12346))

        sock.sendall("BLACKOUT".encode())

# 主控端程式啟動

root = tk.Tk()

app = MonitorApp(root)

root.mainloop()

2.

import socket

import threading

import tkinter as tk

from time import sleep

# 定義伺服端程式

class ServerApp:

    def __init__(self, master):

        self.master = master

        self.master.title("伺服端監控")

        self.master.geometry("400x300")

        # 建立廣播按鈕

        self.broadcast_button = tk.Button(self.master, text="發送廣播", command=self.broadcast_message)

        self.broadcast_button.pack(pady=10)

        # 建立黑屏按鈕

        self.black_screen_button = tk.Button(self.master, text="黑屏所有客戶端", command=self.black_screen_all)

        self.black_screen_button.pack(pady=10)

        # 用於顯示連接狀態的Text框

        self.log = tk.Text(self.master)

        self.log.pack()

        # 啟動伺服器線程

        threading.Thread(target=self.start_server, daemon=True).start()

    def log_message(self, message):

        self.log.insert(tk.END, message + '\n')

        self.log.see(tk.END)

    def broadcast_message(self):

        """每隔30秒廣播訊息"""

        self.log_message("開始發送廣播訊息...")

        server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

        message = "這是伺服端廣播訊息"

        server_socket.sendto(message.encode(), ('<broadcast>', 12345))

        self.log_message("廣播訊息已發送")

    def black_screen_all(self):

        """發送黑屏命令給所有客戶端"""

        self.log_message("發送黑屏訊息給所有客戶端...")

    def start_server(self):

        """啟動伺服器，等待客戶端連接"""

        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        server_socket.bind(('0.0.0.0', 65432))

        server_socket.listen(5)

        self.log_message("伺服器已啟動，等待客戶端連接...")

        while True:

            client_socket, addr = server_socket.accept()

            self.log_message(f"客戶端 {addr} 已連接")

            threading.Thread(target=self.handle_client, args=(client_socket, addr), daemon=True).start()

    def handle_client(self, client_socket, addr):

        """處理客戶端的連接"""

        while True:

            try:

                data = client_socket.recv(1024)

                if not data:

                    break

                message = data.decode()

                self.log_message(f"來自客戶端 {addr} 的訊息: {message}")

            except ConnectionResetError:

                break

        client_socket.close()

        self.log_message(f"客戶端 {addr} 已斷開連接")

# 建立Tkinter界面

root = tk.Tk()

app = ServerApp(root)

root.mainloop()

client端

客戶端設計

客戶端主要功能：

• 啟動後自動搜尋伺服端

• 接收伺服端的黑屏或暫停畫面命令

• 向伺服端定期報告狀態

1.

import socket

import pyautogui

import pickle

import threading

import time

import tkinter as tk

def send_screenshot(server_ip):

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.connect((server_ip, 12345))

    while True:

        # 擷取屏幕

        screenshot = pyautogui.screenshot()

        screenshot_data = pickle.dumps(screenshot)  # 將截圖轉換為可傳輸的格式

        sock.sendall(screenshot_data)

        time.sleep(1)  # 每秒截圖一次

def listen_for_commands():

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.bind(('0.0.0.0', 12346))  # 監聽所有網路接口

    sock.listen(1)

    while True:

        conn, addr = sock.accept()

        print(f"接收到來自 {addr} 的連接")

        while True:

            command = conn.recv(1024).decode()

            if command == "BLACKOUT":

                blackout_screen()

def blackout_screen():

    blackout_window = tk.Tk()

    blackout_window.attributes('-fullscreen', True)

    blackout_window.configure(bg='black')

    blackout_window.title("黑屏模式")

    blackout_window.mainloop()

# 設置客戶端的IP

server_ip = input("請輸入主控端的IP地址: ")

threading.Thread(target=send_screenshot, args=(server_ip,), daemon=True).start()

listen_for_commands()

2.

import socket

import pyautogui

import pickle

import threading

import time

import tkinter as tk

def send_screenshot(server_ip):

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.connect((server_ip, 12345))

    while True:

        # 擷取屏幕

        screenshot = pyautogui.screenshot()

        screenshot_data = pickle.dumps(screenshot)  # 將截圖轉換為可傳輸的格式

        sock.sendall(screenshot_data)

        time.sleep(1)  # 每秒截圖一次

def listen_for_commands():

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.bind(('0.0.0.0', 12346))  # 監聽所有網路接口

    sock.listen(1)

    while True:

        conn, addr = sock.accept()

        print(f"接收到來自 {addr} 的連接")

        while True:

            command = conn.recv(1024).decode()

            if command == "BLACKOUT":

                blackout_screen()

def blackout_screen():

    blackout_window = tk.Tk()

    blackout_window.attributes('-fullscreen', True)

    blackout_window.configure(bg='black')

    blackout_window.title("黑屏模式")

    blackout_window.mainloop()

# 設置客戶端的IP

server_ip = input("請輸入主控端的IP地址: ")

threading.Thread(target=send_screenshot, args=(server_ip,), daemon=True).start()

listen_for_commands()