Parts List

You really don’t need much for this experiment, just a speaker and resistor, although some breadboard and jumper wires make it easier to connect things up:

The speaker that I used was scavenged from an old radio receiver and had a connector on the end into which a male-to-male jumper wire could be inserted. You may find a speaker with wires attached that will push into the breadboard or Arduino sockets, or you might have to solder some leads on with wires that are thin enough to fit into breadboard holes.

Breadboard Layout

Figure 15-1 shows the setup for the experiment. 

Figure 15-1. Arduino and speaker

One connection to the speaker is connected to an Arduino GND socket and the other is connected via the resistor to pin D11.

Arduino Software

Here’s the sketch for this project, which you will find in /arduino/experiments/ex_speaker (for information on installing the Arduino sketches for this book, see “The Book Code” in Chapter 2):

const int soundPin = 11;

void setup() {
  pinMode(soundPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("Enter frequency");
}

void loop() {
  if (Serial.available()) {
    int f = Serial.parseInt();
    tone(soundPin, f);     
    delay(2000);
    noTone(soundPin);      
  }
}

The part of this code that might look unfamiliar to you is inside loop().

tone sets one of the output pins of the Arduino to play a tone at the frequency specified (in this case, the frequency that you typed into the Serial Monitor).

After a two-second delay, the noTone command cancels to tone, restoring a restful silence.

Arduino Experimentation

Upload the program and then open the Serial Monitor.  Try entering 1000. This should produce a not particularly pleasant sound, at a reasonable volume, but not loud enough to be heard in a noisy room.

Experiment entering different frequencies and see how the note changes.

Although it might be tempting to try and test the frequency range of your hearing with this setup, sadly this won’t work because the speaker is quite likely to have a restricted range itself. At frequencies over about 10kHz, the level of sound it produces will fall off very sharply. Similarly, a small speaker will not normally be able to produce sound below about 100Hz. 

Parts List

The hardware for this experiment is just the same as “Experiment: Unamplified Speaker and Arduino”. However, you will need to install the following software on your computer to be able to record and process an audio clip:

• Audacity
• The Audio Encoder utility (look for the link on http://highlowtech.org/?p=1963 for your operating system)

Creating the Sound Data

If you do not want to record your own sound clip, you can jump ahead to “Arduino Experimentation” and run the ex_wav_arduino sketch that has a short message encoded in it.

To create the sound file, you first need to start Audacity. Before making your recording, set the recording mode to Mono and the Project Rate to 8000Hz. These options are highlighted in Figure 15-3.

Figure 15-3. Recording a sound clip

Click the red Record button to start recording and record your message. Note that this cannot be longer than about 4 seconds. Once you have recorded the message, you will see the sound wave in Audacity. You can select any silent area at the start or end and delete it, to just leave the part of the message that you want.

The next step is to export the sound file. Again this requires certain options to be set. From the File menu, select Export. Then in the Format dropdown, select “Other uncompressed files,” and click Options, and select WAV (Microsoft) and Unsigned 8 bit PCM (Figure 15-4). Select a filename and continue past the screen that prompts you for details of the artist.

The file that you have just generated is binary data. This needs to be converted into a list of text numbers, each separated by commas, that can be pasted into your sketch. To do this, run the Audio Encoder utility that you downloaded from highlowtech.org. This will prompt you to select the file you want to convert, so select the file that you just exported from Audacity.

After a few moments, you will be shown a dialog window confirming that all the data is in your clipboard.

Open up the sketch /arduino/experiments/wav_arduino. You are going to replace the whole of the line that starts with 125, 119, 115 with the data in the clipboard. This is a very long line, so the best way to select it is to put the cursor at the start of the line, and then hold the Shift key down while you cursor down and then left one place. Use the Paste option to replace the selected text with the data in your clipboard.

Figure 15-4. Setting export options

If you plotted each of those numbers on a chart, the shape you would see would be the same as you saw in Audacity when you were recording a sound clip.

Arduino Code

Before you can compile and run the sketch, you will need to install the PCM library. Download the ZIP archive for the file from GitHub; unzip it, rename the folder to just PCM, and move it into your Arduino libraries folder, as described in “Installing Arduino Libraries” in Chapter 12.

The Arduino sketch (if you ignore the sound data) is tiny:

#include <PCM.h>

const unsigned char sample[] PROGMEM = {   // 
125, 119, 115, 115, 112, 116, 114, 113, 124, 126, 136, 145, 139, 
}; 

void setup() {
  startPlayback(sample, sizeof(sample));  // 
}

void loop() { // 
}

However, that array of data is a very long line!

The data is held in an array of type char, which contains 8-bit unsigned numbers. The PROGMEM command ensures that the data is stored in the flash memory of the Arduino (there should be about 32kB available).

The PCM library plays the sample. startPlayback is passed the array of data to be played and the size of that data in bytes.

The sound clip is played once each time the Arduino resets, so the loop() function is empty. 

Arduino Experimentation

Install the sketch onto your Arduino and as soon as it installs, the sound clip will play!

As you upload the sketch, you will see a message at the bottom of the Arduino IDE that tells you how much of the Arduino’s flash memory was used. It will say something like “Binary sketch size: 11,596 bytes (of a 32,256 byte maximum).” If the sound file gets too big, you will get an error message.

Parts List

To make this project, you will need all the parts from “Project: Pepe, the Dancing Raspberry Pi Puppet” and the following extra components:

PIR sensors are used to detect movement in intruder alarms. This low-cost module is ideal for triggering Pepe when someone comes near. Adding the PIR sensor makes it worthwhile to add a breadboard to hold the servo driver board and wires to the PIR sensor.

Breadboard Layout

In this project, the breadboard provides a firm anchor for the wires to the PIR module and for the servo controller board that will plug directly into the breadboard. Most breadboards have a self-adhesive pad on the underside that you can use to stick it onto the servo chassis to make things a bit more permanent. Figure 15-9 illustrates the breadboard layout for the project, and Figure 15-10 shows the actual wiring of the project.

Figure 15-9. The breadboard layout for the talking puppet

Figure 15-10. The talking puppet 

The PIR sensor has a 3V digital output, but requires a 5V power supply. This makes it ideal for use with a Raspberry Pi.

Software

The software for this project is based on “Project: Pepe, the Dancing Raspberry Pi Puppet”, so you may want to look at that description of the code too.

You can find all the files for this project in the directory python/projects/puppet_voice. As well as the the Adafruit servo code and the program itself (puppet_voice.py), you will also find a sound file here called pepe_1.wav. This is the sound file that will be played when Pepe is triggered by movement:

from Adafruit_PWM_Servo_Driver import PWM  
import RPi.GPIO as GPIO
from pygame import mixer
import time

PIR_PIN = 23     
GPIO.setmode(GPIO.BCM)
GPIO.setup(PIR_PIN, GPIO.IN)

pwm = PWM(0x40)
mixer.init()     
mixer.music.load("pepe_1.wav")

servoMin = 150  # Min pulse length out of 4096     
servoMax = 600  # Max pulse length out of 4096

dance = [     
  #lh  lf  rf  rh
  [130, 20, 20, 130],
  [30, 160, 160, 30],    
  [90, 90, 90, 90]
]

delay = 0.2   
  
def map(value, from_low, from_high, to_low, to_high):  
  from_range = from_high - from_low
  to_range = to_high - to_low
  scale_factor = float(from_range) / float(to_range)
  return to_low + (value / scale_factor)
  
  
def set_angle(channel, angle):  
  pulse = int(map(angle, 0, 180, servoMin, servoMax))
  pwm.setPWM(channel, 0, pulse)
  
def dance_step(step):  
  set_angle(0, step[0])
  set_angle(1, step[1])
  set_angle(2, step[2])
  set_angle(3, step[3])
  
def dance_pupet():     
    for i in range(1, 10):
        for step in dance:
            dance_step(step)
            time.sleep(delay)
    
pwm.setPWMFreq(60)   


while True:  
  if GPIO.input(PIR_PIN) == True:    
      mixer.music.play()
      dance_pupet()
      time.sleep(2)

The first new bit of code is the code to set pin 23 to be a digital input.

There is also some initialization code to start the mixer ready to play the sound clip.

The new function dance_puppet is used to make the puppet repeat the dance steps 10 times.

If the PIR sensor is activated (pin 23 is True), then the music track playing and dancing is started. The music.play function does its work in the background.

Using the Talking Puppet

You can record a new sound clip to play using the Audacity software that you may have used in “Arduino Experimentation”. Just replace the file pepe_1.wav. You could also really go to town on this project and record a number of different sound clips to be played at random, or customized to the time of day.