def SVPSolver( basis, isLLLReduced = False ):
n = len(basis)
if not isLLLReduced:
curBasis, curCoeff = LLL.LLL( basis )
curGSBasis = GSO.gramSchmidtOrthogonalization( curBasis )[0]
utils.printInfo( 'Post LLL Orthogonality Defect: ', GSO.orthogonalityDefect( curBasis ) )
else:
curBasis = basis
curGSBasis, curCoeff = GSO.gramSchmidtOrthogonalization( curBasis )
# if not LLL.isLLLReduced(curBasis):
# print( 'Error - SVP solver was given a bad basis' )
R, shortestBasisVec = op.minNorm( curBasis )
# utils.printInfo( 'Current shortest vector', '' )
# utils.printVectorWithNorm( shortestBasisVec )
lambda1, vec, combination = enumerate( curBasis, curGSBasis, curCoeff, n, n-1, [], R, shortestBasisVec, 0, [0]*n )
# if abs( R - lambda1 ) > BKZ_constants.eps:
# print( 'Enumeration found a shorter vector of length ' + str(lambda1) )
#
# else:
# print( 'LLL found the shortest vector' )
return lambda1, vec, curBasis, curGSBasis, curCoeff, combination
def __init__(self, pin):
utils.printInfo('TEMPERATURE', 'init')
self.dallas = ds18x20.DS18X20(onewire.OneWire(pin))
self.externalTemperatures = {}
self._updateTimer = utils.timer()
self._uploadTimer = utils.timer()
self.update()
self._updateTimer.init(period=_UPDATE_INTERVAL_MS, mode=machine.Timer.PERIODIC, callback=lambda t: self.update())
self._uploadTimer.init(period=_UPLOAD_INTERVAL_MS, mode=machine.Timer.PERIODIC, callback=lambda t: self.upload())
def fit(self, x, y, num_threads=2,verbose=False,holdout_percent=0.01):
assert len(x) == len(y), "Bags and intervals have different lengths"
for i in range(len(y)):
conf_inter = float(y[i])
assert conf_inter >= 0.0 and conf_inter <= 1.0, \
"Bad CI '%s' at index [%s]" % (conf_inter, i)
y[i] = conf_inter
if verbose:
utils.printInfo("Calculating class probabilities")
num_datapoints = len(x)
indices = range(num_datapoints)
random.shuffle(indices)
num_holdout = int(num_datapoints * holdout_percent)
train_indices = indices[num_holdout:]
holdout_indices = indices[:num_holdout]
x = np.array(x)
y = np.array(y)
x_train = x[train_indices]
x_holdout = x[holdout_indices]
y_train = map(np.float,y[train_indices])
y_holdout = map(np.float,y[holdout_indices])
# Calculate priori class probabilities
total_freq = float(len(x_train))
inclass_freq = sum(y_train)
outclass_freq = total_freq - inclass_freq
self.class_freqs[self.inclass] = inclass_freq
self.class_freqs[self.outclass] = outclass_freq
self.class_priori[self.inclass] = inclass_freq / total_freq
self.class_priori[self.outclass] = outclass_freq / total_freq
if verbose:
utils.printInfo("Generating word frequency tuples")
for i in range(len(x_train)):
inclass_freq = y_train[i]
outclass_freq = 1.0 - inclass_freq
for word in set(x_train[i]):
try:
self.word_freqs[word][0] += inclass_freq
self.word_freqs[word][1] += outclass_freq
except KeyError:
self.word_freqs[word] = [inclass_freq,outclass_freq]
"""
Train internal classifier
"""
self.internal_classifier.fit(self._genLogProbs(x_holdout),y_holdout)
def run(self):
utils.printInfo('SERVER', ('listening on port %s' % self.port))
addr = usocket.getaddrinfo('0.0.0.0', self.port)[0][-1]
socket = usocket.socket()
socket.bind(addr)
socket.listen(1)
while True:
cl, addr = socket.accept()
cl.settimeout(2.5)
self.process(cl, addr)
def __init__(self, temperature_sensor, relay_pin, switch_pin, led_pin):
utils.printInfo('THERMOSTAT', 'init')
self._temperature_sensor = temperature_sensor
self._relay_pin = relay_pin
self._led_pin = led_pin
self._config = utils.readJson(_CONFIG_FILE) or self._default_config()
self._update()
self._timer = utils.timer()
self._timer.init(period=_UPDATE_INTERVAL_MS,
mode=machine.Timer.PERIODIC,
callback=lambda t: self._update())
switch_pin.irq(trigger=machine.Pin.IRQ_FALLING
| machine.Pin.IRQ_RISING,
handler=lambda p: self._switch_clicked(p))
utils.printInfo('THERMOSTAT', 'config:\n%s' % (self._config))
def __init__(self, i2c, addresses, width, height):
utils.printInfo('SEGMENTAL', 'init display on 0x%02X address' % addresses)
utils.printInfo('SEGMENTAL', 'size %02dx%02d' %(width, height))
self._width = width
self._height = height
self._lcd = lcd_i2c.LcdI2C(i2c, addresses)
self._initialMessage = 'Hello World!'
self._ip = '0.0.0.0'
self._uptime = (0, 0, 0, 0)
self._time = (0, 0, 0, 0, 0, 0)
self._freeMemory = 0
self._wifiIsConnected = False
self._temperatures = []
self._phase = 0
self._lastLine = 0
def __init__(self, i2c, temperatureSensor, initialMessage):
utils.printInfo('DISPLAY', 'init')
self._displays = []
self._wlan = network.WLAN(network.STA_IF)
self._temperatureSensor = temperatureSensor
for address in i2c.scan():
if address == 0x23:
self._displays.append(segmental_display.SegmentalDisplay(i2c, address, 20, 4))
else:
self._displays.append(segmental_display.SegmentalDisplay(i2c, address, 16, 2))
(ip, _, _, _) = network.WLAN(network.STA_IF).ifconfig()
for display in self._displays:
display.setInitialMessage(initialMessage)
display.setIp(ip)
display.showInitialMessage()
self._updateTimer = utils.timer()
self._updateTimer.init(period=_UPDATE_INTERVAL_MS, mode=machine.Timer.PERIODIC, callback=lambda t: self.update())
import config
import machine
import server
import status_server_controller
import temperature_sensor
import thermostat_server_controller
import utils
utils.printInfo("THERMOSTAT", "boot up")
utils.createSyncDateTimeTimer()
_temperature_sensor = temperature_sensor.TemperatureSensor(machine.Pin(config.DS18B20_PIN))
_relay_pin = machine.Pin(config.THERMOSTAT_RELAY_PIN, machine.Pin.OUT)
_switch_pin = machine.Pin(config.THERMOSTAT_SWITCH_PIN, machine.Pin.IN)
_led_pin = machine.Pin(config.THERMOSTAT_LED_PIN, machine.Pin.OUT)
_thermostat_server_controller = thermostat_server_controller.ThermostatServerController(_temperature_sensor, _relay_pin, _switch_pin, _led_pin)
_controllers = [_thermostat_server_controller]
_statusController = status_server_controller.StatusServerController('Thermostat', _controllers)
_server = server.Server(config.SERVER_PORT, _controllers + [_statusController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("THERMOSTAT", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("THERMOSTAT", "exception during server run: %s" % e)
machine.reboot()
import config
import temperature_sensor
import display
import machine
import server
import status_server_controller
import utils
utils.printInfo("THERMOMETER", "boot up")
utils.createSyncDateTimeTimer()
_i2c = machine.I2C(scl=machine.Pin(config.I2C_SCL_PIN),
sda=machine.Pin(config.I2C_SDA_PIN),
freq=400000)
_temperature_sensor = temperature_sensor.TemperatureSensor(
machine.Pin(config.DS18B20_PIN))
_display = display.Display(_i2c, _temperature_sensor, 'Thermometer')
_statusController = status_server_controller.StatusServerController(
'Thermometer', [])
_server = server.Server(config.SERVER_PORT, [_statusController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("THERMOMETER", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("THERMOMETER", "exception during server run: %s" % e)
machine.reboot()
import animator_server_controller
import config
import machine
import server
import status_server_controller
import utils
utils.printInfo("ANIMATOR", "boot up")
utils.createSyncDateTimeTimer()
animatorServerController = animator_server_controller.AnimatorServerController(
machine.Pin(config.ANIMATOR_PIN, machine.Pin.OUT))
statusController = status_server_controller.StatusServerController(
'Animator', [animatorServerController])
_server = server.Server(config.SERVER_PORT,
[statusController, animatorServerController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("ANIMATOR", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("ANIMATOR", "exception during server run: %s" % e)
machine.reboot()
def __init__(self, deviceType, controllers):
utils.printInfo('STATUS', 'init')
self.wlan = network.WLAN()
self.controllers = controllers
self.adc = machine.ADC(1)
self.deviceType = deviceType
import config
import temperature_sensor
import machine
import pin_scheduler
import server
import status_server_controller
import utils
utils.printInfo("PIN_SCHEDULER", "boot up")
_temperature_sensor = temperature_sensor.TemperatureSensor(machine.Pin(config.DS18B20_PIN))
pinScheduler = pin_scheduler.PinScheduler(machine.Pin(config.SCHEDULER_PIN, machine.Pin.OUT), [((19, 0, 0), 36)])
statusController = status_server_controller.StatusServerController('Pin Scheduler', [])
_server = server.Server(config.SERVER_PORT, [statusController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("PIN_SCHEDULER", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("PIN_SCHEDULER", "exception during server run: %s" % e)
machine.reboot()
def timeout100ms(timer):
utils.printInfo("RADAR", distanceSensor.read())
import config
import machine
import utils
import vl53l0x
utils.printInfo("NODEMCU", "radar boot up")
i2c = machine.I2C(scl=machine.Pin(config.I2C_SCL_PIN),
sda=machine.Pin(config.I2C_SDA_PIN),
freq=400000)
distanceSensor = vl53l0x.VL53L0X(i2c, 0x29)
def timeout100ms(timer):
utils.printInfo("RADAR", distanceSensor.read())
tim1 = utils.timer()
tim1.init(period=100, mode=machine.Timer.PERIODIC, callback=timeout100ms)
import config
import machine
import temperature_sensor
import utils
utils.printInfo("NODEMCU", "thermometer low power boot up")
_temperature_sensor = temperature_sensor.TemperatureSensor(
machine.Pin(config.DS18B20_PIN))
_temperature_sensor.update()
_temperature_sensor.upload()
rtc = machine.RTC()
rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
rtc.alarm(rtc.ALARM0, 60000)
machine.deepsleep()
import config
import esp
import machine
import utils
import ubinascii
utils.printInfo('ANIMATOR', 'fast set leds')
_config = utils.readJson('animator.data')
if _config and _config['powered_on'] and _config['use_color']:
pin = machine.Pin(config.ANIMATOR_PIN, machine.Pin.OUT)
bytes = ubinascii.unhexlify(_config['color'])
color = [bytes[1], bytes[0], bytes[2]]
esp.neopixel_write(pin, bytearray(color * _config['leds']), 1)
utils.printInfo('ANIMATOR', 'finish')
import config
import machine
import pin_server_controller
import server
import status_server_controller
import temperature_sensor
import utils
utils.printInfo("REMOTE_SOCKET", "boot up")
utils.createSyncDateTimeTimer()
_temperature_sensor = temperature_sensor.TemperatureSensor(machine.Pin(config.DS18B20_PIN))
pinServerController = pin_server_controller.PinServerController(config.REMOTE_SOCKET_PINS)
controllers = [pinServerController]
statusController = status_server_controller.StatusServerController('Remote Socket', controllers)
_server = server.Server(config.SERVER_PORT, controllers + [statusController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("REMOTE_SOCKET", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("REMOTE_SOCKET", "exception during server run: %s" % e)
machine.reboot()
def __init__(self, port, controllers):
utils.printInfo('SERVER', 'init')
self.port = port
self.controllers = controllers
import config
import machine
import server
import sonoff_server_controller
import status_server_controller
import utils
utils.printInfo("SONOFF", "boot up")
utils.createSyncDateTimeTimer()
relayPin1 = machine.Pin(config.SONOFF_RELAY1_PIN, machine.Pin.OUT)
switchPin1 = machine.Pin(config.SONOFF_SWITCH1_PIN, machine.Pin.IN)
relayPin2 = machine.Pin(config.SONOFF_RELAY2_PIN, machine.Pin.OUT)
switchPin2 = machine.Pin(config.SONOFF_SWITCH2_PIN, machine.Pin.IN)
switch1 = (relayPin1, None, switchPin1)
switch2 = (relayPin2, None, switchPin2)
statusPin = machine.Pin(config.SONOFF_STATUS_PIN, machine.Pin.OUT)
sonoffServerController = sonoff_server_controller.SonoffServerController(
[switch1, switch2], statusPin)
controllers = [sonoffServerController]
statusController = status_server_controller.StatusServerController(
'Sonoff', controllers)
_server = server.Server(config.SERVER_PORT, controllers + [statusController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("SONOFF", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("SONOFF", "exception during server run: %s" % e)
machine.reboot()