This is a choker that can start recording autonomously when it detects the user humming unconsciously in the bathroom.
The choker compared to a quarter dollar coin
The front look of the choker
The piezo that detects the vibration on the neck and the microphone that detects and records sound
The choker doesn’t begin recording until the sound volume and the level of vibration both reach the thresholds
The audios will be saved to the SD card
Process
The first change I recorded is the choice of vibration detector, I was using a vibration sensor with a digital output at first, and it turned out that it cannot detect small vibration on the neck very well, then I changed it into a piezo.
The circled device is the vibration sensor I was originally using
The second change is the overall appearance of the choker, I was thinking about only leaving the Arduino Nano outside, but in the end I flipped it over to make the choker more flexible to wear.
The original design – outside
The origin design – inside
I flipped it over so that it’s really flexible and comfortable to wear
There are also changes in code that I forgot to record, I was using a naïve for loop calculating the average value to reduce noise but it didn’t work very well, later I use a Kalman filter instead.
Discussion
There are several comments regarding the appearance of the choker, some people are saying “the Arduino Nano as a ‘jewel’ is pretty neat looking, very high tech esthetic”, there are also people suggesting “hide the electronic board in the choker” or “hide all the electronics beneath some crystal/stone decor”. There are also comments regarding the user experience, people are saying “Softening the wires against your neck” and “Assembly and build is challenging to make robust and comfortable”. In the end, the choker turns out to be super cyberpunk due to me trying to make it comfortable to wear given limited hardware. Cyberpunk fans may like it while fans of traditional aesthetics may hate it. We don’t have wires in the lab that are soft enough, and the design of the SD card module make the choker super uncomfortable to wear if I attach the module to the choker. In fact, the original design is already a compromise, my idea is actually to make it into a modern silicon choker where the electronic components are all hidden in it, but due to limitations, this is how the final product looks like.
I’m personally not very satisfied about this project, because it doesn’t look very stable and I actually ran into an uploading issue when I finally decided to upload the code to Arduino Nano. There are some issues in the code as well, and I still cannot figure that out. A lot more extra work is needed in order to make it really satisfy me.
What I learned from this project is that it’s hard to deal with unfamiliar hardware and software libraries, my life would be much easier if I don’t try so many weird stuff. My original thought was just beyond the scope of this course, that’s not something I can finish using limited materials in such limited time. Apart from the hardware part, I was originally also thinking about writing code to make the choker actually distinguish between humming and other sound. I wanted to make something really useful that no other things can achieve the same result. My advice to my past self would be: don’t be too ambitious, why not just make a calorie tracker? You can definitely track it on your phone but it’s still a good little thing to have.
If I have chance to build another iteration of this project, I will debug the software first, and also acquire necessary materials to build a safe, stable, and good-looking choker. I will try to use Bluetooth instead of using SD card, and I will write code for distinguishing between music sound and noise.
Block Diagram
Schematic Diagram
Code
/*
Music Composer Helper
This code enables the choker to record for 3 minutes when the volume and
vibration reach their thresholds, and save the audio to the SD card.
*/
/*
Hardware Pinout Connection
Arduino Nano SD Pin
5V ------------ VCC
GND ----------- GND
D10 ----------- CS
D11 ----------- MOSI
D12 ----------- MISO
D13 ----------- SCK
________________________________________
Arduino Nano Microphone
5v ------------- VCC
GND ------------ GND
A0 ------------- Out
________________________________________
Arduino Nano Piezo
GND ---------- negative
A5 ----------- positive
*/
/*
credit
https://circuitdigest.com/microcontroller-projects/simple-arduino-voice-
recorder-for-spy-bug-voice-recording
*/
#include <SimpleKalmanFilter.h>
#include <TMRpcm.h>//the library for recording
#include <SD.h>
#include <SPI.h>
#define SD_CSPin 10
#define vib_pin A5
#define mic_pin A0;
const int sample_rate = 16000;
int file_number = 0;
int vib = 0;
int vol = 0;
unsigned int sample;
float estimated_vol = 0;
float estimated_vib = 0;
char filePrefixname[50] = "rec";
char exten[10] = ".wav";
TMRpcm audio;
/*
SimpleKalmanFilter(e_mea, e_est, q);
e_mea: Measurement Uncertainty
e_est: Estimation Uncertainty
q: Process Noise
*/
SimpleKalmanFilter volumeKalmanFilter(1, 1, 0.01);
SimpleKalmanFilter vibrationKalmanFilter(1, 1, 0.01);
// delay function for serial log.
void wait_min(int mins) {
int count = 0;
int secs = mins * 60;
while (1) {
Serial.print('.');
delay(1000);
count++;
if (count == secs) {
count = 0;
break;
}
}
Serial.println();
return ;
}
void setup() {
Serial.begin(9600);
//Sets up the pins
pinMode(mic_pin, INPUT);
pinMode(vib_pin, INPUT);
//Checking SD card
Serial.println("loading... SD card");
if (!SD.begin(SD_CSPin)) {
Serial.println("An Error has occurred while mounting SD");
}
while (!SD.begin(SD_CSPin)) {
Serial.print(".");
delay(500);
}
audio.CSPin = SD_CSPin;
}
void loop() {
//print volume
vol = analogRead(mic_pin);
estimated_vol = volumeKalmanFilter.updateEstimate(vol);
Serial.print("vol ");
Serial.println(estimated_vol);
//print vibration
vib = analogRead(vib_pin);
estimated_vib = vibrationKalmanFilter.updateEstimate(vib);
Serial.print("vib ");
Serial.println(estimated_vib);
//print file name
char fileSlNum[20] = "";
itoa(file_number, fileSlNum, 10);
char file_name[50] = "";
strcat(file_name, filePrefixname);
strcat(file_name, fileSlNum);
strcat(file_name, exten);
Serial.print("New File Name: ");
Serial.println(file_name);
//record if volume and vibration hit thresholds
if (estimated_vol > 510 && estimated_vib > 1) {
audio.startRecording(file_name, sample_rate, mic_pin);
vol=0;
vib=0;
estimated_vol = 0;
estimated_vib = 0;
Serial.println("startRecording ");
// record audio for 3mins
wait_min(3);
audio.stopRecording(file_name);
Serial.println("stopRecording");
file_number++;
}
//clear values to avoid bugs
vol=0;
vib=0;
estimated_vol = 0;
estimated_vib = 0;
}