git clone https://github.com/PiSugar/Whisplay.git --depth 1

cd Whisplay/Driver

yes | sudo bash install_wm8960_drive.sh

sudo reboot

cd /home/pi/Whisplay/example && python3 test.py

git clone https://github.com/PiSugar/whisplay-ai-chatbot.git

cd whisplay-ai-chatbot

bash install_dependencies.sh

source ~/.bashrc

cp .env.template .env

nano .env

OPENAI_API_KEY=ここに自分のAPIキー

bash build.sh

bash run_chatbot.sh

cd ~/whisplay-ai-chatbot && bash run_chatbot.sh

sudo apt install -y open-jtalk open-jtalk-mecab-naist-jdic hts-voice-nitech-jp-atr503-m001

wget https://downloads.sourceforge.net/project/mmdagent/MMDAgent_Example/MMDAgent_Example-1.8/MMDAgent_Example-1.8.zip

unzip MMDAgent_Example-1.8.zip

sudo cp -r MMDAgent_Example-1.8/Voice/mei /usr/share/hts-voice/

import subprocess

def speak_japanese(text, voice="normal", speed=0.8):
    # voiceで選択できる種類
    # "normal"   : 標準
    # "happy"    : 明るい
    # "angry"    : 怒り
    # "sad"      : 悲しい
    # "bashful"  : 照れ
    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(["aplay", "/tmp/test.wav"])

speak_japanese("こんにちは", "happy")

sudo fuser -k /dev/snd/*

python3 -m venv venv --system-site-packages

source venv/bin/activate

pip install feedparser

import feedparser

url = "https://www.nhk.or.jp/rss/news/cat0.xml"

feed = feedparser.parse(url)

for entry in feed.entries[:5]:
    print(entry.title)

sudo apt install -y python3-opencv

sudo apt install -y fonts-noto-cjk

import cv2
import time
import sys
import os
import numpy as np
from PIL import Image, ImageDraw, ImageFont
import subprocess
import feedparser
import unicodedata
import threading

mode = 0
speech_ready = False

sys.path.append(os.path.abspath("/home/pi/Whisplay/Driver"))
from WhisPlay import WhisPlayBoard

# =========================
# TTS
# =========================
def speak(text, voice="normal", speed=0.9):

    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(["aplay", "/tmp/test.wav"])
    
# =========================
# Init
# =========================
board = WhisPlayBoard()
board.set_backlight(100)

VIDEO_PATH = "/home/pi/matrix.mp4"

font = ImageFont.truetype(
    "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc", 26
)

show_text = False
current_text = ""

# RSS source list (expandable)
RSS_FEEDS = [
    "https://www3.nhk.or.jp/rss/news/cat5.xml"
    #"https://news.yahoo.co.jp/rss/topics/it.xml"
]

def fetch_news():
    headlines = []

    for url in RSS_FEEDS:
        feed = feedparser.parse(url)
        for entry in feed.entries:
            headlines.append(entry.title)

    return headlines

def get_headlines(n=1):
    news = fetch_news()
    return news[:n]

# =========================
# Overlay icon
# =========================
def overlay_icon(frame, icon_path, x, y, size=None):
    base = Image.fromarray(frame).convert("RGBA")
    icon = Image.open(icon_path).convert("RGBA")

    if size:
        icon = icon.resize(size)

    datas = icon.getdata()
    new_data = []
    for item in datas:
        if item[0] > 240 and item[1] > 240 and item[2] > 240:
            new_data.append((255, 255, 255, 0))
        else:
            new_data.append(item)
    icon.putdata(new_data)

    base.paste(icon, (x, y), icon)
    return np.array(base.convert("RGB"))


# =========================
# Button handler
# =========================
def on_button():
    global show_text, current_text, mode, speech_ready

    if mode == 0:
        mode = 1
        show_text = False
        speech_ready = False

        headlines = get_headlines(3)

        for text in headlines:
            current_text = text
            print(text)
            
            speech_ready = True
            show_text = True
            speak(text)

    else:
        mode = 0
        show_text = False
        current_text = ""

board.on_button_press(on_button)

# =========================
# Image processing
# =========================
def zoom_center(frame, zoom=1.2):
    h, w, _ = frame.shape
    new_w = int(w / zoom)
    new_h = int(h / zoom)
    x1 = (w - new_w) // 2
    y1 = (h - new_h) // 2
    cropped = frame[y1:y1+new_h, x1:x1+new_w]
    return cv2.resize(cropped, (w, h))

def frame_to_rgb565(frame):
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    r = (frame[:, :, 0] >> 3).astype('uint16')
    g = (frame[:, :, 1] >> 2).astype('uint16')
    b = (frame[:, :, 2] >> 3).astype('uint16')
    rgb565 = (r << 11) | (g << 5) | b
    high = (rgb565 >> 8).astype('uint8')
    low = (rgb565 & 0xFF).astype('uint8')
    return np.dstack((high, low)).flatten().tolist()

def resize_and_crop(frame):
    h, w, _ = frame.shape
    screen_w = board.LCD_WIDTH
    screen_h = board.LCD_HEIGHT
    aspect = w / h
    screen_aspect = screen_w / screen_h

    if aspect > screen_aspect:
        new_h = screen_h
        new_w = int(new_h * aspect)
        frame = cv2.resize(frame, (new_w, new_h))
        x = (new_w - screen_w) // 2
        frame = frame[:, x:x + screen_w]
    else:
        new_w = screen_w
        new_h = int(new_w / aspect)
        frame = cv2.resize(frame, (new_w, new_h))
        y = (new_h - screen_h) // 2
        frame = frame[y:y + screen_h, :]

    return frame

def split_text(text, max_width=18):
    lines = []
    current = ""
    width = 0

    for ch in text:
        w = 2 if unicodedata.east_asian_width(ch) in "FWA" else 1

        if width + w > max_width:
            lines.append(current)
            current = ch
            width = w
        else:
            current += ch
            width += w

    if current:
        lines.append(current)

    return lines

# =========================
# Draw text
# =========================
def draw_text(frame, text, x, y):
    pil_img = Image.fromarray(frame)
    draw = ImageDraw.Draw(pil_img)

    lines = split_text(text, max_width=18)

    for i, line in enumerate(lines):
        draw.text((x, y + i * 40), line, font=font, fill=(180, 255, 255))

    return np.array(pil_img)

# =========================
# Main loop
# =========================
cap = cv2.VideoCapture(VIDEO_PATH)

if not cap.isOpened():
    print("Failed to open video")
    sys.exit()

try:
    while True:
        ret, frame = cap.read()

        if not ret:
            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
            continue
        frame = cv2.resize(frame, (160, 120))
        frame = resize_and_crop(frame)
        frame = zoom_center(frame, 1.5)

        if show_text and speech_ready:
            frame = overlay_icon(
                frame,
                "/home/pi/icon_speaker.png",
                75,
                0
            )

            frame = draw_text(frame, current_text, 5, 110)

        rgb565 = frame_to_rgb565(frame)

        board.draw_image(
            0, 0,
            board.LCD_WIDTH,
            board.LCD_HEIGHT,
            rgb565
        )

        time.sleep(0.08)

except KeyboardInterrupt:
    pass

finally:
    cap.release()
    board.cleanup()

sudo tee /etc/apt/sources.list.d/hailo.sources <<EOF
Types: deb
URIs: https://hailo:chahy5Zo@extranet.raspberrypi.org/hailo
Suites: trixie
Components: main
Signed-By: /usr/share/keyrings/raspberrypi-archive-keyring.pgp
EOF

sudo apt update

sudo apt full-upgrade -y

sudo reboot

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)

sudo apt install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

sudo systemctl start docker

sudo docker run hello-world

sudo apt install dkms

sudo apt install -y hailo-h10-all

sudo reboot

sudo apt install -y libssl-dev
git clone https://github.com/hailo-ai/hailo_model_zoo_genai.git
cd /home/pi/hailo_model_zoo_genai
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .
mkdir -p ~/.local/bin
cp ./src/apps/server/hailo-ollama ~/.local/bin/
mkdir -p ~/.config/hailo-ollama/
cp ../config/hailo-ollama.json ~/.config/hailo-ollama/
mkdir -p ~/.local/share/hailo-ollama
cp -r ../models/ ~/.local/share/hailo-ollama
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

hailo-ollama

curl --silent http://localhost:8000/hailo/v1/list

curl --silent http://localhost:8000/api/pull \
     -H 'Content-Type: application/json' \
     -d '{ "model": "qwen2:1.5b", "stream" : true }'

curl --silent http://localhost:8000/api/chat \
     -H 'Content-Type: application/json' \
     -d '{"model": "qwen2:1.5b", "messages": [{"role": "user", "content": "Translate to French: The cat is on the table."}]}'

sudo docker pull ghcr.io/open-webui/open-webui:main

sudo docker run -d \
  -e OLLAMA_BASE_URL=http://127.0.0.1:8000 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --network=host \
  --restart always \
  ghcr.io/open-webui/open-webui:main

sudo docker logs open-webui -f

http://127.0.0.1:8080

import requests
import json
import time

# ローカルで起動しているLLMのAPIエンドポイント
url = "http://localhost:8000/api/chat"

# ユーザーの質問
question = "おすすめの気分転換の方法を教えてください。"

payload = {
    # 使用するLLMモデルを指定
    "model": "qwen2:1.5b",
    # "model": "qwen2.5:1.5b",
    # "model": "llama3.2:1b",
    # "model": "deepseek_r1:1.5b",

    # LLMに送る会話内容を指定
    "messages": [
        {"role": "user", "content": question}
    ]
}

# 質問内容を表示
print(f"質問: {question}\n")

# 思考開始時刻を記録
think_start_time = time.time()
print("思考開始\n")

# LLM APIにPOSTリクエストを送信（ストリーミング）
res = requests.post(url, json=payload, stream=True)

answer_started = False        # 回答開始検知フラグ
final_answer = ""             # 回答全文を格納する変数

for line in res.iter_lines():
    if not line:
        continue

    data = json.loads(line.decode("utf-8"))
    content = data.get("message", {}).get("content", "")

    # 回答が初めて返ってきた瞬間
    if content and not answer_started:
        print("回答開始\n")
        answer_started = True

    # 回答内容を逐次表示しつつ、変数に蓄積
    if content:
        print(content, end="", flush=True)
        final_answer += content

    # 回答終了を検知
    if data.get("done"):
        elapsed = time.time() - think_start_time
        print(f"\n\n処理時間: {elapsed:.2f}秒")
        break

hailortcli scan

git clone https://github.com/hailo-ai/hailo-apps.git

cd hailo-apps

python3 -m venv venv --system-site-packages

source venv/bin/activate

sudo apt update
sudo apt install -y portaudio19-dev

pip install -e ".[gen-ai]"

sudo mkdir -p /usr/local/hailo

sudo chown -R pi:pi /usr/local/hailo

python -m hailo_apps.python.gen_ai_apps.simple_vlm_chat.simple_vlm_chat

python -m hailo_apps.python.gen_ai_apps.vlm_chat.vlm_chat --input rpi

import subprocess
import time

# エラー回避のための強制開放（前回プロセスの残骸対策）
subprocess.run(
    "sudo fuser -k /dev/video* /dev/media* /dev/v4l-subdev*",
    shell=True,
    stdout=subprocess.DEVNULL,
    stderr=subprocess.DEVNULL
)
time.sleep(1)

import sys
import time
import signal
import os
import cv2
from typing import Optional

from hailo_apps.python.gen_ai_apps.vlm_chat.backend import Backend
from hailo_apps.python.core.common.core import (
    get_standalone_parser,
    handle_list_models_flag,
    resolve_hef_path,
)
from hailo_apps.python.core.common.defines import (
    VLM_CHAT_APP,
    HAILO10H_ARCH,
)
from hailo_platform import VDevice
from hailo_platform.genai import LLM

def translate_to_japanese(text: str) -> str:
    vdevice_llm = VDevice()
    llm = LLM(vdevice_llm, "/home/pi/models/Qwen2-1.5B-Instruct.hef")
    
    prompt = f"以下の英文を自然で正しい日本語の表現で翻訳してください。難しい漢字を使わないこと\n\n{text}"    
    #print(prompt)

    messages = [
        {"role": "user", "content": prompt}
    ]

    result = ""
    for chunk in llm.generate(messages):
        result += chunk

    llm.release()
    return result.replace("<|im_end|>", "").strip()

# =========================
# 設定
# =========================
WAIT_SECONDS = 3  # 撮影までの待機時間

QUESTION = """
Look at the camera image carefully.
Describe what is happening in the image.
Be concise and clear.
Mention the main subject and important details.
"""
MAX_TOKENS = 30
TEMPERATURE = 0.1
SEED = 42

# 画像説明用のシステムプロンプト
SYSTEM_PROMPT = """
You see images from a camera.
You describe the image clearly and objectively.
Focus on what is visible.
"""
INFERENCE_TIMEOUT = 60
WINDOW_NAME = "Captured Frame"

def extract_model_name(hef_path: str) -> str:
    # hefファイル名からモデル名を取得
    return os.path.splitext(os.path.basename(hef_path))[0]

class OneShotVLMApp:
    def __init__(self, hef_path: str):
        self.hef_path = hef_path
        self.backend: Optional[Backend] = None
        self.running = True
        signal.signal(signal.SIGINT, self._signal_handler)

    def _signal_handler(self, sig, frame):
        self.running = False

    def _init_camera(self):
        from picamera2 import Picamera2
        from libcamera import controls

        picam2 = Picamera2()
        config = picam2.create_preview_configuration(
            main={"size": (320, 240), "format": "RGB888"}
        )
        picam2.configure(config)
        picam2.start()
        
        # オートフォーカス設定
        picam2.set_controls({
            "AfMode": controls.AfModeEnum.Continuous,
            "AfSpeed": controls.AfSpeedEnum.Fast,
        })
        return picam2

    def _init_backend(self):
        # Hailo VLMバックエンド初期化
        self.backend = Backend(
            hef_path=self.hef_path,
            max_tokens=MAX_TOKENS,
            temperature=TEMPERATURE,
            seed=SEED,
            system_prompt=SYSTEM_PROMPT,
        )

    def run(self):
        
        picam2 = self._init_camera()
        self._init_backend()

        cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_AUTOSIZE)

        # ---------- ライブ表示 ----------
        while self.running:

            start_time = time.time()
            captured_frame = None
            
            while self.running and captured_frame is None:
                frame = picam2.capture_array()
                rgb_frame = Backend.convert_resize_image(frame)
                bgr_frame = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2BGR)

                cv2.imshow(WINDOW_NAME, bgr_frame)
                
                # 指定時間経過で撮影
                if (time.time() - start_time) >= WAIT_SECONDS:
                    captured_frame = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2BGR)
                    break

                if cv2.waitKey(1) & 0xFF == ord("q"):
                    self.running = False
                    break
                
            if not self.running:
                break
        
            loop_start = time.perf_counter()
            t0 = time.perf_counter()
                    
            # VLM推論を実行（画像→テキスト生成）
            result = self.backend.vlm_inference(
                captured_frame,
                QUESTION,
                INFERENCE_TIMEOUT,
            )
            t1 = time.perf_counter()
            inference_time = t1 - t0
            
            answer_text = result.get("answer", "回答を取得できませんでした")

            model_name = extract_model_name(self.hef_path)

            print("\n=====================================\n")
            print("---------- 実行情報 ----------")
            print(f"モデル名   ：{model_name}")
            print(f"VLM推論時間   ：{inference_time:.2f}秒")
            print("------------------------------\n")
                    
            # Hailoデバイス解放
            self.backend.close()
                             
            # 翻訳 -----------------------------------------------
            t2 = time.perf_counter()

            translated_text = translate_to_japanese(answer_text)
            print(translated_text)
            
            t3 = time.perf_counter()
            llm_time = t3 - t2            
                    
            total_time = time.perf_counter() - loop_start # トータル時間計算
                    
            print("\n---------- 処理時間 ----------")
            print(f"LLM推論時間   ：{llm_time:.2f}秒")
            print(f"トータル時間 ：{total_time:.2f}秒")
            print("------------------------------\n")

            self._init_backend()
            time.sleep(1)

            if cv2.waitKey(30) & 0xFF == ord("q"):
                break

if __name__ == "__main__":
    parser = get_standalone_parser()
    handle_list_models_flag(parser, VLM_CHAT_APP)
    options = parser.parse_args()

    hef_path = resolve_hef_path(
        options.hef_path if hasattr(options, "hef_path") else None,
        app_name=VLM_CHAT_APP,
        arch=HAILO10H_ARCH,
    )

    if hef_path is None:
        sys.exit(1)

    OneShotVLMApp(str(hef_path)).run()
    sys.exit(0)

git clone https://github.com/PiSugar/Whisplay.git --depth 1
cd Whisplay/Driver
sudo bash install_wm8960_drive.sh
sudo reboot

hailo-audio-troubleshoot --install-tts

python -c "from hailo_apps.python.gen_ai_apps.gen_ai_utils.voice_processing.text_to_speech import TextToSpeechProcessor as T; t=T(); t.queue_text('Hello, how are you today?'); t.wait_for_completion()"

sudo apt install -y open-jtalk open-jtalk-mecab-naist-jdic hts-voice-nitech-jp-atr503-m001

sudo apt install -y open-jtalk-mecab-naist-jdic hts-voice-nitech-jp-atr503-m001

echo "こんにちは" | open_jtalk -x /var/lib/mecab/dic/open-jtalk/naist-jdic -m /usr/share/hts-voice/nitech-jp-atr503-m001/nitech_jp_atr503_m001.htsvoice -ow /tmp/test.wav && aplay /tmp/test.wav

wget https://downloads.sourceforge.net/project/mmdagent/MMDAgent_Example/MMDAgent_Example-1.8/MMDAgent_Example-1.8.zip

unzip MMDAgent_Example-1.8.zip

sudo cp -r MMDAgent_Example-1.8/Voice/mei /usr/share/hts-voice/

import subprocess

def speak_japanese(text, voice="normal", speed=0.8):
    # voiceで選択できる種類
    # "normal"   : 標準
    # "happy"    : 明るい
    # "angry"    : 怒り
    # "sad"      : 悲しい
    # "bashful"  : 照れ
    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(["aplay", "/tmp/test.wav"])

speak_japanese("こんにちは", "happy")

cd hailo-apps && source venv/bin/activate

python -m hailo_apps.python.gen_ai_apps.voice_assistant.voice_assistant

mkdir -p /home/pi/models

mv /home/pi/ダウンロード/Qwen2-1.5B-Instruct.hef /home/pi/models/

LLM_PROMPT_PREFIX = "日本語で答えてください。\n"

nano ~/hailo-apps/hailo_apps/python/gen_ai_apps/voice_assistant/tts_openjtalk.py

import subprocess

def speak_japanese(text, voice="normal", speed=0.8):
    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(
        ["aplay", "/tmp/test.wav"],
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL
    )

from .tts_openjtalk import speak_japanese

def collect_callback(chunk: str):
    nonlocal response_text
    response_text += chunk

python -m hailo_apps.python.gen_ai_apps.voice_assistant.voice_assistant --no-tts

sudo apt install python3-opencv

sudo apt install -y opencv-data

import cv2
import smbus
from ht16k33segment_python import HT16K33Segment
from luma.led_matrix.device import max7219
from luma.core.interface.serial import spi, noop
from luma.core.legacy import show_message
from luma.core.legacy.font import proportional, CP437_FONT
import HD44780MCP
import MCP230XX
import threading
import time

# -----------------------------
# Haar Cascade configuration
# -----------------------------
HAAR_FILE = "/usr/share/opencv4/haarcascades/haarcascade_frontalface_default.xml"
cascade = cv2.CascadeClassifier(HAAR_FILE)

if cascade.empty():
    raise RuntimeError("Failed to load Haar Cascade XML file")

# -----------------------------
# 7-segment display (HT16K33) configuration
# -----------------------------
i2c = smbus.SMBus(1)
led = HT16K33Segment(i2c)
led.set_brightness(10)

# Initialize MCP
i2cAddr = 0x21
MCP = MCP230XX.MCP230XX('MCP23008', i2cAddr)

# Backlight ON
blPin = 7
MCP.set_mode(blPin, 'output')
MCP.output(blPin, True)

# Initialize LCD (16x2)
LCD = HD44780MCP.HD44780(MCP, 1, -1, 2, [3,4,5,6], rows = 2, characters = 16, mode = 0, font = 0)

LCD.clear_display()
LCD.cursor(False)

def display_count(value):
    """Display a count value (0?9999) on the 7-segment LED."""
    value = max(0, min(9999, value))
    bcd = int(str(value), 16)

    led.set_number((bcd & 0xF000) >> 12, 0)
    led.set_number((bcd & 0x0F00) >> 8, 1)
    led.set_number((bcd & 0x00F0) >> 4, 2)
    led.set_number((bcd & 0x000F), 3)
    led.update()
    
def show_detect_message():
    """Show 'detect' message on MAX7219 LED matrix."""
    serial = spi(port=0, device=1, gpio=noop())
    device = max7219(
        serial,
        cascaded=1,
        block_orientation=90,
        rotate=0
    )

    show_message(
        device,
        "detect",
        fill="white",
        font=proportional(CP437_FONT),
        scroll_delay=0.05
    )    

def lcd_show_detect():
    LCD.clear_display()
    LCD.set_cursor(0, 0)
    LCD.display_string("detect!")

# -----------------------------
# Camera configuration
# -----------------------------
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*'MJPG'))
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 800)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)

detect_count = 0
prev_detected = False
lcd_active = False

cooldown_frames = 20
cooldown_counter = 0

display_count(detect_count)

# -----------------------------
# Main loop
# -----------------------------
while True:
    ret, frame = cap.read()
    if not ret:
        break

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = cascade.detectMultiScale(
        gray,
        scaleFactor=1.2,
        minNeighbors=5,
        minSize=(80, 80)
    )

    detected = len(faces) > 0

    # Case 1: detection starts (False -> True) and cooldown is over
    if detected and not prev_detected and cooldown_counter == 0:
        detect_count += 1
        display_count(detect_count)     # 7-segment update
        lcd_show_detect()               # LCD update
        #lcd_active = True
        # Run MAX7219 message in a separate thread
        threading.Thread(
            target=show_detect_message,
            daemon=True
        ).start()            

    # Case 2: detection ends (True -> False), start cooldown
    if not detected and prev_detected:
        cooldown_counter = cooldown_frames
        
    if cooldown_counter == 0 and not detected:
        LCD.clear_display()
        #lcd_active = False        

    # Decrease cooldown after detection has ended
    if cooldown_counter > 0:
        cooldown_counter -= 1

    prev_detected = detected

    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)

    cv2.imshow("Face Detection Counter", frame)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

# -----------------------------
# Cleanup
# -----------------------------
cap.release()
cv2.destroyAllWindows()
led.clear()
led.update()

sudo apt install rpi-keyboard-config

rpi-keyboard-config leds set --colour red  

rpi-keyboard-config game

from RPiKeyboardConfig import RPiKeyboardConfig

# キーボード制御を初期化
keyboard = RPiKeyboardConfig()

# LEDを直接制御するモードに切り替え
keyboard.set_led_direct_effect()

# 行0・列0のLEDを「ピンク」で点灯（Hue=213）
keyboard.set_led_by_matrix(matrix=[0, 0], colour=(213, 255, 255))

# 設定を反映して実際に光らせる
keyboard.send_leds()

import time
from RPiKeyboardConfig import RPiKeyboardConfig

font_5x4 = {
    "0": ["0110","1001","1001","1001","0100"],
    "1": ["0010","0010","0010","0010","0010"],
    "2": ["0110","1001","0010","0100","1111"],
    "3": ["1110","0001","0110","0001","1110"],
    "4": ["1001","1001","1111","0001","0001"],
    "5": ["1111","1000","1110","0001","1110"],
    "6": ["0111","1000","1110","1001","0110"],
    "7": ["1111","0001","0010","0100","0100"],
    "8": ["0110","1001","0110","1001","0110"],
    "9": ["0110","1001","0111","0001","1110"],
    ":": ["000","010","000","010","000"],
}

keyboard = RPiKeyboardConfig()
keyboard.set_led_direct_effect()

current_brightness = keyboard.get_brightness()
print(f"Current brightness: {current_brightness}")

rows = 5
max_col = 16
scroll_area_cols = 16

def build_message(numbers, space=1):
    message = [""] * rows
    for num in numbers:
        digit = font_5x4[num]
        for r in range(rows):
            message[r] += digit[r] + "0" * space
    return message

while True:
    current_time = time.strftime("%H:%M").lstrip("0")
    message = build_message(current_time, space=2)
    msg_width = len(message[0])

    for shift in range(msg_width + scroll_area_cols):
        for r in range(rows):
            for c in range(scroll_area_cols):
                try:
                    keyboard.set_led_by_matrix(matrix=[r, c], colour=(0, 0, 0))
                except ValueError:
                    pass

        for r in range(rows):
            for c in range(scroll_area_cols):
                src_col = shift + c - scroll_area_cols
                if 0 <= src_col < msg_width:
                    if message[r][src_col] == "1":
                        try:
                            keyboard.set_led_by_matrix(matrix=[r, c], colour=(213, 255, 255))
                        except ValueError:
                            pass

        keyboard.send_leds()
        time.sleep(0.15)

sudo apt install -y fonts-takao

import spidev
import lgpio
from PIL import Image, ImageDraw, ImageFont
from math import sin, cos, radians
import datetime
import time

spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 8000000

DC = 25
RESET = 27

h = lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h, DC)
lgpio.gpio_claim_output(h, RESET)

WIDTH = 128
HEIGHT = 64

def hardware_reset():
    lgpio.gpio_write(h, RESET, 0)
    time.sleep(0.05)
    lgpio.gpio_write(h, RESET, 1)
    time.sleep(0.05)

def send_cmd(cmd):
    lgpio.gpio_write(h, DC, 0)
    spi.writebytes([cmd])

def send_data(data):
    lgpio.gpio_write(h, DC, 1)
    spi.writebytes(data if isinstance(data, list) else [data])

def init_display():
    hardware_reset() 
    cmds = [
        0xAE, 0xD5, 0x80, 0xA8, 0x3F, 0xD3, 0x00,
        0x40, 0x8D, 0x14, 0x20, 0x00, 0xA1, 0xC8,
        0xDA, 0x12, 0x81, 0xCF, 0xD9, 0xF1, 0xDB,
        0x40, 0xA4, 0xA6, 0xAF
    ]
    for cmd in cmds:
        send_cmd(cmd)

def set_addressing():
    send_cmd(0x21)
    send_cmd(0)
    send_cmd(WIDTH - 1)
    send_cmd(0x22)
    send_cmd(0)
    send_cmd((HEIGHT // 8) - 1)

def display_image(image):
    set_addressing()
    pixels = list(image.getdata())
    buffer = []
    for page in range(HEIGHT // 8):
        for x in range(WIDTH):
            byte = 0
            for bit in range(8):
                pixel = pixels[x + (page * 8 + bit) * WIDTH]
                if pixel == 0:
                    byte |= (1 << bit)
            buffer.append(byte)
    for b in buffer:
        send_data(b)

init_display()

font1 = ImageFont.truetype("/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf", 12)
font2 = ImageFont.truetype("/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf", 14)
font3 = ImageFont.truetype("/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf", 24)

scale_factor = 0.7
x_offset = 25
X_CENTER = 64
Y_CENTER = 28
pyramid = ((0, -20, 0), (-20, 20, -20), (20, 20, -20), (0, 20, 20))

try:
    while True:
        for angle in range(0, 361, 10):
            dt_now = datetime.datetime.now()
            date1 = dt_now.strftime('%m/%d')
            weekday = dt_now.strftime('%a').upper()
            time1 = dt_now.strftime('%H:%M')
            second = dt_now.strftime('%S')

            f = [[0.0 for _ in range(3)] for _ in range(4)]
            r = radians(angle)

            for i in range(4):
                x1 = pyramid[i][2] * sin(r) + pyramid[i][0] * cos(r)
                ya = pyramid[i][1]
                z1 = pyramid[i][2] * cos(r) - pyramid[i][0] * sin(r)
                y2 = ya * cos(r) - z1 * sin(r)
                z2 = ya * sin(r) + z1 * cos(r)
                x3 = (x1 * cos(r) - y2 * sin(r)) * scale_factor + x_offset
                y3 = (x1 * sin(r) + y2 * cos(r)) * scale_factor + Y_CENTER
                f[i][0] = x3
                f[i][1] = y3

            image = Image.new("1", (WIDTH, HEIGHT), 255)
            draw = ImageDraw.Draw(image)

            for i in range(3):
                draw.line((f[0][0], f[0][1], f[i + 1][0], f[i + 1][1]), fill=0)
                draw.line((f[i + 1][0], f[i + 1][1], f[(i + 1) % 3 + 1][0], f[(i + 1) % 3 + 1][1]), fill=0)

            draw.text((55, 8), date1, font=font2, fill=0)
            draw.text((103, 8), weekday, font=font2, fill=0)
            draw.text((50, 29), time1, font=font3, fill=0)
            draw.text((114, 39), second, font=font1, fill=0)

            display_image(image)
            time.sleep(0.1)

except KeyboardInterrupt:
    pass

import time

temps = []

for _ in range(60):
    try:
        with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
            temp = int(f.read()) / 1000.0  # 単位はミリ度 → 度に変換
            temps.append(temp)
            print(f"現在の温度: {temp:.2f}℃")
    except Exception as e:
        print("温度の読み取りに失敗しました:", e)
    time.sleep(1)

average = sum(temps) / len(temps) if temps else 0
print(f"\n1分間の平均温度: {average:.2f}℃")

sudo apt install fonts-takao

import time
import psutil
from collections import deque
from PIL import Image, ImageDraw, ImageFont
from board import SCK, MOSI, MISO, D5, D18, D23, D24
from busio import SPI
from digitalio import DigitalInOut, Direction
from adafruit_rgb_display.ili9341 import ILI9341

def get_cpu_temp():
    try:
        with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
            return int(f.read()) / 1000.0
    except:
        return None
    
CS = DigitalInOut(D5)
DC = DigitalInOut(D24)
RST = DigitalInOut(D23)
BL = DigitalInOut(D18)
BL.direction = Direction.OUTPUT
BL.value = True

spi = SPI(clock=SCK, MOSI=MOSI, MISO=MISO)
display = ILI9341(spi, cs=CS, dc=DC, rst=RST, width=240, height=320)    

cpu_history = deque(maxlen=30)
temp_history = deque(maxlen=30)

font_path = "/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf"
font_l = ImageFont.truetype(font_path, 30)
font = ImageFont.truetype(font_path, 24)

bar_width = 5.4
base_y_cpu = 115
base_y_temp = 260
cpu_graph_height = 100
temp_graph_height = 100

while True:
    cpu = psutil.cpu_percent()
    temp = get_cpu_temp() or 0
    cpu_history.append(cpu)
    temp_history.append(temp)

    cpu_min = max(0, min(cpu_history) - 1)
    cpu_max = min(100, max(cpu_history) + 5)
    cpu_range = max(cpu_max - cpu_min, 1)

    temp_min = max(0, min(temp_history) - 3)
    temp_max = max(temp_history) + 1
    temp_range = max(temp_max - temp_min, 1)

    image = Image.new("RGB", (240, 320), (0, 0, 0))
    draw = ImageDraw.Draw(image)

    draw.text((170, 10), "CPU", font=font_l, fill=(255, 255, 255))
    draw.text((170, 85), f"{cpu:.1f}%", font=font, fill=(255, 255, 255))

    for i in range(1, len(cpu_history)):
        x1 = int((i - 1) * bar_width) + 5
        y1 = base_y_cpu - int((cpu_history[i - 1] - cpu_min) / cpu_range * cpu_graph_height)
        x2 = int(i * bar_width) + 5
        y2 = base_y_cpu - int((cpu_history[i] - cpu_min) / cpu_range * cpu_graph_height)
        draw.line((x1, y1, x2, y2), fill=(255, 255, 255))

    draw.text((170, base_y_temp - 55), f"{temp:.1f}℃", font=font, fill=(255, 255, 255))

    for i, t in enumerate(temp_history):
        h = int((t - temp_min) / temp_range * temp_graph_height)
        x = i * bar_width
        if x + bar_width <= 240:
            draw.rectangle((x, base_y_temp - h, x + bar_width - 1, base_y_temp), fill=(255, 255, 255))

    rotated = image.rotate(90, expand=True)
    resized = rotated.resize((240, 320))
    display.image(resized)

    time.sleep(1)

sudo apt update

sudo apt install samba -y

mkdir /home/pi/share

chmod 777 /home/pi/share

sudo nano /etc/samba/smb.conf

[Share]
   path = /home/pi/share
   browseable = yes
   writable = yes
   guest ok = no
   valid users = pi

 vfs objects = fruit streams_xattr

sudo smbpasswd -a pi

sudo systemctl restart smbd

sudo apt remove samba samba-common -y

ssh ユーザー名@ホスト名.local

sudo raspi-config nonint do_vnc 0

hostname -I

sudo apt update

sudo apt upgrade -y

sudo raspi-config nonint do_change_locale ja_JP.UTF-8

sudo apt install -y fcitx5-mozc

sudo reboot

python3 -m venv ~/myenv --system-site-packages

source myenv/bin/activate

pip install --upgrade pip

pip install adafruit-circuitpython-rgb-display

from board import SCK, MOSI, MISO, D5, D18, D23, D24
from busio import SPI
from digitalio import DigitalInOut, Direction
from adafruit_rgb_display.ili9341 import ILI9341
from PIL import Image, ImageDraw, ImageFont

# Setup GPIO pins for display
CS = DigitalInOut(D5)
DC = DigitalInOut(D24)
RST = DigitalInOut(D23)
BL = DigitalInOut(D18)
BL.direction = Direction.OUTPUT
BL.value = True  # Turn on backlight

# Initialize SPI and display
spi = SPI(clock=SCK, MOSI=MOSI, MISO=MISO)
display = ILI9341(spi, cs=CS, dc=DC, rst=RST, width=240, height=320)

# Create a red image
image = Image.new("RGB", (240, 320), (255, 0, 0))
draw = ImageDraw.Draw(image)

# Load default font
font = ImageFont.load_default()

# Draw text
draw.text((20, 150), "Hello, ILI9341!", font=font, fill=(255, 255, 255))

# Display the image
display.image(image)

import time
import requests
from PIL import Image, ImageDraw
from io import BytesIO

from board import SCK, MOSI, MISO, D5, D18, D23, D24
from busio import SPI
from digitalio import DigitalInOut, Direction
from adafruit_rgb_display.ili9341 import ILI9341

# --- Display setup ---
CS = DigitalInOut(D5)
DC = DigitalInOut(D24)
RST = DigitalInOut(D23)
BL = DigitalInOut(D18)
BL.direction = Direction.OUTPUT
BL.value = True

spi = SPI(clock=SCK, MOSI=MOSI, MISO=MISO)
display = ILI9341(spi, cs=CS, dc=DC, rst=RST, width=240, height=320)

# ひまわりの最新画像を取得する関数
def fetch_image():
    url = "http://agora.ex.nii.ac.jp/digital-typhoon/latest/globe/512x512/ir.jpg"
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        img = Image.open(BytesIO(response.content)).convert("RGB")
        return img
    except Exception as e:
        print("Fetch failed:", e)
        return None

# 表示用に画像を整形する関数
def prepare_image(img):
    img = img.rotate(90, expand=True) # 表示向きに90度回転 
    img = img.resize((240, 240))      # ディスプレイ用にサイズ変更

    # 円形マスクを作成して地球部分だけを切り抜き
    mask = Image.new("L", (240, 240), 0)
    draw = ImageDraw.Draw(mask)
    draw.ellipse((0, 0, 240, 240), fill=255)

    black_bg = Image.new("RGB", (240, 240), (0, 0, 0))       # 黒背景画像
    earth_only = Image.composite(img, black_bg, mask)        # 円形で切り抜いた画像と合成

    canvas = Image.new("RGB", (240, 320), (0, 0, 0))
    canvas.paste(earth_only, (0, 40))
    return canvas

# --- メインループ ---
last_canvas = None

while True:
    img = fetch_image()
    if img:
        last_canvas = prepare_image(img)
        print("New image fetched and prepared.")
    else:
        print("Using previous image.")

    if last_canvas:
        display.image(last_canvas)

    time.sleep(600)  # 10 minutes

import os
import requests
from datetime import datetime, timedelta, timezone
from PIL import Image
from io import BytesIO
import time

# Constants
IMAGE_DIR = "/home/pi/image"
MAX_IMAGES = 144
INTERVAL = 8 * 60  # 8 minutes

# JST timezone
JST = timezone(timedelta(hours=9))

# Ensure image directory exists
os.makedirs(IMAGE_DIR, exist_ok=True)

# 最新の保存済み画像の時刻を取得する
def get_latest_saved_time():
    files = sorted(f for f in os.listdir(IMAGE_DIR) if f.endswith(".bmp"))
    if not files:
        return None
    latest_file = files[-1]
    try:
        dt = datetime.strptime(latest_file[:13], "%Y%m%d_%H%M")  # ?: "20250612_1530"
        return dt
    except Exception:
        return None

# 指定時刻から取得候補となる「分」のリストを返す（10分刻み）
def generate_valid_minute_slots(base_time_utc, full=False):
    if full:
        return ["50", "40", "30", "20", "10", "00"]
    current_minute = int(base_time_utc.strftime('%M'))
    return [f"{m:02d}" for m in [50, 40, 30, 20, 10, 0] if m <= current_minute]

# 指定された画像を保存する（JSTのタイムスタンプをファイル名に付ける）
def save_image(canvas, jst_dt):
    filename = jst_dt.strftime("%Y%m%d_%H%M") + ".bmp"
    filepath = os.path.join(IMAGE_DIR, filename)
    canvas.save(filepath, format="BMP")
    print(f"Saved: {filepath}\n")

# 古い画像を削除して、最大枚数を超えないようにする
def cleanup_old_images():
    files = sorted(f for f in os.listdir(IMAGE_DIR) if f.endswith(".bmp"))
    print(len(files))
    while len(files) > MAX_IMAGES:
        os.remove(os.path.join(IMAGE_DIR, files[0]))
        print("Deleted:", files[0])
        files.pop(0)

# 指定したUTC時刻をもとに画像を取得し、保存・整理を行う
def try_fetch_and_save(base_time_utc, full_range=False):
    date_str = base_time_utc.strftime('%Y/%m/%d')
    base_date_str = base_time_utc.strftime('%Y%m%d')
    hour_str = base_time_utc.strftime('%H')
    minute_slots = generate_valid_minute_slots(base_time_utc, full=full_range)

    for mnt in minute_slots:
        time_str = f"{base_date_str}{hour_str}{mnt}"
        url = f"http://agora.ex.nii.ac.jp/digital-typhoon/iiif/{date_str}/{time_str}00.tif/0,0,11000,11000/688,/0/default.jpg"

        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            img = Image.open(BytesIO(response.content)).rotate(90, expand=True)
            img = img.resize((240, 240))
            canvas = Image.new("RGB", (240, 320), (0, 0, 0))
            canvas.paste(img, (0, 40))
            jst_dt = datetime.strptime(time_str + "00", "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc).astimezone(JST)
            save_image(canvas, jst_dt)
            cleanup_old_images()
            return True
        except Exception:
            jst_dt = datetime.strptime(time_str + "00", "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc).astimezone(JST)
            print("No data time (JST):", jst_dt.strftime("%Y/%m/%d %H:%M:%S"))
            time.sleep(2)
    return False

# Main loop
while True:
    wait_after_backfill = False

    latest_jst = get_latest_saved_time()
    if latest_jst:
        target_jst = latest_jst - timedelta(minutes=10)
        filename = target_jst.strftime("%Y%m%d_%H%M") + ".bmp"
        filepath = os.path.join(IMAGE_DIR, filename)
        if not os.path.exists(filepath):
            print("Trying backfill for:", filename)
            target_utc = target_jst.astimezone(timezone.utc)
            if try_fetch_and_save(target_utc):
                wait_after_backfill = True

    if wait_after_backfill:
        time.sleep(5)

    now_utc = datetime.now(timezone.utc)
    if not try_fetch_and_save(now_utc):
        print("Retrying with 1 hour earlier...")
        try_fetch_and_save(now_utc - timedelta(hours=1), full_range=True)

    time.sleep(INTERVAL)

url = f"http://agora.ex.nii.ac.jp/digital-typhoon/iiif/{date_str}/{time_str}00.tif/0,0,11000,11000/688,/0/default.jpg"

python3 himawari_image_save.py

import glob
import time
from PIL import Image

from board import SCK, MOSI, MISO, D5, D18, D23, D24
from busio import SPI
from digitalio import DigitalInOut, Direction
from adafruit_rgb_display.ili9341 import ILI9341

# Setup GPIO pins for display
CS = DigitalInOut(D5)
DC = DigitalInOut(D24)
RST = DigitalInOut(D23)
BL = DigitalInOut(D18)
BL.direction = Direction.OUTPUT
BL.value = True  # Turn on backlight

# Initialize SPI and display
spi = SPI(clock=SCK, MOSI=MOSI, MISO=MISO)
display = ILI9341(spi, cs=CS, dc=DC, rst=RST, width=240, height=320)

while True:
    # 画像フォルダからBMPファイルをすべて取得し、名前順に並べる
    image_files = sorted(glob.glob("/home/pi/image/*.bmp"))

    # 画像を1枚ずつ表示
    for filepath in image_files:
        img = Image.open(filepath)
        display.image(img)
        time.sleep(0.01)

    time.sleep(5)  # 5秒待ってから画像リストを再取得（新しい画像が増えている可能性があるため）

import glob
import time
from PIL import Image
import cv2
import numpy as np

# ウィンドウサイズ
WIDTH = 480
HEIGHT = 480
WINDOW_NAME = "Earth Viewer"

# OpenCVウィンドウを全画面で作成
cv2.namedWindow(WINDOW_NAME, cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty(WINDOW_NAME, cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)

while True:
    # 画像ファイルを時刻順に取得
    image_files = sorted(glob.glob("/home/pi/image/*.bmp"))

    for filepath in image_files:
        # BMP画像を開いてNumPy配列に変換
        pil_img = Image.open(filepath).convert("RGB")

        # 背景キャンバスを作成（黒背景）
        canvas = Image.new("RGB", (WIDTH, HEIGHT), (0, 0, 0))
        
        # PILで中心に貼り付ける位置を計算
        img_w, img_h = pil_img.size
        pos_x = (WIDTH - img_w) // 2
        pos_y = (HEIGHT - img_h) // 2
        canvas.paste(pil_img, (pos_x, pos_y))

        # NumPy配列に変換 → BGRに変換（OpenCV用）
        img_np = np.array(canvas)
        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)

        # 表示
        cv2.imshow(WINDOW_NAME, img_bgr)

        # ESCキーが押されたら終了（27はESCのキーコード）
        if cv2.waitKey(10) == 27:
            cv2.destroyAllWindows()
            exit()

    time.sleep(5)

sudo apt install python3-opencv

wget https://www.flightaware.com/adsb/piaware/files/packages/pool/piaware/f/flightaware-apt-repository/flightaware-apt-repository_1.2_all.deb

sudo dpkg -i flightaware-apt-repository_1.2_all.deb

sudo apt update

sudo apt install -y dump1090-fa

sudo systemctl enable dump1090-fa

sudo apt install -y python3-opencv

sudo reboot

sudo systemctl status dump1090-fa

echo "blacklist dvb_usb_rtl28xxu" | sudo tee /etc/modprobe.d/blacklist-rtl.conf
echo "blacklist rtl2832" | sudo tee -a /etc/modprobe.d/blacklist-rtl.conf
echo "blacklist rtl2830" | sudo tee -a /etc/modprobe.d/blacklist-rtl.conf

sudo systemctl status dump1090-fa

import time
import requests

# 航空機データを取得する関数
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# 10秒ごとに航空機データを表示
while True:
    aircraft_list = get_aircraft_positions()

    print(f"現在受信中の航空機数: {len(aircraft_list)} 機")
    for a in aircraft_list:
        hex_id = a.get('hex', '不明')
        flight = a.get('flight', hex_id).strip()
        lat = a.get('lat')
        lon = a.get('lon')
        alt = a.get('alt_baro', '不明')
        speed = a.get('gs', '不明')
        track = a.get('track', '不明')

        print(f"便名: {flight} | 緯度: {lat} | 経度: {lon} | 高度: {alt} ft | 速度: {speed} kt | 方位: {track}°")

    # 10秒待機
    time.sleep(10)

import time
import requests
import math

# 自宅の緯度・経度に変更してください（例：東京駅付近）
HOME_LAT = 35.681236
HOME_LON = 139.767125

# 航空機データを取得する関数
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# ハーサイン距離計算（地球上の2点間の距離をkmで返す）
def haversine(lat1, lon1, lat2, lon2):
    R = 6371.0  # 地球の半径 (km)
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)
    dlat = lat2_rad - lat1_rad
    dlon = lon2_rad - lon1_rad
    a = math.sin(dlat/2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon/2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    return R * c

# 10秒ごとに一番近い航空機を表示
while True:
    aircraft_list = get_aircraft_positions()
    closest = None
    min_distance = float('inf')

    for a in aircraft_list:
        lat = a.get('lat')
        lon = a.get('lon')
        if lat is not None and lon is not None:
            distance = haversine(HOME_LAT, HOME_LON, lat, lon)
            if distance < min_distance:
                min_distance = distance
                closest = a

    if closest:
        flight = closest.get('flight', closest.get('hex', '不明')).strip()
        print(f"最も近い便名: {flight} | 自宅からの距離: {min_distance:.2f} km")
    else:
        print("航空機データが取得できませんでした。")

    time.sleep(10)

sudo raspi-config nonint do_i2c 0

import smbus
import time
import requests
import math

ADDR = 0x27 # LCDのI2Cアドレス（例: 0x27や0x3F、使用前にi2cdetectで確認）
bus = smbus.SMBus(1)

# 自宅の緯度・経度に変更してください（例：東京駅付近）
HOME_LAT = 35.681236
HOME_LON = 139.767125

def write(data, mode=0):
    for val in [(data & 0xF0), ((data << 4) & 0xF0)]:
        b = val | mode | 0x08
        bus.write_byte(ADDR, b | 0x04)
        time.sleep(0.0005)
        bus.write_byte(ADDR, b)

def init():
    for cmd in [0x33, 0x32, 0x06, 0x0C, 0x28, 0x01]:
        write(cmd)
    time.sleep(0.001)

def message(text, row=0, col=0):
    addr = 0x80 + col if row == 0 else 0xC0 + col
    write(addr)
    for c in text.ljust(16 - col):
        write(ord(c), 1)

# 航空機データを取得する関数
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# ハーサイン距離計算（地球上の2点間の距離をkmで返す）
def haversine(lat1, lon1, lat2, lon2):
    R = 6371.0  # 地球の半径 (km)
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)
    dlat = lat2_rad - lat1_rad
    dlon = lon2_rad - lon1_rad
    a = math.sin(dlat/2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon/2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    return R * c

prev_line1 = ""
prev_line2 = ""

while True:
    aircraft_list = get_aircraft_positions()
    closest = None
    min_distance = float('inf')

    for a in aircraft_list:
        lat = a.get('lat')
        lon = a.get('lon')
        if lat is not None and lon is not None:
            distance = haversine(HOME_LAT, HOME_LON, lat, lon)
            if distance < min_distance:
                min_distance = distance
                closest = a

    if closest:
        flight = closest.get('flight', closest.get('hex', 'UNKNOWN')).strip()
        line1 = flight
        line2 = "Dist: {:.2f} km".format(min_distance)
    else:
        line1 = "No aircraft"
        line2 = "in range"

    # 表示内容に変化があるときだけ更新
    if line1 != prev_line1 or line2 != prev_line2:
        print(f"Updating display:\n{line1}\n{line2}")
        init()
        message(line1, row=0, col=0)
        message(line2, row=1, col=2)
        prev_line1 = line1
        prev_line2 = line2

    time.sleep(2)

import cv2
import requests
import numpy as np
import math
import time

# 自宅の緯度経度（例：東京駅周辺）
HOME_LAT = 35.6812
HOME_LON = 139.7671

# ウィンドウサイズと中心座標
WIDTH = 480
HEIGHT = 480
CENTER_X = WIDTH // 2
CENTER_Y = HEIGHT // 2

# 縮尺（緯度経度 → ピクセル）
SCALE = 400

# 航空機データ取得関数
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# 点線円を描く関数    
def draw_dotted_circle(img, center, radius, color=(0, 255, 0), spacing=2, dot_length=1):
    cx, cy = center
    circumference = 2 * math.pi * radius
    steps = int(circumference / (spacing + dot_length))

    for i in range(steps):
        angle_start = 2 * math.pi * (i * (spacing + dot_length)) / circumference
        angle_end = angle_start + (dot_length / radius)

        x1 = int(cx + radius * math.cos(angle_start))
        y1 = int(cy + radius * math.sin(angle_start))
        x2 = int(cx + radius * math.cos(angle_end))
        y2 = int(cy + radius * math.sin(angle_end))

        cv2.line(img, (x1, y1), (x2, y2), color, 1)

# 三角形で航空機を描画する関数
def draw_triangle(img, center, angle_deg, color=(0, 255, 0)):
    x, y = center
    length = 15
    width = 5
    angle_rad = math.radians(angle_deg)

    tip = (int(x + length * math.sin(angle_rad)), int(y - length * math.cos(angle_rad)))
    left = (int(x - width * math.cos(angle_rad)), int(y - width * math.sin(angle_rad)))
    right = (int(x + width * math.cos(angle_rad)), int(y + width * math.sin(angle_rad)))

    points = np.array([tip, left, right], dtype=np.int32)
    cv2.fillPoly(img, [points], color)

cv2.namedWindow("Radar Display")
cv2.resizeWindow("Radar Display", WIDTH, HEIGHT)

last_update = 0
aircraft_list = []

while True:
    frame = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)

    # 中心（自宅）のマーカー
    cv2.circle(frame, (CENTER_X, CENTER_Y), 2, (0, 255, 0), -1)
    
    # 緑の点線の中央縦線
    for y in range(0, HEIGHT, 10):
        if (y // 10) % 2 == 0:
            cv2.line(frame, (CENTER_X, y), (CENTER_X, y + 5), (0, 255, 0), 1)

    # 緑の点線の中央横線
    for x in range(0, WIDTH, 10):
        if (x // 10) % 2 == 0:
            cv2.line(frame, (x, CENTER_Y), (x + 5, CENTER_Y), (0, 255, 0), 1)

    # 点線円を3本描く
    for r in [60, 140, 220]:
        draw_dotted_circle(frame, (CENTER_X, CENTER_Y), r)


    # 1秒ごとにデータ更新
    if time.time() - last_update > 1.0:
        aircraft_list = get_aircraft_positions()
        last_update = time.time()

    # 各航空機を描画
    for a in aircraft_list:
        dx = (a['lon'] - HOME_LON) * SCALE
        dy = (a['lat'] - HOME_LAT) * SCALE
        x = int(CENTER_X + dx)
        y = int(CENTER_Y - dy)

        if 0 <= x < WIDTH and 0 <= y < HEIGHT:
            if 'track' in a and isinstance(a['track'], (int, float)):
                draw_triangle(frame, (x, y), a['track'])
            else:
                cv2.circle(frame, (x, y), 5, (0, 255, 0), -1)

    cv2.imshow("Radar Display", frame)

    if cv2.waitKey(30) & 0xFF == 27:  # ESCキーで終了
        break

cv2.destroyAllWindows()

git clone https://github.com/pimoroni/hyperpixel2r
cd hyperpixel2r
sudo ./install.sh

sudo nano /boot/config.txt

sudo raspi-config nonint do_i2c 1

import cv2
import requests
import numpy as np
import math
import time

# 自宅の緯度経度に変更してください（以下は東京駅周辺）
HOME_LAT = 35.6812
HOME_LON = 139.7671

# 画面サイズと中心座標
WIDTH = 480
HEIGHT = 480
CENTER_X = WIDTH // 2
CENTER_Y = HEIGHT // 2

# 緯度経度→ピクセル変換倍率
SCALE = 300

# 飛行機アイコンの読み込み（アルファチャンネル付き）
icon = cv2.imread("plane_icon.png", cv2.IMREAD_UNCHANGED)
icon_h, icon_w = icon.shape[:2]

# 背景レーダー動画の読み込み
cap = cv2.VideoCapture("radar.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)
delay = int(1000 / fps) if fps > 0 else 33  # フレーム遅延時間(ms)

# 航空機データ取得関数
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# 飛行機アイコンを回転描画する関数
def draw_icon_rotated(img, icon, center, angle_deg):
    x, y = center
    M = cv2.getRotationMatrix2D((icon_w // 2, icon_h // 2), -angle_deg, 1.0)
    rotated = cv2.warpAffine(
        icon, M, (icon_w, icon_h),
        flags=cv2.INTER_NEAREST,
        borderMode=cv2.BORDER_CONSTANT,
        borderValue=(0, 0, 0, 0)
    )

    # アイコン貼り付け位置の計算
    x1 = x - icon_w // 2
    y1 = y - icon_h // 2
    x2 = x1 + icon_w
    y2 = y1 + icon_h

    # 画面外ならスキップ
    if x1 < 0 or y1 < 0 or x2 > img.shape[1] or y2 > img.shape[0]:
        return

    # ROI合成（アルファブレンド）
    roi = img[y1:y2, x1:x2]
    if rotated.shape[2] == 4:
        alpha = rotated[:, :, 3] / 255.0
        for c in range(3):
            roi[:, :, c] = (1 - alpha) * roi[:, :, c] + alpha * rotated[:, :, c]

# ウィンドウを全画面表示
cv2.namedWindow("Radar Display", cv2.WINDOW_NORMAL)
cv2.setWindowProperty("Radar Display", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)

# 初期化
aircraft_list = []
last_update = 0

while True:
    now = time.time()
    if now - last_update >= 1.0:
        aircraft_list = get_aircraft_positions()
        last_update = now    
    
    # 動画フレームの読み込み
    ret, video_frame = cap.read()
    if not ret:
        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # 動画を最初に戻す
        continue

    # 動画のリサイズ（1.8倍ズーム＋アスペクト比維持）
    video_h, video_w = video_frame.shape[:2]
    scale = min(WIDTH / video_w, HEIGHT / video_h) * 1.8
    new_w = int(video_w * scale)
    new_h = int(video_h * scale)
    resized = cv2.resize(video_frame, (new_w, new_h), interpolation=cv2.INTER_NEAREST)
    resized = cv2.convertScaleAbs(resized, alpha=0.6, beta=0)  # 薄く表示

    # 最終描画フレーム（黒背景）
    frame = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)

    # 動画の貼り付け位置計算（中央寄せ）
    x_offset = (WIDTH - new_w) // 2
    y_offset = (HEIGHT - new_h) // 2
    x1_dst = max(x_offset, 0)
    y1_dst = max(y_offset, 0)
    x1_src = max(-x_offset, 0)
    y1_src = max(-y_offset, 0)
    x2_dst = min(x_offset + new_w, WIDTH)
    y2_dst = min(y_offset + new_h, HEIGHT)
    x2_src = x1_src + (x2_dst - x1_dst)
    y2_src = y1_src + (y2_dst - y1_dst)

    # 動画フレームを合成
    frame[y1_dst:y2_dst, x1_dst:x2_dst] = resized[y1_src:y2_src, x1_src:x2_src]

    # 航空機データ取得
    aircraft_list = get_aircraft_positions()

    # 航空機ごとにアイコンを描画
    for a in aircraft_list:
        dx = (a['lon'] - HOME_LON) * SCALE
        dy = (a['lat'] - HOME_LAT) * SCALE
        x = int(CENTER_X + dx)
        y = int(CENTER_Y - dy)

        # 画面内に収まっているか判定
        if 0 <= x < WIDTH and 0 <= y < HEIGHT:
            if 'track' in a and isinstance(a['track'], (int, float)):
                draw_icon_rotated(frame, icon, (x, y), a['track'])
            else:
                cv2.circle(frame, (x, y), 5, (0, 255, 0), -1)

    # フレーム表示
    cv2.imshow("Radar Display", frame)

    # ESCキーで終了
    key = cv2.waitKey(delay) & 0xFF
    if key == 27:
        break

# 終了処理
cap.release()
cv2.destroyAllWindows()

import cv2
import requests
import numpy as np
import math
import time

# 自宅の緯度経度に変更してください（以下は東京駅周辺）
HOME_LAT = 35.6812
HOME_LON = 139.7671

# 画面サイズと中心座標
WIDTH = 480
HEIGHT = 480
CENTER_X = WIDTH // 2
CENTER_Y = HEIGHT // 2

# 緯度経度→ピクセル変換倍率
SCALE = 600

# 飛行機アイコンの読み込み（アルファチャンネル付き）
icon = cv2.imread("plane_icon.png", cv2.IMREAD_UNCHANGED)
icon_h, icon_w = icon.shape[:2]

# 背景レーダー動画の読み込み
cap = cv2.VideoCapture("radar.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)
delay = int(1000 / fps) if fps > 0 else 33  # フレーム遅延時間(ms)

# 航空機データ取得関数
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# 飛行機アイコンを回転描画する関数
def draw_icon_rotated(img, icon, center, angle_deg):
    x, y = center
    M = cv2.getRotationMatrix2D((icon_w // 2, icon_h // 2), -angle_deg, 1.0)
    rotated = cv2.warpAffine(
        icon, M, (icon_w, icon_h),
        flags=cv2.INTER_NEAREST,
        borderMode=cv2.BORDER_CONSTANT,
        borderValue=(0, 0, 0, 0)
    )

    # アイコン貼り付け位置の計算
    x1 = x - icon_w // 2
    y1 = y - icon_h // 2
    x2 = x1 + icon_w
    y2 = y1 + icon_h

    # 画面外ならスキップ
    if x1 < 0 or y1 < 0 or x2 > img.shape[1] or y2 > img.shape[0]:
        return

    # ROI合成（アルファブレンド）
    roi = img[y1:y2, x1:x2]
    if rotated.shape[2] == 4:
        alpha = rotated[:, :, 3] / 255.0
        for c in range(3):
            roi[:, :, c] = (1 - alpha) * roi[:, :, c] + alpha * rotated[:, :, c]

# ウィンドウを全画面表示
cv2.namedWindow("Radar Display", cv2.WINDOW_NORMAL)
cv2.setWindowProperty("Radar Display", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)

# 初期化
aircraft_list = []
last_update = 0

while True:
    now = time.time()
    if now - last_update >= 1.0:
        aircraft_list = get_aircraft_positions()
        last_update = now    
    
    # 動画フレームの読み込み
    ret, video_frame = cap.read()
    if not ret:
        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # 動画を最初に戻す
        continue

    # 動画のリサイズ（1.8倍ズーム＋アスペクト比維持）
    video_h, video_w = video_frame.shape[:2]
    scale = min(WIDTH / video_w, HEIGHT / video_h) * 1.8
    new_w = int(video_w * scale)
    new_h = int(video_h * scale)
    resized = cv2.resize(video_frame, (new_w, new_h), interpolation=cv2.INTER_NEAREST)
    resized = cv2.convertScaleAbs(resized, alpha=0.6, beta=0)  # 薄く表示

    # 最終描画フレーム（黒背景）
    frame = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)

    # 動画の貼り付け位置計算（中央寄せ）
    x_offset = (WIDTH - new_w) // 2
    y_offset = (HEIGHT - new_h) // 2
    x1_dst = max(x_offset, 0)
    y1_dst = max(y_offset, 0)
    x1_src = max(-x_offset, 0)
    y1_src = max(-y_offset, 0)
    x2_dst = min(x_offset + new_w, WIDTH)
    y2_dst = min(y_offset + new_h, HEIGHT)
    x2_src = x1_src + (x2_dst - x1_dst)
    y2_src = y1_src + (y2_dst - y1_dst)

    # 動画フレームを合成
    frame[y1_dst:y2_dst, x1_dst:x2_dst] = resized[y1_src:y2_src, x1_src:x2_src]

    # 航空機ごとにアイコンを描画
    for a in aircraft_list:
        dx = (a['lon'] - HOME_LON) * SCALE
        dy = (a['lat'] - HOME_LAT) * SCALE
        x = int(CENTER_X + dx)
        y = int(CENTER_Y - dy)

        # 画面内に収まっているか判定
        if 0 <= x < WIDTH and 0 <= y < HEIGHT:
            if 'track' in a and isinstance(a['track'], (int, float)):
                draw_icon_rotated(frame, icon, (x, y), a['track'])
            else:
                cv2.circle(frame, (x, y), 5, (0, 255, 0), -1)
                
            # --- 便名を描画 ---
            if 'flight' in a and a['flight']:
                flight_text = a['flight']
                font = cv2.FONT_HERSHEY_SIMPLEX
                font_scale = 0.5
                thickness = 1
                text_size, _ = cv2.getTextSize(flight_text, font, font_scale, thickness)
                text_x = x - text_size[0] // 2 + 6
                text_y = y + icon_h // 2 + text_size[1] - 2 # アイコン下
                cv2.putText(frame, flight_text, (text_x, text_y), font, font_scale, (0, 255, 0), thickness, cv2.LINE_AA)                

    # フレーム表示
    cv2.imshow("Radar Display", frame)

    # ESCキーで終了
    key = cv2.waitKey(delay) & 0xFF
    if key == 27:
        break

# 終了処理
cap.release()
cv2.destroyAllWindows()

sudo bash -c "$(wget -O - https://repo-feed.flightradar24.com/install_fr24_rpi.sh)"

fr24feed-status

sudo systemctl stop fr24feed
sudo systemctl disable fr24feed

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import os
import sys
import time
import math
import smbus2
import requests
import numpy as np
import cv2
from PIL import Image
sys.path.append("..")
from lib import LCD_1inch28

# ── QMC5883L 設定 ──
QMC5883L_ADDRESS = 0x0D
X_OFFSET    = -110.0
Y_OFFSET    = -587.5
X_SCALE     = 1.0234375
Y_SCALE     = 0.95
DECLINATION = -8.0
HEADING_OFFSET = 76.4

# ── 自宅座標とスケール ──
HOME_LAT = 35.6812
HOME_LON = 139.7671
SCALE = 250 #350
WIDTH = 240
HEIGHT = 240
CENTER_X = WIDTH // 2
CENTER_Y = HEIGHT // 2

# ── LCD 初期化 ──
disp = LCD_1inch28.LCD_1inch28()
disp.Init()
disp.clear()

# ── I2C 初期化 ──
bus = smbus2.SMBus(1)
bus.write_byte_data(QMC5883L_ADDRESS, 0x0B, 0x01)
time.sleep(0.1)
bus.write_byte_data(QMC5883L_ADDRESS, 0x09, 0x1D)
time.sleep(0.1)

# ── 方位取得 ──
def read_axis(reg_lsb):
    lsb = bus.read_byte_data(QMC5883L_ADDRESS, reg_lsb)
    msb = bus.read_byte_data(QMC5883L_ADDRESS, reg_lsb + 1)
    value = (msb << 8) | lsb
    if value >= 0x8000:
        value -= 0x10000
    return value

def get_heading():
    raw_x = read_axis(0x00)
    raw_y = read_axis(0x02)
    adj_x = (raw_x - X_OFFSET) * X_SCALE
    adj_y = (raw_y - Y_OFFSET) * Y_SCALE
    raw_heading = math.degrees(math.atan2(adj_y, adj_x))
    if raw_heading < 0:
        raw_heading += 360.0
    heading = (raw_heading - HEADING_OFFSET + DECLINATION) % 360.0
    return heading

# ── 航空機データ取得 ──
def get_aircraft_positions():
    try:
        res = requests.get("http://192.168.1.46:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# ── 背景画像の読み込み ──
original = Image.open("dragon2.png").convert("RGB")
original = original.resize((240, 240))
original_cv = cv2.cvtColor(np.array(original), cv2.COLOR_RGB2BGR)

# ── メインループ ──
last_update = 0
aircraft_list = []

while True:
    # 背景画像をコピー（毎回初期化）
    frame = original_cv.copy()

    # 1秒ごとに航空機情報を更新
    if time.time() - last_update > 2.0:
        aircraft_list = get_aircraft_positions()
        last_update = time.time()
    print("航空機数: {}".format(len(aircraft_list)))
    for a in aircraft_list:
        print("  LAT: {:.4f}, LON: {:.4f}".format(a['lat'], a['lon']))        

    # 航空機を黄色い円で描画
    for a in aircraft_list:
        dx = (a['lon'] - HOME_LON) * SCALE
        dy = (a['lat'] - HOME_LAT) * SCALE
        x = int(CENTER_X + dx)
        y = int(CENTER_Y - dy)
        if 0 <= x < WIDTH and 0 <= y < HEIGHT:
            cv2.circle(frame, (x, y), 6, (0, 255, 255), -1)  # BGRで黄色

    # OpenCV → PIL に変換して回転
    image_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
    # ── センサー読み取り ──
    raw_x = read_axis(0x00)
    raw_y = read_axis(0x02)
    raw_z = read_axis(0x04)

    adj_x = (raw_x - X_OFFSET) * X_SCALE
    adj_y = (raw_y - Y_OFFSET) * Y_SCALE

    raw_heading = math.degrees(math.atan2(adj_y, adj_x))
    if raw_heading < 0:
        raw_heading += 360.0

    heading = raw_heading - HEADING_OFFSET + DECLINATION
    heading %= 360.0

    # ── デバッグ表示 ──
    #print("raw_x = {:6d}, raw_y = {:6d}, heading = {:.2f}°".format(raw_x, raw_y, heading))
    rotated = image_pil.rotate(heading, expand=True)

    # 黒背景に中央配置
    background = Image.new("RGB", (240, 240), (0, 0, 0))
    x_offset = (240 - rotated.width) // 2
    y_offset = (240 - rotated.height) // 2
    background.paste(rotated, (x_offset, y_offset))

    # LCDに表示
    disp.ShowImage(background)

    time.sleep(0.3)

import requests
import math
from datetime import datetime
from PIL import Image, ImageDraw, ImageFont
from io import BytesIO
import cv2
import numpy as np
import re

# ===============================
# 設定
# ===============================

# 自宅の緯度経度に変更してください（以下は東京駅周辺）
HOME_LAT = 35.6812
HOME_LON = 139.7671

# RapidAPI（AeroDataBox）キー
RAPIDAPI_KEY = "RapidAPIキーを入力してください"

# dump1090-fa のローカルURL
DUMP1090_URL = "http://localhost:8080/data/aircraft.json"

# ===============================
# 航空機データ取得関数
# ===============================
def get_aircraft_positions_dump1090():
    """dump1090-fa から航空機位置データを取得"""
    try:
        res = requests.get(DUMP1090_URL, timeout=1)
        data = res.json()
        return [a for a in data.get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# ===============================
# 距離計算
# ===============================

def haversine(lat1, lon1, lat2, lon2):
    """2点間の距離（km）をハーサイン式で計算"""
    R = 6371.0
    dlat = math.radians(lat2 - lat1)
    dlon = math.radians(lon2 - lon1)
    a = math.sin(dlat / 2)**2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon / 2)**2
    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

# ===============================
# AeroDataBox から便情報取得
# ===============================

def get_flight_info(flight_number):
    """便名から到着地と到着時刻を取得"""
    date = datetime.today().strftime('%Y-%m-%d')
    url = f"https://aerodatabox.p.rapidapi.com/flights/number/{flight_number}/{date}"
    headers = {
        "X-RapidAPI-Key": RAPIDAPI_KEY,
        "X-RapidAPI-Host": "aerodatabox.p.rapidapi.com"
    }
    try:
        res = requests.get(url, headers=headers, timeout=3)
        data = res.json()
        if isinstance(data, list) and data:
            f = data[0]
            flight = f['number']
            airport = f['arrival']['airport']['name']
            time_str = f['arrival']['scheduledTime']['local']
            arrival_time = datetime.fromisoformat(time_str).strftime('%H:%M')
            return flight, airport, arrival_time
    except:
        pass
    return None, None, None

# ===============================
# メイン処理
# ===============================

# 航空機データを取得
aircraft_list = get_aircraft_positions_dump1090()

if not aircraft_list:
    print("航空機が見つかりませんでした。")
    exit()

# ===============================
# 距離順にソートして3機選択
# ===============================

for a in aircraft_list:
     # 各航空機について、自宅（HOME_LAT, HOME_LON）からの距離を計算して追加
    a["distance"] = haversine(HOME_LAT, HOME_LON, a["lat"], a["lon"])
    
# 距離（"distance"）の値を基準に昇順ソート（最も近い機体が先頭に来る）
aircraft_list.sort(key=lambda x: x["distance"])
# 最も近い3機だけを抽出
closest_aircrafts = aircraft_list[:3]

# ===============================
# 表示処理（3機を縦に並べて描画）
# ===============================

icao_to_iata = {
    "ANA": "NH", "JAL": "JL", "ADO": "HD", "SNA": "7G", "SKY": "BC",
    "APJ": "MM", "FDA": "JH", "CPA": "CX", "UAE": "EK", "THA": "TG",
    "MAS": "MH", "CES": "MU", "CSN": "CZ", "CCA": "CA", "PAL": "PR",
    "TGW": "TR", "SIA": "SQ", "JST": "JQ", "JJP": "GK", "TNA": "9C",
    "BAW": "BA", "AAL": "AA", "UAL": "UA", "DAL": "DL", "KLM": "KL",
    "AFR": "AF", "DLH": "LH", "QFA": "QF",
}

base = Image.new("RGB", (1280, 720), (0, 0, 80))
draw = ImageDraw.Draw(base)
font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
font = ImageFont.truetype(font_path, 60)

y_base = 60          # 1段目（最初の航空機情報）の描画開始位置（上から60pxの位置）
block_height = 220   # 各段の高さ（1つの航空機情報を描く縦スペース）

# ==== 近い3機を順に処理して、便情報を取得 ====
for idx, ac in enumerate(closest_aircrafts):
    # 航空機の便名（flight）を取得。空白やNoneの場合は空文字に置き換え
    ident = ac.get("flight", "").strip()
    
    # 便名が空、または先頭が英字でない（例: 数字のみや不正データ）の場合はスキップ
    if not ident or not ident[0].isalpha():
        continue
    
    # AeroDataBox APIを使って、便名から到着地と到着時刻を取得
    flight, airport, arrival_time = get_flight_info(ident)
    if not all([flight, airport, arrival_time]):
        continue
    
    print(f"[{idx}] 便名: {flight}")
    print(f"    距離: {ac['distance']:.1f} km")
    print(f"    到着地: {airport}")
    print(f"    到着時刻: {arrival_time}")
    print()
    
    # 便名の先頭3文字を抽出（例: "JAL124" → "JAL"）
    airline_code = flight.strip()[:3].upper()
    
    # ICAOコード（3文字）をIATAコード（2文字）に変換
    # 変換できない場合は、先頭2文字をそのまま使う    
    iata = icao_to_iata.get(airline_code, airline_code[:2])
    
     # 便名から数字部分だけを抽出（例: "JAL124" → "124"）
    flight_number = ''.join(re.findall(r'\d+', flight))
    
    # 到着地の文字列を最大9文字までに制限（長すぎる地名対策）
    destination = airport[:9]

    # ==== 航空会社ロゴの取得 ====
    # Daisycon APIを利用して、航空会社のロゴ画像を取得
    # IATAコードを使ってURLを生成（白色ロゴ・横幅300px）
    if iata == "BC":
        # スカイマーク（IATA: BC）は正しいロゴが取得できないため、例外的に Airhex（https://content.airhex.com/）のロゴを使用
        url = "https://content.airhex.com/content/logos/airlines_BC_300_100_s.png"
    else:
        # それ以外の航空会社は Daisycon から白色ロゴを取得
        url = f"https://images.daisycon.io/airline/?width=300&height=95&color=ffffff&iata={iata}"
        
    img_data = requests.get(url, timeout=5).content# 画像データをダウンロード（バイナリとして取得）
    logo = Image.open(BytesIO(img_data)).convert("RGBA")# 取得したロゴをRGBA形式（透過対応）で読み込み
    white_bg = Image.new("RGBA", logo.size, (255,255,255,255))# 白背景を作成（透過部分を白に塗りつぶすため）
    logo_with_white = Image.alpha_composite(white_bg, logo)# 白背景とロゴを合成（透過部分が白になる）
    logo_w, logo_h = logo_with_white.size# ロゴ画像の幅と高さを取得（後で配置位置を計算するため）

    # 配置位置
    y_offset = y_base + idx * block_height
    base.paste(logo_with_white.convert("RGB"), (40, y_offset), mask=logo_with_white.split()[3])

    # テキスト描画
    text_start_x = 360  # テキストの描画開始位置（左からのオフセット）
    # 便名（数字部分）を描画
    draw.text((text_start_x, y_offset+10), flight_number, fill=(255,255,255), font=font)
    # 到着地（空港名）を描画
    draw.text((text_start_x+190, y_offset+10), destination, fill=(255,255,255), font=font)
    # 到着予定時刻を描画
    draw.text((text_start_x+630, y_offset+10), arrival_time, fill=(255,255,255), font=font)

# ===============================
# OpenCVで全画面表示
# ===============================

cv2.namedWindow("Flight Info", cv2.WINDOW_NORMAL)
cv2.setWindowProperty("Flight Info", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
img_cv = cv2.cvtColor(np.array(base), cv2.COLOR_RGB2BGR)
cv2.imshow("Flight Info", img_cv)

while True:
    if cv2.waitKey(10) == 27:
        break
cv2.destroyAllWindows()

import cv2
import numpy as np
from datetime import datetime
import requests
import math
import time

# 自宅の緯度・経度（東京駅周辺など）
HOME_LAT = 35.681236
HOME_LON = 139.767125

# データ取得関数
def get_aircraft_positions():
    try:
        res = requests.get("http://192.168.1.46:8080/data/aircraft.json", timeout=1)
        return res.json().get("aircraft", [])
    except Exception as e:
        print("データ取得エラー:", e)
        return []
    
# 緯度経度から距離(km)を求める関数（簡易版・近距離用）
def calc_distance(lat1, lon1, lat2, lon2):
    R = 6371  # 地球の半径(km)
    dlat = math.radians(lat2 - lat1)
    dlon = math.radians(lon2 - lon1)
    a = math.sin(dlat / 2)**2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon / 2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    return R * c

# HUD風オーバーレイ描画
def draw_target_overlay(img, offset_x=0, offset_y=0):
    """中央ターゲットや計器枠などのHUD風描画（元の形状そのまま＋オフセット対応）"""
    scale = img.shape[0] / 128
    def s(x): return int(x * scale)

    ox = int(offset_x)
    oy = int(offset_y)

    # 中央座標
    center_x = img.shape[1] // 2 + ox
    center_y = img.shape[0] // 2 + oy

    # 中央円
    cv2.circle(img, (center_x, center_y), s(18), (0, 255, 0), 2)
    cv2.circle(img, (center_x, center_y), s(1), (0, 255, 0), -1)

    # 十字補助線
    cv2.line(img, (s(42) + ox, center_y), (s(50) + ox, center_y), (0, 255, 0), 2)
    cv2.line(img, (s(78) + ox, center_y), (s(86) + ox, center_y), (0, 255, 0), 2)
    cv2.line(img, (center_x, s(42) + oy), (center_x, s(50) + oy), (0, 255, 0), 2)
    cv2.line(img, (center_x, s(78) + oy), (center_x, s(86) + oy), (0, 255, 0), 2)

    cv2.line(img, (s(56) + ox, center_y), (s(60) + ox, center_y), (0, 255, 0), 2)
    cv2.line(img, (s(68) + ox, center_y), (s(72) + ox, center_y), (0, 255, 0), 2)
    cv2.line(img, (center_x, s(56) + oy), (center_x, s(60) + oy), (0, 255, 0), 2)
    cv2.line(img, (center_x, s(68) + oy), (center_x, s(72) + oy), (0, 255, 0), 2)

    # 左側グラフ
    cv2.line(img, (83 + ox, s(60) + oy), (83 + ox, s(92) + oy), (0, 255, 0), 2)
    cv2.line(img, (83 + ox, s(60) + oy), (99 + ox, s(60) + oy), (0, 255, 0), 2)
    cv2.line(img, (83 + ox, s(68) + oy), (93 + ox, s(68) + oy), (0, 255, 0), 2)
    cv2.line(img, (83 + ox, s(76) + oy), (99 + ox, s(76) + oy), (0, 255, 0), 2)
    cv2.line(img, (83 + ox, s(84) + oy), (93 + ox, s(84) + oy), (0, 255, 0), 2)
    cv2.line(img, (83 + ox, s(92) + oy), (99 + ox, s(92) + oy), (0, 255, 0), 2)

    # 右側グラフ
    cv2.line(img, (613 + ox, s(30) + oy), (613 + ox, s(92) + oy), (0, 255, 0), 2)
    cv2.line(img, (595 + ox, s(30) + oy), (628 + ox, s(30) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(36) + oy), (623 + ox, s(36) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(43) + oy), (623 + ox, s(43) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(50) + oy), (628 + ox, s(50) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(56) + oy), (623 + ox, s(56) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(63) + oy), (623 + ox, s(63) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(71) + oy), (628 + ox, s(71) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(77) + oy), (623 + ox, s(77) + oy), (0, 255, 0), 2)
    cv2.line(img, (613 + ox, s(84) + oy), (623 + ox, s(84) + oy), (0, 255, 0), 2)
    cv2.line(img, (595 + ox, s(92) + oy), (628 + ox, s(92) + oy), (0, 255, 0), 2)

    # 半円ゲージ
    cv2.ellipse(
        img,
        (center_x, s(122) + oy),
        (s(20), s(20)),
        0, 180, 360,
        (0, 255, 0),
        2
    )
    cv2.line(img, (center_x, s(102) + oy), (center_x, s(105) + oy), (0, 255, 0), 2)
    cv2.line(img, (s(44) + ox, s(122) + oy), (s(46) + ox, s(122) + oy), (0, 255, 0), 2)
    cv2.line(img, (s(82) + ox, s(122) + oy), (s(84) + ox, s(122) + oy), (0, 255, 0), 2)

    # 半円ゲージの目盛り
    cv2.line(img, (300 + ox, 592 + oy), (305 + ox, 600 + oy), (0, 255, 0), 2)
    cv2.line(img, (259 + ox, 640 + oy), (268 + ox, 645 + oy), (0, 255, 0), 2)
    cv2.line(img, (417 + ox, 600 + oy), (422 + ox, 592 + oy), (0, 255, 0), 2)
    cv2.line(img, (453 + ox, 645 + oy), (462 + ox, 640 + oy), (0, 255, 0), 2)

    return img

# =============================
# メイン処理ループ
# =============================
cap = cv2.VideoCapture("cockpit_view.mp4")
if not cap.isOpened():
    print("動画ファイルを開けませんでした。")
    exit()

cv2.namedWindow("Square View", cv2.WINDOW_NORMAL)
cv2.resizeWindow("Square View", 720, 720)
cv2.setWindowProperty("Square View", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)

# 総フレーム数を取得
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
skip_point = int(total_frames * 0.85)  # 後半1/4の開始フレーム

# 前回のデータ取得時刻を記録
last_fetch = 0

while True:
    ret, frame = cap.read()
    if not ret:
        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
        continue
    
    # 8枚スキップして再生を速くする
    for _ in range(8):
        cap.grab()    
    
    # --- 2秒に1回だけAPIを呼ぶ ---
    now = time.time()
    if now - last_fetch >= 2.0:
        aircraft_data = get_aircraft_positions()
        last_fetch = now  # 時刻を更新
        
        # 有効な座標を持つ航空機だけを抽出
        valid = [a for a in aircraft_data if 'lat' in a and 'lon' in a]

        if not valid:
            print("有効なデータがありません。")
            ident = "No aircraft"
            alt_m = 0
            hdg = 0
            dist = 0
            spd_kmh = 0
        else:
            # それぞれの機体との距離を計算
            for a in valid:
                a["distance_km"] = calc_distance(HOME_LAT, HOME_LON, a["lat"], a["lon"])

            # 最も近い機体を選択
            nearest = min(valid, key=lambda a: a["distance_km"])

            ident = nearest.get("flight", "Unknown")
            alt_ft = nearest.get("alt_baro", "N/A")
            spd_kt = nearest.get("gs", "N/A")
            hdg = nearest.get("track", "0")
            dist = nearest.get("distance_km", 0)
            
            # フィート→メートル換算
            if isinstance(alt_ft, (int, float)):
                alt_m = alt_ft * 0.3048
            else:
                alt_m = 0
                
            # ノット→km/h換算
            spd_kmh = spd_kt * 1.852 if isinstance(spd_kt, (int, float)) else 0            

            print(f"最も近い航空機:")
            print(f"Ident: {ident}")
            print(f"Altitude: {alt_ft} ft ({alt_m:.0f} m)")
            print(f"Speed: {spd_kt} kt ({spd_kmh:.0f} km/h)")
            print(f"Heading: {hdg}")
            print(f"Distance: {dist:.1f} km")        
    
    # 現在のフレーム番号を取得
    current_frame = int(cap.get(cv2.CAP_PROP_POS_FRAMES))  

    # --- 後半1/4に到達したら最初に戻す ---
    if current_frame >= skip_point:
        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
        continue    

    height, width, _ = frame.shape
    frame = frame[:int(height * 0.6), int(width * 0.35):]
    square_size = frame.shape[0]
    frame = frame[:, :square_size]
    frame_resized = cv2.resize(frame, (720, 720), interpolation=cv2.INTER_AREA)
    
    # --- 少し黒っぽく（明るさを下げる）処理 ---
    dark_factor = 0.5  # 0.7で少し暗め（0.5ならもっと黒っぽい）
    frame_resized = (frame_resized * dark_factor).astype(np.uint8)        

    # --- 図形を描画（オフセット指定可能）---
    frame_resized = draw_target_overlay(frame_resized)
    
    # --- HUDテキスト描画 ---
    font = cv2.FONT_HERSHEY_SIMPLEX
    color = (0, 255, 0)
    aa = cv2.LINE_AA

    cv2.putText(frame_resized, ident, (80, 170), font, 1.5, color, 2, aa)
    cv2.putText(frame_resized, 'ALTITUDE', (80, 250), font, 0.7, color, 2, aa)
    cv2.putText(frame_resized, f"{alt_m:.0f}", (80, 290), font, 1.2, color, 2, aa)

    cv2.putText(frame_resized, 'RANGE', (499, 195), font, 0.7, color, 2, aa)
    cv2.putText(frame_resized, f"{dist:.1f}", (499, 230), font, 1.2, color, 2, aa)

    cv2.putText(frame_resized, 'HEADING', (469, 495), font, 0.7, color, 2, aa)
    cv2.putText(frame_resized, str(int(hdg)), (470, 540), font, 1.5, color, 2, aa)

    cv2.putText(frame_resized, 'SPEED', (325, 645), font, 0.7, color, 2, aa)
    cv2.putText(frame_resized, str(int(spd_kmh)), (315, 690), font, 1.5, color, 2, aa)

    cv2.putText(frame_resized, '-0', (40, 433), font, 0.8, color, 2, aa)
    cv2.putText(frame_resized, '3800', (635, 290), font, 0.6, color, 1, aa)
    cv2.putText(frame_resized, '4000', (635, 407), font, 0.6, color, 1, aa)
    cv2.putText(frame_resized, '46', (348, 605), font, 0.6, color, 1, aa)
    cv2.putText(frame_resized, '10', (258, 690), font, 0.6, color, 1, aa)

    cv2.imshow("Square View", frame_resized)
    if cv2.waitKey(1) == 27:
        break

cap.release()
cv2.destroyAllWindows()

sudo raspi-config

import serial
import time

ser = serial.Serial("/dev/serial0", 9600, timeout=1)

def convert_to_decimal(raw, direction):
    if raw == "":
        return None

    if direction in ["N", "S"]:
        deg = int(raw[:2])
        minutes = float(raw[2:])
    else:
        deg = int(raw[:3])
        minutes = float(raw[3:])

    value = deg + minutes / 60

    if direction in ["S", "W"]:
        value *= -1

    return value

def convert_time(utc_str):
    if utc_str == "":
        return None

    hh = int(utc_str[0:2])
    mm = int(utc_str[2:4])
    ss = int(utc_str[4:6])

    hh = (hh + 9) % 24
    return f"{hh:02}:{mm:02}:{ss:02}"

while True:
    try:
        line = ser.readline()
    except:
        print("serial error")
        time.sleep(1)
        continue

    if not line:
        continue

    try:
        line = line.decode("utf-8").strip()
    except:
        continue

    # ★ 生データ確認（必要なら）
    # print(line)

    if line.startswith("$GNGGA") or line.startswith("$GPGGA"):
        parts = line.split(",")

        if len(parts) > 6:
            fix = parts[6]
            lat = convert_to_decimal(parts[2], parts[3])
            lon = convert_to_decimal(parts[4], parts[5])
            jst = convert_time(parts[1])

            if lat is not None and lon is not None:
                print(f"{lat},{lon}")
            else:
                print("位置未取得")

            print("fix:", fix, "日本時間:", jst)

import cv2
import numpy as np
import math
import time
import serial
import requests

# ===== GPS設定 =====
ser = serial.Serial("/dev/serial0", 9600, timeout=1)

last_lat = None
last_lon = None
has_fix_once = False
gps_status = "WAITING GPS"

def convert_to_decimal(raw, direction):
    if raw == "":
        return None

    if direction in ["N", "S"]:
        deg = int(raw[:2])
        minutes = float(raw[2:])
    else:
        deg = int(raw[:3])
        minutes = float(raw[3:])

    value = deg + minutes / 60

    if direction in ["S", "W"]:
        value *= -1

    return value

def get_gps():
    global last_lat, last_lon, has_fix_once, gps_status

    try:
        line = ser.readline()
    except:
        gps_status = "GPS ERROR"
        return last_lat, last_lon

    if not line:
        return last_lat, last_lon

    try:
        line = line.decode("utf-8").strip()
    except:
        return last_lat, last_lon

    if line.startswith("$GNGGA") or line.startswith("$GPGGA"):
        parts = line.split(",")

        if len(parts) > 6:
            fix = parts[6]
            lat = convert_to_decimal(parts[2], parts[3])
            lon = convert_to_decimal(parts[4], parts[5])

            current_valid = (lat is not None and lon is not None and fix != "0")

            if current_valid:
                last_lat = lat
                last_lon = lon
                has_fix_once = True
                gps_status = "GPS OK"
            else:
                if has_fix_once:
                    gps_status = "GPS LOST (using last)"
                else:
                    gps_status = "WAITING GPS"

    return last_lat, last_lon


# ===== 表示設定 =====
WIDTH = 720
HEIGHT = 720
CENTER_X = WIDTH // 2
CENTER_Y = HEIGHT // 2
SCALE = 450

icon = cv2.imread("plane_icon.png", cv2.IMREAD_UNCHANGED)
icon_h, icon_w = icon.shape[:2]

cap = cv2.VideoCapture("radar.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)
delay = int(1000 / fps) if fps > 0 else 33


# ===== 航空機データ取得関数 =====
def get_aircraft_positions():
    try:
        res = requests.get("http://localhost:8080/data/aircraft.json", timeout=1)
        return [a for a in res.json().get("aircraft", []) if 'lat' in a and 'lon' in a]
    except:
        return []

# ===== アイコン描画 =====
def draw_icon_rotated(img, icon, center, angle_deg):
    x, y = center

    M = cv2.getRotationMatrix2D((icon_w // 2, icon_h // 2), -angle_deg, 1.0)
    rotated = cv2.warpAffine(
        icon, M, (icon_w, icon_h),
        flags=cv2.INTER_NEAREST,
        borderMode=cv2.BORDER_CONSTANT,
        borderValue=(0, 0, 0, 0)
    )

    x1 = x - icon_w // 2
    y1 = y - icon_h // 2
    x2 = x1 + icon_w
    y2 = y1 + icon_h

    if x1 < 0 or y1 < 0 or x2 > img.shape[1] or y2 > img.shape[0]:
        return

    roi = img[y1:y2, x1:x2]

    if rotated.shape[2] == 4:
        alpha = rotated[:, :, 3] / 255.0
        for c in range(3):
            roi[:, :, c] = (1 - alpha) * roi[:, :, c] + alpha * rotated[:, :, c]


# ===== 画面 =====
cv2.namedWindow("Radar Display", cv2.WINDOW_NORMAL)
cv2.setWindowProperty("Radar Display", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)

aircraft_list = []
last_update = 0


# ===== メインループ =====
while True:

    # GPS取得
    HOME_LAT, HOME_LON = get_gps()

    # 初回待ち
    if not has_fix_once:
        frame = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)

        cv2.putText(frame, "WAITING GPS", (330, 20),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 2)

        cv2.imshow("Radar Display", frame)

        if cv2.waitKey(delay) & 0xFF == 27:
            break
        continue

    # 航空機更新
    now = time.time()
    if now - last_update >= 1.0:
        aircraft_list = get_aircraft_positions()
        last_update = now

    # 背景動画
    ret, video_frame = cap.read()
    if not ret:
        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
        continue

    video_h, video_w = video_frame.shape[:2]
    scale = min(WIDTH / video_w, HEIGHT / video_h) * 1.8
    new_w = int(video_w * scale)
    new_h = int(video_h * scale)

    resized = cv2.resize(video_frame, (new_w, new_h), interpolation=cv2.INTER_NEAREST)
    resized = cv2.convertScaleAbs(resized, alpha=0.6, beta=0)

    frame = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)

    x_offset = (WIDTH - new_w) // 2
    y_offset = (HEIGHT - new_h) // 2

    x1_dst = max(x_offset, 0)
    y1_dst = max(y_offset, 0)
    x1_src = max(-x_offset, 0)
    y1_src = max(-y_offset, 0)
    x2_dst = min(x_offset + new_w, WIDTH)
    y2_dst = min(y_offset + new_h, HEIGHT)
    x2_src = x1_src + (x2_dst - x1_dst)
    y2_src = y1_src + (y2_dst - y1_dst)

    frame[y1_dst:y2_dst, x1_dst:x2_dst] = resized[y1_src:y2_src, x1_src:x2_src]

    # 飛行機描画
    for a in aircraft_list:
        dx = (a['lon'] - HOME_LON) * SCALE
        dy = (a['lat'] - HOME_LAT) * SCALE

        x = int(CENTER_X + dx)
        y = int(CENTER_Y - dy)

        if 0 <= x < WIDTH and 0 <= y < HEIGHT:
            if 'track' in a and isinstance(a['track'], (int, float)):
                draw_icon_rotated(frame, icon, (x, y), a['track'])
            else:
                cv2.circle(frame, (x, y), 5, (0, 255, 0), -1)

            # ===== 便名表示 =====
            flight = a.get('flight', '').strip()

            if flight != "":
                font = cv2.FONT_HERSHEY_SIMPLEX
                font_scale = 0.4
                thickness = 1

                text_size, _ = cv2.getTextSize(flight, font, font_scale, thickness)

                text_x = x - text_size[0] // 2
                text_y = y + 25  # アイコンの下

                cv2.putText(frame, flight,
                            (text_x, text_y),
                            font, font_scale,
                            (0, 255, 0),
                            thickness,
                            cv2.LINE_AA)

    # GPS状態表示
    color = (0, 255, 0) if gps_status == "GPS OK" else (0, 0, 255)

    cv2.putText(frame, gps_status, (330, 20),
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

    # 表示
    cv2.imshow("Radar Display", frame)

    if cv2.waitKey(delay) & 0xFF == 27:
        break


cap.release()
cv2.destroyAllWindows()

vcgencmd measure_temp

libcamera-hello --timeout 0