The Making of the Babble Fish

At last, the Babblefish has been brought to life! A lot of coding, troubleshooting, and wires later, and the final microcontroller system for the Babblefish was complete! Overall, the piece came out very well, and was a major success both in terms of physical computing and in digital fabrication.

Photo of the near-finished wiring of the Babblefish system. 

By connecting all of the wires with crimping and wire nuts, the system was made far more durable and less likely to have an error occur due to a loose wire falling on during transportation to the Palmer Event Center for the Maker Faire.

Once the tank was together, all the finishing touches could be added to make the tank complete.

For our tank, we decided to create a bit of an environment for our babble fish and this included making some rocks for the bottom of the ocean. At first, I thought about how this could be 3D printed and then I saw blue work-out mat foam and thought it would be faster to carve rocks out of that!

To start, I cut various shapes and sizes of rocks using a small blade.

Then I sanded the sides of each rock to give it a smoother surface finish.

Finally, I added a bit of green paint using a natural sponge in order to give it some texture and depth.

Now that all the individual components have been prototyped and are functional, its time to merge them all together into the final microcontroller system.

Unfortunately, there were some problems that arose from this step in the process. Nothing that couldn’t be fixed with a little troubleshooting, howeve.

The first major issue came in the form of interference between libraries. More specifically, the default servo library and the audio playback library, SimpleSDAudio, both had a defined variable called vector 11. Because they were both providing definitions for vector 11, Arduino couldn’t decide which definition to use, and was thus unable to run. The solution: use two separate arduinos, one to run the servo, and one to run everything else. In order for the two to communicate, we created what was essentially a ‘button’ in the wiring that would pass a high or low value from the host arduino to the slave arduino when the main button was pushed. When a high value is read by the slave arduino, the code to run the servo is run. 

Progress of servo! Newer, higher-power servo is working and has added randomness in the position the servo rotates to, as well as the speed of rotation, to emulate some different speech patterns. 

The last major component that needed to be addressed for the Babblefish before moving onto the final merged microcontroller system was the servo that would drive jaw movement. 

Overall, the servo ended up being pretty simple to figure out. The main consideration was to move from a smaller microservo, the SG90, to a larger, more powerful one that would be able to provide more torque and hopefully make less noise, called the HiTec HS430BH High Voltage Servo.

Progress! Playing the example audio file included with the SimpleSDAudio library, through a small microcontroller speaker.

Code used to play example file is listed below:

/*  Simple SD Audio bare minimum example, plays file EXAMPLE.AFM from root folder of SD card.

 This example shows how to use the SimpleSDAudio library for audio playback.  You need:  - An Arduino with ATmega368 or better  - An SD-Card connected to Arduinos SPI port (many shields will do)   -> copy EXAMPLE.AFM on freshly formated SD card into root folder  - A passive loudspeaker and resistor or better: active speakers (then stereo output will be possible)

 Audio signal output is at the following pin:  - Arduino with ATmega328       (many non-mega Arduinos): Pin 9  - Arduino with ATmega1280/2560 (many mega Arduinos)    : Pin 44

 Using passive speaker:    Audio-Pin --- -[100 Ohm resistor]- ---- Speaker ---- GND

 Using amplifier / active speaker / line-in etc.:    Audio-Pin --||--------------[10k resistor]----+----[1k resistor]---- GND              100nF capacitor                   to amp

 See SimpleSDAudio.h or our website for more information:  http://www.hackerspace-ffm.de/wiki/index.php?title=SimpleSDAudio

 created  20 Jan 2013 by Lutz Lisseck */ #include <SimpleSDAudio.h>

// Here's how to control the LEDs from any two pins:

void setup() {  // Open serial communications and wait for port to open:  Serial.begin(9600);  while (!Serial) {    ; // wait for serial port to connect. Needed for Leonardo only  }

 // Using F("...") to avoid wasting RAM  Serial.print(F("\nInitializing SD card..."));

 // If your SD card CS-Pin is not at Pin 4, enable and adapt the following line:  // SdPlay.setSDCSPin(10);

 if (!SdPlay.init(SSDA_MODE_HALFRATE | SSDA_MODE_STEREO | SSDA_MODE_AUTOWORKER)) {    Serial.println(F("initialization failed. Things to check:"));    Serial.println(F("* is a card is inserted?"));    Serial.println(F("* Is your wiring correct?"));    Serial.println(F("* maybe you need to change the chipSelect pin to match your shield or module?"));    Serial.print(F("Error code: "));    Serial.println(SdPlay.getLastError());    while (1);  } else {    Serial.println(F("Wiring is correct and a card is present."));  }

 Serial.print(F("Looking for TESTER02.AFS... "));  if (!SdPlay.setFile("TESTER02.AFS")) {    Serial.println(F(" not found on card! Error code: "));    Serial.println(SdPlay.getLastError());    while (1);  } else {    Serial.println(F("found."));  }

 Serial.print(F("Playing... "));  SdPlay.play();  while (!SdPlay.isStopped()) {    ; // no worker needed anymore :-)  }  Serial.println(F("done."));  SdPlay.deInit();

}

// Runs 10 LEDs at a time along strip, cycling through red, green and blue. // This requires about 200 mA for all the 'on' pixels + 1 mA per 'off' pixel.

In order to use the new audio playback system and the SimpleSDAudio library, there were some considerations that needed to be addressed. 

First, how did the audio files need to be formatted? The new library offered a flexible range of how files could be formatted, as long as they were adhered to the following:

-Could be stereo or mono

-Could be halfrate or fullrate

-Needed to be stored as a very specific set of file formats, most commonly including .AFM and .AFS

To format the files, it was necessary to use a command line software called SoX. Essentially, Sox was needed to take audio files, and convert them to a file format that denoted whether the file was stereo or mono, halfrate or fullrate in order for the Arduino to work with the SimpleSDAudio library. For more information on using SoX, check out the references/useful links post at the top of this blog.

As far as formatting the SD card goes, SimpleSDAudio required an SD card to be formatted using the FAT32 standard. 

While the SmartWAV seemed great on paper, we ran into some major issues when it came to actually implementing it into our design. 

-First, the amount of documentation online is minimal. While the product manual online is thorough, it is definitely not friendly to entry level microcontroller users. The answers seemed to be there, but were mired in a huge web of unfamiliar computing and serial terminology that was baffling to an Arduino newcomer such as myself. Besides that, the amount of digestible, easy-to-understand websites and videos made by other users that could help explain the SmartWAV were small in number.

-Secondly, the SmartWAV needed to be connected as what is known as a “slave device” to the “host” microcontroller via a specific Serial communication circuit called UART. Because the SmartWAV has its own embedded microprocessor, it needs to be connected to the Arduino via UART to be told what to do, otherwise problems can arise in programming and debugging from two microcontrollers with separate microprocessors. 

-Lastly, the external library that was needed to communicate with the SmartWAV was also pretty lacking in documentation.

Ultimately, we were unable to utilize the SmartWAV in our microcontroller system. While it seems like a great solution to consolidating the many components needed for audio playback, the lack of user-friendly documentation, confusing UART connection requirement, and difficult-to-understand library made it clear that the component may have been overcomplicated for our needs. 

So, time for Plan B. Instead of using the SmartWAV, we decided to use the following:

-an SD card reader micro-component

-still using an active speaker

-a male to male aux cable to connect our Arduino to the speaker

With some of the other Babbleish features taken care of, it was time to address arguably the most important component of the piece: the audio playback.

Having never worked with audio playback from a microcontroller before, we as a team knew that there were a few factors we had to take into consideration for our end goals:

-First, how would we store and access files in a contained system? For our purposes, we wouldn't need an immense number of files for the Babblefish to access, but the more the merrier. Ideally, we wanted to have a large bank of files that could be accessed randomly by the “fun fact” button. The solution to easily store files via a computer, and access them again from the Arduino was to use an SD/ microSD card. The Arduino needed to access an SD card formatted with the FAT32 file standard, so the largest SD card we could use would be 32GB, giving us immense flexibility with both the quantity and quality of audio files we could access from our system.

-Next, we needed to find a way to play the files through a speaker. Both for greater volume and quality, a speaker would be necessary for the Babblefish to be heard in the Maker Faire. Arduino is able to play through both active and passive speakers, but the ideal choice would be to use an active speaker so that we wouldn’t have to worry about power concerns that could arise from implementing an amplifier into the speaker-microcontroller system. 

For more info on Passive vs Active speakers, check out this link: 

https://www.aperionaudio.com/blogs/aperion-audio-blog/passive-vs-active-speakers

-To communicate between our Arduino and speaker, we would also need to implement an Aux cable. A standard 3.5mm aux cable would connect into our speaker on one end, and on the other end would connect to ground and signal wires that would be implemented into the overall Arduino system. 

-Lastly, there would need to be some formatting of the audio files to achieve the best quality from the Arduino. By default, you can deliver audio signal through the PWM pins on the Arduino UNO, but the quality will be extremely poor. Therefore, the best choice seemed to be using some sort of external component to process the audio signal and set a standard for it to transmit through the audio playback system. 

To add another level of polish to the Babblefish design, we decided to swap out simple push buttons for  LED arcade buttons. We also felt that it fit better into our design to use light-up arcade style buttons because the Babblefish tank was reminiscent of an arcade cabinet.

The usage of the button would be to allow the user to trigger the many functional components of the Babblefish with the push of a button. When pushed, the button would light up and send a signal to the Arduino microcontroller to trigger the audio playback, LED strip animation, RGB LED Animation, and Servo animation for the Jaw.

Below is a link to an extremely useful wiring diagram for the LED arcade buttons I found online. ***Note: using the 2 pins to control the LED inside the button is optional. It’s possible to send the necessary signal from the button being pushed to drive other components in the microcontroller system without wiring up the LED. Here, you may have to make a tradeoff of being able to turn off/control the LED for freeing up an additional signal pin in your microcontroller. 

https://www.circuito.io/app?components=9442,11286,62012

Below is code useful for seeing if your Button is wired properly, and is a basic framework for using both the button and its built-in LED.

Button Prototyping Code Below:

int arcadeButton = 7; int arcadeButtonState; int buttonLed = 8;

void setup() {  // put your setup code here, to run once:  Serial.begin(9600);  pinMode(arcadeButton, INPUT);  pinMode(buttonLed, OUTPUT); }

void loop() {

 // put your main code here, to run repeatedly:  arcadeButtonState = digitalRead(arcadeButton);   Serial.println(arcadeButtonState);  if (arcadeButtonState == HIGH) {