Electronics Projects

With advancements in artificial intelligence and natural language processing, personalized chatbots have gained popularity for their ability to provide interactive and engaging conversations. These chatbots can understand natural language and respond intelligently, making human-computer interaction more intuitive and user-friendly. This project involves building a voice-activated chatbot using a Raspberry Pi, integrating OpenAI's GPT-3.5 model for natural language understanding and generation.

The chatbot is designed to listen for a wake word (“Hey”), after which it processes user input, generates a response using GPT-3.5, and communicates it back to the user through a text-to-speech engine. The main goal of this project is to create an interactive, hands-free voice assistant that can have personalized conversations.

Objectives of Raspberry Pi Chatbot Project

The objective of this project is to:

1. Build a voice-activated chatbot using a Raspberry Pi.
2. Use Google's Speech Recognition API to recognize speech and trigger the chatbot.
3. Utilize OpenAI's GPT-3.5 model to generate natural language responses.
4. Implement text-to-speech functionality to vocalize the responses.
5. Provide personalized interactions by integrating custom greetings and wake word detection.

Materials Required for Raspberry Pi Chatbot

To build this project, the following components are necessary:

• Raspberry Pi  – The central processing unit that will run the chatbot code and connect to the OpenAI API.
• Monitor – Used to operate the Raspberry Pi and visualize the output.
• Keyboard – For typing commands and programming on the Raspberry Pi.
• Microphone – To capture the user’s speech input.
• Speaker or Headphones – To output the chatbot's vocal responses.
• SD Card – Stores the Raspberry Pi OS and the project files.
• Power Supply for Raspberry Pi – Provides power to the Raspberry Pi.
• Internet Connection – Required for the chatbot to interact with the OpenAI API.
• Python Libraries – To enable speech recognition, text-to-speech, and API communication.

Steps to build OpenAi Chatbot using Raspberry Pi

Step 1: Writing and Testing the Code for Chatbot on Your Computer

1. Set Up Your Development Environment:

   • Install Python on your computer if it is not already installed. You can download it from the official Python website.
   • Install the required libraries using the following command in your terminal or command prompt:
     
     
     pip install openai python-dotenv SpeechRecognition pyttsx3 numpy
     
     

2. Obtain Your OpenAI API Key:

   • Visit the OpenAI website.
   • Sign up for an account or log in if you already have one.
   • Navigate to the API section and create a new API key. Make sure to save this key securely, as it will be required to authenticate requests to the OpenAI service.
     

3. Create a Python Script:

   • Create a new file named chatbot.py on your computer using a text editor or an Integrated Development Environment (IDE) like Visual Studio Code or PyCharm.
   • Here is the explaination of the code:

.

Step 2: Setting Up Raspberry Pi 

A. Install Raspberry Pi OS

1. Download the Raspberry Pi Imager from the official Raspberry Pi website.
2. Install the Raspberry Pi OS (64-bit or 32-bit depending on your Raspberry Pi model) using the Raspberry Pi Imager onto an SD card (16GB or higher).
3. Insert the SD card into your Raspberry Pi and power it on.
4. Complete the initial setup by following the on-screen instructions (setting up language, time zone, Wi-Fi, etc.).

B. Install Python and Necessary Libraries

1. Open a terminal on the Raspberry Pi.
   
   
2. Update your system packages by running the following commands:
   sudo apt update sudo apt upgrade


3. Install Python if it’s not already pre-installed:
   sudo apt install python3


4. Install the required Python libraries by running:
   pip3 install openai python-dotenv SpeechRecognition pyttsx3 numpy



C. Obtain and Set Up Your OpenAI API Key

1. Follow the same steps as in Step 1 to obtain your OpenAI API key from the OpenAI website.
   
   
2. Create a .env file in your Raspberry Pi home directory and add the API key in this format:
   OPENAI_API_KEY=your-api-key-here

1. On Your PC:
   • Plug in a USB drive.
   • Copy the chatbot.py file to the USB drive.
   • Eject the USB drive safely.

2. On the Raspberry Pi:

   • Plug the USB drive into the Raspberry Pi.
   • Open a terminal on the Raspberry Pi.
   • Navigate to the /media/pi/ directory to locate the USB drive:
     cd /media/pi/


   • List the contents to identify your USB drive (usually named after the USB label or model):
     ls


   • Enter the USB drive directory:
     cd [USB_DRIVE_NAME]


   • Copy the chatbot.py file to the Raspberry Pi home directory:
     cp chatbot.py /home/pi/



3. Verifying the File Transfer:

   • Navigate to your home directory and check if the file has been copied successfully:
     cd /home/pi/ ls


   • You should see chatbot.py listed.

E. Connect Microphone and Speaker

1. Plug in the USB microphone into the Raspberry Pi.
2. Connect speakers or headphones to the Raspberry Pi’s 3.5mm audio jack or use Bluetooth-enabled speakers.

F. Testing the Setup

1. Run the chatbot.py script to test the setup:
   python3 chatbot.py


   Ensure that the microphone, speaker, and chatbot respond as expected.

Results

Upon successfully running the chatbot, you can interact with it by speaking. The chatbot will listen for the wake word and respond to your queries using voice output. The integration with the OpenAI API allows for dynamic and intelligent conversations.

Code 

import os
import openai
from dotenv import load_dotenv
import time
import speech_recognition as sr
import pyttsx3
import numpy as np

load_dotenv()
openai.api_key = os.getenv('OPENAI_API_KEY')
model = 'gpt-3.5-turbo'

r = sr.Recognizer()
engine = pyttsx3.init("dummy")
voice = engine.getProperty('voices')[1]
engine.setProperty('voice', voice.id)

name = "YOUR NAME HERE"
greetings = [
f"What's up master {name}?",
"Yeah?",
"Well, hello there, Master of Puns and Jokes - how's it going today?",
f"Ahoy there, Captain {name}! How's the ship sailing?"
]

def listen_for_wake_word(source):
print("Listening for 'Hey'...")
while True:
audio = r.listen(source)
try:
text = r.recognize_google(audio)
if "hey" in text.lower():
print("Wake word detected.")
engine.say(np.random.choice(greetings))
engine.runAndWait()
listen_and_respond(source)
break
except sr.UnknownValueError:
pass

def listen_and_respond(source):
print("Listening...")
while True:
audio = r.listen(source)
try:
text = r.recognize_google(audio)
print(f"You said: {text}")
if not text:
continue

response = openai.ChatCompletion.create(
model=model,
messages=[{"role": "user", "content": text}]
)
response_text = response.choices[0].message.content
print(response_text)

engine.say(response_text)
engine.runAndWait()

except sr.UnknownValueError:
print("Silence found, shutting up, listening...")
listen_for_wake_word(source)
break

except sr.RequestError as e:
print(f"Could not request results; {e}")
engine.say(f"Could not request results; {e}")
engine.runAndWait()
listen_for_wake_word(source)
break

with sr.Microphone() as source:
listen_for_wake_word(source)