# サーボを0〜180度でゆっくり往復させる
from gpiozero import AngularServo
from time import sleep
SERVO_PIN = 18
STEP_INTERVAL = 0.015  # 角度を1度動かす間隔(秒)
servo = AngularServo(SERVO_PIN, min_angle=0, max_angle=180,
                      min_pulse_width=0.0005, max_pulse_width=0.0025)
angle = 0
step = 1
while True:
    servo.angle = angle
    sleep(STEP_INTERVAL)
    angle += step
    if angle >= 180 or angle <= 0:
        step = -step  # 端まで来たら向きを反転

# L298NでDCモーターの向きと速さを制御
from gpiozero import Motor
from time import sleep
motor = Motor(forward=23, backward=24, enable=18, pwm=True)
while True:
    motor.forward(0.6)   # ゆっくり正転(速度は0.0〜1.0)
    sleep(2)
    motor.stop()
    sleep(0.5)
    motor.backward(0.9)  # 速めに逆転
    sleep(2)
    motor.stop()
    sleep(0.5)

from gpiozero import OutputDevice
from time import sleep
PINS = (5, 6, 13, 19)
STEPS_PER_REV = 4096  # 28BYJ-48の1回転あたりステップ数(半ステップ)
outputs = [OutputDevice(p) for p in PINS]
SEQUENCE = [
    [1, 0, 0, 0],
    [1, 1, 0, 0],
    [0, 1, 0, 0],
    [0, 1, 1, 0],
    [0, 0, 1, 0],
    [0, 0, 1, 1],
    [0, 0, 0, 1],
    [1, 0, 0, 1],
]
def step(count, delay=0.0015):
    direction = 1 if count >= 0 else -1
    phases = SEQUENCE if direction == 1 else list(reversed(SEQUENCE))
    for _ in range(abs(count)):
        for phase in phases:
            for pin, value in zip(outputs, phase):
                pin.value = value
            sleep(delay)
while True:
    print("Forward 1 turn")
    step(STEPS_PER_REV)             # 1回転、正転
    sleep(1)
    print("Backward half turn")
    step(-STEPS_PER_REV // 2)        # 半回転、逆転
    sleep(1)

# オリジナルの短いメロディーを演奏する
from gpiozero import TonalBuzzer
from gpiozero.tones import Tone
from time import sleep
buzzer = TonalBuzzer(18)
# ドレミファソラシド(オクターブ4〜5)
notes = ["C4", "D4", "E4", "F4", "G4", "A4", "B4", "C5"]
durations = [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.6]
while True:
    for note, duration in zip(notes, durations):
        buzzer.play(Tone(note))
        sleep(duration * 1.2)  # 音と音の間に少し隙間を空ける
    buzzer.stop()
    sleep(2)

# pip install tm1637
import tm1637
from time import sleep, monotonic
CLK_PIN = 23
DIO_PIN = 24
display = tm1637.TM1637(clk=CLK_PIN, dio=DIO_PIN)
display.brightness(5)  # 0〜7
start_time = monotonic()
while True:
    elapsed_sec = int(monotonic() - start_time)
    minutes = (elapsed_sec // 60) % 100
    seconds = elapsed_sec % 60
    display.numbers(minutes, seconds, colon=True)  # 中央のコロンを点灯
    sleep(0.2)

# pip install RPLCD
# 事前に sudo raspi-config で I2C を有効化しておく
from RPLCD.i2c import CharLCD
# アドレスは0x27または0x3Fが多い(不明な場合はi2cdetect -y 1で確認)
lcd = CharLCD('PCF8574', 0x27, cols=16, rows=2)
lcd.clear()
lcd.write_string('Hello, RaspberryPi!')
lcd.crlf()
lcd.write_string('LCD Ready :)')
# 表示は固定のまま。動くコードにしたい時はここでlcd.clear()と
# 新しい表示内容を書き直す

# pip install luma.led-matrix
# 事前に sudo raspi-config で SPI を有効化しておく
from luma.core.interface.serial import spi, noop
from luma.core.render import canvas
from luma.led_matrix.device import max7219
serial = spi(port=0, device=0, gpio=noop())
device = max7219(serial, cascaded=1, block_orientation=0)
device.contrast(16)
# ハート型のパターン(1行8ビット×8行)
HEART = [
    "01100110",
    "11111111",
    "11111111",
    "11111111",
    "01111110",
    "00111100",
    "00011000",
    "00000000",
]
with canvas(device) as draw:
    for y, row in enumerate(HEART):
        for x, bit in enumerate(row):
            if bit == "1":
                draw.point((x, y), fill="white")

# 赤→青→黄→赤 の順で切り替わる信号機
from gpiozero import LED
from time import monotonic
red = LED(17)
yellow = LED(27)
green = LED(22)
DURATIONS = {"RED": 4, "GREEN": 3, "YELLOW": 1}
state = "RED"
state_start = monotonic()
def apply_state():
    red.value = state == "RED"
    yellow.value = state == "YELLOW"
    green.value = state == "GREEN"
while True:
    elapsed = monotonic() - state_start
    if elapsed >= DURATIONS[state]:
        state = {"RED": "GREEN", "GREEN": "YELLOW", "YELLOW": "RED"}[state]
        state_start = monotonic()
    apply_state()

# 6個のLEDが左右に往復する光の帯
from gpiozero import LEDBoard
from time import sleep
leds = LEDBoard(2, 3, 4, 17, 27, 22)
position = 0
direction = 1
while True:
    leds.value = tuple(i == position for i in range(len(leds)))
    sleep(0.08)
    position += direction
    if position >= len(leds) - 1 or position <= 0:
        direction = -direction  # 端で折り返す

# LEDが光ってからボタンを押すまでの時間を測る
from gpiozero import LED, Button
from time import monotonic, sleep
import random
led = LED(17)
button = Button(2, pull_up=True)
while True:
    print("Get ready...")
    led.off()
    sleep(random.uniform(2, 5))  # ランダムな待ち時間でフライングを防ぐ
    led.on()
    lit_time = monotonic()
    print("GO! Press the button!")
    button.wait_for_press()
    reaction_ms = int((monotonic() - lit_time) * 1000)
    led.off()
    print(f"Reaction time: {reaction_ms} ms")
    sleep(3)

# ボタンを押すとサイコロの目(LED本数)がランダムに光る
from gpiozero import LEDBoard, Button
from signal import pause
import random
leds = LEDBoard(2, 3, 4, 17, 27, 22)
button = Button(8, pull_up=True)
def roll_dice():
    result = random.randint(1, 6)  # 1〜6
    leds.value = tuple(i < result for i in range(6))
    print(f"Dice: {result}")
button.when_pressed = roll_dice
pause()  # イベント待ちのままプログラムを維持する

# ボタンを押すとグー・チョキ・パーをランダム表示
from gpiozero import LED, Button
from signal import pause
import random
rock = LED(17)
scissors = LED(27)
paper = LED(22)
button = Button(2, pull_up=True)
HAND_NAMES = ["Rock", "Scissors", "Paper"]
def show_hand():
    hand = random.randint(0, 2)  # 0:グー 1:チョキ 2:パー
    rock.value = hand == 0
    scissors.value = hand == 1
    paper.value = hand == 2
    print(HAND_NAMES[hand])
button.when_pressed = show_hand
pause()

# pip install tm1637
import tm1637
from gpiozero import Button, TonalBuzzer
from gpiozero.tones import Tone
from time import sleep, monotonic
CLK_PIN = 23
DIO_PIN = 24
display = tm1637.TM1637(clk=CLK_PIN, dio=DIO_PIN)
display.brightness(5)
buzzer = TonalBuzzer(18)
button = Button(4, pull_up=True)
seconds_left = 10  # 10秒からスタート
running = False
last_tick_time = monotonic()
display.number(seconds_left)
while True:
    if not running and button.is_pressed:
        running = True
        seconds_left = 10
        last_tick_time = monotonic()
    if running and monotonic() - last_tick_time >= 1:
        last_tick_time = monotonic()
        seconds_left -= 1
        display.number(seconds_left)
        if seconds_left <= 0:
            running = False
            buzzer.play(Tone("A4"))  # 終了音
            sleep(0.8)
            buzzer.stop()

# 「SOS」をモールス信号でLEDとブザーで送る
from gpiozero import LED, TonalBuzzer
from gpiozero.tones import Tone
from time import sleep
led = LED(17)
buzzer = TonalBuzzer(18)
DOT_S = 0.2    # 短点の長さ
DASH_S = 0.6   # 長点の長さ(短点の3倍)
GAP_S = 0.2    # 信号同士の間隔
def signal_on(duration):
    led.on()
    buzzer.play(Tone("A4"))
    sleep(duration)
    led.off()
    buzzer.stop()
    sleep(GAP_S)
def send_dot():
    signal_on(DOT_S)
def send_dash():
    signal_on(DASH_S)
while True:
    # S = ・・・
    for _ in range(3):
        send_dot()
    sleep(0.4)
    # O = ー ー ー
    for _ in range(3):
        send_dash()
    sleep(0.4)
    # S = ・・・
    for _ in range(3):
        send_dot()
    sleep(2)  # メッセージ間の長い休み

# 1個のボタンで短押し・長押し・ダブルクリックを判定
from gpiozero import Button, LED
from time import monotonic, sleep
from signal import pause
button = Button(2, pull_up=True, bounce_time=0.02)
led = LED(17)
LONG_PRESS_S = 0.6
DOUBLE_CLICK_GAP_S = 0.3
press_start_time = 0.0
last_release_time = 0.0
waiting_second_click = False
def on_press():
    global press_start_time
    press_start_time = monotonic()
def on_release():
    global last_release_time, waiting_second_click
    now = monotonic()
    duration = now - press_start_time
    if duration >= LONG_PRESS_S:
        print("Long press")
        led.on()
        sleep(0.2)
        led.off()
    elif waiting_second_click and now - last_release_time <= DOUBLE_CLICK_GAP_S:
        print("Double click")
        waiting_second_click = False
    else:
        waiting_second_click = True
        last_release_time = now
def check_single_click():
    global waiting_second_click
    if waiting_second_click and monotonic() - last_release_time > DOUBLE_CLICK_GAP_S:
        print("Single click")
        waiting_second_click = False
button.when_pressed = on_press
button.when_released = on_release
while True:
    check_single_click()
    sleep(0.02)

# pip install pyserial
# 事前に sudo raspi-config で Serial Port を有効化(シリアルコンソールは無効化)
import serial
from gpiozero import Button
from time import sleep
ser = serial.Serial("/dev/serial0", 9600, timeout=1)
button = Button(2, pull_up=True)
while True:
    ser.write(b'\x01' if button.is_pressed else b'\x00')
    sleep(0.1)

# pip install pyserial
import serial
from gpiozero import LED
ser = serial.Serial("/dev/serial0", 9600, timeout=1)
led = LED(17)
while True:
    data = ser.read(1)
    if data:
        led.value = data == b'\x01'

# EEPROM代わりにJSONファイルへ保存する
from gpiozero import Button
from signal import pause
import json
import os
STORAGE_FILE = "/home/pi/press_count.json"
button = Button(2, pull_up=True)
def load_count():
    if os.path.exists(STORAGE_FILE):
        with open(STORAGE_FILE) as f:
            return json.load(f).get("count", 0)
    return 0
def save_count(count):
    with open(STORAGE_FILE, "w") as f:
        json.dump({"count": count}, f)
press_count = load_count()  # 前回の続きから読み込む
print(f"Loaded count: {press_count}")
def on_press():
    global press_count
    press_count += 1
    save_count(press_count)
    print(f"Count: {press_count}")
button.when_pressed = on_press
pause()

# pip install smbus2
# 事前に sudo raspi-config で I2C を有効化しておく
import smbus2
from time import sleep
bus = smbus2.SMBus(1)
DS3231_ADDR = 0x68  # i2cdetect -y 1 で確認できるアドレス
def bcd_to_dec(bcd):
    return (bcd // 16) * 10 + (bcd % 16)
while True:
    data = bus.read_i2c_block_data(DS3231_ADDR, 0x00, 7)
    second = bcd_to_dec(data[0] & 0x7F)
    minute = bcd_to_dec(data[1])
    hour = bcd_to_dec(data[2] & 0x3F)
    day = bcd_to_dec(data[4])
    month = bcd_to_dec(data[5] & 0x1F)
    year = bcd_to_dec(data[6]) + 2000
    print(f"{year}/{month}/{day} {hour}:{minute:02d}:{second:02d}")
    sleep(1)

# リレーで5秒ごとにON/OFFを繰り返す
from gpiozero import OutputDevice
from time import sleep
# 多くのモジュールはLOWでON(active_high=False)。要確認
relay = OutputDevice(17, active_high=False, initial_value=False)
while True:
    relay.on()
    sleep(5)
    relay.off()
    sleep(5)

# ボタンで開閉する自動ドア風サーボ(コピペ用まとめ版)
from gpiozero import AngularServo, Button
from time import monotonic
SERVO_PIN = 18
BUTTON_PIN = 2
CLOSED_ANGLE = 0
OPEN_ANGLE = 90
STEP_INTERVAL = 0.015
HOLD_OPEN_S = 3
servo = AngularServo(SERVO_PIN, min_angle=0, max_angle=180)
button = Button(BUTTON_PIN, pull_up=True)
state = "CLOSED"
current_angle = CLOSED_ANGLE
last_step_time = monotonic()
hold_start_time = 0.0
servo.angle = current_angle
while True:
    now = monotonic()
    if state == "CLOSED" and button.is_pressed:
        state = "OPENING"
    if state == "OPENING" and now - last_step_time >= STEP_INTERVAL:
        last_step_time = now
        current_angle += 1
        servo.angle = current_angle
        if current_angle >= OPEN_ANGLE:
            state = "HOLDING"
            hold_start_time = now
    if state == "HOLDING" and now - hold_start_time >= HOLD_OPEN_S:
        state = "CLOSING"
    if state == "CLOSING" and now - last_step_time >= STEP_INTERVAL:
        last_step_time = now
        current_angle -= 1
        servo.angle = current_angle
        if current_angle <= CLOSED_ANGLE:
            state = "CLOSED"