def test_boutons(affichage=False,console=False,stockage=False):
listeB = [22,18,16]
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])
GPIO.setup(listeB[0],GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(listeB[1],GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(listeB[2],GPIO.IN, pull_up_down=GPIO.PUD_UP)
if affichage == True:
lcd.clear()
while True:
if affichage == True:
lcd.cursor_pos = (0, 0)
lcd.write_string("Boutons : ")
lcd.cursor_pos = (1, 0)
lcd.write_string("1: o 2: o 3: o")
bouton1 = GPIO.input(listeB[0])
if bouton1 == False:
print('Button 1 Pressed')
if affichage == True:
lcd.cursor_pos = (1, 3)
lcd.write_string("X")
bouton2 = GPIO.input(listeB[1])
if bouton2 == False:
print('Button 2 Pressed')
if affichage == True:
lcd.cursor_pos = (1, 9)
lcd.write_string("X")
bouton3 = GPIO.input(listeB[2])
if bouton3 == False:
print('Button 3 Pressed')
if affichage == True:
lcd.cursor_pos = (1, 15)
lcd.write_string("X")
time.sleep(0.2)
def run(self):
#This is so that the light works
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
userLightColor = 3
if self.author in self.users:
userLightColor = self.users[self.author]
GPIO.setup(userLightColor, GPIO.OUT)
GPIO.output(userLightColor, True)
#this is the lcd stuff
lcd = CharLCD(cols=16,
rows=2,
pin_rs=22,
pin_e=18,
pins_data=[16, 11, 12, 15],
numbering_mode=GPIO.BOARD)
lcd.cursor_pos = (1, 0)
lcd.write_string(self.author)
for i in range(0, 2):
currentPositionLCD = 0
for char in self.message:
lcd.cursor_pos = (0, currentPositionLCD)
#increasing the cursor position
currentPositionLCD += 1
currentPositionLCD = currentPositionLCD % 16
lcd.write_string(char)
time.sleep(.1)
time.sleep(.5)
GPIO.output(userLightColor, False)
lcd.clear()
def test_caching(mocker):
"""
Characters should only be written if they have changed
"""
lcd = CharLCD()
send = mocker.patch.object(lcd, '_send')
lcd.write_string('hello')
assert send.call_count == 5
calls = [c[0] for c in send.call_args_list]
assert calls[0] == (104, RS_DATA)
assert calls[1] == (101, RS_DATA)
assert calls[2] == (108, RS_DATA)
assert calls[3] == (108, RS_DATA)
assert calls[4] == (111, RS_DATA)
lcd.home()
send.reset_mock()
lcd.write_string('he77o')
assert send.call_count == 5
calls = [c[0] for c in send.call_args_list]
assert calls[0] == (LCD_SETDDRAMADDR | 1, RS_INSTRUCTION)
assert calls[1] == (LCD_SETDDRAMADDR | 2, RS_INSTRUCTION)
assert calls[2] == (55, RS_DATA)
assert calls[3] == (55, RS_DATA)
assert calls[4] == (LCD_SETDDRAMADDR | 5, RS_INSTRUCTION)
def test_caching(mocker, charlcd_kwargs):
"""
Characters should only be written if they have changed
"""
lcd = CharLCD(**charlcd_kwargs)
send_data = mocker.patch.object(lcd, '_send_data')
send_instruction = mocker.patch.object(lcd, '_send_instruction')
lcd.write_string('hello')
assert send_data.call_count == 5
data_calls = [c[0] for c in send_data.call_args_list]
assert data_calls[0] == (104,)
assert data_calls[1] == (101,)
assert data_calls[2] == (108,)
assert data_calls[3] == (108,)
assert data_calls[4] == (111,)
lcd.home()
send_data.reset_mock()
send_instruction.reset_mock()
lcd.write_string('he77o')
assert send_data.call_count == 2
assert send_instruction.call_count == 3
data_calls = [c[0] for c in send_data.call_args_list]
instruction_calls = [c[0] for c in send_instruction.call_args_list]
assert instruction_calls[0] == (LCD_SETDDRAMADDR | 1,)
assert instruction_calls[1] == (LCD_SETDDRAMADDR | 2,)
assert data_calls[0] == (55,)
assert data_calls[1] == (55,)
assert instruction_calls[2] == (LCD_SETDDRAMADDR | 5,)
class LCD:
line1 = ""
line2 = ""
def __init__(self):
self.lcd = CharLCD(pin_rs=26,
pin_e=19,
pins_data=[13, 6, 5, 11],
numbering_mode=GPIO.BCM)
def writeLine1(self, text: str):
self.line1 = text
self._toDisplay()
def writeLine2(self, text: str):
self.line2 = text
self._toDisplay()
def _toDisplay(self):
#self.clear()
self.lcd.write_string(f"{self.line1}\n{self.line2}")
def clear(self):
self.lcd.clear()
def close(self):
self.lcd.close(clear=True)
def display(self, message):
lcd = CharLCD(pin_rs=22, pin_rw=24, pin_e=23, pins_data=[21, 16, 12, 20],
numbering_mode=GPIO.BCM,
cols=16, rows=2, dotsize=8,
charmap='A02',
auto_linebreaks=True)
lcd.write_string(message)
class Lcd:
def __init__(self):
print("Init LCD...")
self.lcd = CharLCD(numbering_mode=GPIO.BOARD,
cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 23])
def display(self, output):
self.lcd.clear()
self.lcd.write_string(output)
def lcd_write(text):
text = text.replace('\n', '\n\r')
lcd = CharLCD(pin_rs=15,
pin_rw=16,
pin_e=18,
pins_data=[21, 22, 23, 24],
numbering_mode=GPIO.BOARD,
cols=16,
rows=2,
dotsize=8,
charmap='A02',
auto_linebreaks=True)
lcd.clear()
lcd.write_string(text)
def test_charmap(mocker, charmap, ue):
"""
The charmap should be used. The "ü" Umlaut should be encoded correctly.
"""
lcd = CharLCD(charmap=charmap)
send = mocker.patch.object(lcd, '_send')
text = 'Züri'
lcd.write_string(text)
assert send.call_count == 4, 'call count was %d' % send.call_count
calls = [c[0] for c in send.call_args_list]
assert calls[0] == (90, RS_DATA)
assert calls[1] == (ue, RS_DATA)
assert calls[2] == (114, RS_DATA)
assert calls[3] == (105, RS_DATA)
class LcdManager:
def __init__(self, config):
config = config['lcd_manager']
self.dimmer_pin = int(config['dimmer_pin'])
GPIO.setup(self.dimmer_pin, GPIO.OUT)
self.turn_on_backlight()
self.lcd_width = int(config['width'])
self.lcd = CharLCD(
pin_rs=int(config['rs']),
pin_e=int(config['e']),
pins_data=[int(y) for y in config['data_pins'].split(",")],
auto_linebreaks=True,
numbering_mode=GPIO.BCM,
cols=self.lcd_width)
for foo, bar in zip(range(len(register_char)), register_char):
self.lcd.create_char(foo, bar)
self.lines = [
TextLine('', self.lcd_width),
TextLine('', self.lcd_width)
]
def turn_on_backlight(self):
GPIO.output(self.dimmer_pin, GPIO.HIGH)
def turn_off_backlight(self):
GPIO.output(self.dimmer_pin, GPIO.LOW)
def close(self):
self.turn_off_backlight()
self.lcd.close(clear=True)
def set_lines(self, line, line2):
self.lines[0].set_text(line)
self.lines[1].set_text(line2)
def update(self):
i = 0
for line in self.lines:
self.lcd.cursor_pos = (i, 0)
self.lcd.write_string(str(line).ljust(self.lcd_width))
i += 1
class Display:
def __init__(self):
self.lcd = CharLCD(cols=16,
rows=2,
pin_rs=16,
pin_e=36,
pins_data=[38, 32, 11, 37],
numbering_mode=GPIO.BOARD)
def show_message(self, text):
self.lcd.clear()
self.lcd.write_string(text)
def clear(self):
self.lcd.clear()
def close(self):
self.lcd.close(clear=True)
def test_write_simple(mocker, charlcd_kwargs):
"""
Write "HelloWorld" to the display.
"""
lcd = CharLCD(**charlcd_kwargs)
send_data = mocker.patch.object(lcd, '_send_data')
text = 'HelloWorld'
lcd.write_string(text)
assert send_data.call_count == len(text)
calls = [c[0] for c in send_data.call_args_list]
assert calls[0] == (72,)
assert calls[1] == (101,)
assert calls[2] == (108,)
assert calls[3] == (108,)
assert calls[4] == (111,)
assert calls[5] == (87,)
assert calls[6] == (111,)
assert calls[7] == (114,)
assert calls[8] == (108,)
assert calls[9] == (100,)
def test_write_simple(mocker):
"""
Write "HelloWorld" to the display.
"""
lcd = CharLCD()
send = mocker.patch.object(lcd, '_send')
text = 'HelloWorld'
lcd.write_string(text)
assert send.call_count == len(text)
calls = [c[0] for c in send.call_args_list]
assert calls[0] == (72, RS_DATA)
assert calls[1] == (101, RS_DATA)
assert calls[2] == (108, RS_DATA)
assert calls[3] == (108, RS_DATA)
assert calls[4] == (111, RS_DATA)
assert calls[5] == (87, RS_DATA)
assert calls[6] == (111, RS_DATA)
assert calls[7] == (114, RS_DATA)
assert calls[8] == (108, RS_DATA)
assert calls[9] == (100, RS_DATA)
def print_lcd(temp_f: float, aqi: float, outdoor_f: float, outdoor_aqi: float) -> None:
"""
Print to Rasperry Pi's LCD screen
"""
from RPLCD.gpio import CharLCD
from RPi import GPIO
GPIO.setwarnings(False)
lcd = CharLCD(
cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 23],
numbering_mode=GPIO.BOARD,
compat_mode=True,
)
aqi_str = f" AQI: {aqi} / {round(outdoor_aqi, 1)}"
temp_str = f"\r\nTemp: {temp_f} / {round(outdoor_f, 1)}"
lcd.write_string(aqi_str)
lcd.write_string(temp_str)
class LCD:
def __init__(self):
self.lcd = CharLCD(pin_rs=16,
pin_rw=None,
pin_e=20,
pins_data=[26, 19, 13, 6],
numbering_mode=GPIO.BCM,
rows=2,
cols=16)
#self.lcd.write_string(u"Hello")
#self.lcd = CharLCD (pin_rs=36, pin_rw=None, pin_e=38, pins_data=[31, 33, 35, 37], numbering_mode=GPIO.BOARD, rows=2, cols=16)
self.lcd.cursor_mode = "hide"
def clearScreen(self):
self.lcd.clear()
def printOut(self, string):
self.lcd.write_string(u"" + string)
def println(self, string):
self.lcd.write_string(u"\r\n" + string)
def test_write_newline(mocker, rows, cols):
"""
Write text containing CR/LF chars to the display.
"""
lcd = CharLCD(rows=rows, cols=cols)
send = mocker.patch.object(lcd, '_send')
text = '\nab\n\rcd'
lcd.write_string(text)
assert send.call_count == len(text)
calls = [c[0] for c in send.call_args_list]
assert calls[0] == (0x80 + 0x40, RS_INSTRUCTION), calls
assert calls[1] == (97, RS_DATA), calls
assert calls[2] == (98, RS_DATA), calls
if rows == 2:
assert calls[3] == (0x80 + 2, RS_INSTRUCTION), calls
assert calls[4] == (0x80 + 0, RS_INSTRUCTION), calls
else:
assert calls[3] == (0x80 + cols + 2, RS_INSTRUCTION), calls
assert calls[4] == (0x80 + cols + 0, RS_INSTRUCTION), calls
assert calls[5] == (99, RS_DATA), calls
assert calls[6] == (100, RS_DATA), calls
def test_lcd():
lcd = CharLCD(cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[40, 38, 36, 32, 33, 31, 29, 23],
numbering_mode=GPIO.BOARD)
#GPIO.setmode(GPIO.BOARD)
lcd.clear()
status = ["NO", "NO", "NO"]
with open("indication.txt", "r") as fd:
lines = fd.readlines()
for i in range(3):
if ("False" in lines[i]):
status[i] = "NO"
else:
status[i] = "YES"
lcd.write_string("Inet:" + status[0] + "\n")
lcd.cursor_pos = (1, 0)
lcd.write_string("Cam:" + status[1] + "\n")
lcd.cursor_pos = (1, 8)
lcd.write_string("Mav:" + status[2] + "\n")
fd.close()
GPIO.cleanup()
class Display():
def __init__(self):
# Configure the LCD
self.lcd = CharLCD(pin_rs=38,
pin_rw=None,
pin_e=40,
pins_data=[36, 18, 16, 12],
numbering_mode=GPIO.BOARD,
auto_linebreaks=False,
cols=COLS,
rows=ROWS)
def print(self, string):
if len(string) > COLS * ROWS:
print('WARNING: String \'{}\' too big and overflows the display.'.
format(string))
self.lcd.clear()
self.lcd.write_string(string)
def __del__(self):
self.lcd.close()
class Wrapper:
lcd = 1
text = 'Initializing'
oldtext = text
shutDownLCD = False
def __init__(self):
self.activate()
workerThread = threading.Thread(target=self.updateScreenWorker,
args=(),
daemon=True)
workerThread.start()
def activate(self):
# Initialize LCD
self.lcd = CharLCD(pin_rs=16,
pin_e=18,
pins_data=[11, 12, 13, 15],
numbering_mode=GPIO.BOARD,
cols=20,
rows=4,
dotsize=8,
charmap='A02',
auto_linebreaks=True,
pin_backlight=22)
self.lcd.clear()
GPIO.output(22, GPIO.HIGH) #turn on LCD backlight
# Main loop
def updateScreenWorker(self):
self.text = "\nReady."
while not self.shutDownLCD:
if self.text != self.oldtext:
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(self.text)
self.oldtext = self.text
time.sleep(1)
self.cleanShutdown()
# If clean shut down is requested, shut down cleanly, and display optional message.
def cleanShutdown(self, closeMessage=''):
print('\nshutting down LCD')
if GPIO.getmode() != None: # If screen can be accessed
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(closeMessage)
self.lcd.close(clear=False)
else: # If screen can not be accessed, activate
self.activate()
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(closeMessage)
self.lcd.close(clear=False)
print('complete')
class Display:
def __init__(self):
self.lcd = CharLCD(pin_rs=15,
pin_rw=18,
pin_e=16,
pins_data=[21, 22, 23, 24],
numbering_mode=GPIO.BOARD)
self._create_chars()
def update_display(self,
count,
interval,
counter=0,
camera_connected=False):
self.lcd.cursor_pos = (0, 0)
self.lcd.write_string("Interval:")
self.lcd.cursor_pos = (0, 9)
self.lcd.write_string(str(interval) + " ")
if not counter == 0:
self.lcd.cursor_pos = (0, 13)
self.lcd.write_string(str(counter)[:3] + " ")
self.lcd.cursor_pos = (1, 0)
self.lcd.write_string("Shots:" + str(count) + " ")
if camera_connected: # displays camera icon if camera connected
self.lcd.cursor_pos = (1, 13)
self.lcd.write_string("\x00\x01\x02")
def _create_chars(self):
# camera icon
bitmap0 = (0b00000, 0b00000, 0b00011, 0b00011, 0b00011, 0b00011,
0b00011, 0b00011)
bitmap1 = (0b01110, 0b11111, 0b11011, 0b10001, 0b00000, 0b10001,
0b11011, 0b11111)
bitmap2 = (0b00000, 0b00000, 0b11000, 0b01000, 0b11000, 0b11000,
0b11000, 0b11000)
self.lcd.create_char(0, bitmap0)
self.lcd.create_char(1, bitmap1)
self.lcd.create_char(2, bitmap2)
def test_write_newline(mocker, rows, cols, charlcd_kwargs):
"""
Write text containing CR/LF chars to the display.
"""
lcd = CharLCD(rows=rows, cols=cols, **charlcd_kwargs)
send_data = mocker.patch.object(lcd, '_send_data')
send_instruction = mocker.patch.object(lcd, '_send_instruction')
text = '\nab\n\rcd'
lcd.write_string(text)
assert send_data.call_count + send_instruction.call_count == len(text)
data_calls = [c[0] for c in send_data.call_args_list]
instruction_calls = [c[0] for c in send_instruction.call_args_list]
assert instruction_calls[0] == (0x80 + 0x40,), instruction_calls
assert data_calls[0] == (97,), data_calls
assert data_calls[1] == (98,), data_calls
if rows == 2:
assert instruction_calls[1] == (0x80 + 2,), instruction_calls
assert instruction_calls[2] == (0x80 + 0,), instruction_calls
else:
assert instruction_calls[1] == (0x80 + cols + 2,), instruction_calls
assert instruction_calls[2] == (0x80 + cols + 0,), instruction_calls
assert data_calls[2] == (99,), data_calls
assert data_calls[3] == (100,), data_calls
class CommonHardwarePIHD44780GPIO(object):
"""
Class for interfacing with pi lcd HD44780
"""
def __init__(self):
self.lcd_inst = CharLCDGPIO(pin_rs=15, pin_rw=18, pin_e=16,
pins_data=[21, 22, 23, 24],
numbering_mode=GPIO.BOARD,
cols=20, rows=4, dotsize=8,
charmap='A02',
auto_linebreaks=True)
def com_hard_pi_hd44780_write(self, lcd_string, x_pos=None, y_pos=None):
if x_pos is not None:
self.lcd_inst.cursor_pos = (x_pos, y_pos)
self.lcd_inst.write_string(lcd_string)
def com_hard_pi_hd44780_clear(self):
self.lcd_inst.clear()
def com_hard_pi_hd44780_close(self, clear_screen=True):
self.lcd_inst.close(clear=clear_screen)
class Wrapper:
i = 0
lcd = 1
text = 'Initializing'
oldtext = text
shutDownLCD = False
def __init__(self):
self.activate()
workerThread = threading.Thread(target=self.updateScreenWorker,
args=(),
daemon=True)
workerThread.start()
def activate(self):
self.lcd = CharLCD(pin_rs=16,
pin_e=18,
pins_data=[11, 12, 13, 15],
numbering_mode=GPIO.BOARD,
cols=20,
rows=4,
dotsize=8,
charmap='A02',
auto_linebreaks=True,
pin_backlight=22)
self.lcd.clear()
GPIO.output(22, GPIO.HIGH) #turns on backlight
def updateScreenWorker(self):
self.text = "Ready."
while not self.shutDownLCD:
#print("Text = " + self.text + " Oldtext = " + self.oldtext)
if self.text != self.oldtext:
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(self.text)
self.i = self.i + 1
self.oldtext = self.text
time.sleep(1)
self.cleanShutdown()
def cleanShutdown(self, closeMessage=''):
print('\nshutting down LCD')
if GPIO.getmode() != None:
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(closeMessage)
self.lcd.close(clear=False)
else:
self.activate()
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(closeMessage)
self.lcd.close(clear=False)
print('complete')
dotsize=8,
pin_rs=26,
pin_e=24,
pins_data=[22, 18, 16, 12],
numbering_mode=GPIO.BOARD)
lcd.clear()
GPIO.setup(selectBtnPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(incBtnPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(decBtnPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
startUp()
while inSetUp:
time.sleep(1)
lcd.clear()
lcd.write_string("Welcome to")
lcd.crlf()
lcd.write_string("Planet Finder")
time.sleep(2)
lcd.clear()
lcd.write_string("Select a planet")
lcd.crlf()
lcd.write_string("Mercury")
time.sleep(2)
while True:
time.sleep(1)
55: '>',
56: '?'
}
fp = open('/dev/hidraw0', 'rb')
rfid_number = ""
shift = False
done = False
### Begin run loop
while True:
### Wait for RFID
while not done: ## Get the character from the HID
lcd.clear() ## Clear the LCD before writing
blue_backlight.on() ## Turn on the blue backlight
lcd.cursor_pos = (0, 3) ## Set cursor pos on first line
lcd.write_string('Swipe Badge')
buffer = fp.read(8)
for c in buffer:
if ord(
c
) > 0: ## 40 is carriage return which signifies we are done looking for characters
if int(ord(c)) == 40:
done = True
break
## If we are shifted then we have to use the hid2 characters.
if shift: ## If it is a '2' then it is the shift key
if int(ord(c)) == 2:
shift = True
else: # if not a 2, lookup mapping
rfid_number += hid2[int(ord(c))]
substr_c = get_line("Folsom: ", 'folsom_c.txt', " C")
substr_hf = get_line("Today: ", 'folsom_hf.txt', " F")
substr_hc = get_line("Today: ", 'folsom_hc.txt', " C")
fp = open('folsom_desc.txt', 'r')
line = fp.readline()
fp.close()
line = line[:-1]
line.ljust(15)[:15]
substr_desc = (line + 15 * " ")[:15]
print(substr_desc)
counter = counter + 1
x = datetime.datetime.now()
lcd.cursor_pos = (0, 0)
lcd.write_string(x.strftime("%d %b %H:%M:%S"))
lcd.cursor_pos = (1, 0)
len = 11
if ((counter % len) < 2):
lcd.write_string(substr_c)
elif ((counter % len) <= 4):
lcd.write_string(substr_f)
elif ((counter % len) <= 6):
lcd.write_string(substr_hc)
elif ((counter % len) <= 8):
lcd.write_string(substr_hf)
elif ((counter % len) <= 10):
lcd.write_string(substr_desc)
# else:
import RPi.GPIO as GPIO
from RPLCD.gpio import CharLCD
from time import sleep
# When numbering_mode is set to BOARD, reference PIN number.
# When numbering_mode is set to BCM, reference the number after GP in the pinout name.
lcd = CharLCD(pin_rs=15, pin_rw=18, pin_e=16, pins_data=[8, 10, 11, 12], numbering_mode=GPIO.BOARD, cols=20, rows=4, dotsize=8)
# Clear the screen of any previous input
lcd.clear()
sleep(2)
counter = 0
lcd.cursor_pos = (0, 0)
lcd.write_string(str('It works!'))
while(True):
# Set the cursor to the second row, 0th column
lcd.cursor_pos = (1, 0)
# Timer print string builder
secondRow = ('UpTime %s m %s s' % (counter/60, counter%60))
# Add spaces at the end to force out 'hanging' characters
# This is a symptom of the LCD screen and printed character 'hanging' in memory.
# If you don't overwrite EVERY character space on a row, anything extending past
# the last char of the new row will remain.
while(20 > len(secondRow)):
secondRow = secondRow + u' '
from RPLCD.gpio import CharLCD
from RPi import GPIO
lcd = CharLCD(numbering_mode=GPIO.BOARD,
cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[40, 38, 36, 32, 33, 31, 29, 23])
lcd.write_string(u'Hello world!2')
class Ticker:
def __init__(self, lcd_rs, lcd_e, lcd_data, buzzer_pin, red_led_pin,
yellow_led_pin, green_led_pin, button_pins, fm_username: str,
fm_key: str, spot_client: str, spot_secret: str,
spot_refresh: str):
self.lcd = CharLCD(numbering_mode=GPIO.BCM,
cols=lcd_width,
rows=2,
pin_rs=lcd_rs,
pin_e=lcd_e,
pins_data=lcd_data,
auto_linebreaks=True)
self.lcd.cursor_mode = 'hide'
self.leds = TrafficLights(red=red_led_pin,
yellow=yellow_led_pin,
green=green_led_pin,
pwm=True)
self.buzzer = TonalBuzzer(buzzer_pin)
self.buzzer_lock = Lock()
self.notif_button = Button(button_pins[0])
self.notif_button.when_activated = self.handle_notif_click
self.button2 = Button(button_pins[1])
self.button2.when_activated = lambda: self.queue_text('hey', 'hey')
self.button3 = Button(button_pins[2])
self.button4 = Button(button_pins[3])
self.button4.when_held = self.handle_network_hold
self.location = DisplayLocation.home
self.pulled_idle_text = dict()
self.notification_queue = Queue()
self.display_queue = Queue()
self.display_thread = Thread(target=self.display_worker,
name='display',
daemon=True)
self.network_active = True
self.rsession = Session()
self.fmnet = FMNetwork(username=fm_username, api_key=fm_key)
self.spotnet = SpotNetwork(
NetworkUser(client_id=spot_client,
client_secret=spot_secret,
refresh_token=spot_refresh)).refresh_access_token()
self.network_pull_thread = Thread(target=self.network_pull_worker,
name='puller',
daemon=True)
def start(self):
logger.info('starting ticker')
self.lcd.clear()
self.display_thread.start()
self.network_pull_thread.start()
self.set_status(green=True)
def set_status(self, green: bool = False, yellow: bool = False):
self.leds.green.value = 1 if green else 0
self.leds.yellow.value = 1 if yellow else 0
# HANDLERS
def handle_notif_click(self):
if not self.notification_queue.empty():
while not self.notification_queue.empty():
self.display_queue.put(self.notification_queue.get())
self.leds.red.off()
else:
self.queue_text('No Notifications', '', interrupt=True, time=1)
def handle_network_hold(self):
self.network_active = not self.network_active
logger.info(f'setting network activity {self.network_active}')
if self.network_active:
self.set_status(green=True)
else:
self.set_status(yellow=True)
self.beep()
# THREADS
def network_pull_worker(self):
"""thread function for pulling network display items and update cache"""
while True:
if self.network_active:
try:
total = self.fmnet.get_scrobble_count_from_date(
input_date=date.today())
logger.debug(f'loaded daily scrobbles {total}')
# self.queue_text('Scrobbles Today', total)
self.pulled_idle_text['daily_scrobbles'] = DisplayItem(
'Scrobbles Today', str(total))
except LastFMNetworkException as e:
logger.exception(e)
self.queue_text(
'Last.FM Error',
f'{e.http_code}, {e.error_code}, {e.message}')
try:
artists = self.fmnet.get_top_artists(
period=FMNetwork.Range.WEEK, limit=3)
logger.debug(f'loaded top artists')
self.pulled_idle_text['weekly_artists'] = DisplayItem(
'Weekly Artists',
', '.join([str(i) for i in artists]),
iterations=1)
except LastFMNetworkException as e:
logger.exception(e)
self.queue_text(
'Last.FM Error',
f'{e.http_code}, {e.error_code}, {e.message}')
# try:
# from_time = date.today()
# from_time = datetime(year=from_time.year, month=from_time.month, day=1)
#
# to_time = datetime.now()
#
# total = len(self.fmnet.get_recent_tracks(from_time=from_time, to_time=to_time, page_limit=200))
# logger.debug(f'loaded monthly scrobbles {total}')
#
# # self.queue_text('Scrobbles Today', total)
# self.pulled_idle_text['monthly_scrobbles'] = DisplayItem('This Month', str(total))
# except LastFMNetworkException as e:
# logger.exception(e)
# self.queue_text('Last.FM Error', f'{e.http_code}, {e.error_code}, {e.message}')
try:
playlist_total = len(self.spotnet.get_user_playlists())
logger.debug(f'loaded daily scrobbles {playlist_total}')
self.pulled_idle_text['playlist_count'] = DisplayItem(
'Playlists', str(playlist_total))
except SpotifyNetworkException as e:
logger.exception(e)
self.queue_text('Spotify Error',
f'{e.http_code}, {e.message}')
sleep(net_thread_interval)
def display_worker(self):
"""LCD controller, reads queue for new items to display or roll over idle items"""
while True:
if not self.display_queue.empty():
display_item = self.display_queue.get(block=False)
logger.info(
f'dequeued {display_item}, size {self.display_queue.qsize()}'
)
self.write_display_item(display_item)
self.display_queue.task_done()
else:
if len(self.idle_text
) > 0 and self.location == DisplayLocation.home:
for key, item in self.idle_text.items():
if not self.display_queue.empty():
break
logger.debug(f'writing {key}')
self.write_display_item(item)
else:
self.write_to_lcd(['Ticker...', ''])
sleep(display_thread_interval)
# DISPLAY
def write_display_item(self, display_item):
"""write display item to LCD now"""
if display_item.message is None:
display_item.message = ''
if len(display_item.message) > lcd_width:
buffer = [display_item.title, '']
self.write_to_lcd(buffer)
self.loop_string(display_item.message,
buffer,
row=1,
iterations=display_item.iterations)
else:
buffer = [display_item.title, display_item.message]
self.write_to_lcd(buffer)
sleep(display_item.time)
def queue_notification(self,
title,
message,
wrap_line=False,
iterations=2):
logger.debug(
f'queueing {title}/{message} {iterations} times, wrapped: {wrap_line}'
)
self.notification_queue.put(
DisplayItem(title, str(message), wrap_line, iterations))
self.leds.red.pulse()
def queue_text(self,
title,
message,
wrap_line=False,
time=5,
iterations=2,
interrupt=False):
logger.debug(
f'queueing {title}/{message} {iterations} times, wrapped: {wrap_line}'
)
item = DisplayItem(title,
str(message),
wrap_line=wrap_line,
iterations=iterations,
time=time)
if interrupt:
self.write_display_item(item)
else:
self.display_queue.put(item)
def write_to_lcd(self, framebuffer):
"""Write the framebuffer out to the specified LCD."""
self.lcd.home()
for row in framebuffer:
self.lcd.write_string(row.ljust(lcd_width)[:lcd_width])
self.lcd.write_string('\r\n')
def loop_string(self, string, framebuffer, row, delay=0.4, iterations=2):
padding = ' ' * lcd_width
s = padding + string + padding
for round_trip in range(iterations):
for i in range(len(s) - lcd_width + 1):
framebuffer[row] = s[i:i + lcd_width]
self.write_to_lcd(framebuffer)
sleep(delay)
@property
def idle_text(self) -> dict:
"""merge last pulled with system pullable text items"""
system_idle = dict()
now = datetime.now()
system_idle['date'] = DisplayItem(title=now.strftime('%d.%m.%y'),
message=now.strftime('%R'))
return {**system_idle, **self.pulled_idle_text}
# SOUND
def beep(self):
self.buzzer_lock.acquire()
self.buzzer.play(Tone("A4"))
sleep(0.1)
self.buzzer.stop()
sleep(0.1)
self.buzzer_lock.release()
import RPLCD as RPLCD
from RPLCD.gpio import CharLCD
import RPi.GPIO as GPIO
import time
GPIO.setwarnings(False)
lcd = CharLCD(numbering_mode=GPIO.BOARD,
cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 26])
lcd.clear()
lcd.write_string(u'Test')
time.sleep(3)
GPIO.cleanup()
import RPi.GPIO as GPIO
from RPLCD.gpio import CharLCD
GPIO.setwarnings(False)
lcd = CharLCD(cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 23],
numbering_mode=GPIO.BOARD)
heart = [
0b00000, 0b01010, 0b11111, 0b11111, 0b11111, 0b01110, 0b00100, 0b00000
]
lcd.cursor_pos = (0, 6)
lcd.write_string(u'I ')
lcd.create_char(0, heart)
lcd.write_string(unichr(0))
lcd.cursor_pos = (1, 2)
lcd.write_string(u'Raspberry Pi')
