Sistema de bloqueio automático do computador: 4 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Neste tutorial, vamos explorar a segurança do bloqueio de tela do computador. Os sistemas operacionais têm um tempo limite configurável que bloqueará sua tela se o usuário não tiver tocado no mouse ou no teclado.

Normalmente, o padrão é cerca de um minuto. Se você seguir este padrão e deixar seu computador em um ambiente ocupado, alguém pode acessar seu computador naquele minuto até que a tela bloqueie. Se você configurá-lo para alguns segundos, obterá a tela de bloqueio muitas vezes quando não estiver tocando o teclado e isso é irritante …

Um dia, um colega de trabalho me perguntou se eu posso "consertar" esse problema com algum tipo de dispositivo que bloqueia o computador quando ele não está lá, e aceitei o desafio:)

Já explorei várias opções na minha cabeça, como usar arduinos e um sensor termômetro infravermelho, sensor PIR ou talvez usar a detecção de rosto no computador, mas optei por um método mais simples:

Vamos combinar a funcionalidade Arduino Leonardo HID (emular teclado) com um sensor de distância ultrassônico para detectar se uma pessoa está usando o computador, caso contrário, o dispositivo enviará uma combinação de teclas via USB para bloquear o computador.

Etapa 1: Componentes

Como esta é uma prova de conceito, vamos construir o dispositivo em uma placa de ensaio

Você precisará:

1. Arduino Leonardo (é importante usar o Leonardo porque ele pode emular teclado)

2. Sensor de distância ultrassônico HC-SR04

3. 2 x 10 K resistores variáveis

4. placa de ensaio, fios da placa de ensaio

5. cabo USB

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

Etapa 2: Montagem e upload

Primeiro verifique se você tem todos os componentes necessários e um IDE Arduino. Vou rapidamente para as etapas de conexão, e você pode sempre dar uma olhada no esquema fritzing anexo

conjunto

1. Coloque o Leonardo na placa de ensaio e segure-o no lugar com um elástico

2. coloque os dois resistores variáveis, o display OLED e o sensor ultrassônico na placa de ensaio

3. conecte os aterramentos e os VCCs

4. conecte os pinos do meio dos resistores ao arduino A0 e A1

5. conecte o SDA e SCL do monitor ao SDA e SCL marcado no Leonardo

6. conecte o gatilho e o pino de eco do sensor ultrassônico aos 12, 13 pinos digitais do Leonardo

7. conecte o USB ao computador

Envio

Em primeiro lugar, você precisará baixar e instalar as bibliotecas arduino necessárias:

1. Biblioteca GOFi2cOLED:

2. Biblioteca Ultrasonic-HC-SR04:

Se você não sabe como instalar as bibliotecas do Arduino, verifique este tutorial.

Depois de baixar e instalar as bibliotecas acima, você pode clonar ou baixar meu repositório arduino localizado aqui: https://github.com/danionescu0/arduino, e usaremos este esboço: https://github.com/danionescu0 / arduino / tree / master…

Ou você pode copiar e colar o código abaixo:

/ * * Bibliotecas usadas por este projeto: * * 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;

Ultra-sônico ultrassônico (12, 13);

const byte distancePot = A0;

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

void setup ()

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

void loop ()

{clearDisplay (); actualDistance = getActualDistance (); writeStatusData (); doDisplay (); if (! lockTimerStarted && shouldEnableLockTimer ()) {lockTimerStarted = true; maxDistanceDetectionTime = millis (); Serial.println ("início do temporizador de bloqueio"); } else if (! shouldEnableLockTimer ()) {Serial.println ("temporizador de bloqueio desativado"); lockTimerStarted = false; } if (shouldLockScreen ()) {lockScreen (); Serial.println ("Tela de bloqueio"); } atraso (100); }

bool shouldLockScreen ()

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

bool shouldEnableLockTimer ()

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

void writeStatusData ()

{setDisplayText (1, "MinDistance:", String (getDistance ())); setDisplayText (1, "Timer:", String (getTimer ())); setDisplayText (1, "ActualDistance:", String (actualDistance)); int countDown = getTimer () - (millis () - maxDistanceDetectionTime) / 1000; String mensagem = ""; if (shouldLockScreen ()) {mensagem = "bloqueio enviado"; } else if (shouldEnableLockTimer () && countDown> = 0) {message = ".." + String (countDown); } mais {mensagem = "não"; } setDisplayText (1, "Bloqueio:", mensagem); }

void initializeDisplay ()

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

void setDisplayText (byte fontSize, String label, String data)

{GOFoled.setTextSize (fontSize); GOFoled.println (rótulo + ":" + dados); }

void doDisplay ()

{GOFoled.display (); }

void clearDisplay ()

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

int getActualDistance ()

{distância interna total = 0; para (byte i = 0; i <10; i ++) {distanceSum + = ultrasônico. Variação (CM); }

return distanceSum / 10;

}

int getDistance ()

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

int getTimer ()

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

void lockScreen ()

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

Por fim, conecte o arduino ao computador usando o cabo USB e carregue o esboço no arduino.

Etapa 3: usando o dispositivo

Quando o arduino é conectado ao computador, ele monitora continuamente a distância na frente do sensor e envia uma combinação de teclas de tela de "bloqueio" para o computador se a distância aumentar.

O dispositivo possui algumas configurações:

1. Distância normal, a distância pode ser configurada usando o resistor variável conectado ao A0. A distância também é exibida no OLED. Quando a distância aumentar em 25% daquela que está definida, uma contagem regressiva começará

2. Tempo limite (contagem regressiva). O tempo limite em segundos também é configurável a partir do resistor conectado ao A1. Quando o tempo limite expirar, o comando de bloqueio será enviado

3. Trave a combinação de teclas. A combinação de teclas de bloqueio padrão é configurada para funcionar no Ubuntu Linux 18 (CTRL + ALT + L). Para alterar a combinação, você precisa modificar seu esboço de acordo com seu sistema operacional:

4. Tempo limite e proteção de distância. Como este é um dispositivo que emula o teclado, é uma boa ideia ter um mecanismo para desativar a funcionalidade do teclado. Em meu esboço, escolhi que o tempo limite e a distância devem ser maiores que "1". (você pode modificar isso no código, se quiser)

Localize e altere a função "lockScreen ()"

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

Para uma lista completa das chaves especiais do Arduino, verifique aqui:

Etapa 4: Outras abordagens

Antes desta implementação, também considerei algumas outras implementações:

1. Termômetro infravermelho (MLX90614 https://www.sparkfun.com/products/10740). Um termômetro infravermelho é um dispositivo que mede a temperatura analisando as radiações infravermelhas emitidas por um objeto à distância. Eu tinha um por perto e pensei que talvez pudesse detectar a diferença de temperatura na frente do computador.

Eu o conectei, mas a diferença de temperatura era muito pequena (quando eu estava na frente ou não) 1 a 2 graus e pensei que não poderia ser tão confiável

2. Sensor PIR. (https://www.sparkfun.com/products/13285) Esses sensores baratos são comercializados como "sensores de movimento", mas eles realmente detectam mudanças na radiação infravermelha, então em teoria poderia funcionar, quando uma pessoa sai do computador o sensor detectaria que.. Além disso, esses sensores têm um tempo limite embutido e botões de sensibilidade. Então eu conectei um e brinquei com ele, mas parece que o sensor não é feito para uma faixa próxima (ele tem um ângulo amplo), ele deu todos os tipos de alertas falsos.

3. Detecção de rosto usando a webcam. Esta opção me pareceu muito interessante, já que eu brinquei com este campo de computador em meus outros projetos como: https://github.com/danionescu0/robot-camera-platfo… e https://github.com/danionescu0/image-processing- pr …

Isso foi moleza! Mas havia algumas desvantagens: a câmera do laptop não podia ser usada para outros fins quando o programa estava em execução e alguns recursos do computador seriam necessários para isso. Então, também abandonei essa ideia.

Se você tiver mais ideias sobre como isso pode ser feito, compartilhe-as, obrigado!