కోరిందకాయ పై పై ఓపెన్‌సివిని ఉపయోగించి అలారంతో సిసిటివి మోషన్ డిటెక్షన్

ఓపెన్‌సివి ఒక శక్తివంతమైన సాధనం మరియు రాస్‌ప్బెర్రీ పైతో కలిపి అనేక పోర్టబుల్ స్మార్ట్ పరికరాలకు తలుపులు తెరవగలదు. మా మునుపటి రాస్ప్బెర్రీ పై సిసిటివి పర్యవేక్షణ కథనంలో, ఆర్టిఎస్పిని ఉపయోగించి డివిఆర్ నుండి లైవ్ సిసిటివి వీడియోను ఎలా పొందాలో నేర్చుకున్నాము మరియు రాస్ప్బెర్రీ పైలో ప్రదర్శిస్తాము, కొనసాగడానికి ముందు దాన్ని తనిఖీ చేయండి. ఈ వ్యాసంలో, ఓపెన్‌సివి యొక్క శక్తిని ఎలా ప్రభావితం చేయాలో మరియు మా లైవ్ సిసిటివి ఫుటేజ్‌లపై రాస్‌ప్బెర్రీ పై మోషన్ డిటెక్షన్ సిస్టమ్‌ను ఎలా నిర్మించాలో నేర్చుకుంటాము. మీరు సిసిటివిని వ్యవస్థాపించకపోతే, యుఎస్బి కెమెరాలను నేరుగా మీ పైకి కనెక్ట్ చేయడం ద్వారా మీరు రాస్ప్బెర్రీ పై నిఘా వ్యవస్థను నిర్మించవచ్చు. మరియు మీరు పై మరియు పైథాన్ యొక్క పెద్ద అభిమాని కాకపోతే, మీరు ESP32 తో సమానమైనదాన్ని నిర్మించవచ్చు, మరిన్ని వివరాల కోసం ESP32 Wi-Fi డోర్ బెల్ చూడండి.

ఏదైనా కార్యకలాపాలకు (మోషన్) ఒకేసారి నాలుగు సిసిటివి కెమెరాలను పర్యవేక్షించగల పైథాన్ స్క్రిప్ట్‌ను వ్రాస్తాము. ఏదైనా కెమెరాలో కార్యాచరణ కనుగొనబడితే, మా రాస్‌ప్బెర్రీ పై స్వయంచాలకంగా నిర్దిష్ట కెమెరా స్క్రీన్‌కు మారుతుంది మరియు ఏ కార్యాచరణ జరిగిందో హైలైట్ చేస్తుంది, ఇవన్నీ నిజ సమయంలో కేవలం 1.5 సెకన్ల లాగ్‌తో ఉంటాయి. నేను ఒక అలారం లక్షణాన్ని కూడా జోడించాను, బజర్ వంటిది, కార్యాచరణ కనుగొనబడితే బీప్ చేయడం ద్వారా వినియోగదారుని హెచ్చరించగలదు. కానీ మీరు సందేశం లేదా ఇ-మెయిల్ పంపడానికి దీన్ని సులభంగా స్కేల్ చేయవచ్చు లేదా ఏమి కాదు! ఉత్తేజకరమైనది !! ప్రారంభిద్దాం

బస్టర్ మరియు ఓపెన్‌సివిలతో రాస్‌ప్బెర్రీ పై ఏర్పాటు

నేను రాస్ప్బెర్రీ పై 3 బి + ను బస్టర్ OS తో నడుపుతున్నాను మరియు ఓపెన్ సివి వెర్షన్ 4.1. మీరు పూర్తిగా క్రొత్తగా ఉంటే, మీరు ప్రారంభించడానికి ముందు ఈ క్రింది ట్యుటోరియల్‌లను అనుసరించండి.

మీ పై అప్ మరియు అభివృద్ధికి సిద్ధంగా ఉండటమే లక్ష్యం. మీ పైలో రాస్పియన్ ఓఎస్ యొక్క ఏదైనా సంస్కరణను కలిగి ఉండటం సరైందే కాని ఓపెన్‌సివి వెర్షన్ 4.1 లేదా అంతకంటే ఎక్కువ అని నిర్ధారించుకోండి. మీ ఓపెన్‌సివిని కంపైల్ చేయడానికి మీరు పై ట్యుటోరియల్‌ను అనుసరించవచ్చు, ఇది గంటలు పడుతుంది, కాని భారీ ప్రాజెక్టులకు మరింత నమ్మదగినది లేదా కింది ఆదేశాలను ఉపయోగించి పైప్ నుండి నేరుగా ఇన్‌స్టాల్ చేయండి.

$ పైప్ ఇన్‌స్టాల్ ఓపెన్‌సివి-కంట్రిబ్యూట్-పైథాన్ == 4.1.0.25

మీరు మొదటిసారి పైప్‌తో ఓపెన్‌సివిని ఇన్‌స్టాల్ చేస్తుంటే, మీరు ఇతర డిపెండెన్సీలను కూడా ఇన్‌స్టాల్ చేయాలి. దాని కోసం క్రింది ఆదేశాలను ఉపయోగించండి.

$ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev $ sudo apt-get install libatlas-base-dev gfortran $ sudo apt-get install libhdf5- dev libhdf5-serial-dev libhdf5-103 $ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5

మేము ఇప్పటికే చాలా రాస్‌ప్బెర్రీ పై ఓపెన్‌సివి ప్రాజెక్టులను నిర్మించాము, మీరు మరింత ప్రేరణల కోసం దాన్ని కూడా తనిఖీ చేయవచ్చు.

రాస్ప్బెర్రీ పై 5 ఇంచ్ డిస్ప్లేకి బజర్ కలుపుతోంది

హార్డ్వేర్ వైపు, మాకు 5-ఇంచ్ డిస్ప్లే మరియు బజర్ తప్ప చాలా ఎక్కువ లేదు. రాస్ప్బెర్రీ పైతో 5-ఇంచ్ డిస్ప్లేని ఇంటర్‌ఫేసింగ్ చేసిన తరువాత, మేము నేరుగా బజర్‌ను డిస్ప్లే వెనుక వైపుకు మౌంట్ చేయవచ్చు, ఇది మన కోసం కొన్ని GPIO పిన్‌లను విస్తరించింది. క్రింద చూపిన విధంగా నేను నా బజర్‌ను కనెక్ట్ చేసాను-

మీరు ఎక్కువ I / O పిన్‌లను ఉపయోగించటానికి ఆసక్తి కలిగి ఉంటే, అప్పుడు క్రింది పిన్ వివరణ ఉపయోగపడుతుంది. విస్తరించిన పిన్‌లలో మీరు చూడగలిగినట్లుగా, చాలా పిన్‌లను డిస్ప్లే ద్వారా టచ్‌స్క్రీన్ ఇంటర్‌ఫేస్ కోసం ఉపయోగించుకుంటారు. కానీ ఇప్పటికీ, మనకు పిన్స్ 3,5,7,8,10,11,12,13,15,16, మరియు 24 కి కనెక్షన్ లేదు మరియు మేము దానిని మా స్వంత అప్లికేషన్ కోసం ఉపయోగించవచ్చు. ఈ ట్యుటోరియల్‌లో, నేను బజర్‌ను GPIO 3 కి కనెక్ట్ చేసాను.

సిసిటివి మోషన్ డిటెక్షన్ కోసం ప్రోగ్రామింగ్ రాస్ప్బెర్రీ పై

ఈ ప్రాజెక్ట్ కోసం పూర్తి పైథాన్ స్క్రిప్ట్ ఈ పేజీ దిగువన చూడవచ్చు, అయితే ఇది ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి కోడ్ యొక్క ప్రతి విభాగాన్ని చర్చిద్దాం.

RTSP ఉపయోగించి రాస్ప్బెర్రీ పై ఆన్ లాగ్ లేకుండా బహుళ కెమెరాలను పర్యవేక్షిస్తుంది

ఈ పనిని చేయడంలో సవాలుగా ఉన్న భాగం ఏమిటంటే, స్ట్రీమింగ్‌లో మందగింపును నివారించడానికి రాస్‌ప్బెర్రీ పైపై భారాన్ని తగ్గించడం. ప్రారంభంలో, నేను చలన కోసం నాలుగు కెమెరాల మధ్య మారడానికి ప్రయత్నించాను కాని అది చాలా మందగించింది (సుమారు 10 సెకన్లు). అందువల్ల నేను నాలుగు కెమెరాలను ఒకే చిత్రానికి మిళితం చేసాను మరియు ఆ చిత్రంపై అన్ని కదలికలను గుర్తించే చర్యలను చేసాను. నేను రెండు ఫంక్షన్లను వ్రాసాను, అవి కెమెరాను సృష్టించండి మరియు కెమెరాను చదవండి.

కెమెరా సృష్టించడానికి ఫంక్షన్ దాని సంబంధిత ఛానల్ సంఖ్య తో కామ్ తెరవడానికి ఉపయోగిస్తారు. RTSP URL “02” తో ముగుస్తుందని గమనించండి, అంటే నేను ఉప-స్ట్రీమ్ వీడియో ఫీడ్‌ను ఉపయోగిస్తున్నాను, ఇది తక్కువ రిజల్యూషన్ ఉంటుంది మరియు చదవడానికి వేగంగా ఉంటుంది. అలాగే, మీరు ఉపయోగించే వీడియో కోడెక్ రకం కూడా వేగానికి దోహదం చేస్తుంది, నేను వేర్వేరు కోడ్‌లతో ప్రయోగాలు చేసాను మరియు FFMPEG అన్నింటికీ ఉపవాసం ఉన్నట్లు కనుగొన్నాను.

def create_camera (ఛానెల్): rtsp = "rtsp: //" + rtsp_username + ":" + rtsp_password + "@" + rtsp_IP + ": 554 / స్ట్రీమింగ్ / ఛానెల్స్ /" + ఛానల్ + "02" # IP ని సరిపోయేలా మార్చండి yours cap = cv2.VideoCapture (rtsp, cv2.CAP_FFMPEG) cap.set (3, cam_width) # వెడల్పు కోసం ID సంఖ్య 3 cap.set (4, cam_height) # ఎత్తు కోసం ID సంఖ్య 480 cap.set (10, 100) ప్రకాశం కోసం # ID సంఖ్య 10 రిటర్న్ క్యాప్

లో రీడ్ కెమెరా ఫంక్షన్, మేము అనే ఒకే చిత్రం వాటిని అన్ని మిళితం అవి cam1, cam2, cam3, మరియు మీరు cam4 నాలుగు కామ్లు చదువుతాను Main_screen . ఈ ప్రధాన స్క్రీన్ సిద్ధమైన తర్వాత, మేము ఈ చిత్రంపై మా ఓపెన్‌సివి పనిని చేస్తాము.

def read_camera (): విజయం, current_screen = cam1.read () Main_screen = current_screen success, current_screen = cam2.read () Main_screen = current_screen success, current_screen = cam3.read () Main_screen = current_screen success, current_screen = cam4.read () మెయిన్_స్క్రీన్ = ప్రస్తుత_స్క్రీన్ రిటర్న్ (మెయిన్_స్క్రీన్)

నాలుగు కెమెరాలతో కలిపి ప్రధాన స్క్రీన్ చిత్రం క్రింద చూపిన చిత్రంగా కనిపిస్తుంది.

రాస్ప్బెర్రీ పై ఉపయోగించి ఓపెన్ సివిలో మోషన్ డిటెక్షన్

ఇప్పుడు మనకు ఇమేజ్ సిద్ధంగా ఉంది, మన మోషన్ డిటెక్షన్ తో ప్రారంభించవచ్చు. టైమ్ లూప్ లోపల, ఫ్రేమ్ 1 మరియు ఫ్రేమ్ 2 అనే రెండు వేర్వేరు ఫ్రేమ్‌లను చదవడం ద్వారా ప్రారంభిస్తాము, తరువాత వాటిని గ్రేస్కేల్‌గా మారుస్తాము

frame1 = read_camera () # మొదటి ఫ్రేమ్‌ను చదవండి గ్రేఇమేజ్_ఎఫ్ 1 = సివి 2. సివిటి కలర్ (ఫ్రేమ్ 1, సివి 2.COLOR_BGR2GRAY) # బూడిద ఫ్రేమ్‌గా మార్చండి = రీడ్_కామెరా () # 2 వ ఫ్రేమ్‌ను చదవండి గ్రేఇమేజ్_ఎఫ్ 2 = సివి 2

అప్పుడు ఏమి మారిందో చూడటానికి ఈ రెండు చిత్రాల మధ్య తేడాను తీసుకుంటాము మరియు ఒక ప్రవేశంతో, మార్పు ఉన్న అన్ని ప్రదేశాలను మేము సమూహపరుస్తాము, ఒక రకమైన బొట్టు వంటిది. పదునైన అంచులను నివారించడానికి చిత్రాన్ని అస్పష్టం చేయడం మరియు విడదీయడం కూడా సాధారణం.

diffImage = cv2.absdiff (గ్రేఇమేజ్_ఎఫ్ 1, గ్రేఇమేజ్_ఎఫ్ 2) # తేడాను పొందండి - ఇది కూల్ బ్లర్ ఇమేజ్ = సివి 2.గౌసియన్ బ్లూర్ (డిఫైజ్ ఇమేజ్, (5,5), 0) _, థ్రెషోల్డ్ ఇమేజ్ = సివి 2. థ్రెషోల్డ్ (బ్లర్ ఇమేజ్, 20,255, సివిబిఎన్హెచ్ఆర్) dilatedImage = cv2.dilate (ప్రవేశ చిత్రం, కెర్నల్, పునరావృత్తులు = 5)

తదుపరి దశ కౌంటర్లను కనుగొని, ప్రతి కౌంటర్ యొక్క వైశాల్యాన్ని తనిఖీ చేయడం, ఆ ప్రాంతాన్ని కనుగొనడం ద్వారా, ఎంత పెద్ద కదలికను మనం గుర్తించవచ్చు. మోషన్_డిటెక్టెడ్ వేరియబుల్‌లో పేర్కొన్న విలువ కంటే ప్రాంతం పెద్దదిగా ఉంటే, అప్పుడు మేము దానిని ఒక కార్యాచరణగా పరిగణిస్తాము మరియు దానిని వినియోగదారుకు హైలైట్ చేయడానికి మార్పు చుట్టూ ఒక పెట్టెను గీయండి.

ఆకృతులు, _ = cv2.findContours (డైలేటెడ్ ఇమేజ్, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)., 1) display_screen = find_screen ()

నాలుగు కెమెరాలలో కార్యాచరణ ఎక్కడ జరిగిందో తెలుసుకోవడానికి ఫంక్షన్ find_screen () ఉపయోగించబడుతుంది. కదలిక యొక్క x మరియు y విలువలు మనకు తెలుసు కాబట్టి మనం కనుగొనవచ్చు. ఏ స్క్రీన్ కార్యాచరణను ఇచ్చిందో తెలుసుకోవడానికి మేము ఈ x మరియు y విలువలను ప్రతి స్క్రీన్ యొక్క స్థానంతో పోల్చి చూస్తాము మరియు మేము మళ్ళీ ఆ నిర్దిష్ట స్క్రీన్‌ను కత్తిరించుకుంటాము, తద్వారా పై టచ్ స్క్రీన్‌లో ప్రదర్శించగలము.

def find_screen (): if (x <cam_width): if (y <cam_height): screen = frame1 print ("cam screen 1 లో కార్యాచరణ") else: screen = frame1 print ("cam screen 2 లో కార్యాచరణ") else: if (y <cam_height): స్క్రీన్ = ఫ్రేమ్ 1 ప్రింట్ ("కామ్ స్క్రీన్ 3 లో కార్యాచరణ") వేరే: స్క్రీన్ = ఫ్రేమ్ 1 ప్రింట్ ("కామ్ స్క్రీన్ 4 లో కార్యాచరణ") తిరిగి (స్క్రీన్)

మోషన్ డిటెక్షన్ కోసం అలారం సెట్ చేస్తోంది

మనకు తెలిసిన తర్వాత, ఏ స్క్రీన్, మోషన్ కనుగొనబడితే, మనకు అవసరమైన ఏ రకమైన అలారం అయినా జోడించడం సులభం. ఇక్కడ మేము GPIO 3 కి కనెక్ట్ చేయబడిన బజర్‌ను బీప్ చేస్తాము. స్క్రీన్ 3 లో మోషన్ కనుగొనబడిందా అని if స్టేట్మెంట్ తనిఖీ చేస్తుంది మరియు ట్రిగ్_అలార్మ్ అనే వేరియబుల్‌ను పెంచుతుంది . మీకు నచ్చిన ఏదైనా స్క్రీన్‌ను లేదా బహుళ స్క్రీన్‌లలో కూడా మీరు గుర్తించవచ్చు.

if ((x> cam_width) మరియు (y

ట్రిగ్_అలార్మ్ విలువ 3 కన్నా ఎక్కువకు చేరుకుంటే, మేము ఒకసారి బజర్‌ను బీప్ చేస్తాము. ఈ గణనకు కారణం కొన్నిసార్లు నీడలు లేదా పక్షులు నకిలీ అలారం సృష్టించడం నేను గమనించాను. కాబట్టి ఈ విధంగా 3 ఫ్రేమ్‌ల కోసం నిరంతర కార్యాచరణ ఉంటేనే, మాకు అలారం వస్తుంది.

if (tri_alarm> = 3): # కాంటెస్ 3 కదలికల కోసం వేచి ఉండండి # బజర్ GPIO.output (BUZZER, 1) time.sleep (0.02) GPIO.output (BUZZER, 0) tri_alarm = 0

CPU ఉష్ణోగ్రత మరియు వినియోగాన్ని పర్యవేక్షిస్తుంది

సిస్టమ్ 24x7 పని చేయడానికి ఇండెంట్ చేయబడింది మరియు అందువల్ల పై చాలా వేడిగా ఉంటుంది, కాబట్టి ఆ విలువలను తెరపై ప్రదర్శించడం ద్వారా ఉష్ణోగ్రత మరియు సిపియు వాడకాన్ని పర్యవేక్షించాలని నేను నిర్ణయించుకుంటాను. మేము gpiozero లైబ్రరీని ఉపయోగించి ఈ సమాచారాన్ని పొందాము.

cpu = CPUT ఉష్ణోగ్రత () లోడ్ = లోడ్ సగటు () cpu_temperature = str ((cpu.temperature) // 1) load_average = str (load.load_average) #print (cpu.temperature) #print (load.load_average) cv2.putText (display_screen, cpu_temperature, (250,250), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1) cv2.putText (display_screen, load_average, (300,250), cv2.

మీ పై సిసిటివి మోషన్ డిటెక్టర్‌ను ప్రారంభిస్తోంది

సేకరించడానికి రోజుల తరబడి నేను దీనిని పరీక్షించాను మరియు ఇది ప్రతిసారీ పనిచేస్తుంది మరియు నేను ఒక కెమెరాను దెబ్బతీసే వరకు ఇది నిజంగా సరదాగా నిర్మించబడింది,