Sistema informàtic de bloqueig automàtic: 4 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

En aquest tutorial explorarem la seguretat del bloqueig de pantalla de l'ordinador. Els sistemes operatius tenen un temps d’espera configurable que bloquejarà la pantalla si l’usuari no ha tocat el ratolí o el teclat.

Normalment, el valor per defecte és d’uns minuts. Si seguiu aquest valor predeterminat i deixeu l'ordinador en un entorn ocupat, algú pot accedir a l'ordinador en aquest minut fins que es bloquegi la pantalla. Si el configureu a uns quants segons, obtindreu la pantalla de bloqueig molt sovint quan no toqueu el teclat i això és molest …

Un dia, un company de feina em va preguntar si puc "solucionar" aquest problema per algun tipus de dispositiu que bloqueja l'ordinador quan no hi és, i vaig assumir el repte:)

He explorat diverses opcions al cap, com ara utilitzar arduinos i un sensor de termòmetre d’infrarojos, un sensor PIR o potser fer servir la detecció de cares a l’ordinador, però he adoptat un mètode més senzill:

Combinarem la funcionalitat Arduino Leonardo HID (emulació del teclat) amb un sensor de distància ultrasònic per detectar si una persona utilitza l’ordinador, si no, el dispositiu enviarà una combinació de tecles mitjançant USB per bloquejar l’ordinador.

Pas 1: components

Com que aquesta és una prova de concepte, anem a construir el dispositiu en una taula de treball

Necessitareu:

1. Arduino Leonardo (és important utilitzar Leonardo perquè pot emular el teclat)

2. Sensor de distància ultrasònic HC-SR04

3. 2 x 10 K resistències variables

4. taulers de fil, cables de taulers de taula

5. Cable USB

6. Pantalla OLED (https://www.adafruit.com/product/931)

Pas 2: Muntatge i càrrega

Primer comproveu si teniu tots els components necessaris i un IDE Arduino. Aniré breument als passos de connexió i sempre podeu fer una ullada a l’esquema de fritzing adjunt

muntatge

1. Poseu el Leonardo a la pissarra i manteniu-lo al lloc amb una goma

2. col·loqueu les dues resistències variables, la pantalla OLED i el sensor d'ultrasons a la placa de suport

3. connecteu els terrenys i els vcc

4. connecteu els pins centrals de les resistències a l’arduino A0 i A1

5. connecteu l'SDA i SCL de la pantalla a l'SDA i SCL marcats al Leonardo

6. connecteu el disparador i el pin de ressò del sensor d'ultrasons als 12, 13 pins digitals del Leonardo

7. connecteu l'USB a l'ordinador

Pujar

Primer de tot, haureu de descarregar i instal·lar les biblioteques arduino necessàries:

1. Biblioteca GOFi2cOLED:

2. Biblioteca Ultrasonic-HC-SR04:

Si no sabeu com instal·lar biblioteques arduino, consulteu aquest tutorial.

Després de descarregar i instal·lar les biblioteques anteriors, podeu clonar o descarregar el meu dipòsit arduino ubicat aquí: https://github.com/danionescu0/arduino i utilitzarem aquest esbós: https://github.com/danionescu0 / arduino / tree / master …

O bé podeu copiar i enganxar el codi següent:

/ * * Biblioteques utilitzades per aquest projecte: * * 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;

Ultrasons ultrasònics (12, 13);

byte constant distancePot = A0;

const byte timerPot = A1; const float percentMaxDistanceChangedAllowed = 25; int actualDistància; sense signar llarg maxDistanceDetectionTime; bool lockTimerStarted = fals;

configuració nul·la ()

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

bucle buit ()

{clearDisplay (); actualDistància = getActualDistance (); writeStatusData (); doDisplay (); if (! lockTimerStarted && shouldEnableLockTimer ()) {lockTimerStarted = true; maxDistanceDetectionTime = millis (); Serial.println ("inici del temporitzador de bloqueig"); } else if (! shouldEnableLockTimer ()) {Serial.println ("temporitzador de bloqueig desactivat"); lockTimerStarted = fals; } if (shouldLockScreen ()) {lockScreen (); Serial.println ("Pantalla de bloqueig"); } retard (100); }

bool shouldLockScreen ()

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

bool shouldEnableLockTimer ()

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

void writeStatusData ()

{setDisplayText (1, "MinDistance:", String (getDistance ())); setDisplayText (1, "Temporitzador:", String (getTimer ())); setDisplayText (1, "ActualDistance:", String (actualDistance)); int countDown = getTimer () - (millis () - maxDistanceDetectionTime) / 1000; Missatge de cadena = ""; if (shouldLockScreen ()) {message = "bloqueig enviat"; } else if (shouldEnableLockTimer () && countDown> = 0) {message = ".." + String (countDown); } else {message = "no"; } setDisplayText (1, "Bloqueig:", missatge); }

void initializeDisplay ()

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

void setDisplayText (font de mida de byte, etiqueta de cadena, dades de cadena)

{GOFoled.setTextSize (fontSize); GOFoled.println (etiqueta + ":" + dades); }

void doDisplay ()

{GOFoled.display (); }

void clearDisplay ()

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

int getActualDistance ()

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

distància de retorn Suma / 10;

}

int getDistance ()

{retorn mapa (analogRead (timerPot), 0, 1024, 0, 200); }

int getTimer ()

{mapa de retorn (analogRead (distancePot), 0, 1024, 0, 20); }

void lockScreen ()

{Serial.println ("prement"); Keyboard.press (KEY_LEFT_CTRL); retard (10); Keyboard.press (KEY_LEFT_ALT); retard (10); Keyboard.write ('l'); retard (10); Keyboard.releaseAll (); }

Finalment, connecteu l’arduino a l’ordinador mitjançant el cable USB i pengeu l’esbós a l’arduino.

Pas 3: utilitzar el dispositiu

Quan l'arduino estigui connectat a l'ordinador, supervisarà contínuament la distància davant del sensor i enviarà una combinació de tecles de pantalla de "bloqueig" a l'ordinador si augmenta la distància.

El dispositiu té algunes configuracions:

1. Distància normal, la distància es pot configurar mitjançant la resistència variable connectada a l'A0. La distància també es mostra a l'OLED. Quan la distància augmentarà amb un 25% de la que s'estableix, començarà el compte enrere

2. Temps d'espera (compte enrere). El temps d'espera en segons també es pot configurar des de la resistència connectada a l'A1. Quan el temps d'espera expiri, s'enviarà l'ordre de bloqueig

3. Combinació de tecles de bloqueig. La combinació de tecles de bloqueig per defecte està configurada per funcionar a Ubuntu Linux 18 (CTRL + ALT + L). Per canviar la combinació, heu de modificar l'esbós segons el vostre sistema operatiu:

4. Temps d'espera i protecció a distància. Com que es tracta d'un dispositiu que emula el teclat, és una bona idea tenir un mecanisme per desactivar la funcionalitat del teclat. Al meu esbós he escollit que el temps d'espera i la distància han de ser superiors a "1". (podeu modificar-ho al codi si voleu)

Localitzeu i canvieu la funció "lockScreen ()"

void lockScreen () {Serial.println ("prement"); Keyboard.press (KEY_LEFT_CTRL); retard (10); Keyboard.press (KEY_LEFT_ALT); retard (10); Keyboard.write ('l'); retard (10); Keyboard.releaseAll (); }

Per obtenir una llista completa de claus especials arduino, consulteu aquí:

Pas 4: altres enfocaments

Abans d'aquesta implementació, també he tingut en compte algunes altres implementacions:

1. Termòmetre d’infrarojos (MLX90614 https://www.sparkfun.com/products/10740). Un termòmetre d’infrarojos és un dispositiu que mesura la temperatura mitjançant l’anàlisi de les radiacions d’infrarojos emeses per un objecte a distància. Jo en tenia un i vaig pensar que potser podia detectar la diferència de temperatura davant de l’ordinador.

Ho he connectat, però la diferència de temperatura era molt petita (quan estava al davant o no) 1-2 graus i vaig pensar que no podia ser tan fiable

2. Sensor PIR. (https://www.sparkfun.com/products/13285) Aquests sensors barats es comercialitzen com a "sensors de moviment", però realment detecten canvis en la radiació infraroja, de manera que en teoria podria funcionar quan una persona surt de l'ordinador. això.. A més, aquests sensors tenen un control del temps d'espera i dels comandaments de sensibilitat. Així que n’he enganxat un i hi he jugat, però sembla que el sensor no està fet per a un abast proper (té un gran angle), donava tot tipus de falses alertes.

3. Detecció de cares mitjançant la càmera web. Aquesta opció semblava molt interessant, ja que jugava amb aquest camp informàtic en els meus altres projectes com: https://github.com/danionescu0/robot-camera-platfo… i https://github.com/danionescu0/image-processing- pr …

Això era un tros de pastís! Però hi havia alguns inconvenients: la càmera de l'ordinador portàtil no es podia utilitzar per a altres propòsits quan s'executava el programa i es necessitarien recursos informàtics per a això. Així que també he abandonat aquesta idea.

Si teniu més idees sobre com es podria fer, compartiu-les, gràcies!