This is a meandering saga of exploration with the illustrious Kemet Tokin. It is a classic tale of a great plan, that just like any great battle plan, the instant it encounters reality, the time spent was for naught. None the less, the  commitment persists and there are battles to be fought and lessons to be learned.

Audacious plans were devised to take the measure of the mighty Tokin and apply its mysteries to tame the wild Stirling. Diabolical contraptions and apparatus were assembled to test the mettle of the incredible Tokin in wide ranging rigors and to determine the limits of its performance and its suitability for the imminent challenge.

These epic struggles are chronicled herewith in the annals of the magic element14.

May observers find entertainment in the pitfalls of encounters with the unknown.

 

Apparatus Description and First Music Test

 

Speaker Driver Frequency Response

The MP3 player is not really the issue with distorted waveforms - the amplifier was clipping and the speaker is not good at low frequency.

The piezo speaker definitely has some resonant frequencies.

 

An Attempt at Speaker Design and Subsequent Tests

This speaker design actually allowed the thump of bass drums to come through although not very loud, but it also illustrated how tough it might be to design a high fidelity speaker.

I found it amazing that the vibration sensor indicated that the amplifier was clipping. I would not have thought of this use for a vibration sensor, but you saw me discover it in a live camera shoot.

A good vibration sensor like this Kemet could be very useful in discovering frequency responses and resonances in all the parts that are used in a speaker design. Because these sensors can focus on what is happening to the material at a particular location without "hearing" a lot of other acoustic vibrations in the air coming from somewhere else (that a microphone would hear).

I had the scope filtering the signal to get cleaner sine waves, so that may explain some of the poor high frequency response displayed on the scope in this video.

 

Sensor Sensitivity - Impact, Stringed Instruments, Wine Glasses and a Plastic Bottle

That wine glass large wobble was 5 Hz not 50 Hz and not audible - it was standing on foam.

The speaker case has its own resonant modes and is not a good place the sensor.

The plastic bottle resonance is so low you may need good speakers or headphones to hear it.

I am noticing other correctness issues with the blog, but hopefully the ideas are coming across and hopefully it is obvious that this is an impressive vibration sensor.

 

White Noise FFT, Pink Noise FFT, Square Wave and Triangle Wave Harmonics

Some preliminary conclusions about the sensor performance:

  • The Kemet sensor is very sensitive
  • The sensor has very low noise, making it easy to see small vibrations.
  • The sensor has good frequency response from at least 5 Hz to 20 KHz
  • The amplitude response is flat over this range with no self resonances
  • The sensor is easy to use, just supply a voltage and a clean signal is generated at a useful amplitude - no external amplifier or signal conditioning needed.
  • The sensor is very good for monitoring any vibrations in the audio range of frequencies which makes it useful in a wide variety of applications.
  • The sensor has a low mass, so it does not interfere with or alter most vibrations.

I am impressed with the sensor size and performance and expect I will find more uses for it in the future.

 

Next I will be taking a look at the Stirling engine, which definitely has some vibration issues.

The ultimate goal for this Stirling engine project is to make it into an even more interesting demonstration than its already hypnotic external combustion mechanical wizardry.

The first idea is to explore ways to make it rotate itself on a lazy Susan. I want to harness the power generated by the motor to overcome the friction of the lazy Susan bearings.

One cool idea is to use gyroscopic precession to cause rotation. To do this we would use the flywheel as the gyro wheel and apply a force to tip the wheel axis over. I will explain it a bit better in a future segment if I get it working, but my first attempts weren't very successful. I think the flywheel needs quite a bit more mass or speed for this idea to work, but I will see if I can get it working well enough to show the concept.

My next idea is to turn the flywheel into a propeller that will push the engine in a circle. This was more successful, but it requires the system to be really well balanced and to remain perfectly level throughout the rotation. Unfortunately the lazy Susan I have doesn't have ideal bearings and they have some tolerance that allows the platter to tilt a bit and the fan doesn't have enough thrust to push any unbalanced weight up hill. I will try to build a platter with better bearings, but I am worried that I will introduce too much friction. But that is all part of the experimental process.

The first order of business though is to make sure the engine doesn't wander off the platter....

I want to start by having a look at the vibration to see if there is enough signal correlation to the rotation to think of using a counterweight to combat the vibration.....

 

Stirling Engine Vibration Control and Self Powered Rotation

I examined the vibration signal and decided implementing counteracting pistons with a gear train would get pretty ugly and have little chance of eliminating the vibration. It might be possible to design a balanced Stirling engine if I had a machine shop, but adding onto this one would just make it ugly, which is the opposite of what I am trying to achieve.

Things like the play in the bushings and bearings of the moving parts are creating all kinds of vibrations and the geometry of the solid pieces gives rise to vibrations in all directions.

Fortunately the foam solution stops the machine from wandering around and the vibration sensor saved me from going down the rabbit hole of trying to counterbalance the pistons.

I still want to try a heavier flywheel, because that may reduce the magnitude of the vibration, but that is just out of interest unless I can figure out a way to make it look good as well.

The propeller idea looks like it can be made to work if the platter can be kept perfectly level at all times, so I will make an attempt to do that. I cant make the blades any bigger as they already had to be trimmed to stop them hitting the piston. I am toying with the idea of adding an electric fan driven by the little generator - it isn't a very efficient or pretty solution, but I could increase the torque by moving the fan away from the center of rotation. I know that adding an electric fan will reduce the motor speed, so the flywheel fan would suffer.

 

In the next segment I will explore reducing vibration with a more massive flywheel, and harnessing the power generated by the Stirling engine to do interesting things.

On this journey I am still getting better at monitoring the vibration sensor on the scope so this blog is hopefully getting better. Not everything I try is successful, and some things require iteration to improve performance, but I am learning a lot and actually making progress in designing some interesting applications for the Stirling engine.

 

Flywheel Attachments and Progress Towards More Interesting Applications

Here is a video showing how a more massive flywheel helps stabilize the chassis:

Conclusions from this segment:

  • A more massive flywheel does help reduce vibration, but it also slows down the engine, which reduces its generator output
  • Adding a turbine to the flywheel can provide enough thrust to rotate a turntable

 

Stirling Engine Sensor System

This section explores harnessing the power generated by the Stirling engine to run a sensor system that monitors the Stirling Engine, creating a self-contained system. The Senor system includes 6 sensors and an liquid crystal display:

  • a vibration sensor to monitor chassis vibrations with different mounting schemes
  • 3 thermocouples to monitor temperatures at both cylinders and the flame
  • a current sensor to measure the current supplied by the generator connected to the Stirling engine
  • a voltage sensor to measure the voltage being output by the same generator

This video shows how it all goes together and how it works:

The vibration sensor shows that a more massive base also reduces the vibration.

I think it is ultra cool that the Stirling engine can generate enough power to monitor itself despite all the inefficiencies in the system.

I did not have to use any low power tricks to get the system to run.

It even had enough power left over to run 4 backlight LEDs.

I decided the display was too hard to see when lying flat, so I added a stand to hold it at an angle, but also decided to make a better chassis for the electronics at the same time, to make it easier to assemble:

 

Project Design Elements

This is a design challenge so this section is a review of the design elements of the project.

The vibration sensor did not need any design, it worked very well as a complete sensor with appropriate output.

Many design disciplines were used in the completion of this project, the main categories include mechanical design, electronic design and firmware design.

Design challenges also require planning, fabrication, assembling, programming, testing and blogging, but this section just highlights some of the custom design elements.

This picture shows most of the custom designed subsystems:

The following video discusses each of the main design elements in a bit more detail:

This project ended up involving at least twelve 3D printed parts and a couple of printed circuit board designs.

Of course some of them were necessitated by requirements for design improvements and the experimental nature of the project.

But I love designing, so that was a fun aspect of the project.

 

Firmware

I am putting the firmware for the sensor module here.

It works, but is not well documented and makes no claim to be good code.

//
//Vibration Sensor Project
//by Doug Wong
//2020


#include <SPI.h>
#include <Wire.h>
#include "Adafruit_MAX31855.h"


//Maxim thermocouple chips use SPI
#define MAXDO   14
#define MAXCLK  15
#define MAXCS1   A0
#define MAXCS2   A1
#define MAXCS3   A2


#define SpeedPIN A3
#define PIN_VIN A10
#define PIN_IIN A6
#define PIN_SW 5


//SPI LCD pins
#define PIN_BL 9
#define PIN_SCE   6
#define PIN_RESET 7
#define PIN_DC    8
#define PIN_SDIN  16
// #define PIN_CLK  15


#define LCD_C     LOW
#define LCD_D     HIGH


#define LCD_X     84  // horizontal pixels
#define LCD_Y     48  // vertical pixels


// wheel pulses per rotation - not implemented
#define ENC_COUNT_REV 50

// Hall sensor output to Arduino Interrupt pin
#define ENC_IN 2 

// One-second interval for measurements
int interval = 1000;

// Counters for milliseconds during interval
long previousMillis = 0;
long currentMillis = 0;

// Variables for RPM measuerment
int rpm = 0;
int ecount = 0;
int ppulsepin = 0;
int pulsepin;

// analog voltage variables
int aVIN;
int VINi;
float VIN;
int aVIB;
int aVIBO;
int VIBi;
float VIB;


const int led1 = 17;


// font bit maps
static const byte ASCII[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20  
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j 
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f →
};


char srpm[5];
String ssrpm;
String ssTC1;
char TC1[4];
double TCr;
int ssTC1i;


String ssVIN;
char sVIN[4];


// Initialize the Thermocouples
Adafruit_MAX31855 thermocouple1(MAXCLK, MAXCS1, MAXDO);
Adafruit_MAX31855 thermocouple2(MAXCLK, MAXCS2, MAXDO);
Adafruit_MAX31855 thermocouple3(MAXCLK, MAXCS3, MAXDO);


// Initiallize DIO
void initiallizeDIO()
{
pinMode(PIN_SW, INPUT_PULLUP);
pinMode(PIN_BL, OUTPUT);
digitalWrite(PIN_BL, LOW);
}


void initiallizeinterrupt()
{
    // Set encoder as input with internal pullup  
  pinMode(ENC_IN, INPUT); 

  // Setup initial values for timer
  previousMillis = millis();
  
}


void LcdCharacter(char character)
{
  LcdWrite(LCD_D, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D, 0x00);
}


void LcdClear(void)
{
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(LCD_D, 0x00);
  }
}


void LcdInitialise(void)
{
  pinMode(PIN_SCE, OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(MAXCLK, OUTPUT);
  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);
  LcdWrite(LCD_C, 0x21 );  // LCD Extended Commands.
  LcdWrite(LCD_C, 0xBA );  // Set LCD Vop (Contrast). 
  LcdWrite(LCD_C, 0x04 );  // Set Temp coefficent. //0x04
  LcdWrite(LCD_C, 0x14 );  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_C, 0x20 );  // LCD Basic Commands
  LcdWrite(LCD_C, 0x0C );  // LCD in normal mode.
}


void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}


void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, MAXCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}


void setup(void)
{
  LcdInitialise();
  LcdClear();
  LcdString("  STIRLING  ");
  LcdString("   ENGINE   ");
  LcdString("   MONITOR  ");
  LcdString("            ");
  LcdString("     by     ");
  LcdString("  DOUG WONG ");
  delay (2000);
  
  LcdClear();
  LcdString(" TC1        ");
  LcdString(" TC2        ");
  LcdString(" TC3        ");
  LcdString(" VIB        ");
  LcdString(" mV         ");
  LcdString(" mA         ");


  delay (1000);


  if (!thermocouple1.begin()) {
    LcdString("ERROR.");
  }
}
void loop()
{ 


  if (1)
  {


  // find max vibration for 1 second
     aVIB = analogRead(SpeedPIN);
    if (aVIB < 512) {
      aVIB=512;
    }
    if (aVIB > aVIBO) {
      aVIBO=aVIB;
    }
  
  // Update display values every second
  currentMillis = millis();
  if (currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;
    
    // Calculate RPM
//    rpm = (float)(ecount * 60 / ENC_COUNT_REV);
//    rpm = digitalRead(ENC_IN)+ 1;


   // display VIB
      VIB = (aVIBO-512)*7.2;
      aVIBO = 0;
      VIBi = int(VIB);
      LcdWrite(LCD_C, 0x43 );  // set Y to line 4
      LcdWrite(LCD_C, 0xAA );  // set X to column 26
      ssrpm=String(VIBi);
      ssrpm.toCharArray(srpm,5);
      LcdString(srpm);
      LcdString("   ");
    


   // display VIN
      aVIN = analogRead(PIN_VIN);
      VIN = aVIN*10+460;
      VINi = int(VIN);
      ssVIN=String(VINi);
      ssVIN.toCharArray(sVIN,5);
      LcdWrite(LCD_C, 0x44 );  // set Y to line 5
      LcdWrite(LCD_C, 0xAA );  // set X to column 26
      LcdString(sVIN);
      LcdString("   ");




   // display IIN
      aVIN = analogRead(PIN_IIN);
      VIN = aVIN*.03222;
      VINi = int(VIN);
      ssVIN=String(VINi);
      ssVIN.toCharArray(sVIN,4);
      LcdWrite(LCD_C, 0x45 );  // set Y to line 6
      LcdWrite(LCD_C, 0xAA );  // set X to column 26
      LcdString(sVIN);
      LcdString("    ");


   // display TC1
      LcdWrite(LCD_C, 0x40 );  // set Y to line 1
      LcdWrite(LCD_C, 0xAA );  // set X to column 26
      TCr = thermocouple1.readCelsius();
      ssTC1i=(int)(TCr);
      ssTC1=String(ssTC1i);
      ssTC1.toCharArray(TC1,5);
      LcdString(TC1);
      LcdString("   ");
  
   // display TC2
      LcdWrite(LCD_C, 0x41 );  // set Y to line 2
      LcdWrite(LCD_C, 0xAA );  // set X to column 26
      TCr = thermocouple2.readCelsius();
      ssTC1i=(int)(TCr);
      ssTC1=String(ssTC1i);
      ssTC1.toCharArray(TC1,5);
      LcdString(TC1);
      LcdString("   ");
   
   // display TC3
      LcdWrite(LCD_C, 0x42 );  // set Y to line 3
      LcdWrite(LCD_C, 0xAA );  // set X to column 26
      TCr = thermocouple3.readCelsius();
      ssTC1i=(int)(TCr);
      ssTC1=String(ssTC1i);
      ssTC1.toCharArray(TC1,5);
      LcdString(TC1);
      LcdString("   ");
   }
  }
 }

 

I summarized the design aspects of the design challenge above, but the title of the challenge is "Experimenting With Vibration Sensors", so a summary of the vibration experiments is in order. This list doesn't include all the experiments with the Stirling engine, just the ones that involve the vibration sensor:

 

Vibration Experiments Summary

  • testing a piezo-electric effect speaker frequency response in vibration compared to acoustic
    • handling music stimulus with and without sound box
    • handling sine wave, square wave and triangle wave tones, generating FFTs and looking at harmonics
    • handling frequency sweeps from 10 Hz to 20KHz and generating Bode plots
  • testing a electro-magnet speaker driver frequency response in vibration compared to acoustic
    • handling music stimulus with a sound box
    • handling sine wave, square wave and triangle wave tones, generating FFTs and looking at harmonics
    • handling frequency sweeps from 10 Hz to 20KHz and generating Bode plots
    • testing frequency response to white noise and pink noise
  • testing a 3D printed speaker cone on a surface audio driver and using the vibration sensor to troubleshoot amplifier clipping
  • testing a speaker case vibration versus the corresponding acoustic speaker waveforms
  • testing sensitivity of the vibration sensor to small vibrations, small direct impacts and small external impacts, including a pin drop
  • testing vibration of wine glasses clinking
  • testing vibration of a steel ruler cantilever
  • testing vibration of a single string, emulating a stringed instrument in potential tuning applications
  • testing the resonance of a bottle with air blowing across its mouth
  • testing Stirling engine vibration in multiple axes sitting on various surfaces, including foam rubber
  • testing how Stirling engine vibration changes based on flywheel mass
  • testing how Stirling engine vibration changes based on chassis mass
  • testing a microcontroller reading and displaying the vibration sensor monitoring a Stirling engine subjected to various mounting arrangements
  • testing the vibration sensor as a throat microphone and a bone conduction microphone

Devising all these experiments was an interesting exercise and the results increased my knowledge of vibration, which in turn helped develop more experiments.

 

Highlights of Lessons Learned

I learned that the Kemet vibration sensor is much more sensitive than I had expected and it has a surprisingly flat frequency response over a wide range.

I learned that speakers can be intelligible even with a very uneven frequency response. I also learned that to design high fidelity speakers requires careful attention to materials and geometry and associated resonances.

I learned a bit about how mass affects vibration.

Using a vibration sensor to detect amplifier clipping was an unexpected discovery.

There are many little things you learn whenever you build and test something new, and this project had many of those, especially since some of the things that were attempted were unknown and not easy to guarantee by design. Such as:

Can this Stirling engine drive itself on a rotary table by adding an air turbine to the flywheel?

Can this engine generate enough power to run a microcontroller with 6 sensors and a display?

It was risky to design a microcontroller PCB on the off-chance that the generator could run it, but the risks paid off and these aggressive objectives were successfully met.

 

Disappointments

I think I damaged the vibration sensor or the sensor cable somewhere along the way. I can no longer get any sensitivity out of the sensor. I am sure I would have found uses for it in the future. One experiment I really wanted to try was to use the vibration sensor as a throat mic or a bone conduction mic. With its excellent frequency response in the audio range, it should make a great throat mic. I had an amp all set up in case the signal was too low, but the sensor was no longer cooperating. I would have recorded some of the videos with the sensor as a throat mic if I could get it to work. That would have been icing on the project.

 

Conclusions And Summary

This project was an exploration of vibration sensors and related applications that took quite a few unexpected turns. Many of the conclusions from the various experiments are included in corresponding sections above, but it is worth putting some highlights here.

Performance of the vibration sensor was researched using a variety of tests and applications (about 20 tests).

Apparatus to execute these tests was designed and assembled.

Video of the tests was captured and edited. (about 110 videos)

The Kemet VS-BV203-B vibration sensor has excellent performance and its ease of use made exploring its capabilities a lot of fun.

Vibration sensors primarily measure vibration and acceleration, which seems very specialized, but the enormous number of things that vibrate give rise to a wide variety of applications for such sensors. Vibration is crucial in the entire fields of music, sound pollution, vehicle comfort, machine health and machine lifespan among many others, including esoteric applications like stealth machines. It is fun to go around trying the sensor on anything that vibrates to see what is actually going on. I even tried it on an old reciprocating electric razor, which has a very violent vibration.

The project also included attempts to reduce the vibration of a Stirling engine while exploring novel uses of the power it develops.

Eventually rotary motion was achieved using thrust from a custom flywheel air turbine, and the engine was kept from wandering off the turntable.

A self-contained system running a monitoring microcontroller powered from a small generator driven by the Stirling engine was designed and built.

There is something poetic about the way these systems work that I find simply delightful.

Both self propulsion and self monitoring were risky objectives since it was not known if they could be achieved, but this made their success that much more enjoyable.

These achievements plus the interesting vibration experiments and overall knowledge gained, combined to make this project a most satisfying experience.

Thanks to Kemet and elemet14 for the opportunity to participate and to the members who have commented.

 

Update:

Here is the awesome prize I received for this project:

Here is a quick demo of one of its really cool features:

This great whiteboard is likely to feature in some upcoming blogs.

 

Relevant Links:

Taming The Wild Stirling Engine  - This is the introductory blog to this project

Experimenting with Vibration Sensors: About the Competition

Kemet web site

VS-BV203-B datasheet

Petro wax - the amazing wax glue used for mounting accelerometers - also sold by other vendors