def _send(self):
"""
send the buffer over SPI.
"""
disable_irq()
self.spi.write(self.buf)
enable_irq()
def send_buf(self):
"""
Send buffer over SPI.
"""
disable_irq()
self.spi.write(self.buf)
enable_irq()
gc.collect()
def ativa(self, p):
try:
irq = disable_irq()
self.p4.value(1)
p.deinit()
enable_irq(irq)
except:
reset()
def button2_int_handler(pin):
global STATE
global onBoardLed
print('button two pressed')
if STATE is not 2:
STATE = 2
onBoardLed.off()
machine.enable_irq(machine.disable_irq())
def button1_int_handler(pin):
global STATE
global onBoardLed
print('button one pressed')
if STATE is not 1:
STATE = 1
onBoardLed.on()
machine.enable_irq(machine.disable_irq())
def send_buf(self):
"""
Send buffer over SPI.
"""
disable_irq()
self.spi.write(self.buf)
enable_irq()
gc.collect()
def write_bit_field(addr, val, num_bits=None, low_posn=0, size=32):
if num_bits is None:
num_bits = size
check_bit_field_parms(num_bits, low_posn, size)
shifted, mask = get_bit_maps(val, num_bits, low_posn, size)
mem = get_mem_func(size)
irq_state = machine.disable_irq()
mem[addr] ^= (mem[addr] ^ shifted) & mask
machine.enable_irq(irq_state)
def setAll(color):
for pos in range(num_pixels):
if pos not in (0, 11):
setPixel(pos, color, show=False)
else:
setPixel(pos, [color[0], color[2], color[1]], show=False)
state = disable_irq()
showPixels()
enable_irq(state)
def acquire_out_buffer(self):
while self.out_buffer_lock == True:
time.sleep_ms(1) # Wait for release
self.irqstate = machine.disable_irq()
if self.out_buffer_lock == True: # TODO: check if this locking is enough
machine.enable_irq(self.irqstate)
return False
self.out_buffer_lock = True
return True
def update_time(display_time): state = machine.disable_irq() my_time.increment() if display_time: time = my_time.string() display(time) machine.enable_irq(state)
def game_loop(self):
while True:
if self.dirty:
self.update()
self.draw()
# critical section
state = disable_irq()
self.dirty = 0
enable_irq(state)
def handle_pins_input(): ### software timer event handler ###
irq_state = machine.disable_irq()
local_pins_input = [pin for pin in pins_input]
machine.enable_irq(irq_state)
for pin_number in local_pins_input:
value = pins_info[pin_number]["pin"].value()
mqtt.client.publish(mqtt.topic_path + "/out",
"(nb:pin_value " + str(pin_number) + " " + str(value) + ")")
def getval(pin):
ms = [1] * 300
pin(0)
time.sleep_us(20000)
pin(1)
irqf = disable_irq()
for i in range(len(ms)):
ms[i] = pin() ## sample input and store value
enable_irq(irqf)
return ms
async def printerCoro() -> None:
global READY_TO_PRINT, VALUES_TO_PRINT
while True:
state = disable_irq()
if READY_TO_PRINT:
while not VALUES_TO_PRINT.is_empty():
print(VALUES_TO_PRINT.dequeue(), end="")
READY_TO_PRINT = False
enable_irq(state)
await uasyncio.sleep_ms(1)
def button_pressed_isr(pin):
state = disable_irq()
global button_pressed
global button_pin
global press_counter
button_pressed = True
button_pin = pin
press_counter = press_counter + 1
enable_irq(state)
def on_change(self, pin):
irq_state = machine.disable_irq()
new_state = pin.value()
if self.state == 0 and new_state == 1:
if self.button_up:
self.button_up()
elif self.state == 1 and new_state == 0:
self.button_down()
self.state = new_state
machine.enable_irq(irq_state)
def watch(self, scheduler):
while True:
await scheduler.sleep_ms(self._check)
irq = disable_irq()
if self._irq_fired_at is not None:
self._unchanged_since = self._irq_fired_at
self._irq_fired_at = None
enable_irq(irq)
if self._unchanged_since is not None and utime.ticks_diff(utime.ticks_ms(), self._unchanged_since) > self._threshold:
self._unchanged_since = None
self._on_change.trigger()
def main():
global led_count
machine.disable_irq()
led_init()
switch_push_init()
led_count = 0
machine.enable_irq()
while True:
pass
def switch_cb(self, pin):
state = disable_irq()
value = pin.value()
if value == 1:
self.read_als = True
else:
self.read_als = False
self.do_debounce = True
self.test_led.on()
enable_irq(state)
return
def button_pressed(self, pin):
previous_state = disable_irq()
self._initialize_servos()
if pin.value():
time.sleep_ms(300)
self.feed()
print('#' * 80)
self._deinit_servos()
enable_irq(previous_state)
def getval(pin):
"""readout a dht11/22 sensor"""
ms = [1] * 300
pin(0)
time.sleep_us(20000)
pin(1)
irqf = disable_irq()
for i in range(len(ms)):
ms[i] = pin() # sample input and store value
enable_irq(irqf)
return ms
def getval(pin):
ms = [1] * _BUFFERSIZE
mslen = len(ms)
pin(0)
time.sleep_us(20000)
pin(1)
irqf = disable_irq()
for _ in range(mslen):
ms[_] = pin() # sample input and store value
enable_irq(irqf)
return ms
def run(sleep_time=sleep_time):
prev_i = 3
while True:
for i, digit in enumerate(digits):
isr = machine.disable_irq()
shiftOut(mapping[digit])
columns[prev_i].on()
latch.on()
columns[i].off()
machine.enable_irq(isr)
sleep(sleep_time)
prev_i = i
def write_bit(self, value):
sleep_us = time.sleep_us
pin = self.pin
i = machine.disable_irq()
pin(0)
sleep_us(1)
pin(value)
sleep_us(60)
pin(1)
sleep_us(1)
machine.enable_irq(i)
def caculate_speed(self, t):
irq_state = machine.disable_irq() # Start of critical section
self.speed1 = (self.count1 - self.pre_count1) * self.rad_per_pulse * 2
self.speed2 = (self.count2 - self.pre_count2) * self.rad_per_pulse * 2
self.speed3 = (self.count3 - self.pre_count3) * self.rad_per_pulse * 2
self.pre_count1 = self.count1
self.pre_count2 = self.count2
self.pre_count3 = self.count3
machine.enable_irq(irq_state) # End of critical section
def getval(self, pin):
value = []
time.sleep(1)
pin(0)
time.sleep_ms(20) # MODIFIED
pin(1)
# time.sleep_us(50) # MODIFIED
irq = disable_irq()
for i in range(700): # MODIFIED
value.append(pin())
enable_irq(irq)
return value
def write_bit(self, value):
sleep_us = time.sleep_us
pin = self.pin
i = machine.disable_irq()
pin(0)
sleep_us(1)
pin(value)
sleep_us(60)
pin(1)
sleep_us(1)
machine.enable_irq(i)
def send_ir_command(index):
with open(Commands[index], "rb") as f:
length = f.readinto(data)
gc.disable()
isr = machine.disable_irq()
try:
output_ir_command(data, length // 2)
finally:
machine.enable_irq(isr)
gc.enable()
def read_data(self, *args, **kwargs):
irq_state = machine.disable_irq()
if self.function_sample:
data = self.function_sample()
else:
data = self.data
ret = (self.events, data)
self.reset()
machine.enable_irq(irq_state)
return ret
def _change_handler(self, pin):
"""Scheduled(!) every time a pin's state changes."""
irq = disable_irq()
try:
# Start the timer interrupt, if it's not already running.
if self._running_jobs == self.RUNNING_NONE:
self._timer.init(period=1,
mode=Timer.PERIODIC,
callback=self._timer_handler_bound)
# Whatever this was before, now there's at least one running.
self._running_jobs = self.RUNNING_SOME
finally:
enable_irq(irq)
def my_callback(p):
interrupt_state = machine.disable_irq()
global act_flag
if (act_flag == 0):
act_flag = 1
else:
act_flag = 0
time.sleep_ms(500)
machine.enable_irq(interrupt_state)
return
def get_pressed_button(self):
"""
Returns a button press.
Note: Can be None
"""
pressedButton = None
irq_state = machine.disable_irq()
if len(self.buttonBuffer) > 0:
pressedButton = self.buttonBuffer.pop()
machine.enable_irq(irq_state)
return pressedButton
def think(self, ticks_ms):
irq_state = machine.disable_irq()
try:
if not self.triggered:
return
self.triggered = False
for handler in self.handlers.values():
if handler.triggered:
handler.triggered = False
handler.lower_half(handler.pin, handler.trigger)
finally:
machine.enable_irq(irq_state)
def getval(pin):
ms = [1] * 700 # needs long sample size to grab all the bits from the DHT
time.sleep(1)
pin(0)
time.sleep_us(10000)
pin(1)
irqf = disable_irq()
for i in range(len(ms)):
ms[i] = pin() ## sample input and store value
enable_irq(irqf)
#for i in range(len(ms)): #print debug for checking raw data
# print (ms[i])
return ms
def update_mboot(filename):
print('Loading file', filename)
mboot_fw = dfu_read(filename)
if mboot_fw is None:
return
if len(mboot_fw) != 1:
assert 0
mboot_addr, mboot_fw = mboot_fw[0]
if mboot_addr != 0x08000000:
assert 0
# TODO: Validate firmware in a simple way
print('Found Mboot data with size %u.' % len(mboot_fw))
chk = check_mem_contains(mboot_addr, mboot_fw)
if chk:
print('Supplied version of Mboot is already on device.')
return
print('Programming Mboot, do not turn off!')
time.sleep_ms(50)
irq = machine.disable_irq()
flash_unlock()
flash_erase_sector(0)
if len(mboot_fw) > 16 * 1024 and not check_mem_erased(mboot_addr + 16 * 1024, 16 * 1024):
flash_erase_sector(1)
flash_write(mboot_addr, mboot_fw)
flash_lock()
machine.enable_irq(irq)
print('New Mboot programmed.')
if check_mem_contains(mboot_addr, mboot_fw):
print('Verification of new Mboot succeeded.')
else:
print('Verification of new Mboot FAILED! Try rerunning.')
print('Programming finished, can now reset or turn off.')
def read(self):
# wait for the device being ready
while self.pOUT() == 1:
idle()
# shift in data, and gain & channel info
result = 0
for j in range(24 + self.GAIN):
state = disable_irq()
self.pSCK(True)
self.pSCK(False)
enable_irq(state)
result = (result << 1) | self.pOUT()
# shift back the extra bits
result >>= self.GAIN
# check sign
if result > 0x7fffff:
result -= 0x1000000
return result
def reEnableIRQ(self):
machine.enable_irq(True)
self.irqState=True
# Little hack because the WDT's .feed doesn't really work on ESP8266 yet
# This is required because sometimes, importing the 'moisture' module
# fails with a MemoryError
import machine
irq = machine.disable_irq()
from moisture import MoistureMonitor
import network
import time
import ntptime
import config
machine.enable_irq(irq)
sta = network.WLAN(network.STA_IF)
sta.active(True)
for ap in sta.scan():
if ap[0] not in config.aps:
continue
print("Found AP {}".format(ap))
ap = ap[0]
sta.connect(ap, config.aps[ap])
while sta.status() != network.STAT_GOT_IP:
print("Waiting for connection to come up")
time.sleep(1)
