Materials:
Denim Jacket
3 ply Steel Conductive Thread
Pulse Sensor
8 Sewable Neopixels
2 LED Sequins (they come in a pack of 5)
about 15 Jumpers
Arduino
Breadboard
Solder/Soldering Iron
Cutters & Strippers
6 long wires
This is an image of the breadboard and the Arduino with all the cabled/jumpers and the Pulse Sensor. The wire is soldered onto the jumpers, and the jumpers are soldered onto the breadboard. The pulse sensor is connected the wires, to make it longer and to allow for it to go through the sleeve and reach the hand. There are other three wires attached, one connected to power, one connected to ground, and one connected to pin 5. These wires are connected to the neopixels.
The lights change color according the beats per minute; from 0 – 65 BPM the lights are blue, 65 – 100 BPM the lights are purple, and >100 BPM the lights are red. The pulse sensor isn’t very reliable, but it does pick up on the pulse if you hold it for a while. The lights have a little delay but they work according to the BPM. I wanted the lights to flicker on and off, to mimic the pulse of the person, but that was difficult to achieve, but the result is still something I really liked
I added the LED sequins because the heard didn’t really look like a heart, the sequins add a little more shape to the heart, by marking the points in the heart.
In the video, I purposely pressed on the pulse sensor a little faster to mimic an increasing pulse. You can see the lights change from blue, to purple, to red. I also tried showing the way everything is connected.
/* Pulse Sensor Amped 1.4 by Joel Murphy and Yury Gitman http://www.pulsesensor.com
———————- Notes ———————- ———————-
This code:
1) Blinks an LED to User’s Live Heartbeat PIN 13
2) Fades an LED to User’s Live HeartBeat
3) Determines BPM
4) Prints All of the Above to Serial
Read Me:
https://github.com/WorldFamousElectronics/PulseSensor_Amped_Arduino/blob/master/README.md
———————- ———————- ———————-
*/
#include <Adafruit_NeoPixel.h> // Library containing
#define USE_GET_MILLISECOND_TIMER 1
#include “FastLED.h”
// Variables
int pulsePin = A0; // Pulse Sensor purple wire connected to analog pin 0
//int blinkPin = 13; // pin to blink led at each beat
int fadePin = 5; // pin to do fancy classy fading blink at each beat
int fadeRate = 0; // used to fade LED on with PWM on fadePin
// Volatile Variables, used in the interrupt service routine!
volatile int BPM; // int that holds raw Analog in 0. updated every 2mS
volatile int Signal; // holds the incoming raw data
volatile int IBI = 600; // int that holds the time interval between beats! Must be seeded!
volatile boolean Pulse = false; // “True” when User’s live heartbeat is detected. “False” when not a “live beat”.
volatile boolean QS = false; // becomes true when Arduoino finds a beat.
// Regards Serial OutPut — Set This Up to your needs
static boolean serialVisual = true; // Set to ‘false’ by Default. Re-set to ‘true’ to see Arduino Serial Monitor ASCII Visual Pulse
// Set up use of NeoPixels
const int NUMPIXELS = 8; // Put the number of NeoPixels you are using here
uint8_t brightness = 128; // Set brightness of NeoPixels here
CRGB leds [NUMPIXELS];
//CRGBPalette16 currentPalette;
//CRGBPalette16 targetPalette;
//CRGBPalette16 targetPalette1;
//CRGBPalette16 targetPalette2;
uint8_t maxChanges = 24;
TBlendType currentBlending;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, fadePin, NEO_GRB + NEO_KHZ800);
uint32_t resetTime;
void setup() {
interruptSetup(); // sets up to read Pulse Sensor signal every 2mS
pinMode(fadePin, OUTPUT); // pin that will fade to your heartbeat!
strip.begin();
strip.setBrightness(brightness);
// currentPalette = OceanColors_p; // RainbowColors_p; CloudColors_p; PartyColors_p; LavaColors_p; HeatColors_p;
//targetPalette = ForestColors_p; // RainbowColors_p; CloudColors_p; PartyColors_p; LavaColors_p; HeatColors_p;
//targetPalette1 = LavaColors_p; // RainbowColors_p; CloudColors_p; PartyColors_p; LavaColors_p; HeatColors_p;
//targetPalette2 = HeatColors_p; // RainbowColors_p; CloudColors_p; PartyColors_p; LavaColors_p; HeatColors_p;
currentBlending = LINEARBLEND;
Serial.begin(115200); // we agree to talk fast!
strip.show(); // Ensure the pixels are off
delay(1000); // Wait a second
}
void FillLEDsFromPaletteColors (uint8_t colorIndex) {
uint8_t beatB = beatsin8 (15, 10, 20); // Delta hue between LED’s
for (int i = 0; i < NUMPIXELS; i ++) {
// leds [i] = ColorFromPalette (currentPalette, colorIndex, 255, currentBlending);
//colorIndex + = beatB;
colorIndex = beatB;
}
}
// Where the Magic Happens
void loop() {
serialOutput() ;
uint8_t beatA = beatsin8 (0, 0, 255); // Starting hue
// FillLEDsFromPaletteColors (beatA);
show_at_max_brightness_for_power (); // Power managed display.
if (QS == true) { // A Heartbeat Was Found
// BPM and IBI have been Determined
// Quantified Self “QS” true when arduino finds a heartbeat
// digitalWrite(blinkPin, HIGH); // Blink LED, we got a beat.
fadeRate = 255; // Makes the LED Fade Effect Happen
}
// Set ‘fadeRate’ Variable to 255 to fade LED with pulse
serialOutputWhenBeatHappens(); // A Beat Happened, Output that to serial.
QS = false; // reset the Quantified Self flag for next time
//}
ledFadeToBeat(); // Makes the LED Fade Effect Happen
CheckBPM();
delay(20); // take a break
}
void ledFadeToBeat() {
fadeRate -= 15; // set LED fade value
fadeRate = constrain(fadeRate, 0, 255); // keep LED fade value from going into negative numbers!
strip.show();
// analogWrite(fadePin, fadeRate); // fade LED
// digitalWrite(blinkPin, LOW); // Blink LED, we got a beat.
//setStrip(fadeRate);
//nblendPaletteTowardPalette (currentPalette, targetPalette, maxChanges);
// colorWipe(strip.Color(0, 255, 0), 50); // Green
}
void setStrip(int r) { // Set the strip to one color intensity (red)
//nblendPaletteTowardPalette (currentPalette, targetPalette, maxChanges);
int g = 0; // Green is set to zero (for non-red colors, change this)
int b = 0; // Blue is set to zero (for non-red colors, change this)
for (int x = 0; x < NUMPIXELS; x++) {
strip.setPixelColor(x, strip.Color(r, g, b));
}
strip.show();
}
uint32_t get_millisecond_timer ()
{
return millis () – resetTime;
}
// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
}
}
void CheckBPM (){
Serial.println(“here”);
if (BPM >= 0 && BPM <= 65) { // FastLED based timer to update / display the sequence every 5 seconds.
colorWipe(strip.Color(0, 128, 255), 50); // Blue
// nblendPaletteTowardPalette (currentPalette, targetPalette, maxChanges);
strip.show();
}
if (BPM >= 65 && BPM <= 100) {
colorWipe(strip.Color(102, 0, 204), 50); // Purple
//nblendPaletteTowardPalette (targetPalette, targetPalette1, maxChanges);
strip.show();
}
if (BPM >= 100) {
colorWipe(strip.Color(204, 0, 0), 50); // Red
// nblendPaletteTowardPalette (targetPalette1, targetPalette2, maxChanges);
strip.show();
}
}