def __init__(self, window, size, options):
""" Initialise and start the snackspace application """
self.inittime = int(time.time())
self.options = options
self.input_handler = InputHandler()
self.task_handler = TaskHandler(self)
self.task_handler.add_function(self.rfid_task, 500, True)
self.logger = logging.getLogger("snackspace")
self.rfid = RFIDReader(self.options.rfid_port)
self.is_fullscreen = True
self.cursor_visible = False
self.window_size = size
self.screen_manager = ScreenManager(self, window, size)
self.user = None
self.products = []
self.reply_queue = Queue.Queue()
self.dbaccess = DbClient(self.options.hostip, self.task_handler,
self.db_state_callback)
self.dbaccess.daemon = True
self.dbaccess.start()
def __init__(self, stdscreen, userpass):
self.username = userpass['user']
self.password = userpass['pass']
self.screen = stdscreen
self.dimensions = self.screen.getmaxyx()
self.screen_manager = ScreenManager(self.screen)
self.all_databases_query = "SELECT pg_catalog.pg_database.datname FROM pg_catalog.pg_database WHERE pg_catalog.pg_get_userbyid(pg_catalog.pg_database.datdba) = \'%s\';" % (self.username)
self.all_tables_query = "SELECT table_schema,table_name FROM information_schema.tables ORDER BY table_schema,table_name;"
self.current_database = None
def __init__(self):
print("[APP ] Initialized\n")
self.d = Display()
self.ds = DataStore()
self.sett = AppSettings()
self.keypad = Keypad()
self.sensors = Sensors()
self.lightc = LightController(self.ds, self.sett)
self.condc = CondController(self.ds, self.sett)
self.fanc = FanController(self.ds, self.sett)
self.evc = EVController(self.ds, self.sett)
self.screenMngr = ScreenManager(self.d, self.ds, self.sett,
self.keypad)
self.screenMngr.update()
self.processStart = 0
self.screensStart = 0
def __init__(self):
self.username = '' #username we will store from the user input
self.password = ''
self.screen = curses.initscr()
self.screen_manager = ScreenManager(self.screen)
def main():
"""Application entry point"""
global running
num_array = []
last_added = time.monotonic()
ignore_quit = False
if not platform.system() == "Linux":
sys.exit("'%s' OS not supported!" % platform.system())
if os.geteuid() == 0:
sys.exit("Camplayer is not supposed to be run as root!")
GLOBALS.PYTHON_VER = sys.version_info
if GLOBALS.PYTHON_VER < CONSTANTS.PYTHON_VER_MIN:
sys.exit("Python version '%i.%i' or newer required!"
% (CONSTANTS.PYTHON_VER_MIN[0], CONSTANTS.PYTHON_VER_MIN[1]))
# Started with arguments?
if len(sys.argv) > 1:
for idx, arg in enumerate(sys.argv):
# 1st argument is application
if idx == 0:
continue
# Help info
if arg == "-h" or arg == "--help":
print(" -h --help Print this help")
print(" -v --version Print version info")
print(" -c --config Use a specific config file")
print(" --rebuild-cache Rebuild cache on startup")
print(" --rebuild-cache-exit Rebuild cache and exit afterwards")
print(" -d --demo Demo mode")
print(" --ignorequit Don't quit when the 'Q' key is pressed")
sys.exit(0)
# Run in a specific mode
if arg == "--rebuild-cache" or arg == "--rebuild-cache-exit":
# Clearing the cache
clear_cache()
# Rebuild cache only and exit
if arg == "--rebuild-cache-exit":
# Exit when reaching the main loop
running = False
# Run with a specific config file
if arg == "-c" or arg == "--config" and (idx + 1) < len(sys.argv):
CONSTANTS.CONFIG_PATH = sys.argv[idx + 1]
# Display version info
if arg == "-v" or arg == "--version":
print("version " + __version__)
sys.exit(0)
# Run demo mode
if arg == "-d" or arg == "--demo":
CONSTANTS.CONFIG_PATH = CONSTANTS.DEMO_CONFIG_PATH
# Ignore keyboard 'quit' command
if arg == "--ignorequit":
ignore_quit = True
# Load settings from config file
CONFIG.load()
# Signal handlers
signal.signal(signal.SIGTERM, signal_handler)
signal.signal(signal.SIGINT, signal_handler)
LOG.INFO(_LOG_NAME, "Starting camplayer version %s" % __version__)
LOG.INFO(_LOG_NAME, "Using config file '%s' and cache directory '%s'"
% (CONSTANTS.CONFIG_PATH, CONSTANTS.CACHE_DIR))
# Cleanup some stuff in case something went wrong on the previous run
utils.kill_service('omxplayer.bin', force=True)
utils.kill_service('vlc', force=True)
utils.kill_service('pipng', force=True)
# OMXplayer is absolutely required!
if not utils.os_package_installed("omxplayer.bin"):
sys.exit("OMXplayer not installed but required!")
# ffprobe is absolutely required!
if not utils.os_package_installed("ffprobe"):
sys.exit("ffprobe not installed but required!")
# Get system info
sys_info = utils.get_system_info()
gpu_mem = utils.get_gpu_memory()
hw_info = utils.get_hardware_info()
# Set some globals for later use
GLOBALS.PI_SOC = hw_info.get("soc") # Not very reliable, usually reports BCM2835
GLOBALS.PI_MODEL = hw_info.get("model")
GLOBALS.PI_SOC_HEVC = hw_info.get('hevc')
GLOBALS.NUM_DISPLAYS = 2 if hw_info.get('dual_hdmi') else 1
GLOBALS.VLC_SUPPORT = utils.os_package_installed("vlc")
GLOBALS.PIPNG_SUPPORT = utils.os_package_installed("pipng")
GLOBALS.FFMPEG_SUPPORT = utils.os_package_installed("ffmpeg")
GLOBALS.USERNAME = os.getenv('USER')
# Log system info
LOG.INFO(_LOG_NAME, "********************** SYSTEM INFO **********************")
LOG.INFO(_LOG_NAME, str("Camplayer version = %s" % __version__))
LOG.INFO(_LOG_NAME, str("Operating system = %s" % sys_info))
LOG.INFO(_LOG_NAME, str("Raspberry Pi SoC = %s" % hw_info.get("soc")))
LOG.INFO(_LOG_NAME, str("Raspberry Pi revision = %s" % hw_info.get("revision")))
LOG.INFO(_LOG_NAME, str("Raspberry Pi model name = %s" % hw_info.get("model")))
LOG.INFO(_LOG_NAME, str("GPU memory allocation = %i MB" % gpu_mem))
LOG.INFO(_LOG_NAME, str("Python version = %s MB" % sys.version.splitlines()[0]))
LOG.INFO(_LOG_NAME, str("VLC installed = %s" % GLOBALS.VLC_SUPPORT))
LOG.INFO(_LOG_NAME, str("pipng installed = %s" % GLOBALS.PIPNG_SUPPORT))
LOG.INFO(_LOG_NAME, str("ffmpeg installed = %s" % GLOBALS.FFMPEG_SUPPORT))
LOG.INFO(_LOG_NAME, "*********************************************************")
# Register for keyboard 'press' events, requires root
# TODO: check privileges?
keyboard = InputMonitor(event_type=['press'])
# Log overwrites for debugging purpose
for setting in CONFIG.advanced_overwritten:
LOG.INFO(_LOG_NAME, "advanced setting overwritten for '%s' is '%s'" % (setting[0], setting[1]))
# Does this system fulfill the minimal requirements
if CONFIG.HARDWARE_CHECK:
if not hw_info.get("supported"):
sys.exit("Unsupported hardware with revision %s ..." % hw_info.get("revision"))
if gpu_mem < CONSTANTS.MIN_GPU_MEM:
sys.exit("GPU memory of '%i' MB insufficient ..." % gpu_mem)
# Auto detect screen resolution
# For the raspberry pi 4:
# both HDMI displays are supposed to have the same configuration
if CONFIG.SCREEN_HEIGHT == 0 or CONFIG.SCREEN_WIDTH == 0:
display_conf = utils.get_display_mode()
CONFIG.SCREEN_HEIGHT = display_conf.get('res_height')
CONFIG.SCREEN_WIDTH = display_conf.get('res_width')
LOG.INFO(_LOG_NAME, "Detected screen resolution for HDMI0 is '%ix%i@%iHz'" % (
CONFIG.SCREEN_WIDTH, CONFIG.SCREEN_HEIGHT, display_conf.get('framerate')))
if CONFIG.SCREEN_HEIGHT <= 0:
CONFIG.SCREEN_HEIGHT = 1080
if CONFIG.SCREEN_WIDTH <= 0:
CONFIG.SCREEN_WIDTH = 1920
# Are we sure the 2nd HDMI is on for dual HDMI versions?
if GLOBALS.NUM_DISPLAYS == 2:
# Check for resolution instead of display name as the latter one is empty with force HDMI hotplug
if not utils.get_display_mode(display=7).get('res_height'):
GLOBALS.NUM_DISPLAYS = 1
# Calculate the virtual screen size now that we now the physical screen size
CONSTANTS.VIRT_SCREEN_WIDTH = int(CONFIG.SCREEN_WIDTH * (100 - CONFIG.SCREEN_DOWNSCALE) / 100)
CONSTANTS.VIRT_SCREEN_HEIGHT = int(CONFIG.SCREEN_HEIGHT * (100 - CONFIG.SCREEN_DOWNSCALE) / 100)
CONSTANTS.VIRT_SCREEN_OFFSET_X = int((CONFIG.SCREEN_WIDTH - CONSTANTS.VIRT_SCREEN_WIDTH) / 2)
CONSTANTS.VIRT_SCREEN_OFFSET_Y = int((CONFIG.SCREEN_HEIGHT - CONSTANTS.VIRT_SCREEN_HEIGHT) / 2)
LOG.INFO(_LOG_NAME, "Using a virtual screen resolution of '%ix%i'" %
(CONSTANTS.VIRT_SCREEN_WIDTH, CONSTANTS.VIRT_SCREEN_HEIGHT))
# Workaround: srt subtitles have a maximum display time of 99 hours
if CONFIG.VIDEO_OSD and (not CONFIG.REFRESHTIME_MINUTES or CONFIG.REFRESHTIME_MINUTES >= 99 * 60):
CONFIG.REFRESHTIME_MINUTES = 99 * 60
LOG.WARNING(_LOG_NAME, "Subtitle based OSD enabled, forcing 'refreshtime' to '%i'" % CONFIG.REFRESHTIME_MINUTES)
# Show 'loading' on master display
BackGroundManager.show_icon_instant(BackGround.LOADING, display_idx=0)
# Initialize screens and windows
screenmanager = ScreenManager()
if screenmanager.valid_screens < 1:
sys.exit("No valid screen configuration found, check your config file!")
# Hide 'loading' message on master display
BackGroundManager.hide_icon_instant(display_idx=0)
# Working loop
while running:
# Trigger screenmanager working loop
screenmanager.do_work()
for event in keyboard.get_events():
last_added = time.monotonic()
if event.code in KEYCODE.KEY_NUM.keys():
LOG.DEBUG(_LOG_NAME, "Numeric key event: %i" % KEYCODE.KEY_NUM.get(event.code))
num_array.append(KEYCODE.KEY_NUM.get(event.code))
# Two digit for numbers from 0 -> 99
if len(num_array) > 2:
num_array.pop(0)
else:
# Non numeric key, clear numeric num_array
num_array.clear()
if event.code == KEYCODE.KEY_RIGHT:
screenmanager.on_action(Action.SWITCH_NEXT)
elif event.code == KEYCODE.KEY_LEFT:
screenmanager.on_action(Action.SWITCH_PREV)
elif event.code == KEYCODE.KEY_UP:
screenmanager.on_action(Action.SWITCH_QUALITY_UP)
elif event.code == KEYCODE.KEY_DOWN:
screenmanager.on_action(Action.SWITCH_QUALITY_DOWN)
elif event.code == KEYCODE.KEY_ENTER or event.code == KEYCODE.KEY_KPENTER:
screenmanager.on_action(Action.SWITCH_SINGLE, 0)
elif event.code == KEYCODE.KEY_ESC or event.code == KEYCODE.KEY_EXIT:
screenmanager.on_action(Action.SWITCH_GRID)
elif event.code == KEYCODE.KEY_SPACE:
screenmanager.on_action(Action.SWITCH_PAUSE_UNPAUSE)
elif event.code == KEYCODE.KEY_D:
screenmanager.on_action(Action.SWITCH_DISPLAY_CONTROL)
elif event.code == KEYCODE.KEY_Q and not ignore_quit:
running = False
break
# Timeout between key presses expired?
if time.monotonic() > (last_added + (CONSTANTS.KEY_TIMEOUT_MS / 1000)):
num_array.clear()
# 1 second delay to accept multiple digit numbers
elif time.monotonic() > (last_added + (CONSTANTS.KEY_MULTIDIGIT_MS / 1000)) and len(num_array) > 0:
LOG.INFO(_LOG_NAME, "Process numeric key input '%s'" % str(num_array))
number = 0
number += num_array[-2] * 10 if len(num_array) > 1 else 0
number += num_array[-1]
if number == 0:
num_array.clear()
screenmanager.on_action(Action.SWITCH_GRID)
else:
num_array.clear()
screenmanager.on_action(Action.SWITCH_SINGLE, number - 1)
time.sleep(0.1)
# Cleanup stuff before exit
keyboard.destroy()
BackGroundManager.destroy()
utils.kill_service('omxplayer.bin', force=True)
utils.kill_service('vlc', force=True)
utils.kill_service('pipng', force=True)
LOG.INFO(_LOG_NAME, "Exiting raspberry pi camplayer, have a nice day!")
sys.exit(0)
def __init__(self, stdscreen, userpass):
self.screen = stdscreen
self.username = userpass['user']
self.password = userpass['pass']
self.database_manager = DatabaseManager(self.screen, userpass)
self.screen_manager = ScreenManager(self.screen)
self.table_manager = TableManager(self.screen, userpass)
self.query_manager = queryDB(self.screen, userpass)
headeroptions = {'user': self.username}
#I ran into an error here when trying to set cursur to invisible
#this if/try makes sure that both the version of curses and the
#terminal support this functionality
if hasattr(curses, 'curs_set'):
try:
curses.curs_set(0)
except:
pass
importer = impexp(self.screen, userpass)
data_items = [
('Import', self.database_manager.display_all_databases_opt,
importer.list_sql_files),
('Export', self.database_manager.display_all_databases_opt,
importer.export)
]
data = Menu(data_items, self.screen, headeroptions)
browse_database_items = [
('List Databases', self.database_manager.display_all_databases),
('Create', self.database_manager.create_new_database),
('Copy', self.database_manager.display_all_copy_database),
('Drop', self.database_manager.display_all_delete_database)
]
browse_database = Menu(browse_database_items, self.screen,
headeroptions)
browse_table_items = [
('List Tables', self.database_manager.display_all_databases_opt,
self.table_manager.listTables),
('Create', self.database_manager.display_all_databases_opt,
self.table_manager.createTable),
('Delete', self.database_manager.display_all_databases_opt,
self.table_manager.list_drop_tables)
]
browse_table = Menu(browse_table_items, self.screen, headeroptions)
query_items = [
('Enter A Query', self.database_manager.display_all_databases_opt,
self.query_manager.do), ('Save A Query', self.query_manager.save),
('View Past Queries',
self.database_manager.display_all_databases_opt,
self.query_manager.get_history),
('View Saved Queries',
self.database_manager.display_all_databases_opt,
self.query_manager.get_saved)
]
query = Menu(query_items, self.screen, headeroptions)
main_menu_items = [('Data Management', data.display),
('Browse Databases', browse_database.display),
('Browse Tables', browse_table.display),
('Query', query.display)]
main_menu = Menu(main_menu_items, self.screen, headeroptions)
main_menu.display()
from animationAggregator import aggregateAnim
from displayableElement import DisplayableElement
from inputManager import processInputs
from screenmanager import ScreenManager
from textElement import TextElement
from room import Room
from player import Player
from backwall import BackWall
from diedmenu import DiedMenu
pygame.init()
pygame.font.init()
# Vars
size = width, height = 1024, 576
SM = ScreenManager(size)
clock = pygame.time.Clock()
time = 180
roomNumber = 0
floorNumber = 1
#roomNumber = 0
#floorNumber = 1
pygame.key.set_repeat(1, 200)
# Music
pygame.mixer.music.load("music.wav")
pygame.mixer.music.set_volume(0.1)
gameObjects = []
for x in range(16):
for y in range(9):
gameObjects.append(BackWall((x, y)))
def __init__(self, stdscreen, userpass):
self.username = userpass['user']
self.password = userpass['pass']
self.screen = stdscreen
self.dimensions = self.screen.getmaxyx()
self.screen_manager = ScreenManager(self.screen)
