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