def _card_state_change(self, pin):
"""
Need to debounce this
:param pin:
:return:
"""
if self._debounce:
return
self._debounce = True
self._debounce_timer = Timer(-1)
self._debounce_timer.init(period=DEBOUNCE_TIME,
mode=Timer.ONE_SHOT,
callback=self._remove_debounce)
irq_state = disable_irq()
if pin.value(): # No card present
if self._card: # Card may not be present on boot
enable_irq(irq_state)
uos.umount(self._directory)
irq_state = disable_irq()
self._deinit_card()
else:
try:
card = self._init_card()
enable_irq(irq_state)
uos.mount(card, self._directory)
irq_state = disable_irq()
except OSError: # Mount issue, probably EPERM
pass
enable_irq(irq_state)
def distance_mm(self):
pre = 0
post = 0
k = -1
length = 500
resp = bytearray(length)
resp[0] = 0xFF
machine.disable_irq()
self.spi.send_recv(resp, resp)
machine.enable_irq()
# find first non zero value
try:
i, value = next((ind, v) for ind, v in enumerate(resp) if v)
except StopIteration:
i = -1
if i > 0:
pre = bin(value).count("1")
# find first non full high value afterwards
try:
k, value = next((ind, v)
for ind, v in enumerate(resp[i:length - 2])
if resp[i + ind + 1] == 0)
post = bin(value).count("1") if k else 0
k = k + i
except StopIteration:
i = -1
dist= -1 if i < 0 else\
round(((pre + (k - i) * 8 + post) * 8 * 0.172) / 2)
return dist
def _write_bit(self, value, pin_init, pin_value, Pin_OUT):
"""
Write a single bit - requires cached methods/attributes be passed as arguments.
See also write_bit()
"""
d0, d1, d2, d3 = self.write_delays
udelay = sleep_us
if value:
# write 1
i = disable_irq()
pin_init(Pin_OUT)
pin_value(0)
udelay(d0)
pin_value(1)
enable_irq(i)
udelay(d1)
else:
# write 0
i = disable_irq()
pin_init(Pin_OUT)
pin_value(0)
udelay(d2)
pin_value(1)
enable_irq(i)
udelay(d3)
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()
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 switch_cb(pin):
global irq_counter
if irq_counter < 1:
irq_counter += 1
red_led.off()
green_led.off()
machine.disable_irq()
print('Rebooting to enter Calibration Mode...')
utime.sleep_ms(3000)
machine.reset()
def handle_reset(self, p):
machine.disable_irq()
import micropython
import time
if p.value() == 0:
time.sleep_ms(500)
if p.value() == 0:
print("Resetting Device...")
micropython.schedule(self.hard_reset_ref, 0)
def main():
global led_count
machine.disable_irq()
led_init()
switch_push_init()
led_count = 0
machine.enable_irq()
while True:
pass
def main():
global led_count
machine.disable_irq()
led_init()
switch_push_init()
led_count = 0
machine.enable_irq()
while True:
led_out_bdigit(led_count)
machine.disable_irq()
led_count += 1
machine.enable_irq()
busy_wait()
def write_bit(self, addr): #发送位函数。
#发送时关掉中断，防止中断影响时序
state = machine.disable_irq()
self.pin.value(1) #开始拉高
sleep_us(1000)
#sleep_us( 1000 )
self.pin.value(0) #开始引导码
# minimal 2ms
sleep_us(4000) #此处延时最少要大于2ms
self.pin.value(1)
#将数字（二进制）对应位数比较，若对应位都为1，则对应位为1，否则为0；
#即将addr按位取出
#addr & 0x01 表示最低位,即低位在前
#addr & 0x01 means lower bit fist
# 3:1 time occupation means "1"
if (addr & 0x01): #3:1表示数据位1,每个位用两个脉冲表示
sleep_us(600)
self.pin.value(0)
sleep_us(200)
# 1:3 time occupation means "0"
else: # 1：3表示数据位0 ,每个位用两个脉冲表示
sleep_us(200)
self.pin.value(0)
sleep_us(600)
self.pin.value(addr)
self.pin.value(1)
#恢复中断
#resum interrupt
machine.enable_irq(state)
def debounce(self, timer):
state = machine.disable_irq()
if (self.debouncing and self.debouncing.value() == 0):
self.debounce_done = True
else:
self.debouncing = None
machine.enable_irq(state)
def read(self):
#First wait for data ready, DOUT will be low when ready
while not self.is_ready():
pass
#disable interrupts to avoid problems during reading
#If SCK goes high longer than 65µs the chip enter power down state.
#So we must avoid interruots during reading
interrupt_status = machine.disable_irq()
dataBits = 0
for i in range(0, 24):
self.pSCK.value(True)
dataBits <<= 1
utime.sleep_us(1) #Minimum waiting time
self.pSCK.value(False)
bitLu = self.pOUT()
if bitLu: dataBits += 1
utime.sleep_us(1) #Minimum waiting time
# set channel and gain factor for next reading
for i in range(self.GAIN):
self.pSCK.value(True)
utime.sleep_us(1) #Minimum waiting time
self.pSCK.value(False)
utime.sleep_us(1) #Minimum waiting time
#
machine.enable_irq(interrupt_status) #Re enable interrupts
if dataBits >= 8388608: #negative value
dataBits = dataBits - 16777216
return dataBits
def _upper_half(pin):
irq_state = machine.disable_irq()
try:
self.triggered = True
self.handlers[(id(pin), trigger)].triggered = True
finally:
machine.enable_irq(irq_state)
def read(self):
"""
Acquire vbatt reading by sampling ADC.
"""
# Power on ADC.
self.adc.init()
log.debug('Reading battery level on pin {} with voltage divider {}/{}'.
format(self.pin, self.resistor_r1, self.resistor_r2))
# Sample ADC a few times.
# Todo: Make attenuation factor configurable.
adc_channel = self.adc.channel(attn=ADC.ATTN_6DB, pin=self.pin)
adc_samples = [0.0] * self.adc_sample_count
adc_mean = 0.0
i = 0
irq_state = disable_irq()
while i < self.adc_sample_count:
sample = adc_channel()
adc_samples[i] = sample
adc_mean += sample
i += 1
enable_irq(irq_state)
adc_mean /= self.adc_sample_count
adc_variance = 0.0
for sample in adc_samples:
adc_variance += (sample - adc_mean)**2
adc_variance /= (self.adc_sample_count - 1)
raw_voltage = adc_channel.value_to_voltage(4095)
mean_voltage = adc_channel.value_to_voltage(int(adc_mean))
mean_variance = (adc_variance * 10**6) // (adc_mean**2)
# log.debug("ADC readings. count=%u:\n%s" %(self.adc_sample_count, str(adc_samples)))
log.debug(
"SystemBatteryLevel: Mean of ADC readings (0-4095) = %15.13f" %
adc_mean)
log.debug(
"SystemBatteryLevel: Mean of ADC voltage readings (0-%dmV) = %15.13f"
% (raw_voltage, mean_voltage))
log.debug("SystemBatteryLevel: Variance of ADC readings = %15.13f" %
adc_variance)
log.debug(
"SystemBatteryLevel: 10**6*Variance/(Mean**2) of ADC readings = %15.13f"
% mean_variance)
resistor_sum = self.resistor_r1 + self.resistor_r2
voltage_millivolt = (adc_channel.value_to_voltage(
int(adc_mean))) * resistor_sum / self.resistor_r2
voltage_volt = voltage_millivolt / 1000.0
# Shut down ADC channel.
adc_channel.deinit()
log.debug('Battery level: {}'.format(voltage_volt))
reading = {'system.voltage': voltage_volt}
return reading
def _settle_checker(self, _):
"""Scheduled(!) each ms while we're debouncing something."""
self._running_jobs = self.RUNNING_CHECKING
# Most of the following code could possibly be moved into the
# ``DebouncedTimer`` class for separation of concerns, but we should
# probably do some benchmarking first.
for pin_id, pin in self._pins.items():
if pin._settle_wait is not None: # pin is being debounced
if pin._settle_wait <= 0: # it has settled now
pin._settle_wait = None
if pin._value != pin._previous:
pin._previous = pin._value
pin._callback(pin_id, pin._value)
else:
# Since no interrupt sets this to None, we can safely
# assume that it's an int.
pin._settle_wait -= 1
# There is at least one running job left.
self._running_jobs = self.RUNNING_SOME
# If there are no debouncing jobs left, disable the timer.
irq = disable_irq()
try:
if self._running_jobs == self.RUNNING_CHECKING:
# Didn't see running jobs, and no new ones were inserted
# meanwhile via an interrupt.
self._running_jobs = self.RUNNING_NONE
self._timer.deinit()
finally:
enable_irq(irq)
def main():
global relay_pin
client = MQTTClient(CLIENT_ID, SERVER)
client.set_callback(new_msg)
try:
client.connect()
except OSError:
print("MQTT Broker seems down")
print("Resetting after 20 seconds")
time.sleep(20)
machine.reset()
client.subscribe(COMMAND_TOPIC)
# Publish as available once connected
client.publish(AVAILABILITY_TOPIC, "online", retain=True)
switch_pin = machine.Pin(5, machine.Pin.IN, machine.Pin.PULL_UP)
reed_switch = Switch(switch_pin)
# Initialize state of garage door after booting up
if switch_pin.value():
client.publish(STATE_TOPIC, "open", retain=True)
else:
client.publish(STATE_TOPIC, "closed", retain=True)
relay_pin = machine.Pin(4, machine.Pin.OUT, 0)
try:
while True:
reed_switch_new_value = False
# Disable interrupts for a short time to read shared variable
irq_state = machine.disable_irq()
if reed_switch.new_value_available:
reed_switch_value = reed_switch.value
reed_switch_new_value = True
reed_switch.new_value_available = False
machine.enable_irq(irq_state)
# If the reed switch had a new value, publish the new state
if reed_switch_new_value:
if reed_switch_value:
client.publish(STATE_TOPIC, "open")
else:
client.publish(STATE_TOPIC, "closed")
# Process any MQTT messages
if client.check_msg():
client.wait_msg()
time.sleep_ms(500)
finally:
client.publish(AVAILABILITY_TOPIC, "offline", retain=False)
client.disconnect()
machine.reset()
def callback(self,pin): irqs = machine.disable_irq() hasdata = self.mr() machine.enable_irq(irqs) if hasdata and not self.rxtimer: self.rxtimer = machine.Timer(1) self.rxtimer.init(mode=machine.Timer.ONE_SHOT, period=1,callback=self.real_decoder)
def start_killer():
global dog_started, dog_start_time, killed
state = machine.disable_irq()
dog_started = True
dog_start_time = ticks_ms()
killed = False
machine.enable_irq(state)
def read(self):
# wait for the device being ready
for _ in range(500):
if self.pOUT() == 0:
break
time.sleep_ms(1)
else:
raise OSError("Sensor does not respond")
# 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 my_callback(p):
interrupt_state = machine.disable_irq()
print('in interrupt')
time.sleep_ms(800)
print(11111)
machine.enable_irq(interrupt_state)
return
def stop_killer():
global dog_started, dog_start_time, killed
state = machine.disable_irq()
dog_started = False
dog_start_time = None
killed = False
machine.enable_irq(state)
def encbutprss(a):
global debouncetime, lastbouncetime, updatescreen, dispcursor, pnr, ticktock
irq_state = machine.disable_irq()
now = utime.ticks_ms()
if now - lastbouncetime > debouncetime and pnr == 0:
ticktock = utime.ticks_ms()
#killme.init(period=15000, mode=Timer.ONE_SHOT, callback=shutdown)
if Value0[dispcursor] == "off":
Value0[dispcursor] = "on"
if datatype[dispcursor] != 2:
Value1[dispcursor] = "100"
else:
Value0[dispcursor] = "off"
if datatype[dispcursor] != 2:
Value1[dispcursor] = "0"
updatemsg = {
"id": dispcursor,
"value0": Value0[dispcursor],
"value1": Value1[dispcursor]
}
updatemsgjson = ujson.dumps(updatemsg)
mqttobject.publish(secrets["topicpub"], updatemsgjson)
pnr = 0
lastbouncetime = now
updatescreen = 1
machine.enable_irq(irq_state)
def __collect_input(self):
# collect the data while unchanged found
unchanged_count = 0
# this is used to determine where is the end of the data
max_unchanged_count = 100
last = -1
data = []
m = bytearray(800) # needs long sample size to grab all the bits from the DHT # noqa
irqf = disable_irq()
self.__pin(1)
for i in range(len(m)):
m[i] = self.__pin() # sample input and store value
enable_irq(irqf)
for i in range(len(m)):
current = m[i]
data.append(current)
if last != current:
unchanged_count = 0
last = current
else:
unchanged_count += 1
if unchanged_count > max_unchanged_count:
break
# print(data)
return data
def btn_isr(self, pin):
state = machine.disable_irq()
self.debouncing = pin
self.debounce_timer.init(period=80,
mode=machine.Timer.ONE_SHOT,
callback=self.debounce)
machine.enable_irq(state)
def update_timer_counter():
global timer_counter
if event_list.head:
timer_counter_new = event_list.head.time_next - ticks_ms()
irq_state = machine.disable_irq()
timer_counter = timer_counter_new
machine.enable_irq(irq_state)
def main():
global sw_pressed
sw_pressed = None
SW_PRESS_INTERVAL = 250 * 1000 #250ms
SW_IRQ_TRIGGER = Pin.IRQ_FALLING
#SW1
sw1 = Pin(20, Pin.IN, Pin.PULL_UP)
#割り込みの設定
sw1.irq(trigger=SW_IRQ_TRIGGER, handler=callback)
ref_time = utime.ticks_us()
while True:
if sw_pressed:
# disable IRQ until get values
sw_state = machine.disable_irq()
sw_trigger = sw_pressed.irq().flags()
time_diff = utime.ticks_diff(utime.ticks_us(), ref_time)
# enable IRQ
machine.enable_irq(sw_state)
if( time_diff > SW_PRESS_INTERVAL ):
if sw_trigger == SW_IRQ_TRIGGER:
if sw_pressed == sw1:
print("sw1")
else:
pass
else:
pass # avoid chattering
sw_pressed = None
ref_time = utime.ticks_us()
def button_hdlr(_pin):
global last_press
state = machine.disable_irq()
if utime.time() - last_press > 1:
last_press = utime.time()
micropython.schedule(debounce_press, 0)
machine.enable_irq(state)
def main():
'''Main Event Loop'''
global interruptCounter, totalInterrupts, CUR_FORMULA, READY, GPIO_ODR, COL_INDEX, COL_TIME
# PINS REGISTERS
GPIO_REG = const(0x3ff44000)
GPIO_EN = const(0x8)
GPIO_CLR = const(0xC)
BIT21 = const(1 << 21) # 2097152
BIT14 = const(1 << 14) # 16384
BIT26 = const(1 << 26) # 67108864
BIT15 = const(1 << 15) # 32768
BIT25 = const(1 << 25) # 33554432
BIT27 = const(1 << 27) # 134217728
BIT12 = const(1 << 12) # 4096
BIT13 = const(1 << 13) # 8192
LEDS = [BIT21, BIT14, BIT26, BIT15, BIT25, BIT27, BIT12, BIT13]
_LED_PINS = [21, 14, 26, 15, 25, 27, 12, 13]
LED_PINS = [Pin(i, Pin.OUT, value=0) for i in _LED_PINS]
ALL_LEDS = const(237039616)
LED_COUNT = const(8)
GPIO_ODR = {
"REG": GPIO_REG,
"EN": GPIO_EN,
"CLR": GPIO_CLR,
"ALL_LEDS": ALL_LEDS,
"LED_COUNT": LED_COUNT
}
# Last Revolution Time
LAST_REV = 0
print("POVPi Ready")
display_status(9)
# Run Blynk in Thread
thread.stack_size(5 * 1024)
thread.start_new_thread(run_blynk, ())
# Startup Shadow
startup_shadow = {"display": "_LINE_", "enabled": True}
update_shadow(new_state=startup_shadow)
gc.collect()
while 1:
# Handle Interrupts
if interruptCounter > 0:
state = machine.disable_irq()
interruptCounter -= 1
machine.enable_irq(state)
time_delta = time.ticks_diff(time.ticks_cpu(), LAST_REV)
COL_TIME = int(time_delta / 360)
COL_INDEX = 0
LAST_REV = time.ticks_cpu()
totalInterrupts += 1
if READY and CUR_FORMULA:
if LAST_REV == 0:
LAST_REV = time.ticks_cpu()
if COL_INDEX < 90:
byte = CUR_FORMULA[COL_INDEX]
COL_INDEX = display(byte, COL_TIME, COL_INDEX, GPIO_REG, GPIO_EN,
GPIO_CLR, ALL_LEDS)
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 timeouta(self, t):
#print(t)
state = machine.disable_irq()
self.client.check_msg()
machine.enable_irq(state)
self.tim.init(period=self.timeout,
mode=Timer.ONE_SHOT,
callback=self.timeouta)
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 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 read_bit(self):
sleep_us = time.sleep_us
enable_irq = machine.enable_irq
pin = self.pin
pin(1) # half of the devices don't match CRC without this line
i = machine.disable_irq()
pin(0)
sleep_us(1)
pin(1)
sleep_us(1)
value = pin()
enable_irq(i)
sleep_us(40)
return value
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
# 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)
def disableIRQ(self):
self.irqState = machine.disable_irq() # Start of critical section