From: Russ Handorf Date: Fri, 14 Jan 2022 02:52:33 +0000 (-0500) Subject: more backups X-Git-Url: https://handorf.org/code/?a=commitdiff_plain;p=rb-clock.git more backups --- diff --git a/python/lcd-clear.py b/python/lcd-clear.py new file mode 100644 index 0000000..2914f25 --- /dev/null +++ b/python/lcd-clear.py @@ -0,0 +1,13 @@ +import RPi.GPIO as GPIO +from RPLCD.gpio import CharLCD +import socket +import fcntl +import struct +import time +from signal import signal, SIGINT +from sys import exit + +lcd = CharLCD(cols=40, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23], numbering_mode=GPIO.BOARD) +lcd.clear() +lcd.clear() +lcd.close() diff --git a/python/lcd-test.py b/python/lcd-test.py new file mode 100644 index 0000000..9dcad18 --- /dev/null +++ b/python/lcd-test.py @@ -0,0 +1,45 @@ +import RPi.GPIO as GPIO +from RPLCD.gpio import CharLCD +import socket +import fcntl +import struct +import time +from signal import signal, SIGINT +from sys import exit + +lcd = CharLCD(cols=20, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23], numbering_mode=GPIO.BOARD) +lcd.clear() + +def handler(signal_received, frame): + lcd.close() + print('SIGINT or CTRL-C detected. Exiting gracefully') + exit(0) + +def get_ip_address(ifname): + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + return socket.inet_ntoa(fcntl.ioctl( + s.fileno(), + 0x8915, + struct.pack('256s', ifname[:15]) + )[20:24]) + +if __name__ == '__main__': + signal(SIGINT, handler) + while True: + for i in range(0,6): + lcd.clear() + lcd.write_string("Time: %s" %time.strftime("%H:%M:%S")) + lcd.cursor_pos = (1, 0) + lcd.write_string("Date: %s" %time.strftime("%m/%d/%Y")) + time.sleep(1) + lcd.clear() + lcd.write_string("IP Address:") + lcd.cursor_pos = (1, 0) + lcd.write_string(get_ip_address('eth0')) + time.sleep(5) + +#lcd.clear() +#lcd.write_string(u'Hello world!') +#lcd.crlf() +#lcd.write_string(u'Hello world!') +lcd.close() diff --git a/python/py-gaugette b/python/py-gaugette new file mode 160000 index 0000000..14732a7 --- /dev/null +++ b/python/py-gaugette @@ -0,0 +1 @@ +Subproject commit 14732a78fc953cfc920f548b04d69d5b6219ba54 diff --git a/python/rotor-test.py b/python/rotor-test.py new file mode 100644 index 0000000..5dcebd7 --- /dev/null +++ b/python/rotor-test.py @@ -0,0 +1,29 @@ +import time +import gaugette.rotary_encoder +import gaugette.gpio +import gaugette.switch + +A_PIN = 5 +B_PIN = 4 +SW_PIN = 2 + +gpio = gaugette.gpio.GPIO() +encoder = gaugette.rotary_encoder.RotaryEncoder(gpio, A_PIN, B_PIN) +encoder.start() +switch = gaugette.switch.Switch(gpio, SW_PIN) +last_state = None +sw = gaugette.switch.Switch(gpio, SW_PIN) +last_state = sw.get_state() + +while True: + delta = encoder.get_cycles() + state = sw.get_state() + if state != last_state: + print "switch %d" % state + last_state = state + + if delta!=0: + print "rotate %d" % delta + else: + time.sleep(0.1) + diff --git a/python/rotor-test2.py b/python/rotor-test2.py new file mode 100644 index 0000000..2fdc836 --- /dev/null +++ b/python/rotor-test2.py @@ -0,0 +1,35 @@ +from RPi import GPIO +from time import sleep + +clk = 23 +dt = 24 +sw = 27 + +GPIO.setmode(GPIO.BCM) +GPIO.setup(clk, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) +GPIO.setup(dt, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) +GPIO.setup(sw, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) + +counter = 0 +clkLastState = GPIO.input(clk) +swLastState = GPIO.input(sw) + +try: + + while True: + clkState = GPIO.input(clk) + dtState = GPIO.input(dt) + swState = GPIO.input(sw) + if clkState != clkLastState: + if dtState != clkState: + counter += 1 + else: + counter -= 1 + print counter + clkLastState = clkState + if swState != swLastState: + print "Pushed" + swLastState = swState + sleep(0.01) +finally: + GPIO.cleanup() diff --git a/python/rotor-test3.py b/python/rotor-test3.py new file mode 100644 index 0000000..14968b4 --- /dev/null +++ b/python/rotor-test3.py @@ -0,0 +1,76 @@ +# Sample code for both the RotaryEncoder class and the Switch class. +# The common pin for the encoder should be wired to ground. +# The sw_pin should be shorted to ground by the switch. + +# Output looks like this: +# +# A B STATE SEQ DELTA SWITCH +# 1 1 3 2 1 0 +# 0 1 2 3 1 0 +# 0 0 0 0 1 0 +# 1 0 1 1 1 0 +# 1 1 3 2 1 0 +# 0 1 2 3 1 0 + +import gaugette.rotary_encoder +import gaugette.switch +import math + +A_PIN = 5 +B_PIN = 4 +SW_PIN = 2 + +encoder = gaugette.rotary_encoder.RotaryEncoder(A_PIN, B_PIN) +switch = gaugette.switch.Switch(SW_PIN) + +last_state = None +last_switch_state = None +last_delta = 0 +last_sequence = encoder.rotation_sequence() +last_heading = 0 + +# NOTE: the library includes individual calls to get +# the rotation_state, rotation_sequence and delta values. +# However this demo only reads the rotation_state and locally +# derives the rotation_sequence and delta. This ensures that +# the derived values are based on the same two input bits A and B. +# If we used the library calls, there is a very real chance that +# the inputs would change while we were sampling, giving us +# inconsistent values in the output table. + +while True: + + state = encoder.rotation_state() + switch_state = switch.get_state() + + if (state != last_state or switch_state != last_switch_state): + last_switch_state = switch_state + last_state = state + + # print a heading every 20 lines + if last_heading % 20 == 0: + print "A B STATE SEQ DELTA SWITCH" + last_heading += 1 + + # extract individual signal bits for A and B + a_state = state & 0x01 + b_state = (state & 0x02) >> 1 + + # compute sequence number: + # This is the same as the value returned by encoder.rotation_sequence() + sequence = (a_state ^ b_state) | b_state << 1 + + # compute delta: + # This is the same as the value returned by encoder.get_delta() + delta = (sequence - last_sequence) % 4 + if delta == 3: + delta = -1 + elif delta==2: + # this is an attempt to make sense out of a missed step: + # assume that we have moved two steps in the same direction + # that we were previously moving. + delta = int(math.copysign(delta, last_delta)) + last_delta = delta + last_sequence = sequence + + print '%1d %1d %3d %4d %4d %4d' % (a_state, b_state, state, sequence, delta, switch_state) diff --git a/python/sw.py b/python/sw.py new file mode 100644 index 0000000..6c8d9a0 --- /dev/null +++ b/python/sw.py @@ -0,0 +1,11 @@ +import gaugette.gpio +import gaugette.switch +SW_PIN = 13 +gpio = gaugette.gpio.GPIO() +sw = gaugette.switch.Switch(gpio, SW_PIN) +last_state = sw.get_state() +while True: + state = sw.get_state() + if state != last_state: + print "switch %d" % state + last_state = state diff --git a/python/unit-test.py b/python/unit-test.py new file mode 100644 index 0000000..bf72cff --- /dev/null +++ b/python/unit-test.py @@ -0,0 +1,106 @@ +import RPi.GPIO as GPIO +from RPLCD.gpio import CharLCD +import socket +import fcntl +import struct +import time +from signal import signal, SIGINT +from sys import exit +import gaugette.rotary_encoder +import gaugette.gpio +import gaugette.switch +import os + +A_PIN = 5 +B_PIN = 4 +SW_PIN = 2 + +menusize=3 +menupos=0 +timeout=time.localtime() + +lcd = CharLCD(cols=40, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23], numbering_mode=GPIO.BOARD) +lcd.clear() + +gpio = gaugette.gpio.GPIO() +encoder = gaugette.rotary_encoder.RotaryEncoder(gpio, A_PIN, B_PIN) +encoder.start() +switch = gaugette.switch.Switch(gpio, SW_PIN) +last_state = None +sw = gaugette.switch.Switch(gpio, SW_PIN) +last_state = sw.get_state() + +def handler(signal_received, frame): + lcd.close() + print('SIGINT or CTRL-C detected. Exiting gracefully') + exit(0) + +def get_ip_address(ifname): + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + return socket.inet_ntoa(fcntl.ioctl( + s.fileno(), + 0x8915, + struct.pack('256s', ifname[:15]) + )[20:24]) + +def display_ip(lcd): + lcd.clear() + lcd.write_string("IP Address:") + lcd.cursor_pos = (1, 0) + lcd.write_string(get_ip_address('eth0')) + +def display_time(lcd): + lcd.clear() + lcd.write_string("Time: %s" %time.strftime("%H:%M:%S")) + lcd.cursor_pos = (1, 0) + lcd.write_string("Date: %s" %time.strftime("%m/%d/%Y")) + +def display_reboot(lcd): + lcd.clear() + lcd.write_string("Reboot?") + +def display_blank(lcd): + lcd.clear() + lcd.write_string("Dynamic screen status") + +if __name__ == '__main__': + signal(SIGINT, handler) + while True: + delta = encoder.get_cycles() + state = sw.get_state() + if state != last_state: + print "switch %d" % state + last_state = state + if menupos==1: + lcd.clear() + lcd.write_string("Rebooting!!!") + time.sleep(3) + os.system("sudo reboot") + + if delta!=0: + if delta>0: + menupos+=1 + if delta<0: + menupos-=1 + if menupos<0: + menupos=menusize + if menupos>menusize: + menupos=0 + + if menupos==0: + display_blank(lcd) + if menupos==1: + display_reboot(lcd) + if menupos==2: + display_time(lcd) + if menupos==3: + display_ip(lcd) + #print "rotate %d" % delta + else: + time.sleep(0.1) + if menupos==2: + if timeout!=time.localtime(): + display_time(lcd) + timeout=time.localtime() + +lcd.close()