In this article, you’ll be delving into the development of a voice command calculator using Python, taking advantage of libraries like Speech-Recognition and PyAudio that will allow users with swift means of performing arithmetic operations. Developing such a program will require you to go through some of the basics of speech recognition and PyAudio. Let’s go through each, but before that have a short idea of the project.

Speech to Text Conversion

Setting Up the Environment

To get started with building a voice command calculator in Python using SpeechRecognition and Pyaudio, you will need to set up your development environment in PyCharm, a popular Python IDE. Here’s a step-by-step guide to help you get everything ready:

1. Download and Install PyCharm

Begin by downloading PyCharm from the official JetBrains website. Choose the Community edition if you are looking for a free option. Install PyCharm by following the installation instructions for your operating system.

Install Pycharm IDE

2. Create a New Project

Open PyCharm and create a new project. Click on “New Project” from the welcome screen. In the dialog that appears, name your project (e.g., VoiceCommandCalculator) and specify the location where you want to save it.

3. Set Up a Virtual Environment

PyCharm will prompt you to set up a virtual environment for your project. Ensure that “New environment” is selected and choose “Virtualenv” as the environment type. This will create a virtual environment in your project directory, which helps manage dependencies separately from your system Python.

Create new project and virtual environment

4. Install Required Libraries

Once your project is created, you need to install the required libraries: SpeechRecognition and Pyaudio. You can do this directly within PyCharm:

• Open the terminal in PyCharm by clicking on “Terminal” at the bottom of the window.
• Run the following commands to install the libraries.

pip install SpeechRecognition
pip install pyaudio

Alternatively, you can go to “File” > “Settings” (or “PyCharm” > “Preferences” on macOS), then “Project” > “Python Interpreter”, and click the “+” button to search for and install these packages.

Install Speech-Recognition and PyAudio libraries

5. Verify Microphone Setup

Ensure that your microphone is properly connected and recognized by your computer. You can test it using any standard audio recording application to make sure it works.

Initializing the Libraries

With your development environment set up in PyCharm, the next step is to initialize the necessary libraries for your voice command calculator. This involves importing the libraries and setting up the components required for capturing and processing audio input.

1. Import the Libraries

Open the newly created Python file and start by importing the required libraries. You’ll need speech_recognition for handling speech recognition , pyaudio for capturing audio input and re for working with regular expressions in arithmetic evaluation process. Add the following import statements at the top of your file:

import speech_recognition as sr
import pyaudio
import re

2. Initialize the Recognizer

The SpeechRecognition library requires a recognizer instance to process the audio input. Initialize the recognizer with the following line of code:

recognizer = sr.Recognizer()

3. Configuring the Microphone

Use the Microphone class from SpeechRecognition to capture audio input. PyAudio works in the background to handle the audio stream. The Microphone class from SpeechRecognition uses PyAudio internally.

with sr.Microphone() as source:
    print("Adjusting for ambient noise, please wait...")
    recognizer.adjust_for_ambient_noise(source)
    print("Microphone is ready. Please speak your command.")

4. Capturing and Processing Audio Input

Now, you need to capture the audio input from the user. Add the following code within the with sr.Microphone() as source block to listen for a user’s voice:

 audio = recognizer.listen(source)

5. Converting Audio to Text

Use the recognizer to convert the captured audio into text. Add the following code to process the audio input

try:
        text = recognizer.recognize_google(audio)
        print(f"You said: {text}")
    except sr.UnknownValueError:
        print("Sorry, I could not understand the audio.")
    except sr.RequestError as e:
        print(f"Could not request results from Google Speech Recognition service; {e}")

Implementing the Voice Command Calculator Logic

After setting up the environment and initializing the necessary libraries, the next step is to implement the logic for the voice command calculator. This involves listening to voice commands, parsing arithmetic expressions, and evaluating these expressions to provide results. Here’s a detailed guide on how to do it:

1. Listening to Voice Commands

First, we create a function that listens to voice commands and recognizes them as text using the SpeechRecognition library. This function initializes the microphone, adjusts for ambient noise, and captures the audio input from the user. The audio is then converted to text using Google’s Speech Recognition service.

import speech_recognition as sr
import pyaudio

# Initialize the recognizer
recognizer = sr.Recognizer()

def listen_for_command():
    with sr.Microphone() as source:
        print("Adjusting for ambient noise, please wait...")
        recognizer.adjust_for_ambient_noise(source)
        print("Microphone is ready. Please speak your command.")
        
        # Listen for the user's input
        audio = recognizer.listen(source)
        
        try:
            # Convert the audio input to text
            command = recognizer.recognize_google(audio)
            print(f"You said: {command}")
            return command
        except sr.UnknownValueError:
            print("Sorry, I could not understand the audio.")
            return None
        except sr.RequestError as e:
            print(f"Could not request results from Google Speech Recognition service; {e}")
            return None

The listen_for_command function initializes the microphone, adjusts for ambient noise, and listens for the user’s input. It converts the audio to text using the Google Speech Recognition service.

2. Parsing Arithmetic Expressions

Next, we create a function to parse the recognized text for arithmetic expressions. This function uses a regular expression to identify and extract the arithmetic operation from the text.

def parse_expression(command):
    # Simple regex to find basic arithmetic expressions
    pattern = r'(\d+)\s*(\+|\-|\*|\/)\s*(\d+)'
    match = re.search(pattern, command)
    if match:
        num1, operator, num2 = match.groups()
        return num1, operator, num2
    else:
        print("Could not parse arithmetic expression.")
        return None, None, None

The parse_expression function uses a regular expression to find and extract arithmetic expressions from the recognized text. It returns the two operands and the operator if found, otherwise, it returns None.

3. Evaluating the Arithmetic Expression

Then, we create a function that evaluates the extracted arithmetic expression. The function constructs an arithmetic expression from the parsed operands and operator, and evaluates it using Python’s eval() function.

def evaluate_expression(num1, operator, num2):
    try:
        expression = f"{num1} {operator} {num2}"
        result = eval(expression)
        return result
    except Exception as e:
        print(f"Error evaluating expression: {e}")
        return None

The evaluate_expression function constructs an arithmetic expression from the parsed operands and operator and evaluates it using the eval() function. It handles any errors that may occur during evaluation.

4. Putting It All Together

Finally, we combine all the steps into a main function that orchestrates the process: listening for a command, parsing the command, evaluating the expression, and printing the result.

def main():
    command = listen_for_command()
    if command:
        num1, operator, num2 = parse_expression(command)
        if num1 and operator and num2:
            result = evaluate_expression(num1, operator, num2)
            if result is not None:
                print(f"The result of {num1} {operator} {num2} is {result}")
            else:
                print("Could not evaluate the expression.")
        else:
            print("Could not parse the command.")
    else:
        print("No command recognized.")

if __name__ == "__main__":
    main()

The main function ties everything together. It listens for a voice command, parses the command to extract the arithmetic expression, evaluates the expression, and prints the result. If any step fails, appropriate messages are printed.

Output: