#include <Adafruit_NeoPixel.h>
// Pin definitions
const int knockSensor = A0; // Piezo sensor on pin 0.
//const int greenLED = 13; // Status LED
const int PIOpin0 = 11;
const int PIOpin1 = 10;
const int PIOpin2 = 9;

#define StripLEDpin 3
#define NUMPIXELS 12
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, StripLEDpin, NEO_GRB + NEO_KHZ800);

// Tuning constants. Could be made vars and hoooked to potentiometers for soft configuration, etc.
const int threshold = 10; // Minimum signal from the piezo to register as a knock
const int rejectValue = 25; // If an individual knock is off by this percentage of a knock we don’t unlock..
const int averageRejectValue = 15; // If the average timing of the knocks is off by this percent we don’t unlock.
const int knockFadeTime = 150; // milliseconds we allow a knock to fade before we listen for another one. (Debounce timer.)

const int maximumKnocks = 20; // Maximum number of knocks to listen for.
const int knockComplete = 1200; // Longest time to wait for a knock before we assume that it’s finished.

// Variables.
int CinderellaCode[maximumKnocks] = {25, 25, 25, 25, 100, 50, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Cinderella Knock Pattern
int FrozenCode[maximumKnocks] = {100, 50, 25, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Frozen Knock Pattern
int TrippleCode[maximumKnocks] = {25, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int KoreanCode[maximumKnocks] = {80, 40 ,80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

int knockReadings[maximumKnocks]; // When someone knocks this array fills with delays between knocks.
int knockSensorValue = 0; // Last reading of the knock sensor.

void setStripLED(int r, int g, int b)
{
for(int i=0;i<12;i+=2)
{
pixels.setPixelColor(i, pixels.Color(r, g, b)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
}
}
void correctStripLED(int r, int g, int b)
{
for(int i=0;i<NUMPIXELS;i++)
{
pixels.setPixelColor(i, pixels.Color(r, g, b)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(30);
}
for(int i=0;i<NUMPIXELS;i++)
{
pixels.setPixelColor(i, pixels.Color(0, 0, 0)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(20);
}
for(int i=0;i<NUMPIXELS;i++)
{
pixels.setPixelColor(i, pixels.Color(r, g, b)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(10);
}
for(int i=0;i<NUMPIXELS;i++)
{
pixels.setPixelColor(i, pixels.Color(0, 0, 0)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(20);
}
}

// Sees if our knock matches the secret.
// returns true if it’s a good knock, false if it’s not.
// todo: break it into smaller functions for readability.
boolean validateKnock(int *secretCode)
{
// simplest check first: Did we get the right number of knocks?
int currentKnockCount = 0;
int secretKnockCount = 0;
int maxKnockInterval = 0; // We use this later to normalize the times.

for (int i=0;i<maximumKnocks;i++)
{
if (knockReadings[i] > 0)
currentKnockCount++;

if (*(secretCode+i) > 0) //todo: precalculate this.
secretKnockCount++;

if (knockReadings[i] > maxKnockInterval) // collect normalization data while we’re looping.
maxKnockInterval = knockReadings[i];
}

if (currentKnockCount != secretKnockCount)
return false;

int totaltimeDifferences = 0;
int timeDiff = 0;
for (int i=0;i<maximumKnocks;i++) // Normalize the times
{
knockReadings[i] = map(knockReadings[i], 0, maxKnockInterval, 0, 100);
timeDiff = abs(knockReadings[i] – *(secretCode+i));

if(timeDiff > rejectValue) // Individual value too far out of whack
return false;

totaltimeDifferences += timeDiff;
}
// It can also fail if the whole thing is too inaccurate.
if(totaltimeDifferences/secretKnockCount > averageRejectValue)
return false;

return true;
}

void triggerPIO(int *secretCode, int setPIOpin1, int setPIOpin2)
{
if (validateKnock(secretCode) == true)
{
correctStripLED(100, 200, 100);
Serial.println(“Secret knock correct.”);
digitalWrite(setPIOpin1, LOW);
digitalWrite(setPIOpin2, LOW);
delay(1000);
digitalWrite(setPIOpin1, HIGH);
digitalWrite(setPIOpin2, HIGH);
}
else
{
Serial.println(“Secret knock failed.”);
}
}

// Records the timing of knocks.
void listenToSecretKnock()
{
Serial.println(“knock starting”);

for (int i=0;i<maximumKnocks;i++)
knockReadings[i] = 0;

int currentKnockNumber = 0; // Incrementer for the array.
int startTime = millis(); // Reference for when this knock started.
int now = millis();

setStripLED(200, 100, 100); // we blink the LED for a bit as a visual indicator of the knock.
delay(knockFadeTime); // wait for this peak to fade before we listen to the next one.
setStripLED(0, 0, 0);

while ((now-startTime < knockComplete) && (currentKnockNumber < maximumKnocks))
{
//listen for the next knock or wait for it to timeout.
knockSensorValue = analogRead(knockSensor);
if (knockSensorValue >= threshold) //got another knock…
{
//record the delay time.
Serial.println(“knock.”);
now = millis();
knockReadings[currentKnockNumber++] = now-startTime;
startTime = now;

// and reset our timer for the next knock
setStripLED(200, 100, 100);
delay(knockFadeTime); // again, a little delay to let the knock decay.
setStripLED(0, 0, 0);
}
now = millis();
}
}

void setup()
{
// pinMode(greenLED, OUTPUT);
pinMode(PIOpin0, OUTPUT);
pinMode(PIOpin1, OUTPUT);
pinMode(PIOpin2, OUTPUT);

Serial.begin(9600); // Uncomment the Serial.bla lines for debugging.
Serial.println(“Program start.”); // but feel free to comment them out after it’s working right.

pixels.begin(); // This initializes the NeoPixel library.
setStripLED(0, 0, 0);
digitalWrite(PIOpin0, HIGH);
digitalWrite(PIOpin1, HIGH);
digitalWrite(PIOpin2, HIGH);
}

void loop()
{
// Listen for any knock at all.
knockSensorValue = analogRead(knockSensor);
if (knockSensorValue >=threshold)
{
listenToSecretKnock();
triggerPIO(FrozenCode, PIOpin0, PIOpin0);
triggerPIO(CinderellaCode, PIOpin1, PIOpin1);
triggerPIO(TrippleCode, PIOpin2, PIOpin2);
triggerPIO(KoreanCode, PIOpin0, PIOpin1);
setStripLED(0, 0, 0);
}
}

if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume(); // Receive the next value }

irsend.sendNEC(0xFF19E6, 32);