def webServerStart(port):
global kill_received
webServer = WebServer(port)
while not kill_received:
time.sleep(1)
webServer.shutdown()
def build(self):
# self.ws = WebServer("http://192.168.43.150:5000", 1)
self.screen_manager = ScreenManager()
if 'MANTENCIONES_VERBOSE' in os.environ:
verbose=1
else:
verbose=0
if 'DEVELOPMENT_SERVER' in os.environ:
domain_url='http://192.168.43.150:5000'
# domain_url='http://192.168.1.39:5000'
else:
domain_url='http://kheitmann.webfactional.com'
self.ws = WebServer(domain_url, verbose)
self.informe_actual = ""
self.store = JsonStore('base_de_datos.json')
if self.store.exists('session'):
session = self.store.get('session')
if session['auth_token'] is None:
print("No hay login")
self.screen_manager.add_widget(Login(name="login"))
self.screen_manager.add_widget(Grupos(name="grupos"))
else:
print("Si hay login")
self.ws.set_auth_token(session['auth_token'])
self.screen_manager.add_widget(Grupos(name="grupos"))
self.screen_manager.add_widget(Login(name="login"))
else:
print("no hay")
self.store.put('session', auth_token=None)
self.screen_manager.add_widget(Login(name="login"))
self.screen_manager.add_widget(Grupos(name="grupos"))
agregar_screens(self.screen_manager)
return self.screen_manager
def createWebServer(self):
server = WebServer(self)
self.m_servers.append(server)
# :TODO:
# page.applySettings(self.m_defaultPageSettings)
# page.libraryPath = os.path.dirname(os.path.abspath(self.m_scriptFile)
return server
def main():
print(open("banner").read())
print("")
gyro = GyroMon()
user = UserMon()
serial_send = SerialSend(user, gyro)
gyro.start()
#user.start()
serial_send.start()
raw_input("Press any key to start sending real data\n")
serial_send.start_real()
dirname = os.getcwd()
cherrypy.log.screen = None
cherrypy.quickstart(
WebServer(user, gyro, serial_send), '/', {
'global': {
'server.socket_host': '0.0.0.0',
'server.socket_port': 8080
},
'/remote.html': {
'tools.staticfile.on':
True,
'tools.staticfile.filename':
os.path.join(dirname, 'remote/remote.html')
}
})
def build(self):
self.screen_manager = ScreenManager()
import os
if 'MANTENCIONES_VERBOSE' in os.environ:
verbose=1
else:
verbose=0
if 'DEVELOPMENT_SERVER' in os.environ:
# domain_url='http://192.168.43.150:5000'
domain_url='http://192.168.1.39:5000'
else:
domain_url='http://kheitmann.webfactional.com'
from webserver import WebServer
from kivy.storage.jsonstore import JsonStore
self.ws = WebServer(domain_url, verbose)
self.store = JsonStore('base_de_datos.json')
if self.store.exists('session'):
session = self.store.get('session')
if session['auth_token'] is None:
print("AUTH TOKEN ES NONE")
return None
else:
self.ws.set_auth_token(session['auth_token'])
else:
print("NO HAY BASE DE DATOS")
return None
self.screen_manager.add_widget(Grupo(name='grupo'))
self.screen_manager.add_widget(Informe(name='informe'))
return self.screen_manager
def __init__(self):
"""Initie les caractéristiques du socket.
Auteur : Nathan
"""
self.host = input("Host ? (si vide sera localshost)\n : ")
if self.host == "":
self.host = "localhost"
self.port = 9876
self.max_size = 2048
self.client = None
self.encours = True
self.attente = False
self.etat = "None"
i = input("Voulez vous que ce soit un client websocket ?\n(par défaut = non)\n : ")
if i.lower() in ["o", "oui", "y", "yes"]:
self.ws = True
from webserver import WebServer
self.webserver = WebServer(self)
else:
self.ws = False
self.genres = ["homme", "femme", "agenre", "androgyne", "bigender",
"non-binaire", "autre"]
self.debug = False
def __init__(self, test_mode: bool) -> None:
super().__init__()
self.test_mode = test_mode
handlers = [(r'/socket', RocketSocket, dict(server=self))]
self.webserver = WebServer(port=8080, handlers=handlers)
self.source: Inputs = InputTest() if test_mode else InputSerial()
self.recorders: List[Recorder] = [LogRecorder(), CSVRecorder()]
def addWorker(self, color, radius, script, interval, title):
if (title == "auto"):
title = str(self.id)
self.id += 1
newws = WebServer(color, radius, self, script, interval, title)
newws.start()
self.threadList.append(newws)
def main():
relay_controller = RelayController(vendor_id=VENDOR_ID,
product_id=PRODUCT_ID,
activation_time=ACTIVATION_TIME)
web_server = WebServer(host=HOST,
port=PORT,
relay_controller=relay_controller)
web_server.start()
def setup(self):
self.logger.info("--------------------------------------")
self.logger.info(" Balloon Mission Computer V4.01 ")
self.logger.info("--------------------------------------")
self.logger.debug("setup")
# setup
with open('data/config.json') as fin:
self.config = json.load(fin)
self.images_dir = self.config["directories"][
"images"] if "directories" in self.config and "images" in self.config[
"directories"] else "./images"
self.tmp_dir = self.config["directories"][
"tmp"] if "directories" in self.config and "tmp" in self.config[
"directories"] else "./tmp"
if not os.path.exists(self.tmp_dir):
os.makedirs(self.tmp_dir)
if not os.path.exists(self.images_dir):
os.makedirs(self.images_dir)
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM) # Broadcom pin-numbering scheme
GPIO.setup(self.config['pins']['BUZZER'], GPIO.OUT)
GPIO.setup(self.config['pins']['LED1'], GPIO.OUT)
GPIO.setup(self.config['pins']['LED2'], GPIO.OUT)
GPIO.output(self.config['pins']['LED1'], GPIO.HIGH)
self.aprs = APRS(self.config['callsign'], self.config['ssid'],
"idoroseman.com")
self.modem = AFSK()
self.gps = Ublox()
self.gps.start()
self.radio = Dorji(self.config['pins'])
self.radio.init()
self.radio_q = queue.Queue()
self.radio_thread = threading.Thread(target=self.radio_worker)
self.radio_thread.start()
self.timers = Timers(self.config['timers'])
self.sensors = Sensors()
self.cam = Camera()
self.ssdv = SSDV(self.config['callsign'], self.config['ssid'])
self.sstv = SSTV()
self.webserver = WebServer()
self.radio_queue(self.config['frequencies']['APRS'],
'data/boatswain_whistle.wav')
for item in ["APRS", "APRS-META", "Imaging", 'Capture']:
self.timers.handle({item: self.config['timers'][item] > 0}, [])
self.timers.handle({"Buzzer": False}, [])
self.ledState = 1
self.imaging_counter = 1
self.state = "init"
self.min_alt = sys.maxsize
self.max_alt = 0
self.prev_alt = 0
self.send_bulltin()
GPIO.output(self.config['pins']['LED1'], GPIO.LOW)
def start(self):
log.startLogging(sys.stdout)
self.weather = WeatherLogger(self.config.settings)
self.display = DisplayManager(self.config.settings)
self.sensors = SensorMonitor(self.config.settings)
self.server = WebServer(self.config.settings)
lc = LoopingCall(self.process_event)
lc.start(0.25)
reactor.run()
def setUp(self):
self.w = Wallet()
self.blocks = BlockStorage()
self.driver = ContractDriver()
self.ws = WebServer(wallet=self.w,
contracting_client=ContractingClient(),
blocks=self.blocks,
driver=n)
self.ws.client.flush()
self.ws.blocks.drop_collections()
def __init__(self,
token_path=None,
client_creds=None,
scope=None,
**kwargs):
"""
Initialize Oauth object.
The client (the app that is requesting access to the user (user=resource owner) resources on behalf of user.
Optional args:
token_path - the path to where the user's access/refresh tokens will be stored.
- client_creds - this is a convenience that allows the caller to pass a dict that contains the client_id and client_secret as, or as a string that is the path to a file that contains the client credentials in json format.
EG:
# pass a dict:
oauth = Oauth('/home/user/.user.creds', client_creds=creds_dict)
or
# pass a str that's a path to a json file:
oauth = Oauth('/home/user/.user.creds', client_creds='/home/Downloads/creds_dict')
The client credentials will then be handled by this module.
TODO:
- chmod 600 token_path
- define ONE oauth2.0 server in __init__(), because as far as I can tell, there is only one oauth server...
"""
if token_path:
self.token_path = token_path
else:
self.token_path = os.path.expanduser(
'~/.contacts_address_resolution')
self.webserver = WebServer()
# Test if a path to the json file that contains the client_id and secret has been passed to init, else, the client params should be passed as key:value pairs to kwargs, which will then be returned as a dict. kwargs.keys() will be tested to ensure that the right values have been passed or an exception will be raised.
if client_creds:
if isinstance(client_creds, dict):
self.client_creds = ClientCredentials(scope=scope,
**client_creds)
if isinstance(client_creds, str):
self.client_creds = ClientCredentials(scope=scope,
client_file=client_creds)
elif 'client_id' in kwargs and 'client_secret' in kwargs:
self.client_creds = ClientCredentials(scope=scope, **kwargs)
else:
raise Exception("The client id and secret need to be provided.")
def __init__(self):
"""Begin the app."""
web_dir = os.path.join(os.path.dirname(__file__), 'html')
os.chdir(web_dir)
print('CWD:', web_dir)
self.totp = TOTP('supersecretkey32') # Key unique to each user.
self.fr = FaceRecognition()
self.fr.set_request_unlock(request_unlock)
self.server = WebServer(port=8080, ws_port=8081)
self.server.set_begin_registration(self.begin_registration)
self.server.set_verify_code(self.verify_code)
self.requestedUnlock = False
print('Hello world!')
self.fr.start_recognition()
def init():
WLAN(mode=WLAN.AP, ssid='Panel Meter Clock', auth=(None))
# setup the PWM channels
App.pwmHours = PWM(0, frequency=5000)
App.pwmMinutes = PWM(1, frequency=5000)
App.pwmSeconds = PWM(2, frequency=5000)
App.pwmChHours = App.pwmHours.channel(0,
pin=HOURS_PANEL_METER_PIN,
duty_cycle=0)
App.pwmChMinutes = App.pwmMinutes.channel(1,
pin=MINUTES_PANEL_METER_PIN,
duty_cycle=0)
App.pwmChSeconds = App.pwmSeconds.channel(2,
pin=SECONDS_PANEL_METER_PIN,
duty_cycle=0)
# push button callback (active HIGH)
App.pushButton = Pin(PUSH_BUTTON_PIN, Pin.IN)
set_pin_callback(App.pushButton, push_button_callback)
# rotary encoder callback
App.encoderASignal = Pin(ROTARY_ENCODER_A_SIGNAL_PIN,
Pin.IN,
pull=Pin.PULL_UP)
set_pin_callback(App.encoderASignal, encoder_a_callback)
App.encoderBSignal = Pin(ROTARY_ENCODER_B_SIGNAL_PIN,
Pin.IN,
pull=Pin.PULL_UP)
set_pin_callback(App.encoderBSignal, encoder_b_callback)
# initialize the Real Time Clock to the date/time this project was started
App.rtc.init((2017, 11, 24, 3, 22, 0, 0, 0))
# create and start the webServer
App.webServer = WebServer(80, 'index.htm', webserver_request_callback,
True)
App.webServer.start()
import gc, core from webserver import WebServer gc.collect() core.do_connect() ws = WebServer() ws.start()
"server-network",
resource_group_name=resource_group.name,
location=resource_group.location,
address_spaces=["10.0.0.0/16"],
subnets=[
network.VirtualNetworkSubnetArgs(name="default",
address_prefix="10.0.1.0/24")
],
opts=ResourceOptions(parent=resource_group),
)
subnet = network.Subnet(
"server-subnet",
resource_group_name=resource_group.name,
virtual_network_name=net.name,
address_prefixes=["10.0.2.0/24"],
opts=ResourceOptions(parent=net),
)
web_server = WebServer(
"server",
WebServerArgs(
resource_group=resource_group,
subnet=subnet,
username=username,
password=password,
),
)
pulumi.export("public_ip", web_server.public_ip_addr)
logger.setLevel(logging.DEBUG)
formatter = '%(asctime)s %(module)s(%(lineno)s):%(funcName)s [%(levelname)s]: %(message)s'
streamhandler = logging.StreamHandler()
streamhandler.setFormatter(logging.Formatter(formatter, datefmt='%H:%M:%S'))
streamhandler.setLevel(logging.DEBUG)
logger.addHandler(streamhandler)
logger.debug('Session start')
mpqueue = MPQueue() # queue for multiprocessing
threadqueue = ThreadQueue() # queue for threading
aqueue = MPQueue() # for archiver
ws = WSServer(port=Constants.wsport)
ws.start()
wd = WebServer(name='Flask')
wd.start()
serialReceiver: Dict[str, dict] = {
'sGPS': {
'port': '/dev/ttyACM0',
'baud': 9600,
},
'sAIS': {
'port': '/dev/ttyUSB0',
'baud': 38400,
},
}
for k, v in serialReceiver.items():
receiver = Receiver(port=v['port'], baud=v['baud'], mailpost=mpqueue, name=k)
if receiver.ready:
# -*- coding: utf-8 -*-
from time import sleep
from webserver import WebServer
class mydataclass(object):
def __init__(self):
self.param1 = 0
self.param2 = 0
#MAIN LOOP
try:
mydata = mydataclass()
myWebServer = WebServer(mydata)
myWebServer.start()
cycling = True
while cycling:
#In the mail loop , do something, for example increment param2
#and do some verificationon param1
mydata.param2 += 1
sleep(1)
if mydata.param1 < 0:
print 'param1 is negative...'
if mydata.param1 == 5:
#parameter param1 is incremented by the user on the browser
cycling = False
myWebServer.stop()
def do_activate(self):
self.server = WebServer(self.object, os.path.dirname(os.path.realpath(__file__)))
self.server.start()
config_AP_PASSWORD = '******'
config_AP_CHANNEL = 7
config_AP_ON_TIME_SEC = 600
config_FTP_USER = '******'
config_FTP_PASSWORD = '******'
config_WEB_USER = '******'
config_WEB_PASSWORD = '******'
config_ERROR = True
if config_AP_ON_TIME_SEC < 120:
config_AP_ON_TIME_SEC = 120
_ftp = Server()
_ftp.deinit()
_web = WebServer(config_WEB_USER, config_WEB_PASSWORD)
if not config_ERROR and (len(config.MB_TCP_IP) > 0):
_wdt = machine.WDT(timeout=20000)
_status_ap_enabled_once = False
_status_mb_got_request = False
_modbus = ModbusTCP()
print('ModbusTCP created')
_modbus_process = _modbus_tcp_process
pycom.heartbeat(False)
pycom.rgbled(0x00ff00)
#_modbus_process()
from timeit import default_timer as timer
from pydispatch import dispatcher
from webserver import WebServer
import subprocess
import time
import random
import math
Web_Server = WebServer() # Webserver running on BBB for an HTML interface
try:
import Adafruit_BBIO.GPIO as GPIO
import Adafruit_BBIO.PWM as PWM
except:
print "Could not import GPIO library!"
# Hardware Pin defines
# ---------------------------------------
Solenoid1_Pin = "P9_23"
Solenoid2_Pin = "P9_24"
StepperPin0 = "P9_11"
StepperPin1 = "P9_13"
StepperPin2 = "P9_15"
StepperPin3 = "P9_27"
pin_list = [StepperPin0, StepperPin1, StepperPin2, StepperPin3]
# all leds are setup on pwm pins, although not necessary since not all need to fade
LED_Brain_Activity_Pin = "P9_14"
LED_Eye1_Pin = "P9_21"
LED_Eye2_Pin = "P8_13"
from webserver import WebServer
from camera import Camera
from controller import Controller
if __name__ == '__main__':
print('Starting camera')
camera = None
print('Starting controller')
controller = Controller(camera=camera, offset=7)
print('Starting Web Server')
server = WebServer(camera=camera, controller=controller, log_output=True)
# Module name : main.py
# created by alvifsandanamahardika at 6/10/21
import signal
import sys
from webserver import WebServer
def shutdownServer(sig, unused):
"""
Shutdown server from a SIGINT received signal
:param sig: integer
"""
server.shutdown()
sys.exit(1)
if __name__ == '__main__':
signal.signal(signal.SIGINT, shutdownServer)
server = WebServer(8000)
server.start()
print("Press Ctrl+C to shut down server.")
def setup(self):
self.logger.info("--------------------------------------")
self.logger.info(" Balloon Mission Computer V4.01 ")
self.logger.info("--------------------------------------")
self.logger.debug("setup")
# setup files and directories
with open('data/config.json') as fin:
self.config = json.load(fin)
self.images_dir = self.config["directories"][
"images"] if "directories" in self.config and "images" in self.config[
"directories"] else "./images"
self.tmp_dir = self.config["directories"][
"tmp"] if "directories" in self.config and "tmp" in self.config[
"directories"] else "./tmp"
if not os.path.exists(self.tmp_dir):
os.makedirs(self.tmp_dir)
if not os.path.exists(self.images_dir):
os.makedirs(self.images_dir)
# setup gpio
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM) # Broadcom pin-numbering scheme
GPIO.setup(self.config['pins']['BUZZER'], GPIO.OUT)
GPIO.setup(self.config['pins']['LED1'], GPIO.OUT)
GPIO.setup(self.config['pins']['LED2'], GPIO.OUT)
GPIO.output(self.config['pins']['LED1'], GPIO.HIGH)
# modules
self.aprs = APRS(self.config['callsign'], self.config['ssid'],
"idoroseman.com")
self.modem = AFSK()
try:
self.gps = Ublox()
self.gps.start()
except:
pass
self.radio = Dorji(self.config['pins'])
self.radio.init()
self.radio_q = queue.Queue()
self.radio_thread = threading.Thread(target=self.radio_worker)
self.radio_thread.start()
self.timers = Timers(self.config['timers'])
self.sensors = Sensors()
self.cam = Camera()
self.ssdv = SSDV(self.config['callsign'], self.config['ssid'])
self.sstv = SSTV()
self.webserver = WebServer()
self.radio_queue(self.config['frequencies']['APRS'],
'data/boatswain_whistle.wav')
self.syslog = logging.getLogger()
kh = MyLogHandler()
kh._listeners.append(self.handle_log)
kh.setLevel(logging.DEBUG)
formatter2 = logging.Formatter('%(levelname)s: %(name)s - %(message)s')
kh.setFormatter(formatter2)
self.syslog.addHandler(kh)
# timers
for item in ["APRS", "APRS-META", "Imaging", 'Capture']:
self.timers.set_state(item, self.config['timers'][item] > 0)
self.timers.set_state("Buzzer", False)
# lets go
self.ledState = 1
self.imaging_counter = 1
self.state = "init"
self.min_alt = sys.maxsize
self.max_alt = 0
self.prev_alt = 0
self.send_bulltin()
GPIO.output(self.config['pins']['LED1'], GPIO.LOW)
def recv(self, message, ref):
action = message.get('action', None)
if action == 'config':
if self.manager.isrunning:
self.debug("Reconfiguration process: Shutting down Manager",
color='cyan')
self.manager.shutdown()
# Initialize manager
self.debug("Starting up manager", color='blue')
self.manager.attach(
WebServer(uuid.uuid4(), 'Local Webserver', self.__commit))
watchdog_uuid = uuid.uuid4()
self.manager.attach(Watchdog(watchdog_uuid, 'Watchdog', self))
self.manager.set_watchdog(watchdog_uuid)
# Get commit ID
commit = message.get('commit', None)
if commit:
if self.__force_version:
self.debug("Using static version: {}".format(
self.__force_version),
color="cyan")
else:
# Set new commit
self.debug("Setting COMMIT to: {}".format(commit),
color="cyan")
with open("commit.dat", "w") as F:
F.write(commit)
# Pull changes
cmd = "git show --format='%H' --no-patch" # Long HASH
status, output = getstatusoutput(cmd)
if status:
lastcommit = output
else:
lastcommit = None
if commit != lastcommit:
status, output = getstatusoutput("git fetch origin")
if status:
self.error(
"Couldn't fetch changes from REPOSITORY, I won't try any MERGE!"
)
else:
if commit == 'LATEST':
extraarg = ''
else:
extraarg = ' ' + commit
status, output = getstatusoutput(
"git merge{}".format(extraarg))
if status:
self.error("Couldn't merge changes!")
else:
# Delete commit.dat
self.warning("This client is not linked to GITHUB")
if os.path.exists("commit.dat"):
os.unlink("commit.dat")
# Configure hardware
self.debug("Setting configuration", color='blue')
error = False
for hw in message.get('hardware', []):
# Get details
uuidtxt = hw.get('uuid', None)
kind = hw.get('kind', '')
config = hw.get('config', {})
if uuidtxt is not None:
uid = uuid.UUID(uuidtxt)
if not self.manager.exists_worker(uid):
self.debug(" > Configuring ",
color='yellow',
tail=False)
self.debug(str(uid),
color='purple',
head=False,
tail=False)
self.debug(" as ",
color='yellow',
head=False,
tail=False)
if kind in self.AVAILABLE_HARDWARE:
self.debug(kind, color='white', head=False)
try:
self.manager.attach(
self.AVAILABLE_HARDWARE.get(kind)(uid,
config))
except HardwareError as e:
self.send_error(
"Device {} as {} is wrong configured: {}".
format(uid, kind, e), ref, uid)
error = True
else:
self.debug(
"{}??? - Not setting it up!".format(kind),
color='red',
head=False)
else:
self.error(
" > I found a hardware configuration without UUID, I will not set it up!"
)
# Make sure all tasks in manager are running
self.manager.run(self)
# If some error during startup
if error:
self.error(
"I have detected some error, I will try to reconfigure system when next message arrives!"
)
else:
# No error happened, we are ready to go
self.debug("Everything is set up and ready to work",
color='green')
self.__fully_configured = True
elif action == 'reset':
self.warning("Got Reset request from Server")
self.close(reason='Reset requested from Server')
elif action == 'msg':
msg = message.get('message', None)
uid = message.get('uuid', None)
if msg and uid:
error = self.manager.recv(msg, ref, uid)
if error:
self.send_error(error, ref)
elif msg:
self.send_error("No destination added to your message", ref)
elif uuid:
self.send_error("Got message for '{}' with no content", ref)
else:
self.send_error(
"Missing message and destination for your message", ref)
elif action == 'error':
self.error("Got an error from server: {}".format(
message.get('error', 'No error')))
elif action == 'ping':
subref = message.get('ref', '-')
self.debug("Sending PONG {} (ref:{})".format(subref, ref))
self.send({'action': 'pong'}, ref)
elif action != 'config':
self.send_error("Unknown action '{}'".format(action), ref)
if action != 'config' and not self.__fully_configured:
self.debug("Reconfigure system", color='yellow')
self.send({'action': 'get_config'}, ref)
import argparse
import config
from webserver import WebServer
from handler import Handler
from config_reader import ConfigReader
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='server')
parser.add_argument('-r', type=str, help='root directory')
parser.add_argument('-c', type=int, help='CPU count')
parser.add_argument('-H', type=int, help='host')
parser.add_argument('-p', type=str, help='port')
args = vars(parser.parse_args())
config_file = ConfigReader(config.config_path)
cpu_count = args['c'] or config_file.cpu_limit or config.CPU_COUNT
root_dir = args['r'] or config_file.document_root or config.ROOT_DIR
host = args['H'] or config_file.host or config.HOST
port = args['p'] or config_file.listen or config.PORT
address = (config.HOST, config.PORT)
handler = Handler(root_dir)
server = WebServer(cpu_count, address, config.LISTENERS, config.BUFFER,
handler)
server.start()
cwd=os.path.join(current_dir, 'frontend'),
shell=True).wait()
if code != 0:
print('An error occurred while building!')
quit(code)
if os.path.join(current_dir, 'frontend', 'dist') != webserver_static_path:
shutil.rmtree(webserver_static_path)
shutil.copytree(os.path.join(current_dir, 'frontend', 'dist'),
webserver_static_path)
web = WebServer(
oauth2_client_id=global_settings['APPLICATION_ID'],
oauth2_client_secret=global_settings['APPLICATION_SECRET'],
oauth2_redirect_uri=global_settings['OAUTH2_REDIRECT_URI'],
webserver_secret=global_settings['WEBSERVER_SECRET'],
discord_bot=bot,
static_path=webserver_static_path,
debug=global_settings['WEBSERVER_DEBUG'],
)
app = web.app
if __name__ == '__main__':
kwargs = {}
try:
port_index = sys.argv[1:].index('--port')
kwargs['port'] = sys.argv[1:][port_index + 1]
except ValueError:
pass
try:
def create_server(host='127.0.0.1', port=5000):
return WebServer((host, port), handlers)
import util
from webserver import WebServer
from mqttclient import MqttClient
from state import State
try:
import usocket as socket
except ModuleNotFoundError:
import socket
state = State()
# Configuration
state.save_value(key='id', value=1)
state.save_value(key='type', value='temperature')
webserver = WebServer()
#webserver.start()
webThread = _thread.start_new_thread(webserver.start, ())
type = state.get_value('type')
if type == 'temperature':
sensor = sensor.TemperatureSensor()
elif type == 'power':
sensor = sensor.PowerSensor()
elif type == 'ambient':
sensor = sensor.AmbientSensor()
webserver.router.set_sensor(sensor)
mqttClient = MqttClient(sensor=sensor)