Sistema informático de bloqueo automático: 4 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

En este tutorial vamos a explorar la seguridad del bloqueo de pantalla de la computadora. Los sistemas operativos tienen un tiempo de espera configurable que bloqueará su pantalla si el usuario no ha tocado el mouse o el teclado.

Por lo general, el valor predeterminado es de alrededor de un minuto. Si sigue este valor predeterminado y deja su computadora en un entorno ajetreado, alguien podría acceder a su computadora en ese minuto hasta que la pantalla se bloquee. Si lo configura en unos segundos, obtendrá la pantalla de bloqueo muy a menudo cuando no esté tocando el teclado y eso es molesto …

Un día, un colega de trabajo me preguntó si podía "solucionar" este problema con algún tipo de dispositivo que bloqueara la computadora cuando él no estaba allí, y acepté el desafío:)

He explorado varias opciones en mi cabeza, como usar arduinos y un sensor de termómetro infrarrojo, sensor PIR o tal vez usar la detección de rostros en la computadora, pero me he conformado con un método más simple:

Vamos a combinar la funcionalidad Arduino Leonardo HID (emular teclado) con un sensor de distancia ultrasónico para detectar si una persona está usando la computadora, si no, el dispositivo enviará una combinación de teclas a través de USB para bloquear la computadora.

Paso 1: componentes

Debido a que esta es una prueba de concepto, vamos a construir el dispositivo en una placa de pruebas.

Necesitarás:

1. Arduino Leonardo (es importante usar Leonardo porque puede emular el teclado)

2. Sensor de distancia ultrasónico HC-SR04

3. 2 resistencias variables de 10 K

4. tablero, alambres del tablero

5. cable USB

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

Paso 2: Montaje y carga

Primero verifique si tiene todos los componentes necesarios y un IDE de Arduino. Voy a ir brevemente a los pasos de conexión, y siempre puedes echar un vistazo al esquema de fritzing adjunto.

Montaje

1. Coloque el Leonardo en la placa de pruebas y manténgalo en su lugar con una banda de goma

2. coloque las dos resistencias variables, la pantalla OLED y el sensor ultrasónico en la placa de pruebas

3. conecte las tierras y los vcc

4. conecte los pines del medio de las resistencias al arduino A0 y A1

5. conecte el SDA y SCL de la pantalla al SDA y SCL marcados en el Leonardo

6. conecte el disparador y el pin de eco del sensor ultrasónico a los 12, 13 pines digitales del Leonardo

7. conecte el USB a la computadora

Subir

En primer lugar, deberá descargar e instalar las bibliotecas arduino necesarias:

1. Biblioteca GOFi2cOLED:

2. Biblioteca de Ultrasonic-HC-SR04:

Si no sabe cómo instalar las bibliotecas arduino, consulte este tutorial.

Una vez que haya descargado e instalado las bibliotecas anteriores, puede clonar o descargar mi repositorio de arduino ubicado aquí: https://github.com/danionescu0/arduino, y usaremos este boceto: https://github.com/danionescu0 / arduino / árbol / maestro…

O puede copiar y pegar el código a continuación:

/ * * Bibliotecas utilizadas por este proyecto: * * GOFi2cOLED: https://github.com/hramrach/GOFi2cOLED * Ultrasonic-HC-SR04: https://github.com/JRodrigoTech/Ultrasonic-HC-SR04 * / #include "Keyboard.h" #incluye "Wire.h" #include "GOFi2cOLED.h" #include "Ultrasonic.h"

GOFi2cOLED GOFoled;

Ultrasónico ultrasónico (12, 13);

const byte distancePot = A0;

byte const timerPot = A1; const float percentMaxDistanceChangedAllowed = 25; int actualDistance; unsigned long maxDistanceDetectionTime; bool lockTimerStarted = falso;

configuración vacía ()

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

bucle vacío ()

{clearDisplay (); actualDistance = getActualDistance (); writeStatusData (); doDisplay (); if (! lockTimerStarted && shouldEnableLockTimer ()) {lockTimerStarted = true; maxDistanceDetectionTime = millis (); Serial.println ("inicio del temporizador de bloqueo"); } else if (! shouldEnableLockTimer ()) {Serial.println ("temporizador de bloqueo desactivado"); lockTimerStarted = falso; } if (shouldLockScreen ()) {lockScreen (); Serial.println ("Pantalla de bloqueo"); } retraso (100); }

bool shouldLockScreen ()

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

bool shouldEnableLockTimer ()

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

void writeStatusData ()

{setDisplayText (1, "MinDistance:", String (getDistance ())); setDisplayText (1, "Temporizador:", String (getTimer ())); setDisplayText (1, "ActualDistance:", String (actualDistance)); int countDown = getTimer () - (millis () - maxDistanceDetectionTime) / 1000; Mensaje de cadena = ""; if (shouldLockScreen ()) {mensaje = "bloqueo enviado"; } else if (shouldEnableLockTimer () && countDown> = 0) {message = ".." + String (countDown); } else {mensaje = "no"; } setDisplayText (1, "Bloqueo:", mensaje); }

void initializeDisplay ()

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

void setDisplayText (byte fontSize, etiqueta de cadena, datos de cadena)

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

void doDisplay ()

{GOFoled.display (); }

void clearDisplay ()

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

int getActualDistance ()

{int SumaDistancia = 0; para (byte i = 0; i <10; i ++) {distanciaSuma + = rango ultrasónico (CM); }

return distanceSum / 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 ("presionando"); Keyboard.press (KEY_LEFT_CTRL); retraso (10); Keyboard.press (KEY_LEFT_ALT); retraso (10); Keyboard.write ('l'); retraso (10); Keyboard.releaseAll (); }

Finalmente conecte el arduino a la computadora usando el cable usb y cargue el boceto en el arduino.

Paso 3: uso del dispositivo

Cuando el arduino está conectado a la computadora, monitoreará continuamente la distancia frente al sensor y enviará una combinación de teclas de pantalla de "bloqueo" a la computadora si la distancia aumenta.

El dispositivo tiene algunas configuraciones:

1. Distancia normal, la distancia se puede configurar usando la resistencia variable conectada al A0. La distancia también se muestra en el OLED. Cuando la distancia aumente en un 25% respecto a la establecida, comenzará una cuenta atrás.

2. Tiempo de espera (cuenta atrás). El tiempo de espera en segundos también se puede configurar desde la resistencia conectada al A1. Cuando expire el tiempo de espera, se enviará el comando de bloqueo

3. Bloquear combinación de teclas. La combinación de teclas de bloqueo predeterminada está configurada para funcionar con Ubuntu Linux 18 (CTRL + ALT + L). Para cambiar la combinación, debe modificar su boceto de acuerdo con su sistema operativo:

4. Protección de tiempo de espera y distancia. Debido a que este es un dispositivo que emula el teclado, es una buena idea tener un mecanismo para desactivar la funcionalidad del teclado. En mi boceto, he elegido que el tiempo de espera y la distancia deben ser mayores que "1". (puede modificar eso en el código si lo desea)

Busque y cambie la función "lockScreen ()"

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

Para obtener una lista completa de las claves especiales de arduino, consulte aquí:

Paso 4: otros enfoques

Antes de esta implementación, también he considerado algunas otras implementaciones:

1. Termómetro de infrarrojos (MLX90614 https://www.sparkfun.com/products/10740). Un termómetro infrarrojo es un dispositivo que mide la temperatura analizando las radiaciones infrarrojas emitidas por un objeto a distancia. Tenía uno por ahí y pensé que tal vez podría detectar la diferencia de temperatura frente a la computadora.

Lo conecté, pero la diferencia de temperatura era muy pequeña (cuando estaba al frente o no) 1-2 grados y pensé que no podía ser tan confiable

2. Sensor PIR. (https://www.sparkfun.com/products/13285) Estos sensores baratos se comercializan como "sensores de movimiento", pero realmente detectan cambios en la radiación infrarroja, por lo que, en teoría, podría funcionar, cuando una persona deja la computadora, el sensor los detectaría. eso.. También estos sensores tienen un tiempo de espera integrado y perillas de sensibilidad. Así que conecté uno y jugué con él, pero parece que el sensor no está hecho para un rango cercano (tiene un gran angular), dio todo tipo de falsas alertas.

3. Detección de rostros mediante la cámara web. Esta opción me pareció muy interesante, ya que jugué con este campo informático en mis otros proyectos como: https://github.com/danionescu0/robot-camera-platfo… y https://github.com/danionescu0/image-processing- pr…

¡Esto fue pan comido! Pero había algunos inconvenientes: la cámara de la computadora portátil no se podía usar para otros fines cuando el programa se estaba ejecutando, y se necesitarían algunos recursos de la computadora para eso. Así que también dejé esta idea.

Si tiene más ideas sobre cómo se podría hacer esto, por favor compártalas, ¡gracias!