This code implements a "Smart Safe System" involving multiple functionalities...

June 29, 2025 at 08:37 PM

// --- LIBRARIES ---
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Keypad.h>
#include <Adafruit_Fingerprint.h>
#include <RTClib.h>
#include <PN532_I2C.h>
#include <PN532.h>
#include <SoftwareSerial.h>
#include <WiFiEsp.h>
#include <WiFiEspClient.h>

// --- OLED ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// --- Keypad ---
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {30, 32, 34, 36};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

String inputCode = "";
String password = "1234";

// --- Fingerprint Sensor ---
SoftwareSerial fingerSerial(10, 11); // RX, TX
Adafruit_Fingerprint finger(&fingerSerial);

// --- Vibration Sensor ---
#define VIB_SENSOR 5

// --- Hall Effect Sensor ---
#define HALL_SENSOR 4

// --- RFID (PN532) ---
PN532_I2C pn532_i2c(Wire);
PN532 nfc(pn532_i2c);

// --- RTC ---
RTC_DS3231 rtc;

// --- Lock & Buzzer ---
#define LOCK_PIN 7
#define BUZZER 6

// --- WiFi (ESP-01 via SoftwareSerial) ---
SoftwareSerial espSerial(14, 15); // RX, TX on Mega (use different pins if needed)
WiFiEspClient client;
char ssid[] = "Your_SSID";
char pass[] = "Your_PASSWORD";
String botToken = "Your_BOT_TOKEN";
String chatID = "Your_CHAT_ID";

void sendTelegramMessage(String message) {
  if (client.connect("api.telegram.org", 443)) {
    String url = "/bot" + botToken + "/sendMessage?chat_id=" + chatID + "&text=" + message;
    client.println("GET " + url + " HTTP/1.1");
    client.println("Host: api.telegram.org");
    client.println("Connection: close");
    client.println();
  }
}

void unlockSafe() {
  digitalWrite(LOCK_PIN, LOW);
  sendTelegramMessage("The Safe was Opened!");
  tone(BUZZER, 1000, 200);
  delay(5000);
  digitalWrite(LOCK_PIN, HIGH);
}

void setup() {
  Serial.begin(9600);
  Wire.begin();

  // OLED
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.println("Smart Safe Initializing");
  display.display();

  // Fingerprint
  finger.begin(57600);

  // Sensors
  pinMode(VIB_SENSOR, INPUT);
  pinMode(HALL_SENSOR, INPUT);

  // RFID (PN532)
  nfc.begin();
  uint32_t versiondata = nfc.getFirmwareVersion();
  if (!versiondata) {
    Serial.println("Didn't find PN532 board");
    while (1);
  }
  nfc.SAMConfig();

  // RTC
  rtc.begin();

  // Lock and Buzzer
  pinMode(LOCK_PIN, OUTPUT);
  digitalWrite(LOCK_PIN, HIGH);
  pinMode(BUZZER, OUTPUT);

  // WiFi
  espSerial.begin(9600);
  WiFi.init(&espSerial);
  while (WiFi.status() != WL_CONNECTED) {
    WiFi.begin(ssid, pass);
    delay(500);
  }
  sendTelegramMessage("Smart Safe Online");
}

void loop() {
  // --- Keypad ---
  char key = keypad.getKey();
  if (key) {
    if (key == '#') {
      if (inputCode == password) {
        unlockSafe();
      }
      inputCode = "";
    } else {
      inputCode += key;
    }
  }

  // --- Fingerprint ---
  if (finger.getImage() == FINGERPRINT_OK &&
      finger.image2Tz() == FINGERPRINT_OK &&
      finger.fingerSearch() == FINGERPRINT_OK) {
    unlockSafe();
  }

  // --- Vibration ---
  if (digitalRead(VIB_SENSOR) == HIGH) {
    sendTelegramMessage("Vibration Detected!");
    tone(BUZZER, 1000, 300);
  }

  // --- Hall Sensor ---
  if (digitalRead(HALL_SENSOR) == LOW) {
    Serial.println("Safe is closed.");
  } else {
    Serial.println("Safe is open!");
  }

  // --- RFID ---
  uint8_t success;
  uint8_t uid[7];
  uint8_t uidLength;
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
  if (success) {
    unlockSafe();
    delay(1000);
  }
}

This code implements a "Smart Safe System" involving multiple functionalities using various hardware components such as an OLED for display, a keypad for input, a fingerprint sensor, a vibration sensor, a hall effect sensor, RFID, a WiFi-enabled alert system (via Telegram), and a relay-controlled lock mechanism. Here's a breakdown of what the code does:

1. Initialization (`setup` method):

OLED Display: Displays an initialization message "Smart Safe Initializing".
Fingerprint Sensor: Sets up communication with a fingerprint sensor to authenticate users.
Sensors:
- Vibration Sensor: Monitors for vibrations (e.g., tampering attempts).
- Hall Sensor: Detects whether the safe door is open or closed.
RFID: Configures and initializes the PN532 RFID module for reading card/tag IDs.
RTC (Real-Time Clock): Sets up the DS3231 real-time clock module, though it is not actively used in this context.
WiFi: Initializes an ESP-01 WiFi module to connect to a wireless network and send alerts via Telegram.
Buzzer & Lock: Configures the lock and buzzer pins.

The system also sends a Telegram alert ("Smart Safe Online") upon successfully starting up.

2. Main Functionality (`loop` method):

The loop method constantly monitors different inputs and executes appropriate actions based on certain conditions:

a) Keypad Input:

Users can input a numeric code using the keypad.
Pressing # signals the system to check whether the entered code matches a predefined password (1234 by default).
If the code matches, the safe unlocks via the unlockSafe function and sends a Telegram alert ("The Safe was Opened!").

b) Fingerprint Authentication:

The system continuously checks whether a valid fingerprint is scanned. If a recognized fingerprint is detected, the safe is unlocked using the unlockSafe function.

c) Vibration Sensor:

If vibration is detected (potentially indicating tampering), the system:
- Sends a Telegram alert ("Vibration Detected!").
- Activates the buzzer for 300 milliseconds to signal abnormal activity.

d) Hall Sensor:

Detects whether the safe door is open or closed. It prints the status ("Safe is closed" or "Safe is open") to the serial monitor for debugging.

e) RFID Authentication:

Checks for RFID card or tag authentication. If an RFID tag is successfully read, the safe is unlocked.

3. Support Functions:

a) `unlockSafe`:

Unlocks the safe by activating the lock pin (controlled by a relay or similar device).
Sends a Telegram notification ("The Safe was Opened!").
Sounds the buzzer for 200 milliseconds.
Keeps the lock open for 5 seconds before re-locking the safe.

b) `sendTelegramMessage`:

Sends a message to a specified Telegram chat using an HTTP GET request to the Telegram Bot API.
Used to send notifications like "The Safe was Opened!" or "Vibration Detected!" to the user.

4. Hardware and Protocols Used:

OLED Display: Provides visual feedback (e.g., initialization messages).
Keypad: Allows password input.
Fingerprint Sensor: Fingerprint-based user authentication.
Vibration Sensor: Detects tampering by monitoring vibrations.
Hall Sensor: Monitors the open/closed state of the safe.
RFID (PN532): Allows access via RFID cards or tags.
ESP-01 WiFi Module: Sends alerts via Telegram.
RTC (DS3231): Provides real-time clock functionality (though not used in the current logic).
Buzzer: Signals events like unlocking or tampering.
Relay-Controlled Lock: Controls the locking mechanism of the safe.

Summary:

This code creates a comprehensive smart safe system that supports multiple authentication methods (keypad, fingerprint, and RFID) and integrates security features like vibration detection and door monitoring. It also notifies the user of key events via Telegram alerts. This ensures robust security and user awareness of safe activities.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr