class ButtonOff(threading.Thread):
def __init__(self, btnID):
threading.Thread.__init__(self)
self.lcd = LCD()
self.dName = 'Button-Press'
self.btnID = btnID
GPIO.setup(self.btnID, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def run(self):
while True:
if not GPIO.input(self.btnID):
threading.Thread(target=self.beep).start()
str = "Btn On Pressed!"
self.lcd.print(str)
print(str)
threading.Thread(target=self.offOutSideLights).start()
time.sleep(0.2)
def buzzerOff(self):
pin = 16
GPIO.setup(pin, GPIO.OUT)
GPIO.output(pin, False)
self.updateStatus(0, 60)
def offOutSideLights(self):
conn = ConnectionDB()
data = conn.getAllOutSideLights()
devices = []
for app in data:
devices.append(app['conn_d_id'])
macros = MacroCommand(devices, 'off', self.lcd, 'system')
macros.execute()
def sessie(hall=AH3661(26)):
GPIO.setup(18, GPIO.OUT)
while True:
global stop
stop = False
uid, found = serialReadBadgeID() # get BadgeID
correctuid = datatodb.correct_badgeID(uid) # Check badgeID
if found is True and correctuid is True:
init_speed_distance() # Standard values on LCD
buzzer(True) # when badged, buzz
datatodb.create_session(uid,
datetime.datetime.now()) # Create session
hall.create_event() # create event
uid2, stop = serialReadBadgeID() # get badgeID
correctuid2 = datatodb.correct_badgeID(uid2) # Check badgeID
if found is stop and correctuid2 is True:
buzzer(True) # when badged, buzz
eind = datetime.datetime.now()
print("sessie is gedaan")
datatodb.save_session(eind, round(hall.distance, 2))
hall.remove_event() # delete session
lcd = LCD()
lcd.stuur_instructie(1)
break
else:
buzzer(False) # when badged, buzz
pass
class Microprocessor(Receiver):
in_0 = KeyboardPanel()
out_0 = LCD()
out_1 = Bell()
out_2 = Lock()
def __init__(self):
self.olh = OpenLockHandler(self)
self.clh = ClosedLockHandler(self)
self.pkh = PassKeyHandler(self)
self.ckh = CtrlKeyHandler(self)
self.pkch = PassKeyChangeHandler(self)
self.cbh = CallButtonHandler(self)
self.pkah = PassKeyAcceptHandler(self.pkh, self)
self.ckah = PassKeyAcceptHandler(self.ckh, self)
self.cbh.set_next(self.clh).set_next(self.pkh).set_next(
self.olh).set_next(self.ckh).set_next(self.ckh).set_next(self.pkch)
def receive_signal(self, signal):
signal = self.in_0.invoke()
self.cbh.handle(signal)
self.out_0.receive_signal(signal)
def procedure(self):
self.out_2.receive_signal(None)
print(f"Lock: {self.out_2.state.info}")
def __init__(self):
''' Initialization code '''
self.busy = False
self.masterMode = False
#Initialize system components
self.rfidReader = RFIDReader()
self.keypad = Keypad()
self.lcd = LCD()
self.doorLatch = DoorLatch()
self.database = Database()
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_address = ('192.168.43.206', 8888)
self.socket.bind(self.server_address)
self.correct_pin = self.database.getCorrectPin()
self.entered_pin = ""
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 __init__(self, test=False):
logging.getLogger().setLevel(logging.INFO)
logging.info("Starting")
if not test:
from LCD import LCD
from Reader import Reader
from Keypad import Keypad
self.lcd = LCD()
self.reader = Reader()
self.keypad = Keypad()
else:
from testLCD import TestLCD
from testReader import TestReader
from testKeypad import TestKeypad
self.lcd = TestLCD()
self.reader = TestReader()
self.keypad = TestKeypad()
def __init__(self, database):
self.pins = [RaspberryPi.GPIO0,
RaspberryPi.GPIO1,
RaspberryPi.GPIO2,
RaspberryPi.GPIO3,
RaspberryPi.GPIO4,
RaspberryPi.GPIO5,
RaspberryPi.GPIO6]
self.active = 0
pin0 = {RaspberryPi.GPIO1: '2',
RaspberryPi.GPIO6: '5',
RaspberryPi.GPIO5: '8',
RaspberryPi.GPIO3: '0'}
pin2 = {RaspberryPi.GPIO1: '1',
RaspberryPi.GPIO6: '4',
RaspberryPi.GPIO5: '7',
RaspberryPi.GPIO3: '*'}
pin4 = {RaspberryPi.GPIO1: '3',
RaspberryPi.GPIO6: '6',
RaspberryPi.GPIO5: '9',
RaspberryPi.GPIO3: '#'}
self.lookup = {RaspberryPi.GPIO0: pin0,
RaspberryPi.GPIO2: pin2,
RaspberryPi.GPIO4: pin4}
self.message = ''
self.password = ''
self.typePassword = 0
for i in range(3):
GPIO.setup(self.pins[::2][i], GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(self.pins[1::2][i], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(self.pins[6], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
self.buzzer = Buzzer()
self.lcd = LCD()
self.database = database
self.setup_callbacks()
self.loop()
def toon_start_info(lcd=LCD()):
initLCD()
lcd.stuur_tekst("Programma wordt gestart")
time.sleep(2)
lcd.stuur_instructie(1)
lcd.stuur_tekst("IP adres wordt getoond in 3")
time.sleep(1)
lcd.stuur_instructie(0x4B | 0b10000000)
lcd.stuur_tekst("2")
time.sleep(1)
lcd.stuur_instructie(0x4B | 0b10000000)
lcd.stuur_tekst("1")
time.sleep(1)
lcd.stuur_instructie(1)
lcd.stuur_tekst(str(get_ip_address())) # Toon ip address op scherm
time.sleep(5)
lcd.stuur_instructie(1)
#!/usr/bin/python
# https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code/tree/master/Adafruit_CharLCD
from LCD import LCD
from subprocess import *
from time import sleep, strftime
from datetime import datetime
lcd = LCD()
cmd = "ip addr show wlan0 | grep inet | awk '{print $2}' | cut -d/ -f1"
lcd.begin(16,1)
def run_cmd(cmd):
p = Popen(cmd, shell=True, stdout=PIPE)
output = p.communicate()[0]
return output.split('\n')[0]
while 1:
lcd.clear()
ipaddr = run_cmd(cmd)
lcd.message(datetime.now().strftime('%b %d %H:%M:%S\n'))
lcd.message('IP %s' % ( ipaddr ) )
sleep(1)
import time
import requests
from LCD import LCD
URL = 'http://localhost:8000'
LCD_ADDRESS = 0x27
lcd = LCD(2, LCD_ADDRESS, True)
lcd.clear()
counter = 0
while True:
try:
data = requests.get(URL).json()
temp_text = '{:.1f}C'.format(data['temperature'])
hum_text = '{:.1f}%'.format(data['humidity'])
counter = (counter + 1) % 11
temp_c = 0
while temp_c < counter:
temp_text = ' '+temp_text
hum_text = ' '+hum_text
temp_c += 1
lcd.clear()
lcd.message(temp_text, 1)
lcd.message(hum_text, 2)
except:
lcd.clear()
lcd.message("Service", 1)
lcd.message("Unavailable", 2)
time.sleep(3)
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()
from LCD import LCD
from mpd import MPDClient
import time
import random
DISP_LEN = 20
lcd = LCD() # params available for rPi revision, I2C Address, and backlight on/off
# lcd = LCD(2, 0x3F, True)
client = MPDClient()
client.connect("localhost", 6600)
def display_long_text(from_ch, txt):
return txt[from_ch:]
def display_text(txt, prev_pos=0):
if len(txt) > DISP_LEN:
if prev_pos == 0:
return display_long_text(prev_pos, txt), prev_pos+1
elif DISP_LEN-1 == (len(txt)-prev_pos):
return display_long_text(prev_pos, txt), 0
else:
return display_long_text(prev_pos, txt), prev_pos+1
else:
return txt, 0
def parse_audio(audio):
d = audio.split(":")
#!/usr/bin/python
# https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code/tree/master/Adafruit_CharLCD
from LCD import LCD
from subprocess import *
from time import sleep, strftime
from datetime import datetime
lcd = LCD()
cmd = "ip addr show wlan0 | grep inet | awk '{print $2}' | cut -d/ -f1"
lcd.begin(16, 1)
def run_cmd(cmd):
p = Popen(cmd, shell=True, stdout=PIPE)
output = p.communicate()[0]
return output.split('\n')[0]
while 1:
lcd.clear()
ipaddr = run_cmd(cmd)
lcd.message(datetime.now().strftime('%b %d %H:%M:%S\n'))
lcd.message('IP %s' % (ipaddr))
sleep(1)
print light
# on Close Box
def suspend(number):
global saved_number
if number != saved_number:
f = open('datafile.txt', 'w')
f.write(str(number))
saved_number = number
f.close()
# on PowerON
def resume():
num = 0
try:
f = open('datafile.txt', 'r')
num = int(f.read())
f.close()
except:
num = 0
return num
tsl = TSL2561()
lcd = LCD()
start_number = resume()
target = liblo.Address('127.0.0.1', 12000)
tak(17, 10, 0)
class SmartDoorLockSystem:
''' Smart Door Lock System Logic '''
def __init__(self):
''' Initialization code '''
self.busy = False
self.masterMode = False
#Initialize system components
self.rfidReader = RFIDReader()
self.keypad = Keypad()
self.lcd = LCD()
self.doorLatch = DoorLatch()
self.database = Database()
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_address = ('192.168.43.206', 8888)
self.socket.bind(self.server_address)
self.correct_pin = self.database.getCorrectPin()
self.entered_pin = ""
def listen_for_messages(self):
"""
Listen for incoming UDP messages
Parameters
----------
None
Returns
-------
None
"""
#Listen for incoming UDP messages and proces them accordingly using the enum defined in UDP.py
while True:
buf, address = self.socket.recvfrom(2048)
if len(buf):
UDP.processMessage(buf, self.doorLatch)
def updateDoorStatusInApp(self):
"""
Send a UDP message of the current doorState to the app on every iteration
Parameters
----------
None
Returns
-------
None
"""
#Setup the target of the UDP messages and the send the current door state
host = "192.168.43.1"
port = 8888
target_address = (host, port)
data = self.doorLatch.status
self.socket.sendto(data.encode('utf-8'), target_address)
def main(self):
#Create a new thread to always listen for UDP messages
t = Thread(target=self.listen_for_messages)
t.daemon = True
t.start()
#Infinite Loop
while True:
#
# RFID LOGIC
#
if (
self.busy != True
): #self.busy variable is needed to prevent the logic loop from breaking
#Scan for an RFID card every iteration
tagID = self.rfidReader.grab_rfid_data()
#If the tagID returned was nothing (no tag was scanned)
if (tagID[0] != ""): #tagID is a tuple
self.busy = True
#If a master tag was scanned, switch between normal mode and master mode
if (self.database.isMasterTag(tagID[0])):
if (self.masterMode):
self.lcd.setText('')
self.masterMode = False
time.sleep(1)
else:
self.lcd.setText('MASTER MODE')
self.masterMode = True
time.sleep(1)
#If a normal tag was scanned
else:
#If in master mode
if (self.masterMode):
#Remove the tag from the database if found
if (self.database.isTagInDatabase(tagID[0])):
if (self.database.removeTagFromDatabase(
tagID[0])):
self.lcd.setText('TAG DEACTIVATED', 2)
else:
self.lcd.setText(
'FAILED TO \nDEACTIVATE TAG', 2)
#Add the tag to the database if not found
else:
if (self.database.addTagToDatabase(tagID[0])):
self.lcd.setText('TAG ACTIVATED', 2)
else:
self.lcd.setText(
'FAILED TO \nACTIVATE TAG', 2)
#If in normal mode
else:
#If the tag is in the database, unlock the door
if self.database.isTagInDatabase(tagID[0]):
self.doorLatch.unlockDoor()
self.lcd.setText('ACCESS GRANTED', 2)
time.sleep(3)
self.doorLatch.lockDoor()
#If the tag is NOT in the database, log the failed entry
else:
self.lcd.setText('ACCESS DENIED', 2)
self.database.logFailedAccess()
#
# KEYPAD LOGIC
#
#If a key was pressed on the keypad
if (self.keypad.lastKeyPressed != ""):
self.busy = True
#Append the key to the pin being entered
self.entered_pin = self.entered_pin + self.keypad.lastKeyPressed
self.lcd.setText(self.entered_pin)
#Cancel pin entry if the '#' button is pressed on the keypad
if ((self.keypad.lastKeyPressed == '#')):
self.lcd.setText("Cancelled PIN \nEntry", 2)
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#If the '*' key is pressed, submit the entered keycode
if ((self.keypad.lastKeyPressed == '*')):
#If the entered pin is of the correct length
if ((len(self.entered_pin) - 1) == len(
self.correct_pin)):
#If the user entered the correct pin
if (self.entered_pin[:-1] == self.correct_pin):
#Update the system state
self.doorLatch.unlockDoor()
self.lcd.setText("ACCESS GRANTED", 2)
time.sleep(3)
self.doorLatch.lockDoor()
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#If the user entered the incorrect pin
else:
#Update the system state, and log the failed entry
self.lcd.setText("ACCESS DENIED", 2)
self.database.logFailedAccess()
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#If the user entered pin is longer than the correct pin
else:
self.lcd.setText("Invalid PIN \nFormat", 2)
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#If the user entered pin is shorter than the correct pin
elif (len(self.entered_pin) > len(self.correct_pin)):
#Flash LED
self.lcd.setText("Invalid PIN \nFormat", 2)
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#Clear the lastKeyPressed on every iteration
self.keypad.lastKeyPressed = ""
#If the physical unlock button is pressed, update the system state
if (Button.isUnlockButtonPressed()
and (self.doorLatch.status == "LOCKED")):
self.doorLatch.unlockDoor()
self.lcd.setText("DOOR UNLOCKED", 1)
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#If the physical lock button is pressed, update the system state
if (Button.isLockButtonPressed()
and (self.doorLatch.status == "UNLOCKED")):
self.doorLatch.lockDoor()
self.lcd.setText("DOOR LOCKED", 1)
self.entered_pin = ""
self.keypad.lastKeyPressed = ""
#Flush the serial input on every iteration, to prevent a tag from being read multiple times
self.rfidReader.ser.flushInput()
#Reset the busy state to False
self.busy = False
#If in master mode, clearly display that this is the case
if (self.masterMode):
self.lcd.setText('MASTER MODE')
#Update the door status in app
self.updateDoorStatusInApp()
#!/usr/bin/python from LCD import LCD from subprocess import * from time import sleep, strftime from datetime import datetime from threading import Thread import RPi.GPIO as GPIO import urllib3 import threading import signal import os import sys GPIO.setwarnings(0) lcd = LCD() lcd.begin(16,1) class SpotiPi: keeprunning = True oldsong = "" songname = "" artist = "" ip = "192.168.1.4" http = urllib3.PoolManager() printit = 0 lock = threading.RLock() def printSong(self): while(1): if self.keeprunning == True: with self.lock:
def main():
# create objects
myLCD = LCD(CS1=17, CS2=7, E=15, RS=14, D0=27, D1=23, D2=24, D3=25, D4=8, D5=11, D6=9, D7=22, PWM=1) #PWM pin number is wiringPi numbering!
myAM2302 = AM2302(pin=4)
myCalendar = GoogleCalendar()
# set the initial backlight flag
if isNight():
backlightNightFlag = 1
myLCD.setBacklightPWM(BACKLIGHT_NIGHT_VALUE)
else:
backlightNightFlag = 0
myLCD.setBacklightPWM(BACKLIGHT_DAY_VALUE)
last_update = datetime.datetime.now() - datetime.timedelta(seconds=UPDATE_FREQUENCY_BUS)
while(True):
# dim backlight if its night
if isNight():
if backlightNightFlag == 0:
backlightNightFlag = 1
myLCD.setBacklightPWM(BACKLIGHT_NIGHT_VALUE)
elif backlightNightFlag == 1:
backlightNightFlag = 0
myLCD.setBacklightPWM(BACKLIGHT_DAY_VALUE)
# update bus/temp only every n secs
if (datetime.datetime.now() - last_update).seconds >= UPDATE_FREQUENCY_BUS:
# get bus
next_bus_dict = get_next_bus()
# update calendar data
events = myCalendar.get_events()
if len(events) > 1: # only display next 2 events
running_string = events[0] + ' - ' + events[1]
elif len(events) == 0:
running_string = 'No events scheduled'
else: # only 1 event
running_string = events[0]
running_string_2 = running_string + ' - ' + running_string # double string to make it easier for running it over the screen
running_index = 0
display_next_buses(myLCD, next_bus_dict)
temp, hum = myAM2302.get_data()
display_room_climate_data(myLCD, temp, hum)
log_room_climate_data('/home/pi/Infoscreen/room_climate.log', temp, hum)
last_update = datetime.datetime.now()
# print the running text for the calendar
currently_displayed_string = running_string_2[running_index:running_index+16]
myLCD.printString(currently_displayed_string,7)
if running_index == len(running_string) + 2: #2=3-1, 3= number of characters in separator (' - ')
running_index = 0
else:
running_index += 1
sleep(0.3)
def display_next_buses(LCD, bus_dict):
for i in range(len(bus_dict['busNr'])):
line_to_display = bus_dict['busNr'][i] + ': ' + bus_dict['timeToNextBus'][i] + ' min (' + bus_dict['delay'][i] + ')'
LCD.printString(line_to_display, i)
def show_on_lcd(self):
lcd = LCD()
lcd.stuur_instructie(0x0C | 0b10000000)
lcd.stuur_tekst(str(round(self.speed, 2)))
lcd.stuur_instructie(0x4C | 0b10000000)
lcd.stuur_tekst(str(round(self.distance, 2)))
lcd.stuur_instructie(12)
def initLCD(lcd=LCD()):
lcd.stuur_instructie(56) # 8-bit, 2 lines, character font 5x10
lcd.stuur_instructie(12) # display aan, cursor uit, cursor blink uit
lcd.stuur_instructie(1) # clear display en cursor home
def init_speed_distance(lcd=LCD()):
lcd.stuur_tekst("Snelheid:")
lcd.stuur_instructie(0x40 | 0b10000000)
lcd.stuur_tekst("Afstand:")
lcd.stuur_instructie(12)
dht11Pin = 14
dht22Pin = 15
relaisPinOpen = 17
relaisPinClose = 27
ledPinRed = 23
ledPinGreen = 24
d11 = DHTSensor(dht11Pin, 'DHT11', True)
d22 = DHTSensor(dht22Pin, 'DHT22', True)
windowOpen = Relais(relaisPinOpen, 5)
windowClose = Relais(relaisPinClose, 5)
lcd = LCD()
ledRed = LED(ledPinRed)
ledGreen = LED(ledPinGreen)
dispatcher = Dispatcher(d11, d22, ledRed, ledGreen, lcd, windowOpen, windowClose, True)
#button = Button()
#button.run()
try:
while True:
dispatcher.main()
time.sleep(delay)
except KeyboardInterrupt:
import Adafruit_DHT
import sys, time
import MySQLdb
from blink import LED
from LCD import LCD
import warnings
warnings.filterwarnings("ignore")
db = MySQLdb.connect("localhost", "mine", "secret", "finalproject")
cur = db.cursor()
sensor = Adafruit_DHT.DHT11
pin = 4
id = 1
mid = 'r1'
while True:
humid, temp = Adafruit_DHT.read_retry(sensor, pin)
if humid is not None and temp is not None:
print('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(temp, humid))
LED(humid)
time.sleep(5)
now = time.strftime('%Y-%m-%d %H:%M:%S')
cur.execute('insert into datain values(%s, %s, %s, %s, %s)',
(mid, temp, humid, now, id))
db.commit()
LCD(db)
else:
print('Failed to get reading. Try again!')
def display_room_climate_data(LCD, temp, hum):
LCD.printString('Temp: ' + str(round(temp,1)) + ' øC',4)
LCD.printString('Hum: ' + str(round(hum,1)) + ' %',5)
def display1(self, str):
lcd = LCD()
lcd.print(str)
del lcd
def start(self):
# change these as desired - they're the pins connected from the
# SPI port on the ADC to the Cobbler
SPICLK = RaspberryPi.SPI_CE1 #CLK
SPIMISO = RaspberryPi.SPI_CE0 #DOUT
SPIMOSI = RaspberryPi.SPI_SCLK #DIN
SPICS = RaspberryPi.SPI_MISO #CS
# set up the SPI interface pins
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)
# 10k trim pot connected to adc #0
potentiometer_adc = 0;
last_read = 0 # this keeps track of the last potentiometer value
tolerance = 5 # to keep from being jittery we'll only change
# volume when the pot has moved more than 5 'counts'
buzzer = Buzzer()
lcd = LCD()
lcd.Blink()
printed = False
try:
while True:
# we'll assume that the pot didn't move
trim_pot_changed = False
# read the analog pin
trim_pot = self.readadc(potentiometer_adc, SPICLK, SPIMOSI, SPIMISO, SPICS)
# how much has it changed since the last read?
pot_adjust = abs(trim_pot - last_read)
if DEBUG:
print "trim_pot:", trim_pot
print "pot_adjust:", pot_adjust
print "last_read", last_read
if ( pot_adjust > tolerance ):
trim_pot_changed = True
if DEBUG:
print "trim_pot_changed", trim_pot_changed
if ( trim_pot_changed ):
value = trim_pot / 10.24 # convert 10bit adc0 (0-1024) trim pot read into 0-100 volume level
value = round(value) # round out decimal value
value = int(value) # cast volume as integer
number = '';
printedNumber = ''
released = False
if ( value != 60):
if (value >= 75 and value < 80):
number ='1'
elif (value >= 69 and value < 74):
number ='2'
elif (value >= 64 and value <= 70):
number ='3'
elif (value >= 0 and value <= 12):
number ='4'
elif (value >= 32 and value <= 37):
number ='5'
elif (value >= 38 and value <= 44):
number ='6'
elif (value >= 21 and value <= 26):
number ='7'
elif (value >= 83 and value <= 90):
number ='8'
elif (value >= 45 and value <= 51):
number ='9'
elif (value >= 54 and value <= 59):
number ='*'
elif (value >= 94 and value <= 100):
number ='0'
elif (value >= 50 and value <= 53):
number ='#'
else:
print "Dunno: ", value
if (value == 60):
released = True
printed = False
if(number != printedNumber and not printed):
printedNumber = number
print number, value
lcd.message(number)
buzzer.beep(659, 125)
printed = True
time.sleep(0.1)
if(number == '*'):
self.typePassword = 1
self.password = ''
elif(number == '#' and self.typePassword == 1):
lcd.noBlink()
self.typePassword = 0
user = self.database.check_login(self.password)
print user
sleep_time = 1
if(user != 'Invalid Code'):
sleep_time = 5
self.led.show_status_light = 1
system_status = self.database.system_status()
if(system_status == '1'):
self.sp.stop_timer()
self.sp.soundingAlarm = 0
self.database.system_disarm()
message = 'User '+user['first_name']+' '+user['last_name']+' disarmed the system'
print message
self.database.log(message)
print user['first_name']+' '+user['last_name']
user = '******'+user['first_name']+' '+user['last_name']
else:
self.database.system_arm()
user = user['first_name']+' '+user['last_name']+'\nArmed The System'
self.database.log(user)
time.sleep(0.5)
lcd.clear()
lcd.message(user)
self.message = ''
time.sleep(sleep_time)
lcd.clear()
lcd.Blink()
if(self.password == '1111'):
print 'play mario'
mario_thread = threading.Thread(target=self.play_song(),)
print 'die mario'
mario_thread.start()
elif(self.typePassword == 1):
if(number != '*'):
self.password += number
time.sleep(0.01)
except KeyboardInterrupt:
GPIO.cleanup()
print "\nKill"
def display2(self, str1, str2):
lcd = LCD()
lcd.printB(str1, str2)
del lcd
# -*- coding: utf-8 -*-
from flask import Flask, render_template, request, jsonify
from LCD import LCD
import subprocess
import os
app = Flask(__name__)
lcd = LCD()
lcd.init(C=False, B=False)
lcd.clear()
@app.route("/")
def Index():
return render_template("index.html")
@app.route("/api/LCD")
def _writeLCD():
data = request.args
lcd.clear()
for i in range(4):
lcd.moveLine(i)
lcd.writeText(data["line" + str(i + 1)])
subprocess.call(["fswebcam", "/home/pi/FlaskLCD/static/out.jpg"])
return jsonify(data="success")
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=True)
class Keypad:
def __init__(self, database):
self.pins = [RaspberryPi.GPIO0,
RaspberryPi.GPIO1,
RaspberryPi.GPIO2,
RaspberryPi.GPIO3,
RaspberryPi.GPIO4,
RaspberryPi.GPIO5,
RaspberryPi.GPIO6]
self.active = 0
pin0 = {RaspberryPi.GPIO1: '2',
RaspberryPi.GPIO6: '5',
RaspberryPi.GPIO5: '8',
RaspberryPi.GPIO3: '0'}
pin2 = {RaspberryPi.GPIO1: '1',
RaspberryPi.GPIO6: '4',
RaspberryPi.GPIO5: '7',
RaspberryPi.GPIO3: '*'}
pin4 = {RaspberryPi.GPIO1: '3',
RaspberryPi.GPIO6: '6',
RaspberryPi.GPIO5: '9',
RaspberryPi.GPIO3: '#'}
self.lookup = {RaspberryPi.GPIO0: pin0,
RaspberryPi.GPIO2: pin2,
RaspberryPi.GPIO4: pin4}
self.message = ''
self.password = ''
self.typePassword = 0
for i in range(3):
GPIO.setup(self.pins[::2][i], GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(self.pins[1::2][i], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(self.pins[6], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
self.buzzer = Buzzer()
self.lcd = LCD()
self.database = database
self.setup_callbacks()
self.loop()
def setup_callbacks(self):
for i in range(3):
GPIO.add_event_detect(self.pins[1::2][i], GPIO.RISING,
callback=self.callback, bouncetime=200)
GPIO.add_event_detect(self.pins[6], GPIO.RISING,
callback=self.callback, bouncetime=200)
def callback(self, channel):
if (GPIO.input(channel)):
char = self.lookup[self.active][channel]
#self.buzzer.beep(659, 125)
print 'PRESS: ', char
self.message += char
self.lcd.clear()
self.lcd.message(self.message)
if(char == '*'):
self.typePassword = 1
self.password = ''
elif(char == '#' and self.typePassword == 1):
self.typePassword = 0
user = self.database.check_login(self.password)
sleep(0.5)
self.lcd.clear()
self.lcd.message(user)
self.message = ''
sleep(3)
self.lcd.clear()
elif(self.typePassword == 1):
self.password += char
def loop(self):
while True:
for i in range(3):
self.active = self.pins[::2][i]
GPIO.output(self.active, True)
sleep(0.01)
GPIO.output(self.active, False)
def __init__(self, btnID):
threading.Thread.__init__(self)
self.lcd = LCD()
self.dName = 'Button-Press'
self.btnID = btnID
GPIO.setup(self.btnID, GPIO.IN, pull_up_down=GPIO.PUD_UP)
display.write(get_date())
now = datetime.datetime.now()
sec = int(now.strftime("%S"))
time.sleep(60-sec)
display.clear_display()
display.write(get_time())
display.new_line()
display.write(get_date())
def update():
display.clear_display()
display.write(get_time())
display.new_line()
display.write(get_date())
display = LCD(12, 16, 18, 22, 24, 26, 32, 36, 10, 8)
display.function_set()
display.init_cursor()
display.clear_display()
#start()
#while True:
#time.sleep(60)
#date = get_date()
#time1 = get_time()
#display.clear_display()
#display.write(time1)
#display.new_line()
#display.write(date)
