Ang isang kawili-wiling ideya ay naimbento at ipinatupad ng isang master na may palayaw carolinebuttet1.
Sa mundo mayroong mga 770 milyong mga camera ng pagsubaybay. Ang ilan sa mga ito ay walang password o mayroong isang default na password. Ginagawa nitong madali silang mai-access sa sinumang may koneksyon sa internet.
Ang virtual na peephole na ito, na naimbento ng isang master aparato para sa pagsubaybay sa ilan sa mga hindi protektadong camera. Ang pagpili ng camera ay random, i.e. sa bawat oras na iyong isara at buksan muli ang mata, maaari mong makita ang imahe mula sa isa pa, sapalarang napiling, video camera.
Upang maipatupad ang ideyang ito, ginamit ng panginoon ang mga sumusunod na kagamitan:
-Arduino Micro
Photoresistor
-Raspberry Pi 3 Model B
- Screen ng raspberry Pi
-Wooden Box
-Mga panloob na peephole
-Drill
Screwdriver
Ang virtual na peephole ay binubuo ng dalawang natatanging bahagi: ang Raspberry Pi (na may maliit na screen) at Arduino Micro. Ang Raspberry Pi ay konektado sa Internet at sa isang website na nag-broadcast ng isang random na channel mula sa camera.
Mayroong isang light sensor sa loob ng mata upang matukoy kung ito ay nakabukas o sarado. Tuwing sarado ang peephole, ang signal ay ipinapadala sa Raspberry Pi (sa pamamagitan ng Arduino Micro) at lumipat ang website sa isa pang camera. Ang data ng camera na ginamit ng wizard para sa proyektong ito ay kinuha mula sa site Insecam , na nagrerehistro ng higit sa 73,000 mga hindi protektadong camera.
Website upang ipakita.
Para sa kanyang virtual na peephole, ang wizard ay lumikha ng isang website gamit ang data na nakolekta niya mula sa insecam. Maaari mong gawin nang hindi lumilikha ng isang site at gamitin ito ang link (binabago nito ang webcam sa bawat oras na pinindot mo ang spacebar)
I-configure ang Raspberry Pi.
Siguraduhin na ang iyong Raspberry Pi ay up at tumatakbo (tingnan Ang gabay na itokung bago ka sa Raspberry Pi). Ikonekta ang LCD screen sa Raspberry Pi. Kailangan mong i-configure ang iyong Raspberry Pi upang magsimula ito sa isang web page. Paano ito gawin, makikita mo dito.
Pag-setup ng Arduino.
Tandaan: upang gawin ang proyektong ito, ang iyong board ng Arduino ay dapat suportahan ang isang library ng keyboard. Tulad ng nabanggit sa pahina ng aklatan:
Mga suportadong modelo - mga motherboards batay sa 32u4 at SAMD (pamilya ni Leonardo, Esplora, Zero, Dahil, at MKR)
Ikonekta ang iyong light sensor sa Arduino
I-download ang code sa Arduino.
Sinimulan muna ng code ang pagkakalibrate ng 5 segundo (kung saan ang minimum at maximum na mga halaga para sa photosensor ay maitala), at pagkatapos ay magpapadala ng isang "puwang" key signal sa tuwing mas mababa ang halaga ng pag-iilaw kaysa sa halaga (iyon ay, ang mata ay sarado).
Magsimula ang CODE
nakaraangMillis = 0
// sapagkat ang ilaw ay palaging nag-iiba, i-calibrate namin ang photoseor sa bawat boot.
mahabang calibrationtime = 5000;
mahabang simulaMillis = 0;
// ang maximum na halaga para sa isang sensor ng analog ay 1024
int sensorMin = 1024;
int sensorMax = 0;
int average = 0;
int threshold = 5;
bool lastState = totoo;
bool isClosed = totoo;
walang pag-setup () {
Serial.begin (9600); // buksan ang serial port
Keyboard.begin (); // simulan ang keyboard library
startMillis = millis (); // simulan ang counter
}
walang bisa na loop () {
// patatagin ang pagbabasa sa unang 5 segundo
// pagkatapos, tuklasin ang isang pagkakaiba-iba sa pag-stabilize.
hindi naka-lagay na mahabang kasalukuyangMillis = millis (); // itakda ang millis bilang kasalukuyang oras
int sensorValue = analogRead (A0); // basahin ang sensor
kung (kasalukuyangMillis-startMillis & lt; calibrationtime) {
// basta nasa oras na tayo ng pagkakalibrate
// sa panahon ng pag-calibrate na ito, buksan at isara ang peephole upang ma-calibrate ito.
int elapsedtime = currentMillis - startMillis;
Serial.println (elapsedtime);
Serial.println (sensorMin);
Serial.println (sensorMax);
kung (sensorValue & lt; sensorMin) {// irehistro ang halaga ng max at min para sa sensor
sensorMin = sensorValue;
average = (sensorMin + sensorMax) / 2;
}
kung (sensorValue & gt; sensorMax) {
sensorMax = sensorValue;
average = (sensorMin + sensorMax) / 2;
}
pagkaantala (100); // pagkaantala
}
kung hindi man {// kung tapos na ang pagkakalibrate
kung (sensorValue & gt; average + threshold) {// tiktikan kung ang peephole ay nakabukas o sarado
isClosed = maling;
kung (lastState! = isClosed) {
}
}
iba pa {
isClosed = totoo;
kung (lastState! = isClosed) {
Keyboard.print (""); // magpadala ng isang pangunahing signal kung ang peephole ay nakabukas
}
}
lastState = isClosed;
pagkaantala (100);
}
}KATAPUSAN NG CODE.
Susunod, kailangan mong i-install ang kagamitan sa kahon.
Mag-drill ng isang butas sa peephole ng pinto upang mai-install ang photosensor (matutukoy nito kung ang iyong peephole ay nakabukas o hindi sarado, at pagkatapos ay buhayin ang pagbabago sa webcam). Mag-drill ng butas sa kahon. Bago ang peephole ng pinto, i-fasten ang screen ng Raspberry (ginamit ng master ang Velcro).
Ikonekta ang Arduino:
Ikonekta ang sensor ng larawan sa Arduino
Ruta ang USB cable sa pagitan ng Rpi at Arduino. Ang Arduino ay kikilos bilang isang keyboard at magpadala ng isang space bar sa Raspberry Pi.
Matapos mai-mount ang lahat, maaari mong simulan ang virtual peephole.
Ilagay ang aparato sa dingding
Ikonekta ang iyong Rapsberry Pi sa kapangyarihan
Ngayon ay magkakaroon ka ng 5 segundo upang ma-calibrate ang photosensor na matatagpuan sa pintuan ng pintuan, kailangan mong buksan at isara ito nang maraming beses.
Ngayon ang virtual na peephole ay dapat gumana!
Sa aking palagay isang mahusay na ideya at pagpapatupad. Siyempre, maaari mong mai-install ang aparato sa ibang kaso, maaari itong na-finalize ang code at gumawa ng isang listahan ng mga camera na may isang ginustong koneksyon, ngunit ang lahat ay maaaring gawin ito sa kanilang sarili.