This is a new version of my Tengu clone. This time on a printed circuit board (PCB). I have them produced by Olimex and I am very pleased with the quality. The PCB worked on the first try and has some minor issues only.

Materials

• Tengu PCB
• Everlight 8*5 LED dot matrix
• ATmega48, 4kB Flash RAM, 512 bytes RAM
• 4 MHz crystal
• LM386 Op-Amp
• 28 pin header
• 8 pin header
• 2 * 22pF capacitors
• 3 * 100nF capacitors
• 10k potentiometer
• 100k potentiometer
• 100k resistor
• 5 * 1k resistors
• 2 * 7 pin header sockets
• 2 pin headers for power supply and microphone (optional)
• Electret microphone (not on the picture)

Note, that the electret microphone has a polarity. On the PCB the inner pin is the positive one. If you connect it the wrong way, it is heating up really quick.

The microphone that I used here has an impedance of 2k. You may have to experiement a bit with different microphones.

The capacitor C2 is used to control the amplification of the LM386. I used 0.1uF but you can use up to 10uF to get a stronger amplification. Here is the amplifier circuit that I used.

PCB design issues

As this is my first design, there are a couple of things that I would redesign.

As I tried to insert the pin header sockets, I realized that the drill holes were a bit too narrow. You have to use a bit of strength to insert the headers, but it works.

All solder pads used for resistors and capacitors are a bit too small. It was a bit difficult to solder them. I would make them a larger next time.

I think I should use a bit less of the silk layer. Some solder pads are covered with silk. Most of the time that does not hurt as it is on the top side. But there are pins that you may wont to solder on the top side, e.g. the power connector.

Improvements

The component count could be reduced if I had dropped crystal. For the animation of the LED matrix the internal oscillator would be sufficient. On the other hand, with a suited crystal, this circuit could be modified to display the time.

I would add an ISP (in system programming) header for easier programming. Now you have to flip off the display, take out the controller, program it, re-insert it and put the display back in place. Not a fast turn around if you want to modify the firmware.

What would you think of an Arduino version of this circuit? The controller could be replaced with an Arduino compatible ATmega168. Or maybe as an Arduino shield?

Conclusion

It is great to see your first produced PCB. Even better if it works on the first try. Maybe I can even build a kit out of it with the next revision of the board.

As I have still two boards left, you can email me at alex at this domain and I will send you the PCB for free. The only requirement would be, that you really want to build it and that you give me feedback on how it worked, what you would change or how you modded it.

Links and Downloads

• Crispin Jones Tengu, the original idea of this device
• Mini Amplifier with LM386
• Tengu clone on prototype board
• Tengu clone on a breadboard
• tengu-clone-rev-1.0a.zip source and Eagle schematics

More at Flickr.

It is a blog hitcounter, that rings a bell. Literally. It puts a smile on your face, every time someone hits your blog. And it is a great way to annoy your colleages or your girl friend.

It consists of an Arduino board, a bell, a servo and a couple of lines of code in c, python and php.

Materials

So what is needed?

• Arduino Board. I have an Arduino Diecimila from Adafruits. In the meantime there are really cheap and handy clones out there, e.g. the bare bone board from Modern Devices, especially if you want to use them on a breadboard.
• A servo motor. Any servo will do. I took an old one that was used in my former hobby.
• A bell. Prefarably one that is small enough to shake it with the servo.
• Two paperclips. A large one to hold the bell and a small one to build the actuator to ring the bell.
• A website. In fact it hasn’t has to be a website or a blog. Actually everything that can be counted, will work.
• A PC or a Mac to connect the Arduino board with the blog or website.
• Wires.

Assembly

The bell is held by a strong paperclip. The small paperclip is used to form a kind of arm that is atached to the servo motor.

Schematics

There is no real schematic. Just attach the servo motor to the Arduino. The servo has three wires:

• yellow or orange: signal
• red: VCC
• brown: GND

The red and the brown one are attached to the according pins on the Arduino. The orange one is wired to pin 2. It will signal the servo in which direction to turn.

Software

The software stack has three parts. First part is the counter embedded in my blog. Second is the glue code, running on my mac to fetch the counter and to update the Arduino. Third is the Arduino sketch itself to control the servo motor.

This is a small php snippet to write a counter into a text file. I have included it into one of my wordpress templates. That’s not very smart, but for now my traffic is not that high so this should not be a problem.

<?php  $count_my_page = ("hitcounter.txt");
$hits = file($count_my_page);
$hit = trim($hits[0]);
$hit++;
$fp = fopen($count_my_page , "w");
fputs($fp , "$hit");
fclose($fp);
echo $hit;
?>

Here is the second part, the python snippet to fetch the counter. It opens a connection to the saved hitcounter.txt and loads the content, which is the actual value of the counter. This counter is compared with the previous fetched value. If it differs, than it has an incident to report. The delta is written as byte to the serial port and sent to the Arduino. That is done every ten seconds.

#
# fetch counter
#
import time
import urllib
import serial

# usb serial connection to arduino

ser = serial.Serial(
   '/dev/tty.usbserial-A4001JAh', 9600)
myUrl = 'http://tinkerlog.com/hitcounter.txt'

last_counter = urllib.urlopen(myUrl).read()
while (True):
  counter = urllib.urlopen(myUrl).read()
  delta = int(counter) - int(last_counter)
  print "counter: %s, delta: %s" % (counter, delta)
  ser.write(chr(ord(chr(delta))))
  last_counter = counter
  time.sleep(10)

Last part is the Arduino sketch. It is mainly based on the code that I found at the ITP Physical Computing. In the loop you see the reading of the delta value provided by the python script. If there are some rings to perform, a little state machine takes control of how far and when to move the servo arm. The servo motor is controlled with PWM, pulse width modulation. That’s the last part of the sketch. How far the servo arm turns can be adjusted with the min- and maxPulse values.

/*
 * Arduino XMAS Blog hitcounter
 * http://tinkerlog.com/
 *
 * Reference:
 * - Servo control from an analog input
 *   taken from http://itp.nyu.edu/physcomp/Labs/Servo
 *
 */
int servoPin = 2;      // control pin for servo motor
int minPulse = 1200;   // minimum servo position
int maxPulse = 1700;   // maximum servo position
int pulse = 0;         // amount to pulse the servo
int rings = 0;         // amount of rings
long nextMillis = 0;   // the time to pass before the next action
long lastPulse = 0;    // the time in milliseconds of the last pulse
int refreshTime = 20;  // the time needed in between pulses
int state = 0;         // for the state machine

void setup() {
  pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
  pulse = minPulse;           // Set the motor position value to the minimum
  Serial.begin(9600);
}

// define states for the state machine
#define PULSE_ON       0
#define WAIT_PULSE_ON  1
#define PULSE_OFF      2
#define WAIT_PULSE_OFF 3

void loop() {

  // read the rings
  if (Serial.available() > 0) {
    rings += Serial.read();
    Serial.println(rings);
  }

  // state machine to control, which action to perform
  if (rings > 0) {
    switch (state) {
      case PULSE_ON:
        pulse = maxPulse;                // send servo to max position
        nextMillis = millis() + 300;     // wait 300 ms
        state = WAIT_PULSE_ON;
        break;
      case WAIT_PULSE_ON:
        if (millis() > nextMillis) {
          state = PULSE_OFF;             // time is up
        }
        break;
      case PULSE_OFF:
        pulse = minPulse;                // send servo to min position
        nextMillis = millis() + 1000;    // wait 1 second between two rings
        state = WAIT_PULSE_OFF;
        break;
      case WAIT_PULSE_OFF:
        if (millis() > nextMillis) {
          state = PULSE_ON;              // time is up
          rings--;                       // one ring is done
        }
        break;
      }
  }

  // pulse the servo again if the refresh time (20 ms) have passed:
  if (millis() - lastPulse >= refreshTime) {
    digitalWrite(servoPin, HIGH);   // Turn the motor on
    delayMicroseconds(pulse);       // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse
  }

}

Conclusion

It is the first time, that I built something, that has moving parts. That’s my first step to bridge the gap between the virtual and the real world. And it was really easy, the code is straight forward. Also most of the parts were in my trash bin, except the bell. Putting everything together and waiting for someone to hit my blog was fun.

Side note:

• Me, excited: “Did you hear that? There was another one!”
• My girlfriend: “I k-n-o-w a-l-r-e-a-d-y!”

Action

Ok, time for some action.

Links

• Arduino, official site
• Arduino servo control
• Real Bare Bone Board at Modern Devices
• Arduino Diecimila at Adafruits

As you can see, everything fits nice under the LED display.

The next step would be to design a PCB of it.

More and full size pictures at Flickr.

Links

• DIY Tengu on a breadboard

Parts

• ATmega48, 4kb flash memory, 512 bytes main memory
• crystal, 10 MHz
• Everlight 8×5 LED dot matrix display
• electret microphone, taken from an old mobile phone head set
• LM386 op-amp
• 5 x 1k resistor
• 1 x 100k resistor
• 1 x 10k potentiometer
• 1 x 100k potentiometer
• 3 x 0.1u capicitor
• 2 x 22p capicitor

All parts should be available for less than US10$.

Sound sensor

To get a good and robust signal out of the microphone, an amplifier is needed. I found an really easy schematic of an amplifier at Jose Pino’s site. It is based on the LM386, an op-amp, often used in small music amplifiers, e.g. Cracker box Amp in Make 09.

I assembled it on a small breadboard and tested it with my new Arduino.

It worked great, but I had to use an alternative power source. When I used USB as power supply, the on- and off-switching of the monitoring LED lead to additional noise. 4 AAA cells solved that problem. For the first test you can use a small speaker attached to pin 5 of the LM386. Be sure to add the 220u capicitor between the LM386 and the speaker as shown in the schematic, otherwise you may blow your amplifier.

Here is a little sketch, that I used to test the sound sensor.

/*
 * Monitor for sound sensor
 */

int potPin = 2;    // select the input pin for sound sensor
int ledPin = 13;   // select the pin for the LED
int val = 0;
int amp = 0;

void setup() {
  pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
}

void loop() {
  val = analogRead(potPin);
  amp = (val >= 512) ? val - 512 : 512 - val;
  if (amp > 100) {
    digitalWrite(ledPin, HIGH);
    delay(20);
  }
  else {
    digitalWrite(ledPin, LOW);
  }
}

Controller and LED matrix

The Everlight LED matrix with its 40 LEDs is big enough to display a small face. The matrix needs 5 1k resistors for every row to limit the current.

The sound and its amplitude is sampled by the ATmega48 with one of its analog input pins (ADC). Then the suitable face is choosen to display. The faces are stored as simple bitmaps.

Conclusion

This small thingy is fun to watch. And it was fun to build. Maybe I’ll try to put it on a prototype board to be able to carry it around.

Click To Play

Yes, I know. My camera sucks.

Links

• Crispin Jones Tengu
• Mini amplifier with LM386
• Cheap sound sensor for AVR

Downloads

• tengu_clone.zip, source, hex and Eagle schematic

• 2 resistors 10k
• 1 resistor 100k
• transistor 2N3904
• 1 capacitor 0.1u
• electret microphone

Prototyping the amplifier

Putting things together on a breadboard.

Actually I had no 2N3904 around, so I replaced it with a BC337. The circuit is a emitter circuit with voltage degeneration (I dont know if that exists in english). I dropped the couple capacitor and took the signal right away at the collector.

Prototyping with the ATmega

The sound sensing is done with the ADC of the ATmega. A simple program reads the analog value of the amplifier over and over. If the value (loudness) exeeds a specific level, an LED is lit.

The schematic for rebuilding.

The code can be found here mic_sensor.c. It is just hacked together and has lots of room for improvements.

Video

Here is a video that I made. Has lousy quality, for both, video and audio.

It was easy and worked pretty well. I enjoyed looking at the LED responding to the music. I haven’t recorded anything with this amplifier, it might sound awfull. Next steps could be playing the sound back or be able to analyze the sound (FFT). And (re-)learning more on analog circuit design.

Links

• Simple preamp
• Audio Amplifiers