•

Published November 25, 2021 © GPL3+

Accountability Boxes

This product allows for accountability with a partner. If the box is opened without the password an alarm sounds and notifies the partner.

IntermediateFull instructions providedOver 1 day232

Things used in this project

Hardware components

Particle Argon

Reed Switch, SPST-NO

Elegoo 4X4 Membrane Switch

Elegoo Active Buzzer

Software apps and online services

Particle Build Web IDE

IFTTT Maker service

Google Sheets

Fritzing

Hand tools and fabrication machines

Drill / Driver, Cordless

Files

Story

Our main goal in creating this product was to help others. After some deliberating and thinking of people in our lives that are struggling we came up with the idea of an accountability box. The main purpose of the accountability box is to help free people from addiction, the way this is done is by putting something in the box and giving the keypad to an accountability partner. If the box is opened without the passcode entered first the alarm will sound and give the accountability partner a notification. This will tell the accountability partner he needs to reach out to the addicted individual. One issue with typical accountability partners is that unless what the person is struggling with is thrown away it still is in the house, and temptation can cause the individual to cave. This product solves the issue of the individual lying to their accountability partner. There are many ways this problem could be solved, accelerometers or tilt switches could be used to tell if the box was being tampered with, however, for this product, we decided to use an Elegoo membrane switch, active buzzer, and a reed switch. Our current design is the most efficient way to build this with our limited resources. If put into production the fewer sensors would be way cheaper. This is the first version of the product and more updates will come, possibly including more sensors and a bigger storage compartment. The compartment is a little too small to fit a cell phone, but this could easily be scaled up on the slicer to fit a phone for parents to use as discipline. The best part about this concept is that it can be scaled up as needed and can help people free themselves from addiction when integrity is not the strong suit of the addicted individual.

Here is a breakdown of our project:

How the Accountability Box Works

Here is the general way the code is running:

Basic Code Breakdown

Below are pictures of the enclosure for the items that are being stored:

1 / 4 • Enclosure for the Circuit (smaller hole) and the Addicted Items (bigger hole)

Below are pictures of the lid to the above enclosure

1 / 2 • Lid for above Enclosure, Holes are all for Magnets

Below are pictures of the keypad enclosure:

1 / 3 • Key Pad Circuit Enclosure

Below are pictures of the lid for the enclosure above:

1 / 2 • Keypad Enclosure Lid

Live data readings are consistently taken with these devices and stored in two separate Google Sheets files. These recordings were made possible through IFTTT. The first file updates whenever the code is either put in correctly on the Keypad, or when there is an incorrect number pushed. This data is plotted in Sheets, showing a simple 1 or 0 based on whether the code was correct or incorrect.

Code File in Sheets:

https://docs.google.com/spreadsheets/d/1ddosjNvrP2ca6SdmhSnQnwB7g0WETc35HcaQlcBZwNQ/edit?usp=sharing

The second file stores data when the box is opened, after the correct input is provided. The graph that is produced is a simple plot that shows a 1 value and the date and time that the box was opened.

Response File in Sheets:

https://docs.google.com/spreadsheets/d/1HPlLaadKQt5hO7vh6xqsr09WAldvP0iNa4dWEE4BPNY/edit?usp=sharing

Below is an image of the plot that is created from the "CODE" file

The second graph showcases the plot that is created from the "RESPONSE" file, as stated above.

Schematics

Code

// This #include statement was automatically added by the Particle IDE.
#include <Keypad_Particle.h>

int speakerPin = D8; 
int invalidcount=12;
int currentposition=0;



int accessgranted = 0;

char* password="22B8";

const byte rows=4;
const byte cols=4;
 
char key[rows][cols]={
{'1','2','3', 'A'},
{'4','5','6', 'B'},
{'7','8','9', 'C'},
{'*','0','#', 'D'}
};

byte rowPins[rows]={D7, D6, D5, D4};
byte colPins[cols]={D3, D9, D1, D0};

Keypad keypad= Keypad(makeKeymap(key),rowPins,colPins,rows,cols);

 
void setup()
{
pinMode(A5, INPUT);
pinMode(A4, INPUT);
pinMode(A3, INPUT);
pinMode(D9, OUTPUT);
pinMode(A2, OUTPUT);
pinMode(D8, OUTPUT);
pinMode(D10, OUTPUT);
pinMode(D11, OUTPUT);
pinMode(D12, OUTPUT);
pinMode(D13, INPUT_PULLUP);

  Particle.subscribe("RESPONSE", myHandler, MY_DEVICES);

pinMode(speakerPin, OUTPUT);
Serial.begin(9600);
}
 
void loop()
{
   
    accessgranted = 0;

    char code=keypad.getKey();
    if(code!=NO_KEY)
    {

        for(int l=0; l<=currentposition; l++)
        {
        }
        if (code==password[currentposition])
        {
            tone(speakerPin, 3000, 25);
            delay(50);
            noTone(speakerPin);
            ++currentposition;
            if(currentposition == 4)
            {
                unlockdoor();
                currentposition=0;
                
                
                
                
 
            }
 
        }
        else if (code!=password[currentposition] && code == password[0])
        {
            tone(speakerPin, 3000, 25);
            delay(50);
            noTone(speakerPin);
            currentposition = 1;
        }
        else
        {
            ++invalidcount;
            incorrect();
            currentposition=0;
            Particle.publish("CODE", "INCORRECT", PRIVATE);
 
        }
    }
     
   
    
    
}

//********OPEN THE DOOR FUNCTION!!!!***********//
 
void unlockdoor()
{
   
   // unlockbuzz();
    Particle.publish("CODE", "CORRECT" , PRIVATE);
   // accessgranted = 1;
    delay(500);
    ///countdownbuzz();
    
    currentposition = 0;
   // accessgranted = 0;
}
 
//************WRONG CODE FUNCTION********//
 
void incorrect()
{
    tone(speakerPin, 3000, 25);
    delay(50);
    noTone(speakerPin);
}

//**************KEYPRESS********************//
/*void keypress()
{
 
 

tone(speakerPin, 3000, 25);
delay(50);
noTone(speakerPin);
}*/
//**********UNLOCK BUZZ*************//
void unlockbuzz()
{
 
tone(speakerPin, 3000, 25);
delay(80);
noTone(speakerPin);
delay(80);
tone(speakerPin, 3000, 25);
delay(200);
noTone(speakerPin);
delay(80);
tone(speakerPin, 3000, 25);
delay(80);
noTone(speakerPin);
delay(80);
tone(speakerPin, 3000, 25);
delay(80);
noTone(speakerPin);
delay(80);
}


//**********INVALID ACCESS*************//
void invalidbuzz ()
{
    tone(speakerPin, 3000, 25);
    delay(75);
    tone(speakerPin, 3000, 25);
    delay(50);
    
   /* tone(speakerPin, 3000, 25);
    delay(500);
    tone(speakerPin, 3000, 25);
    delay(500);
    tone(speakerPin, 3000, 25);
    delay(500);
    */
}

//**********Countdown Buzz*************//
void countdownbuzz ()
 { 
    for (int u = 0; u < 5; u++) 
    {
        tone(speakerPin, 3000, 25);
        delay(990);
        noTone(speakerPin);
        delay(10);  
    }
    
    for (int i = 0; i < 10; i++) 
    {
        tone(speakerPin, 3000, 25);
        delay(490);
        noTone(speakerPin);
        delay(10);  
    }
    
    for (int l = 0; l < 10; l++) 
    {
        tone(speakerPin, 3000, 25);
        delay(240);
        noTone(speakerPin);
        delay(10);  
    }
    
    for (int j = 0; j < 10; j++) 
    {
        tone(speakerPin, 3000, 25);
        delay(115);
        noTone(speakerPin);
        delay(10);  
    }
    
    for (int k = 0; k < 20; k++) 
    {
        tone(speakerPin, 3000, 25);
        delay(52.5);
        noTone(speakerPin);
        delay(10);  
    }
    
    tone(speakerPin, 4000, 25);
    delay(1000);
    noTone(speakerPin);
}

void myHandler(const char *event, const char *data)
{
     if (strcmp(data,"INVALID")==0){
       invalidbuzz();
        }
        
    else if (strcmp(data,"VALID")==0){
       countdownbuzz();
        Particle.publish("CODE", "TIMESUP" , PRIVATE);
        }
}

int reed_switch = D13;
int val = 0;
int accessgranted = 0;
int red_light_pin = D10;
int green_light_pin = D11;
int blue_light_pin = D12;

void setup() {
pinMode(reed_switch, INPUT_PULLUP);
pinMode(D10, OUTPUT);
pinMode(D11, OUTPUT);
pinMode(D12, OUTPUT);

Particle.subscribe("CODE", myHandler, MY_DEVICES);
}



void myHandler(const char *event, const char *data)
{
if (strcmp(data,"CORRECT")==0){
        accessgranted = 1;

 }
 if (strcmp(data,"TIMESUP")==0){
        accessgranted = 0;


  
   
    accessgranted = 0;
 }
 
}
void RGB_color(int red_light_value, int green_light_value, int blue_light_value)
{
digitalWrite(red_light_pin, red_light_value);
digitalWrite(green_light_pin, green_light_value);
digitalWrite(blue_light_pin, blue_light_value);
}

void loop() {

val = digitalRead(reed_switch);

if (val == HIGH && accessgranted == 0)
    {
       RGB_color(255,0,0);
       delay(50);
       RGB_color(0,0,0);
        Particle.publish("RESPONSE", "INVALID", PRIVATE);
        delay(1000);
        
    }
    else if (val == HIGH && accessgranted == 1)
    {
        RGB_color(0,255,255);
        delay(50);
        RGB_color(0,0,0);
        Particle.publish("RESPONSE", "VALID", PRIVATE);
        delay(20000);
       
    }

}

Credits

Noah Cowen

1 project • 1 follower

Contact

Accountability Boxes