def test_btn(suppress=False, lf=True, df=True):
s = '''
press pulses red
release pulses green
double click pulses yellow
long press pulses blue
'''
print('Test of pushbutton scheduling coroutines.')
print(helptext)
print(s)
pin = Pin('X1', Pin.IN, Pin.PULL_UP)
red = LED(1)
green = LED(2)
yellow = LED(3)
blue = LED(4)
pb = Pushbutton(pin, suppress)
pb.press_func(pulse, (red, 1000))
pb.release_func(pulse, (green, 1000))
if df:
print('Doubleclick enabled')
pb.double_func(pulse, (yellow, 1000))
if lf:
print('Long press enabled')
pb.long_func(pulse, (blue, 1000))
loop = asyncio.get_event_loop()
loop.run_until_complete(killer())
class LED(HomieNode):
def __init__(self, name="Onboard LED", pin=2):
super().__init__(id="led", name=name, type="LED")
self.pin = pin
self.led = Pin(pin, Pin.OUT, value=0)
self.btn = Pushbutton(Pin(0, Pin.IN, Pin.PULL_UP))
self.btn.press_func(self.toggle_led)
self.power_property = HomieNodeProperty(
id="power",
name="LED Power",
settable=True,
datatype=BOOLEAN,
default=TRUE,
)
self.add_property(self.power_property, self.on_power_msg)
def on_power_msg(self, topic, payload, retained):
self.led(ONOFF[payload])
self.power_property.data = ONOFF[self.led()]
def toggle_led(self):
if self.power_property.data != TRUE:
self.led(0)
self.power_property.data = TRUE
else:
self.led(1)
self.power_property.data = FALSE
class Button(Module):
def __init__(self, *args, **kwargs):
print("Initializing button")
super().__init__(*args, **kwargs)
self.pin = machine.Pin(self.settings["pin"], machine.Pin.IN)
self.pushbutton = Pushbutton(self.pin)
self.pushbutton.press_func(self.button_pressed)
def button_pressed(self, timer=None):
print("Button pressed")
self.parent.call_callbacks("button_on_pressed_callback")
def test_btncb():
print('Test of pushbutton executing callbacks.')
print(helptext)
pin = Pin('X1', Pin.IN, Pin.PULL_UP)
red = LED(1)
green = LED(2)
yellow = LED(3)
blue = LED(4)
pb = Pushbutton(pin)
pb.press_func(toggle, (red, ))
pb.release_func(toggle, (green, ))
pb.double_func(toggle, (yellow, ))
pb.long_func(toggle, (blue, ))
loop = asyncio.get_event_loop()
loop.run_until_complete(killer())
def test_btn():
print('Test of pushbutton scheduling coroutines.')
print(helptext)
pin = Pin('X1', Pin.IN, Pin.PULL_UP)
red = LED(1)
green = LED(2)
yellow = LED(3)
blue = LED(4)
pb = Pushbutton(pin)
pb.press_func(pulse, (red, 1000))
pb.release_func(pulse, (green, 1000))
pb.double_func(pulse, (yellow, 1000))
pb.long_func(pulse, (blue, 1000))
loop = asyncio.get_event_loop()
loop.run_until_complete(killer())
def __init__(self):
log.info('DISP:init')
self.screens = [self.show_measurement_screen,
self.show_decibel_screen,
self.show_environmental_screen,
self.show_voltage_monitor_screen,
self.show_display_sleep_screen]
pin_screen = Pin(0, Pin.IN, Pin.PULL_UP)
pb_screen = Pushbutton(pin_screen)
pb_screen.press_func(self.next_screen)
self.active_screen = 1 # TODO make some sort of datastructure for screens + screen ids
self.next_screen = 0 # show the measurement screen first TODO this is a clunky way to show this after measurement screen
self.diag_count = 0
self.screen_timeout = False
self.timeout_timer = Timer(-1)
self.backlight_ctrl = Pin(2, Pin.OUT)
self.backlight_ctrl.value(0)
loop = asyncio.get_event_loop()
loop.create_task(self.run_display())
async def test_btn(pin, suppress=True, lf=True, df=True):
''' handler for aswitch.Pushbutton instances '''
pb = Pushbutton(pin, suppress)
print('{} set up'.format(pin))
pb.press_func(button_operation, (
str(pin),
"pushed",
))
pb.release_func(button_operation, (
str(pin),
"released",
))
pb.double_func(button_operation, (
str(pin),
"double-clicked",
))
pb.long_func(button_operation, (
str(pin),
"long pressed",
))
class switch_plugin:
inputtype = "normal" # Default switch type
datastore = None # Place where plugin data is stored for reboots
def __init__(self):
# generic section
self._log = core._log
self._log.debug("Plugin: switch contruction")
self._utils = core._utils
self._plugins = core._plugins
self._hal = core._hal
self._lock = Event()
self.dxpin = dxpin
# plugin specific section
self.valuenames = {}
self.valuenames["valueN1"] = "switch"
self.valuenames["valueF1"] = ""
self.valuenames["valueD1"] = 0
# release lock, ready for next measurement
self._lock.clear()
def init(self, plugin, device, queue, scriptqueue):
self._log.debug("Plugin: switch init")
# generic section
self._utils.plugin_initdata(self, plugin, device, queue, scriptqueue)
self.content = plugin.get('content', content)
plugin['dtype'] = dtype
plugin['stype'] = stype
plugin['template'] = template
datastore = self._plugins.readstore(self.devicename)
# plugin specific section
self.switch_status = bootstate
if self.inputtype == 'normal':
self._log.debug("Plugin: switch init normal, pin: " + self.dxpin)
# Setup switch
self.swpin = self._hal.pin(self.dxpin, core.PIN_IN,
core.PIN_PULL_UP)
self.switch = Switch(self.swpin)
# Register coros to launch on contact close and open
self.switch.close_func(self.asyncswitchopen)
self.switch.open_func(self.asyncswitchclosed)
elif self.inputtype == 'low':
self._log.debug("Plugin: switch init low, pin: " + self.dxpin)
# Setup button active low
self.swpin = self._hal.pin(self.dxpin, core.PIN_IN,
core.PIN_PULL_UP)
self.switch = Pushbutton(self.swpin)
self.switch.press_func(self.asyncbuttonpress)
self.switch.release_func(self.asyncbuttonrelease)
self.switch.double_func(self.asyncbuttondouble)
self.switch.long_func(self.asyncbuttonlong)
else:
self._log.debug("Plugin: switch init high, pin: " + self.dxpin)
# Setup button active high
self.swpin = self._hal.pin(self.dxpin, core.PIN_IN,
core.PIN_PULL_DOWN)
self.switch = Pushbutton(self.swpin)
self.switch.press_func(self.asyncbuttonpress)
self.switch.release_func(self.asyncbuttonrelease)
self.switch.double_func(self.asyncbuttondouble)
self.switch.long_func(self.asyncbuttonlong)
return True
def loadform(self, plugindata):
self._log.debug("Plugin: switch loadform")
# generic section
self._utils.plugin_loadform(self, plugindata)
# plugin specific section
plugindata['inputtype'] = self.inputtype
plugindata['dxpin0'] = self.dxpin
def saveform(self, plugindata):
self._log.debug("Plugin: switch saveform")
# generic section
self._utils.plugin_saveform(self, plugindata)
# plugin specific section
self.inputtype = plugindata['inputtype']
self.dxpin = plugindata['dxpin0']
# store values
data = {}
data["inputtype"] = self.inputtype
data["dxpin"] = self.dxpin
data["valueN1"] = self.valuenames["valueN1"]
data["valueF1"] = self.valuenames["valueF1"]
data["valueD1"] = self.valuenames["valueD1"]
self._plugins.writestore(self.devicename, data)
if self.inputtype == 'normal':
# Setup switch
self.swpin = self._hal.pin(self.dxpin, core.PIN_IN,
core.PIN_PULL_UP)
self.switch = Switch(self.swpin)
# Register coros to launch on contact close and open
self.switch.close_func(self.asyncswitchopen)
self.switch.open_func(self.asyncswitchclosed)
elif self.inputtype == 'low':
# Setup button active low
self.swpin = self._hal.pin(self.dxpin, core.PIN_IN,
core.PIN_PULL_UP)
self.switch = Pushbutton(self.swpin)
self.switch.press_func(self.asyncbuttonpress)
self.switch.release_func(self.asyncbuttonrelease)
self.switch.double_func(self.asyncbuttondouble)
self.switch.long_func(self.asyncbuttonlong)
else:
# Setup button active high
self.swpin = self._hal.pin(self.dxpin, core.PIN_IN,
core.PIN_PULL_DOWN)
self.switch.press_func(self.asyncbuttonpress)
self.switch.release_func(self.asyncbuttonrelease)
self.switch.double_func(self.asyncbuttondouble)
self.switch.long_func(self.asyncbuttonlong)
def read(self, values):
self._log.debug("Plugin: switch read")
# generic section
values['valueN1'] = self.valuenames["valueN1"]
values['valueD1'] = self.switch_status
def write(self, values):
self._log.debug("Plugin: switch write")
async def asyncprocess(self):
self._log.debug("Plugin: switch process")
# plugin specific section
# If a switch occured
if self.switch_status:
# send data to protocol and script/rule queues
self.valuenames["valueD1"] = self.switch_status
self._utils.plugin_senddata(self)
# erase status
self.switch_status = ""
# release lock, ready for next measurement
self._lock.clear()
#
#CUSTOM SENSOR CODE...
#
async def asyncswitchopen(self):
self.switch_status = 'open'
# release lock, ready for next measurement
self._lock.clear()
async def asyncswitchclosed(self):
self.switch_status = 'closed'
# release lock, ready for next measurement
self._lock.clear()
async def asyncbuttonpress(self):
self.switch_status = 'press'
# release lock, ready for next measurement
self._lock.clear()
async def asyncbuttonrelease(self):
self.switch_status = 'release'
# release lock, ready for next measurement
self._lock.clear()
async def asyncbuttondouble(self):
self.switch_status = 'double'
# release lock, ready for next measurement
self._lock.clear()
async def asyncbuttonlong(self):
self.switch_status = 'long'
# release lock, ready for next measurement
self._lock.clear()
data[1] = 0x01
data[2] = userHCScore >> 8
data[3] = userHCScore
i2c2.write(data)
i2c2.stop()
except:
pass
await asyncio.sleep(60)
upBtn = Pushbutton(upPin)
downBtn = Pushbutton(downPin)
selectBtn = Pushbutton(selectPin)
upBtn.press_func(buttonPressed, (1, ))
downBtn.press_func(buttonPressed, (2, ))
selectBtn.press_func(buttonPressed, (3, ))
upBtn.debounce_ms = 100
def startWifi():
global userHCScore
wifi_config.start_wifi()
if wifi_config.is_wifi_connected():
userHCScore = hc.get_score(hcid)
if userHCScore == "Error":
userHCScore = "0"
print("-- H -- A -- C -- K -- E -- R -- M -- A -- N --")
print("Hacker Score: " + str(userHCScore))
