Created
June 28, 2019 08:41
-
-
Save sunsetsonwheels/b4e9f2640c65e8fa1ac8ca1e5ebac17d to your computer and use it in GitHub Desktop.
lcdsmart
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from gpiozero import MCP3008, LED, Button | |
from time import localtime, sleep | |
from lcddriver import lcd | |
from json import load | |
from os import getcwd | |
from os.path import join | |
from pyowm import OWM | |
print("-------------------------------------------------------------") | |
print("-------------------------------------------------------------") | |
print("DeskClockPi v0.1") | |
print("'A smart clock in a cardboard box'") | |
print("-------------------------------------------------------------") | |
print("-------------------------------------------------------------") | |
altIndex = 0 | |
led = LED(17) | |
button = Button(27) | |
display = lcd() | |
display.lcd_clear() | |
display.lcd_display_string("DeskClockPi", 1) | |
display.lcd_display_string("Now loading...", 2) | |
owm = OWM("cc2dbc8e660e2dd27440b3abdb90e335") | |
refreshedHour= 0 | |
refreshFirst = True | |
weather = None | |
def poweroff(): | |
led.off() | |
display.lcd_clear() | |
display.lcd_display_string("Powered off!", 1) | |
exit() | |
def addindex(): | |
global altIndex | |
if altIndex < 2: | |
altIndex += 1 | |
elif altIndex >= 2: | |
altIndex = 0 | |
button.when_pressed = poweroff | |
led.on() | |
while True: | |
lcTime = localtime() | |
formattedTime = None | |
display.lcd_clear() | |
if len(str(lcTime.tm_hour)) < 2: | |
formattedTime = str(0)+str(lcTime.tm_hour) | |
else: | |
formattedTime = str(lcTime.tm_hour) | |
formattedTime = formattedTime+":" | |
if len(str(lcTime.tm_min)) < 2: | |
formattedTime = formattedTime+str(0)+str(lcTime.tm_min) | |
else: | |
formattedTime = formattedTime+str(lcTime.tm_min) | |
formattedTime = formattedTime+" " | |
if len(str(lcTime.tm_mday)) < 2: | |
formattedTime = formattedTime+str(0)+str(lcTime.tm_mday) | |
else: | |
formattedTime = formattedTime+str(lcTime.tm_mday) | |
formattedTime = formattedTime+"/" | |
if len(str(lcTime.tm_mon)) < 2: | |
formattedTime = formattedTime+str(0)+str(lcTime.tm_mon) | |
else: | |
formattedTime = formattedTime+str(lcTime.tm_mon) | |
formattedTime = formattedTime+"/"+str(lcTime.tm_year) | |
display.lcd_display_string(formattedTime, 1) | |
if altIndex == 0: | |
display.lcd_display_string("In. Temp: "+str(round(MCP3008(0).value*330/1023*1000, 1))+chr(223)+"C", 2) | |
elif altIndex == 1: | |
calendarjson = load(open(join(getcwd(), "calendar.json"), 'r')) | |
if calendarjson["events"]: | |
for events in calendarjson["events"]: | |
if calendarjson["events"][events]["eventDate"] == formattedTime.split(" ")[1]: | |
display.lcd_display_string(events, 2) | |
else: | |
display.lcd_display_string("No events today", 2) | |
sleep(5) | |
else: | |
display.lcd_display_string("No events today", 2) | |
del calendarjson | |
elif altIndex == 2: | |
if not refreshedHour: | |
refreshedHour = lcTime.tm_hour | |
if refreshFirst: | |
weather = str(owm.weather_at_place('Kuala Lumpur,MY').get_weather().get_status()) | |
refreshFirst = False | |
elif refreshedHour < lcTime.tm_hour+2: | |
weather = str(owm.weather_at_place('Kuala Lumpur,MY').get_weather().get_status()) | |
display.lcd_display_string("Outside: "+weather, 2) | |
addindex() | |
del lcTime | |
del formattedTime | |
sleep(5) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from flask import Flask, jsonify, make_response, request, abort | |
from json import dump, load | |
from os import getcwd | |
from os.path import isfile, join | |
from gpiozero import MCP3008 | |
calendarjson = {"events": {}} | |
if not isfile(join(getcwd(), "calendar.json")): | |
dump(calendarjson, open(join(getcwd(), "calendar.json"), 'w+')) | |
calendarjson = load(open(join(getcwd(), "calendar.json"), 'r')) | |
app = Flask(__name__) | |
@app.route("/calendar", methods=["POST"]) | |
def processrequest(): | |
try: | |
if request.json["method"] == "add": | |
if not request.json["params"]["eventName"] in calendarjson["events"]: | |
calendarjson["events"][request.json["params"]["eventName"]] = {"eventTime": request.json["params"]["eventTime"], | |
"eventDate": request.json["params"]["eventDate"]} | |
dump(calendarjson, open(join(getcwd(), "calendar.json"), 'w')) | |
return make_response(jsonify({"status": "OK"}), 200) | |
else: | |
return make_response(jsonify({"error:logic": "Event already exists!"}), 400) | |
elif request.json["method"] == "delete": | |
if request.json["params"]["eventName"] in calendarjson["events"]: | |
del calendarjson["events"][request.json["params"]["eventName"]] | |
dump(calendarjson, open(join(getcwd(), "calendar.json"), 'w')) | |
return make_response(jsonify({"status": "OK"}), 200) | |
else: | |
return make_response(jsonify({"error:logic": "Event doesn't exist yet!"}), 400) | |
elif request.json["method"] == "list": | |
return make_response(jsonify({"status": "OK", "events": calendarjson["events"]}), 200) | |
else: | |
return make_response(jsonify({"error:logic": "Method doesn't exist!"})) | |
except Exception as e: | |
return make_response(jsonify({"error:python": str(e)}), 400) | |
@app.route("/temperature", methods=["GET"]) | |
def gettemperature(): | |
return make_response(jsonify({"temperature": MCP3008(0).value*330/1023*1000}), 200) | |
if __name__ == "__main__": | |
app.run(host='0.0.0.0') |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# -*- coding: utf-8 -*- | |
# Original code found at: | |
# https://gist.github.com/DenisFromHR/cc863375a6e19dce359d | |
# http://www.circuitbasics.com/raspberry-pi-i2c-lcd-set-up-and-programming/ | |
""" | |
Compiled, mashed and generally mutilated 2014-2015 by Denis Pleic | |
Made available under GNU GENERAL PUBLIC LICENSE | |
# Modified Python I2C library for Raspberry Pi | |
# as found on http://www.recantha.co.uk/blog/?p=4849 | |
# Joined existing 'i2c_lib.py' and 'lcddriver.py' into a single library | |
# added bits and pieces from various sources | |
# By DenisFromHR (Denis Pleic) | |
# 2015-02-10, ver 0.1 | |
""" | |
# i2c bus (0 -- original Pi, 1 -- Rev 2 Pi) | |
I2CBUS = 1 | |
# LCD Address | |
ADDRESS = 0x27 | |
import smbus | |
from time import sleep | |
class i2c_device: | |
def __init__(self, addr, port=I2CBUS): | |
self.addr = addr | |
self.bus = smbus.SMBus(port) | |
# Write a single command | |
def write_cmd(self, cmd): | |
self.bus.write_byte(self.addr, cmd) | |
sleep(0.0001) | |
# Write a command and argument | |
def write_cmd_arg(self, cmd, data): | |
self.bus.write_byte_data(self.addr, cmd, data) | |
sleep(0.0001) | |
# Write a block of data | |
def write_block_data(self, cmd, data): | |
self.bus.write_block_data(self.addr, cmd, data) | |
sleep(0.0001) | |
# Read a single byte | |
def read(self): | |
return self.bus.read_byte(self.addr) | |
# Read | |
def read_data(self, cmd): | |
return self.bus.read_byte_data(self.addr, cmd) | |
# Read a block of data | |
def read_block_data(self, cmd): | |
return self.bus.read_block_data(self.addr, cmd) | |
# commands | |
LCD_CLEARDISPLAY = 0x01 | |
LCD_RETURNHOME = 0x02 | |
LCD_ENTRYMODESET = 0x04 | |
LCD_DISPLAYCONTROL = 0x08 | |
LCD_CURSORSHIFT = 0x10 | |
LCD_FUNCTIONSET = 0x20 | |
LCD_SETCGRAMADDR = 0x40 | |
LCD_SETDDRAMADDR = 0x80 | |
# flags for display entry mode | |
LCD_ENTRYRIGHT = 0x00 | |
LCD_ENTRYLEFT = 0x02 | |
LCD_ENTRYSHIFTINCREMENT = 0x01 | |
LCD_ENTRYSHIFTDECREMENT = 0x00 | |
# flags for display on/off control | |
LCD_DISPLAYON = 0x04 | |
LCD_DISPLAYOFF = 0x00 | |
LCD_CURSORON = 0x02 | |
LCD_CURSOROFF = 0x00 | |
LCD_BLINKON = 0x01 | |
LCD_BLINKOFF = 0x00 | |
# flags for display/cursor shift | |
LCD_DISPLAYMOVE = 0x08 | |
LCD_CURSORMOVE = 0x00 | |
LCD_MOVERIGHT = 0x04 | |
LCD_MOVELEFT = 0x00 | |
# flags for function set | |
LCD_8BITMODE = 0x10 | |
LCD_4BITMODE = 0x00 | |
LCD_2LINE = 0x08 | |
LCD_1LINE = 0x00 | |
LCD_5x10DOTS = 0x04 | |
LCD_5x8DOTS = 0x00 | |
# flags for backlight control | |
LCD_BACKLIGHT = 0x08 | |
LCD_NOBACKLIGHT = 0x00 | |
En = 0b00000100 # Enable bit | |
Rw = 0b00000010 # Read/Write bit | |
Rs = 0b00000001 # Register select bit | |
class lcd: | |
#initializes objects and lcd | |
def __init__(self): | |
self.lcd_device = i2c_device(ADDRESS) | |
self.lcd_write(0x03) | |
self.lcd_write(0x03) | |
self.lcd_write(0x03) | |
self.lcd_write(0x02) | |
self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE) | |
self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON) | |
self.lcd_write(LCD_CLEARDISPLAY) | |
self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT) | |
sleep(0.2) | |
# clocks EN to latch command | |
def lcd_strobe(self, data): | |
self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT) | |
sleep(.0005) | |
self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT)) | |
sleep(.0001) | |
def lcd_write_four_bits(self, data): | |
self.lcd_device.write_cmd(data | LCD_BACKLIGHT) | |
self.lcd_strobe(data) | |
# write a command to lcd | |
def lcd_write(self, cmd, mode=0): | |
self.lcd_write_four_bits(mode | (cmd & 0xF0)) | |
self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0)) | |
# write a character to lcd (or character rom) 0x09: backlight | RS=DR< | |
# works! | |
def lcd_write_char(self, charvalue, mode=1): | |
self.lcd_write_four_bits(mode | (charvalue & 0xF0)) | |
self.lcd_write_four_bits(mode | ((charvalue << 4) & 0xF0)) | |
# put string function with optional char positioning | |
def lcd_display_string(self, string, line=1, pos=0): | |
if line == 1: | |
pos_new = pos | |
elif line == 2: | |
pos_new = 0x40 + pos | |
elif line == 3: | |
pos_new = 0x14 + pos | |
elif line == 4: | |
pos_new = 0x54 + pos | |
self.lcd_write(0x80 + pos_new) | |
for char in string: | |
self.lcd_write(ord(char), Rs) | |
# clear lcd and set to home | |
def lcd_clear(self): | |
self.lcd_write(LCD_CLEARDISPLAY) | |
self.lcd_write(LCD_RETURNHOME) | |
# define backlight on/off (lcd.backlight(1); off= lcd.backlight(0) | |
def backlight(self, state): # for state, 1 = on, 0 = off | |
if state == 1: | |
self.lcd_device.write_cmd(LCD_BACKLIGHT) | |
elif state == 0: | |
self.lcd_device.write_cmd(LCD_NOBACKLIGHT) | |
# add custom characters (0 - 7) | |
def lcd_load_custom_chars(self, fontdata): | |
self.lcd_write(0x40); | |
for char in fontdata: | |
for line in char: | |
self.lcd_write_char(line) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment