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
