def __init__(self, wlan_agent): self.dev_eui = None self.app_eui = None self.rf_mode = None self.measuring_mode = True self.debug_mode = False self._app_key = None self.onewire_interface = None self.web_server = None self.deepsleep = True self.chrono = Timer.Chrono() self.chrono.start() self.sensors = {} self.rgb_color = 0x007f00 #self.case_button = Button('P8', longms=500) self.wlan_agent = wlan_agent # Initialize Webserver self.web_server = Webserver(dev_state=self) self.web_server.init_webserver() # init pins for mode recognizion self.bin_switch_1 = Pin('P20', mode=Pin.IN, pull=Pin.PULL_UP) self.bin_switch_2 = Pin('P21', mode=Pin.IN, pull=Pin.PULL_UP) self.bin_switch_3 = Pin('P22', mode=Pin.IN, pull=Pin.PULL_UP) trigger = Pin.IRQ_FALLING | Pin.IRQ_RISING self.update_node_mode(None) self.bin_switch_1.callback(trigger, self.update_node_mode) self.bin_switch_2.callback(trigger, self.update_node_mode) self.bin_switch_3.callback(trigger, self.update_node_mode)
def main(): global device device.activate_ap() gc.collect() log.info("Free memory: {}".format(gc.mem_free())) http = Http() # Register handler for each path http.register_handler(HTTP_METHOD.GET, "/config", get_config) http.register_handler(HTTP_METHOD.POST, "/config", save_config) # Start the server @ port 80 log.info("IP: {}".format(device.get_ip())) log.info("Device ID: {}".format(device.id)) web = Webserver(http) web.start(80) gc.collect() device.indicate_ready() try: while True: # Let server process requests web.handle_client() time.sleep_ms(50) except Exception as err: log.severe("Unhandled exception: " + str(err)) finally: web.close()
def main(): args = get_args() setup_logging(args) options = dict(args.__dict__) options.update({ "format": args.format.strip(), "dimensions": (args.width, args.height), "outputSize": (args.dimension, args.dimension), "draw_debug_rects" : False, "draw_final_rects" : False, "color_model" : args.color_model.upper() }) if not args.cpus : options["cpus"] = os.cpu_count() logging.info("Image dimensions: {dimensions} format: {format}".format_map(options)) if args.profile : pr = cProfile.Profile() pr.enable() for i in range(args.initial, args.initial + args.count) : count, elapsed = pr.runcall(make_page, *(str(i), options)) print(count, elapsed) if elapsed > 2 : ps = pstats.Stats(pr) ps.sort_stats('cumtime') ps.print_stats(0.1) pr.clear() elif args.daemon : logging.info("Starting webserver, queue size {}".format(args.count)) server = Webserver(options) server.start_server() else : logging.info("Writing images to: {output_directory}".format_map(options)) logging.info("Generating {} images starting at {}".format(args.count, args.initial)) if options["cpus"] == 1 : for i in range(args.initial, args.initial + args.count) : num, elapsed = make_page(str(i), options) print("{} - {} images in {:.2f} seconds".format(i, num, elapsed)) else: mp.freeze_support() generate_pages(options)
async def run(): conn = await asyncpg.create_pool(user='******', password='******', database='msp', host='db') logging.info('Connected to database') tm = ThrustManager() server = Webserver(conn, '0.0.0.0', '5001', tm) worker = Worker(conn, tm) server.worker = worker await asyncio.wait([ asyncio.create_task(server.run()), asyncio.create_task(worker.run()), ]) await conn.close()
def start_webserver(self): if self.webserver: return if sys.platform=="darwin": try: self.webserver = Webserver() self.webserver.start() msg = self.webserver.wait_on_msg() if msg: m = QtGui.QMessageBox(self) m.setText(msg) m.setWindowModality(Qt.WindowModal) m.exec_() except: self.webserver = None
def web_loop(remote,file,stop): from webserver import Webserver while(not stop): #Checks the received data for matching strings and acts accordingly when the matching is successful web_data=Webserver().auto() if web_data==b"CLOSE_FILE": remote.autoSwitch() file.close() break elif web_data==b"SWITCH_HDMI": remote.autoSwitch() #This will make sure that our keyboard_loop thread will be stopped stop=True
def create_webserver(self): self.webserver = Webserver() self.webserver.post_handlers["up"] = self.wheels.forwards self.webserver.post_handlers["down"] = self.wheels.backwards self.webserver.post_handlers["left"] = self.wheels.left self.webserver.post_handlers["right"] = self.wheels.right self.webserver.post_handlers["stop"] = self.wheels.stop self.webserver.post_handlers["menu_next"] = self.menu.next self.webserver.post_handlers["menu_prev"] = self.menu.prev self.webserver.post_handlers["menu_select"] = self.menu.select self.webserver.post_handlers["menu_text"] = self.menu.text try: self.webserver.post_handlers["photo"] = self.webcam.take_photo except AttributeError: pass self.webserver.serve() self.add_component("Webserver", self.webserver)
def __init__(self): super().__init__() self.webserver = Webserver(self) self.database = DatabaseManager(self) # Init variables self.config = {} self.binance = None self.trading_pair_info = None self.base_asset_name = None self.base_asset_precision = None self.base_asset_balance = None self.base_asset_balance_precision = None self.base_asset_price = None self.base_asset_sell_price = None self.base_asset_take_profit_price = None self.base_asset_buy_price = None self.base_asset_old_price = None self.base_asset_change = None self.quote_asset_name = None self.quote_asset_precision = None self.quote_asset_balance = None self.quote_asset_balance_precision = None self.pair_min_price = None self.pair_max_price = None self.pair_min_quantity = None self.pair_max_quantity = None self.pair_step_size = None self.pair_min_ordersize = None self.countdown_timer = None self.buy_barrier_countdown_timer = None self.buy_barrier_timer_thread = None self.telegram = None self.sell_counter = 0 self.buy_counter = 0 self.timer_thread = None self.trading_thread = None self.webserver_thread = None
import json from webserver import Webserver with open('configs/config.json') as config_file: playlist = json.load(config_file)["playlist"] if __name__ == '__main__': webserver = Webserver(playlist) webserver.run()
def main(): server = Webserver("0.0.0.0", 80, 5, os.path.dirname(os.path.abspath(__file__)) + "/static") server.add_handler(handle_comments, "POST", "/comments") server.add_handler(handle_orders, "POST", "/orders") server.run()
class MainWnd(QtGui.QMainWindow): def __init__(self): super(MainWnd, self).__init__() self.tabs = [] # list of TabsType objects (namedtuples) self.folder_for_reveal = None self.filter = None self.treeView, self.treeViewModel = None,None self.text_change_mutex = Lock() self.paused = False self.tabCtrl = None self.proc_terminated = False self.taskManager = None self.threads = [] self.filter_model = None self.settings = QtCore.QSettings() self.openRecentMenu = None self.initUI() self.qtimer = QtCore.QTimer() self.qtimer.timeout.connect( self.make_screenshot ) self.qtimer.start( 5*1000 ) self.webserver = None RestoreGeom(self) def make_screenshot(self): if self.webserver: pngPath = self.webserver.pngPath if pngPath: widget = self.centralWidget() r = widget.rect() pixmap = QtGui.QPixmap( r.size() ) widget.render( pixmap, QtCore.QPoint(), QtGui.QRegion(r) ) file = QtCore.QFile(pngPath) file.open(QtCore.QIODevice.WriteOnly) pixmap.save(file, "PNG") def initUI(self): widget = QtGui.QWidget() total_layout = QtGui.QVBoxLayout() top = self.makeTopLayout() bottom = self.makeBottomLayout() self.initUI2(bottom) total_layout.addLayout(top) total_layout.addLayout(bottom) widget.setLayout(total_layout) self.setCentralWidget(widget) def makeTopLayout(self): """Make a QHBoxLayout containing clickable buttons like 'Pause', and filters ('errors', 'warnings'...)""" top = QtGui.QHBoxLayout() top.setAlignment( Qt.AlignLeft ) btn = QtGui.QPushButton("Pause") btn.setCheckable(True) btn.pressed.connect( self.toggle_paused ) top.addWidget( btn ) btn = QtGui.QPushButton("Run") btn.pressed.connect( self.run_yaml ) top.addWidget( btn ) btn = QtGui.QPushButton("Stop") btn.pressed.connect( self.stop_yaml ) top.addWidget( btn ) top.addWidget( QtGui.QLabel("Filters:") ) model = QStandardItemModel() combo = QtGui.QComboBox() combo.setModel(model) self.filter_model = model ix = 0 for label,str in config.FILTERS: item = QStandardItem(label) model.appendRow(item) combo.setItemData(ix, str) ix += 1 combo.currentIndexChanged.connect( lambda ix, combo=combo : self.filter_combo_changed(ix, combo) ) top.addWidget(combo) return top def makeBottomLeftLayout(self): bottom_left = QtGui.QVBoxLayout() self.treeView = QtGui.QTreeView() tv = self.treeView self.treeViewModel = QStandardItemModel() tvm = self.treeViewModel tvm.setHorizontalHeaderLabels (["Build Tasks"]) tv.setSizePolicy( QtGui.QSizePolicy( QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Expanding ) ) tv.setModel(tvm) bottom_left.addWidget(tv) color_key = QtGui.QTextEdit() color_key.setFrameStyle( QtGui.QFrame.NoFrame ) color_key.setReadOnly(True) color_key.setHtml(''' <b>Key:</b> <p> <ul> <li><span style="color:{blue}">Blue Items - Task is completed.</span></li> <li><span style="color:{gray}">Gray Items - Optional task is disabled.</span></li> <li><span style="color:{green}">Green Items - Task is running.</span></li> <li><span style="color:{black}">Black Items - Task is still to be run.</span></li> </ul> </p> '''.format(red=Color().Red().htmlCol, black=Color().Black().htmlCol, gray=Color().Gray().htmlCol, green=Color().Green().htmlCol, blue=Color().Blue().htmlCol)) color_key.setSizePolicy( QtGui.QSizePolicy( QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed ) ) color_key.setFixedHeight(100) bottom_left.addWidget(color_key) return bottom_left def updateRecentFileList(self): menu = self.openRecentMenu menu.clear() paths = self.settings.value("recentPaths", []) if paths: for path in paths: action = QtGui.QAction(path, self) action.triggered.connect(lambda self=self, path=path : self.open_yaml_from_path(path)) menu.addAction(action) def makeBottomLayout(self): bottom = QtGui.QHBoxLayout() bottom.addLayout(self.makeBottomLeftLayout()) # self.enqueueTreeBuildTasks( [("Build CC Debug", "Build..."), ("Build CC Release", "Build...")] ) return bottom def enqueueTreeBuildTasks(self, listOfTasksAndDescriptions): ''' returns list( (taskLabel, parent QStandardItem) ) ''' tvm = self.treeViewModel tvm.clear() tvm.setHorizontalHeaderLabels (["Build Tasks"]) results = [] for label,description in listOfTasksAndDescriptions: parent = QStandardItem(label) parent.appendRow([QStandardItem(description)]) tvm.appendRow(parent) results.append( (label, parent) ) return results def enqueue_tab(self, label): ''' returns tab_ix - integer index of tab generated ''' def StyledTextEdit(): rv = QtGui.QTextEdit() rv.setStyleSheet('font-family: "Andale Mono", "Courier New", "Lucida Console", Monaco, monospace;' + 'font-size: 10px;') return rv tt = TabsType(edit=StyledTextEdit(), label=label, textread="", lastlines=-1, qprocess=None) self.tabs.append(tt) tab_ix = len(self.tabs)-1 self.tabCtrl.addTab( tt.edit, tt.label) self.tabCtrl.setCurrentIndex(tab_ix) return tab_ix def initUI2(self, hb): tabCtrl = QtGui.QTabWidget() self.tabCtrl = tabCtrl hb.addWidget(tabCtrl); actions = [] SEPARATOR = "separator" OPEN_RECENT_PLACEHOLDER = "OpenRecentPlaceholder" for x in ( ("Open YAML task file...", "Ctrl+O", self.open_yaml_task), OPEN_RECENT_PLACEHOLDER, SEPARATOR, ("Run YAML tasks", "Ctrl+R", self.run_yaml), ("Stop YAML tasks", "Ctrl+Shift+R", self.stop_yaml), SEPARATOR, ("Reveal in Finder / Explorer", "Ctrl+E", self.reveal_in_x), SEPARATOR, ("Start Webserver", "", self.start_webserver), ("Stop Webserver", "", self.stop_webserver), SEPARATOR, ("Exit", "Ctrl+Q", self.close) ): if x==SEPARATOR: action = QtGui.QAction("", self) action.setSeparator(True) actions.append(action) elif x==OPEN_RECENT_PLACEHOLDER: actions.append(OPEN_RECENT_PLACEHOLDER) else: label, cut, action_fn = x action = QtGui.QAction(label, self) action.setShortcut(cut) action.triggered.connect(action_fn) actions.append(action) sb = self.statusBar() menubar = self.menuBar() fileMenu = menubar.addMenu('&File') for act in actions: if act==OPEN_RECENT_PLACEHOLDER: self.openRecentMenu = QtGui.QMenu(title="Open Recent") fileMenu.addMenu(self.openRecentMenu) self.updateRecentFileList() else: fileMenu.addAction(act) self.setGeometry(300, 300, 350, 250) self.setWindowTitle('BuildChimp') self.show() def reveal_in_x(self): QtGui.QDesktopServices.openUrl(self.folder_for_reveal) def toggle_paused(self): self.paused = not self.paused if not self.paused: self.filter_change_filter( self.filter ) # Bump a change in texts def filter_combo_changed(self, ix, combo): data = combo.itemData(ix) self.filter_change_filter( data ) def filter_change_filter(self, filter): self.text_change_mutex.acquire() with ScopeGuard(self.text_change_mutex.release) as sg: self.filter = filter for x in self.tabs: edit = x.edit text = x.textread edit.setText( self.apply_filter(text, self.filter) ) def apply_filter(self, text, filter): def colorize(str, filter): # TODO: We can add <span...>...</span>... around text. return str if not filter: return text x = text.decode("utf-8").split("\n") return "\n".join( [colorize(y,filter) for y in x if filter in y.lower()] ) def write_process_output(self, process, finish, line_flush, tabs_ix): if self.proc_terminated: return self.text_change_mutex.acquire() with ScopeGuard(self.text_change_mutex.release) as sg: t = str( process.readAllStandardOutput() ) t += str( process.readAllStandardError() ) if finish: t = t + "\n" + "Process exit-code = {}".format(process.exitCode()) old = self.tabs[tabs_ix] newText = old.textread + t nLines = newText.count("\n") / line_flush self.tabs[tabs_ix] = old._replace(textread=newText, lastlines=nLines) if not self.paused and old.lastlines != nLines or finish: old.edit.setText( self.apply_filter(newText, self.filter) ) def warn_fn(self): ''' Returns True - user wants quit, False - user cancelled (doesn't want quit). ''' res = QtGui.QMessageBox.warning(self, "Closing", "Processes are still running - do you want to quit?", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Cancel) if res==QtGui.QMessageBox.Ok: if self.taskmanager: self.taskmanager.stop() return True return False def add_load_path(self, path): path_list = self.settings.value("recentPaths", []) path_list = [path] + path_list def filter_dups_stable(seq): seen = set() seen_add = seen.add return [x for x in seq if not (x in seen or seen_add(x))] path_list = filter_dups_stable(path_list) path_list_items = set(path_list) self.settings.setValue("recentPaths", path_list) self.updateRecentFileList() def open_yaml_task(self): path, filter = QtGui.QFileDialog.getOpenFileName(filter="YAML buildchimp files (*.yaml)") if path: self.open_yaml_from_path(path) def open_yaml_from_path(self, path): self.folder_for_reveal = None path_user = None if path[-5:]==".yaml": path_user = path[:-5] + ".user.yaml" yaml_user = None try: with open(path_user, "rb") as user_yaml_file: if user_yaml_file: yaml_user = user_yaml_file.read() except: pass self.taskManager = taskmanager.TaskManager( open(path, "rb").read(), yaml_user, self ) self.add_load_path(path) qf = QtCore.QFileInfo(path) self.folder_for_reveal = "file://" + qf.absoluteDir().absolutePath() # print(self.folder_for_reveal) def run_yaml(self): if self.taskManager: self.taskManager.run_loop_init() self.tabs = [] self.tabCtrl.clear() self.taskManager.run_loop() def stop_yaml(self): if self.taskManager: self.taskManager.stop() def closeEvent(self, event): SaveGeom(self) self.settings.sync() stop_webserver = (lambda ws=self.webserver : ws.stop()) if self.webserver else lambda : None if not self.tabs or len(self.tabs)==0: stop_webserver() return self.close() for x in self.tabs: if x.qprocess: print(x.qprocess.state()) if x.qprocess and x.qprocess.state()!=QtCore.QProcess.NotRunning: if not self.warn_fn(): return stop_webserver() def start_webserver(self): if self.webserver: return if sys.platform=="darwin": try: self.webserver = Webserver() self.webserver.start() msg = self.webserver.wait_on_msg() if msg: m = QtGui.QMessageBox(self) m.setText(msg) m.setWindowModality(Qt.WindowModal) m.exec_() except: self.webserver = None def stop_webserver(self): if self.webserver: self.webserver.stop() self.webserver = None
class State(): def __init__(self, wlan_agent): self.dev_eui = None self.app_eui = None self.rf_mode = None self.measuring_mode = True self.debug_mode = False self._app_key = None self.onewire_interface = None self.web_server = None self.deepsleep = True self.chrono = Timer.Chrono() self.chrono.start() self.sensors = {} self.rgb_color = 0x007f00 #self.case_button = Button('P8', longms=500) self.wlan_agent = wlan_agent # Initialize Webserver self.web_server = Webserver(dev_state=self) self.web_server.init_webserver() # init pins for mode recognizion self.bin_switch_1 = Pin('P20', mode=Pin.IN, pull=Pin.PULL_UP) self.bin_switch_2 = Pin('P21', mode=Pin.IN, pull=Pin.PULL_UP) self.bin_switch_3 = Pin('P22', mode=Pin.IN, pull=Pin.PULL_UP) trigger = Pin.IRQ_FALLING | Pin.IRQ_RISING self.update_node_mode(None) self.bin_switch_1.callback(trigger, self.update_node_mode) self.bin_switch_2.callback(trigger, self.update_node_mode) self.bin_switch_3.callback(trigger, self.update_node_mode) #self.case_button.short = self.toggle_measuring #self.case_button.long = self.toggle_debug @property def app_key(self): return None # helper functions def set_rgb_color(self, color): """change local led colour""" self.rgb_color = color rgbled(color) def set_rgb_off(self): rgbled(RGBOFF) def update_node_mode(self, arg): # pin 1 and 2 0 0 0 1 1 0 1 1 # possible rf mode ["NO_MODE", "WLAN_AP", "WLAN_CLIENT", "LORA"] # measuring mode pin 3 # pins has to be inverted to fit to the labels on the pcb switch_1 = not self.bin_switch_1() switch_2 = not self.bin_switch_2() switch_3 = not self.bin_switch_3() log("Switch Positions: 1:{} 2:{} 3:{}".format(switch_1, switch_2, switch_3)) if switch_1 and switch_2: self.rf_mode = RF_MODES.LORA self.wlan_agent.stop() self.web_server.stop() elif switch_1 and not switch_2: self.rf_mode = RF_MODES.WLAN_CLIENT self.wlan_agent.activate_sta_mode() self.web_server.start() elif not switch_1 and switch_2: self.rf_mode = RF_MODES.WLAN_AP self.wlan_agent.activate_ap_mode() self.web_server.start() else: self.rf_mode = RF_MODES.NO_MODE log("Init Node Mode: {}".format(self.rf_mode)) # self.measuring_mode = switch_3 @app_key.setter def app_key(self, value): self._app_key = value def toggle_debug(): rgbled(TOGGLE_DEBUG_COLOR) self.debug_mode = not self.debug_mode if self.onewire_interface is not None: self.onewire_interface.debug = self.debug_mode sleep(0.5) rgbled(self.rgb_color) def toggle_measuring(self): rgbled(TOGGLE_MEASURING_COLOR) self.measuring_mode = not self.measuring_mode if self.measuring_mode: log('Measuring on') self.set_rgb_color(MEASURING_COLOR) else: log('Measuring off') self.set_rgb_color(NO_MEASURING_COLOR) def add_sensor(self, id, name, last_value=None): timestamp = self.chrono.read() counter = 0 self.sensors[id] = [ name, last_value, timestamp, counter, [None] * HISTORY_SIZE ] def update_sensor(self, id, value): counter = self.sensors[id][3] self.sensors[id][4][counter] = [ self.sensors[id][1], self.sensors[id][2] ] if counter == HISTORY_SIZE - 1: counter = 0 else: counter += 1 self.sensors[id][1] = value self.sensors[id][2] = self.chrono.read() self.sensors[id][3] = counter def remove_sensor(self, id): del self.sensors[id] def clear_sensors(self): self.sensors = {} def get_state(self): return { "dev_eui": self.dev_eui, "app_eui": self.app_eui, "sensors": self.sensors, "send_time": self.chrono.read() }
from core import Core from database import Database from webserver import Webserver from exceptionHandler import ExceptionHandler from saveStackTraceLog import SaveStackTraceLog try: classes = { "database" : Database(), "webserver" : Webserver(), "exceptionHandler" : ExceptionHandler(SaveStackTraceLog()), "saveLog" : SaveStackTraceLog() } core = Core(classes) core.start() core.stop() except Exception as e: exceptionHandler = ExceptionHandler(SaveStackTraceLog()) exceptionHandler.handleException(e) finally: print("Terminated")
class GushPiBot(object): """ This class controls the menu and programming and operates the main event loop """ def __init__(self): self.components = [] self.active = True GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) def startup(self): self.create_display() self.create_menu() self.create_wheels() self.create_program() if BUTTONS_AVAILABLE: self.create_buttons() if WEBCAM_AVAILABLE: self.create_webcam() if WII_AVAILABLE: self.create_wiimote() if ECHO_AVAILABLE: self.create_echo() if SPEECH_AVAILABLE: self.create_speech() if AUDIO_AVAILABLE: self.create_audio() if WEBSERVER_AVAILABLE: self.create_webserver() self.create_keyboard() self.update_menu() self.display.display_at(1, 0, "Init complete") def add_component(self, text, component): self.components.append(component) self.display.display_at(1, 0, "Created " + text) def create_display(self): if LCD_AVAILABLE: self.display = LCDDisplay() else: self.display = ConsoleDisplay() self.display.display("GushPiBot...") self.display_ip() self.add_component("Display", self.display) def create_wheels(self): self.wheels = Wheels() self.add_component("Wheels", self.wheels) def create_program(self): self.command = 0 self.program = Program(self.display) self.program.add_command("^", "Forward", self.wheels.forwards, self.wheels.stop) self.program.add_command("v", "Backward", self.wheels.backwards, self.wheels.stop) self.program.add_command("<", "Left", self.wheels.left, self.wheels.stop) self.program.add_command(">", "Right", self.wheels.right, self.wheels.stop) self.program.add_command("{", "Slow Left", self.wheels.slow_left, self.wheels.stop) self.program.add_command("}", "Slow Right", self.wheels.slow_right, self.wheels.stop) self.add_component("Program", self.program) def create_buttons(self): self.buttons = Buttons() self.buttons.handlers["MENU"].add(self.menu.next) self.buttons.handlers["SELECT"].add(self.menu.select) self.add_component("Buttons", self.buttons) def create_webcam(self): self.webcam = Webcam() self.program.add_command("#", "Photo", self.webcam.take_photo) self.add_component("Webcam", self.webcam) def create_wiimote(self): self.wiimote = Wiimote(self.display) self.wiimote.handlers["UP"].add(self.wheels.forwards) self.wiimote.handlers["DOWN"].add(self.wheels.backwards) self.wiimote.handlers["LEFT"].add(self.wheels.left) self.wiimote.handlers["RIGHT"].add(self.wheels.right) self.wiimote.handlers["A"].add(self.wheels.stop) try: self.wiimote.handlers["B"].add(self.webcam.take_photo) except AttributeError: pass self.wiimote.handlers["HOME"].add(self.menu.select) self.wiimote.handlers["MINUS"].add(self.menu.prev) self.wiimote.handlers["PLUS"].add(self.menu.next) self.wiimote.stop_handler = self.wheels.stop self.add_component("Wiimote", self.wiimote) def create_speech(self): self.speech = Speech() self.speech.speak("Hello. I am Gush Pi Bot.") self.wheels.speech_handler.add(self.speech.speak) self.add_component("Speech", self.speech) def create_audio(self): self.audio = Audio() self.add_component("Audio", self.audio) def create_echo(self): self.echo = Echo(self.display) self.echo.stop_handler.add(self.wheels.stop) self.add_component("Echo", self.echo) def create_keyboard(self): self.keyboard = Keyboard(self.display.stdscr) self.keyboard.handlers["UP"].add(self.wheels.forwards) self.keyboard.handlers["DOWN"].add(self.wheels.backwards) self.keyboard.handlers["LEFT"].add(self.wheels.left) self.keyboard.handlers["RIGHT"].add(self.wheels.right) self.keyboard.handlers["."].add(self.wheels.stop) self.keyboard.handlers["{"].add(self.wheels.slow_left) self.keyboard.handlers["}"].add(self.wheels.slow_right) self.keyboard.handlers["CTRL+X"].add(self.pi_shutdown) self.keyboard.handlers["PAGEDOWN"].add(self.menu.next) self.keyboard.handlers["PAGEUP"].add(self.menu.prev) self.keyboard.handlers["RETURN"].add(self.menu.select) self.keyboard.handlers["ESC"].add(self.exit) try: self.keyboard.handlers["#"].add(self.webcam.take_photo) except AttributeError: pass self.add_component("Keyboard", self.keyboard) def create_webserver(self): self.webserver = Webserver() self.webserver.post_handlers["up"] = self.wheels.forwards self.webserver.post_handlers["down"] = self.wheels.backwards self.webserver.post_handlers["left"] = self.wheels.left self.webserver.post_handlers["right"] = self.wheels.right self.webserver.post_handlers["stop"] = self.wheels.stop self.webserver.post_handlers["menu_next"] = self.menu.next self.webserver.post_handlers["menu_prev"] = self.menu.prev self.webserver.post_handlers["menu_select"] = self.menu.select self.webserver.post_handlers["menu_text"] = self.menu.text try: self.webserver.post_handlers["photo"] = self.webcam.take_photo except AttributeError: pass self.webserver.serve() self.add_component("Webserver", self.webserver) def create_menu(self): self.display.display("GushPiBot...\nCreating menu") self.menu = Menu(self.display) def update_menu(self): for item in self.components: item.update_menu(self.menu) menu = self.menu.add_folder("System") self.menu.add_function("Exit", self.exit, menu) self.menu.add_function("Shutdown RasPi", self.pi_shutdown, menu) self.menu.add_function("IP Address", self.display_ip, menu) try: self.menu.speech = self.speech except AttributeError: pass def run(self, program=None): if program: self.display.display("GushPiBot...\nRunning...") self.program.set(program) self.program.view() self.program.run() else: self.display.display("GushPiBot...\nListening...") while self.loop_cycle(): time.sleep(0.1) def display_ip(self): p = Popen("hostname -I", shell=True, stdout=PIPE) output = p.communicate()[0].split("\n")[0] self.display.display_at(1, 0, output.ljust(16)) def exit(self): self.display.display("GushPiBot...\nExiting...") self.active = False def loop_cycle(self): for item in self.components: item.check() return self.active def cleanup(self): for item in self.components: try: item.cleanup() except: pass def pi_shutdown(self): self.display.display("Pi Shutdown") try: self.speech.speak("Shutting down Raspberry Pi") except AttributeError: pass call('halt', shell=False)
class ModRef: ''' helper class to store references to the global modules ''' def __init__(self): self.server = None self.message_handler = None def _(s): return s logger = schnipsllogger.getLogger(__name__) DirectoryMapper( os.path.abspath(os.path.dirname(__file__)), { 'backup': 'volumes/backup', 'runtime': 'volumes/runtime', 'tmpfs': 'volumes/tmpfs', 'videos': 'volumes/videos', }) modref = ModRef() # create object to store all module instances modref.message_handler = MessageHandler(modref) modref.server = Webserver(modref) plugin_manager = PluginManager(modref, 'plugins') modref.server.run() while (True): time.sleep(1)
config = {} with open(config_path, 'r') as ymlfile: config = yaml.load(ymlfile, Loader=yaml.SafeLoader) logger.info("Loaded %d configuration items from %s" % (len(config), config_path)) # Create the AT command poller at_poller = Poller( config['at']['dev'], config['at']['poll_delay'], config['at']['statsd'] if 'statsd' in config['at'] else None) at_poller.start() # Create the internet connection checker ip_checker = InternetChecker() # Create the supervisor instance cm_supervisor = Supervisor(config['cm']['path'], config['cm']['respawn_delay'], config['cm']['apn'], config['cm']['log_lines'], at_poller, ip_checker) cm_supervisor.start() # Create the webserver server = Webserver(config['web']['port'], at_poller, cm_supervisor, ip_checker) # Start the server server.start_server() # Keep the main thread alive in case the web server was configured not to start while cm_supervisor.is_supervising: time.sleep(1)
import time import network import ujson as json import tempio import timer from machine import Pin, Timer from display_web import DisplayWeb from webserver import Webserver display_web = DisplayWeb() display = display_web webserver = Webserver(display_web) settings = json.load(open("settings.json", 'r')) temp_io = tempio.TempIO(settings) led = Pin(5, Pin.OUT) oldvalue = True def check_wifi(wifi): if 'wifi-station' not in settings: return if wifi.isconnected(): led.value(0) return global oldvalue