def poll(self):
try:
value = self.touchpin.read()
except ValueError:
logger.error('Failed reading touchpin')
return
weighted_value = sum(self.readings[-2:] + [value]) / 3
mean = self.get_current_mean()
thresh = mean * self.threshold
ratio = weighted_value / mean
#logger.debug(
# '[{}] Mean: {:04.0f}, Threshold: {:04.0f}, This: {:04.0f}, This weighted: {:04.0f} / {:.0%}'
# .format(utime.ticks_ms(), mean, thresh, value, weighted_value, ratio)
#)
# logger.debug('{} {} {}'.format(mean, weighted_value, int(ratio*100)))
if weighted_value < thresh:
now = utime.ticks_ms()
if (utime.ticks_diff(now, self.callback_triggered_last) <
self.debounce_ms):
logger.info('Debounced')
# Make reading affect mean less - this allows for slow recalibration
#value += (thresh - value)*0.9
else:
self.callback()
self.callback_triggered_last = now
self.readings.pop(0)
self.readings.append(weighted_value)
def check_mqtt():
if not wifi_connected():
# print('Wifi not connected, skipping MQTT check')
return
try:
mqtt_client.check_msg()
except (OSError, AttributeError):
logger.error('Failed checking MQTT')
def setup_mqtt():
logger.info('Connecting to MQTT...')
mqtt_client.set_callback(mqtt_callback)
try:
mqtt_client.connect()
mqtt_client.subscribe(config.MQTT_SET_TOPIC)
mqtt_client.subscribe(config.MQTT_DEBUG_TOPIC)
publish_state(str(fcycle.index))
logger.info('Connected to MQTT and subscribed.')
except OSError:
logger.error('Failed setting up MQTT.')
def record(self, entry):
"""Records an entry in the history."""
self.entries.append(entry)
message = '[{}] {} {} ({})'.format(
entry.process, entry.action, entry.operation,
', '.join([str(value) for value in entry.values]))
if entry.action == 'invoke':
logger.warn(message)
elif entry.action == 'ok':
logger.debug(message)
elif entry.action == 'fail':
logger.error(message)
elif entry.action == 'function':
logger.info(message)
def rawDataReceived(self, data):
"""
Called when acting as TCP tunnel endpoint to actual proxy/server.
"""
if self.isReady:
logger.error('%s: DATA RECEIVED WHILE NOT WANTED' % self)
return
if self.server._tunnelStatus.is_established:
self.consumer.write(data)
data_type = 'TCP'
else:
tunnel.HTTPRequester.rawDataReceived(self, data)
data_type = 'UNKNOWN_RAW'
logger.debug('%s: WROTE %s (len=%d)' % (self, data_type, len(data)))
def process(self):
if self.channel._tunnelStatus.is_established:
if self.method == b'POST':
del self.channel.requests[1] # suicide
self.content.seek(0,0)
self.channel.client.transport.write(self.content.read())
self.__cleanup()
else:
# while this is possible, tcp handling has problem and above if is not safe neither
logger.error('%s: NON_TCP_DATA_IN_TUNNEL_MODE: mode: %s, req: %r' % \
(self.channel, self.channel._tunnelStatus._state, self))
self.channel._tunnelStatus.no_tunnel()
tunnel.Request.process(self)
else:
tunnel.Request.process(self)
def publish_state(level):
logger.info('Publishing current state: %s' % level)
try:
mqtt_client.publish(config.MQTT_GET_TOPIC, level)
except Exception as e:
logger.error('MQTT publish failed: {}'.format(e))
