Skip to content

Instantly share code, notes, and snippets.

@vitouXY
Last active May 2, 2020 19:06
Show Gist options
  • Save vitouXY/194a25ea5a768bacc736df4ba2a64ff0 to your computer and use it in GitHub Desktop.
Save vitouXY/194a25ea5a768bacc736df4ba2a64ff0 to your computer and use it in GitHub Desktop.
0.0.1-04.27.2020-raw
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# vim: set fileencoding=utf-8 :
"""
piMenu
1.3" OLED Display HAT for Raspberry Pi by Waveshare
128x64
Driver: SH1106
Interface: SPI
NOTES:
* Error with : *
* and more unknown errors...
(C) 2020 All Rights Not Reserved - This program comes with ABSOLUTELY NO
WARRANTY. This is free software, and you are welcome to redistribute
it under the GNU GPL Version 3 (or later) License.
"""
from __future__ import print_function, unicode_literals
__author__ = "vitouXY"
__copyright__ = "Copyright 2020, All Rights Not Reserved"
__credits__ = ["vitouXY"]
__license__ = "GPL"
__version__ = "0.0.1"
__maintainer__ = "vitouXY"
__email__ = "nothave@mail."
__status__ = "--"
__rev__="05.02.2020-raw"
#| Imports
import sys
import os
import RPi.GPIO as GPIO
from luma.core.interface.serial import spi, i2c
from luma.core.render import canvas
from luma.core import lib
from luma.oled.device import sh1106
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
from subprocess import *
import subprocess
from collections import OrderedDict
import signal
import threading
import logging
import time
from datetime import datetime
import platform
import os.path
import usb.core
#try:
# from monicommon import myFunc
# from monicommon import myEntry
#except ImportError:
# sys.exit("The monicommon library was not found.")
try:
import psutil
except ImportError:
sys.exit("The psutil library was not found. Run 'sudo -H pip install psutil' to install it.")
if sys.version_info < (3, 0):
sys.exit("{}: Currently, this program runs only under python3.".format(sys.version_info[0]))
if os.geteuid() != 0:
sys.exit('{}: Operation not permitted'.format(os.geteuid()))
if os.name != 'posix':
sys.exit('{}: Platform not supported'.format(os.name))
#| Global variables
VENDOR = 0x12d1
PRODUCT = 0x14db
WIDTH = 128
HEIGTH = 64
FONT = ImageFont.load_default() # 4x6
LINE_MENU_MAX = 5
# 0 1 2 3 4 5 6
# 4x6 05 16 27 38 49 -- -- -- 4L
# 4x6 00 12 22 32 42 52 -- -- 5L
# 00 08 16 24 32 40 48 56 7L +8
LINE_MENU_POS_X = 2
LINE_MENU_POS_Y = {0:11,1:21,2:31,3:41,4:51} # 5
try: # ./fonts/FreePixel.ttf ## ), "fonts", "FreePixel.ttf" )), 9)
FONT_ = ImageFont.truetype(os.path.abspath(os.path.join(os.path.dirname(__file__),
"FreePixel.ttf" )), 9)
except:
FONT_ = ImageFont.load_default()
THREAD_Timeout = 30
global mainTHREAD_Kill
CURR_SELECTED = 0
CURR_TOP = 0
STATE = 1
mainTHREAD_Kill = 0
MENU_STATE = 0
ENTRIES = {}
ENTRIES_backMenu = {}
ENTRIES_menuLevel = 0
ENTRIES_Lst = {}
TEXT_Lst = []
ENTRIES_backMenu[ENTRIES_menuLevel] = 0
# GPIO define
RST_PIN = 25
CS_PIN = 8
DC_PIN = 24
# Buttons
key = {}
key['key1'] = 21
key['key2'] = 20
key['key3'] = 16
key['left'] = 5
key['up'] = 6
key['down'] = 19
key['right'] = 26
key['press'] = 13
# init GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(key['key1'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['key2'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['key3'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['left'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['up'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['press'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['down'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key['right'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
serial = spi(device = 0,
port = 0,
bus_speed_hz = 8000000,
transfer_size = 4096,
gpio_DC = DC_PIN,
gpio_RST = RST_PIN
)
device = sh1106(serial, rotate = 2)
# Initialize the display...
# draw = ImageDraw.Draw(Image.new('1', (WIDTH,HEIGTH)))
# draw.rectangle((0,0,WIDTH,HEIGTH), outline=0, fill=0)
# device.contrast(255) # device.hide()
# device.show()
# device.clear()
#| Class declarations
#| Function declarations
#' ''
def keyboardInterruptHandler(signal, frame):
global mainTHREAD_Kill
mainTHREAD_Kill = 1
time.sleep(2)
#GPIO.output(RST_PIN,GPIO.LOW)
GPIO.cleanup()
#logging.warning('--KeyboardInterrupt! 0')
sys.exit(" KeyboardInterrupt (ID: {}) has been caught. Cleaning up...".format(signal))
signal.signal(signal.SIGINT, keyboardInterruptHandler)
#' ''
def Test(arg):
print(' < ! > Im Test!!! < ! > ', arg)
ENTRIES = {
0:{
'Menu 1':{
1:{
'Sub 1 Menu 1':{
2:{
'Sub 2 Menu 1':{
3:{
Test
}
},
'Sub 2 Mwnu 2':{
3:{
'Sub 3 Menu 1':{
4:{
Test
}
},
'Sub 3 Menu 2':{
4:{
Test
}
}
}
}
}
}
}
},
'Menu 2':{
1:{
Test
}
}
}
}
ENTRIES[0]['Menu 3'] = {1:{Test}}
########################################################################
logging.info(os.getpid(), platform.system())
def drawText(text=[]):
x = 8
count = 0
max_count = 7
if len(text) < max_count:
max_count = len(text)
#device.clear()
time.sleep(0.01)
with canvas(device) as draw:
while count < max_count:
draw.text((1,x*count), str(text[count]), 'white')
count += 1
def showSplash():
device.contrast(255)
logging.debug('--showSplash!')
drawText([
'',
'',
'PiMenu',
__version__+'-'+__rev__
])
time.sleep(3)
device.contrast(100)
drawText([
'Raspberry Pi Zero W',
'',
'128x64 OLED Hat',
'Drive: sh1106',
'Interface: SPI',
'',
'GNU/Linux & Python3'
])
time.sleep(1)
device.contrast(50)
def ScreenSaver():
global STATE
logging.debug('--ScreenSaver!')
time.sleep(0.01)
if STATE == 1:
STATE = 0
device.hide()
#GPIO.output(RST_PIN,GPIO.LOW)
else:
STATE = 1
device.show()
def showMenu():
logging.debug('--showMenu!')
countS = 0.00
while True:
time.sleep(0.01)
if MENU_STATE == 1:
getMenu(1)
with canvas(device) as draw:
draw.rectangle((0,0,127,63), outline='white', fill='black')
draw.rectangle((0,0,128,10), outline='white', fill='white')
draw.text((LINE_MENU_POS_X,0), clock(), 'black')
# StatusBox (from Right to Left)
# 1
if IsConnected() == 1: draw.rectangle((123,2,126,8), outline='black', fill='black')
else: draw.rectangle((123,2,126,8), outline='black', fill='white')
# 2
#if 0 == 1: draw.rectangle((118,2,121,8), outline='black', fill='black')
#else: draw.rectangle((118,2,121,8), outline='black', fill='white')
# 3
#if 0 == 1: draw.rectangle((113,2,116,8), outline='black', fill='black')
#else: draw.rectangle((113,2,116,8), outline='black', fill='white')
draw.rectangle((LINE_MENU_POS_X, (CURR_SELECTED - CURR_TOP)*10+12,
128-(LINE_MENU_POS_X+1),((CURR_SELECTED - CURR_TOP)*10)+10+12),
outline='white', fill='white')
for ind, y in LINE_MENU_POS_Y.items():
try:
numb = CURR_TOP + ind
text = ENTRIES_menuName[numb]
if text.lower().find('_separator_'.lower()) >= 0:
text = ' '
elif (CURR_SELECTED == numb) and (draw.textsize(text, font=FONT)[0] > 125):
lm = int(125/draw.textsize('M', font=FONT)[0])
countSS = int(countS)
try:
text = text+' '
li = 0+countSS
le = lm+countSS
if (len(text)-li-1 < lm) or (le+1 > len(text)):
countS = 0.00
elif countSS == 0: countS += 0.02
else: countS += 0.05
text = text[li:le]
except:
countS = 0.00
text = text
else: countS = 0.00
#if CURR_SELECTED == numb: text = '>'+text
textColor = ['white']*len(ENTRIES_menuName)
textColor[CURR_SELECTED] = 'black'
draw.text((LINE_MENU_POS_X+1,y), text, textColor[ind+CURR_TOP])
# .__1__2__ x
# |
# 1 ####
# | # #
# 2 ####
# |
# y
# x1 y1 x2 y2
draw.rectangle((126,(ind+1)*10+7, 128,((ind+1)*10)+9), outline='white', fill='white')
draw.rectangle((0,(ind+1)*10+7, 1,((ind+1)*10)+9), outline='white', fill='white')
except:
pass
elif (MENU_STATE == 2) or (MENU_STATE == 3):
with canvas(device) as draw:
x = 8
max_count = 7
ttlist = TEXT_Lst
if len(ttlist) < max_count:
max_count = len(ttlist)
#device.clear()
time.sleep(0.01)
for count in range(0,max_count):
draw.text((0,x*count), str(ttlist[count]), font=FONT_, fill='white')
if mainTHREAD_Kill == 1: break
def getMenu(menu=1, data=TEXT_Lst):
global ENTRIES_menuLevel
global ENTRIES_backMenu
global ENTRIES_Lst
global ENTRIES_menuName
global MENU_STATE
global TEXT_Lst
TEXT_Lst = []
if (menu == 2) and (str(data.__class__.__name__).lower() == 'list'.lower()):
TEXT_Lst = data
MENU_STATE = 2
else:
ENTRIES_menuName = {}
count = 0
for menun, menud in ENTRIES_Lst[ENTRIES_menuLevel].items():
if str(menud.__class__.__name__).lower() == 'dict'.lower():
ENTRIES_menuName[count] = menun
count += 1
MENU_STATE = 1
def detectDown(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
if (STATE == 1) and (MENU_STATE == 1):
if CURR_SELECTED + 1 >= len(ENTRIES_menuName):
CURR_SELECTED = 0
CURR_TOP = 0
else:
CURR_SELECTED = CURR_SELECTED + 1
if CURR_SELECTED > CURR_TOP + LINE_MENU_MAX-1:
CURR_TOP = CURR_TOP + 1
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
True
def detectUp(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
if (STATE == 1) and (MENU_STATE == 1):
if CURR_SELECTED - 1 < 0:
CURR_SELECTED = len(ENTRIES_menuName) - 1
if len(ENTRIES_menuName) >= LINE_MENU_MAX+1:
CURR_TOP = len(ENTRIES_menuName) - LINE_MENU_MAX
else:
CURR_SELECTED = CURR_SELECTED - 1
if CURR_SELECTED < CURR_TOP:
CURR_TOP = CURR_TOP - 1
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
True
def detectRight(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
global THREAD_Lock
global THREAD_Kill
if (STATE == 1) and (MENU_STATE == 1):
for menun, menud in ENTRIES_Lst[ENTRIES_menuLevel].items():
if menun.lower().find('_separator_'.lower()) >= 0:
getMenu(1)
elif menun == ENTRIES_menuName[CURR_SELECTED]:
for ind, new_value in menud.items():
if str(new_value).lower() == '{}':
getMenu(1)
elif str(new_value.__class__.__name__).lower() == 'dict'.lower():
ENTRIES_backMenu[ENTRIES_menuLevel] = CURR_SELECTED
ENTRIES_menuLevel = ENTRIES_menuLevel + 1
CURR_SELECTED = 0
CURR_TOP = 0
ENTRIES_Lst[ENTRIES_menuLevel] = new_value
getMenu(1)
elif str(new_value.__class__.__name__).lower() == 'set'.lower():
THREAD_Lock = 1
getMenu(2,['Wait...'])
for func in new_value:
if str(func.__class__.__name__).lower() == 'function'.lower():
device.contrast(250)
THREAD_Lock = 1
THREAD_Kill = False
#funcThread = threading.Thread(target=func, args=(lambda:THREAD_Kill,), daemon=True)
funcThread = threading.Thread(target=func, args=(str(menun),), daemon=True)
funcThread.start()
count_kill = 0
while funcThread.isAlive():
THREAD_Lock = 1
time.sleep(1)
if count_kill > THREAD_Timeout:
THREAD_Kill = True
count_kill += 1
device.contrast(5)
THREAD_Lock = 0
myFuncEntry.get()
elif (STATE == 1) and (MENU_STATE == 2):
True
def detectLeft(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
global THREAD_Kill
if (STATE == 1) and (MENU_STATE == 1):
if ENTRIES_menuLevel > 0:
ENTRIES_menuLevel = ENTRIES_menuLevel - 1
CURR_SELECTED = ENTRIES_backMenu[ENTRIES_menuLevel]
CURR_TOP = ENTRIES_backMenu[ENTRIES_menuLevel]
if (CURR_SELECTED == len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) - 1):
#print('a1')
if (len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) >= LINE_MENU_MAX+1):
#print('a2')
CURR_TOP = len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) - LINE_MENU_MAX
elif (len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) < LINE_MENU_MAX+1):
#print('a3')
CURR_TOP = 0
elif (CURR_SELECTED <= len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) - 1):
#print('b1')
if (CURR_SELECTED < LINE_MENU_MAX) or (len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) < LINE_MENU_MAX+1):
#print('b2')
CURR_TOP = 0
elif (len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) >= LINE_MENU_MAX+1):
#print('b3')
CURR_TOP = len(ENTRIES_Lst[ENTRIES_menuLevel].keys()) - LINE_MENU_MAX
myFuncEntry.get()
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
THREAD_Kill = True
if THREAD_Lock == 0:
MENU_STATE = 1
getMenu(1)
def detectPress(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
if (STATE == 1) and (MENU_STATE == 1):
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
True
def detectKey1(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
device.contrast(255)
if (STATE == 1) and (MENU_STATE == 1):
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
True
def detectKey2(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
device.contrast(5)
if (STATE == 1) and (MENU_STATE == 1):
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
True
def detectKey3(any=''):
global CURR_SELECTED
global CURR_TOP
global ENTRIES_Lst
global ENTRIES_menuLevel
global ENTRIES_backMenu
global MENU_STATE
ScreenSaver()
if MENU_STATE == 1:
getMenu(1)
elif (STATE == 1) and (MENU_STATE == 2):
True
########################################################################
########################################################################
########## USER CONFIG
########################################################################
########################################################################
# > /dev/null 2>&1 < /dev/null
def RunCmdAu(cmd):
p = Popen(cmd, shell=True, stdout=PIPE)
output = p.communicate()[0]
output = str(output, 'utf-8').split('\n')[0]
return output
def RunCmdA(cmd):
p = Popen(cmd, shell=True, stdout=PIPE)
output = p.communicate()[0]
output = str(output).split('\n')[0]
return output
def RunCmdBu(cmd):
output = subprocess.check_output(cmd, shell= True)
output = str(output, 'utf-8')
return output
def RunCmdB(cmd):
output = subprocess.check_output(cmd, shell= True)
output = str(output)
return output
def IsConnected():
return usb.core.find(idVendor=VENDOR, idProduct=PRODUCT) is not None
def entry_Test():
global ENTRIES
for x in range(0,3):
ENTRIES[0]['Run Test '+ x ] = {1:{myFunc.Test2}}
ENTRIES[0]['Menu 6'] = {1:{myFunc.Test2}}
# overwrite
ENTRIES[0]['Menu 6'][1] = {myFunc.Test}
ENTRIES[0]['Menu 6'][2] = {myFunc.Test2}
def clock():
#"date +\"%Y-%m-%d %H:%M:%S\"" "date +%R"
now = datetime.now()
today_date = now.strftime("%d-%b-%Y")
today_time = now.strftime("%H:%M:%S")
return "%s %s" % (today_date, today_time)
#return "%s %s" % (today_time)
def Services_Update():
# ENTRIES[0]['System'] = {1:{}} # add, clear all
#ENTRIES[0]['System'][1]['_separator_01'] ={999:{}}
ENTRIES[0]['System'][1]['Services'] = {
2:{
'Start':{3:{}},
'Stop':{3:{}},
'Enable':{3:{}},
'Disable':{3:{}}
}
}
services = []
services = ['wpa_supplicant','wpa_supplicant','psiphon@a','psiphon@b','psiphon@c','haproxy','dhcpcd','bluetooth']
services = list(dict.fromkeys(services))
if len(services) > 0:
for ind in range(0,len(services)):
service = str(services[ind]).replace('.service','')
ENTRIES[0]['System'][1]['Services'][2]['Start'][3][service] = {
4:{myFunc.Service_Start_}
}
ENTRIES[0]['System'][1]['Services'][2]['Stop'][3][service] = {
4:{myFunc.Service_Stop_}
}
ENTRIES[0]['System'][1]['Services'][2]['Enable'][3][service] = {
4:{myFunc.Service_Enable_}
}
ENTRIES[0]['System'][1]['Services'][2]['Disable'][3][service] = {
4:{myFunc.Service_Disable_}
}
def Network_Update():
global ENTRIES
ENTRIES[0]['Network'] = {1:{}} # add, clear all
#ENTRIES[0]['Network'][1] = {}
ENTRIES[0]['Network'][1]['Bring Up'] = {2:{}}
ENTRIES[0]['Network'][1]['Bring Down'] = {2:{}}
stats = psutil.net_if_stats()
available_networks = []
up_available_networks = []
down_available_networks = []
for intface, addr_list in stats.items():
available_networks.append(intface)
down_available_networks.append(intface)
if intface in stats and getattr(stats[intface], "isup"):
up_available_networks.append(intface)
down_available_networks.remove(intface)
if len(up_available_networks) > 0:
for ind in range(0,len(up_available_networks)):
iface = str(up_available_networks[ind])
ENTRIES[0]['Network'][1]['Bring Down'][2][iface] = {
3:{myFunc.Iface_Down_}
}
if len(down_available_networks) > 0:
for ind in range(0,len(down_available_networks)):
iface = str(down_available_networks[ind])
ENTRIES[0]['Network'][1]['Bring Up'][2][iface] = {
3:{myFunc.Iface_Up_}
}
if len(available_networks) > 0:
for ind in range(0,len(available_networks)):
iface = str(available_networks[ind])
if iface.find('wlan') < 0:
continue
ENTRIES[0]['System'][1]['Services'][2]['Start'][3]['wpa_supplicant@'+iface] = {
4:{myFunc.Service_Start_}
}
ENTRIES[0]['System'][1]['Services'][2]['Stop'][3]['wpa_supplicant@'+iface] = {
4:{myFunc.Service_Stop_}
}
ENTRIES[0]['System'][1]['Services'][2]['Enable'][3]['wpa_supplicant@'+iface] = {
4:{myFunc.Service_Enable_}
}
ENTRIES[0]['System'][1]['Services'][2]['Disable'][3]['wpa_supplicant@'+iface] = {
4:{myFunc.Service_Disable_}
}
########## USER FUNCTIONS FOR ENTRIES
class myFunc:
def Test(arg):
while True:
time.sleep(0.01)
if THREAD_Kill:break
getMenu(2,['Line Text 01/07'])
time.sleep(0.2)
getMenu(2,['','Line Text 02/07'])
time.sleep(0.2)
getMenu(2,['','','Line Text 03/07'])
time.sleep(0.2)
getMenu(2,['','','','Line Text 04/07'])
time.sleep(0.2)
getMenu(2,['','','','','Line Text 05/07'])
time.sleep(0.2)
getMenu(2,['','','','','','Line Text 06/07'])
time.sleep(0.2)
getMenu(2,['','','','','','','Line Text 07/07'])
time.sleep(0.2)
def Test2(arg):
while True:
time.sleep(0.01)
if THREAD_Kill:break
getMenu(2,[arg,RunCmdAu('date +%r')])
def Halt(arg):
getMenu(2,['','Halt...'])
RunCmdA('halt --halt')
def Halt_Force(arg):
getMenu(2,['','Halt... (Force)'])
RunCmdA('halt --halt --force')
def Reboot(arg):
getMenu(2,['','Reboot...'])
RunCmdA('halt --reboot')
def Reboot_Force(arg):
getMenu(2,['','Reboot... (Force)'])
RunCmdA('halt --reboot --force')
def Service_Start_(arg):
cmd = 'start'
RunCmdA('systemctl '+ cmd +' '+arg+'.service')
getMenu(2,['['+arg+']('+cmd+')',' Done!'])
def Service_Stop_(arg):
cmd = 'stop'
RunCmdA('systemctl '+ cmd +' '+arg+'.service')
getMenu(2,['['+arg+']('+cmd+')',' Done!'])
def Service_Enable_(arg):
cmd = 'enable'
RunCmdA('systemctl '+ cmd +' '+arg+'.service')
getMenu(2,['['+arg+']('+cmd+')',' Done!'])
def Service_Disable_(arg):
cmd = 'disable'
RunCmdA('systemctl '+ cmd +' '+arg+'.service')
getMenu(2,['['+arg+']('+cmd+')',' Done!'])
def Iface_Up_(arg):
cmd = 'up'
RunCmdA('ip link set dev '+ arg +' '+cmd)
getMenu(2,['['+arg+']('+cmd+')',' Done!'])
def Iface_Down_(arg):
cmd = 'down'
RunCmdA('ip link set dev '+ arg +' '+cmd)
getMenu(2,['['+arg+']('+cmd+')',' Done!'])
########## FUNCTION THAT GENERATES ENTRIES - POST LOAD '_ENTRIES'
class myFuncEntry:
def get():
global ENTRIES
#ENTRIES[0]['Test X'] = {1:{myFunc.Test2}}
try:
#entry_Test()
Services_Update()
Network_Update()
except: pass
########## USER ENTRIES
class myEntry:
_ENTRIES = {}
def get():
#global _ENTRIES
# Don't repeat Name at the same Level.
# Funtions without (). Example: 'myFunc.Test' for 'myFunc.Test()'
# level name -> level name/function -> level name/function -> ...
_ENTRIES = {
0:
{
'System':
{
1:
{
'Halt':{2:{'Normal':{3:{myFunc.Halt}},'Force':{3:{myFunc.Halt_Force}}}},
'Reboot':{2:{'Normal':{3:{myFunc.Reboot}},'Force':{3:{myFunc.Reboot_Force}}}}
}
}
}
}
#
#_ENTRIES[0]['TestX'] = {1:{myFunc.Test2}}
#
return _ENTRIES
########################################################################
########################################################################
########################################################################
# def detectKey1(event):
GPIO.add_event_detect(key['key1'], GPIO.RISING, callback=detectKey1, bouncetime=200)
GPIO.add_event_detect(key['key2'], GPIO.RISING, callback=detectKey2, bouncetime=200)
GPIO.add_event_detect(key['key3'], GPIO.RISING, callback=detectKey3, bouncetime=200)
GPIO.add_event_detect(key['left'], GPIO.RISING, callback=detectLeft, bouncetime=200)
GPIO.add_event_detect(key['up'], GPIO.RISING, callback=detectUp, bouncetime=200)
GPIO.add_event_detect(key['press'], GPIO.RISING, callback=detectPress, bouncetime=200)
GPIO.add_event_detect(key['down'], GPIO.RISING, callback=detectDown, bouncetime=200)
GPIO.add_event_detect(key['right'], GPIO.RISING, callback=detectRight, bouncetime=200)
# if GPIO.event_detected(key['key1']):
#GPIO.add_event_detect(key['key1'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['key2'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['key3'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['left'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['up'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['press'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['down'], GPIO.FALLING, bouncetime=300)
#GPIO.add_event_detect(key['right'], GPIO.FALLING, bouncetime=300)
# GPIO.wait_for_edge(key['key1'], GPIO.FALLING)
threadN02 = ''
def main():
global MENU_STATE
global ENTRIES
global ENTRIES_Lst
global mainTHREAD_Kill
#args = sys.argv[1:]
#if not args:
# print('usage: [--flags options] [inputs] ')
# sys.exit(1)
showSplash()
########################################################################
try:
ENTRIES = myEntry.get()
myFuncEntry.get()
except:
logging.error('--Err! Entries!')
pass
########################################################################
ENTRIES_Lst[ENTRIES_menuLevel] = ENTRIES[ENTRIES_menuLevel]
MENU_STATE = 1
try:
threadN02 = threading.Thread(name='showMenu', target=showMenu)
threadN02.start()
#threadN03 = threading.Thread(name='xMenu', target=xMenu, daemon=True)
#threadN03.start()
signal.pause()
except (KeyboardInterrupt, SystemExit):
#logging.warning('--KeyboardInterrupt!')
mainTHREAD_Kill = 1
#time.sleep(2)
sys.exit(' Bye!')
#except: # comment for output
# logging.error('--Uups!')
# sys.exit(' Uups!')
#| Main body
if __name__ == '__main__':
try:
main()
except (KeyboardInterrupt, SystemExit):
mainTHREAD_Kill = 1
logging.warning('--KeyboardInterrupt!')
#time.sleep(2)
sys.exit(' Bye!')
except: # comment for output
mainTHREAD_Kill = 1
logging.error('--Oops!')
time.sleep(2)
sys.exit(' Oops!')
mainTHREAD_Kill = 1
time.sleep(2)
GPIO.cleanup()
sys.exit(2)
os.close()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment