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 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 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)