babble-fish

[babble-fish]

View of the full Babblefish tank installed at the Maker Faire exhibit.

[babble-fish]

Final Babblefish Circuit Diagram

[babble-fish]

Interacting with the Babblefish at the Maker Faire, with audio playback.

[babble-fish]

Close up of fish in the final design.

[babble-fish]

The Moment of Truth: Babblefish at the Maker Faire

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.

One important thing to note at the end of the project, is how much it changed from the beginning design proposal. Initially, we had planned on using more buttons, in the range of 4-5, as well as implementing a vacuum pump stomach for one of the major interactions. There was also the initial design choice to have the insides of the fish be revealed through a scrim by illuminating a light on the inside of the Babblefish. Ultimately, while the initial design was very exciting, certain aspects of it would have been extremely complicated to pull off in the project development period (looking at you vacuum pump). We ditched some of the more complex component choices and simplified the Babblefish design by eliminating the vacuum pump, changing the Babblefish body from a scrim structure to a 3D printed head and torso, and limited the number of buttons down to one master button.

[babble-fish]

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.

***Note not pictured is the second arduino, which was implemented shortly hereafter.

[babble-fish]

Tank Finishing Touches

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

[babble-fish]

All the Rocks!

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.

TADA! Rocks!

[babble-fish]

Bringing it all together: Merging the Individual Prototyped Components Into a Final Microcontroller System

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. 

The second major issue involved the LED strip. Because so many devices were connected to the 5V power supply of the arduino, the maximum current was being drawn and thus, there wasn’t enough current to power all of the devices correctly. In order to power the LED strip properly, the solution was to provide it its own 5V external power supply.  

[babble-fish]

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. 

***Note: the servo pictured above is being powered with 5V, while the actual range listed in the product documentation is 6-7.4V. The servo still works well, but won’t provide as much torque/run as efficiently as it possibly could. For our purposes however, the servo running at 5V should be just fine.

[babble-fish]

Prototyping the Jaw Servo

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.

The final design would use the default, built-in servo library.

[babble-fish]

More audio playback progress! In the video above, audio was able to be played back through a larger active speaker, and the audio file was converted via SoX. At this point, all that remained was to record the audio files for the Babblefish.

[babble-fish]

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.

void loop(void) { }

[babble-fish]

Formatting Audio Files for the SimpleSDAudio Library, Formatting the SD card

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. 

Lastly, for safe measure, file names needed to fit within the 8.3 filename format, meaning that filenames needed to be all caps and under 8 characters. Not entirely sure if this is required, but I made sure to format my files to this standard and it ended up working.

[babble-fish]

Issues with the SmartWAV, moving on to another audio playback solution

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

-a new library for controlling audio playback: <SimpleSDAudio>

[babble-fish]

Prototyping Audio Playback with the SmartWAV Audio Microprocessor

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. 

With these concerns in mind, we decided to order a SmartWAV audio microprocessor. The unit would process audio for the best quality, has a built in 3.5mm aux jack, has a built in microSD card port, and an external library with documentation to help get the most functionality with audio playback.

[babble-fish]

Prototyping the LED Arcade Buttons

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) {

   digitalWrite(buttonLed, HIGH);  }  else  {    Serial.println(arcadeButtonState);    digitalWrite(buttonLed, LOW);  } }