TimeLock Box

Proiectul constă într-o cutie inteligentă cu închidere mecanică, destinată depozitării telefonului sau a altor obiecte în timpul unei sesiuni de lucru. Utilizatorul selectează o durată de blocare, iar dispozitivul blochează capacul folosind un servomotor. Deblocarea se poate face doar după expirarea timpului setat sau prin introducerea unei combinații rotative.

Proiectul este gândit ca un sistem fizic de limitare a accesului la obiecte care pot distrage atenția, în special telefonul. Spre deosebire de o aplicație software de productivitate, TimeLock Box obligă utilizatorul să își respecte intervalul de lucru printr-o blocare mecanică reală. Sistemul afișează starea curentă pe un LCD și semnalizează vizual sau acustic evenimentele importante.

Componentele principale ale proiectului sunt vizibile în schema bloc de mai jos. Placa ATmega328P Xplained Mini este blocul central al sistemului: citește intrările utilizatorului, actualizează afișajul și comandă mecanismul de blocare.

Encoderul de timp este folosit pentru alegerea duratei de blocare, iar encoderul de cod este folosit pentru introducerea combinației de deblocare. LCD-ul comunică prin I2C și afișează starea sistemului. Servomotorul SG90 este comandat prin PWM și acționează zăvorul mecanic. Microswitch-ul detectează ridicarea capacului, iar buzzerul și LED-urile oferă feedback acustic și vizual. Servo-ul este alimentat separat la 5V, cu masă comună cu restul sistemului.

Schema electrică a proiectului este realizată în KiCad și este atașată mai jos. Pentru lizibilitate, conexiunile sunt grupate prin etichete de semnal, iar alimentarea servo-ului este separată de alimentarea logică.

În această secțiune voi încărca video-ul realizat în laborator:

• montajul general pe breadboard;
• testul pentru buzzer și LED roșu;
• testul pentru LCD și LED-ul verde.

Firmware-ul este dezvoltat în PlatformIO, folosind framework-ul Arduino pentru microcontrollerul ATmega328P Xplained Mini. Configurația proiectului folosește platforma atmelavr, placa custom atmega328p_xplained_mini și frecvența de lucru de 16 MHz.

• Arduino.h - funcționalități de bază Arduino: setup(), loop(), millis(), digitalRead(), pinMode(), tone().
• Wire.h - comunicația I2C/TWI folosită de LCD.
• LiquidCrystal_I2C.h - afișarea meniurilor, codului și timpului rămas pe LCD 1602.
• Servo.h - generarea semnalului PWM pentru servomotorul SG90 care acționează zăvorul.
• avr/io.h - acces direct la registre AVR pentru LED-uri, prin DDRC și PORTC.

Proiectul implementează un TimeLock Box cu două encodere rotative separate: unul pentru alegerea timpului de blocare și unul pentru setarea/introducerea codului. Codul de deblocare este setat direct din hardware la începutul sesiunii, fără a fi recompilat firmware-ul și fără cod de deblocare hardcodat în firmware. În plus, cutia are un sistem de alarmă folosind microswitch-ul, care detectează deschiderea capacului cât timp seiful este blocat.

• GPIO - citire butoane encoder, microswitch capac, comandă LED-uri.
• Întreruperi externe - citirea encoderului pentru cod folosind pinii PD2 și PD3.
• Timere / PWM - semnalul pentru servomotor și semnalele sonore pentru buzzer.
• I2C / TWI - comunicația cu LCD-ul 1602 prin adaptorul I2C.
• USART - serialul este folosit pentru debug în timpul testării.

Logica este organizată ca o mașină de stări:

enum SafeState {
  SET_CODE,
  SET_TIME,
  LOCKED,
  ENTER_CODE,
  ALARM
};

Stările principale sunt:

• SET_CODE - utilizatorul alege codul de sesiune folosind encoderul de cod;
• SET_TIME - utilizatorul alege durata de blocare folosind encoderul de timp;
• LOCKED - servo-ul ține zăvorul închis, LED-ul roșu este aprins și cronometrul scade;
• ENTER_CODE - utilizatorul introduce codul pentru deblocare sau pentru oprirea alarmei;
• ALARM - microswitch-ul a detectat capacul ridicat cât timp seiful era blocat.

Pe lângă aceste stări există variabile de control pentru starea fizică a seifului:

bool safe_locked = false;
bool alarm_active = false;
long remaining_seconds = 0;
int session_code[3] = {0, 0, 0};

În funcția setup() se inițializează LCD-ul, encoderele, microswitch-ul, buzzerul, LED-urile, servomotorul și comunicația serială. LED-ul verde este aprins la pornire, iar servo-ul este poziționat în starea de zăvor deschis.

În funcția loop() se execută următorii pași:

• se verifică microswitch-ul; dacă seiful este blocat și capacul este ridicat, se activează alarma;
• în starea de alarmă, codul poate fi introdus doar după ce capacul revine închis;
• dacă seiful este blocat, cronometrul este actualizat cu millis(), fără delay() pentru scurgerea timpului;
• timpul continuă să scadă inclusiv în starea ENTER_CODE;
• encoderul de timp modifică durata în trepte de 5 minute;
• encoderul de cod modifică cifra curentă între 0 și 9;
• apăsarea butonului encoderului de cod confirmă cifra curentă;
• la introducerea celor 3 cifre, codul este comparat cu session_code;
• dacă acest cod este corect, servo-ul retrage zăvorul, LED-ul verde se aprinde și sesiunea se resetează;
• dacă timpul expiră natural, seiful se deblochează automat și revine la setarea unui cod nou.

Pentru a reduce problemele de bouncing și citirile greșite ale encoderelor, afișajul LCD nu este redesenat continuu. Se folosește un flag de refresh, astfel încât LCD-ul este actualizat doar când se schimbă o valoare sau o stare:

bool screen_dirty = true;
 
// exemplu: după rotirea encoderului
current_digit++;
screen_dirty = true;

#define CODE_CLK_PIN 2    // PD2
#define CODE_DT_PIN 3     // PD3
#define CODE_SW_PIN 4     // PD4
 
#define TIME_CLK_PIN 5    // PD5
#define TIME_DT_PIN 6     // PD6
#define TIME_SW_PIN 7     // PD7
 
#define BUZZER_PIN 8       // PB0
#define SERVO_PIN 9        // PB1
#define DOOR_SWITCH_PIN 10 // PB2

LED-urile sunt controlate direct prin registre:

DDRC |= (1 << PC0) | (1 << PC1); // PC0 roșu, PC1 verde
 
void stareDeschis_LED() {
  PORTC |= (1 << PC1);
  PORTC &= ~(1 << PC0);
}
 
void stareInchis_LED() {
  PORTC |= (1 << PC0);
  PORTC &= ~(1 << PC1);
}

Microswitch-ul și butoanele encoderelor sunt configurate cu rezistențele interne de pull-up. Astfel, apăsarea butonului sau închiderea microswitch-ului produce nivel logic LOW.

pinMode(DOOR_SWITCH_PIN, INPUT_PULLUP);
pinMode(CODE_SW_PIN, INPUT_PULLUP);
pinMode(TIME_SW_PIN, INPUT_PULLUP);

Encoderul pentru cod este citit prin întreruperi externe pe ambele linii (CLK și DT). Tranzițiile sunt decodate cu un tabel de cuadratură, ceea ce reduce citirile inverse produse de bouncing.

attachInterrupt(digitalPinToInterrupt(CODE_CLK_PIN), code_encoder_interrupt, CHANGE);
attachInterrupt(digitalPinToInterrupt(CODE_DT_PIN), code_encoder_interrupt, CHANGE);

Servomotorul SG90 este controlat prin biblioteca Servo.h. În implementarea curentă, unghiul 0 reprezintă zăvorul retras, iar unghiul 90 reprezintă zăvorul coborât.

Servo lockServo;
 
lockServo.attach(SERVO_PIN);
lockServo.write(0);   // zăvor deschis
lockServo.write(90);  // zăvor închis

Buzzerul este folosit pentru confirmări scurte, erori și alarmă:

void sunaBuzzer(int durata_ms) {
  tone(BUZZER_PIN, 1000);
  delay(durata_ms);
  noTone(BUZZER_PIN);
}

LCD-ul 1602 este inițializat la adresa 0x27 și este folosit pentru afișarea meniului, codului și timpului rămas.

LiquidCrystal_I2C lcd(0x27, 16, 2);
 
lcd.init();
lcd.backlight();
lcd.clear();

Timpul rămas este afișat în format HHh:MMm:SSs, pentru a putea reprezenta inclusiv sesiuni mai lungi de o oră.

Serialul este folosit pentru debug în timpul dezvoltării și testării:

Serial.begin(115200);

• Encoderele KY-040 sunt citite pe front descendent și au debounce software scurt, bazat pe millis().
• LCD-ul este actualizat doar la schimbări de stare sau valoare, pentru a evita lag-ul care poate produce citiri greșite ale encoderelor.
• Pentru encoderul de timp, fiecare pas modifică durata cu 5 minute.
• Butoanele encoderelor au un mic delay de confirmare pentru a evita apăsările multiple.
• Unghiurile servo-ului (0 și 90) pot fi ajustate în funcție de zăvorul mecanic real.
• Servo-ul este alimentat separat la 5V, iar GND-ul sursei servo este comun cu GND-ul plăcii.
• Dacă bouncing-ul mecanic persistă, se pot adăuga condensatori de 100nF între CLK și GND, respectiv între DT și GND pentru fiecare encoder.

Am obținut o cutie care se blochează pe un timp ales din encoder și se deschide doar cu codul setat sau după ce expiră timpul. Pe LCD se afișează timpul rămas, iar dacă ușa este forțată pornește alarma.

Proiectul funcționează cum mi-am propus. Partea cea mai dificilă a fost legarea și calibrarea componentelor, mai ales encoderele și microswitch-ul.

GitHub

Export to PDF