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 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 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 __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
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)
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)
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()
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
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")
