Build Instructions

Collapse

• 1

  Step 1

  Wiring:

  The first step is to wire the Arduino and the breadboard with the components as shown in the pictures below.
  

  The most important detail here refers to the analog reference provided to the Arduino ADC. In my tests, I got better results using 3.3V with the Sparkfun Electret Breakout. That is why I added a jumper between the 3.3V pin and the AREF pin. If you decide to use the analogRead funcion (for any reason) while 3.3V is being applied to the AREF pin, you MUST call analogReference(EXTERNAL) before you use the analogRead function. Otherwise, you will short together the active reference voltage (internally generated) and the AREF pin, possibly damaging the microcontroller on your Arduino board.
  

• 2

  Step 2

  Now you have to upload the code below to your Arduino. You can also download the Arduino sketch from the link below the code. Before you upload the code, you must properly install the BitVoicer Server libraries into the Arduino IDE (Importing a .zip Library).

  #include <BVSP.h>
  #include <BVSMic.h>
  
  // Defines the Arduino pin that will be used to capture audio 
  #define BVSM_AUDIO_INPUT 5
  
  // Defines the LED pins
  #define RED_LED_PIN 6
  #define YELLOW_LED_PIN 9
  #define GREEN_LED_PIN 10
  
  // Defines the constants that will be passed as parameters to 
  // the BVSP.begin function
  const unsigned long STATUS_REQUEST_TIMEOUT = 1000;
  const unsigned long STATUS_REQUEST_INTERVAL = 2000;
  
  // Defines the size of the audio buffer 
  const int AUDIO_BUFFER_SIZE = 64;
  
  // Defines the size of the receive buffer
  const int RECEIVE_BUFFER_SIZE = 2;
  
  // Initializes a new global instance of the BVSP class 
  BVSP bvsp = BVSP();
  
  // Initializes a new global instance of the BVSMic class 
  BVSMic bvsm = BVSMic();
  
  // Creates a buffer that will be used to read recorded samples 
  // from the BVSMic class 
  byte audioBuffer[AUDIO_BUFFER_SIZE];
  
  // Creates a buffer that will be used to read the commands sent
  // from BitVoicer Server.
  // Byte 0 = pin number
  // Byte 1 = pin value
  byte receiveBuffer[RECEIVE_BUFFER_SIZE];
  
  void setup() 
  {
    // Sets up the pin modes
    pinMode(RED_LED_PIN, OUTPUT);
    pinMode(YELLOW_LED_PIN, OUTPUT);
    pinMode(GREEN_LED_PIN, OUTPUT);
    
    // Starts serial communication at 115200 bps 
    Serial.begin(115200); 
    
    // Sets the Arduino serial port that will be used for 
    // communication, how long it will take before a status request 
    // times out and how often status requests should be sent to 
    // BitVoicer Server. 
    bvsp.begin(Serial, STATUS_REQUEST_TIMEOUT, STATUS_REQUEST_INTERVAL);
      
    // Defines the function that will handle the frameReceived 
    // event 
    bvsp.frameReceived = BVSP_frameReceived; 
    
    // Prepares the BVSMic class timer 
    bvsm.begin();
  }
  
  void loop() 
  {
    // Checks if the status request interval has elapsed and if it 
    // has, sends a status request to BitVoicer Server 
    bvsp.keepAlive();
    
    // Checks if there is data available at the serial port buffer 
    // and processes its content according to the specifications 
    // of the BitVoicer Server Protocol 
    bvsp.receive();
  
    // Checks if there is one SRE available. If there is one, 
    // starts recording.
    if (bvsp.isSREAvailable()) 
    {
      // If the BVSMic class is not recording, sets up the audio 
      // input and starts recording 
      if (!bvsm.isRecording)
      {
        bvsm.setAudioInput(BVSM_AUDIO_INPUT, EXTERNAL); 
        bvsm.startRecording();
      }
  
      // Checks if the BVSMic class has available samples 
      if (bvsm.available)
      {
        // Makes sure the inbound mode is STREAM_MODE before 
        // transmitting the stream
        if (bvsp.inboundMode == FRAMED_MODE)
          bvsp.setInboundMode(STREAM_MODE); 
          
        // Reads the audio samples from the BVSMic class
        int bytesRead = bvsm.read(audioBuffer, AUDIO_BUFFER_SIZE);
        
        // Sends the audio stream to BitVoicer Server
        bvsp.sendStream(audioBuffer, bytesRead);
      }
    }
    else
    {
      // No SRE is available. If the BVSMic class is recording, 
      // stops it.
      if (bvsm.isRecording)
        bvsm.stopRecording();
    }
  }
  
  // Handles the frameReceived event 
  void BVSP_frameReceived(byte dataType, int payloadSize) 
  {
    // Checks if the received frame contains binary data
    // 0x07 = Binary data (byte array)
    if (dataType == DATA_TYPE_BINARY)
    {
      // If 2 bytes were received, process the command.
      if (bvsp.getReceivedBytes(receiveBuffer, RECEIVE_BUFFER_SIZE) == RECEIVE_BUFFER_SIZE)
      {
        analogWrite(receiveBuffer[0], receiveBuffer[1]);
      }
    }
  }

  Arduino Sketch: BVS_Demo1.ino

  This sketch has four major parts:
  

  • Library references and variable declaration: The first two lines include references to the BVSP and BVSMic libraries. These libraries are provided by BitSophia and can be found in the BitVoicer Server installation folder. The other lines declare constants and variables used throughout the sketch. The BVSP class is used to communicate with BitVoicer Server and the BVSMic class is used to capture and store audio samples.
  • Setup function: This function initializes serial communication, the BVSP class, the BVSMic class and sets the “event handler” (it is actually a function pointer) for the frameReceived event.
    
  • Loop function: This function performs three important actions: requests status info to the server (keepAlive() function), checks if the server has sent any data and processes the received data (receive() function), and controls the recording and sending of audio streams (isSREAvailable(), startRecording(), stopRecording() and sendStream() functions).
    
  • BVSP_frameReceived function: This function is called every time the receive() function identifies that one complete frame has been received. Here I run the command sent from BitVoicer Server. The command contains 2 bytes. The first byte indicates the pin and the second byte indicates the pin value. I use the analogWrite() function to set the appropriate value to the pin.
    
• 3

  Step 3

  Importing BitVoicer Server Solution Objects

  Now you have to set up BitVoicer Server to work with the Arduino. BitVoicer Server has four major solution objects: Locations, Devices, BinaryData and Voice Schemas.
  

  Locations represent the physical location where a device is installed. In my case, I created a location called Home.
  

  Devices are the BitVoicer Server clients. I created a Mixed device, named it ArduinoMicro and entered the communication settings. NOTE ABOUT ARDUINO MICRO: it uses RTS and DTR so you have to enable these settings in the communication tab. I also created a SystemSpeaker device to synthesize speech using the server audio adapter.
  

  BinaryData is a type of command BitVoicer Server can send to client devices. They are actually byte arrays you can link to commands. When BitVoicer Server recognizes speech related to that command, it sends the byte array to the target device. I created one BinaryData object to each pin value and named them ArduinoMicroGreenLedOn, ArduinoMicroGreenLedOff and so on. I ended up with 18 BinaryData objects in my solution, so I suggest you download and import the objects from the VoiceSchema.sof file below.
  

  Voice Schemas are where everything comes together. They define what sentences should be recognized and what commands to run. For each sentence, you can define as many commands as you need and the order they will be executed. You can also define delays between commands. That is how I managed to perform the sequence of actions you see in the video.
  

  You can import (Importing Solution Objects) all solution objects I used in this project from the files below. One contains the Devices and the other contains the Voice Schema and its Commands.
  

  Solution Object Files:
  

  Devices.sof

  VoiceSchema.sof

View all 4 instructions