Sistem de computer cu blocare automată: 4 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În acest tutorial vom explora securitatea blocării ecranului computerului. Sistemele de operare au un timeout configurabil care vă va bloca ecranul dacă utilizatorul nu a atins mouse-ul sau tastatura.

De obicei, valoarea implicită este de aproximativ un minut. Dacă urmați acest lucru implicit și lăsați computerul într-un mediu ocupat, cineva ar putea să vă acceseze computerul în acel minut până când ecranul se blochează. Dacă îl setați la câteva secunde, veți obține ecranul de blocare foarte des atunci când nu atingeți tastatura și asta este enervant …

Într-o zi, un coleg de serviciu m-a întrebat dacă pot „remedia” această problemă cu un fel de dispozitiv care blochează computerul atunci când nu este acolo și am luat provocarea:)

Am explorat mai multe opțiuni în capul meu, cum ar fi utilizarea arduino-urilor și un senzor cu termometru în infraroșu, senzorul PIR sau poate folosirea detectării feței pe computer, dar am adoptat o metodă mai simplă:

Vom combina funcționalitatea Arduino Leonardo HID (emulează tastatura) cu un senzor de distanță cu ultrasunete pentru a detecta dacă o persoană folosește computerul, dacă nu, dispozitivul va trimite o combinație de taste prin USB pentru a bloca computerul.

Pasul 1: Componente

Deoarece aceasta este o dovadă a conceptului, vom construi dispozitivul pe o placă de calcul

O să ai nevoie:

1. Arduino Leonardo (este important să folosiți Leonardo, deoarece poate emula tastatura)

2. Senzor de distanță cu ultrasunete HC-SR04

3. 2 x 10 K rezistențe variabile

4. breadboard, fire de breadboard

5. Cablu USB

6. Afișaj OLED (https://www.adafruit.com/product/931)

Pasul 2: Asamblare și încărcare

Mai întâi verificați dacă aveți toate componentele necesare și un IDE Arduino. Voi merge pe scurt la pașii de conectare și puteți oricând să aruncați o privire pe schema fritzing atașată

Asamblare

1. Puneți Leonardo pe panou și țineți-l în poziție cu o bandă de cauciuc

2. puneți cele două rezistențe variabile, afișajul OLED și senzorul cu ultrasunete pe panou

3. conectați terenurile și vcc-urile

4. conectați pinii din mijloc ai rezistențelor la arduino A0 și A1

5. conectați SDA și SCL ale afișajului la SDA și SCL marcate pe Leonardo

6. conectați declanșatorul și pinul de ecou al senzorului cu ultrasunete la 12, 13 pini digitali ai Leonardo

7. conectați USB-ul la computer

Încărcați

În primul rând va trebui să descărcați și să instalați bibliotecile arduino necesare:

1. Biblioteca GOFi2cOLED:

2. Biblioteca cu ultrasunete-HC-SR04:

Dacă nu știți cum să instalați bibliotecile arduino, consultați acest tutorial.

După ce ați descărcat și instalat bibliotecile de mai sus, puteți clona sau descărca depozitul meu arduino situat aici: https://github.com/danionescu0/arduino și vom folosi această schiță: https://github.com/danionescu0 / arduino / tree / master …

Sau puteți copia și lipi codul de mai jos:

/ * * Biblioteci utilizate de acest proiect: * * GOFi2cOLED: https://github.com/hramrach/GOFi2cOLED * Ultrasonic-HC-SR04: https://github.com/JRodrigoTech/Ultrasonic-HC-SR04 * / #include "Keyboard.h" #include "Wire.h" #include "GOFi2cOLED.h" #include "Ultrasonic.h"

GOFi2cOLED GOFoled;

Ultrasunete cu ultrasunete (12, 13);

const byte distancePot = A0;

const byte timerPot = A1; const float percentMaxDistanceChangedAllowed = 25; int actualDistanță; nesemnat lung maxDistanceDetectionTime; bool lockTimerStarted = false;

configurare nulă ()

{Serial.begin (9600); Keyboard.begin (); initializeDisplay (); }

bucla nulă ()

{clearDisplay (); actualDistanță = getActualDistance (); writeStatusData (); doDisplay (); if (! lockTimerStarted && shouldEnableLockTimer ()) {lockTimerStarted = true; maxDistanceDetectionTime = millis (); Serial.println ("blocarea temporizatorului începe"); } else if (! shouldEnableLockTimer ()) {Serial.println ("timer blocare dezactivat"); lockTimerStarted = false; } if (shouldLockScreen ()) {lockScreen (); Serial.println („Ecran de blocare”); } întârziere (100); }

bool shouldLockScreen ()

{return lockTimerStarted && (millis () - maxDistanceDetectionTime) / 1000> getTimer (); }

bool shouldEnableLockTimer ()

{int allowDistance = percentMaxDistanceChangedAllowed / 100 * getDistance (); return getTimer ()> 1 && getDistance ()> 1 && actualDistance - getDistance ()> permitDistance; }

void writeStatusData ()

{setDisplayText (1, "MinDistance:", String (getDistance ())); setDisplayText (1, "Timer:", String (getTimer ())); setDisplayText (1, "ActualDistance:", String (actualDistance)); int countDown = getTimer () - (millis () - maxDistanceDetectionTime) / 1000; String message = ""; if (shouldLockScreen ()) {message = "blocare trimisă"; } else if (shouldEnableLockTimer () && countDown> = 0) {message = ".." + String (countDown); } else {message = "nu"; } setDisplayText (1, "Blocare:", mesaj); }

void initializeDisplay ()

{GOFoled.init (0x3C); GOFoled.clearDisplay (); GOFoled.setCursor (0, 0); }

void setDisplayText (octet font Size, String label, String data)

{GOFoled.setTextSize (fontSize); GOFoled.println (etichetă + ":" + date); }

void doDisplay ()

{GOFoled.display (); }

void clearDisplay ()

{GOFoled.clearDisplay (); GOFoled.setCursor (0, 0); }

int getActualDistance ()

{int distanceSum = 0; for (octet i = 0; i <10; i ++) {distanceSum + = ultrasonic. Ranging (CM); }

retur Suma / 10;

}

int getDistance ()

{return map (analogRead (timerPot), 0, 1024, 0, 200); }

int getTimer ()

{return map (analogRead (distancePot), 0, 1024, 0, 20); }

void lockScreen ()

{Serial.println („apăsare”); Keyboard.press (KEY_LEFT_CTRL); întârziere (10); Keyboard.press (KEY_LEFT_ALT); întârziere (10); Keyboard.write ('l'); întârziere (10); Keyboard.releaseAll (); }

În cele din urmă, conectați arduino la computer utilizând cablul USB și încărcați schița în arduino.

Pasul 3: Utilizarea dispozitivului

Când arduino-ul este conectat la computer, acesta va monitoriza continuu distanța în fața senzorului și va trimite o combinație de taste de blocare a ecranului la computer dacă distanța crește.

Dispozitivul are câteva configurații:

1. Distanța normală, distanța poate fi configurată folosind rezistorul variabil conectat la A0. Distanța este afișată și pe OLED. Când distanța va crește cu 25% față de cea setată, va începe numărătoarea inversă

2. Timeout (numărătoare inversă). Timpul de expirare în secunde este, de asemenea, configurabil de la rezistorul conectat la A1. Când expiră expirarea, comanda de blocare va fi trimisă

3. Blocați combinația de taste. Combinația de taste de blocare implicită este configurată să funcționeze pentru Ubuntu Linux 18 (CTRL + ALT + L). Pentru a schimba combinația, trebuie să vă modificați schița în funcție de sistemul dvs. de operare:

4. Timeout și protecție la distanță. Deoarece acesta este un dispozitiv care emulează tastatura, este o idee bună să aveți un mecanism de dezactivare a funcționalității tastaturii. În schița mea, am ales ca expirarea și distanța să fie mai mari decât „1”. (puteți modifica acest lucru în cod dacă doriți)

Localizați și modificați funcția „lockScreen ()”

void lockScreen () {Serial.println ("apăsând"); Keyboard.press (KEY_LEFT_CTRL); întârziere (10); Keyboard.press (KEY_LEFT_ALT); întârziere (10); Keyboard.write ('l'); întârziere (10); Keyboard.releaseAll (); }

Pentru o listă completă a cheilor speciale arduino, verificați aici:

Pasul 4: Alte abordări

Înainte de această implementare, am luat în considerare și alte implementări:

1. Termometru cu infraroșu (MLX90614 https://www.sparkfun.com/products/10740). Un termometru cu infraroșu este un dispozitiv care măsoară temperatura analizând radiațiile infraroșii emise de un obiect la distanță. Am avut unul în jur și m-am gândit că poate detectez diferența de temperatură în fața computerului.

L-am conectat, dar diferența de temperatură a fost foarte mică (când eram în față sau nu) 1-2 grade și am crezut că nu poate fi atât de fiabil

2. Senzor PIR. (https://www.sparkfun.com/products/13285) Acești senzori ieftini sunt comercializați ca „senzori de mișcare”, dar detectează într-adevăr modificările radiației infraroșii, astfel încât, teoretic, ar putea funcționa, atunci când o persoană părăsește computerul, senzorul ar detecta că.. De asemenea, acești senzori au un buton de expirare și sensibilitate. Așa că am conectat unul și m-am jucat cu el, dar se pare că senzorul nu este făcut pentru o gamă apropiată (are un unghi larg), a dat tot felul de alerte false.

3. Detectarea feței folosind camera web. Această opțiune mi s-a părut foarte interesantă, întrucât m-am jucat cu acest câmp de computer în celelalte proiecte ale mele precum: https://github.com/danionescu0/robot-camera-platfo… și https://github.com/danionescu0/image-processing- relatii cu publicul…

Aceasta a fost o bucată de tort! Dar au existat unele dezavantaje: camera laptopului nu putea fi utilizată în alte scopuri atunci când programul rulează și ar fi necesare anumite resurse pentru computer. Așa că am renunțat și la această idee.

Dacă aveți mai multe idei despre cum s-ar putea face acest lucru, vă rugăm să le împărtășiți, mulțumesc!