import creopyson
import os

current_dir = os.getcwd()
# 初始化
c = creopyson.Client()

# 启动Creo
# nitro_proe_remote.bat复制自parametric.bat，不知道CREOSON为什么默认改成这个名字
# 修改nitro_proe_remote.bat用于自定义配置
command = "connection"
function = "start_creo"
data = {"start_dir": current_dir, "start_command": "nitro_proe_remote.bat", "retries": 5}
result = c._creoson_post(command, function, data)
# 这样也行
# c.start_creo(current_dir + "\\nitro_proe_remote.bat", 5, False)

c.connect()  # 这个必须得要，否则后面会提示没有sessionID

# 修改工作目录为程序所在目录
command = "creo"
function = "cd"
data = {"dirname": current_dir}
result = c._creoson_post(command, function, data)
# 这样也行
# c.creo_cd(current_dir)

# 打开文件并显示
command = "file"
function = "open"
data = {"file": "fin.prt", "display": True, "activate": True}
result = c._creoson_post(command, function, data)
# 这样也行
# c.file_open("fin.prt", display=True)

# 添加或修改参数
command = "parameter"
function = "set"
data = {"name": "test", "type": "STRING", "value": "测试参数值", "no_create": False, "designate": True}
result = c._creoson_post(command, function, data)
# 这样也行
# c.parameter_set("test", "测试参数值2", None, "STRING", None, True, False)

# 保存文件
command = "file"
function = "save"
data = {"file": "FIN.PRT"}
result = c._creoson_post(command, function, data)
# 这样也行
# c.file_save("fin.prt")

# -*- coding: utf-8 -*-
import json
import os
import pvporcupine
import pyaudio
import struct
import wave
import time
import subprocess
import tempfile
import threading
import queue
import signal
from aip import AipSpeech
import appbuilder

# ---------- 1. 读取配置 ----------
with open(os.path.join(os.path.dirname(__file__), "config.json"), "r", encoding="utf-8") as f:
    CFG = json.load(f)

# ---------- 2. 初始化 Porcupine ----------
porc = pvporcupine.create(**CFG["porcupine"])

# ---------- 3. 初始化百度语音 ----------
baidu_cfg = CFG["baidu_asr_tts"]
client = AipSpeech(baidu_cfg["APP_ID"], baidu_cfg["API_KEY"], baidu_cfg["SECRET_KEY"])

# ---------- 4. 初始化千帆 ----------
os.environ["APPBUILDER_TOKEN"] = CFG["qianfan"]["APPBUILDER_TOKEN"]
_qianfan_client = appbuilder.AppBuilderClient(CFG["qianfan"]["APP_ID"])
_qianfan_conversation_id = _qianfan_client.create_conversation()

def ask_qianfan(query: str) -> str:
    try:
        print("千帆请求中...")
        ans = _qianfan_client.run(_qianfan_conversation_id, query).content.answer
        print("千帆返回：", ans)
        return ans
    except Exception as e:
        print("千帆请求失败：", e)
        return "网络开小差了，稍后再试"

# ---------- 5. 常量 & 音频流 ----------
SAMPLE_RATE = 16000
FRAME_LEN = 512
SILENCE_SEC = 1.0
SILENCE_RMS = 150
WAV_FILE = "temp.wav"

pa = pyaudio.PyAudio()
kw_stream = pa.open(format=pyaudio.paInt16, channels=1,
                    rate=SAMPLE_RATE, input=True,
                    frames_per_buffer=FRAME_LEN)

def play_prompt(audio_file):
    if os.path.exists(audio_file):
        os.system(f"aplay -q {audio_file}")
    else:
        print(f"警告：音频文件 {audio_file} 不存在，跳过播放")

# ---------- 6. 后台播放线程：预加载 + 连续播放 ----------
stop_play = threading.Event()      # 主线程→播放线程：立即停
text_queue = queue.Queue()         # 主线程把「待播放文本」塞进来
preload_queue = queue.Queue(maxsize=1)  # 预合成 wav 路径（最大 1 段）
_play_thread = None

def _play_worker():
    while True:
        text = text_queue.get()
        if text is None:           # 退出信号
            break

        stop_play.clear()
        # ---- 6.1 问千帆（可被打断） ----
        if stop_play.is_set():
            continue
        answer = ask_qianfan(text)
        if stop_play.is_set():
            continue

        # ---- 6.2 长文本分段（<=512 字节 GBK） ----
        seg_list, cur, cur_len = [], '', 0
        for ch in answer:
            ch_len = len(ch.encode('gbk', errors='ignore'))
            if cur_len + ch_len > 512 and cur:
                seg_list.append(cur)
                cur, cur_len = ch, ch_len
            else:
                cur += ch
                cur_len += ch_len
        if cur:
            seg_list.append(cur)
        if not seg_list:
            continue
        if stop_play.is_set():
            continue

        # ---- 6.3 预合成 + 连续播放 ----
        tmp_base = tempfile.mktemp()
        n = len(seg_list)

        # 先合成第一段
        def _preload_one(idx):
            if idx >= n or stop_play.is_set():
                return None
            seg = seg_list[idx]
            try:
                print(f"TTS 合成段落 {idx}: {seg}")
                wav_bytes = client.synthesis(seg, 'zh', 1,
                                             {'spd': 5, 'pit': 5, 'vol': 9, 'per': 0})
                if not isinstance(wav_bytes, bytes):
                    return None
            except Exception as e:
                print('TTS 异常：', e)
                return None
            raw = tmp_base + f'_{idx}_raw.wav'
            with open(raw, 'wb') as f:
                f.write(wav_bytes)
            target = tmp_base + f'_{idx}_16k.wav'
            subprocess.run(['ffmpeg', '-y', '-i', raw,
                            '-ar', '16000', '-ac', '1', '-sample_fmt', 's16',
                            '-b:a', '256k', target],
                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            os.unlink(raw)
            return target

        # 预合成第一段
        next_wav = _preload_one(0)
        if not next_wav:
            continue

        # 顺序播放 & 后台预合成下一段
        for i in range(n):
            if stop_play.is_set():
                try: os.unlink(next_wav)
                except: pass
                break
            # 播放当前段
            print("播放段落", i)
            player = subprocess.Popen(['aplay', '-q', next_wav])
            # 后台开始合成下一段
            if i + 1 < n:
                t = threading.Thread(target=lambda idx: preload_queue.put(_preload_one(idx)),
                                     args=(i + 1,), daemon=True)
                t.start()
            # 等待当前段播完
            while player.poll() is None:
                if stop_play.is_set():
                    player.send_signal(signal.SIGTERM)
                    player.wait(timeout=0.5)
                    break
                time.sleep(0.05)
            try: os.unlink(next_wav)
            except: pass
            if stop_play.is_set():
                break
            # 取出下一段 wav
            if i + 1 < n:
                try:
                    next_wav = preload_queue.get(timeout=10)
                except queue.Empty:
                    next_wav = None
                if not next_wav:
                    break

# 启动播放线程
_play_thread = threading.Thread(target=_play_worker, daemon=True)
_play_thread.start()

# ---------- 7. 录音 ----------
def record_audio(filename=WAV_FILE, silence_sec=SILENCE_SEC, threshold=SILENCE_RMS):
    print("开始录音...")
    max_silent = int(silence_sec * SAMPLE_RATE / FRAME_LEN)
    rec_stream = pa.open(format=pyaudio.paInt16, channels=1,
                         rate=SAMPLE_RATE, input=True,
                         frames_per_buffer=FRAME_LEN * 4)
    frames, silent_frames = [], 0
    for _ in range(max_silent * 10):
        try:
            data = rec_stream.read(FRAME_LEN, exception_on_overflow=False)
        except OSError:
            continue
        frames.append(data)
        pcm = struct.unpack("h" * FRAME_LEN, data)
        rms = (sum(x * x for x in pcm) / FRAME_LEN) ** 0.5
        print(f"\rRMS={rms:.0f} ", end="", flush=True)
        if rms < threshold:
            silent_frames += 1
        else:
            silent_frames = 0
        if silent_frames > max_silent:
            break
    rec_stream.stop_stream(); rec_stream.close()
    print("\n录音结束")
    with wave.open(filename, 'wb') as wf:
        wf.setnchannels(1)
        wf.setsampwidth(pa.get_sample_size(pyaudio.paInt16))
        wf.setframerate(SAMPLE_RATE)
        wf.writeframes(b''.join(frames))
    return filename

# ---------- 8. 语音识别 ----------
def asr(filename):
    with open(filename, 'rb') as f:
        res = client.asr(f.read(), 'wav', 16000, {'dev_pid': 1537})
    return res['result'][0] if res.get('err_no') == 0 else None

# ---------- 9. 主循环：永远检测唤醒词 ----------
try:
    print("等待唤醒词“小派”...")
    while True:
        pcm = kw_stream.read(FRAME_LEN, exception_on_overflow=False)
        pcm = struct.unpack("h" * FRAME_LEN, pcm)
        if porc.process(pcm) >= 0:
            print("\n【唤醒】检测到“小派”！")
            stop_play.set()                 # 1. 立即打断正在进行的播放
            play_prompt(CFG["audio"]["prompt_wav"])

            wav = record_audio()
            play_prompt(CFG["audio"]["confirm_wav"])
            text = asr(wav)
            if text:
                print("识别结果：", text)
                text_queue.put(text)       # 2. 把文本交给后台线程
            else:
                text_queue.put("我没听清，请再说一遍")
            print("等待下次唤醒...")
except KeyboardInterrupt:
    print("\n程序退出")
finally:
    stop_play.set()
    text_queue.put(None)        # 通知播放线程退出
    _play_thread.join(timeout=2)
    kw_stream.close()
    pa.terminate()
    porc.delete()

from aip import AipSpeech
import subprocess
import os

BAIDU = {
    "APP_ID": "替换成你自己的",
    "API_KEY": "替换成你自己的",
    "SECRET_KEY": "替换成你自己的"
}
client = AipSpeech(BAIDU["APP_ID"], BAIDU["API_KEY"], BAIDU["SECRET_KEY"])

def mkwav(text, out_file):
    wav = client.synthesis(text, 'zh', 1, {'spd': 5, 'pit': 5, 'vol': 9, 'per': 0})
    if not isinstance(wav, bytes):
        print('TTS 失败'); return
    tmp = 'tmp.wav'
    with open(tmp, 'wb') as f:
        f.write(wav)
    # 转码成 16kHz 16bit 单声道 256kbps
    subprocess.run(['ffmpeg', '-y', '-i', tmp,
                    '-ar', '16000', '-ac', '1', '-sample_fmt', 's16',
                    '-b:a', '256k', out_file],
                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    os.unlink(tmp)
    print('已生成：', out_file)

mkwav("在呢，请说？", "在呢，请说.wav")
mkwav("收到，我来整理下,请稍等", "收到，我来整理下.wav")

serial = i2c(port=1, address=0x3C)
# 初始化设备，这里改ssd1306, ssd1325, ssd1331, sh1106
device = ssd1306(serial)
imagepath = str(sys.argv[1])

WIDTH = 128
HEIGHT = 64

def resize_image_by_height(image, target_height):
  width, height = image.size
  new_width = int(width * target_height / height)
  resized_image = image.resize((new_width, target_height))
  return resized_image

def resize_image_by_width(image, target_width):
  width, height = image.size
  new_height = int(target_width * height / width)
  resized_image = image.resize((target_width, new_height))
  return resized_image

def AspectRatio(image):
  width, height = image.size
  return width / height

def resize_and_paste(middle_img):
  transparent_image = Image.new('RGBA', (128, 64), color = (0, 0, 0, 0))
  middle_size = middle_img.size
  x = (transparent_image.width - middle_size[0]) // 2
  y = (transparent_image.height - middle_size[1]) // 2
  transparent_image.paste(middle_img, (x, y))
  return transparent_image

while True:
  with Image.open(imagepath) as gif:
    frames = [frame.copy() for frame in ImageSequence.Iterator(gif)]
    for frame in frames:
      if AspectRatio(frame) > 2:
        resized_image = resize_image_by_width(frame, WIDTH)
      else:
        resized_image = resize_image_by_height(frame, HEIGHT) 
      device.display(resize_and_paste(resized_image).convert(device.mode))

# -*- coding: utf-8 -*-
from luma.core.interface.serial import i2c  # , spi
from luma.oled.device import ssd1306  # , ssd1325, ssd1331, sh1106
from PIL import Image, ImageSequence
import sys

WIDTH = 128
HEIGHT = 64

def resize_image_by_height(image, target_height):
  width, height = image.size
  new_width = int(width * target_height / height)
  resized_image = image.resize((new_width, target_height))
  return resized_image

def resize_image_by_width(image, target_width):
  width, height = image.size
  new_height = int(target_width * height / width)
  resized_image = image.resize((target_width, new_height))
  return resized_image

def AspectRatio(image):
  width, height = image.size
  return width / height

def resize_and_paste(middle_img):
  transparent_image = Image.new('RGBA', (128, 64), color = (0, 0, 0, 0))
  middle_size = middle_img.size
  x = (transparent_image.width - middle_size[0]) // 2
  y = (transparent_image.height - middle_size[1]) // 2
  transparent_image.paste(middle_img, (x, y))
  return transparent_image

def main():
  __version__ = 1.0
  print("current version:", __version__)
  # 初始化端口
  serial = i2c(port=1, address=0x3C)
  # 初始化设备，这里改ssd1306, ssd1325, ssd1331, sh1106
  device = ssd1306(serial)
  imagepath = str(sys.argv[1])
  while True:
    with Image.open(imagepath) as gif:
      frames = [frame.copy() for frame in ImageSequence.Iterator(gif)]
      for frame in frames:
        if AspectRatio(frame) > 2:
          resized_image = resize_image_by_width(frame, WIDTH)
        else:
          resized_image = resize_image_by_height(frame, HEIGHT) 
        device.display(resize_and_paste(resized_image).convert(device.mode))
        print("next frame")
    print("replay")

if __name__ == "__main__":
  try:
    main()
  except KeyboardInterrupt:
    pass

# -*- coding: utf-8 -*-
from luma.core.interface.serial import i2c  # , spi
from luma.oled.device import ssd1306  # , ssd1325, ssd1331, sh1106
import cv2
from PIL import Image

cam = cv2.VideoCapture(0)
cam.set(cv2.CAP_PROP_FRAME_WIDTH, 320)  # 设置宽度
cam.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)  # 设置高度
# 初始化端口‌知识产权师
serial = i2c(port=1, address=0x3C)
# 初始化设备，这里改ssd1306, ssd1325, ssd1331, sh1106
device = ssd1306(serial)
while True:
    ret, image = cam.read()
    cv2.imshow(("video"), image)‌知识产权师
    print(image.shape)
    image = cv2.resize(image, (128, 96))
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    h, w = gray_image.shape[:2]
    start_y = h // 6
    end_y = (h * 5) // 6
    gray_image = gray_image[start_y:end_y, :]
    gray_image = cv2.flip(gray_image, 1)
    cv2.imshow(("gray"),gray_image)
    pil_image = Image.fromarray(cv2.cvtColor(gray_image, cv2.COLOR_BGR2RGB))
    print(pil_image.size)
    device.display(pil_image.convert(device.mode))
    k = cv2.waitKey(1)
    if k != -1:
        break
cam.release()
cv2.destroyAllWindows()