如何写一个声音报警脚本

本文目录导读：

1. 最简版本（Windows + Linux 通用）
2. 进阶版本（带多种音效）
3. 实时监控报警脚本
4. 命令行工具版本
5. 网页接口版本
6. 使用场景示例
7. 注意事项

我来提供一个声音报警脚本,包含多种实现方式和实用功能：

最简版本（Windows + Linux 通用）

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
简单声音报警脚本
支持 Windows 和 Linux 系统
"""
import sys
import time
def simple_beep(times=3, duration=0.5):
    """最简报警 - 使用系统蜂鸣器"""
    for i in range(times):
        if sys.platform == 'win32':
            import winsound
            winsound.Beep(1000, int(duration * 1000))  # 1000Hz, 持续时间
        else:
            # Linux/Mac 使用终端响铃字符
            print('\a', end='', flush=True)
            time.sleep(duration)
        time.sleep(0.2)
# 使用示例
if __name__ == "__main__":
    simple_beep(times=5, duration=0.8)
    print("检测到异常！")

进阶版本（带多种音效）

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
多功能声音报警系统
支持多种报警方式、可配置参数
"""
import threading
import time
import sys
import os
import random
class SoundAlarm:
    def __init__(self):
        self.running = False
        self.thread = None
        self.alarm_type = "beep"  # beep, melody, speech, music
    def beep_win(self, frequency=1000, duration=0.5, times=3):
        """Windows 蜂鸣器"""
        try:
            import winsound
            for _ in range(times):
                winsound.Beep(frequency, int(duration * 1000))
                time.sleep(0.2)
        except ImportError:
            self.beep_linux(duration, times)
    def beep_linux(self, duration=0.5, times=3):
        """Linux 终端蜂鸣"""
        for _ in range(times):
            print('\a', end='', flush=True)
            time.sleep(duration)
            time.sleep(0.2)
    def melody_alarm(self):
        """旋律报警"""
        try:
            import winsound
            # 经典警报旋律
            notes = [
                (1000, 0.3), (1500, 0.3), (1000, 0.3), (1500, 0.3),
                (2000, 0.5), (1500, 0.5)
            ]
            for freq, dur in notes:
                winsound.Beep(freq, int(dur * 1000))
                time.sleep(0.1)
        except ImportError:
            # Linux 下的简单替代
            self.beep_linux(duration=0.3, times=6)
    def speech_alarm(self, text="警告！检测到异常情况！"):
        """语音报警"""
        try:
            import pyttsx3
            # 使用平台自带的游戏引擎
            if sys.platform == 'win32':
                import win32com.client
                speaker = win32com.client.Dispatch("SAPI.SpVoice")
                speaker.Speak(text)
            else:
                os.system(f'espeak "{text}"')
        except:
            print(f"[语音报警] {text}")
            self.beep_linux(duration=0.5, times=3)
    def start_alarm(self, alarm_type=None):
        """开始报警"""
        if self.running:
            print("报警已在运行中")
            return
        self.running = True
        self.alarm_type = alarm_type or "beep"
        self.thread = threading.Thread(target=self._run)
        self.thread.daemon = True
        self.thread.start()
    def stop_alarm(self):
        """停止报警"""
        self.running = False
        if self.thread:
            self.thread.join(timeout=2)
    def _run(self):
        """报警主循环"""
        while self.running:
            if self.alarm_type == "melody":
                self.melody_alarm()
            elif self.alarm_type == "speech":
                self.speech_alarm()
            else:
                self.beep_win()
    def continuous_alert(self, interval=2, times=None):
        """连续告警"""
        count = 0
        while (times is None or count < times):
            self._run()
            count += 1
            time.sleep(interval)
# 使用示例
if __name__ == "__main__":
    alarm = SoundAlarm()
    # 简单蜂鸣
    print("简单报警测试...")
    alarm.beep_win(times=2)
    # 旋律报警
    print("旋律报警测试...")
    alarm.alarm_type = "melody"
    alarm.continuous_alert(interval=1, times=2)
    # 语音报警
    print("语音报警测试...")
    alarm.speech_alarm("系统状态异常，请立即检查")
    print("所有报警测试完成")

实时监控报警脚本

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
实时监控报警系统
监控系统资源并报警
"""
import psutil
import time
import logging
from datetime import datetime
import threading
import os
class MonitorAlarm:
    def __init__(self):
        self.setup_logging()
        self.alarm = SoundAlarm()
        self.thresholds = {
            'cpu': 80,        # CPU使用率
            'memory': 90,     # 内存使用率
            'disk': 85,       # 磁盘使用率
            'uptime': 7*24*60*60  # 运行时间(秒)
        }
    def setup_logging(self):
        """配置日志系统"""
        logging.basicConfig(
            filename='monitor_alarm.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
    def check_cpu(self):
        """检查CPU使用率"""
        cpu_percent = psutil.cpu_percent(interval=1)
        if cpu_percent > self.thresholds['cpu']:
            self.trigger_alarm(f"CPU使用率过高: {cpu_percent}%")
        return cpu_percent
    def check_memory(self):
        """检查内存使用率"""
        memory = psutil.virtual_memory()
        if memory.percent > self.thresholds['memory']:
            self.trigger_alarm(f"内存使用率过高: {memory.percent}%")
        return memory.percent
    def check_disk(self):
        """检查磁盘使用率"""
        disk = psutil.disk_usage('/')
        if disk.percent > self.thresholds['disk']:
            self.trigger_alarm(f"磁盘使用率过高: {disk.percent}%")
        return disk.percent
    def check_uptime(self):
        """检查系统运行时间"""
        import psutil
        uptime = time.time() - psutil.boot_time()
        if uptime > self.thresholds['uptime']:
            self.trigger_alarm(f"系统运行时间过长: {uptime/3600:.1f}小时")
        return uptime
    def trigger_alarm(self, message):
        """触发报警"""
        print(f"[{datetime.now()}] 报警: {message}")
        logging.warning(message)
        # 声音报警
        self.alarm.alarm_type = "melody"
        self.alarm.start_alarm()
        time.sleep(5)  # 报警持续5秒
        self.alarm.stop_alarm()
        # 发送邮件通知(可选)
        # self.send_email_alert(message)
    def send_email_alert(self, message):
        """发送邮件报警"""
        import smtplib
        from email.mime.text import MIMEText
        # 配置邮件服务器
        sender = "your_email@example.com"
        receiver = "admin@example.com"
        smtp_server = "smtp.example.com"
        msg = MIMEText(f"服务器报警: {message}")
        msg['Subject'] = '服务器监控报警'
        msg['From'] = sender
        msg['To'] = receiver
        try:
            with smtplib.SMTP(smtp_server, 587) as server:
                server.starttls()
                server.login("username", "password")
                server.sendmail(sender, [receiver], msg.as_string())
            logging.info(f"报警邮件已发送: {message}")
        except Exception as e:
            logging.error(f"发送邮件失败: {e}")
    def run_monitor(self, interval=5):
        """运行监控"""
        print("开始监控系统资源...")
        logging.info("开始监控系统资源")
        try:
            while True:
                cpu = self.check_cpu()
                mem = self.check_memory()
                disk = self.check_disk()
                uptime = self.check_uptime()
                print(f"[{datetime.now().strftime('%H:%M:%S')}] "
                      f"CPU:{cpu}% 内存:{mem}% 磁盘:{disk}% 运行:{uptime/3600:.1f}h")
                time.sleep(interval)
        except KeyboardInterrupt:
            print("\n监控停止")
            logging.info("监控已停止")
# 使用示例
if __name__ == "__main__":
    monitor = MonitorAlarm()
    monitor.run_monitor(interval=5)  # 每5秒检查一次

命令行工具版本

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
命令行声音报警工具
用法: python alarm.py [参数]
"""
import argparse
import subprocess
import sys
import time
def main():
    parser = argparse.ArgumentParser(description='命令行声音报警工具')
    parser.add_argument('-t', '--time', type=str, help='报警时间 (如: 10s, 1m)')
    parser.add_argument('-r', '--repeat', type=int, default=1, help='重复次数')
    parser.add_argument('-f', '--frequency', type=int, default=1000, help='频率(Hz)')
    parser.add_argument('-m', '--message', type=str, default='', help='报警信息')
    parser.add_argument('-s', '--stop', action='store_true', help='停止之前的报警')
    parser.add_argument('-l', '--list', action='store_true', help='列出系统音频设备')
    args = parser.parse_args()
    if args.stop:
        stop_alarm()
        return
    if args.list:
        list_audio_devices()
        return
    if args.time:
        # 解析时间
        duration = parse_time(args.time)
        print(f"将在 {duration} 秒后报警")
        time.sleep(duration)
    # 开始报警
    trigger_alarm(frequency=args.frequency, 
                  message=args.message,
                  repeat=args.repeat)
def parse_time(time_str):
    """解析时间字符串"""
    if time_str.endswith('s'):
        return int(time_str[:-1])
    elif time_str.endswith('m'):
        return int(time_str[:-1]) * 60
    elif time_str.endswith('h'):
        return int(time_str[:-1]) * 3600
    else:
        return int(time_str)
def trigger_alarm(frequency=1000, message="", repeat=1):
    """触发报警"""
    for i in range(repeat):
        if message:
            print(f"\n⚠️  {message}")
        else:
            print(f"\n⚠️  报警！")
        # 根据平台使用不同的音频播放
        if sys.platform == 'win32':
            import winsound
            winsound.Beep(frequency, 1000)  # 持续1秒
        else:
            # Linux 下使用系统声音
            try:
                subprocess.run(['paplay', '/usr/share/sounds/alsa/Front_Center.wav'])
            except:
                print('\a', end='', flush=True)
        if i < repeat - 1:
            time.sleep(1)
def stop_alarm():
    """停止报警"""
    print("停止所有报警...")
    if sys.platform == 'win32':
        # Windows下可能已经结束
        pass
    else:
        # Linux下尝试停止声音
        subprocess.run(['pkill', 'paplay'])
def list_audio_devices():
    """列出音频设备"""
    if sys.platform == 'win32':
        print("Windows 使用系统默认音频设备")
    else:
        result = subprocess.run(['aplay', '-l'], capture_output=True, text=True)
        print(result.stdout)
if __name__ == "__main__":
    main()

网页接口版本

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Web接口声音报警系统
提供HTTP接口控制报警
"""
from flask import Flask, jsonify, request
import threading
import time
app = Flask(__name__)
class WebAlarm:
    def __init__(self):
        self.alarm_active = False
        self.alarm_thread = None
        self.alarm_type = "beep"
    def start_alarm(self, alarm_type="beep"):
        if not self.alarm_active:
            self.alarm_active = True
            self.alarm_type = alarm_type
            self.alarm_thread = threading.Thread(target=self._run)
            self.alarm_thread.start()
            return True
        return False
    def stop_alarm(self):
        self.alarm_active = False
        if self.alarm_thread:
            self.alarm_thread.join(timeout=2)
        return True
    def _run(self):
        while self.alarm_active:
            # 在这里实现具体报警逻辑
            if sys.platform == 'win32':
                import winsound
                winsound.Beep(1000, 500)
            else:
                print('\a', end='', flush=True)
            time.sleep(1)
alarm = WebAlarm()
@app.route('/alarm/start', methods=['POST'])
def start_alarm():
    data = request.json
    alarm_type = data.get('type', 'beep')
    if alarm.start_alarm(alarm_type):
        return jsonify({"status": "success", "message": "报警已启动"})
    else:
        return jsonify({"status": "warning", "message": "报警已在运行"})
@app.route('/alarm/stop', methods=['POST'])
def stop_alarm():
    alarm.stop_alarm()
    return jsonify({"status": "success", "message": "报警已停止"})
@app.route('/alarm/status', methods=['GET'])
def alarm_status():
    return jsonify({
        "status": "running" if alarm.alarm_active else "stopped",
        "type": alarm.alarm_type
    })
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

使用场景示例

# 1. 定时任务配合使用
from alarm_script import SoundAlarm
import schedule
import time
def scheduled_task():
    print("执行任务...")
    # 任务逻辑
    time.sleep(3)
    print("任务完成")
def alarm_if_failed():
    alarm = SoundAlarm()
    alarm.alarm_type = "speech"
    alarm.start_alarm()
    time.sleep(3)
    alarm.stop_alarm()
# 每5分钟执行一次任务
schedule.every(5).minutes.do(scheduled_task)
schedule.every().hour.do(alarm_if_failed)
while True:
    schedule.run_pending()
    time.sleep(1)
# 2. 邮件通知集成
def send_alert_with_sound(message):
    alarm = SoundAlarm()
    alarm.trigger_alarm(message)
    send_email(message)  # 你自己的邮件函数

注意事项

1. 测试环境：使用前先在测试环境中试运行
2. 音量控制：根据实际需要调整音量
3. 兼容性：不同操作系统使用不同的硬件和软件实现
4. 资源占用：连续的报警可能会消耗系统资源
5. 日志记录：建议记录报警事件以便追踪
6. 错误处理：添加try-except处理可能出现的异常

选择适合你的场景的方案：

• 简单场景：使用最简版本
• 监控场景：使用实时监控版本
• 远程控制：使用Web接口版本
• 定时任务：结合schedule使用

有任何问题或需要修改,请告诉我！