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

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

sudo apt install -y fonts-takao

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

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# 拡大率
scale_factor=0.8

# X方向の位置調整
x_offset=65

# Y方向中心座標
Y_CENTER=32

# 三角錐の頂点座標
pyramid=((0,-20,0),(-20,20,-20),(20,20,-20),(0,20,20))

while True:

    # 0〜360度回転
    for angle in range(0,361,10):

        # 座標保存用
        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)

            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",(128,64),0)

        # 描画オブジェクト作成
        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=1
            )

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

        # SSD1306転送用バッファ
        buffer=[]

        # 8ページ分変換
        for page in range(8):

            for x in range(128):

                byte=0

                for bit in range(8):

                    # ピクセル確認
                    if image.getpixel((x,page*8+bit)):
                        byte|=(1<<bit)

                buffer.append(byte)

        # ディスプレイへ転送
        send(1,buffer)

        time.sleep(0.1)

import spidev
import lgpio
import time
from PIL import Image, ImageDraw

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# SSD1306用バッファ変換
def image_to_buffer(image):

    buffer=[]

    for page in range(8):
        for x in range(128):
            byte=0
            for bit in range(8):
                if image.getpixel((x,page*8+bit)):
                    byte|=(1<<bit)
            buffer.append(byte)

    return buffer

# 表示用画像作成
img = Image.new("1", (128, 64), 0)

# 描画オブジェクト作成
draw = ImageDraw.Draw(img)

# 1. 左下に四角形（塗りつぶし）
draw.rectangle([(10, 48), (30, 64)], fill=1)

# 2. 右上に円（塗りつぶし）
draw.ellipse([(98, 2), (118, 22)], fill=1)

# 3. 左上から右下へ線
draw.line([(0, 0), (127, 63)], fill=1)

# 4. 中央に三角形（枠線のみ）
draw.polygon([(60, 25), (70, 5), (80, 25)], outline=1)

# 5. 中央右に四角形（枠線のみ）
draw.rectangle([(50, 40), (70, 60)], outline=1)

# 6. 左上に円（枠線のみ）
draw.ellipse([(5, 15), (25, 35)], outline=1)

# SSD1306へ転送
send(1, image_to_buffer(img))

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

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# SSD1306用バッファ変換
def image_to_buffer(image):

    buffer=[]

    for page in range(8):
        for x in range(128):
            byte=0
            for bit in range(8):
                if image.getpixel((x,page*8+bit)):
                    byte|=(1<<bit)
            buffer.append(byte)

    return buffer

# フォントのパスとサイズ設定
font_size=11
font=ImageFont.truetype("/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf",font_size)

# 白黒画像作成
image=Image.new("1",(128,64),0)

# 描画オブジェクト
draw=ImageDraw.Draw(image)

# テキスト描画
draw.text((0,0),"1.51インチ透明",font=font,fill=1)

draw.text((5,30),"青色OLEDディスプレイ",font=font,fill=1)

# 表示
send(1,image_to_buffer(image))

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

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# SSD1306用バッファ変換
def image_to_buffer(image):

    buffer=[]

    for page in range(8):
        for x in range(128):
            byte=0
            for bit in range(8):
                if image.getpixel((x,page*8+bit)):
                    byte|=(1<<bit)
            buffer.append(byte)

    return buffer

# フォントのパスとサイズ設定
font_size=11
font=ImageFont.truetype("/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf",font_size)

# 行高さ
line_height=font_size+2

# テキストスクロール表示
def draw_text_with_scroll(text):

    lines=[]

    for char in text:

        current_text=(lines[-1] if lines else "")+char

        bbox=font.getbbox(current_text)

        text_width=bbox[2]-bbox[0]

        # 横幅超過で改行
        if text_width>128:
            lines.append(char)

        else:

            if not lines:
                lines.append(current_text)

            else:
                lines[-1]=current_text

        # 縦幅超過でスクロール
        if len(lines)*line_height>64:
            lines.pop(0)

        # 白黒画像作成
        image=Image.new("1",(128,64),0)

        draw=ImageDraw.Draw(image)

        # 行描画
        y=0

        for line in lines:

            draw.text((0,y),line,font=font,fill=1)

            y+=line_height

        # 表示
        send(1,image_to_buffer(image))

        time.sleep(0.04)
        
# 表示テキスト
text="こんにちは、Raspberry Piと透明OLEDディスプレイを使っています。文字がディスプレイの幅を超えた場合は自動的に改行やスクロールを行い、長いテキストも適切に扱えるようにしました。"

draw_text_with_scroll(text)

unzip /home/pi/Downloads/seven_segment.zip -d /home/pi/

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

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# SSD1306用バッファ変換
def image_to_buffer(image):

    buffer=[]

    for page in range(8):
        for x in range(128):
            byte=0
            for bit in range(8):
                if image.getpixel((x,page*8+bit)):
                    byte|=(1<<bit)
            buffer.append(byte)

    return buffer

# フォント
font_path = "/home/pi/Seven Segment.ttf"

font1 = ImageFont.truetype(font_path, 14)
font2 = ImageFont.truetype(font_path, 15)
font3 = ImageFont.truetype(font_path, 25)
font4 = ImageFont.truetype(font_path, 38)

# スケーリング係数
scale_factor = 0.7
x_offset = 25

# 画面中心
Y_CENTER = 32

# 三角錐
pyramid = (
    (0, -20, 0),
    (-20, 20, -20),
    (20, 20, -20),
    (0, 20, 20)
)

scroll_x = 0

try:

    while True:

        for angle in range(0, 361, 10):

            # 描画用画像を作成
            img = Image.new("1", (128, 64), 0)
            draw = ImageDraw.Draw(img)

            # 現在日時を取得
            dt_now = datetime.datetime.now()

            date1 = dt_now.strftime("%m/%d")
            weekday = dt_now.strftime("%a").upper()
            hour = dt_now.strftime("%H")
            minute = dt_now.strftime("%M")
            second = dt_now.strftime("%S")
            second = dt_now.strftime("%S")
            
            scroll_text = dt_now.strftime("%Y/%m/%d %a").upper()

            # 頂点座標格納用
            f = [[0, 0] 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)

                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

            # 三角錐を描画
            for i in range(3):

                draw.line((f[0][0], f[0][1], f[i + 1][0], f[i + 1][1]), fill=1)

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

            # 日時を描画
            scroll_img = Image.new("1", (300, 18), 0)
            scroll_draw = ImageDraw.Draw(scroll_img)

            scroll_draw.text((0, 0), scroll_text, font=font2, fill=1)

            text_width = scroll_draw.textlength(scroll_text, font=font2)

            scroll_draw.text((text_width + 20, 0), scroll_text, font=font2, fill=1)

            crop = scroll_img.crop((scroll_x, 0, scroll_x + 85, 18))

            img.paste(crop, (43, 5))            
            
            draw.text((50, 28), hour, font=font3, fill=1)
            draw.text((71, 12), ":", font=font4, fill=1)
            draw.text((78, 28), minute, font=font3, fill=1)
            draw.text((108, 37), second, font=font2, fill=1)
            
            scroll_x += 2

            if scroll_x >= text_width + 20:
                scroll_x = 0            
            

            # SSD1306へ転送
            send(1, image_to_buffer(img))

            time.sleep(0.1)

except KeyboardInterrupt:
    pass

finally:
    lgpio.gpiochip_close(h)
    spi.close()

import spidev
import lgpio
import time
from PIL import Image, ImageDraw, ImageFont, ImageOps

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# SSD1306用バッファ変換
def image_to_buffer(image):

    buffer=[]

    for page in range(8):
        for x in range(128):
            byte=0
            for bit in range(8):
                if image.getpixel((x,page*8+bit)):
                    byte|=(1<<bit)
            buffer.append(byte)

    return buffer

# 画像読み込み
image = Image.open("tenki.png")

# 色反転
image = ImageOps.invert(image.convert("RGB"))

# 表示用画像作成
img = Image.new("1", (128, 64), 0)

# 画像貼り付け
img.paste(image.convert("1"), (0, 0))

# フォント読み込み
font = ImageFont.truetype(
    "/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf",
    11
)

# テキスト描画
draw = ImageDraw.Draw(img)
draw.text((60, 10), "Hello,OLED!", font=font, fill=1)

# SSD1306へ転送
send(1, image_to_buffer(img))

import spidev
import lgpio
import time
import json
import requests
from datetime import datetime
from PIL import Image, ImageDraw, ImageFont

# SPI初期化
spi=spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=8000000

h=lgpio.gpiochip_open(0)
lgpio.gpio_claim_output(h,25)
lgpio.gpio_claim_output(h,27)

# コマンド/データ送信関数
send=lambda dc,d:(lgpio.gpio_write(h,25,dc),spi.writebytes(d))

# ディスプレイをリセット
lgpio.gpio_write(h,27,0);time.sleep(0.05)
lgpio.gpio_write(h,27,1);time.sleep(0.05)

# SSD1306初期化
send(0,[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,0x21,0,127,0x22,0,7])

# SSD1306用バッファ変換
def image_to_buffer(image):

    buffer=[]

    for page in range(8):
        for x in range(128):
            byte=0
            for bit in range(8):
                if image.getpixel((x,page*8+bit)):
                    byte|=(1<<bit)
            buffer.append(byte)

    return buffer

def draw_dotted_line(draw, start, end, dash=2):

    x1, y1 = start
    x2, y2 = end

    if y1 == y2:

        for x in range(int(x1), int(x2), dash * 2):
            draw.line((x, y1, min(x + dash, x2), y1), fill=1)

    elif x1 == x2:

        for y in range(int(y1), int(y2), dash * 2):
            draw.line((x1, y, x1, min(y + dash, y2)), fill=1)

# CoinGecko API
url="https://api.coingecko.com/api/v3/coins/bitcoin/market_chart"

params={
    "vs_currency":"jpy",
    "days":80
}

# フォント
font_path="/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf"

font=ImageFont.truetype(font_path,11)
font_s=ImageFont.truetype(font_path,8)

try:

    while True:

        # 価格取得
        response=requests.get(url,params=params)
        response.raise_for_status()

        data=json.loads(response.text)

        prices=[x[1] for x in data["prices"]]

        min_price=min(prices)
        max_price=max(prices)

        sorted_prices=sorted(prices)
        prices_len=len(sorted_prices)

        if prices_len%2==1:
            median_price=sorted_prices[prices_len//2]
        else:
            middle1=sorted_prices[(prices_len//2)-1]
            middle2=sorted_prices[prices_len//2]
            median_price=(middle1+middle2)/2

        formatted_min_price=f"{min_price/1000000:.1f}M"
        formatted_median_price=f"{median_price/1000000:.1f}M"
        formatted_max_price=f"{max_price/1000000:.1f}M"

        last_price=prices[-1]
        formatted_price="{:,}".format(int(last_price))

        # 描画用画像
        img=Image.new("1",(128,64),0)
        draw=ImageDraw.Draw(img)

        # グラフ設定
        width=128
        height=64

        top_margin=13
        bottom_margin=0
        left_margin=22
        right_margin=0

        inner_margin=3

        graph_width=width-left_margin-right_margin
        graph_height=height-top_margin-bottom_margin

        # 現在価格
        draw.text((28,0),f"BTC:{formatted_price}円",font=font,fill=1)

        # 目盛
        draw.text((0,10),formatted_max_price,font=font_s,fill=1)
        draw.text((0,33),formatted_median_price,font=font_s,fill=1)
        draw.text((0,55),formatted_min_price,font=font_s,fill=1)

        # グラフ
        for i in range(1,len(prices)):

            x1=left_margin+inner_margin+(i-1)*(
                (graph_width-inner_margin*2)/(len(prices)-1)
            )

            y1=top_margin+inner_margin+(
                graph_height-inner_margin*2
            )-(
                (prices[i-1]-min_price)
                /(max_price-min_price)
                *(graph_height-inner_margin*2)
            )

            x2=left_margin+inner_margin+i*(
                (graph_width-inner_margin*2)/(len(prices)-1)
            )

            y2=top_margin+inner_margin+(
                graph_height-inner_margin*2
            )-(
                (prices[i]-min_price)
                /(max_price-min_price)
                *(graph_height-inner_margin*2)
            )

            draw.line((x1,y1,x2,y2),fill=1)

        # 枠線
        draw.rectangle(
            [
                left_margin,
                top_margin,
                left_margin+graph_width-1,
                top_margin+graph_height-1
            ],
            outline=1
        )

        # 横中央点線
        middle_y=top_margin+graph_height/2

        draw_dotted_line(
            draw,
            (left_margin,middle_y),
            (width-right_margin-1,middle_y)
        )

        # 縦点線
        third_x1=left_margin+graph_width/3
        third_x2=left_margin+graph_width*2/3

        draw_dotted_line(
            draw,
            (third_x1,top_margin),
            (third_x1,height-bottom_margin-1)
        )

        draw_dotted_line(
            draw,
            (third_x2,top_margin),
            (third_x2,height-bottom_margin-1)
        )

        # OLEDへ転送
        send(1,image_to_buffer(img))

        # 取得時刻表示
        now=datetime.now()
        print(f"取得時刻: {now.strftime('%Y-%m-%d %H:%M:%S')}")

        # 10分待機
        time.sleep(600)

except Exception as e:
    print(e)

except KeyboardInterrupt:
    pass

finally:
    lgpio.gpiochip_close(h)
    spi.close()

import RPi.GPIO as GPIO
from luma.oled.device import ssd1306
from luma.core.interface.serial import spi
from PIL import Image, ImageDraw, ImageFont

# ====== GPIO設定（6枚分）======
CS_PINS  = [21, 7, 22, 18, 12, 16]
DC_PINS  = [25, 24, 5, 13, 20, 2]
RST_PINS = [27, 23, 6, 19, 26, 3]

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)

for cs in CS_PINS:
    GPIO.setup(cs, GPIO.OUT)
    GPIO.output(cs, GPIO.HIGH)

# ====== OLEDインスタンスの初期化 ======
devices = []
for i in range(6):
    GPIO.output(CS_PINS[i], GPIO.LOW)
    serial = spi(port=0, device=0, gpio_DC=DC_PINS[i], gpio_RST=RST_PINS[i])
    device = ssd1306(serial)
    devices.append(device)
    GPIO.output(CS_PINS[i], GPIO.HIGH)

# ====== フォント設定 ======
font_path = "/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf"
font = ImageFont.truetype(font_path, 68)

# ====== 表示（白背景に黒文字）======
for i in range(6):
    for cs in CS_PINS:
        GPIO.output(cs, GPIO.HIGH)
    GPIO.output(CS_PINS[i], GPIO.LOW)
    image = Image.new('1', (128, 64), color=0)
    draw = ImageDraw.Draw(image)
    draw.text((50, 0), str(i+1), font=font, fill=255)
    devices[i].display(image)
    GPIO.output(CS_PINS[i], GPIO.HIGH)

# 全て非選択に戻す
for cs in CS_PINS:
    GPIO.output(cs, GPIO.HIGH)

import RPi.GPIO as GPIO
from luma.oled.device import ssd1306
from luma.core.interface.serial import spi
from luma.core.render import canvas
from PIL import ImageFont
import time
import threading

# GPIO定義
CS_PINS  = [21, 7, 22, 18, 12, 16]
DC_PINS  = [25, 24, 5, 13, 20, 2]
RST_PINS = [27, 23, 6, 19, 26, 3]

# 初期化
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
for pin in CS_PINS:
    GPIO.setup(pin, GPIO.OUT)
    GPIO.output(pin, GPIO.HIGH)

devices = []
for i in range(6):
    GPIO.output(CS_PINS[i], GPIO.LOW)
    serial = spi(port=0, device=0, gpio_DC=DC_PINS[i], gpio_RST=RST_PINS[i])
    devices.append(ssd1306(serial))
    GPIO.output(CS_PINS[i], GPIO.HIGH)

# フォント
font_path = "/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf"
font = ImageFont.truetype(font_path, 60)

# SPIロック
lock = threading.Lock()

# 共通処理
def draw_centered_text(draw, device_index, char):
    bbox = draw.textbbox((0, 0), char, font=font)
    w = bbox[2] - bbox[0]
    h = bbox[3] - bbox[1]
    draw.text(((128 - w)//2, (64 - h)//2), char, font=font, fill=255)

# 各ディスプレイごとのスレッド処理
def display0_thread():
    chars = list("0123456789")
    pos = 0
    while True:
        char = chars[pos % len(chars)]
        with lock:
            GPIO.output(CS_PINS[0], GPIO.LOW)
            with canvas(devices[0]) as draw:
                draw_centered_text(draw, 0, char)
            GPIO.output(CS_PINS[0], GPIO.HIGH)
        pos += 1
        time.sleep(1)

def display1_thread():
    chars = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
    pos = 0
    while True:
        char = chars[pos % len(chars)]
        with lock:
            GPIO.output(CS_PINS[1], GPIO.LOW)
            with canvas(devices[1]) as draw:
                draw_centered_text(draw, 1, char)
            GPIO.output(CS_PINS[1], GPIO.HIGH)
        pos += 1
        time.sleep(0.5)

def display2_thread():
    chars = list("あいうえおかきくけこ")
    pos = 0
    while True:
        char = chars[pos % len(chars)]
        with lock:
            GPIO.output(CS_PINS[2], GPIO.LOW)
            with canvas(devices[2]) as draw:
                draw_centered_text(draw, 2, char)
            GPIO.output(CS_PINS[2], GPIO.HIGH)
        pos += 1
        time.sleep(0.3)

def display3_thread():
    chars = list("漢字東京大阪明日元気")
    pos = 0
    while True:
        char = chars[pos % len(chars)]
        with lock:
            GPIO.output(CS_PINS[3], GPIO.LOW)
            with canvas(devices[3]) as draw:
                draw_centered_text(draw, 3, char)
            GPIO.output(CS_PINS[3], GPIO.HIGH)
        pos += 1
        time.sleep(0.1)

def display4_thread():
    chars = list("♠♥♦♣★☆♪☀☁☂")
    pos = 0
    while True:
        char = chars[pos % len(chars)]
        with lock:
            GPIO.output(CS_PINS[4], GPIO.LOW)
            with canvas(devices[4]) as draw:
                draw_centered_text(draw, 4, char)
            GPIO.output(CS_PINS[4], GPIO.HIGH)
        pos += 1
        time.sleep(0.7)

def display5_thread():
    chars = list("←→↑↓◎◉◇◆■□")
    pos = 0
    while True:
        char = chars[pos % len(chars)]
        with lock:
            GPIO.output(CS_PINS[5], GPIO.LOW)
            with canvas(devices[5]) as draw:
                draw_centered_text(draw, 5, char)
            GPIO.output(CS_PINS[5], GPIO.HIGH)
        pos += 1
        time.sleep(0.5)

# スレッド起動
threads = [
    threading.Thread(target=display0_thread),
    threading.Thread(target=display1_thread),
    threading.Thread(target=display2_thread),
    threading.Thread(target=display3_thread),
    threading.Thread(target=display4_thread),
    threading.Thread(target=display5_thread),
]
for t in threads:
    t.start()

try:
    for t in threads:
        t.join()
except KeyboardInterrupt:
    GPIO.cleanup()

import RPi.GPIO as GPIO
from luma.oled.device import ssd1306
from luma.core.interface.serial import spi
from luma.core.render import canvas
from PIL import Image, ImageDraw, ImageFont
import time
import threading
from math import sin, cos, radians
import requests
from datetime import datetime, timedelta
from bs4 import BeautifulSoup

# 気象データ共有クラス
class WeatherDataStore:
    def __init__(self):
        self.lock = threading.Lock()
        self.temps = []
        self.pressures = []
        self.humidities = []
        self.rains = []
        self.icon_code = ""
        self.summary = ""

    def update(self, temps, pressures, humidities, rains, summary=""):
        with self.lock:
            self.temps = temps
            self.pressures = pressures
            self.humidities = humidities
            self.rains = rains
            self.summary = summary            

    def get_data(self):
        with self.lock:
            return (
                self.temps[:],
                self.pressures[:],
                self.humidities[:],
                self.rains[:],
                self.summary
            )            


# インスタンス作成（全スレッドで共有）
weather_store = WeatherDataStore()

# データ取得スレッド
def weather_fetch_thread():
    api_key = 'OPENWEATHERMAP_API_KEY'# OpenWeatherMap の APIキー ※ 自分のAPIキーに置き換えてください。
    city = 'Shizuoka,JP' # 天気予報を取得したい都市（"都市名,国コード" の形式）
    url = 'https://api.openweathermap.org/data/2.5/forecast'
    params = {'q': city, 'appid': api_key, 'units': 'metric', 'lang': 'en'}
    
    pref_name = "静岡"  # 気象庁の天気概況（日本語の天気概要）取得に使用する都道府県名

    while True:
        try:
            res = requests.get(url, params=params)
            data = res.json()
            temps = [e['main']['temp'] for e in data['list'][:16]]
            pressures = [e['main']['pressure'] for e in data['list'][:16]]
            humidities = [e['main']['humidity'] for e in data['list'][:16]]
            rains = [e.get('rain', {}).get('3h', 0.0) for e in data['list'][:16]]
            
            summary_text = ""
            try:
                feed_url = "https://www.data.jma.go.jp/developer/xml/feed/regular.xml"
                feed_res = requests.get(feed_url)
                soup = BeautifulSoup(feed_res.content, "xml")

                for entry in soup.find_all("entry"):
                    if entry.find("title").text.strip() != "府県天気概況":
                        continue

                    xml_url = entry.find("link")["href"]
                    xml_res = requests.get(xml_url)
                    xml_soup = BeautifulSoup(xml_res.content, "xml")

                    target_area = xml_soup.find("TargetArea")
                    if target_area and pref_name in target_area.text:
                        text_tag = xml_soup.find("Text", {"type": "本文"})
                        if text_tag:
                            full_text = text_tag.text.strip()
                            if "【" in full_text:
                                summary_text = full_text.split("【")[0].strip()
                            else:
                                summary_text = full_text
                        break            

            except Exception as e:
                print("天気概況取得エラー:", e)

            weather_store.update(
                temps=temps,
                pressures=pressures,
                humidities=humidities,
                rains=rains,
                summary=summary_text
            )
            
            print("データ取得完了")
        except Exception as e:
            print("取得エラー:", e)
            
        time.sleep(3600)  # 1時間ごと
        
def draw_dotted_line(draw, start, end, interval=3, dot_length=1):
    x1, y1 = start
    x2, y2 = end
    total_length = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
    num_dots = int(total_length / interval)

    for i in range(num_dots):
        dot_start = i * interval + (interval - dot_length) / 2
        dot_end = dot_start + dot_length
        dot_start_x = x1 + (x2 - x1) * (dot_start / total_length)
        dot_start_y = y1 + (y2 - y1) * (dot_start / total_length)
        dot_end_x = x1 + (x2 - x1) * (dot_end / total_length)
        dot_end_y = y1 + (y2 - y1) * (dot_end / total_length)
        draw.line([(dot_start_x, dot_start_y), (dot_end_x, dot_end_y)], fill="white")        

# ====== GPIO設定（6枚分）======
CS_PINS  = [21, 7, 22, 18, 12, 16]
DC_PINS  = [25, 24, 5, 13, 20, 2]
RST_PINS = [27, 23, 6, 19, 26, 3]

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
for pin in CS_PINS:
    GPIO.setup(pin, GPIO.OUT)
    GPIO.output(pin, GPIO.HIGH)

# デバイス初期化
devices = []
for i in range(6):
    GPIO.output(CS_PINS[i], GPIO.LOW)
    serial = spi(port=0, device=0, gpio_DC=DC_PINS[i], gpio_RST=RST_PINS[i])
    devices.append(ssd1306(serial))
    GPIO.output(CS_PINS[i], GPIO.HIGH)

font_path = "/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf"
font = ImageFont.truetype(font_path, 10)
font_s = ImageFont.truetype(font_path, 8)
        
lock = threading.Lock()

# Display 1: アニメーション
def display1_thread():
    font1 = ImageFont.truetype(font_path, 13)
    font2 = ImageFont.truetype(font_path, 15)
    font3 = ImageFont.truetype(font_path, 25)

    scale_factor = 0.7
    x_offset = 25
    Y_CENTER = 32

    pyramid = ((0, -20, 0), (-20, 20, -20), (20, 20, -20), (0, 20, 20))

    while True:
        for angle in range(0, 361, 10):
            now = datetime.now()
            date1 = now.strftime('%b %-d')
            weekday = now.strftime('%a').upper()
            time1 = now.strftime('%H:%M')
            second = now.strftime('%S')
            f = [[0.0, 0.0] 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)
                x3 = (x1 * cos(r) - y2 * sin(r)) * scale_factor + x_offset
                y3 = (x1 * sin(r) + y2 * cos(r)) * scale_factor + Y_CENTER
                f[i] = [x3, y3]

            with lock:
                GPIO.output(CS_PINS[0], GPIO.LOW)
                with canvas(devices[0]) as draw:
                    for i in range(3):
                        draw.line((f[0][0], f[0][1], f[i+1][0], f[i+1][1]), fill="white")
                        draw.line((f[i+1][0], f[i+1][1], f[(i+1)%3+1][0], f[(i+1)%3+1][1]), fill="white")

                    draw.text((46, 5), date1, font=font2, fill="white")
                    draw.text((100, 5), weekday, font=font2, fill="white")
                    draw.text((46, 29), time1, font=font3, fill="white")
                    draw.text((114, 38), second, font=font1, fill="white")
                GPIO.output(CS_PINS[0], GPIO.HIGH)

            time.sleep(0.1)

# Display 2: 
def display2_thread():
    while True:
        try:
            _, _, humidities, _, _ = weather_store.get_data()
            if not humidities:
                time.sleep(1)
                continue

            values = humidities
            title = "Humidity (%)"

            # 湿度は0〜100に固定
            min_v = 0
            max_v = 100

            width = devices[1].width
            height = devices[1].height
            margin = 5
            left_label_width = 16
            bottom_label_height = 10
            top_padding = 10

            graph_width = width - margin - left_label_width
            graph_height = height - margin - bottom_label_height - top_padding
            step_x = graph_width / (len(values) - 1)
            fixed_lines = 5

            with lock:
                GPIO.output(CS_PINS[1], GPIO.LOW)
                with canvas(devices[1]) as draw:
                    draw.text((margin + 20, 0), title, font=font, fill=255)

                    # 補助線とラベル（0〜100を等間隔に）
                    for i in range(fixed_lines):
                        ratio = i / (fixed_lines - 1)
                        label_value = max_v - ratio * (max_v - min_v)
                        y = int(top_padding + ratio * graph_height)
                        draw_dotted_line(draw, (left_label_width, y), (width - margin, y))
                        draw.text((0, y - 4), f"{int(label_value)}", font=font_s, fill=255)

                    # 縦の点線（1/4、1/2、3/4）
                    for x in [
                        left_label_width + graph_width // 4,
                        left_label_width + graph_width // 2,
                        left_label_width + (graph_width * 3) // 4
                    ]:
                        draw_dotted_line(draw, (x, top_padding), (x, top_padding + graph_height))

                    # 折れ線グラフ（四捨五入しない）
                    for i in range(len(values) - 1):
                        x1 = int(left_label_width + i * step_x)
                        x2 = int(left_label_width + (i + 1) * step_x)
                        y1 = int(top_padding + (max_v - values[i]) / (max_v - min_v) * graph_height)
                        y2 = int(top_padding + (max_v - values[i + 1]) / (max_v - min_v) * graph_height)
                        draw.line((x1, y1, x2, y2), fill=255)

                    # グラフ枠線
                    draw.rectangle(
                        (left_label_width, top_padding, left_label_width + graph_width, top_padding + graph_height),
                        outline=255
                    )

                    # 横軸ラベル（仮で0d, 1d）
                    for i in range(2):
                        x = int(left_label_width + (i * 8 * step_x)) - 5
                        draw.text((x, height - bottom_label_height), f"{i}d", font=font_s, fill=255)

                GPIO.output(CS_PINS[1], GPIO.HIGH)
            time.sleep(60)

        except Exception as e:
            print(f"エラー in display1: {e}")
            time.sleep(60)    

# Display 3: 
def display3_thread():
    while True:
        try:
            _, pressures, _, _, _= weather_store.get_data()
            if not pressures:
                time.sleep(1)
                continue

            values = pressures
            title = "Pressure (hPa)"
            min_v = min(values)
            max_v = max(values)

            # 値の差に応じて余白（padding）を計算。ただし差が小さい場合は、最低5を確保する
            padding = max((max_v - min_v) * 0.1, 5)  
            min_v -= padding
            max_v += padding

            width = devices[2].width
            height = devices[2].height
            margin = 5
            left_label_width = 16
            bottom_label_height = 10
            top_padding = 10

            graph_width = width - margin - left_label_width
            graph_height = height - margin - bottom_label_height - top_padding
            step_x = graph_width / (len(values) - 1)
            fixed_lines = 5

            with lock:
                GPIO.output(CS_PINS[2], GPIO.LOW)
                with canvas(devices[2]) as draw:
                    draw.text((margin + 20, 0), title, font=font, fill=255)

                    for i in range(fixed_lines):
                        ratio = i / (fixed_lines - 1)
                        label_value = max_v - ratio * (max_v - min_v)
                        y = int(top_padding + ratio * graph_height)
                        draw_dotted_line(draw, (left_label_width, y), (width - margin, y))
                        draw.text((0, y - 4), f"{int(label_value)}", font=font_s, fill=255)

                    quarter_x1 = left_label_width + graph_width // 4
                    center_x = left_label_width + graph_width // 2
                    quarter_x3 = left_label_width + (graph_width * 3) // 4

                    draw_dotted_line(draw, (quarter_x1, top_padding), (quarter_x1, top_padding + graph_height))
                    draw_dotted_line(draw, (center_x, top_padding), (center_x, top_padding + graph_height))
                    draw_dotted_line(draw, (quarter_x3, top_padding), (quarter_x3, top_padding + graph_height))

                    for i in range(len(values) - 1):
                        x1 = int(left_label_width + i * step_x)
                        x2 = int(left_label_width + (i + 1) * step_x)
                        y1 = int(top_padding + (max_v - values[i]) / (max_v - min_v) * graph_height)
                        y2 = int(top_padding + (max_v - values[i + 1]) / (max_v - min_v) * graph_height)
                        draw.line((x1, y1, x2, y2), fill=255)

                    draw.rectangle(
                        (left_label_width, top_padding, left_label_width + graph_width, top_padding + graph_height),
                        outline=255
                    )

                    for i in range(2):
                        x = int(left_label_width + (i * 8 * step_x)) - 5
                        draw.text((x, height - bottom_label_height), f"{i}d", font=font_s, fill=255)

                GPIO.output(CS_PINS[2], GPIO.HIGH)

            time.sleep(60)

        except Exception as e:
            print(f"エラー: {e}")
            time.sleep(60)

# Display 4:
def display4_thread():
    while True:
        try:
            temps, _, _, _, _= weather_store.get_data()
            if not temps:
                time.sleep(1)
                continue

            values = temps
            title = "Temperature (°C)"
            min_v = min(values)
            max_v = max(values)
            padding = (max_v - min_v) * 0.1
            min_v -= padding
            max_v += padding

            width = devices[3].width
            height = devices[3].height
            margin = 5
            left_label_width = 16
            bottom_label_height = 10
            top_padding = 10

            graph_width = width - margin - left_label_width
            graph_height = height - margin - bottom_label_height - top_padding
            step_x = graph_width / (len(values) - 1)
            fixed_lines = 5

            with lock:
                GPIO.output(CS_PINS[3], GPIO.LOW)
                with canvas(devices[3]) as draw:
                    draw.text((margin + 20, 0), title, font=font, fill=255)

                    for i in range(fixed_lines):
                        ratio = i / (fixed_lines - 1)
                        label_value = max_v - ratio * (max_v - min_v)
                        y = int(top_padding + ratio * graph_height)
                        draw_dotted_line(draw, (left_label_width, y), (width - margin, y))
                        draw.text((0, y - 4), f"{round(label_value)}", font=font_s, fill=255)

                    quarter_x1 = left_label_width + graph_width // 4
                    center_x = left_label_width + graph_width // 2
                    quarter_x3 = left_label_width + (graph_width * 3) // 4

                    draw_dotted_line(draw, (quarter_x1, top_padding), (quarter_x1, top_padding + graph_height))
                    draw_dotted_line(draw, (center_x, top_padding), (center_x, top_padding + graph_height))
                    draw_dotted_line(draw, (quarter_x3, top_padding), (quarter_x3, top_padding + graph_height))

                    for i in range(len(values) - 1):
                        y1 = round(top_padding + (max_v - values[i]) / (max_v - min_v) * graph_height)
                        y2 = round(top_padding + (max_v - values[i + 1]) / (max_v - min_v) * graph_height)
                        x1 = int(left_label_width + i * step_x)
                        x2 = int(left_label_width + (i + 1) * step_x)
                        draw.line((x1, y1, x2, y2), fill=255)

                    draw.rectangle(
                        (left_label_width, top_padding, left_label_width + graph_width, top_padding + graph_height),
                        outline=255
                    )

                    for i in range(2):
                        x = int(left_label_width + (i * 8 * step_x)) - 5
                        draw.text((x, height - bottom_label_height), f"{i}d", font=font_s, fill=255)

                GPIO.output(CS_PINS[3], GPIO.HIGH)

            time.sleep(60)  # 毎分更新で十分

        except Exception as e:
            print(f"エラー in display4: {e}")
            time.sleep(60)
            
# Display 5:
def display5_thread():
    while True:
        try:
            _, _, _, rains, _ = weather_store.get_data()
            if not rains:
                time.sleep(1)
                continue

            values = rains
            title = "Rainfall (mm)"
            min_v = 0  # 降水量は 0 からスタート
            max_v = round(max(values + [0.0]) + 1.0)  # 最大値 + 1.0 mm

            width = devices[4].width
            height = devices[4].height
            margin = 5
            left_label_width = 16
            bottom_label_height = 10
            top_padding = 10

            graph_width = width - margin - left_label_width
            graph_height = height - margin - bottom_label_height - top_padding
            bar_width = graph_width / len(values)
            fixed_lines = 5

            with lock:
                GPIO.output(CS_PINS[4], GPIO.LOW)
                with canvas(devices[4]) as draw:
                    draw.text((margin + 20, 0), title, font=font, fill=255)

                    # 補助線とラベル
                    for i in range(fixed_lines):
                        ratio = i / (fixed_lines - 1)
                        label_value = max_v - ratio * (max_v - min_v)
                        y = int(top_padding + ratio * graph_height)
                        draw_dotted_line(draw, (left_label_width, y), (width - margin, y))
                        draw.text((0, y - 4), f"{label_value:.1f}", font=font_s, fill=255)

                    # 縦の点線（1/4, 1/2, 3/4）
                    for x in [
                        left_label_width + graph_width // 4,
                        left_label_width + graph_width // 2,
                        left_label_width + (graph_width * 3) // 4
                    ]:
                        draw_dotted_line(draw, (x, top_padding), (x, top_padding + graph_height))

                    # 棒グラフ
                    for i, value in enumerate(values):
                        x = int(left_label_width + i * bar_width)
                        h = int((value - min_v) / (max_v - min_v) * graph_height)
                        y_top = top_padding + graph_height - h
                        y_bottom = top_padding + graph_height
                        draw.rectangle((x, y_top, x + int(bar_width) - 1, y_bottom), fill=255)

                    # 枠線
                    draw.rectangle(
                        (left_label_width, top_padding, left_label_width + graph_width, top_padding + graph_height),
                        outline=255
                    )

                    # 横軸ラベル（例：0d, 1d）
                    for i in range(2):
                        x = int(left_label_width + (i * 8 * bar_width)) - 5
                        draw.text((x, height - bottom_label_height), f"{i}d", font=font_s, fill=255)

                GPIO.output(CS_PINS[4], GPIO.HIGH)

            time.sleep(60)

        except Exception as e:
            print(f"エラー in display5: {e}")
            time.sleep(60)


# Display 6:
def display6_thread():
    font_news = ImageFont.truetype(font_path, 12)
    font_size_s = 12

    device = devices[5]

    top_margin = 5
    offset_x = 5
    line_height = font_size_s + 7
    text_area_width = device.width - offset_x + 14

    last_summary = ""

    while True:
        _, _, _, _, summary = weather_store.get_data()
        if not summary:
            time.sleep(1)
            continue
        last_summary = summary

        sentences = [s.strip() + "。" for s in summary.split("。") if s.strip()]

        for sentence in sentences:
            lines = []
            current_line = ""

            for char in sentence:
                test_line = current_line + char
                bbox = font_news.getbbox(test_line)
                line_width = bbox[2] - bbox[0]

                if line_width > (text_area_width-12):
                    lines.append(current_line)
                    current_line = char
                else:
                    current_line = test_line

                # 最大2行＋current_lineまで
                display_lines = lines[-2:]

                image = Image.new("1", (device.width, device.height))
                draw = ImageDraw.Draw(image)

                text_y = top_margin
                for line in display_lines:
                    draw.text((offset_x, text_y), line, font=font_news, fill="white")
                    text_y += line_height
                draw.text((offset_x, text_y), current_line, font=font_news, fill="white")

                with lock:
                    GPIO.output(CS_PINS[5], GPIO.LOW)
                    device.display(image)
                    GPIO.output(CS_PINS[5], GPIO.HIGH)

                time.sleep(0.1)
            time.sleep(1)    

        time.sleep(0.1)

# スレッド起動
threads = [
    threading.Thread(target=weather_fetch_thread),
    threading.Thread(target=display1_thread),
    threading.Thread(target=display2_thread),
    threading.Thread(target=display3_thread),
    threading.Thread(target=display4_thread),
    threading.Thread(target=display5_thread),
    threading.Thread(target=display6_thread),
]    

for t in threads:
    t.start()

try:
    for t in threads:
        t.join()
except KeyboardInterrupt:
    GPIO.cleanup()

import yfinance as yf
import time
import RPi.GPIO as GPIO
from luma.oled.device import ssd1306
from luma.core.interface.serial import spi
from PIL import Image, ImageDraw, ImageFont
import unicodedata

# ====== GPIOピンの設定 ======
CS_PINS  = [21, 7, 22, 18, 12, 16]
DC_PINS  = [25, 24, 5, 13, 20, 2]
RST_PINS = [27, 23, 6, 19, 26, 3]

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
for cs in CS_PINS:
    GPIO.setup(cs, GPIO.OUT)
    GPIO.output(cs, GPIO.HIGH)

# ====== フォント（24px） ======
font_path = "/usr/share/fonts/truetype/takao-gothic/TakaoGothic.ttf"
font = ImageFont.truetype(font_path, 24)

devices = []

for i in range(6):
    GPIO.output(CS_PINS[i], GPIO.LOW)
    serial = spi(port=0, device=0, gpio_DC=DC_PINS[i], gpio_RST=RST_PINS[i])
    device = ssd1306(serial)
    devices.append(device)
    GPIO.output(CS_PINS[i], GPIO.HIGH)

companies = {
    "9432.T": "NTT",
    "8035.T": "東京エレクトロン",    
    "6902.T": "デンソー",
    "4063.T": "信越化学",
    "6367.T": "ダイキン",
    "7203.T": "トヨタ",
    "6758.T": "ソニー",
    "9984.T": "ソフトバンク",
    "8306.T": "三菱UFJ",
    "6861.T": "キーエンス",
    "6098.T": "リクルート",
    "^N225": "日経平均"
}

# ====== 表示サイズと余白 ======
name_width = 70
price_width = 70
diff_width = 70
gap = 0
block_width = name_width + price_width + diff_width + gap

display_width = 128 * len(devices)
display_height = 64

# ====== 描画準備 ======
dummy_img = Image.new("1", (1, 1))
dummy_draw = ImageDraw.Draw(dummy_img)

# データ取得と描画領域の計算
stock_data = []
for ticker, name in companies.items():
    stock = yf.Ticker(ticker)
    price = int(stock.fast_info["lastPrice"])
    prev_close = int(stock.fast_info["previousClose"])
    diff = price - prev_close
    sign = "+" if diff >= 0 else "-"
    diff_text = f"{sign}{abs(diff)}"
    stock_data.append((name, str(price), diff_text))

canvas_width = len(stock_data) * block_width
image = Image.new("1", (canvas_width, display_height))
draw = ImageDraw.Draw(image)

# 各行を右揃えで描画
x = 0
for name, price, diff in stock_data:
    name_x = x + name_width - dummy_draw.textbbox((0, 0), name, font=font)[2]
    price_x = x + price_width - dummy_draw.textbbox((0, 0), price, font=font)[2]
    diff_x = x + diff_width - dummy_draw.textbbox((0, 0), diff, font=font)[2]

    draw.text((name_x, 0), name, font=font, fill=255)
    draw.text((price_x, 21), price, font=font, fill=255)
    draw.text((diff_x, 42), diff, font=font, fill=255)

    x += block_width

# ====== スクロール範囲 ======
scroll_width = canvas_width
start_offset = -display_width
end_offset = scroll_width

# ====== 無限スクロールループ ======
while True:
    for offset in range(start_offset, end_offset, 2):
        for i in range(len(devices)):
            for cs in CS_PINS:
                GPIO.output(cs, GPIO.HIGH)
            GPIO.output(CS_PINS[i], GPIO.LOW)

            right_index = len(devices) - 1 - i
            x_start = offset + right_index * 128
            x_end = x_start + 128
            frame = image.crop((x_start, 0, x_end, display_height))

            devices[i].display(frame)
            GPIO.output(CS_PINS[i], GPIO.HIGH)

        time.sleep(0.01)

sudo systemctl enable pigpiod.service

sudo systemctl start pigpiod.service

wget http://abyz.me.uk/rpi/pigpio/code/irrp_py.zip

unzip irrp_py.zip

python3 irrp.py -r -g21 -f air_conditioner heating cooling

python3 irrp.py -p -g20 -f air_conditioner heating

python3 irrp.py -p -g20 -f air_conditioner cooling

import subprocess

# 暖房運転スタートのスクリプトを実行
subprocess.call(['python3', 'irrp.py', '-p', '-g20', '-f', 'air_conditioner', 'heating'])

git clone https://github.com/vshymanskyy/blynk-library-python.git

cd blynk-library-python

sudo python3 setup.py install

import BlynkLib
import subprocess

BLYNK_AUTH = 'Your_Blynk_Auth_Token'  # Blynkの認証トークンに置き換えてください

# Blynkインスタンスを初期化
blynk = BlynkLib.Blynk(BLYNK_AUTH)

# 仮想ピンV0に対するコールバック関数を定義（暖房モードで運転）
@blynk.on("V0")
def v0_write_handler(value):
    # ボタンが押されたら暖房モード運転のスクリプトを実行
    if int(value[0]) == 1:
        print("暖房ボタンが押されました。")
        subprocess.call(['python3', 'irrp.py', '-p', '-g20', '-f', 'air_conditioner', 'heating'])

# 仮想ピンV1に対するコールバック関数を定義（冷房モードで運転）
@blynk.on("V1")
def v1_write_handler(value):
    # ボタンが押されたら冷房モードのスクリプトを実行
    if int(value[0]) == 1:
        print("冷房ボタンが押されました。")
        subprocess.call(['python3', 'irrp.py', '-p', '-g20', '-f', 'air_conditioner', 'cooling'])

# メインループ
while True:
    blynk.run()

git clone https://github.com/waveshare/Waveshare-DSI-LCD
cd Waveshare-DSI-LCD
cd 6.1.21
cd 64
sudo bash ./WS_xinchDSI_MAIN.sh 40C I2C0
sudo reboot

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -

sudo apt install -y nodejs

git clone https://github.com/MichMich/MagicMirror

cd MagicMirror/

npm run install-mm

cp config/config.js.sample config/config.js

npm run start

cd MagicMirror/ && npm run start

let config = {
	address: "localhost",	// Address to listen on, can be:
							// - "localhost", "127.0.0.1", "::1" to listen on loopback interface
							// - another specific IPv4/6 to listen on a specific interface
							// - "0.0.0.0", "::" to listen on any interface
							// Default, when address config is left out or empty, is "localhost"
	port: 8080,
	basePath: "/",	// The URL path where MagicMirror² is hosted. If you are using a Reverse proxy
									// you must set the sub path here. basePath must end with a /
	ipWhitelist: ["127.0.0.1", "::ffff:127.0.0.1", "::1"],	// Set [] to allow all IP addresses
									// or add a specific IPv4 of 192.168.1.5 :
									// ["127.0.0.1", "::ffff:127.0.0.1", "::1", "::ffff:192.168.1.5"],
									// or IPv4 range of 192.168.3.0 --> 192.168.3.15 use CIDR format :
									// ["127.0.0.1", "::ffff:127.0.0.1", "::1", "::ffff:192.168.3.0/28"],

	useHttps: false,			// Support HTTPS or not, default "false" will use HTTP
	httpsPrivateKey: "",	// HTTPS private key path, only require when useHttps is true
	httpsCertificate: "",	// HTTPS Certificate path, only require when useHttps is true

	language: "en",
	locale: "en-US",
	logLevel: ["INFO", "LOG", "WARN", "ERROR"], // Add "DEBUG" for even more logging
	timeFormat: 24,
	units: "metric",

	modules: [
		{
			module: "alert",
		},
		{
			module: "updatenotification",
			position: "top_bar"
		},
		{
			module: "clock",
			position: "top_left"
		},
		{
			module: "calendar",
			header: "US Holidays",
			position: "top_left",
			config: {
				calendars: [
					{
						fetchInterval: 7 * 24 * 60 * 60 * 1000,
						symbol: "calendar-check",
						url: "https://ics.calendarlabs.com/76/mm3137/US_Holidays.ics"
					}
				]
			}
		},
		{
			module: "compliments",
			position: "lower_third"
		},
		{
			module: "weather",
			position: "top_right",
			config: {
				weatherProvider: "openweathermap",
				type: "current",
				location: "New York",
				locationID: "5128581", //ID from http://bulk.openweathermap.org/sample/city.list.json.gz; unzip the gz file and find your city
				apiKey: "YOUR_OPENWEATHER_API_KEY"
			}
		},
		{
			module: "weather",
			position: "top_right",
			header: "Weather Forecast",
			config: {
				weatherProvider: "openweathermap",
				type: "forecast",
				location: "New York",
				locationID: "5128581", //ID from http://bulk.openweathermap.org/sample/city.list.json.gz; unzip the gz file and find your city
				apiKey: "YOUR_OPENWEATHER_API_KEY"
			}
		},
		{
			module: "newsfeed",
			position: "bottom_bar",
			config: {
				feeds: [
					{
						title: "New York Times",
						url: "https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml"
					}
				],
				showSourceTitle: true,
				showPublishDate: true,
				broadcastNewsFeeds: true,
				broadcastNewsUpdates: true
			}
		},
	]
};

/*************** DO NOT EDIT THE LINE BELOW ***************/
if (typeof module !== "undefined") { module.exports = config; }

cd
cd ~/MagicMirror/modules
git clone https://github.com/nitpum/MMM-EmbedYoutube.git
cd MMM-EmbedYoutube
npm install

var config = {
    address: "0.0.0.0",
    port: 8080,
    ipWhitelist: ["127.0.0.1", "::ffff:127.0.0.1", "::1"],

    language: "ja",
    timeFormat: 24,
    units: "metric",

    modules: [
    		{
			module: "clock",
			position: "top_center",
            config: {
                showDate: false,
                displaySeconds: true, 
                },
		},
{
    module: 'MMM-EmbedYoutube', // Path to youtube module from modules folder Exmaple: MagicMirror/modules/custom/MMM-EmbedYoutube/ so it's custom/MMM-EmbedYoutube
    position: 'top_left', // This can be any of the regions.
    config: {
      // See 'Configuration options' in README.md for more information.
      video_id: 'n_GpVsz4nHU',
      loop: true,
      autoplay: true,
    },
  },
    ]
};

/*************** DO NOT EDIT THE LINE BELOW ***************/
if (typeof module !== "undefined") { module.exports = config; }

/* Magic Mirror
 * Module: Embed Youtube
 *
 * v 1.4.0
 *
 * By Nitipoom Unrrom (aka nitpum) https://nitpum.com
 * MIT Licensed.
 */
Module.register("MMM-EmbedYoutube", {
    defaults: {
        autoplay: false,
        cc_load_policy: false,
        color: "red",
        controls: false,
        disablekb: false,
        fs: true,
        height: 900,
        width: 1300,
        loop: false,
        modestbranding: false,
        rel: false,
        showinfo: false,
        video_id: "",
        playlist: "",
        video_list: []
    },

    getDom: function () {
        var wrapper = document.createElement("div");

        // Parameter
        var params = "";

        var videoList = "";
        if (this.config.video_list && this.config.video_list.length > 0) {
            videoList = "&playlist=";
            for (var i = 0; i < this.config.video_list.length; i++) {
                videoList += this.config.video_list[i];
                if (i + 1 < this.config.video_list.length) {
                    videoList += ",";
                }
            }
        }

        params += this.config.autoplay ? "autoplay=1" : "autoplay=0";
        params += this.config.cc_load_policy ? "&cc_load_policy=1" : "&cc_load_policy=0";
        params += (typeof this.config.color !== "undefined" && this.config.color != "red") ? "&color=" + this.config.color : "";
        params += this.config.controls ? "&controls=1" : "&controls=0";
        params += this.config.disablekb ? "&disablekb=1" : "";
        params += this.config.fs ? "" : "&fs=0";
        params += (videoList != "" && (typeof this.config.playlist === "undefined" || this.config.playlist == "")) ? videoList : "&playlist=" + this.config.video_id;
        params += this.config.loop ? "&loop=1" : "";
        params += this.config.modestbranding ? "&modestbranding=1" : "";
        params += this.config.rel ? "&rel=1" : "&rel=0";
        params += this.config.showinfo ? "&showinfo=1" : "&showinfo=0";

        var videoId = this.config.video_id + "?version=3";
        if (typeof this.config.playlist !== "undefined" && this.config.playlist != "") {
            videoId = "playlist?list=" + this.config.playlist + "&";
        }

        wrapper.innerHTML =
            "<iframe width=\"" + this.config.width +
            "\" height=\"" + this.config.height +
            "\" src=\"https://www.youtube.com/embed/" + videoId + "&" + params +
            "\" frameborder=\"0\"" +
            " referrerpolicy=\"strict-origin-when-cross-origin\"" +
            " allow=\"autoplay; encrypted-media\"" +
            " allowfullscreen></iframe>";

        return wrapper;
    }
});

touch /home/pi/MagicMirror/config/custom.css

nano /home/pi/MagicMirror/config/custom.css

.MMM-EmbedYoutube {
  margin-left: -370px;    
  margin-top: -150px;
}

Module.register("MMM-EmbedYoutube", {
    defaults: {
        autoplay: false,
        cc_load_policy: false,
        color: "red",
        controls: false,
        disablekb: false,
        fs: true,
        height: 900,
        width: 1300,
        loop: false,
        modestbranding: false,
        rel: false,
        showinfo: false,
        video_id: "",
        playlist: "",
        video_list: [],
        videoRotationList: "", // 動画IDのリスト
        rotationInterval: 60000, // 1分おきに動画を切り替える
    },

    start: function() {
        this.currentVideoIndex = 0; // 現在の動画インデックス
        this.updateVideo(); // 最初の動画を設定
        this.scheduleUpdate(); // 動画更新スケジュールを設定
    },

    scheduleUpdate: function() {
        var self = this;
        setInterval(function() {
            self.updateVideo();
        }, this.config.rotationInterval);
    },

    updateVideo: function() {
        if (this.config.videoRotationList.length > 0) {
            this.config.video_id = this.config.videoRotationList[this.currentVideoIndex];
            this.currentVideoIndex += 1;
            if (this.currentVideoIndex >= this.config.videoRotationList.length) {
                this.currentVideoIndex = 0; // リストの最初に戻る
            }
            this.updateDom();
        }
    },

    getDom: function() {
        var wrapper = document.createElement("div");

        // Parameter
        var params = "";

        var videoList = "";
        if (this.config.video_list && this.config.video_list.length > 0) {
            videoList = "&playlist=";
            for (var i = 0; i < this.config.video_list.length; i++) {
                videoList += this.config.video_list[i];
                if (i + 1 < this.config.video_list.length) videoList += ",";
            }
        }
        params += (this.config.autoplay) ? "autoplay=1" : "autoplay=0";
        params += (this.config.cc_load_policy) ? "&cc_load_policy=1" : "&cc_load_policy=0";
        params += (typeof this.config.color !== "undefined" && this.config.color != "red") ? "&color=" + this.config.color : "";
        params += (this.config.controls) ? "&controls=1" : "&controls=0";
        params += (this.config.disablekb) ? "&disablekb=1" : "";
        params += (this.config.fs) ? "" : "&fs=0";
        params += (videoList != "" && (typeof this.config.playlist === "undefined" || this.config.playlist == "")) ? videoList : "&playlist=" + this.config.video_id;
        params += (this.config.loop) ? "&loop=1" : "";
        params += (this.config.modestbranding) ? "&modestbranding=1" : "";
        params += (this.config.rel) ? "&rel=1" : "&rel=0";
        params += (this.config.showinfo) ? "&showinfo=1" : "&showinfo=0";

        var videoId = this.config.video_id + "?version=3";
        if (typeof this.config.playlist !== "undefined" && this.config.playlist != "")
            videoId = "playlist?list=" + this.config.playlist + "&";

        wrapper.innerHTML = "<iframe width=\"" + this.config.width + "\" height=\"" + this.config.height + "\" src=\"https://www.youtube.com/embed/" + videoId + "&" + params + "\" frameborder=\"0\" allowfullscreen></iframe>";
        return wrapper;
    }
});

var config = {
    address: "0.0.0.0",
    port: 8080,
    ipWhitelist: ["127.0.0.1", "::ffff:127.0.0.1", "::1"],

    language: "ja",
    timeFormat: 24,
    units: "metric",

    modules: [
    		{
			module: "clock",
			position: "top_center",
            config: {
                showDate: false,
                displaySeconds: true 
                },
		},
        
{
    module: 'MMM-EmbedYoutube', // Path to youtube module from modules folder Exmaple: MagicMirror/modules/custom/MMM-EmbedYoutube/ so it's custom/MMM-EmbedYoutube
    position: 'top_left', // This can be any of the regions.
    config: {
      // See 'Configuration options' in README.md for more information.
      videoRotationList: ['dkLjO4TE634', 'O52zDyxg5QI'],
      rotationInterval: 60000, // 1分おきに動画を切り替える
      loop: true,
      autoplay: true,
    },
  },
    ]
};

/*************** DO NOT EDIT THE LINE BELOW ***************/
if (typeof module !== "undefined") { module.exports = config; }

pip3 install openai

# OpenAIのライブラリをインポート
import openai

# APIキーを設定
openai.api_key = "YOUR OpenAI API key" # 前述で発行したAPIキーに置き換えてください

# クライアントを初期化
client = openai.OpenAI(api_key=openai.api_key)

# GPT-3.5-turboモデルを使ってチャットの回答を生成するリクエストを作成
response = client.chat.completions.create(
    model="gpt-3.5-turbo",  # 使用するモデルを指定
    messages=[  # メッセージのリスト
        {
            "role": "user",  # ユーザーの役割
            "content": "あなたは誰？"  # ユーザーからの質問
        },
    ]
)

# 返信のみを取得して変数に格納
c_res = response.choices[0].message.content

# 返信を出力
print(c_res)

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user",
         "content": "最低気温"+temp_min+"℃、最高気温"+temp_max+"℃、"+tenki+"の天気に適した30代男性の服装を50文字以内で教えて。気温や天気は不要です。"}, #※1後述
    ]
)

user = '''
あなたは骨格診断のスペシャリストです。
これから私にさまざまな質問をしながら骨格診断をして、私の骨格のタイプを教えて。

#質問のルール
・質問形式は全てAとBの2択で答えられるようにしてください。
・質問数は最大7回まで。
・最後の質問に答えたあとに診断結果を出してください。
・最初の質問で,AとBの2択で性別を選択させること。
・質問は必ず１つずつ出力してください。
・質問文は簡潔にすること。
・診断結果は簡潔にすること。
・「了解しました。」や「次の質問です。」は書かないこと。

それでは質問を開始してください。'''

sudo apt update

sudo apt install -y python3-opencv

rpicam-hello --timeout 0

from picamera2 import Picamera2

picam2 = Picamera2()

# フル解像度で画像を取得するための設定
capture_config = picam2.create_still_configuration(
    main={"size": picam2.camera_properties['PixelArraySize']}  # センサーのフル解像度を指定
)

# 設定の適用
picam2.configure(capture_config)

# カメラの開始
picam2.start()

# 画像のキャプチャ
picam2.capture_file("test.jpg")

# カメラの停止
picam2.stop()

from picamera2 import Picamera2
import datetime

# 現在の日時を取得し、ファイル名に使用する
dt_now = datetime.datetime.now()
file_name = dt_now.strftime('%Y%m%d_%H%M%S')

picam2 = Picamera2()

# フル解像度で画像を取得するための設定
capture_config = picam2.create_still_configuration(
    main={"size": picam2.camera_properties['PixelArraySize']}  # センサーのフル解像度を指定
)

# 設定の適用
picam2.configure(capture_config)

# カメラの開始
picam2.start()

# 画像のキャプチャ
picam2.capture_file(file_name + '.jpg')

# カメラの停止
picam2.stop()

from picamera2 import Picamera2

picam2 = Picamera2()

# 解像度を1920x1080に設定
video_config = picam2.create_video_configuration(
    main={"size": (1920, 1080)}  # フルHDに変更
)

# 設定の適用
picam2.configure(video_config)

# 動画撮影の開始と5秒後の自動停止
picam2.start_and_record_video("test.mp4", duration=5)

# カメラの停止
picam2.stop()

import cv2
from picamera2 import Picamera2
from libcamera import controls

picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(main={"format": 'XRGB8888', "size": (640, 480)}))
picam2.start()
#カメラを連続オートフォーカスモードにする
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

while True:
  im = picam2.capture_array()
  cv2.imshow("Camera", im)
 
  key = cv2.waitKey(1)
  # Escキーを入力されたら画面を閉じる
  if key == 27:
    break

picam2.stop()
cv2.destroyAllWindows()

picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})

import cv2
from picamera2 import Picamera2
from libcamera import controls
import os

picam2 = Picamera2()

#HDRをオンにする
os.system("v4l2-ctl --set-ctrl wide_dynamic_range=1 -d /dev/v4l-subdev0")
print("Setting HDR to ON")

picam2.configure(picam2.create_preview_configuration(main={"format": 'XRGB8888', "size": (640, 480)}))
picam2.start()
#カメラを連続オートフォーカスモードにする
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})

while True:
  im = picam2.capture_array()
  cv2.imshow("Camera", im)
 
  key = cv2.waitKey(1)
  # Escキーを入力されたら画面を閉じる
  if key == 27:
    break

picam2.stop()
cv2.destroyAllWindows()

#HDRをオフにする
os.system("v4l2-ctl --set-ctrl wide_dynamic_range=0 -d /dev/v4l-subdev0")
print("Setting HDR to OFF")

sudo apt install opencv-data

import cv2
from picamera2 import Picamera2
from libcamera import controls

# Haar Cascadeのファイルパス
HAAR_FILE = (
    "/usr/share/opencv4/haarcascades/"
    "haarcascade_frontalface_default.xml"
)
face_detector = cv2.CascadeClassifier(HAAR_FILE)

cv2.startWindowThread()

picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(main={"format": 'XRGB8888', "size": (640, 480)}))
picam2.start()
#カメラを連続オートフォーカスモードにする
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

while True:
    im = picam2.capture_array()

    grey = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
    faces = face_detector.detectMultiScale(grey, 1.1, 5)

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

    cv2.imshow("Camera", im)
   
    key = cv2.waitKey(1)
    # Escキーを入力されたら画面を閉じる
    if key == 27:
        break

picam2.stop()
cv2.destroyAllWindows()

sudo apt update

sudo apt install libcap-dev

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

source ~/mp/bin/activate

git clone https://github.com/googlesamples/mediapipe.git

cd mediapipe/examples/object_detection/raspberry_pi

sh setup.sh

# Copyright 2023 The MediaPipe Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import sys
import time
import cv2
import mediapipe as mp
from picamera2 import Picamera2
from libcamera import controls
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
from utils import visualize

# Initial configuration of the camera
picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(
    main={"format": 'XRGB8888', "size": (640, 480)}))
picam2.start()
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

# Global variables to calculate FPS
COUNTER, FPS = 0, 0
START_TIME = time.time()

def run(model: str, max_results: int, score_threshold: float,
        width: int, height: int) -> None:
            
    global is_inference_in_flight
    global latest_detection_result

    # Initialize global variables here
    is_inference_in_flight = False
    latest_detection_result = None            

    def save_result(result: vision.ObjectDetectorResult,
                    unused_output_image: mp.Image,
                    timestamp_ms: int):
        """Callback when the detection is done."""
        global is_inference_in_flight, latest_detection_result, COUNTER, START_TIME, FPS

        # Mark that inference has finished, so we can send another frame
        is_inference_in_flight = False

        # Update FPS
        if COUNTER % fps_avg_frame_count == 0:
            current_time = time.time()
            FPS = fps_avg_frame_count / (current_time - START_TIME)
            START_TIME = current_time

        latest_detection_result = result
        COUNTER += 1

    # Initialize the object detection model
    base_options = python.BaseOptions(model_asset_path=model)
    options = vision.ObjectDetectorOptions(
        base_options=base_options,
        running_mode=vision.RunningMode.LIVE_STREAM,
        max_results=max_results,
        score_threshold=score_threshold,
        result_callback=save_result
    )
    detector = vision.ObjectDetector.create_from_options(options)

    # Visualization parameters
    row_size = 50  # pixels
    left_margin = 24  # pixels
    text_color = (0, 0, 0)  # black
    font_size = 1
    font_thickness = 1
    fps_avg_frame_count = 10

    # Create a window to display the detection results
    cv2.namedWindow('object_detection', cv2.WINDOW_NORMAL)
    cv2.resizeWindow('object_detection', 800, 600)

    while True:
        frame = picam2.capture_array()
        if frame is None:
            break

        # Resize and convert for inference
        image = cv2.resize(frame, (width, height))
        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image)

        # If the previous inference is done, start a new one
        if not is_inference_in_flight:
            detector.detect_async(mp_image, time.time_ns() // 1_000_000)
            is_inference_in_flight = True
        else:
            # If inference is still in flight,
            # we do NOT enqueue a new frame to avoid backlog
            pass

        # Draw FPS
        fps_text = 'FPS = {:.1f}'.format(FPS)
        text_location = (left_margin, row_size)
        cv2.putText(image, fps_text, text_location, cv2.FONT_HERSHEY_DUPLEX,
                    font_size, text_color, font_thickness, cv2.LINE_AA)

        # Visualize the latest detection result (if it exists)
        if latest_detection_result is not None:
            image = visualize(image, latest_detection_result)

        cv2.imshow('object_detection', image)

        # Stop if ESC is pressed
        if cv2.waitKey(1) == 27:
            break

    detector.close()
    picam2.stop()
    cv2.destroyAllWindows()

def main():
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('--model', help='Path of the object detection model.',
                        required=False, default='efficientdet.tflite')
    parser.add_argument('--maxResults', help='Max number of detection results.',
                        required=False, default=5)
    parser.add_argument('--scoreThreshold',
                        help='The score threshold of detection results.',
                        required=False, type=float, default=0.25)
    parser.add_argument('--cameraId', help='Id of camera.',
                        required=False, type=int, default=0)
    parser.add_argument('--frameWidth',
                        help='Width of frame to capture from camera.',
                        required=False, type=int, default=1280)
    parser.add_argument('--frameHeight',
                        help='Height of frame to capture from camera.',
                        required=False, type=int, default=720)
    args = parser.parse_args()

    run(args.model, int(args.maxResults), args.scoreThreshold,
        args.frameWidth, args.frameHeight)

if __name__ == '__main__':
    main()

# Copyright 2023 The MediaPipe Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import sys
import time
import cv2
import mediapipe as mp
from picamera2 import Picamera2
from libcamera import controls
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
from utils import visualize

# 任意の物体名を指定する変数（ここで変更可能）
target_object = "person"  # ここを好きな物体名に変更できる

# カメラの初期設定
picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(
    main={"format": 'XRGB8888', "size": (640, 480)}))
picam2.start()
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

# FPS計算用のグローバル変数
COUNTER, FPS = 0, 0
START_TIME = time.time()
is_inference_in_flight = False
latest_detection_result = None
fps_avg_frame_count = 10

def save_result(result: vision.ObjectDetectorResult,
                unused_output_image: mp.Image,
                timestamp_ms: int):
    """検出が完了したときに呼び出されるコールバック関数"""
    global is_inference_in_flight, latest_detection_result, COUNTER, START_TIME, FPS

    # 推論が終了したことをマークし、新しいフレームを送信できるようにする
    is_inference_in_flight = False

    # 検出結果から指定した物体の数をカウントする
    object_count = sum(1 for detection in result.detections if detection.categories[0].category_name == target_object)
    
    # 検出された物体の数をコンソールに出力
    print(f"検出された {target_object} の数: {object_count}")

    # FPSを更新
    if COUNTER % fps_avg_frame_count == 0:
        current_time = time.time()
        FPS = fps_avg_frame_count / (current_time - START_TIME)
        START_TIME = current_time

    latest_detection_result = result
    COUNTER += 1

    # 画像上に検出された物体の数を描画
    object_text = f'{target_object.capitalize()}: {object_count}'
    image_copy = unused_output_image.numpy_view().copy()  # 書き込み可能なコピーを作成
    cv2.putText(image_copy, object_text, (24, 100),
                cv2.FONT_HERSHEY_DUPLEX, 1, (0, 0, 255), 1, cv2.LINE_AA)

def run(model: str, max_results: int, score_threshold: float,
        width: int, height: int) -> None:
    global is_inference_in_flight

    # オブジェクト検出モデルを初期化
    base_options = python.BaseOptions(model_asset_path=model)
    options = vision.ObjectDetectorOptions(
        base_options=base_options,
        running_mode=vision.RunningMode.LIVE_STREAM,
        max_results=max_results,
        score_threshold=score_threshold,
        result_callback=save_result
    )
    detector = vision.ObjectDetector.create_from_options(options)

    # 表示に関するパラメータ
    row_size = 50  # ピクセル
    left_margin = 24  # ピクセル
    text_color = (0, 0, 0)  # 黒
    font_size = 1
    font_thickness = 1

    # 検出結果を表示するウィンドウを作成
    cv2.namedWindow('object_detection', cv2.WINDOW_NORMAL)
    cv2.resizeWindow('object_detection', 800, 600)

    while True:
        frame = picam2.capture_array()
        if frame is None:
            break

        # フレームをリサイズし、推論用に変換
        image = cv2.resize(frame, (width, height))
        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image)

        # 前回の推論が終了していれば、新しい推論を開始
        if not is_inference_in_flight:
            detector.detect_async(mp_image, time.time_ns() // 1_000_000)
            is_inference_in_flight = True

        # FPSを画像上に描画
        fps_text = 'FPS = {:.1f}'.format(FPS)
        text_location = (left_margin, row_size)
        cv2.putText(image, fps_text, text_location, cv2.FONT_HERSHEY_DUPLEX,
                    font_size, text_color, font_thickness, cv2.LINE_AA)

        # 最新の検出結果が存在する場合は画像に描画
        if latest_detection_result is not None:
            image = visualize(image, latest_detection_result)

            # 画像上に検出された物体の数を描画
            object_count = sum(1 for detection in latest_detection_result.detections if detection.categories[0].category_name == target_object)
            object_text = f'{target_object.capitalize()}: {object_count}'
            cv2.putText(image, object_text, (24, 100), cv2.FONT_HERSHEY_DUPLEX,
                        font_size, text_color, font_thickness, cv2.LINE_AA)

        cv2.imshow('object_detection', image)

        # ESCキーが押されたら終了
        if cv2.waitKey(1) == 27:
            break

    detector.close()
    picam2.stop()
    cv2.destroyAllWindows()

def main():
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('--model', help='オブジェクト検出モデルのパス',
                        required=False, default='efficientdet.tflite')
    parser.add_argument('--maxResults', help='検出結果の最大数',
                        required=False, default=5)
    parser.add_argument('--scoreThreshold',
                        help='検出結果のスコア閾値',
                        required=False, type=float, default=0.25)
    parser.add_argument('--cameraId', help='カメラID',
                        required=False, type=int, default=0)
    parser.add_argument('--frameWidth',
                        help='カメラからキャプチャするフレームの幅',
                        required=False, type=int, default=1280)
    parser.add_argument('--frameHeight',
                        help='カメラからキャプチャするフレームの高さ',
                        required=False, type=int, default=720)
    args = parser.parse_args()

    run(args.model, int(args.maxResults), args.scoreThreshold,
        args.frameWidth, args.frameHeight)

if __name__ == '__main__':
    main()