def main():
if (len(sys.argv) < 2):
print "Kayttoohje: sudo python Main.py Raspberryn_IP_osoite Lampomittarin_polku"
sys.exit(0)
ip = sys.argv[1]
lampomittari_path = sys.argv[2]
GPIO.setmode(GPIO.BCM)
lampomittarin_laite = LED(17)
valoanturin_laite = LED(27)
lampomittari = Lampomittari(lampomittari_path, lampomittarin_laite, True,
24)
valoanturi = Valoanturi(18, 23, valoanturin_laite, True, 6)
web_ui = WebUI(ip, lampomittari, valoanturi)
thread.start_new_thread(web_ui.kaynnista, ())
while True:
valoanturi.paivita()
print valoanturi.anna_valoisuus()
#print lampomittari.paivita()
time.sleep(1)
def __init__(self):
self._mongo = Mongo()
self._sensor = Sensor()
self._adafruit = Adafruit()
self._lcd = lcd_ecologic()
self._led = LED()
self._firebase = Firebase()
def __init__(self, *args, **kwargs):
wx.Panel.__init__(self, *args, **kwargs)
self.StaticBox = wx.StaticBox(self, -1, "Channel")
self.StaticBoxSizer = wx.StaticBoxSizer(self.StaticBox, wx.VERTICAL)
self.grid = wx.GridBagSizer(0, 0)
self.On = wx.Button(self, -1, "ON", size=(58, 22))
self.Off = wx.Button(self, -1, "OFF", size=(58, 22))
self.Led = LED(self)
self.Led.SetState(0)
self.PWR = wx.StaticText(self,
label=u"Power [dBm]: ",
size=(120, 20),
style=wx.ALIGN_RIGHT)
self.WVL = wx.StaticText(self,
label=u"Wavelength [nm]: ",
size=(120, 20),
style=wx.ALIGN_RIGHT)
self.txtPWR = wx.TextCtrl(self, size=(80, 20), value="")
self.txtWVL = wx.TextCtrl(self, size=(80, 20), value="")
self.grid.Add(self.On,
pos=(0, 0),
flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.Off,
pos=(0, 1),
flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.Led,
pos=(0, 2),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.PWR,
pos=(1, 0),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0,
span=(1, 2))
self.grid.Add(self.WVL,
pos=(2, 0),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0,
span=(1, 2))
self.grid.Add(self.txtPWR,
pos=(1, 2),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.txtWVL,
pos=(2, 2),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.StaticBoxSizer.Add(self.grid, 0, wx.ALL | wx.LEFT, 0)
self.SetSizerAndFit(self.StaticBoxSizer)
def __init__(self):
""" Door Latch Constructor """
#Open a serial connection to the Arduino
self.ser = serial.Serial('/dev/ttyACM0', 9600, timeout=0.2)
self.status = "LOCKED"
#Initialize the LED System
LED.setup()
#Initialize the hardware buttons
Button.setup()
def __init__(self, confpath="./example.conf"):
"""
Instantiates a WeatherStation object and all of its individual
components.
@param: confpath - absolute path to configuration file.
default = "./example.conf"
"""
self.mode = None
self.warnings = None
self.params = {}
self.leds = []
self.ledpins = {}
self.sensorpins = {}
# read through the config file
try:
os.stat(confpath)
self.__parseconfig(confpath)
except FileNotFoundError:
print("Config file %r not found." % confpath)
sys.exit(-1)
except AssertionError as e:
print("The config file is missing the following sections: ", e)
sys.exit(-1)
except Exception as e:
print("Error has occured whilst accessing config file:")
print(e)
sys.exit(-1)
# set warnings
gpio.setwarnings(self.warnings)
# instantiate all components
self.lcd = LCD(self.mode)
self.sensor = SHT11(self.sensorpins["data"], self.sensorpins["clock"],
self.mode)
self.status_led = LED(self.ledpins["green"], self.mode)
self.temperature_led = LED(self.ledpins["red"], self.mode)
self.humidity_led = LED(self.ledpins["yellow"], self.mode)
self.query_led = LED(self.ledpins["blue"], self.mode)
self.leds = [self.status_led, self.temperature_led, self.humidity_led,
self.query_led]
# blink all LEDs
for led in self.leds:
led.blink(0.3)
# write status to the screen
self.__lcd_write("WEATHERSTATION", "OPERATIONAL")
class HeartBeat:
def __init__(self):
self._running = True
self._LED = LED()
def terminate(self):
self._running = False
def run(self):
while self._running:
self._LED.ledOn()
time.sleep(0.5)
self._LED.ledOff()
time.sleep(0.5)
def __init__(self, button_pin=29, led_pin=31):
# GPIO interaction
Button.__init__(self, pin=button_pin)
LED.__init__(self, pin=led_pin)
GPIO.add_event_callback(self.button_pin, callback=self.listener)
# for record
self.pa = None
self.stream = None
self.frames = None
# check button state
self.button_pressed = None
while True:
time.sleep(.01)
def LEDTest():
power = CPI()
node1 = Transistor(True)
led = LED()
power.setConnection(node1)
node1.setConnection(led)
node1.setSignal(True)
print(led.display())
node1.setSignal(False)
print(led.display())
def __init__(self, args):
self.kySocket = mySocket(self, args.socket_ip,
args.socket_port) #arg port 넣기
self.button = MyButton(self)
self.tts = busPlayList(keyData.TTS_client_id,
keyData.TTS_client_secret)
self.userBus = UserBus()
self.control = Control(self)
self.bus = StationDict(
self, args.stationID, keyData.serviceKey,
args.url) # 순서 중요 tts -> userBus-> control -> bus
self.led = LED()
self.updateCycle = args.updateCycle
self.systemState = False # 시스템 상태(default : 대기)
def __InitializeLEDS(self, ledGpioPins):
ledColor = Color.GREEN
for i in range(0, Globals.NUMBER_OF_LEDS):
if i < 5:
ledColor = Color.GREEN
else:
ledColor = Color.RED
self.__leds.append(
LED(position=i, gpioPIN=ledGpioPins[i], color=ledColor))
def lockDoor(self):
"""
Set the latch pin state to HIGH, retracting the latch (a.k.a. unlocking door)
Parameters
----------
None
Returns
-------
None
"""
#Lock the door
self.ser.write("%d" % LOCK)
#Update the door status
self.status = "LOCKED"
#Update the LEDs
LED.updateLEDs(self.status)
def __init__(self, bb8):
self.BB8 = bb8
self.red = LED(5)
self.green = LED(6)
self.blue = LED(12)
self.State = "default"
self.nextUpdate = 0
def button_handler(the_button, state):
""" Handles button event.
Parameters:
'the_button' is a reference to the BUTTON instance that invoked the callback (ie the button variable created below)
'state' is the button state, eg PRESSED, RELEASED, HOLD """
global led_index
if state == BUTTON.PRESSED: # (1)
led_index += 1
if led_index >= len(LEDS):
led_index = 0
logger.info(
"Turning the Potentiometer dial will change the rate for LED #{}".
format(led_index))
elif state == BUTTON.HOLD: # (2)
rate = pot.get_value()
logger.info("Changing rate for all LEDs to {}".format(rate))
LED.set_rate_all(rate)
def __init__(self):
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
self.green_led = LED(5)
self.yellow_led = LED(13)
self.red_led = LED(21)
self.motor = Motor()
self.web_cam = cv.VideoCapture(0)
self.pi_cam = PiCamera()
self.angle = 0.25
self.open = False
self.face = None
self.server_ip = '10.10.3.21'
self.port = 8080
self.threshold = 20000
self.interval = 10
class ProcessStateIndicator:
def __init__(self, bb8):
self.BB8 = bb8
self.red = LED(5)
self.green = LED(6)
self.blue = LED(12)
self.State = "default"
self.nextUpdate = 0
def SetBrightness(self, brightness):
self.red.SetBrightness(brightness)
self.green.SetBrightness(brightness)
self.blue.SetBrightness(brightness)
def SetValue(self, r, g, b):
self.red.SetValue(r)
self.green.SetValue(g)
self.blue.SetValue(b)
def SetDefault(self):
self.SetValue(0, 0, 0)
self.State = "default"
def SetR2D2(self):
self.State = "r2d2"
self.nextUpdate = time.time()
def Update(self):
if self.State == "default":
v = 255 * self.BB8.Sound.GetAmplitude()
self.SetValue(v, v, v)
elif self.State == "r2d2":
t = time.time()
if t > self.nextUpdate:
self.nextUpdate = t + 3 * random.random()
if self.red.Value == 255:
self.SetValue(0, 0, 255)
else:
self.SetValue(255, 0, 0)
import json
# import RPi.GPIO as GPIO
from uuid import getnode as get_mac
import time
from LED import LED
from Buzzer import Buzzer
# GPIO.setmode(GPIO.BCM)
hostename = "broker.hivemq.com"
# mac = get_mac()
mac = 123456789012345
c = "/frame/" + str(mac)
print(c)
buzzer = Buzzer(23)
led = LED(24)
def on_connect(client, userdata, flags, rc):
client.subscribe(c, 0)
print("connected with result code " + str(rc))
def on_message(client, userdata, msg):
#print(msg.topic + " " + str(msg.payload))
msg = str(msg.payload)[2:-1]
# print(msg)
dictionaryToJson = json.dumps(msg.lower())
print(dictionaryToJson)
if (dictionaryToJson == "frame_added"):
buzzer.lawaai_buzzer_add_frame()
class WeatherStation(object):
"""
Control class for the entire hardware setup.
Contains:
- 16x2 LCD
- temperature & humidity sensor
- green LED to indicate station is operational
- blue LED to indicate sensors are currently being queried
- red LED to indicate extreme temperature readings
- yellow LED to indicate extreme humidity readings
Example usage:
>>> from WeatherStation import WeatherStation
>>>
>>> # for details about the config file, see "example.conf"
>>> ws = WeatherStation("/absolute/path/to/config/file.conf")
>>> ws.monitor(run_time=3600, frequency=5)
"""
def __init__(self, confpath="./example.conf"):
"""
Instantiates a WeatherStation object and all of its individual
components.
@param: confpath - absolute path to configuration file.
default = "./example.conf"
"""
self.mode = None
self.warnings = None
self.params = {}
self.leds = []
self.ledpins = {}
self.sensorpins = {}
# read through the config file
try:
os.stat(confpath)
self.__parseconfig(confpath)
except FileNotFoundError:
print("Config file %r not found." % confpath)
sys.exit(-1)
except AssertionError as e:
print("The config file is missing the following sections: ", e)
sys.exit(-1)
except Exception as e:
print("Error has occured whilst accessing config file:")
print(e)
sys.exit(-1)
# set warnings
gpio.setwarnings(self.warnings)
# instantiate all components
self.lcd = LCD(self.mode)
self.sensor = SHT11(self.sensorpins["data"], self.sensorpins["clock"],
self.mode)
self.status_led = LED(self.ledpins["green"], self.mode)
self.temperature_led = LED(self.ledpins["red"], self.mode)
self.humidity_led = LED(self.ledpins["yellow"], self.mode)
self.query_led = LED(self.ledpins["blue"], self.mode)
self.leds = [self.status_led, self.temperature_led, self.humidity_led,
self.query_led]
# blink all LEDs
for led in self.leds:
led.blink(0.3)
# write status to the screen
self.__lcd_write("WEATHERSTATION", "OPERATIONAL")
def __parseconfig(self, confpath):
"""
Parses the config file, registering all found values.
In case a paricular value is not present, a fallback is provided.
@param: confpath - path to the configuration file
@return: none
"""
parser = ConfigParser()
parser.read(confpath)
# check if all required sections are present:
sections = parser.sections()
expected = ["General", "Parameters", "Sensor", "LEDs"]
assert sections >= expected, "%r" % expected - sections
# get operations mode
mode = parser["General"]["MODE"]
if mode.lower() == "board":
self.mode = gpio.BOARD
else:
self.mode = gpio.BCM
# get warnings setting
self.warnings = parser.getboolean("General", "WARNINGS", fallback=False)
# get operational parameters
parameters = parser["Parameters"]
self.params["maxt"] = parameters.getfloat("MAX_TEMP", fallback=40.0)
self.params["mint"] = parameters.getfloat("MIN_TEMP", fallback=20.0)
self.params["maxh"] = parameters.getfloat("MAX_HUMID", fallback=70.0)
self.params["minh"] = parameters.getfloat("MIN_HUMID", fallback=30.0)
# get sensor pins
sensorpins = parser["Sensor"]
self.sensorpins["data"] = sensorpins.getint("DATA", fallback=27)
self.sensorpins["clock"] = sensorpins.getint("CLOCK", fallback=4)
# get led pins
ledpins = parser["LEDs"]
self.ledpins["green"] = ledpins.getint("GREEN", fallback=12)
self.ledpins["red"] = ledpins.getint("RED", fallback=19)
self.ledpins["yellow"] = ledpins.getint("YELLOW", fallback=20)
self.ledpins["blue"] = ledpins.getint("BLUE", fallback=21)
def monitor(self, run_time=600, frequency=1):
"""
Lights the appropriate LEDs and displays the result on the LCD for
a given ammount of time and at a specified frequency.
@param run_time: Time to run in seconds.
@param frequency: The frequency at which the update occurs.
@return: None
"""
self.status_led.on()
start_time = time.time()
end_time = start_time + run_time
while time.time() <= end_time:
# query the sensor
self.query_led.on()
try:
temperature = self.sensor.temperature()
humidity = self.sensor.humidity(temperature)
except Exception:
self.sensor.reset()
time.sleep(1)
continue
self.query_led.off()
# trigger appropriate LEDs
self.__trigger_leds(humidity, temperature)
# write values on the LCD
self.__lcd_write("%.2f %s" % (temperature, "(C)"),
"%.2f %s" % (humidity, "(RH%)"))
time.sleep(frequency)
self.clear()
self.__lcd_write("WEATHERSTATION", "OPERATIONAL")
def __lcd_write(self, line1="", line2=""):
"""
Centers and writes the two lines to the LCD.
@param: line1 - what to write on the first line of the LCD.
@param: line2 - what to write on the second line of the LCD.
@return: None
"""
self.lcd.writeline(line1.center(self.lcd.SCREENWIDTH, " "), line=1)
self.lcd.writeline(line2.center(self.lcd.SCREENWIDTH, " "), line=2)
def __trigger_leds(self, humidity, temperature):
"""
Lights up the LEDs based on the current status.
@param: humidity - current humidity reading.
@param: temperature - current temperature reading.
@return: None
"""
if self.params["minh"] > humidity or self.params["maxh"] < humidity:
self.humidity_led.on()
else:
self.humidity_led.off()
if self.params["mint"] > temperature or self.params["maxt"] < temperature:
self.temperature_led.on()
else:
self.temperature_led.off()
def clear(self):
"""
Turns off all LED's, clear the LCD, set sensor to idle.
@param: None
@return: None
"""
for led in self.leds:
led.off()
self.sensor.reset()
self.lcd.clear()
def cleanup(self):
"""
Turn off associated LED's, clear the LCD, cleanup all pins.
This method is meant to be called after the instance of
WeatherStation has done its job and is no longer required.
After this method is called, this instance of WeatherStation is
rendered useless.
@param: None
@return: None
"""
self.clear()
gpio.cleanup()
class Menu:
def __init__(self):
self._mongo = Mongo()
self._sensor = Sensor()
self._adafruit = Adafruit()
self._lcd = lcd_ecologic()
self._led = LED()
self._firebase = Firebase()
def leerSensores(self):
try:
self._sensor.lectura()
print()
print('Temperatura={0:0.1f}° Humedad={1:0.1f}%'.format(
self._sensor.getTemperatura(), self._sensor.getHumedad()))
print('Humedad_planta={0} LDR={1}'.format(
self._sensor.getHumedadPlanta(), self._sensor.getLDR()))
print('Fecha={0}'.format(self._sensor.getFecha()))
except:
sys.exit(1)
def publicaDatos(self):
self._adafruit.publicarHumedad(self._sensor.getHumedad())
self._adafruit.publicarTemperatura(self._sensor.getTemperatura())
self._adafruit.publicarHumedadPlanta(self._sensor.getHumedadPlanta())
self._adafruit.publicarLDR(self._sensor.getLDR())
self._firebase.insertaSensores(self._sensor.getTemperatura(),
self._sensor.getHumedad(),
self._sensor.getLDR(),
self._sensor.getHumedadPlanta(),
self._sensor.getFecha())
def imprimeDatos(self):
self._led.encenderLED(self._sensor.getHumedadPlanta())
self._lcd.imprimirPantalla(self._sensor.getHumedad(),
self._sensor.getTemperatura(),
self._sensor.getHumedadPlanta(),
self._sensor.getLDR(),
self._sensor.getFecha())
def guardaDatos(self):
self._mongo.consultarCantidadRegistros()
self._mongo.insertarDatos(self._sensor.getTemperatura(),
self._sensor.getHumedad(),
self._sensor.getHumedadPlanta(),
self._sensor.getLDR(),
self._sensor.getFecha())
def run(self):
try:
while True:
self.leerSensores()
self.guardaDatos()
self.publicaDatos()
self.imprimeDatos()
time.sleep(10)
else:
print("Tiempo excedido")
except KeyboardInterrupt:
print('Pantalla limpiada')
self._lcd.limpiarPantalla()
print('LEDs limpiados')
self._led.limpiarLED()
def __init__(self):
self.pins = [RaspberryPi.SDA, RaspberryPi.GPIO7]
self.led = LED()
for pin in self.pins:
GPIO.setup(pin, GPIO.OUT)
print("Running QA Environment Configuration")
environment = cfg.env_qa
else:
print("Running Production Environment Configuration")
environment = cfg.env_prod
# Application constants from Environment and Configuration file
sampleTime = cfg.sampleTime
debug = cfg.debug
deviceID = cfg.deviceID
webApiUrl = environment["webApi"]
webApiUsername = environment["username"]
webApiPassword = environment["password"]
# Create an indicator LED on GPIO pin 17
led = LED(17)
# Create the Temperature Sensor on GPIO pin 4
temperatureSensor = TemperatureSensor(4)
# Dictionary to hold Temperature Sensor data
temperatureData = {}
# Sit in a loop reading the sensors every sampleTime, convert result to JSON, and POST to the Web API
while True:
# Turn LED ON
led.on()
# Read the Temperature Sensor
temperatureSensor.read()
if temperatureSensor.valid:
'the_pot' is a reference to the POT instance that invoked the callback (ie the pot variable created below)
'value' is the mapped value (ie in the range MIN_BLINK_RATE_SECS..MAX_BLINK_RATE_SECS) """
logger.info("Changing LED #{} rate to {}".format(led_index, value))
LEDS[led_index].set_rate(value)
# Create POT class instances and register pot_handler() callback with it.
pot = POT(analog_channel=POT_CHANNEL,
min_value=MIN_BLINK_RATE_SECS,
max_value=MAX_BLINK_RATE_SECS,
poll_secs=POT_POLL_SECS,
callback=pot_handler)
# Create LED class instances.
LEDS = [LED(gpio=13, pi=pi), LED(gpio=19, pi=pi)]
# The index of the LED in LEDS List which will be affected when the potentiometer value changes.
# 'led_index' is updated in button_handler() and referenced in pot_handler()
led_index = 0
if __name__ == "__main__": # (3)
try:
logger.info(
"Version 2 - Thread and Callback Example. Press Control + C To Exit."
)
# Initialise all LEDs
rate = pot.get_value()
LED.set_rate_all(rate) # Initialise all LEDS based on POT value.
MIN_L = 1600
MIN_R = 1600
STOP_R = 1550
STOP_L = 1550
MAX_L = 2000
MAX_R = 2000
LM = STOP_L
RM = STOP_R
MAX_ACCL = 5
sense = SenseHat()
led = LED()
def accelerationToMotors(acceleration, LM, RM):
global MIN_L, MIN_R, MAX_L, MAX_R, MAX_ACCL
#Detect tilt acceleration
if acceleration > 0.25:
LM = min(LM + acceleration * (MAX_ACCL), MAX_L)
RM = min(RM + acceleration * (MAX_ACCL), MAX_R)
elif acceleration < -0.3:
LM = max(LM + acceleration * (MAX_ACCL) * 10, MIN_L)
RM = max(RM + acceleration * (MAX_ACCL) * 10, MIN_R)
return LM, RM
class Buzzer:
def __init__(self):
self.pins = [RaspberryPi.SDA, RaspberryPi.GPIO7]
self.led = LED()
for pin in self.pins:
GPIO.setup(pin, GPIO.OUT)
#self.boop()
#self.mario()
#time.sleep(5)
#self.storm()
#self.beep(659, 125)
def beep(self, hz, ms):
#print 'beep ' + str(hz) + 'hz ' + str(ms) + 'ms'
DELAY_OFFSET = 11
us = (500000 / hz) - DELAY_OFFSET
rep = (ms * 500) / (us + DELAY_OFFSET)
sleep_time = us/1000000.0
for i in range(0, rep):
GPIO.output(RaspberryPi.SDA, True)
GPIO.output(RaspberryPi.GPIO7, False)
time.sleep(sleep_time)
GPIO.output(RaspberryPi.SDA, False)
GPIO.output(RaspberryPi.GPIO7, True)
time.sleep(sleep_time)
self.led.beep()
#time.sleep(0.05)
def beepBoopLoop(self):
for i in range(0, 100000):
print i
self.beep(2000, 1000)
time.sleep(0.10)
def boop(self):
print 'boop'
for _ in xrange(5):
for value in [True, False]:
GPIO.output(RaspberryPi.SDA, value)
time.sleep(0.001)
time.sleep(0.05)
def sleep2(self, ms):
sleep_time = ms/1000.0
time.sleep(sleep_time)
def mario(self):
self.beep(659, 125)
self.beep(659, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(523, 125)
self.beep(659, 125)
self.sleep2(125)
self.beep(784, 125)
self.sleep2(375)
self.beep(392, 125)
self.sleep2(375)
self.beep(523, 125)
self.sleep2(250)
self.beep(392, 125)
self.sleep2(250)
self.beep(330, 125)
self.sleep2(250)
self.beep(440, 125)
self.sleep2(125)
self.beep(494, 125)
self.sleep2(125)
self.beep(466, 125)
self.sleep2(42)
self.beep(440, 125)
self.sleep2(125)
self.beep(392, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(125)
self.beep(784, 125)
self.sleep2(125)
self.beep(880, 125)
self.sleep2(125)
self.beep(698, 125)
self.beep(784, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(125)
self.beep(523, 125)
self.sleep2(125)
self.beep(587, 125)
self.beep(494, 125)
self.sleep2(125)
self.beep(523, 125)
self.sleep2(250)
self.beep(392, 125)
self.sleep2(250)
self.beep(330, 125)
self.sleep2(250)
self.beep(440, 125)
self.sleep2(125)
self.beep(494, 125)
self.sleep2(125)
self.beep(466, 125)
self.sleep2(42)
self.beep(440, 125)
self.sleep2(125)
self.beep(392, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(125)
self.beep(784, 125)
self.sleep2(125)
self.beep(880, 125)
self.sleep2(125)
self.beep(698, 125)
self.beep(784, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(125)
self.beep(523, 125)
self.sleep2(125)
self.beep(587, 125)
self.beep(494, 125)
self.sleep2(375)
self.beep(784, 125)
self.beep(740, 125)
self.beep(698, 125)
self.sleep2(42)
self.beep(622, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(415, 125)
self.beep(440, 125)
self.beep(523, 125)
self.sleep2(125)
self.beep(440, 125)
self.beep(523, 125)
self.beep(587, 125)
self.sleep2(250)
self.beep(784, 125)
self.beep(740, 125)
self.beep(698, 125)
self.sleep2(42)
self.beep(622, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(698, 125)
self.sleep2(125)
self.beep(698, 125)
self.beep(698, 125)
self.sleep2(625)
self.beep(784, 125)
self.beep(740, 125)
self.beep(698, 125)
self.sleep2(42)
self.beep(622, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(415, 125)
self.beep(440, 125)
self.beep(523, 125)
self.sleep2(125)
self.beep(440, 125)
self.beep(523, 125)
self.beep(587, 125)
self.sleep2(250)
self.beep(622, 125)
self.sleep2(250)
self.beep(587, 125)
self.sleep2(250)
self.beep(523, 125)
self.sleep2(1125)
self.beep(784, 125)
self.beep(740, 125)
self.beep(698, 125)
self.sleep2(42)
self.beep(622, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(415, 125)
self.beep(440, 125)
self.beep(523, 125)
self.sleep2(125)
self.beep(440, 125)
self.beep(523, 125)
self.beep(587, 125)
self.sleep2(250)
self.beep(784, 125)
self.beep(740, 125)
self.beep(698, 125)
self.sleep2(42)
self.beep(622, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(698, 125)
self.sleep2(125)
self.beep(698, 125)
self.beep(698, 125)
self.sleep2(625)
self.beep(784, 125)
self.beep(740, 125)
self.beep(698, 125)
self.sleep2(42)
self.beep(622, 125)
self.sleep2(125)
self.beep(659, 125)
self.sleep2(167)
self.beep(415, 125)
self.beep(440, 125)
self.beep(523, 125)
self.sleep2(125)
self.beep(440, 125)
self.beep(523, 125)
self.beep(587, 125)
self.sleep2(250)
self.beep(622, 125)
self.sleep2(250)
self.beep(587, 125)
self.sleep2(250)
self.beep(523, 125)
self.sleep2(625)
def storm(self):
NOTE_B0 =31
NOTE_C1 =33
NOTE_CS1 =35
NOTE_D1 =37
NOTE_DS1 =39
NOTE_E1 =41
NOTE_F1 =44
NOTE_FS1 =46
NOTE_G1 =49
NOTE_GS1 =52
NOTE_A1 =55
NOTE_AS1 =58
NOTE_B1 =62
NOTE_C2 =65
NOTE_CS2 =69
NOTE_D2 =73
NOTE_DS2 =78
NOTE_E2 =82
NOTE_F2 =87
NOTE_FS2 =93
NOTE_G2 =98
NOTE_GS2 =104
NOTE_A2 =110
NOTE_AS2 =117
NOTE_B2 =123
NOTE_C3 =131
NOTE_CS3 =139
NOTE_D3 =147
NOTE_DS3 =156
NOTE_E3 =165
NOTE_F3 =175
NOTE_FS3 =185
NOTE_G3 =196
NOTE_GS3 =208
NOTE_A3 =220
NOTE_AS3 =233
NOTE_B3 =247
NOTE_C4 =262
NOTE_CS4 =277
NOTE_D4 =294
NOTE_DS4 =311
NOTE_E4 =330
NOTE_F4 =349
NOTE_FS4 =370
NOTE_G4 =392
NOTE_GS4 =415
NOTE_A4 =440
NOTE_AS4 =466
NOTE_B4 =494
NOTE_C5 =523
NOTE_CS5 =554
NOTE_D5 =587
NOTE_DS5 =622
NOTE_E5 =659
NOTE_F5 =698
NOTE_FS5 =740
NOTE_G5 =784
NOTE_GS5 =831
NOTE_A5 =880
NOTE_AS5 =932
NOTE_B5 =988
NOTE_C6 =1047
NOTE_CS6 =1109
NOTE_D6 =1175
NOTE_DS6 =1245
NOTE_E6 =1319
NOTE_F6 =1397
NOTE_FS6 =1480
NOTE_G6 =1568
NOTE_GS6 =1661
NOTE_A6 =1760
NOTE_AS6 =1865
NOTE_B6 =1976
NOTE_C7 =2093
NOTE_CS7 =2217
NOTE_D7 =2349
NOTE_DS7 =2489
NOTE_E7 =2637
NOTE_F7 =2794
NOTE_FS7 =2960
NOTE_G7 =3136
NOTE_GS7 =3322
NOTE_A7 =3520
NOTE_AS7 =3729
NOTE_B7 =3951
NOTE_C8 =4186
NOTE_CS8 =4435
NOTE_D8 =4699
NOTE_DS8 =4978
self.beep( NOTE_D5, 100)
self.sleep2(80)
self.beep( NOTE_F5, 100)
self.sleep2(80)
self.beep( NOTE_D6, 200)
self.sleep2(250)
self.beep( NOTE_D5, 100)
self.sleep2(80)
self.beep( NOTE_F5, 100)
self.sleep2(80)
self.beep( NOTE_D6, 200)
self.sleep2(250)
self.beep( NOTE_E6, 200)
self.sleep2(200)
self.beep( NOTE_F6, 100)
self.sleep2(100)
self.beep( NOTE_E6, 100)
self.sleep2(80)
self.beep( NOTE_F6, 100)
self.sleep2(80)
self.beep( NOTE_E6, 100)
self.sleep2(80)
self.beep( NOTE_C6, 100)
self.sleep2(80)
self.beep( NOTE_A5, 100)
self.sleep2(300)
self.beep( NOTE_A5, 200)
self.sleep2(100)
self.beep( NOTE_D5, 200)
self.sleep2(100)
self.beep( NOTE_F5, 100)
self.sleep2(100)
self.beep( NOTE_G5, 100)
self.sleep2(100)
self.beep( NOTE_A5, 100)
self.sleep2(500)
self.beep( NOTE_A5, 200)
self.sleep2(100)
self.beep( NOTE_D5, 200)
self.sleep2(100)
self.beep( NOTE_F5, 100)
self.sleep2(100)
self.beep( NOTE_G5, 100)
self.sleep2(100)
self.beep( NOTE_E5, 100)
self.sleep2(500)
self.beep( NOTE_D5, 100)
self.sleep2(80)
self.beep( NOTE_F5, 100)
self.sleep2(80)
self.beep( NOTE_D6, 200)
self.sleep2(250)
self.beep( NOTE_D5, 100)
self.sleep2(80)
self.beep( NOTE_F5, 100)
self.sleep2(80)
self.beep( NOTE_D6, 200)
self.sleep2(250)
self.beep( NOTE_E6, 200)
self.sleep2(200)
self.beep( NOTE_F6, 100)
self.sleep2(100)
self.beep( NOTE_E6, 100)
self.sleep2(80)
self.beep( NOTE_F6, 100)
self.sleep2(80)
self.beep( NOTE_E6, 100)
self.sleep2(80)
self.beep( NOTE_C6, 100)
self.sleep2(80)
self.beep( NOTE_A5, 100)
self.sleep2(300)
self.beep( NOTE_A5, 200)
self.sleep2(100)
self.beep( NOTE_D5, 200)
self.sleep2(100)
self.beep( NOTE_F5, 100)
self.sleep2(100)
self.beep( NOTE_G5, 100)
self.sleep2(100)
self.beep( NOTE_A5, 300)
self.sleep2(100)
self.beep( NOTE_A5, 200)
self.sleep2(100)
self.beep( NOTE_D5, 300)
self.sleep2(2000)
def storm2(self):
NOTE_B0 =31
NOTE_C1 =33
NOTE_CS1 =35
NOTE_D1 =37
NOTE_DS1 =39
NOTE_E1 =41
NOTE_F1 =44
NOTE_FS1 =46
NOTE_G1 =49
NOTE_GS1 =52
NOTE_A1 =55
NOTE_AS1 =58
NOTE_B1 =62
NOTE_C2 =65
NOTE_CS2 =69
NOTE_D2 =73
NOTE_DS2 =78
NOTE_E2 =82
NOTE_F2 =87
NOTE_FS2 =93
NOTE_G2 =98
NOTE_GS2 =104
NOTE_A2 =110
NOTE_AS2 =117
NOTE_B2 =123
NOTE_C3 =131
NOTE_CS3 =139
NOTE_D3 =147
NOTE_DS3 =156
NOTE_E3 =165
NOTE_F3 =175
NOTE_FS3 =185
NOTE_G3 =196
NOTE_GS3 =208
NOTE_A3 =220
NOTE_AS3 =233
NOTE_B3 =247
NOTE_C4 =262
NOTE_CS4 =277
NOTE_D4 =294
NOTE_DS4 =311
NOTE_E4 =330
NOTE_F4 =349
NOTE_FS4 =370
NOTE_G4 =392
NOTE_GS4 =415
NOTE_A4 =440
NOTE_AS4 =466
NOTE_B4 =494
NOTE_C5 =523
NOTE_CS5 =554
NOTE_D5 =587
NOTE_DS5 =622
NOTE_E5 =659
NOTE_F5 =698
NOTE_FS5 =740
NOTE_G5 =784
NOTE_GS5 =831
NOTE_A5 =880
NOTE_AS5 =932
NOTE_B5 =988
NOTE_C6 =1047
NOTE_CS6 =1109
NOTE_D6 =1175
NOTE_DS6 =1245
NOTE_E6 =1319
NOTE_F6 =1397
NOTE_FS6 =1480
NOTE_G6 =1568
NOTE_GS6 =1661
NOTE_A6 =1760
NOTE_AS6 =1865
NOTE_B6 =1976
NOTE_C7 =2093
NOTE_CS7 =2217
NOTE_D7 =2349
NOTE_DS7 =2489
NOTE_E7 =2637
NOTE_F7 =2794
NOTE_FS7 =2960
NOTE_G7 =3136
NOTE_GS7 =3322
NOTE_A7 =3520
NOTE_AS7 =3729
NOTE_B7 =3951
NOTE_C8 =4186
NOTE_CS8 =4435
NOTE_D8 =4699
NOTE_DS8 =4978
self.beep( NOTE_D5, 100)
self.sleep2(80)
self.beep( NOTE_F5, 100)
self.sleep2(80)
self.beep( NOTE_D6, 200)
self.sleep2(250)
self.beep( NOTE_D5, 100)
self.sleep2(80)
self.beep( NOTE_F5, 100)
self.sleep2(80)
self.beep( NOTE_D6, 200)
self.sleep2(250)
self.beep( NOTE_E6, 200)
self.sleep2(200)
self.beep( NOTE_F6, 100)
self.sleep2(100)
self.beep( NOTE_E6, 100)
self.sleep2(80)
self.beep( NOTE_F6, 100)
self.sleep2(80)
self.beep( NOTE_E6, 100)
self.sleep2(80)
self.beep( NOTE_C6, 100)
self.sleep2(80)
self.beep( NOTE_A5, 100)
self.sleep2(300)
from LED import LED
from flask import Flask
from flask import render_template, request, redirect, url_for
import _thread
app = Flask(__name__)
lights = LED(255, 102, 0, 1)
lights.gpio()
@app.route('/')
@app.route('/<int:power>')
@app.route('/<int:red>,<int:green>,<int:blue>')
@app.route('/<int:red>,<int:green>,<int:blue>,<int:power>')
def index(red=None, green=None, blue=None, power=None, function=None):
lights.fading = False
# only update color if a color is specified and max is 255
if red is None:
red = lights.red
if green is None:
green = lights.green
if blue is None:
blue = lights.blue
if power is None:
power = lights.power
elif power > 1 and power <= 100:
power /= 100
elif power > 100:
class ChannelFrame(wx.Panel):
def __init__(self, *args, **kwargs):
wx.Panel.__init__(self, *args, **kwargs)
self.StaticBox = wx.StaticBox(self, -1, "Channel")
self.StaticBoxSizer = wx.StaticBoxSizer(self.StaticBox, wx.VERTICAL)
self.grid = wx.GridBagSizer(0, 0)
self.On = wx.Button(self, -1, "ON", size=(58, 22))
self.Off = wx.Button(self, -1, "OFF", size=(58, 22))
self.Led = LED(self)
self.Led.SetState(0)
self.PWR = wx.StaticText(self,
label=u"Power [dBm]: ",
size=(120, 20),
style=wx.ALIGN_RIGHT)
self.WVL = wx.StaticText(self,
label=u"Wavelength [nm]: ",
size=(120, 20),
style=wx.ALIGN_RIGHT)
self.txtPWR = wx.TextCtrl(self, size=(80, 20), value="")
self.txtWVL = wx.TextCtrl(self, size=(80, 20), value="")
self.grid.Add(self.On,
pos=(0, 0),
flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.Off,
pos=(0, 1),
flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.Led,
pos=(0, 2),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.PWR,
pos=(1, 0),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0,
span=(1, 2))
self.grid.Add(self.WVL,
pos=(2, 0),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0,
span=(1, 2))
self.grid.Add(self.txtPWR,
pos=(1, 2),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.grid.Add(self.txtWVL,
pos=(2, 2),
flag=wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL,
border=0)
self.StaticBoxSizer.Add(self.grid, 0, wx.ALL | wx.LEFT, 0)
self.SetSizerAndFit(self.StaticBoxSizer)
def SetLabel(self, text):
self.StaticBox.SetLabel(str(text))
def SetChannelId(self, id):
self.On.SetId(id + 1)
self.Off.SetId(id)
def SetBind(self, handler):
self.Bind(wx.EVT_BUTTON, handler, self.On)
self.Bind(wx.EVT_BUTTON, handler, self.Off)
def SetLed(self, colour):
self.Led.SetState(colour)
def Configure(self, text, id, handler, LedStatus=0, txtPWR="", txtWVL=""):
self.SetLabel(text)
self.SetChannelId(id)
self.SetBind(handler)
self.Led.SetState(LedStatus)
self.txtPWR.SetValue(str(txtPWR))
self.txtWVL.SetValue(str(txtWVL))
def Update(self, LedStatus, txtPWR, txtWVL):
self.Led.SetState(LedStatus)
self.txtPWR.SetValue(str(txtPWR))
self.txtWVL.SetValue(str(txtWVL))
def GetValues(self):
PWR = self.txtPWR.GetValue()
WVL = self.txtWVL.GetValue()
return PWR, WVL
import RPi.GPIO as GPIO import time from LED import LED from Knop import Knop from Buzzer import Buzzer GPIO.setmode(GPIO.BCM) # knop1_ingedrukt = 1 # knop2_ingedrukt = 1 # knop3_ingedrukt = 1 # knop4_ingedrukt = 1 led = LED(25) buzzer = Buzzer(23) buttons = [21, 20, 16, 12] # GPIO.setup(led,GPIO.OUT) # GPIO.setup(buzzer,GPIO.OUT) # p = GPIO.PWM(buzzer,261) knop1 = Knop(buttons[0]) knop2 = Knop(buttons[1]) knop3 = Knop(buttons[2]) knop4 = Knop(buttons[3]) # GPIO.add_event_detect(button, GPIO.RISING, actie, 400) # def led_knipperen(): # GPIO.output(led,GPIO.HIGH) # time.sleep(0.5)
import threading
import os
from time import sleep
#configurations
distance_threshold = 20 #in CM
blink_beep_speed = Speed.FAST
#variables
picture_taken = False
#objects
sensor = UltrasonicSensor(19, 26)
email = Email()
camera = Camera()
grn_led = LED(13)
red_led = LED(6)
buzzer = Buzzer(5)
#methods
def blink_red():
red_led.blink(5, blink_beep_speed)
def blink_green():
grn_led.blink(5, blink_beep_speed)
def beep_buzzer():
buzzer.beep(5, blink_beep_speed)
class Eye:
def __init__(self):
self.LED1 = LED(17)
self.LED2 = LED(27)
self.LED3 = LED(22)
self.LED4 = LED(23)
self.LED5 = LED(24)
self.LED6 = LED(25)
def SetBrightness(self, brightness):
self.LED1.SetBrightness(brightness)
self.LED2.SetBrightness(brightness)
self.LED3.SetBrightness(brightness)
self.LED4.SetBrightness(brightness)
self.LED5.SetBrightness(brightness)
self.LED6.SetBrightness(brightness)
def SetDefault(self):
self.LED1.On()
self.LED2.Off()
self.LED3.Off()
self.LED4.Off()
self.LED5.Off()
self.LED6.Off()
def __init__(self):
self.LED1 = LED(17)
self.LED2 = LED(27)
self.LED3 = LED(22)
self.LED4 = LED(23)
self.LED5 = LED(24)
self.LED6 = LED(25)
class Shit_detector():
def __init__(self):
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
self.green_led = LED(5)
self.yellow_led = LED(13)
self.red_led = LED(21)
self.motor = Motor()
self.web_cam = cv.VideoCapture(0)
self.pi_cam = PiCamera()
self.angle = 0.25
self.open = False
self.face = None
self.server_ip = '10.10.3.21'
self.port = 8080
self.threshold = 20000
self.interval = 10
def lock(self):
self.motor.rotate(0)
def unlock(self):
self.motor.rotate(self.angle)
def reset(self):
self.unlock()
self.pi_cam.capture('origin.jpg')
self.lock()
def detect_face(self):
def call_back(channel):
self.open = True
button = Button(4, call_back)
detector = Face_detector()
while True:
_, img = self.web_cam.read()
if detector.has_face(img):
detector.mark_face(img)
self.green_led.turn_on()
time.sleep(self.interval / 2)
if self.open:
self.face = img
break
else:
self.green_led.turn_off()
self.green_led.turn_off()
self.open = False
def wait_for_flush(self):
client_socket = socket.socket(socket.AF_INET)
client_socket.connect((self.server_ip, self.port))
client_socket.recv(1024)
client_socket.close()
print('flushed !')
def detect_shit(self, img_after):
img_origin = cv.imread('origin.jpg')
diff = get_canny_sum_diff(img_origin, img_after)
if diff > self.threshold:
print('Difference: {} > threshold: {}'.format(
diff, self.threshold))
file_name = datetime.now().strftime("%Y-%m-%d %H:%M:%S").replace(
' ', '_')
cv.imwrite('face.jpg', self.face)
upload('.', 'face.jpg', file_name + '_face.jpg')
cv.imwrite('shit.jpg', img_after)
upload('.', 'shit.jpg', file_name + '_shit.jpg')
self.yellow_led.turn_on()
else:
print('Difference: {} < threshold: {}'.format(
diff, self.threshold))
self.yellow_led.turn_off()
def test(self):
print('start detect')
self.detect_face()
cv.imwrite('face.jpg', self.face)
print('finish')
def test2(self):
self.reset()
print('finish saving origin.jpg')
self.detect_face()
print('finish detect face')
self.pi_cam.capture('after.jpg')
img = cv.imread('after.jpg')
self.detect_shit(img)
print('finish detect shit')
def run(self):
self.reset()
while True:
print('detecting face ...')
self.detect_face()
print('unlock')
self.unlock()
time.sleep(self.interval)
print('lock')
self.lock()
self.red_led.turn_on()
print('wait for flush')
self.wait_for_flush()
print('unlock')
self.unlock()
time.sleep(self.interval)
print('get after image')
self.pi_cam.capture('after.jpg')
img_after = cv.imread('after.jpg')
print('lock')
self.lock()
print('detecting shit ...')
self.detect_shit(img_after)
print('finish detect shit')
self.red_led.turn_off()
def __del__(self):
self.web_cam.release()
from LED import LED
from flask import Flask
from flask import render_template, request, redirect, url_for
import thread
app = Flask(__name__)
if __name__ == "__main__":
app.run()
led1_red_pin = 23
led1_green_pin = 24
led1_bluepin = 25
led_1 = LED(0, 0, 0, 1, led1_red_pin, led1_green_pin, led1_bluepin)
led_1.gpio()
led2_red_pin = 16
led2_green_pin = 26
led2_bluepin = 21
led_2 = LED(0, 0, 0, 1, led2_red_pin, led2_green_pin, led2_bluepin)
led_2.gpio()
led3_red_pin = 17
led3_green_pin = 27
led3_bluepin = 22
led_3 = LED(0, 0, 0, 1, led3_red_pin, led3_green_pin, led3_bluepin)
led_3.gpio()
led4_red_pin = 5
led4_green_pin = 6
led4_bluepin = 13
from LED import LED
import board
import neopixel
led = LED(board.D18, 8, neopixel.GRB)
for i in range(3):
led.random(1)
#led.rainbow(10,2)
led.stop()
pwm = Adafruit_PCA9685.PCA9685() #init for PWM driver
pwm.set_pwm_freq(200)
sockid = lirc.init("myprog", blocking=False) #init for LIRC socket
red = Color(255, 0, 0) #instantiate color objects from colors.py
green = Color(0, 255, 0)
blue = Color(0, 0, 255)
yellow = Color(215, 200, 0)
orange = Color(255, 50, 0)
turquoise = Color(0, 255, 255)
purple = Color(255, 0, 255)
gray = Color(100, 100, 100)
white = Color(255, 255, 255)
led1 = LED(0, 1, 2) #instantiate 3 LED objects for this 3 LED system
led2 = LED(3, 4, 5) #LED(R,G,B) = PWM board pin numbers
led3 = LED(6, 7, 8)
t = [led1, led2, led3] #list used to cycle through for modes
class System():
def __init__(self):
self.bright = .5
self.delay = .5
self.mode = 'Ok'
self.modenum = 0
self.args = None
def turnon(self, color):
pub.sendMessage(led_topic, rate=last_rate) # Set individual LED.
# Create POT class instances.
pot = POT(analog_channel=POT_CHANNEL,
min_value=MIN_BLINK_RATE_SECS,
max_value=MAX_BLINK_RATE_SECS,
poll_secs=POT_POLL_SECS,
name="MyPOT")
# Last rate/value from Potentiometer/ADC.
last_rate = pot.get_value()
# Create LED class instances.
led1 = LED(gpio=13, pi=pi, name="MyLED")
led2 = LED(gpio=19, pi=pi, name="MyOtherLED")
# Topic names to communicate with individual LEDs.
LED_TOPICS = [
led1.topic, # == "LED.MyLED"
led2.topic # == "LED.MyOtherLED"
]
# The index of the LED in LEDS which will
# be affected when the potentiometer value changes.
led_index = 0
# Subscribe to POT and BUTTON messages using the on_message_* methods.
pub.subscribe(on_button_message, button.topic)
pub.subscribe(on_pot_message, pot.topic)
