예제 #1
0
파일: pir.py 프로젝트: GeekyTim/PiClock
    def __init__(self, ledmatrix, pirpin, nomovementforseconds):
        logging.info('init motion')
        self.__Matrix = ledmatrix
        self.__delay = nomovementforseconds
        self.__pin = pirpin

        logging.info('set up sensor')
        self.__PIR = MotionSensor(self.__pin)
        logging.info('starting motion')
예제 #2
0
파일: pir.py 프로젝트: GeekyTim/PiClock
class PIR:
    def __init__(self, ledmatrix, pirpin, nomovementforseconds):
        logging.info('init motion')
        self.__Matrix = ledmatrix
        self.__delay = nomovementforseconds
        self.__pin = pirpin

        logging.info('set up sensor')
        self.__PIR = MotionSensor(self.__pin)
        logging.info('starting motion')

    # -------------------------------------------------------------------------
    # wait_for_no_movement
    # Waits to see if there is movement within self.__delay seconds
    # If there is none, fades the matrix to black and stops it from being
    # updated.
    # Once movement is seen, fades the screen back on.
    # -------------------------------------------------------------------------
    def wait_for_no_movement(self):
        logging.info('motionsensor')
        t = time.time()
        while True:
            nomovement = self.__PIR.wait_for_no_motion(10)
            if nomovement:
                logging.info('No movement')
                if (time.time() - t) >= self.__delay:
                    logging.info('Turning off screen')
                    self.__Matrix.set_draw_on_matrix(False)
                    if self.__PIR.wait_for_motion():
                        t = time.time()
                        logging.info('Turning on screen')
                        self.__Matrix.set_draw_on_matrix(True)
                else:
                    if self.__PIR.wait_for_motion(10):
                        logging.info('Motion detected')
                        t = time.time()
            else:
                logging.info('Motion detected')
                t = time.time()
예제 #3
0
#This doesn't work.  WEnt to RPi.GPIO in Motion 2.py
from gpiozero import MotionSensor, LED
from signal import pause
import time

pir = MotionSensor(17)
led = LED(4)


def turnon():
	led.on
	time.sleep(2)
	led.off	

pir.when_motion = turnon
pir.when_no_motion = led.off

pause()
from mailsender import MailSender
from gpiozero import LED, MotionSensor
#from gpiozero.pins.pigpio import PiGPIOFactory

video_capture = cv2.VideoCapture(0)

image = fr.load_image_file("harish.jpg")
face_encoding = fr.face_encodings(image)[0]

known_face_encondings = [face_encoding]
known_face_names = ["harish"]

#factory = PiGPIOFactory(host='192.168.225.135')
#led = LED(17, pin_factory=factory)
led = LED(17)
pir = MotionSensor(4)

logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                    level=logging.INFO)

logger = logging.getLogger(__name__)

def alert_bot(update, context):
    update.message.reply_text('Alert bot activated')
    logger.info('Alert bot activated send to %s',update.message.chat.username)
    while True:
        try:
            if keyboard.is_pressed('ENTER'):
            # if pir.motion_detected:
                try:
                    update.message.reply_text('Person alert!')
예제 #5
0
from gpiozero import MotionSensor
from time import sleep

motion_sensor = MotionSensor(4)

while True:
    if motion_sensor.motion_detected:
        print('Dectected Motion!')
        sleep(2)
    else:
        print('No Motion Detected!')
        sleep(2)


        
예제 #6
0
#!/usr/bin/env python

from gpiozero import MotionSensor, LED, Button
from os import system

from signal import pause

m = MotionSensor(13)
l1 = LED(19)

def congrats():
#    l1.blink()
     l1.on()
     system("happyBirthday")


m.when_motion = congrats
m.when_no_motion = l1.off

pause()

예제 #7
0
from gpiozero import MotionSensor
from gpiozero import LED
from picamera import PiCamera
from datetime import datetime
from time import sleep

pir = MotionSensor(21)
camera = PiCamera()
led = LED(14)

while True:

    pir.wait_for_motion()

    t = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
    print("Mouvement détecté à", t, "!")
    led.on()

    video = '/home/pi/video_mouvements/' + t + ".h264"
    camera.start_recording(video)

    fileName = '/home/pi/video_mouvements/' + t + ".jpeg"
    camera.capture(fileName)

    pir.wait_for_no_motion()

    t = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
    print("Mouvement arrêté à", t, "!\n")
    led.off()

    camera.stop_recording()
예제 #8
0
#cool python file
#Authors: Happy Hour Squad

from gpiozero import MotionSensor
import time

#pir = MotionSensor(pin=4,queue_len=10,sample_rate=1.0,threshold=0.5,partial=False)
pir2 = MotionSensor(4) 

def abc():
	print("Motion detected")

pir2.when_motion = abc

while True:
	#if pir2.motion_detected:
		#print("Motion detected!")
	a = 3
예제 #9
0
from gpiozero import MotionSensor
from time import sleep
from picamera import PiCamera

pir = MotionSensor(4)
camera = PiCamera()

while True:
	pir.wait_for_motion()
	camera.start_preview()
	pir.wait_for_no_motion()
	camera.stop_preview()
예제 #10
0
import emailSender
from picamera import PiCamera
from gpiozero import MotionSensor

pir = MotionSensor(4)  #monstion sensor connected to gpio 4

pir.wait_for_motion()  #waiting to detect motion

print("Motion Detected")

camera = PiCamera()  #camera object created and rotated
camera.rotation = 180

image = camera.capture('/home/pi/webapp/static/selfie.jpg')  #image capture

filetoSend = "/home/pi/webapp/static/selfie.jpg"  #path of image set to filetoSend

send = emailSender.notify(
    filetoSend)  #use emailSender's method notify to send email
예제 #11
0
import os
from gpiozero import MotionSensor
from time import sleep
from signal import pause

os.system(
    "echo none | sudo tee /sys/class/leds/led0/trigger | echo 1 | sudo tee /sys/class/leds/led0/brightness"
)

print("Power LED disabled")

motionSensor = MotionSensor(17)

print("Motion Detection started")

TIMEOUT = 30
STEP = 1
monitorEnabled = True
stepCounter = 0


def handleMotion():
    global TIMTEOUT, STEP, monitorEnabled, stepCounter
    while True:
        sleep(STEP)
        if motionSensor.motion_detected:
            stepCounter = 0
            enableMonitor()
            monitorEnabled = True
        while stepCounter < TIMEOUT:
            if motionSensor.motion_detected:
예제 #12
0
    # Subscribing in on_connect() means that if we lose the connection and
    # reconnect then subscriptions will be renewed.
    client.subscribe("city/devices/mds/" + devicename)
    client.publish("city/devices/mds/" + devicename, devicename + " connected")


# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
    print(msg.topic + " " + msg.payload.decode())


client = mqtt.Client(protocol=mqtt.MQTTv31)
client.on_connect = on_connect
#read from a file to get the ip of the server
client.connect(siteConfig.ServerIp, 1883, 60)
pir = MotionSensor(portId)
# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
# Other loop*() functions are available that give a threaded interface and a
# manual interface.
client.loop_start()

try:
    while True:
        sleep(1)
        if pir.motion_detected:
            text = "Moition detected"
            client.publish("city/devices/mds/" + devicename, text)

finally:
    client.loop_stop()
예제 #13
0
from gpiozero import LEDBoard, MotionSensor
from gpiozero.pins.pigpio import PiGPIOFactory
from signal import pause

ips = ['192.168.1.3', '192.168.1.4', '192.168.1.5', '192.168.1.6']
remotes = [PiGPIOFactory(host=ip) for ip in ips]

leds = LEDBoard(2, 3, 4, 5)  # leds on this pi
sensors = [MotionSensor(17, pin_factory=r) for r in remotes]  # remote sensors

for led, sensor in zip(leds, sensors):
    led.source = sensor

pause()
예제 #14
0
        else:
            errorCaptura = False
            #                videoCapture.release()
            print("Termino captura de rostros exitosamente")

    return errorCaptura, NombreCarpetaPrueba, targetnames, NombresEtiquetas, video_capture, indexCamara, numeroMuestrasRostros, nombresAñadir

numeroMuestrasRostros = 61
import validarRostro as vR
indexCamara = 0
video_capture = 1.0

import recog as rg
from gpiozero import MotionSensor
import pickle
pir = MotionSensor(4)  # Numero de pin de raspberry

llamada = False
p, inputQueue, outputQueue = 0, 0, 0
estadoActualPasillo = False
estadoActualPuerta = False

nombre = "Sin reconocer"
conexionExitosa, firebase, db, valores, _ = conectarFirebase()


def funcionPrincipal():
    video_capture = 1.0
    movimientoPir = True
    primeraVez = True
    abriendo = "nada"
예제 #15
0
from gpiozero import MotionSensor, LED, Button
from picamera import PiCamera
from datetime import datetime
from signal import pause
from time import sleep

## Email specific libraries
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

## Basic input / LED setups
# pir = MotionSensor(4) # as in pin 7, GPIO4
pir = MotionSensor(27)  # as in pin 13, GPIO27 (GPIO02 in the piz fig)

myLed = LED(17)  # pin 11 / GPIO17
# button = Button(20)
button = Button(25)  # PiZero GPIO25 pin 22 outside
button.hold_time = 4  # secs

## Camera settings
camera = PiCamera()
camera.rotation = 270  # 180 for upside down camera
camera.resolution = (1250, 950)  ## setting from internet
camera.framerate = 90

## Email setup
pwd = open("notMuch.dat", "r")
pwd2 = pwd.read()
예제 #16
0
from gpiozero import MotionSensor
from picamera import PiCamera
from time import sleep
import os

camera = PiCamera()
camera.resolution = (1280, 720)
pir = MotionSensor(26, sample_rate=5, queue_len=3)
while True:
    pir.wait_for_motion()
    print('Motion detected')
    list = os.listdir(
        'ca1/static/images/detected')  # dir is your directory path
    number_files = len(list)
    sleep(3)
    camera.capture('ca1/static/images/detected/captured' + str(number_files) +
                   '.jpg')
    pir.wait_for_no_motion()
    sleep(10)
#uses the camera module to take a photo when the PIR sensor detects movement

from picamera import PiCamera
from time import sleep
from gpiozero import MotionSensor

camera = PiCamera()
sensor=MotionSensor(4)
n=0

camera.start_preview(alpha=200)
sensor.wait_for_motion()
n=n+1
camera.capture("/home/pi/Desktop/pir"+str(n)+".jpg")
camera.stop_preview()
예제 #18
0
import time
import os
import sys
import re

import config_sensor as cfg
from module_play  import play_audio_file
 
#----------- Do not modify below statements -------------------
try:
    print "[DEBUG] Starting PIR motion sensor..."

    # go to the default absolute path in order to read data file correctly
    os.chdir(cfg.folder)
    # motion sensor function probes the movement of people in front of entrance of the market.
    pir = MotionSensor(cfg.GPIO_PIN)
    count = 0
    while True:
        print "[DEBUG] Sleeping..."
        # wait for until customer wil be appeared
        pir.wait_for_motion()
        count += 1
        t = time.localtime()
        print ("################# Motion Detected! (%d) %d:%d:%d ##############################" \
        % (count, t.tm_hour, t.tm_min, t.tm_sec))
        #get time information with strftime fucntion for time acess and conversions
        #https://docs.python.org/2/library/time.html
        current_day = time.strftime("%Y%m%d")

        print "[DEBUG] Reading audio files..."
        #---------------------------------------------- Read audio file folder: start	
예제 #19
0
from gpiozero import MotionSensor, LED, Buzzer, Button
from time import sleep
from signal import pause

pir = MotionSensor(26)
buzzer = Buzzer(19)
button = Button(13)
led1 = LED(17)
led2 = LED(27)
led3 = LED(22)
led4 = LED(10)
led5 = LED(9)
led6 = LED(11)
    
all = [led1,led2,led3,led4,led5,led6]

def all_on():
    buzzer.on()
    for i in all:
        i.on()
        sleep(0.1)
    

def all_off():
    buzzer.off()
    for i in all:
        i.off()
while True:
    button.wait_for_press()
    print("SYSTEM ARMED YOU HAVE 5 SECONDS TO RUN AWAY")
    sleep(5)
예제 #20
0
class Detector(object):
    def __init__(self):
        # 4 = the pin on the Rasberry pi that the MotionSensor is connected to
        self.pir = MotionSensor(4, threshold=0.5)
        self.camera = PiCamera()
        self.source_photo = 'test.jpg'
        with open('new_user_credentials.csv', 'r') as input:
            csvreader = csv.DictReader(input)
            for row in csvreader:
                self.access_key_id = row['Access key ID']
                self.secret_key = row['Secret access key']
        
    def start(self):
        self.wait_for_motion()
        self.take_picture()
        self.wait_for_no_motion()
        photo = self.covert_img_to_bytes()
        results = self.aws_rekognition_image(photo)
        self.print_results(results)
            
    def wait_for_motion(self):
        self.pir.wait_for_no_motion()
        self.pir.wait_for_motion()
        print("Motion detect!")

    def wait_for_no_motion(self):
        self.pir.wait_for_no_motion()
        print("No Motion")
        
    def take_picture(self):
        self.camera.resolution = (1920, 1080)
        self.camera.rotation = 180
        self.camera.start_preview()
        sleep(2)
        self.camera.capture(self.source_photo)
        self.camera.stop_preview()

    def stop_camera(self):
        self.camera.stop_recording()

    def start_camera(self):
        datename = "{0:%Y}-{0:%m}-{0:%d}:{0:%H}:{0:%M}:{0:%S}".format(datetime.now())
        filename = str(datename) + "video.h264"
        self.camera.resolution = (640, 480)
        self.camera.rotation = 180
        self.camera.start_recording(filename)
        
    def aws_rekognition_image(self, photo):
        client = boto3.client('rekognition',
                              aws_access_key_id=self.access_key_id,
                              aws_secret_access_key=self.secret_key,
                              region_name='us-west-2')
        return client.detect_labels(Image={'Bytes': photo})
    
    def covert_img_to_bytes(self):
        with open(self.source_photo, 'rb') as photo:
            return photo.read()
    
    def print_results(self, results):
        for each in results['Labels']:
            print(each['Name'] + ": " + str(each['Confidence']))
예제 #21
0
파일: gpiozero.py 프로젝트: uherting/RasPi
from time import time, sleep
from gpiozero import MotionSensor

#
# measuring tool for checking payload on CPU
#

# for details see https://github.com/RPi-Distro/python-gpiozero/issues/227

# a note from the ticket:
# In GPIO Zero this draws a constant 10-12% of CPU on the Raspberry PI Zero,
# but with the older RPI.GPIO library and GPIO.add_event_detect CPU usage
# barely goes above 1%.

left = MotionSensor(20)
# right = MotionSensor(21)

last_update = time()
last_reset = last_update


def pir_change():
    print("Change")
    global last_reset
    last_reset = time()


left.when_motion = pir_change
# right.when_motion = pir_change

while True:
예제 #22
0
import datetime
from gpiozero import MotionSensor
import subprocess

def takePhoto():
	print("Take photo...")
	# cmd = ['ls', '-l']
	# cmd = ['raspistill', '-o', out_file, '-w', '720', '-h', '720', '-hf', '-vf']
	cmd = ['/bin/bash', '/home/pi/scripts/photo.sh', 'pir']
	runProcessNoWait(cmd)

def runProcessNoWait(cmd):
	process = subprocess.Popen(cmd)


GPIO_PIN = 4
pir = MotionSensor(GPIO_PIN)

while True:
    print("Wait for motion...")
    pir.wait_for_motion()
    print("You moved")
    takePhoto()
    print(datetime.datetime.utcnow())
    print("Wait for no motion")
    pir.wait_for_no_motion()
예제 #23
0
# LED와 PIR 센서를 연결
# 움직임이 감지되면 동영상 녹화 시작
# 움직임이 없어지면 동영상 녹화 중지
# 파일명은 날짜_녹화시작시간.h264
# 화면 출력은 없음
# 녹화 중일 때는 LED ON

import time
from signal import pause
from gpiozero import LED, MotionSensor
import picamera
import datetime

motion = MotionSensor(20)
led = LED(21)

camera = picamera.PiCamera()
camera.resolution = (640, 480)
camera.vflip = True


def start_record():
    led.on()
    now = datetime.datetime.now()
    fname = now.strftime("%T%m%d_%H%M") + ".h264"
    print("motion")
    camera.start_recording(fname)


def stop_record():
    led.off()
예제 #24
0
from gpiozero import Robot, MotionSensor
from signal import pause

robot = Robot(left=(4, 14), right=(17, 18))
pir = MotionSensor(5)

pir.when_motion = robot.forward
pir.when_no_motion = robot.stop

pause()
#
# Monitor activity using the PIR sensor.
# When movement is seen, start the full screen camera preview for 10 seconds
#
# Note:
#  - The PIR sensor seems a little flaky.  It appears to pick up sporatic movement
#    even when there is none.  This can cause the timeout threshold to be not met,
#    or cause a pre-mature in-office event to be triggered
#  - Research and testing seem to point to WiFi interference as the culprit.  Turning off the
#    WiFi adapter on the Pi, or using longer cables and/or sheilding seems to help.
#
from gpiozero import MotionSensor
from picamera import PiCamera
from time import sleep

# PIR sensor is attached to pin #4 on the GPIO
pir = MotionSensor(24)

# Camera does not use the GPIO; it has it's own dedicated interface
camera = PiCamera()

# Loop forever!
while True:
    if pir.motion_detected:
        camera.start_preview()
        sleep(10)
        camera.stop_preview()

    # Don't need to constantly poll the PIR sensor
    sleep(0.025)
예제 #26
0
#!/usr/bin/env python3
from gpiozero import MotionSensor
from vlc import MediaPlayer

from signal import pause
from sys import exit

pir = MotionSensor(24)
song_path = "../media/song.ogg"
p = MediaPlayer(song_path)


def toggle_playing():
    global p
    if p.is_playing():
        p.pause()
    else:
        p.play()

    # We need the next part to start the song again, as soon as the song finishes
    if p.get_time() == 0:
        p.stop()
        p = MediaPlayer(song_path)
        p.play()


pir.when_motion = toggle_playing

try:
    pause()
except KeyboardInterrupt:
예제 #27
0
from gpiozero import MotionSensor
import picamera
import time

# PIR sensor on GPIO pin 4
PIR_SENSOR_PIN = 4
# Minimum time between captures
DELAY = 5

# Create pir and camera objects
pir = MotionSensor(PIR_SENSOR_PIN)
camera = picamera.PiCamera()

while True:
    pir.wait_for_motion()
    timestring = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime())
    print("Taking photo " + timestring)
    camera.capture('/home/pi/photo_' + timestring + '.jpg')
    time.sleep(DELAY)
예제 #28
0
        status = subprocess.check_output(['vcgencmd', 'display_power']).decode('utf-8')
        return int(status[status.find('=') + 1:].strip())
    subprocess.call(['vcgencmd', 'display_power', str(value)])

def reset():
    logging.info('Motion detected')
    global timeout
    displayPower(1)
    timeout = 3600

logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',
    level=logging.DEBUG)

if displayPower():
    timeout = 3600
else:
    timeout = -1

pir = MotionSensor(17)
pir.when_motion = reset


while True:
    if timeout == 0 and displayPower():
        logging.info('No motion for 1 hour, turning off screen')
        displayPower(0)
    time.sleep(1)
    timeout -= 1


예제 #29
0
import time, socket, pickle, pymongo
from gpiozero import MCP3008, Servo, MotionSensor
import sys

#sensors data
divider = MCP3008(0)
servo = Servo(17, 1)
pir = MotionSensor(13)

#input data
location = "Compass One"
close_state = True
northCoordinates = 1.3924
eastCoordinates = 103.8954

#database objects
client = pymongo.MongoClient(
    "mongodb+srv://newuser2:[email protected]/BinData?retryWrites=true&w=majority"
)
mydb = client["BnnyBins"]
mycol = mydb["BinData"]

print("Starting Bunny Bin at", location)

try:
    while True:
        print(divider.value)
        if pir.motion_detected:

            print("Motion detected!")
            if close_state:
예제 #30
0
class RaspiGpioSensor(MotionDetectorImpl):
    """ Class for wrapping python motion sensor
    """
    def __init__(self, settings: RaspiGpioSensorSettings) -> None:
        super().__init__()

        LOGGER.info(f"Using motion sensor on pin {settings.gpio_pin_number}")
        self.__motion_sensor = GPIOMotionSensor(
            pin=settings.gpio_pin_number,
            queue_len=settings.queue_length,
            sample_rate=settings.sample_rate,
            threshold=settings.threshold)

        self.__settings = settings
        self.__motion_sensor.when_activated = self.__when_activated
        self.__motion_sensor.when_deactivated = self.__when_deactivated
        self.__handler: Optional[Callable[..., None]] = None

        self.__led: Optional[LED] = None
        if settings.led_gpio_pin_number > 0:
            self.__led = LED(settings.led_gpio_pin_number)

        # store activation status
        self._activated = False

    def register_handler(self, handler: Callable[..., None]) -> None:
        LOGGER.debug("Registering motion_sensor callback")
        self.__handler = handler

    def shutdown(self) -> None:
        LOGGER.info("Shutting down")
        # shutdown motion sensor thread and join
        self.__motion_sensor.close()

    @property
    def id(self) -> int:
        return self.__settings.gpio_pin_number

    def __when_activated(self) -> None:
        if self.disabled:
            LOGGER.debug("Sensor disabled, activation signal ignored")
            return

        self._activated = True
        LOGGER.debug("Sensor activated")

        if self.__led:
            self.__led.on()

        if self.__handler:
            self.__handler()

    def __when_deactivated(self) -> None:
        # when disabled, still check activation flag - in case of disable between activation cycle
        if self.disabled and not self._activated:
            LOGGER.debug("Sensor disabled, deactivation signal ignored")
            return

        self._activated = False
        LOGGER.debug("Sensor deactivated")

        if self.__led:
            self.__led.off()
from gpiozero import Button, LED, MotionSensor
from time import sleep

button = Button(3)
led = LED(17)
greenLed = LED(18)
pir = MotionSensor(14)
numberOfTimes = 0
encendido = False

#button.when_pressed = led.on
#button.when_released = led.off
#pause()


while True:
    if button.is_pressed:
        numberOfTimes += 1
        sleep(0.5)

    if(numberOfTimes % 2 == 0):
        led.on()
        greenLed.off()
        encendido = False
        #print("Apagado!")
    else:
        led.off()
        encendido = True
        #print("Encendido!")

    if encendido:
예제 #32
0
import picamera                   # Camera functions
import subprocess                 # Subprocess for livestream pipe
import numpy as np                # Use numpy for drawing overlay rectangles
import time

# Constants
url = "rtmp://a.rtmp.youtube.com/live2/" # YouTube livestream url
key = open("StreamKey.txt", "r").read()  # YouTube livestream key
catSearchTimeout = 5 # Cat search time after motion detected (seconds)
catLostTimeout = 30 # Cat search time after target lost (seconds)

# Command to start the livestream
streamCmd = "ffmpeg -re -ar 44100 -ac 2 -acodec pcm_s16le -f s16le -ac 2 -i /dev/zero -f h264 -i - -vcodec copy -acodec aac -ab 128k -g 50 -strict experimental -f flv " + url + key

# Hardware pin setup
pir = MotionSensor(14)

# Initializations
classifier = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalcatface.xml") # Load cat image classifier
camera = picamera.PiCamera(resolution=(800,480), framerate=25) # Init camera
camera.hflip = True # Flip camera
camera.vflip = True


# Cat face detection funtion
def catSearch():
	camera.capture("temp.jpg") # Take an image
	img = cv2.imread("temp.jpg") # Open the image in the cv2 library
	gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Convert to grayscale
	faces = classifier.detectMultiScale(gray, 1.04, 3) # search for cat faces
	return faces # return list of face locations found
예제 #33
0
from gpiozero import MotionSensor

PIR_PIN = 26
pir = MotionSensor(PIR_PIN)

while True:

  if pir.motion_detected:
    print "motion detected"
    while pir.motion_detected:
      print "motion still detected"
  else:
    print "no motion!"
   
예제 #34
0
from gpiozero import LED, MotionSensor, LightSensor
from gpiozero.tools import booleanized, all_values
from signal import pause

garden = LED(2)
motion = MotionSensor(4)
light = LightSensor(5)

garden.source = all_values(booleanized(light, 0, 0.1), motion)

pause()
예제 #35
0
파일: raspi.py 프로젝트: selh/breakthebuild
	global temp_readings 
	temp_readings += 1
	print("increasing count")

def active_count_reset():
	global temp_readings 
	temp_readings = 0
	print("resetting count")

client = MongoClient("mongodb://*****:*****@ds145405.mlab.com:45405/breakthebuild?authMechanism=SCRAM-SHA-1")

db = client["breakthebuild"]

test_collection = db.test_collection

sensor = MotionSensor(4)

sensor.when_motion = active_count

last = datetime.datetime.utcnow()

while True:
	if datetime.datetime.utcnow() > last + datetime.timedelta(seconds = 30):
		print(temp_readings)
		if temp_readings >=  3:
			occupied = True
		else: 
			occupied = False
		
		test_collection.insert({
			"name" : "Lilly",
예제 #36
0
            aio.send('led', c)  # sending data to led feed
            aio.send('power', power)  # sending data to power feed
            pir.wait_for_no_motion()  # waiting for no motion
            aio.send('active', 0)
            green_led.off()  # turning off all the street lights
            led1.off()
            led2.off()
            led3.off()
            led4.off()
            led5.off()
            print("Motion Stopped")


c = 0  # initializing number of led turned on as 0
power = 0  # initializing power consumption as 0
green_led = LED(17)  # GPIO 17
led1 = LED(12)  # GPIO 12
led2 = LED(13)  # GPIO 13
led3 = LED(19)  # GPIO 19
led4 = LED(21)  # GPIO 21
led5 = LED(26)  # GPIO 26
pir = MotionSensor(4)  # GPIO 4
green_led.off()
led1.off()
led2.off()
led3.off()
led4.off()
led5.off()
auto(
)  # By default refering to the auto function for automatic switching on/off the street-lights
예제 #37
0
from gpiozero import MotionSensor
from gpiozero import LED
from signal import pause
from time import sleep
import random

pir1 = MotionSensor(4)
pir2 = MotionSensor(17)
pir3 = MotionSensor(18)

led1 = LED(27)
# led2 = LED(4)

from phue import Bridge
import logging

import thread

logging.basicConfig()

lightrunning = {1: False, 2: False, 3: False}

b = Bridge('192.168.1.178', 'YxPYRWNawywC-sKHkjuRho7iOwMMSrn3di2ETF74')  # Enter bridge IP here.

lights = b.get_light_objects()


# class light_status():
#
#     def __init__(self):
#
예제 #38
0
#!/usr/bin/env python3
"""
	Caputures images triggered by motion sensor
"""

#import the necessary packages
from gpiozero import MotionSensor
from picamera import PiCamera
from time import sleep
from signal import pause

IMAGE_PATH = '/home/pi/cat-repellent-water-gun/images'

pir = MotionSensor(4, pull_up=True)
camera = PiCamera()

#start the camera
camera.rotation = 180
camera.start_preview()

img_num = 0


def take_photo():
    global img_num
    img_num = img_num + 1
    camera.capture(IMAGE_PATH + '/image_%s.jpg' % img_num)
    print('A photo has been taken')
    sleep(10)

예제 #39
0
from gpiozero import MotionSensor, LED

pir = MotionSensor(26)
led = LED(17)

pir.when_motion = led.on
pir.when_no_motion = led.off
예제 #40
0
from gpiozero import MotionSensor
import paho.mqtt.client as paho
import requests
import Adafruit_DHT as ada
import json
import time

pir = MotionSensor(4)


class pirClients:
    def __init__(self, ID, broker, pub_topic, sub_topic, port=None):
        self.Id = ID
        self.broker = broker
        self.port = port
        self.pub_topic = pub_topic
        self.sub_topic = sub_topic
        self.client = paho.Client(ID)
        self.client.on_message = self.on_message
        self.client.on_connect = self.on_connect

    def startLoop(self):
        if self.port == None:
            self.client.connect(self.broker)
        else:
            self.client.connect(self.broker, self.port)
        self.client.loop_start()

    def stopLoop(self):
        self.client.disconnect()
        self.client.loop_stop()
예제 #41
0
client = mqtt.Client()
client.loop_start()


def take_photo():
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = 'pic_' + timestamp + '.jpg'
    camera.capture(filename)
    fqp = os.getcwd() + '/' + filename
    scp = 'pi@' + ipaddr + ':' + fqp
    client.publish(topic, "photo taken: " + scp)

def on_connect(client, userdata, flags, rc):
    client.subscribe(topic)

def on_message(client, userdata, msg):
    command = msg.payload.decode("utf-8")
    if command == "take photo":
        take_photo()

pir = MotionSensor(4)
pir.when_motion = take_photo

client.on_connect = on_connect
client.on_message = on_message
client.connect(server, 1883, 60)

pause()
client.loop_stop()
예제 #42
0
from gpiozero import MotionSensor
from signal import pause
import sys
from time import sleep
import LED_module
import Figure_Movements

pir = MotionSensor(12)


def piron():
    LED_module.light_LED()  #call light_LED function when button is pressed
    Figure_Movements.move_figures_in_sequence()
    sleep(6)
    LED_module.dowse_LED()


def piroff():
    print('led.off')


if __name__ == '__main__':
    while True:

        try:
            #green_led.on()
            #button.wait_for_press()
            pir.when_motion = piron

        #pause()
        except KeyboardInterrupt:
예제 #43
0
from gpiozero import MotionSensor
from picamera import PiCamera
from datetime import datetime
import time
import os


if os.path.isfile('./authenticated')!=1:
	os.system("sudo grive --dry-run -a")
	f = open('authenticated','w')

motion_timeout = 6;
next_video_timeout = 0;
camera = PiCamera()
pir = MotionSensor(4)
while True:
    pir.wait_for_motion()
    print 'motion detected'
    filename = datetime.now().strftime("%Y-%m-%d_%H.%M.%S.h264") 
    camfilename = datetime.now().strftime("%Y-%m-%d_%H.%M.%S.jpg")
    camera.capture(camfilename)
    camera.start_recording(filename)
    pir.wait_for_no_motion(motion_timeout)
    camera.stop_recording()
    print 'motion ended'
    os.system("sudo grive -u -f")
    os.system("sudo rm *.jpg *.h264")
    time.sleep(next_video_timeout)
예제 #44
0
from gpiozero import MotionSensor
import time

PIN_PIR = 23

pir = MotionSensor(PIN_PIR)


def callback_function(channel):
    print("Motion detected.")


try:
    pir.when_motion = callback_function
    while (True):
        time.sleep(10)
except KeyboardInterrupt:
    print("END")
예제 #45
0
args = parser.parse_args()

output_dir = args.output_dir
eventPostUrl = args.server
cameraName = args.camera_name
location = args.location

print("Writing images to " + output_dir)
print("Posting data to " + eventPostUrl)

# IR Lamp MOSFET Setup
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)

# Motion Sensor Setup
pir = MotionSensor(4)

# Camera Setup
camera = picamera.PiCamera()
camera.resolution = camera.MAX_RESOLUTION
camera.led = False

motionActive = False
imageList = []

def getFileName():
    return "/capture-" + datetime.now().strftime("%Y%m%d-%H%M%S.%f") + ".jpg"

def getFilePath(fileName):
    return output_dir + "/" + fileName
예제 #46
0
파일: flow.py 프로젝트: sachin0509/traffic
		}
		else continue recording/flow of lights
"""


from gpiozero import MotionSensor
from picamera import PiCamera
from time import sleep
import signal
import sys
import RPi.GPIO as GPIO
from subprocess import call

#create objects that refer to a,
#a motion sensor and the PiCamera
pir = MotionSensor(4)
camera = PiCamera()
#image name
i=0

# Setup
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
GPIO.setup(22, GPIO.OUT)

def take_photo():
    	global i
   	i = i + 1
	filePath = "/home/pi/Desktop/projectpic/image_%s.jpg' %i"
	currentTime=datetime.now()