def __init__(self):
self.bus = I2C(scl=Pin(self.SCL), sda=Pin(self.SDA))
self.int = Signal(self.INT, Pin.IN, Pin.PULL_UP, invert=True)
#self.int = Pin(self.INT, Pin.IN, Pin.PULL_UP)
self.timer = Timer(-1)
# Enable outputs, bits 4-7
self.bus.writeto(self.BASE_ADDR, bytearray([self.MCP23008_IODIR, 0b00001111]))
# Reverse Polarity, bits 0-3
self.bus.writeto(self.BASE_ADDR, bytearray([self.MCP23008_IPOL, 0b00001111]))
# Enable pullups, bits 0-3
self.bus.writeto(self.BASE_ADDR, bytearray([self.MCP23008_GPPU, 0b00001111]))
# Set interrupt to open-drain
self.bus.writeto(self.BASE_ADDR, bytearray([self.MCP23008_IOCON, 0b00000100]))
# Compare against DEFVAL
self.bus.writeto(self.BASE_ADDR, bytearray([self.MCP23008_INTCON, 0b00001111]))
# Enable Interrupt on Change
self.bus.writeto(self.BASE_ADDR, bytearray([self.MCP23008_GPINTEN, 0b00001111]))
# Turn off all lights
self.all_off()
def main():
from machine import Pin, Signal
import time
import hwconfig
def toggle(aPin):
aPin.value(not aPin.value())
red = Signal(hwconfig.LED_RED, Pin.OUT, value=1, invert=True)
blue = Signal(hwconfig.LED_BLUE, Pin.OUT, invert=True)
do_measure = Signal(hwconfig.D5, Pin.IN, Pin.PULL_UP, invert=True)
last_time = time.ticks_ms()
cnt = 0
print("If D5 is off then it just toggles 2 leds.")
print(
"If D5 is on then it toggles 2 leds as fast as it can and measures time"
)
while True:
toggle(red)
toggle(blue)
if do_measure.value():
cnt += 1
now = time.ticks_ms()
delta = time.ticks_diff(now, last_time)
if delta > 1000:
print("toggled 2 pins: {}/s".format(cnt * 1000 / delta))
cnt = 0
last_time = time.ticks_ms()
else:
time.sleep_ms(50)
def __init__(self, addr: int) -> None:
uart = UART(UART_NUM,
CONSTANTS.UART.BAUD_RATE,
tx=Pin(TX_PIN),
rx=Pin(RX_PIN))
tx_en = Pin(TX_EN_PIN, Pin.OUT)
KtaneBase.__init__(self, addr, uart, tx_en, LOG, idle, ticks_us)
self.status_red = Signal(Pin(STATUS_RED, Pin.OUT), invert=True)
self.status_green = Signal(Pin(STATUS_GREEN, Pin.OUT), invert=True)
self.set_mode(CONSTANTS.MODES.SLEEP)
def __init__(self, pin_id, invert=False):
"""Initialize a new heartbeat.
Args:
pin_id (int): Which pin to toggle.
invert (bool): Whether the pin should be considered "active low".
See the ``invert`` parameter of MicroPython's ``Signal``.
"""
self._sig = Signal(pin_id, Pin.OUT, invert=invert)
self._sig.off()
def _wait_for_sta_connection(self, a_sta_name):
status_led = Signal(Pin(2, Pin.OUT), invert=True)
MAX_CONNECT_TIME_MS = 20000
start = time.ticks_ms()
deadline = start + MAX_CONNECT_TIME_MS
now = start
print("connecting to wifi '{}' ...".format(a_sta_name))
status = 0
while now < deadline:
new_status = self.sta_if.status()
if new_status != status:
status = new_status
print("status: {}".format(self._if_status_string(status)))
if self._connecting_finished(status):
break
time.sleep_ms(50)
now = time.ticks_ms()
status_led.value(not status_led.value())
if self.sta_if.isconnected():
print("DONE (finished in {} ms)".format(now-start))
print(self.sta_if.ifconfig())
status_led.on()
time.sleep_ms(500)
else:
print("FAILED (finished in {} ms)".format(now-start))
status_led.off()
def set_outputs(self, a_params):
""" It processes parameters given as a dictionary of "output_name": "value".
"output_name" must exist in self.pins_out and "value" must be either 0 or 1.
"""
for output, value in a_params.items():
if output.decode() in self.pins_out and value.decode() in ("0",
"1"):
pin = Signal(eval("hwconfig." + output.decode()),
Pin.OUT,
invert=True)
pin.value(int(value))
else:
print("not using {}={}".format(output, value))
def main():
pin = Pin(('GPIO_1', 5), Pin.OUT)
led = Signal(pin, invert=True)
led.off()
led_status = 'OFF'
while True:
reported = {'state': {'reported': {}}}
reported['state']['reported']['led'] = led_status
degu.update_shadow(ujson.dumps(reported))
received = degu.get_shadow()
if received:
try:
desired = ujson.loads(received)
try:
led_status = desired['state']['desired']['led']
except:
pass
if led_status == 'ON':
led.on()
else:
led.off()
except:
pass
time.sleep(1)
class E32CB:
pwm_fan_freq = 25000
pwm_base_freq = 1000
pwm_min = 0
pwm_max = 1023
i2c = I2C(scl=Pin(22), sda=Pin(21))
uart = UART(2, 9600)
q1 = Mosfet(Pin(33), pwm_base_freq, pwm_max)
q2 = Mosfet(Pin(25), pwm_base_freq, pwm_max)
q3 = Mosfet(Pin(27), pwm_base_freq, pwm_max)
q4 = Mosfet(Pin(14), pwm_base_freq, pwm_max)
q5 = Mosfet(Pin(13), pwm_base_freq, pwm_max)
q6 = Mosfet(Pin(4), pwm_base_freq, pwm_max)
q7 = Mosfet(Pin(18), pwm_base_freq, pwm_max)
q8 = Signal(Pin(19, Pin.OUT), invert=True)
@classmethod
def invert_pwm(cls, pwm):
return cls.pwm_min + (cls.pwm_max - pwm)
@staticmethod
def led(value):
Pin(32, Pin.OUT).value(value)
@staticmethod
def fan(value):
PWM(Pin(23), freq=pwm_fan_freq, duty=value)
def __init__(self,
en_pin_nr,
voltage,
settle_time_ms,
inverse_pol=False,
default_state=SUPPLY_STATE_DISABLED):
self.EnPin = Signal(en_pin_nr, mode=Pin.OUT, invert=inverse_pol)
if default_state is self.SUPPLY_STATE_ENABLED:
self.Enable()
else:
self.EnCount = 0
self.EnPin.off()
self.Voltage = voltage
self.SettleTime = settle_time_ms
def main():
from machine import Pin, Signal
from utime import sleep
pin = Pin(0, Pin.IN) # set GPIO4 as input with pullup
pir = Signal(pin, invert=False) # let's use Signals, eh?
detected = False
while True:
if not detected and pir.value(): # gone HIGH
print("A Visitor!")
mp3.play_track(urandom.getrandbits(BITS) +
1) # since the MP3 doesn't recognize song 0
detected = True
elif detected and not pir.value(): # gone LOW
print("Bye!")
detected = False
sleep(60 * 20) # sleep 20 minutes
class Heartbeat:
"""Toggle an output pin in a repeating pattern."""
def __init__(self, pin_id, invert=False):
"""Initialize a new heartbeat.
Args:
pin_id (int): Which pin to toggle.
invert (bool): Whether the pin should be considered "active low".
See the ``invert`` parameter of MicroPython's ``Signal``.
"""
self._sig = Signal(pin_id, Pin.OUT, invert=invert)
self._sig.off()
async def beat(self, sch):
"""Perform the heartbeat.
Pass this function to ``create_task`` of Perthensis' ``Scheduler``.
Note that it will set the pin to "on" for 2 seconds before starting the
pattern. This is supposed to make board resets clearly visible.
"""
self._sig.on()
await sch.sleep(2)
while True:
for idx, delay in enumerate(PATTERN):
self._sig.on() if idx % 2 == 0 else self._sig.off()
await sch.sleep_ms(delay)
def main():
from machine import Pin, Signal
from utime import sleep
pin2 = Pin(2, Pin.IN, Pin.PULL_UP) # set GPIO2 as input with pullup
button = Signal(pin2, invert=True) # let's use Signals, eh?
pressed = False
do_connect() # On boot, connect.
while True:
if not pressed and button.value(): # falling edge - button was pressed
print("Button Pressed")
pressed = True
do_post()
elif pressed and not button.value(): # rising edge - released button
print("Button Released")
pressed = False
sleep(0.01)
class Sonoff():
led = Signal(Pin(13, Pin.OUT, value=1), invert=True)
relay = Pin(12, Pin.OUT, value=0)
button = Pin(0, Pin.IN, Pin.PULL_UP)
mqtt = MQTTClient(CLIENT, SERVER)
q = []
def __init__(self):
self.q.insert(0, self.led.value())
def sub_cb(self, topic, msg):
if topic == T_IN:
# set state
self.q.insert(0, int(msg == M_ON))
def notify(self, topic, msg):
task = loop.create_task(self.pub_msg(topic, msg))
async def pub_msg(self, topic, msg):
self.mqtt.publish(topic, msg)
async def push_button(self):
while True:
start = time.ticks_ms()
while self.button.value() == 0:
pass
pushed = time.ticks_diff(time.ticks_ms(), start)
if pushed > 20:
self.notify(T_OUT, M_BUTTON)
self.q.insert(0, not self.led.value())
pushed = 0
await asyncio.sleep_ms(10)
async def switch(self):
while True:
if self.q:
state = self.q.pop()
self.relay(state)
self.led(state)
if state == 1:
self.notify(T_RESULT, R_ON)
self.notify(T_OUT, M_ON)
else:
self.notify(T_RESULT, R_OFF)
self.notify(T_OUT, M_OFF)
await asyncio.sleep_ms(500)
async def main(self):
self.mqtt.connect()
self.mqtt.set_callback(self.sub_cb)
self.mqtt.subscribe(T_IN)
task1 = loop.create_task(self.switch())
task2 = loop.create_task(self.push_button())
while True:
self.mqtt.check_msg()
await asyncio.sleep_ms(500)
print('exiting')
def __init__(self):
"""
Initialize the node.
Performs the hardware setup and configuration loading from
`config.json` file.
"""
machine.freq(160000000)
self.led = Signal(Pin(2, Pin.OUT), invert=True)
self.led.off()
self.i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000)
self.station = WLAN(STA_IF)
self.config = json.load(open('config.json'))
self.countdown = None
def __init__(self):
""" Creates pins for use later."""
# pins to use - just names from hwconfig
self.pins_pullup = [
"D{}".format(i) for i in (5, 6, 7)
] # pin supporting pull up (connect to GND for change)
self.pins_out = ["LED_RED", "LED_BLUE"]
# objects to use
self.pv_pullup = [(name,
Signal(eval("hwconfig.{}".format(name)),
Pin.IN,
Pin.PULL_UP,
invert=True)) for name in self.pins_pullup]
self.pv_in = []
self.pv_out = [(name,
Signal(eval("hwconfig.{}".format(name)),
Pin.OUT,
invert=True)) for name in self.pins_out]
def blink_user_led(interval, times: int = 1) -> None:
user_led = Signal(Pin(SERVICE_LED_PIN, Pin.OUT), invert=True)
for _ in range(times):
user_led.on()
time.sleep(interval)
user_led.off()
time.sleep(interval)
def __init__(self) -> None:
KtaneHardware.__init__(self, self.read_config())
self.handlers.update({
CONSTANTS.PROTOCOL.PACKET_TYPE.REQUEST_ID:
self.request_id,
CONSTANTS.PROTOCOL.PACKET_TYPE.CONFIGURE:
self.configure,
CONSTANTS.PROTOCOL.PACKET_TYPE.START:
self.start,
CONSTANTS.PROTOCOL.PACKET_TYPE.STOP:
self.stop,
CONSTANTS.PROTOCOL.PACKET_TYPE.DISARMED:
self.disarmed,
})
self.serial_number = b""
self.post_pins = [
Pin(pin_num, Pin.IN, Pin.PULL_UP) for pin_num in POSTS
]
self.posts = [Signal(pin, invert=True) for pin in self.post_pins]
self.wires = [
Signal(Pin(pin_num, Pin.OUT), invert=True) for pin_num in WIRES
]
def main():
gc.collect()
genWebObj = CGenWeb()
switchState = False
switchObj = Signal(Pin(0, Pin.OUT),
invert=True) # GPIO0; Relay: NO ( normally open )
switchObj.off()
# ledObj = Signal(Pin(2, Pin.OUT), invert=True) # GPIO2; ESP01S
# ledObj.off()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(2)
while True:
try:
if gc.mem_free() < G_GC_THRESHOLD:
gc.collect()
conn, addr = s.accept()
conn.settimeout(3.0)
print('Received HTTP GET connection request from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('GET Rquest Content = %s' % request)
switch_on = request.find('/?switch_on')
switch_off = request.find('/?switch_off')
if switch_on == G_CMD_IDX:
print('Switch ON -> GPIO2')
switchState = True
switchObj.on()
# ledObj.on()
if switch_off == G_CMD_IDX:
print('Switch OFF -> GPIO2')
switchState = False
switchObj.off()
# ledObj.off()
resHtml = genWebObj.getWebPage(switchState)
conn.send('HTTP/1.1 200 OK\n')
conn.send('Content-Type: text/html\n')
conn.send('Connection: closed.\n\n')
conn.sendall(resHtml)
conn.close()
except OSError as e:
conn.close()
print('Connection closed. OSError =', e)
class Supply:
SUPPLY_STATE_DISABLED = const(0)
SUPPLY_STATE_ENABLED = const(1)
def __init__(self,
en_pin_nr,
voltage,
settle_time_ms,
inverse_pol=False,
default_state=SUPPLY_STATE_DISABLED):
self.EnPin = Signal(en_pin_nr, mode=Pin.OUT, invert=inverse_pol)
if default_state is self.SUPPLY_STATE_ENABLED:
self.Enable()
else:
self.EnCount = 0
self.EnPin.off()
self.Voltage = voltage
self.SettleTime = settle_time_ms
def Enable(self):
self.EnCount += 1
# print("[Supply] Enable count: {}".format(self.EnCount))
if self.EnCount is 1:
# print("[Supply] Enabling supply")
self.EnPin.on()
utime.sleep_ms(self.SettleTime)
return 0
def Disable(self):
if self.EnCount is 0:
# print("[Supply] Supply cannot be disabled")
return -1
self.EnCount -= 1
# print("[Supply] Enable count: {}".format(self.EnCount))
if self.EnCount is 0:
# print("[Supply] Disabling supply")
self.EnPin.off()
utime.sleep_ms(self.SettleTime)
return 0
def IsEnabled(self):
return self.EnCount > 0
def test():
dout = Pin(Pin.board.Y5, Pin.OUT_PP, value=0) # Define pins
ckout = Pin(Pin.board.Y6, Pin.OUT_PP,
value=0) # Don't assert clock until data is set
din = Pin(Pin.board.Y7, Pin.IN)
ckin = Pin(Pin.board.Y8, Pin.IN)
reset = Pin(Pin.board.Y4, Pin.OPEN_DRAIN)
sig_reset = Signal(reset, invert=True)
channel = SynCom(False, ckin, ckout, din, dout, sig_reset, 10000)
loop = asyncio.get_event_loop()
loop.create_task(heartbeat())
loop.create_task(channel.start(initiator_task))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
ckout.value(0)
def main():
path = 'thing/' + zcoap.eui64()
reported = {'state': {'reported': {}}}
addr = zcoap.gw_addr()
port = 5683
cli = zcoap.client((addr, port))
pin = Pin(('GPIO_1', 5), Pin.OUT)
led = Signal(pin, invert=True)
led.off()
led_status = 'OFF'
while True:
reported['state']['reported']['led'] = led_status
cli.request_post(path, ujson.dumps(reported))
received = cli.request_get(path)
if received:
try:
desired = ujson.loads(received)
try:
led_status = desired['state']['desired']['led']
except:
pass
if led_status == 'ON':
led.on()
else:
led.off()
except:
pass
time.sleep(1)
cli.close()
def __init__(self, i2c, pin_setup=DEFAULT_PIN_SETUP):
"""Initialize Joy Bonnet specific Pins and ADC reader (for the joystick) """
self.i2c = i2c
self.adc = ADS1015(i2c=i2c, address=72)
self.pin_setup = pin_setup
self.last_state = {} # retain the last state of buttons
self.x_center = self.adc.read(rate=0, channel1=1) # around 833
self.y_center = self.adc.read(rate=0, channel1=0) # around 824
self.x_thresold = 10 # minimum thresold around the center value
self.y_thresold = 10 # minimum thresold around the center value
# maximum & scale
self.x_max = 1652
self.y_max = 1652
self.x_scale = 100 / (self.x_max / 2
) # scale to retreive value between -100 & +100
self.y_scale = 100 / (self.y_max / 2)
for name, pinname in self.pin_setup.items():
if not pinname: # skip unassigned button
continue
p = Pin(pinname, Pin.IN, Pin.PULL_UP)
self.pin_setup[name] = Signal(
p, invert=True) # replace PinName by Signal(Pin) Instance
self.last_state[name] = False # Initialize last know button state
# create network class
wlan = network.WLAN(network.STA_IF)
# define inputs
# INTRUDER_PIN = D1 (GPIO5)
INTRUDER_PIN = Pin(5, Pin.IN, Pin.PULL_UP)
# SET_UNSET_PIN = D2 (GPIO4)
SET_UNSET_PIN = Pin(4, Pin.IN, Pin.PULL_UP)
# SECOND_INTRUDER_PIN = D4 (GPIO2)
SECOND_INTRUDER_PIN = Pin(2, Pin.IN, Pin.PULL_UP)
# define outputs
# esp LED
WIFI_LED_PIN = Pin(16, Pin.OUT)
wifi_LED = Signal(WIFI_LED_PIN, invert=True)
# define signals
intruder_signal = Signal(INTRUDER_PIN, invert=True)
set_unset_signal = Signal(SET_UNSET_PIN, invert=True)
second_intruder_signal = Signal(SECOND_INTRUDER_PIN, invert=True)
"""The Notifier class checks the inputs from a signal and depending on the
input triggers certain external actions, in this case triggering a webhook
using IFTTT.
The class has the following methods for direct use:
check_signal(signal_input) - checks the signal and triggers the webhook
if the signal state has changed.
set_action1(str) - sets the action(value1) to be sent with the webhook.
set_action2(str) - sets the action(value2) to be sent with the webhook.
def sendData(x):
global sendData_
sendData_ = True
debounceDelay_ = 20
vane_pin_ = 5
anem_pin_ = 4
led_pin_ = 2
vane_ = Pin(vane_pin_, Pin.IN, Pin.PULL_UP)
anem_ = Pin(anem_pin_, Pin.IN, Pin.PULL_UP)
led_ = Pin(led_pin_, Pin.OUT)
ledsig_ = Signal(led_, invert=True)
anemDebounceTime_ = 0
vaneDebounceTime_ = 0
anemTime_ = 0
anemLastTime_ = 0
anemLastVal_ = anem_.value()
vaneLastVal_ = vane_.value()
anemState_ = 1
vaneState_ = 0
speeds_ = []
directions_ = []
sendData_ = False
sendTimer_ = Timer(-1)
sendTimer_.init(period=2000, mode=Timer.PERIODIC, callback=sendData)
class KtaneHardware(KtaneBase):
mode: int
def __init__(self, addr: int) -> None:
uart = UART(UART_NUM,
CONSTANTS.UART.BAUD_RATE,
tx=Pin(TX_PIN),
rx=Pin(RX_PIN))
tx_en = Pin(TX_EN_PIN, Pin.OUT)
KtaneBase.__init__(self, addr, uart, tx_en, LOG, idle, ticks_us)
self.status_red = Signal(Pin(STATUS_RED, Pin.OUT), invert=True)
self.status_green = Signal(Pin(STATUS_GREEN, Pin.OUT), invert=True)
self.set_mode(CONSTANTS.MODES.SLEEP)
def set_mode(self, mode: int) -> None:
self.mode = mode
if mode == CONSTANTS.MODES.SLEEP:
LOG.info("mode=sleep")
self.status_green.off()
self.status_red.off()
elif mode in [CONSTANTS.MODES.ARMED, CONSTANTS.MODES.READY]:
LOG.info("mode=armed or ready")
self.status_green.off()
self.status_red.on()
elif mode == CONSTANTS.MODES.DISARMED:
LOG.info("mode=disarmed")
self.status_green.on()
self.status_red.off()
def check_queued_tasks(self, was_idle):
if self.queued & CONSTANTS.QUEUED_TASKS.STRIKE:
was_idle = False
self.strike()
state = disable_irq()
self.queued &= ~CONSTANTS.QUEUED_TASKS.STRIKE
enable_irq(state)
if self.queued & CONSTANTS.QUEUED_TASKS.DISARMED:
was_idle = False
self.disarmed()
state = disable_irq()
self.queued &= ~CONSTANTS.QUEUED_TASKS.DISARMED
enable_irq(state)
if was_idle:
self.idle()
def unable_to_arm(self) -> None:
LOG.info("error")
self.queue_packet(
QueuedPacket(CONSTANTS.MODULES.MASTER_ADDR,
CONSTANTS.PROTOCOL.PACKET_TYPE.ERROR))
def disarmed(self):
LOG.info("disarmed")
self.queue_packet(
QueuedPacket(CONSTANTS.MODULES.MASTER_ADDR,
CONSTANTS.PROTOCOL.PACKET_TYPE.DISARMED))
self.set_mode(CONSTANTS.MODES.DISARMED)
def strike(self):
LOG.info("strike")
self.queue_packet(
QueuedPacket(CONSTANTS.MODULES.MASTER_ADDR,
CONSTANTS.PROTOCOL.PACKET_TYPE.STRIKE))
def stop(self, _source: int, _dest: int, _payload: bytes) -> bool:
LOG.info("stop")
self.set_mode(CONSTANTS.MODES.SLEEP)
return False
import socket
import select
import errno
import sys
from machine import Signal, Pin
led1 = Signal(0, Pin.OUT, invert=False)
led2 = Signal(4, Pin.OUT, invert=False)
led3 = Signal(5, Pin.OUT, invert=False)
led1.value(0)
led2.value(0)
led3.value(0)
HEADER_LENGTH = 10
IP = "192.168.43.165"
PORT = 1234
def f(a, b):
a = str(a)
return a + (b - len(a)) * ' '
#my_username = input("Username: ")
my_username = '******'
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((IP, PORT))
client_socket.setblocking(False)
def main():
# prepare bme device
i2c = I2C(scl=Pin(hwconfig.D1), sda=Pin(hwconfig.D2))
bme = BME280(i2c=i2c)
# inputs
switch_name = "D5"
button = Signal(hwconfig.BTN_USER, Pin.IN, invert=True)
switch = Signal(eval("hwconfig." + switch_name),
Pin.IN,
Pin.PULL_UP,
invert=True)
# outputs
led = Signal(hwconfig.LED_BLUE, Pin.OUT, invert=True)
# load thingspeak api key
thingspeak_cfg = "thingspeak.cfg"
try:
f = open(thingspeak_cfg, "r")
api_key = f.read()
api_key = api_key.strip()
f.close()
except:
print("error reading api key from {}".format(thingspeak_cfg))
api_key = None
print(
"Press USER button to see values. Press {} to upload to thingspeak.com"
.format(switch_name))
upload_interval_s = 1
last_upload_time = 0
while True:
t, h, p = (bme.temperature, bme.humidity, bme.pressure)
tv = float(t.replace("C", ""))
hv = float(h.replace("%", ""))
pv = float(p.replace("hPa", ""))
if button.value():
print(t, p, h)
now = time.time()
if switch.value():
print(t, p, h)
if api_key is not None:
if now - last_upload_time > upload_interval_s:
print("uploading...")
data = {
"api_key": api_key,
"field1": tv,
"field2": hv,
"field3": pv
}
upload_to_thingspeak(data, led)
last_upload_time = now
else:
print("you are too quick...")
else:
print(
"not uploading. Save api key in {}".format(thingspeak_cfg))
time.sleep_ms(100)
import machine, time
from machine import Pin, Signal
#blue led on pin 21
green = Signal(Pin(17, Pin.OUT))
red = Signal(Pin(5, Pin.OUT))
blue = Signal(Pin(2, Pin.OUT))
red.off()
blue.off()
green.off()
red.on()
blue.on()
green.on()
green
if not 'i2c' in dir():
i2c = machine.I2C(0, sda=21, scl=22)
#init only one time
if not 'tft' in dir():
tft = m5stack.Display()
import machine, time
if not 'i2c' in dir():
i2c = machine.I2C(0, sda=21, scl=22)
MOTION_ID = const(104)
if MOTION_ID in i2c.scan():
print('motion sensor detected on i2cbus')
# load motion sensor logic,
# two different devices share the same ID, try and retry
from machine import Pin, Signal
valve_pin = Pin(22, Pin.OUT)
valve = Signal(valve_pin, invert=False)
def open():
valve.off()
def close():
valve.on()
def status():
return 'stopped' if valve.value() else 'flowing'
close()
# - Single Neopixel for Status # - Simple push button # See accompanying Fritzing diagram for circuitry. # Still to do: # - Make upgrade module *really* work # - Make a box - thinking matchbox. from machine import Pin, Signal, Timer, RTC import os, utime, machine, esp, network, urequests, json from neopixel import NeoPixel import upgrade pin0 = Pin(0, Pin.OUT) # set GPIO0 to output to drive NeoPixels pin2 = Pin(2, Pin.IN, Pin.PULL_UP) # set GPIO12 as input with pullup button = Signal(pin2, invert=True) # let's use Signals, eh? pressed = False brightness = 128 # Change these to match your unique identifiers # - wifi SSID = 'FooBar' Password = '******' # - io.adafruit.com X_AIO_Key = '4f50c52123232312334ac7582c63ed' User = '******' Feed = 'Feed-Name' np = NeoPixel(pin0, 1) np[0] = (0,0, brightness) np.write()
