context:
  expressions:
    TimerControl:
      - (@politeness) @set_on (a) timer for $pv.TwoDigitInteger:minutes
        minutes
      - "@set_on $appliance:appliance timer for
        $pv.TwoDigitInteger:minutes minutes"
      - (@politeness) [switch, power] $power:power (the) timer for $appliance:appliance
      - (@politeness) [switch, power] (the) $appliance:appliance timer
        $power:power
    TemperatureControl:
      - (@politeness) @heat (oven) to $temperature:temperature (degrees)
    ApplianceControl:
      - (@politeness) turn $appliance:appliance $power:power
      - (@politeness) switch $power:power (the) $appliance:appliance
      - (@politeness) power $power:power (the) $appliance:appliance
    AskState:
      - what is (the) $query_type:query_type (information)
      - (@politeness) tell me (the) $query_type:query_type (information)
      - (@politeness) check (the) $query_type:query_type (information)
  slots:
    appliance:
      - oven
      - stove
    temperature:
      - three fifty
      - three hundred fifty
      - four twenty five
      - four hundred twenty five
      - four hundred
    query_type:
      - time left
      - timer
      - temperature
    power:
      - on
      - off
  macros:
    politeness:
      - please
      - can you
      - could you
    set_on:
      - set
      - start
      - create
    heat:
      - set
      - preheat
      - decrease
      - increase

porcupine = pvporcupine.create(
    access_key=args.ACCESS_KEY,
    keyword_paths=[args.KEYWORD_FILE_PATH]
)
rhino = pvrhino.create(
    access_key=args.ACCESS_KEY,
    context_path=args.CONTEXT_FILE_PATH
)
orca = pvorca.create(access_key=args.ACCESS_KEY)

recorder = PvRecorder(device_index=args.AUDIO_DEVICE_INDEX_INPUT,
                      frame_length=porcupine.frame_length)
speaker = PvSpeaker(sample_rate=orca.sample_rate,
                    bits_per_sample=16,
                    device_index=args.AUDIO_DEVICE_INDEX_OUTPUT)

pcm = recorder.read()
if porcupine.process(pcm) >= 0:
    speak_text(orca, speaker, "Yes?")
    listening_for_intent = True

is_finalized = rhino.process(pcm)
if is_finalized:
    inference = rhino.get_inference()

    if inference.is_understood:
        intent = inference.intent
        slots = inference.slots
        print(f"[UNDERSTOOD] intent={intent}, slots={slots}")
        response_text = execute_appliance_action(intent, slots)
    else:
        print("[NOT UNDERSTOOD]")
        response_text = "Sorry, I did not understand."

def execute_appliance_action(action):
    """
    Executes appliance commands based on the action dictionary.
    In production, this is where you'd integrate with the IoT stack.
    """
    action_type = action.get("action")
    
    if action_type == "start_timer":
        minutes = action.get("minutes")
        appliance = action.get("appliance")
        # Logic to start timer on appliance
        if appliance:
            return f"Starting {appliance} timer for {minutes} minutes."
        return f"Timer set for {minutes} minutes."
    
    elif action_type == "toggle_timer":
        power = action.get("power")
        appliance = action.get("appliance", "timer")
        # Logic to toggle timer on/off
        return f"Turning {appliance} {power}."
        # Add more appliance actions 
    return "Command received."

def speak_text(orca, speaker, text: str, label: str = ""):
    try:
        print(f"Orca speaking: {label or text}")
        pcm_out, _ = orca.synthesize(text)
        pcm_out = [int(s) for s in pcm_out]  # ensure ints
        speaker.start()
        speaker.write(pcm_out)
        speaker.flush()
        speaker.stop()
    except Exception as e:
        print(f"[FAIL] Orca failed to respond ({label}): {e}")

# Kitchen Assistant: Porcupine + Rhino + Orca
import argparse
import sys
import pvporcupine
import pvrhino
import pvorca
from pvrecorder import PvRecorder
from pvspeaker import PvSpeaker


def speak_text(orca, speaker, text: str, label: str = ""):
    try:
        print(f"Orca speaking: {label or text}")
        pcm_out, _ = orca.synthesize(text)
        pcm_out = [int(s) for s in pcm_out]  # ensure ints
        speaker.start()
        speaker.write(pcm_out)
        speaker.flush()
        speaker.stop()
    except Exception as e:
        print(f"[FAIL] Orca failed to respond ({label}): {e}")


def execute_appliance_action(intent, slots): 
    if intent == "TimerControl":
      # Add the appliance logic here
        minutes = slots.get("minutes")
        appliance = slots.get("appliance")
        power = slots.get("power")
        if minutes:
            response_text = f"Starting a timer for {minutes} minutes."
            if appliance:
                response_text = (
                    f"Starting a {appliance} timer for {minutes} minutes."
                )
        elif power:
            response_text = f"Turning {appliance or 'the'} timer {power}."
        else:
            response_text = "Timer command received."

    elif intent == "TemperatureControl":
      # Add the appliance logic here 
        temp = slots.get("temperature")
        response_text = (
            f"Preheating oven to {temp} degrees."
            if temp else "Temperature control command received."
        )

    elif intent == "ApplianceControl":
      # Add the appliance logic here 
        appliance = slots.get("appliance")
        power = slots.get("power")
        if appliance and power:
            response_text = f"Turning {appliance} {power}."
        else:
            response_text = "Appliance control command received."

    elif intent == "AskState":
      # Add the appliance logic here 
        query = slots.get("query_type")
        response_text = (
            f"Checking {query}." if query else "Query command received."
        )

    else:
        response_text = f"Command received. (raw intent={intent})"

    return response_text


def main():
    parser = argparse.ArgumentParser(
        description="Kitchen Assistant using Porcupine, Rhino, and Orca"
    )
    parser.add_argument(
        "--access_key",
        required=True,
        help="Picovoice access key"
    )
    parser.add_argument(
        "--keyword_file_path",
        required=True,
        help="Path to keyword file for wake word detection"
    )
    parser.add_argument(
        "--context_file_path",
        required=True,
        help="Path to context file for intent recognition"
    )
    parser.add_argument(
        "--audio_device_index_input",
        type=int,
        default=-1,
        help="Input audio device index (default: -1)"
    )
    parser.add_argument(
        "--audio_device_index_output",
        type=int,
        default=0,
        help="Output audio device index (default: 0)"
    )

    args = parser.parse_args()

    print("Initializing Kitchen Assistant")

    # Use command line arguments
    access_key = args.access_key
    keyword_path = args.keyword_file_path
    context_path = args.context_file_path
    input_device_index = args.audio_device_index_input
    output_device_index = args.audio_device_index_output

    # Initialize engines
    porcupine = pvporcupine.create(
        access_key=access_key,
        keyword_paths=[keyword_path]
    )
    rhino = pvrhino.create(
        access_key=access_key,
        context_path=context_path
    )
    orca = pvorca.create(access_key=access_key)

    recorder = PvRecorder(
        device_index=input_device_index,
        frame_length=porcupine.frame_length
    )
    speaker = PvSpeaker(
        sample_rate=orca.sample_rate,
        bits_per_sample=16,
        device_index=output_device_index
    )

    print("[OK] Engines initialized")
    print(
        f"Using input device index={input_device_index}, "
        f"output={output_device_index}"
    )
    print("Say the wake word… (Ctrl+C to stop)")

    recorder.start()
    try:
        listening_for_intent = False

        while True:
            pcm = recorder.read()

            if not listening_for_intent:
                # Wake word detection
                keyword_index = porcupine.process(pcm)
                if keyword_index >= 0:
                    print("[EVENT] Wake word detected!")
                    speak_text(
                        orca,
                        speaker,
                        "Yes?",
                        label="wake word confirmation"
                    )
                    listening_for_intent = True
            else:
                # Rhino intent processing
                is_finalized = rhino.process(pcm)
                if is_finalized:
                    inference = rhino.get_inference()

                    if inference.is_understood:
                        intent = inference.intent
                        slots = inference.slots
                        print(
                            f"[UNDERSTOOD] intent={intent}, "
                            f"slots={slots}"
                        )

                        response_text = execute_appliance_action(intent, slots)

                    else:
                        print("[NOT UNDERSTOOD]")
                        response_text = "Sorry, I did not understand."

                    # Speak the response
                    speak_text(
                        orca,
                        speaker,
                        response_text,
                        label="intent response"
                    )

                    # Reset Rhino for next turn
                    rhino.reset()
                    listening_for_intent = False

    except KeyboardInterrupt:
        print("\n[EXIT] Stopping assistant...")
    finally:
        recorder.stop()
        recorder.delete()
        speaker.delete()
        porcupine.delete()
        rhino.delete()
        orca.delete()
        print("[CLEANUP] Resources released.")


if __name__ == "__main__":
    main()

scp -r /path/to/your/folder pi@<your-pi-ip-address>:/home/pi/

ssh pi@<your-pi-ip-address>

pip install pvporcupine pvrhino pvorca pvrecorder pvspeaker

python3 smart-kitchen-appliance.py \
    --access_key="${ACCESS_KEY}" \
    --keyword_file_path="${KEYWORD_FILE_PATH}" \
    --context_file_path="${CONTEXT_FILE_PATH}" \
    --audio_device_index_input="${AUDIO_DEVICE_INDEX_INPUT}" \
    --audio_device_index_output="${AUDIO_DEVICE_INDEX_OUTPUT}"