Turn an Old Rotary Phone into
a Retro AI Companion

# ── GPIO pin assignments ──────────────────────────────────
DIAL_PIN   = 23   # GPIO23 (Pin 16) — rotary dial pulse wire
SWITCH_PIN = 17   # GPIO17 (Pin 11) — hook switch button

# ── Audio detection tuning ───────────────────────────────
SILENCE_THRESHOLD = 500  # Volume level to detect speech (raise if noisy room)
MAX_SILENCE_CHUNKS = 20  # ~1.3 sec silence = end of sentence
DEBOUNCE_TIME = 0.1       # 100ms debounce for pulse counting

def _pulse_detected(self):
    """Called every time the dial breaks the circuit (one pulse)."""
    if not self.switch.is_pressed:  # Only count if handset is lifted
        current_time = time.time()
        if current_time - self.last_pulse_time > DEBOUNCE_TIME:
            self.pulse_count += 1
            self.last_pulse_time = current_time

def _check_number(self):
    """Called in main loop. Waits 1.5s after last pulse to commit digit."""
    if not self.switch.is_pressed and self.pulse_count > 0:
        self.audio_manager.stop_continuous_tone()
        time.sleep(1.5)  # Wait for digit to complete
        
        dialed = self.pulse_count if self.pulse_count != 10 else 0  # 0 = 10 pulses!
        print(f"Dialed: {dialed}")
        
        if dialed == 1:
            self._call_gpt_service()       # 1 → ChatGPT conversation
        # elif dialed == 2: self._weather_service()  # extend here!
        # elif dialed == 3: self._news_service()      # extend here!
        
        self.pulse_count = 0
        if not self.switch.is_pressed:
            self.audio_manager.start_continuous_tone()  # Back to dial tone

# System prompt — customize personality here
messages = [
    {"role": "system", "content": "You are a humorous conversation partner "
                              "engaged in a natural phone call. Keep answers "
                              "concise and to the point."}
]

# Stream response sentence-by-sentence for low latency playback
stream = client.chat.completions.create(
    model="gpt-4o-mini",  # or "gpt-4o" for smarter responses
    messages=messages,
    stream=True
)

# Convert each sentence chunk to speech immediately
response = client.audio.speech.create(
    model="tts-1",
    voice="alloy",   # nova, echo, fable, onyx, shimmer
    input=sentence_buffer,
    speed=1.0
)

# Run manually (suppresses harmless warnings)
python3 callGPT.py 2>/dev/null

# ── Autostart on boot via systemd ─────────────────────────
sudo nano /etc/systemd/system/callgpt.service

[Unit]
Description=Rotary Phone GPT Service
After=network.target

[Service]
ExecStart=/home/pi/callGPT/venv/bin/python3 /home/pi/callGPT/callGPT.py
WorkingDirectory=/home/pi/callGPT
Restart=always
RestartSec=10
User=pi
Environment="OPENAI_API_KEY=sk-your-key-here"

[Install]
WantedBy=multi-user.target

sudo systemctl enable callgpt.service
sudo systemctl start callgpt.service
sudo reboot

SD Card/
├── 01/               ← Dial 1 → plays from this folder
│   ├── 001.mp3       (first song)
│   ├── 002.mp3
│   └── 003.mp3
├── 02/               ← Dial 2 → plays from this folder
│   ├── 001.mp3
│   └── 002.mp3
├── 03/               ← Dial 3 ...
│   └── 001.mp3
└── 04/               ← System sounds (startup, etc.)
    ├── 001.mp3       ("Welcome! Dial a number.")
    └── 002.mp3       ("Goodbye!")

// Install: DFRobotDFPlayerMini library via Arduino Library Manager
#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>

const int DIAL_PIN  = D2;   // Rotary dial pulse input
const int HOOK_PIN  = D1;   // Hook switch input
const int DF_RX     = D6;   // DFPlayer TX → Wemos RX
const int DF_TX     = D7;   // DFPlayer RX ← Wemos TX (via 1kΩ)

SoftwareSerial dfSerial(DF_RX, DF_TX);
DFRobotDFPlayerMini dfPlayer;

volatile int pulseCount = 0;
unsigned long lastPulseTime = 0;
bool counting = false;

void IRAM_ATTR onPulse() {
  // Called on each dial pulse (FALLING edge)
  pulseCount++;
  lastPulseTime = millis();
  counting = true;
}

void setup() {
  pinMode(DIAL_PIN, INPUT_PULLUP);
  pinMode(HOOK_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(DIAL_PIN), onPulse, FALLING);

  dfSerial.begin(9600);
  dfPlayer.begin(dfSerial);
  dfPlayer.volume(25);   // 0–30
  dfPlayer.play(4, 1);   // Play system/startup sound (folder 04, file 001)
}

void loop() {
  // 350ms after last pulse = digit complete
  if (counting && (millis() - lastPulseTime > 350)) {
    counting = false;
    int digit = (pulseCount == 10) ? 0 : pulseCount;  // 10 pulses = 0
    pulseCount = 0;
    
    if (digit >= 1 && digit <= 9) {
      dfPlayer.playFolder(digit, 1);  // Play first file in folder {digit}
    }
  }
}

from gpiozero import Button
import time, threading

DIAL_PIN = 23
DIGIT_TIMEOUT = 1.5   # seconds to wait after last pulse before committing digit

pulse_count = 0
last_pulse_time = 0
dial_button = Button(DIAL_PIN, pull_up=True)

def on_pulse():
    global pulse_count, last_pulse_time
    pulse_count += 1
    last_pulse_time = time.time()

def read_digit():
    """Blocks until a full digit has been dialed. Returns int 0–9."""
    global pulse_count, last_pulse_time
    pulse_count = 0
    
    # Wait for first pulse to start
    while pulse_count == 0:
        time.sleep(0.05)
    
    # Collect pulses until DIGIT_TIMEOUT silence
    while time.time() - last_pulse_time < DIGIT_TIMEOUT:
        time.sleep(0.05)
    
    digit = pulse_count if pulse_count != 10 else 0
    pulse_count = 0
    return digit

dial_button.when_pressed = on_pulse

# Usage — collect a multi-digit number (e.g. phone extension "42")
dialed_digits = []
while True:
    d = read_digit()
    print(f"Digit dialed: {d}")
    dialed_digits.append(d)
    # e.g. stop collecting after 2 digits, or after dialing '*' (special pulse count)

import requests
from gtts import gTTS

def _weather_service(self):
    """Dial 2 → fetches weather for your city, plays it aloud."""
    api_key = "your_openweather_key"
    city = "Turin"   # change to your city
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric&lang=en"
    
    data = requests.get(url).json()
    desc = data['weather'][0]['description']
    temp = round(data['main']['temp'])
    text = f"Current weather in {city}: {desc}, {temp} degrees Celsius."
    
    tts = gTTS(text, lang='en')
    tts.save('/tmp/weather.mp3')
    self.audio_manager.play_file('/tmp/weather.mp3')

# In _check_number(), add:
elif dialed == 2:
    self._weather_service()

def read_multi_digit(self, num_digits=2):
    """Collect up to `num_digits` digits, return as int. E.g. dial 4→2 = 42."""
    digits = []
    for _ in range(num_digits):
        d = self.read_digit()
        digits.append(str(d))
    return int("".join(digits))   # "4","2" → 42