Sistema di blocco automatico del computer: 4 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

In questo tutorial esploreremo la sicurezza del blocco dello schermo del computer. I sistemi operativi hanno un timeout configurabile che bloccherà lo schermo se l'utente non ha toccato il mouse o la tastiera.

Di solito l'impostazione predefinita è di circa un minuto. Se segui questa impostazione predefinita e lasci il tuo computer in un ambiente occupato, qualcuno potrebbe accedere al tuo computer in quel minuto fino al blocco dello schermo. Se lo imposti su pochi secondi otterrai la schermata di blocco molto spesso quando non tocchi la tastiera e questo è fastidioso…

Un giorno un collega di lavoro mi ha chiesto se posso "risolvere" questo problema con un qualche tipo di dispositivo che blocca il computer quando non c'è, e ho accettato la sfida:)

Ho esplorato diverse opzioni nella mia testa come l'utilizzo di arduino e un sensore di termometro a infrarossi, sensore PIR o forse utilizzando il rilevamento del volto sul computer, ma ho optato per un metodo più semplice:

Combineremo la funzionalità HID di Arduino Leonardo (emula tastiera) con un sensore di distanza a ultrasuoni per rilevare se una persona sta utilizzando il computer, in caso contrario il dispositivo invierà una combinazione di tasti tramite USB per bloccare il computer.

Passaggio 1: componenti

Poiché questa è una prova del concetto, costruiremo il dispositivo su una breadboard

Avrai bisogno:

1. Arduino Leonardo (è importante usare Leonardo perché può emulare la tastiera)

2. Sensore di distanza ad ultrasuoni HC-SR04

3. Resistori variabili 2 x 10 K

4. breadboard, fili per breadboard

5. Cavo USB

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

Passaggio 2: assemblaggio e caricamento

Per prima cosa controlla se hai tutti i componenti necessari e un IDE Arduino. Vado brevemente ai passaggi di connessione e puoi sempre dare un'occhiata al fritzing schema allegato

Assemblea

1. Metti il Leonardo sulla breadboard e tienilo in posizione con un elastico

2. metti i due resistori variabili, il display OLED e il sensore a ultrasuoni sulla breadboard

3. collegare le masse e i vcc

4. collegare i pin centrali dei resistori all'arduino A0 e A1

5. collegare SDA e SCL del display a SDA e SCL marcati sul Leonardo

6. collegare il pin trigger ed echo del sensore ultrasonico ai 12, 13 pin digitali del Leonardo

7. collegare l'USB al computer

Caricamento

Prima di tutto dovrai scaricare e installare le librerie arduino necessarie:

1. Libreria GOFi2cOLED:

2. Libreria Ultrasonic-HC-SR04:

Se non sai come installare le librerie arduino, dai un'occhiata a questo tutorial.

Dopo aver scaricato e installato le librerie sopra, puoi clonare o scaricare il mio repository arduino che si trova qui: https://github.com/danionescu0/arduino, e useremo questo sketch: https://github.com/danionescu0 /arduino/albero/maestro…

Oppure puoi copiare e incollare il codice qui sotto:

/* * Librerie utilizzate da questo progetto: * * 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;

Ultrasuoni ad ultrasuoni (12, 13);

const byte distanzaPot = A0;

const byte timerPot = A1; const float percentMaxDistanceChangedAllowed = 25; int distanza reale; maxDistanceDetectionTime lungo senza segno; bool lockTimerStarted = false;

configurazione nulla()

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

ciclo vuoto()

{ clearDisplay(); currentDistance = getActualDistance(); writeStatusData(); doDisplay(); if (!lockTimerStarted && shouldEnableLockTimer()) { lockTimerStarted = true; maxDistanceDetectionTime = millis(); Serial.println("inizio timer blocco"); } else if (!shouldEnableLockTimer()){ Serial.println("lock timer disabilitato"); lockTimerStarted = false; } if (dovrebbeLockScreen()) { lockScreen(); Serial.println("Blocca schermo"); } ritardo(100); }

bool dovrebbeLockScreen()

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

bool dovrebbeEnableLockTimer()

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

void writeStatusData()

{ setDisplayText(1, "MinDistance:", String(getDistance())); setDisplayText(1, "Timer:", String(getTimer())); setDisplayText(1, "ActualDistance:", String(actualDistance)); int countDown = getTimer() - (millis() - maxDistanceDetectionTime) / 1000; Stringa messaggio = ""; if (shouldLockScreen()) { message = "blocco inviato"; } else if (shouldEnableLockTimer() && countDown >= 0) { message = ".." + String(countDown); } else { messaggio = "no"; } setDisplayText(1, "Blocco: ", messaggio); }

void initializeDisplay()

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

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

{ GOFoled.setTextSize(fontSize); GOFoled.println(etichetta + ":" + dati); }

void doDisplay()

{ GOFoled.display(); }

void clearDisplay()

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

int getActualDistance()

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

ritorno distanzaSomma / 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("premendo"); Keyboard.press(KEY_LEFT_CTRL); ritardo(10); Keyboard.press(KEY_LEFT_ALT); ritardo(10); Keyboard.write('l'); ritardo(10); Keyboard.releaseAll(); }

Infine collega l'arduino al computer usando il cavo USB e carica lo schizzo nell'arduino.

Passaggio 3: utilizzo del dispositivo

Quando l'arduino è collegato al computer, monitorerà continuamente la distanza davanti al sensore e invierà una combinazione di tasti della schermata di "blocco" al computer se la distanza aumenta.

Il dispositivo ha alcune configurazioni:

1. Distanza normale, la distanza può essere configurata utilizzando il resistore variabile collegato all'A0. La distanza viene visualizzata anche sull'OLED. Quando la distanza aumenterà del 25% rispetto a quella impostata, inizierà un conto alla rovescia

2. Timeout (conto alla rovescia). Il timeout in secondi è configurabile anche dalla resistenza collegata ad A1. Allo scadere del timeout verrà inviato il comando di blocco

3. Blocca la combinazione di tasti. La combinazione di tasti di blocco predefinita è configurata per funzionare con Ubuntu Linux 18 (CTRL+ALT+L). Per cambiare la combinazione devi modificare il tuo schizzo in base al tuo sistema operativo:

4. Timeout e protezione a distanza. Poiché si tratta di un dispositivo che emula la tastiera, è una buona idea disporre di un meccanismo per disattivare la funzionalità della tastiera. Nel mio sketch ho scelto che il timeout e la distanza devono essere maggiori di "1". (puoi modificarlo nel codice se lo desideri)

Individua e modifica la funzione "lockScreen()"

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

Per un elenco completo delle chiavi speciali di Arduino, controlla qui:

Passaggio 4: altri approcci

Prima di questa implementazione ho preso in considerazione anche alcune altre implementazioni:

1. Termometro a infrarossi (MLX90614 https://www.sparkfun.com/products/10740). Un termometro a infrarossi è un dispositivo che misura la temperatura analizzando le radiazioni infrarosse emesse da un oggetto a distanza. Ne avevo uno in giro e ho pensato che forse potevo rilevare la differenza di temperatura davanti al computer.

L'ho collegato, ma la differenza di temperatura era molto piccola (quando ero davanti o no) 1-2 gradi e ho pensato che non potesse essere così affidabile

2. Sensore PIR. (https://www.sparkfun.com/products/13285) Questi sensori economici sono commercializzati come "sensori di movimento" ma rilevano davvero i cambiamenti nella radiazione infrarossa, quindi in teoria potrebbe funzionare, quando una persona lascia il computer il sensore rileverà che.. Anche questi sensori hanno un timeout integrato e manopole di sensibilità. Quindi ne ho collegato uno e ci ho giocato, ma sembra che il sensore non sia fatto per una distanza ravvicinata (ha un grandangolo), ha dato tutti i tipi di falsi allarmi.

3. Rilevamento del volto tramite la webcam. Questa opzione sembrava molto interessante, dato che ho giocato con questo campo informatico in altri miei progetti come: https://github.com/danionescu0/robot-camera-platfo… e https://github.com/danionescu0/image-processing- p…

Questo era un gioco da ragazzi! Ma c'erano alcuni inconvenienti: la fotocamera del laptop non poteva essere utilizzata per altri scopi quando il programma era in esecuzione e per questo sarebbero state necessarie alcune risorse del computer. Quindi ho abbandonato anche questa idea.

Se hai altre idee su come farlo, condividile, grazie!