Team Electronic Cats: Andrea ZGuz, Andres Sabas, Marcelo Arredondo, Jazmín Hernández

Published October 23, 2023

Fortune Cat: Seeing the future

Cats are always curious, cats know things... Want to know where your life will go? Now your fortune teller is your own Cat!

IntermediateFull instructions provided2 hours588

Things used in this project

Hardware components

Arduino Nano 33 BLE Sense

Seeed Studio Grove - OLED Display 0.66" (SSD1306)- IIC - 3.3V/5V

Software apps and online services

Arduino IDE

Cyberon Speech Recognition Engine

Hand tools and fabrication machines

Premium Female/Female Jumper Wires, 40 x 3" (75mm)

USB micro cable

Story

Fortune Cat: your future I can see...

Have you ever been curious about knowing if you are going to pass a test? If you are going to become a millionaire? If your beloved one notices you are around?

The future cannot to be seen or known; the oracle tricky is, but let us have fun with the possibilities.

This time we will show you how to create a fortune teller that will play games with your emotions by telling you your future.

How does it work?

Simply asking for it! "Fortune Cat, tell me my future". These are the magic words.

Fortune Cat is a small box containing a screen that will show the keyphrase once you have said the words. The master behind the actions is an Arduino Nano 33 BLE Sense board, using a speech recognition system that decodes the words you speak aloud and executes the algorithm that selects and writes the sentence.

Let's begin!

The Arduino Integrated Development Environment - or Arduino Software (IDE) - contains a text editor for writing code, a message area, a text console, a toolbar with buttons for common functions, and a series of menus. It connects to different boards’ hardware to upload programs and communicate with them.

Go to the official Arduino website and download the latest version of Arduino IDE, then install it on your PC. Once installed, launch the application.

On the toolbar, go to Tools > Board > Boards Manager and look for Arduino Mbed OS Nano Boards. Download and install the latest version of the core. Allow the installation of any additional drivers.

Then, go to Tools > Manage Libraries and look for DSpotterSDK_Maker_33BLE. Download and install the latest version of the library. This library will help you with the speech recognition process.

Before proceeding with the coding process, you will need to create the Model with the customized commands to trigger the action of selecting the phrase and showing it on the screen. In this case, we will be using a Free Trial Model Configuration. You will need the serial number of your board to create your model.

Connect the Arduino Nano 33 BLE Sense to your PC, and ensure you select the right COM port and board in the Tools section. Then, go to Tools > Get Board Info and save the serial number.

We are using the speech recognition tool from Cyberon. Cyberon Corporation is a leading speech solution provider. Its speech recognition and text-to-speech technologies have been widely adopted by IoT devices, home appliances, wearable devices, smart toys, automotive equipment, and enterprise customers.

Open the Tool Cyberon website, the following screen will be shown:

Fill in the blanks with the required information and select the right board; read and accept the User License Agreement, and click on the "Next" button.

On the "Create New Project" square, select the language that better fits your application.

Type your Input Trigger Word. Take in mind the advice shown on the left chart to obtain a good model.

And follow the same process for your Command Word or words.

The last step will be to confirm the information for your model, your e-mail, language, board, and serial number. Confirm everything is ok.

Once finished, the website will confirm your model was sent to your e-mail.

You should receive four files:

CybLicense_xxxxxxxxxx.h: this is the license that allows your board to use the speech recognition engine. You must know that this license is not transferable, which means that it will not work on other boards.
Model_xxxxxxxxxx.h: this is the file containing the model information (your trigger and command words).
Model_xxxxxxxxxx_Arduino_33ble.dsproj: this file contains the complete information of your project and could be used if you want to modify your project in the future. To modify your project, you must use the "Import Project File" option in step 2 when creating the model on the Cyberon website.
Info_xxxxxxxxxx.txt: is a text file containing the information of your project, such as creation date and time, license type, language, board, serial number, Trigger word, and Command word (or words).

Now, open your Arduino IDE and go to File > New Sketch; save your new sketch. Copy and paste into the project folder all the four files you received by e-mail.

Copy and paste the code "FortuneCat" that you will find in the "Attachments" section in your sketch. Notice that you should see the additional tabs that match the.h file name of your license and your model.

It is important to include the header files, exactly the same name as the files you received (lines 6 and 7 in the following picture):

We included an extra header file, "images.h" to display our logo when starting up Fortune Cat. This is optional, but if you want to create your own introduction logo, this website may help: XBM File Creator. Remember to copy and paste this additional header file into the project folder, to prevent compilation errors.

Try writing your own phrases on the const char* selectPhrase() routine. Compile the sketch to verify there are no errors.

Connect the board with the OLED display this way:

Connect your board to your PC, select the right COM port, and select the board Arduino Nano 33 BLE Sense; upload the sketch to your Arduino Nano 33 BLE Sense board.

We used a 3D-printer to print our case. Below we share pictures of the drawings.

1 / 7 • Case's bottom.

Once printed and all the things assembled, we've got this:

1 / 2

Testing the application

Here are some points to have in mind while testing the application:

Speaking: pronunciation is really important. Ensure to speak loud and clear, and to say the complete word or words you use for trigger and command status.
Waitingtime: since we are using a Free Trial, there are some limitations. Every time the application changes to the "trigger mode" status, it is necessary to wait for 20 seconds before speak aloud again the trigger word. Otherwise, it won't be detected.
Recognitiontimes: since we are using a Free Trial, the application will be able to execute only 50 recognitions. For more information about Cyberon Licenses, you can reach the Arduino Store website.

1.- Power on your board, connecting the USB cable. You can use your PC as your power supply or any other 5V power supply.

2.- You will see the logo and "Fortune Cat" label on the screen. Wait until it changes to "Your future I can see... just ask". This is the moment when the speech recognition is waiting for the trigger word.

3.- Speak loud! "Fortune Cat" is our trigger word. If the text shown on the screen changes to "Yes?", it means the speech recognition is waiting for the command word. If not, try again.

4.- "Tell me my future" is the command word. Say it loud and clear. If recognized, your future is written on the screen. If not, try again.

5.- You can say "Tell me my future" as long as the screen does not show "Your future I can see... just ask" label again. Otherwise, you will need to repeat the steps 3 and 4, after waiting for 20 seconds.

Tell me my future!

Now is your turn! Use your own tricky and funny future possibilities.

Happy spooky season! 🎃

From Electronic Cats.🐱🐈‍⬛

Code

FortuneCat

#include <Arduino.h>                //Default Arduino library
#include <DSpotterSDK_MakerHL.h>    //Speech Recognition Tool Library
#include <LED_Control.h>            //Controling the onboard LED for checking the status (trigger or command status)
#include <Wire.h>                   //Controlling I2C communication between Arduino Nano 33 BLE Sense and the OLED display
#include "nRF_SH1106Wire.h"         //OLED Display SH1106 library
#include "CybLicense_1696873329.h"  //The DSpotter License Data (License for your board using Cyberon Speech Recognition tool)
#include "Model_1696873329.h"       //Your model, contains your trigger word and command word (or words)
#include "images.h"                 //Electronic Cats Logo

#define DSPOTTER_LICENSE g_lpdwLicense
#define DSPOTTER_MODEL g_lpdwModel
#define COMMAND_FUTURE  10000      //ID number for your command word (more than one if you are using more command words)

static DSpotterSDKHL g_oDSpotterSDKHL;                     //The VR engine object. Only can exist one, otherwise not worked.
SH1106Wire display(0x3c, PIN_WIRE_SDA, PIN_WIRE_SCL);      //I2C ADDRESS, SDA, SCL 


const char* selectPhrase();   //Selecting phrase routine

void VRCallback(int nFlag, int nID, int nScore, int nSG, int nEnergy)     // Callback function for VR engine
{
  if (nFlag==DSpotterSDKHL::InitSuccess)
  {
      //ToDo
  }
  else if (nFlag==DSpotterSDKHL::GetResult)
  {
      /*
      When getting an recognition result,
      the following index and scores are also return to the VRCallback function:
          nID        The result command id (from de command word)
          nScore     nScore is used to evaluate how good or bad the result is.
                     The higher the score, the more similar the voice and the result command are.
          nSG        nSG is the gap between the voice and non-command (Silence/Garbage) models.
                     The higher the score, the less similar the voice and non-command (Silence/Garbage) models are.
          nEnergy    nEnergy is the voice energy level.
                     The higher the score, the louder the voice.
      */
      if(nID==COMMAND_FUTURE)   //If nID=="tell me my future"
        display.clear();        //Clear the display
        display.drawStringMaxWidth(0, 10, 128, selectPhrase());   //Display chosen phrase
        display.display();      //Write the buffer to the display
  }
  else if (nFlag==DSpotterSDKHL::ChangeStage)
  {
      switch(nID)
      {
          case DSpotterSDKHL::TriggerStage:     //If "Fortune Cat" trigger word has not been said yet
            LED_RGB_Off();                      
            LED_BUILTIN_Off();
            display.clear(); 
            display.drawStringMaxWidth(0, 10, 128, "Your future I can see... just ask");   //Display this phrase, waiting for "Fortune Cat" trigger word
            display.display();    
            break;
          case DSpotterSDKHL::CommandStage:    //If "Fortune Cat" trigger word has been said
            LED_BUILTIN_On();
            display.clear(); 
            display.drawStringMaxWidth(0, 10, 128, "Yes?");   //Display this phrase, waiting for "tell me my future" command word
            display.display();    
            break;
          default:
            break;
      }
  }
  else if (nFlag==DSpotterSDKHL::GetError)
  {
      if (nID == DSpotterSDKHL::LicenseFailed)  //If CybLicense_xxxxxxxxxx.h file is not valid (unvalid license)
      {
          Serial.print("DSpotter license failed! The serial number of your device is ");
          Serial.println(DSpotterSDKHL::GetSerialNumber());
      }
      g_oDSpotterSDKHL.Release();
      while(1);//hang loop
  }
  else if (nFlag == DSpotterSDKHL::LostRecordFrame)
  {
      //ToDo
  }
}

void setup()
{
  LED_Init_All();          //Init LED control
  Serial.begin(115200);    //Init Serial output for show debug info
  display.init();          //Init display
  display.flipScreenVertically();             //Use vertical displaying mode
  display.setFont(ArialMT_Plain_10);          //Use this font
  display.setTextAlignment(TEXT_ALIGN_LEFT);  //Start typing from left side
  display.clear();                            //Clears display 
  display.drawXbm(34, 5, EC_Logo_width, EC_Logo_height, EC_Logo_bits);    //Display Electronic Cats logo, available in "images.h" file
  display.drawString(25, 40, "FORTUNE CAT");  //Display "Fortune Cat" as well
  display.display();                          //Write the buffer to the display
  delay(5000);                                //Hold on 5 sec
  display.clear();                            //Clears display
  display.setFont(ArialMT_Plain_16);          //Use this font
  
  DSpotterSDKHL::ShowDebugInfo(true);

  //Init Voice Recognition Engine & Audio
  if (g_oDSpotterSDKHL.Init(DSPOTTER_LICENSE, sizeof(DSPOTTER_LICENSE), DSPOTTER_MODEL, VRCallback) != DSpotterSDKHL::Success)
    return;
}

void loop()
{
  g_oDSpotterSDKHL.DoVR();     //Do Voice Recognition, constantly
}

const char* selectPhrase()    //Selects a random number, this random number matches one phrase, this phrase is then displayed
{
  byte number;
  number=random(1, 20);
  switch (number)
  {
    case 1:
      return "You will win the lottery!";
      break;
    case 2:
      return "Your cat will get lost";
      break;
    case 3:
      return "Your cat will live forever";
      break;
    case 4:
      return "You're not finding the bug";
      break;
    case 5:
      return "You're the next boss";
      break;
    case 6:
      return "You'll become a linuxer";
      break;
    case 7:
      return "You'll find the bug";
      break;
    case 8:
      return "Your board is a fake Arduino";
      break;
    case 9:
      return "You will travel to Bermudas triangle";
      break;
    case 10:
      return "Day off. Not working now.";
      break;
    case 11:
      return "You will not finish this video game at 100%";
      break;
    case 12:
      return "You will be promoted to customer";
      break;
    case 13:
      return "You won't be better than an AI";
      break;
    case 14:
      return "Be careful what you wish for";
      break;
    case 15:
      return "Your luck is about to run out";
      break;
    case 16:
      return "Universe will conspire with you";
      break;
    case 17:
      return "Be careful what's behind you";
      break;
    case 18:
      return "You will get your Engineering Degree";
      break;
    case 19:
      return "You will get shocked";
      break;
    case 20:
      return "Wait a lot will be your downfall";
      break;
    default:
      break;
  }
}

Fortune Cat: Seeing the future