def callback(p): global ytime global gtimemax global gtimemin if p.value(): ytime = utime.ticks_cpu() else: setdiff(utime.ticks_diff(utime.ticks_cpu(), ytime)) print(getdiff())
def _log(self, message, *args): """ Outputs a log message to stdout. """ if len(args)==0: print('[{}] '.format(utime.ticks_cpu()) + str(message)) else: print('[{}] {}'.format( utime.ticks_cpu(), str(message).format(*args) ))
def _udp_thread(self): """ UDP thread, reads data from the server and handles it. """ while not self.udp_stop: try: data, src = self.sock.recvfrom(1024) #print(data.decode('latin-1')) _token = data[1:3] _type = data[3] if _type == PUSH_ACK: self._log("Push ack") elif _type == PULL_ACK: self._log("Pull ack") elif _type == PULL_RESP: self.dwnb += 1 ack_error = TX_ERR_NONE tx_pk = ujson.loads(data[4:]) if "tmst" in data: tmst = tx_pk["txpk"]["tmst"] t_us = tmst - utime.ticks_cpu() - 15000 if t_us < 0: t_us += 0xFFFFFFFF if t_us < 20000000: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link( ubinascii.a2b_base64(tx_pk["txpk"][ "data"]), tx_pk["txpk"]["tmst"] - 50, tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000) * 1000), us=t_us) else: ack_error = TX_ERR_TOO_LATE self._log('Downlink timestamp error!, t_us: {}', t_us) else: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link_class_c( ubinascii.a2b_base64(tx_pk["txpk"]["data"]), tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000) * 1000), us=50) self._ack_pull_rsp(_token, ack_error) self._log("Pull rsp") except usocket.timeout: pass except OSError as ex: if ex.errno != errno.EAGAIN: self._log('UDP recv OSError Exception: {}', ex) except Exception as ex: self._log('UDP recv Exception: {}', ex) # wait before trying to receive again utime.sleep_ms(UDP_THREAD_CYCLE_MS) # we are to close the socket self.sock.close() self.udp_stop = False self._log('UDP thread stopped')
def __init__(self, screen_width, screen_height, size, display, color): """Initialize box. Args: screen_width (int): Width of screen. screen_height (int): Width of height. size (int): Square side length. display (ILI9341): display object. color (int): RGB565 color value. """ self.size = size self.w = screen_width self.h = screen_height self.display = display self.color = color # Generate non-zero random speeds between -5.0 and 5.0 seed(ticks_cpu()) r = random() * 10.0 self.x_speed = 5.0 - r if r < 5.0 else r - 10.0 r = random() * 10.0 self.y_speed = 5.0 - r if r < 5.0 else r - 10.0 self.x = self.w / 2.0 self.y = self.h / 2.0 self.prev_x = self.x self.prev_y = self.y
def get_random_bits(k): result = 0 for _ in range(k): time.sleep(0) result <<= 1 result = result | last_bit(utime.ticks_cpu()) return result
def handler(x): t_cpu = utime.ticks_cpu() self._log("_send_down_link alarm fired at {} late {}us",t_cpu,t_cpu-t_req) self._send_down_link( payload, tmst, tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000 + 0.0005) * 1000 )
def __init__(self): self.ow = onewire.OneWire(Pin(12)) # create a OneWire bus on GPIO12 self.ow.scan() # return a list of devices on the bus self.ow.reset() # reset the bus self.ds = ds18x20.DS18X20(self.ow) self.rtc = machine.RTC() self.rtc.irq(trigger=self.rtc.ALARM0, wake=machine.DEEPSLEEP) self.led = Pin(2, Pin.OUT) self.led.on() # led is inverted # seeding prng t1 = utime.ticks_cpu() self.get_temp() t2 = utime.ticks_cpu() urandom.seed(t2 - t1)
def _send_down_link(self, data, tmst, datarate, frequency): """ Transmits a downlink message over LoRa. """ self.lora.init( mode=LoRa.LORA, region=self.region, frequency=frequency, bandwidth=self._dr_to_bw(datarate), # LoRa.BW_125KHZ sf=self._dr_to_sf(datarate), preamble=8, coding_rate=LoRa.CODING_4_5, power_mode=LoRa.ALWAYS_ON, #tx_iq=True ) if WINDOW_COMPENSATION=='cycle': self.window_compensation = -((self.downlink_count % 25) * 1000) else: self.window_compensation = WINDOW_COMPENSATION t_adj = utime.ticks_add(tmst, self.window_compensation) self.lora_sock.settimeout(1) t_cpu = utime.ticks_cpu() self._log("BEFORE spin wait at {} late {}",t_cpu,t_cpu-tmst) while utime.ticks_diff(t_adj, utime.ticks_cpu()) > 0: pass t_cpu = utime.ticks_cpu() self._log("BEFORE lora_sock.send at {} late {} window_compensation {}",t_cpu,t_cpu-tmst,self.window_compensation) self.lora_sock.send(data) self._log("AFTER lora_sock.send late {}",utime.ticks_cpu()-tmst) self.lora_sock.setblocking(False) self._log( 'Sent downlink packet scheduled on {}, at {:,d} Hz using {}: {}', tmst, frequency, datarate, data ) self.downlink_count += 1
def test(canvas): """Bouncing box.""" try: clear() colors = [ lv_colors.RED, lv_colors.GREEN, lv_colors.BLUE, lv_colors.YELLOW, lv_colors.CYAN, lv_colors.MAGENTA ] # Generate non-zero random speeds between -5.0 and 5.0 seed(ticks_cpu()) x_speed = [] y_speed = [] for i in range(6): r = random() * 10.0 if r < 5: x_speed.append(r) else: x_speed.append(r - 10) r = random() * 10.0 if r < 5: y_speed.append(r) else: y_speed.append(r - 10) # print("speed_x: ",x_speed) sizes = [12, 11, 10, 9, 8, 7] boxes = [ Box(CANVAS_WIDTH, CANVAS_HEIGHT, sizes[i], canvas, x_speed[i], y_speed[i], colors[i]) for i in range(6) ] while True: timer = ticks_us() for b in boxes: b.update_pos() b.draw() # Attempt to set framerate to 30 FPS timer_dif = 33333 - ticks_diff(ticks_us(), timer) if timer_dif > 0: sleep_us(timer_dif) except KeyboardInterrupt: sys.exit()
def main(): ''' Main entry point ''' driver = LEDBTN() game = Simon(driver) print('Welcome Lights') game.welcome() while True: # Wait for keypress to start game driver.get_pressed() print('Game Start') game.fail_game() urandom.seed(time.ticks_cpu()) game.game_loop() print("Game finished, starting new game")
def _send_down_link(self, data, tmst, datarate, frequency): """ Transmits a downlink message over LoRa. """ self.lora.init(mode=LoRa.LORA, frequency=frequency, bandwidth=self._dr_to_bw(datarate), sf=self._dr_to_sf(datarate), preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True) while utime.ticks_cpu() < tmst: pass self.lora_sock.send(data) self._log( 'Sent downlink packet scheduled on {:.3f}, at {:.3f} Mhz using {}: {}', tmst / 1000000, self._freq_to_float(frequency), datarate, data)
def _send_down_link_class_c(self, data, datarate, frequency): self.lora.init( mode=LoRa.LORA, frequency=frequency, bandwidth=self._dr_to_bw(datarate), sf=self._dr_to_sf(datarate), preamble=8, coding_rate=LoRa.CODING_4_5, region=self.region, power_mode=LoRa.ALWAYS_ON, #tx_iq=True, device_class=LoRa.CLASS_C ) self.lora_sock.send(data) self._log( 'Sent downlink packet scheduled on {}, at {:.3f} Mhz using {}: {}', utime.ticks_cpu(), self._freq_to_float(frequency), datarate, data )
SENS = SENS - SENSi OFF = OFF - OFFi Pres = (raw_d1 * SENS / 2097152 - OFF) / 3276800 # barometric pressure # Temp = Temp / 100 fTemp = (Temp * 9 / 5) + 32 print('Temp = ', '%.1fC' % Temp) print('Temp = ', '%.1fF' % fTemp) print('Pressure = ', '%.1f ' % Pres) except: print('ms5837 read failed') # build ms5837 sensor data payload try: time_snapshot = str(utime.ticks_cpu()) #print_TH = "T9602:" + time_snapshot + ":Humidity:" + str(t96h) + "%:Temp:" + str(fTemp) + "F:#" #T9602 humidity and temp print_PT = "MS5837:" + time_snapshot + ":Press:" + str( Pres) + "mB:Temp:" + str(fTemp) + "F:#" # MS5837 sensor payload print(print_PT) except: print("sensor payload build failed") #transmit Temp Humidity data over Zigbee to coordinator try: xbee.transmit(TARGET_64BIT_ADDR, print_PT) #xbee.transmit(ROUTER_64BIT_x1B2D, print_TH) print("send data to coordinator") except: print("xbee coordinator transmit failed")
def run(): seed(ticks_cpu()) lcd.setRotation(3) Snake.timer.init(period=Snake.speed, mode=Timer.PERIODIC, callback=Snake.move)
def _udp_thread(self): """ UDP thread, reads data from the server and handles it. """ loops = 0 while not self.udp_stop: if loops % 20 == 19: b4 = utime.ticks_cpu() gc.collect() self._log("gc.collect for {} us",utime.ticks_diff(utime.ticks_cpu(),b4)) b4 = utime.ticks_cpu() utime.sleep_ms(UDP_THREAD_CYCLE_MS) t_diff = utime.ticks_diff(utime.ticks_cpu(),b4) if t_diff > (UDP_THREAD_CYCLE_MS*1000*1.5): self._log("overslept! for {} us",t_diff) try: b4 = utime.ticks_cpu() data, src = self.sock.recvfrom(1024) self._log("sock.recvfrom for {} us",utime.ticks_diff(utime.ticks_cpu(),b4)) _token = data[1:3] _type = data[3] if _type == PUSH_ACK: self._log("Push ack") elif _type == PULL_ACK: self._log("Pull ack") elif _type == PULL_RESP: self._log("Pull resp") self.dwnb += 1 ack_error = TX_ERR_NONE tx_pk = ujson.loads(data[4:]) if DEBUG: self._log("tx data "+ujson.dumps(tx_pk)) payload = ubinascii.a2b_base64(tx_pk["txpk"]["data"]) # depending on the board, pull the downlink message 1 or 6 ms upfronnt # tmst = utime.ticks_add(tx_pk["txpk"]["tmst"], self.window_compensation) # t_us = utime.ticks_diff(utime.ticks_cpu(), utime.ticks_add(tmst, -15000)) tmst = tx_pk["txpk"]["tmst"] t_req = utime.ticks_add(tmst, -RX_DELAY_TIMER_EARLY) t_cpu = utime.ticks_cpu() self._log("t_cpu {}",t_cpu) t_us = utime.ticks_diff(t_req, t_cpu) self._log("t_us {}",t_us) if 1000 < t_us < 10000000: self._log("Delaying for {} at {}, so should fire at t_req {}, compensated early_by {}",t_us,t_cpu,t_req,RX_DELAY_TIMER_EARLY) def handler(x): t_cpu = utime.ticks_cpu() self._log("_send_down_link alarm fired at {} late {}us",t_cpu,t_cpu-t_req) self._send_down_link( payload, tmst, tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000 + 0.0005) * 1000 ) self.uplink_alarm = Timer.Alarm(handler=handler, us=t_us) else: ack_error = TX_ERR_TOO_LATE self._log('Downlink timestamp error!, t_us: {}', t_us) self._ack_pull_rsp(_token, ack_error) self._log("Pull rsp") except usocket.timeout: pass except OSError as ex: if ex.args[0] != errno.EAGAIN: self._log('UDP recv OSError Exception: {}', ex) except Exception as ex: self._log('UDP recv Exception: {}', ex) # we are to close the socket self.sock.close() self.udp_stop = False self._log('UDP thread stopped')
def callback(p): global START, END, ticks_cpu if START == 0: START = ticks_cpu() else: END = ticks_cpu()
import utime try: utime.sleep_ms except AttributeError: print("SKIP") raise SystemExit utime.sleep_ms(1) utime.sleep_us(1) t0 = utime.ticks_ms() t1 = utime.ticks_ms() print(0 <= utime.ticks_diff(t1, t0) <= 1) t0 = utime.ticks_us() t1 = utime.ticks_us() print(0 <= utime.ticks_diff(t1, t0) <= 500) # ticks_cpu may not be implemented, at least make sure it doesn't decrease t0 = utime.ticks_cpu() t1 = utime.ticks_cpu() print(utime.ticks_diff(t1, t0) >= 0)
def _lora_cb(self, lora): """ LoRa radio events callback handler. """ events = lora.events() if events & LoRa.RX_PACKET_EVENT: self.rxnb += 1 self.rxok += 1 rx_data = self.lora_sock.recv(256) stats = lora.stats() if DEBUG: self._log("stats "+ujson.dumps(stats)) self._log('rx_timestamp diff: {}', utime.ticks_diff(stats.rx_timestamp,utime.ticks_cpu())) packet = self._make_node_packet(rx_data, self.rtc.now(), stats.rx_timestamp, stats.sfrx, self.bw, stats.rssi, stats.snr) packet = self.frequency_rounding_fix(packet, self.frequency) self._log('Received and uploading packet: {}', packet) self._push_data(packet) self._log('after _push_data') self.rxfw += 1 if events & LoRa.TX_PACKET_EVENT: self.txnb += 1 lora.init( mode=LoRa.LORA, region=self.region, frequency=self.frequency, bandwidth=self.bw, sf=self.sf, preamble=8, coding_rate=LoRa.CODING_4_5, power_mode=LoRa.ALWAYS_ON, #tx_iq=True )