def play_show(tune, pin=27, display=matrix.display, duration=None): from machine import Pin, PWM from utime import sleep_ms try: pwm = PWM(Pin(pin)) if duration is None: set_default(tune[0]) else: set_duration(duration) for tone in tune: tone = tone.upper() # all to upper if tone[0] not in Letter: continue if len(tone)==4: display.showstatic(tone.replace(":","")) else: display.showstatic(tone) m = midi(tone) pwm.freq(m[0]) # set frequency pwm.duty(m[1]) # set duty cycle sleep_ms(m[1]) display.clear() finally: pwm.deinit()
def connect(self, timeout=10000): self.wifi.active(True) self.wifi.connect(self.wifi_ssid, self.wifi_password) # -- wait until connected tmo = timeout/100 while not self.wifi.isconnected(): utime.sleep_ms(100) tmo -= 1 if tmo == 0: print(Feedback.ERR_TIMEOUT_WIFI) return False # -- start mqtt if self.mqtt.status()[0] == 0: self.mqtt.start() tmo = timeout / 100 while not self.mqtt.status()[0] == 2: utime.sleep_ms(100) tmo -= 1 if tmo == 0: print(Feedback.ERR_TIMEOUT_MQTT) return False return True
def stop(self): """ Stops the LoRaWAN nano gateway. """ self._log('Stopping...') # send the LoRa radio to sleep self.lora.callback(trigger=None, handler=None) self.lora.power_mode(LoRa.SLEEP) # stop the NTP sync self.rtc.ntp_sync(None) # cancel all the alarms self.stat_alarm.cancel() self.pull_alarm.cancel() # signal the UDP thread to stop self.udp_stop = True while self.udp_stop: utime.sleep_ms(50) # disable WLAN self.wlan.disconnect() self.wlan.deinit()
def __init__(self, i2c, addr=0x77): self.i2c = i2c self.addr = addr self.chip_id = self.i2c.readfrom_mem(self.addr, 0xD0, 2) # read calibration data from EEPROM self._AC1 = unp('>h', self.i2c.readfrom_mem(self.addr, 0xAA, 2))[0] self._AC2 = unp('>h', self.i2c.readfrom_mem(self.addr, 0xAC, 2))[0] self._AC3 = unp('>h', self.i2c.readfrom_mem(self.addr, 0xAE, 2))[0] self._AC4 = unp('>H', self.i2c.readfrom_mem(self.addr, 0xB0, 2))[0] self._AC5 = unp('>H', self.i2c.readfrom_mem(self.addr, 0xB2, 2))[0] self._AC6 = unp('>H', self.i2c.readfrom_mem(self.addr, 0xB4, 2))[0] self._B1 = unp('>h', self.i2c.readfrom_mem(self.addr, 0xB6, 2))[0] self._B2 = unp('>h', self.i2c.readfrom_mem(self.addr, 0xB8, 2))[0] self._MB = unp('>h', self.i2c.readfrom_mem(self.addr, 0xBA, 2))[0] self._MC = unp('>h', self.i2c.readfrom_mem(self.addr, 0xBC, 2))[0] self._MD = unp('>h', self.i2c.readfrom_mem(self.addr, 0xBE, 2))[0] # settings to be adjusted by user self.oversample_setting = 3 self.baseline = 101325.0 # output raw self.UT_raw = None self.B5_raw = None self.MSB_raw = None self.LSB_raw = None self.XLSB_raw = None self.gauge = self.makegauge() # Generator instance for _ in range(128): next(self.gauge) utime.sleep_ms(1)
def disconnect(self, timeout=5000): self.mqtt.stop() tmo = timeout / 100 while not self.mqtt.status()[0] == 0: utime.sleep_ms(100) tmo -= 1 if tmo == 0: print(Feedback.ERR_TIMEOUT_MQTT) return False if self.wifi.isconnected(): self.wifi.disconnect() tmo = timeout / 100 while self.wifi.isconnected(): utime.sleep_ms(100) tmo -= 1 if tmo == 0: print(Feedback.ERR_TIMEOUT_WIFI) return False self.wifi.active(False) return True
def angle(self, to_angle, speed=None, *servo_ids): if len(servo_ids) == 0: servo_ids = ServoJewel.ALL if speed is None: for s in servo_ids: self.servos[s].angle(to_angle) else: longest_range = 0 ranges = {} for s in servo_ids: from_angle = self.servos[s].angle() if from_angle < to_angle: ranges[s] = list(range(int(from_angle), to_angle + 5, 5)) else: ranges[s] = list(range(int(from_angle), to_angle - 5, -5)) if longest_range < len(ranges[s]): longest_range = len(ranges[s]) for i in range(0, longest_range): for s in servo_ids: if i >= len(ranges[s]): continue self.servos[s].angle(ranges[s][i]) utime.sleep_ms(speed)
def calibrate(self,count=256,delay=200): self._offset=(0,0,0) self._scale=(1,1,1) reading=self.magnetic minx=maxx=reading[0] miny=maxy=reading[1] minz=maxz=reading[2] while count: utime.sleep_ms(delay) reading=self.magnetic minx=min(minx,reading[0]) maxx=max(maxx,reading[0]) miny=min(miny,reading[1]) maxy=max(maxy,reading[1]) minz=min(minz,reading[2]) maxz=max(maxz,reading[2]) count-=1 offset_x=(maxx+minx)/2 offset_y=(maxy+miny)/2 offset_z=(maxz+minz)/2 self._offset=(offset_x,offset_y,offset_z) avg_delta_x=(maxx-minx)/2 avg_delta_y=(maxy-miny)/2 avg_delta_z=(maxz-minz)/2 avg_delta=(avg_delta_x+avg_delta_y+avg_delta_z)/3 scale_x=avg_delta/avg_delta_x scale_y=avg_delta/avg_delta_y scale_z=avg_delta/avg_delta_z self._scale=(scale_x,scale_y,scale_z) return self._offset,self._scale
def show(self,data,delay=200,time=400): self.fill(0) if type(data)==str: DISPLAY_WIDTH=16 DISPLAY_HEIGHT=8 matrix=Display(i2c) def matrix_pixel(x,y): matrix._pixel(x,y,1) with BitmapFont(DISPLAY_WIDTH,DISPLAY_HEIGHT,matrix_pixel)as bf: for msg in data: matrix.clear() pos=DISPLAY_WIDTH message_width=bf.width(msg) bf.text(msg,5,0) matrix._show() if len(data)>1: utime.sleep_ms(delay) elif type(data)==int: pass elif type(data)==type(Image.HEART): l=data.str.split(':') for i in range(8): for j in range(16): if l[i][j]=='1': self._pixel(j,i,1) else: self._pixel(j,i,0) self._show()
def play(): # # pack of cards # select N from pack of cards for i in range(0, len(Master_Pack)): Pack.append(Master_Pack[i]) deal(Number_of_cards_to_deal) #print("Remaining: ", Pack) #print("Selected: ", SelectedCards) N = len(SelectedCards) M = 0 Score = 0 print("") print("Welcome to MicroPython Play your Cards Right") print("============================================") while M < (N-1): #print("Turn: ", M) if turn(M): Score = Score + 1 #print("Score: ", Score) M += 1 utime.sleep_ms(2000) # move to next card... print("Score: ", Score, "out of ", N-1) # Tidy Up for i in range(0, N): del SelectedCards[0] for i in range(0,len(Pack)): del Pack[0] utime.sleep_ms(1000) red.off() grn.off() yel.on() print("Bye")
def show(self, data, delay=200, time=400): self.fill(0) if type(data)==str: DISPLAY_WIDTH = 16 # Display width in pixels. DISPLAY_HEIGHT = 8 # Display height in pixels. # Initialize LED matrix. matrix = Display(i2c) #matrix.clear() # Initialize font renderer using a helper function to flip the Y axis # when rendering so the origin is in the upper left. def matrix_pixel(x, y): matrix._pixel(x, y, 1) with BitmapFont(DISPLAY_WIDTH, DISPLAY_HEIGHT, matrix_pixel) as bf: # Global state: for msg in data: matrix.clear() pos = DISPLAY_WIDTH # X position of the message start. message_width = bf.width(msg) # Message width in pixels. bf.text(msg, 5, 0) #change X position matrix._show() if len(data)>1: utime.sleep_ms(delay) elif type(data)==int: pass elif type(data)==type(Image.HEART): # print("Image") l = data.str.split(':') for i in range(8): for j in range(16): if l[i][j] == '1': self._pixel(j, i, 1) else: self._pixel(j, i, 0) #print(l[i][j]) self._show()
def slave(): nrf = NRF24L01(SPI(2), Pin('Y5'), Pin('Y4'), payload_size=8) nrf.open_tx_pipe(pipes[1]) nrf.open_rx_pipe(1, pipes[0]) nrf.start_listening() print('NRF24L01 slave mode, waiting for packets... (ctrl-C to stop)') while True: machine.idle() if nrf.any(): while nrf.any(): buf = nrf.recv() millis, led_state = struct.unpack('ii', buf) print('received:', millis, led_state) for led in leds: if led_state & 1: led.on() else: led.off() led_state >>= 1 utime.sleep_ms(15) nrf.stop_listening() try: nrf.send(struct.pack('i', millis)) except OSError: pass print('sent response') nrf.start_listening()
def blinkIt(): pin2 = machine.Pin(2, machine.Pin.OUT) for loopCount in range(10): pin2.value(1) utime.sleep_ms(500) pin2.value(0) utime.sleep_ms(500) print("hello")
def master(): csn = Pin(cfg['csn'], mode=Pin.OUT, value=1) ce = Pin(cfg['ce'], mode=Pin.OUT, value=0) if cfg['spi'] == -1: spi = SPI(-1, sck=Pin(cfg['sck']), mosi=Pin(cfg['mosi']), miso=Pin(cfg['miso'])) nrf = NRF24L01(spi, csn, ce, payload_size=8) else: nrf = NRF24L01(SPI(cfg['spi']), csn, ce, payload_size=8) nrf.open_tx_pipe(pipes[0]) nrf.open_rx_pipe(1, pipes[1]) nrf.start_listening() num_needed = 16 num_successes = 0 num_failures = 0 led_state = 0 print('NRF24L01 master mode, sending %d packets...' % num_needed) while num_successes < num_needed and num_failures < num_needed: # stop listening and send packet nrf.stop_listening() millis = utime.ticks_ms() led_state = max(1, (led_state << 1) & 0x0f) print('sending:', millis, led_state) try: nrf.send(struct.pack('ii', millis, led_state)) except OSError: pass # start listening again nrf.start_listening() # wait for response, with 250ms timeout start_time = utime.ticks_ms() timeout = False while not nrf.any() and not timeout: if utime.ticks_diff(utime.ticks_ms(), start_time) > 250: timeout = True if timeout: print('failed, response timed out') num_failures += 1 else: # recv packet got_millis, = struct.unpack('i', nrf.recv()) # print response and round-trip delay print('got response:', got_millis, '(delay', utime.ticks_diff(utime.ticks_ms(), got_millis), 'ms)') num_successes += 1 # delay then loop utime.sleep_ms(250) print('master finished sending; successes=%d, failures=%d' % (num_successes, num_failures))
def run(self): while True: iteration_start = utime.ticks_ms() self.perform_tasks() time_spent_on_tasks = utime.ticks_diff(utime.ticks_ms(), iteration_start) if time_spent_on_tasks < self.sleep_ms: utime.sleep_ms(utime.ticks_diff(self.sleep_ms, time_spent_on_tasks)) else: logger.warning('Skipping sleep - spent {}ms on tasks'.format(time_spent_on_tasks))
def pwm_cycle(led, duty, cycles): duty_off = 20 - duty for i in range(cycles): if duty: led.on() utime.sleep_ms(duty) if duty_off: led.off() utime.sleep_ms(duty_off)
def blink(self, *eye_ids): if len(eye_ids) == 0: eye_ids = [0, 1] for m in Eyes.BLINK_MASK: for i in eye_ids: self.matrices.mask[i] = m utime.sleep_ms(50)
def iflush(self): t = 5000 while t: self.i2c.readfrom_into(self.i2c_addr, self.buf16) if self.buf16[0] == 0: return t -= 1 sleep_ms(1) raise OSError(uerrno.ETIMEDOUT)
def say_hello_right(self): self.lean_to_right(ServoJewel.SPEED_SLOW) for i in range(0, 3): self.servos.step_angle(120, ServoJewel.SPEED_SLOW, self.left_ankle) utime.sleep_ms(50) self.servos.step_angle(60, ServoJewel.SPEED_SLOW, self.left_ankle) utime.sleep_ms(50) self.undo_lean_to_right(ServoJewel.SPEED_SLOW)
def say_hello_left(self): self.lean_to_left(ServoJewel.SPEED_SLOW) for i in range(0, 3): self.servos.angle(MAX, ServoJewel.SPEED_SLOW, self.right_ankle) utime.sleep_ms(50) self.servos.angle(MIN, ServoJewel.SPEED_SLOW, self.right_ankle) utime.sleep_ms(50) self.undo_lean_to_left(ServoJewel.SPEED_SLOW)
def _waitfor(self, n, buf): t = 5000 while t: self.i2c.readfrom_into(self.i2c_addr, self.buf1) if self.buf1[0] >= n: self.i2c.readfrom_into(self.i2c_addr, buf) return t -= 1 sleep_ms(1) raise OSError(uerrno.ETIMEDOUT)
def pitch(freq,pin=27,tim=1000): from machine import Pin,PWM from utime import sleep_ms try: pwm=PWM(Pin(pin)) pwm.freq(freq) pwm.duty(tim) sleep_ms(tim) finally: pwm.deinit()
def start(self): """ Starts the LoRaWAN nano gateway. """ self._log('Starting LoRaWAN nano gateway with id: {}', self.id) # setup WiFi as a station and connect self.wlan = WLAN(mode=WLAN.STA) self._connect_to_wifi() # get a time sync self._log('Syncing time with {} ...', self.ntp_server) self.rtc.ntp_sync(self.ntp_server, update_period=self.ntp_period) while not self.rtc.synced(): utime.sleep_ms(50) self._log("RTC NTP sync complete") # get the server IP and create an UDP socket self.server_ip = usocket.getaddrinfo(self.server, self.port)[0][-1] self._log('Opening UDP socket to {} ({}) port {}...', self.server, self.server_ip[0], self.server_ip[1]) self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.IPPROTO_UDP) self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1) self.sock.setblocking(False) # push the first time immediatelly self._push_data(self._make_stat_packet()) # create the alarms self.stat_alarm = Timer.Alarm(handler=lambda t: self._push_data(self._make_stat_packet()), s=60, periodic=True) self.pull_alarm = Timer.Alarm(handler=lambda u: self._pull_data(), s=25, periodic=True) # start the UDP receive thread self.udp_stop = False _thread.start_new_thread(self._udp_thread, ()) # initialize the LoRa radio in LORA mode self._log('Setting up the LoRa radio at {:.1f} Mhz using {}', self._freq_to_float(self.frequency), self.datarate) self.lora = LoRa( mode=LoRa.LORA, frequency=self.frequency, bandwidth=self.bw, sf=self.sf, preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True ) # create a raw LoRa socket self.lora_sock = usocket.socket(usocket.AF_LORA, usocket.SOCK_RAW) self.lora_sock.setblocking(False) self.lora_tx_done = False self.lora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=self._lora_cb) self._log('LoRaWAN nano gateway online')
def pitch(self,pin=27,freq=440,tim=0): from machine import Pin,PWM from utime import sleep_ms pwm=PWM(Pin(pin)) if freq>0: pwm.freq(int(freq)) else: pwm.duty(0) if tim>0: sleep_ms(tim) pwm.deinit()
def get_pixel(self, x, y): self._fcmd2b('<BBBB', 0x61, x, y) t = 1000 while t: self.i2c.readfrom_into(self.i2c_addr, self.buf1) if self.buf1[0] >= 2: self.i2c.readfrom_into(self.i2c_addr, self.buf[3]) return self.buf[3][1] + self.buf[3][2] << 8 t -= 1 sleep_ms(1) raise OSError(uerrno.ETIMEDOUT)
def hal_write_command(self, cmd): """Writes a command to the LCD. Data is latched on the falling edge of E. """ self.rs_pin.value(0) self.hal_write_8bits(cmd) if cmd <= 3: # The home and clear commands require a worst # case delay of 4.1 msec sleep_ms(5)
def recv(self, blocking=False): while blocking: sleep_ms(200) r = self.conn.recv(1024) if r is not None: return r try: sleep_ms(35) return self.conn.recv(1024) except: pass
def shake_right(self): self.lean_to_right(ServoJewel.SPEED_SLOW) for i in range(0, 3): self.servos.step_angle(120, ServoJewel.SPEED_FAST, self.left_hip) utime.sleep_ms(50) self.servos.step_angle(60, ServoJewel.SPEED_FAST, self.left_hip) utime.sleep_ms(50) self.servos.step_angle(90, ServoJewel.SPEED_FAST, self.left_hip) self.undo_lean_to_right(ServoJewel.SPEED_SLOW)
def _send(self, cmd): i = self.i2c.writeto(self.i2c_addr, cmd) if i == len(cmd): return cmd = memoryview(cmd) n = len(cmd) while True: i += self.i2c.writeto(self.i2c_addr, cmd[i:]) if i == n: return sleep_ms(10)
def shake_left(self): self.lean_to_left(ServoJewel.SPEED_SLOW) for i in range(0, 3): self.servos.angle(MAX, ServoJewel.SPEED_FAST, self.right_hip) utime.sleep_ms(50) self.servos.angle(MIN, ServoJewel.SPEED_FAST, self.right_hip) utime.sleep_ms(50) self.servos.angle(CENTER, ServoJewel.SPEED_FAST, self.right_hip) self.undo_lean_to_left(ServoJewel.SPEED_SLOW)
def get_line(self, x, y, buf): l = len(buf) // 2 self._fcmd2b('<BBBBB', 0x10, l, x, y) t = 1000 while t: self.i2c.readfrom_into(self.i2c_addr, self.buf1) if self.buf1[0] >= l: self.i2c.readfrom_into(self.i2c_addr, buf) return t -= 1 sleep_ms(1) raise OSError(uerrno.ETIMEDOUT)
i = 0 # Process button event v = buttons.read(buttons.BOTTOM_LEFT | buttons.BOTTOM_RIGHT | buttons.TOP_RIGHT) if v == 0: button_pressed = False if not button_pressed and v & buttons.BOTTOM_LEFT != 0: button_pressed = True event_nb -= 1 if event_nb < 0: event_nb = 0 offset = 0 i = -7 if not button_pressed and v & buttons.BOTTOM_RIGHT != 0: button_pressed = True event_nb += 1 if event_nb >= len_events: event_nb = len_events - 1 offset = 0 i = -7 if not button_pressed and v & buttons.TOP_RIGHT != 0: button_pressed = True event_nb = compute_next_event_nb(events) offset = 0 i = -7 utime.sleep_ms(10)
def run(): playtestcounter = 0 slotTriggered = None print("Monitoring Slots") while True: if slotTriggered is not None and playtestcounter >= playtestfrequency: playtestcounter = 0 if not player.playing(): slotTriggered = None playtestcounter += 1 slotsUncovered = io.input_pins(inPins) if False in slotsUncovered: firstCovered = slotsUncovered.index(False) if firstCovered != slotTriggered: slotTriggered = firstCovered print("{} coin".format(firstCovered)) if slotTriggered in player.tracks: print("{} play".format(firstCovered)) player.playNext(slotTriggered) # workaround for scanplayer which resets volume sleep_ms(2000) # TODO can this be removed? Belt and braces player.awaitvolume() player.volume(1.0) run()
def ping(host, count=4, timeout=5000, interval=10, quiet=False, size=64): import utime import uselect import uctypes import usocket import ustruct import urandom # prepare packet assert size >= 16, "pkt size too small" pkt = b'Q' * size pkt_desc = { "type": uctypes.UINT8 | 0, "code": uctypes.UINT8 | 1, "checksum": uctypes.UINT16 | 2, "id": uctypes.UINT16 | 4, "seq": uctypes.INT16 | 6, "timestamp": uctypes.UINT64 | 8, } # packet header descriptor h = uctypes.struct(uctypes.addressof(pkt), pkt_desc, uctypes.BIG_ENDIAN) h.type = 8 # ICMP_ECHO_REQUEST h.code = 0 h.checksum = 0 h.id = urandom.randint(0, 65535) h.seq = 1 # init socket sock = usocket.socket(usocket.AF_INET, usocket.SOCK_RAW, 1) sock.setblocking(0) sock.settimeout(timeout / 1000) addr = usocket.getaddrinfo(host, 1)[0][-1][0] # ip address sock.connect((addr, 1)) not quiet and print("PING %s (%s): %u data bytes" % (host, addr, len(pkt))) seqs = list(range(1, count + 1)) # [1,2,...,count] c = 1 t = 0 n_trans = 0 n_recv = 0 finish = False while t < timeout: if t == interval and c <= count: # send packet h.checksum = 0 h.seq = c h.timestamp = utime.ticks_us() h.checksum = checksum(pkt) if sock.send(pkt) == size: n_trans += 1 t = 0 # reset timeout else: seqs.remove(c) c += 1 # recv packet while 1: socks, _, _ = uselect.select([sock], [], [], 0) if socks: resp = socks[0].recv(4096) resp_mv = memoryview(resp) h2 = uctypes.struct(uctypes.addressof(resp_mv[20:]), pkt_desc, uctypes.BIG_ENDIAN) # TODO: validate checksum (optional) seq = h2.seq if h2.type == 0 and h2.id == h.id and ( seq in seqs): # 0: ICMP_ECHO_REPLY t_elasped = (utime.ticks_us() - h2.timestamp) / 1000 ttl = ustruct.unpack('!B', resp_mv[8:9])[0] # time-to-live n_recv += 1 not quiet and print( "%u bytes from %s: icmp_seq=%u, ttl=%u, time=%f ms" % (len(resp), addr, seq, ttl, t_elasped)) seqs.remove(seq) if len(seqs) == 0: finish = True break else: break if finish: break utime.sleep_ms(1) t += 1 # close sock.close() ret = (n_trans, n_recv) not quiet and print("%u packets transmitted, %u packets received" % (n_trans, n_recv)) return (n_trans, n_recv)
import machine import utime servo = machine.PWM(machine.Pin(15)) servo.freq(50) def interval_mapping(x, in_min, in_max, out_min, out_max): return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min def servo_write(pin, angle): pulse_width = interval_mapping(angle, 0, 180, 0.5, 2.5) duty = int(interval_mapping(pulse_width, 0, 20, 0, 65535)) pin.duty_u16(duty) while True: for angle in range(180): servo_write(servo, angle) utime.sleep_ms(20) for angle in range(180, -1, -1): servo_write(servo, angle) utime.sleep_ms(20)
thub = SmartHub() thub.connect() steer_trim = PBMotor("D") thumb_trigger = PBMotor("C") force_sensor = port.B.device light_sensor = port.A.device light_sensor.mode((2, 0)) # Ambient, Return Pct (0-100) # roll0=motion.yaw_pitch_roll()[2] while thub.is_connected() and not (button.center.is_pressed()): trim = steer_trim.angle() * 4 # check rotation of the steering wheel with gyro roll steer_angle = motion.yaw_pitch_roll()[2] * 1.0 # Check flappy paddles # Returns about 0 if both are pressed or released # Returns a positive number if the force sensor is pressed speed = force_sensor.get()[0] * 12 - (light_sensor.get()[0] - 40) * 2 thub.dc(1, speed - steer_angle) sleep_ms(10) thub.dc(2, -speed - steer_angle) sleep_ms(10) thub.dc(1, 0) thub.dc(2, 0) thub.disconnect() raise SystemExit
codes = ir.read() # read IR code if len(codes) > 0 and codes[0] in keys: code = codes[0] print(code, keys[code]) if code != '0': prev_key = keys[code] key = prev_key if key == 'UP': value = rgb[color] rgb[color] = min(value + 8, 255) elif key == 'DOWN': value = rgb[color] rgb[color] = max(value - 8, 0) elif key == 'HOME': rgb = 3 * [0] color = 0 elif key in ['0', '1', '2']: color = int(key) elif key == 'POWER': break np[0] = tuple(rgb) np.write() time.sleep_ms(100) except KeyboardInterrupt: pass finally: ir.deinit() np[0] = (0, 0, 0) np.write() print('Done')
import machine import utime # Creado por Daniel Alvarez ([email protected]) para curso de Python de EOI (eoi.es) led = machine.Pin(2, machine.Pin.OUT) # inicializamos otro pin, esta vez el 0 que es donde esta conectado el boton, y en modo entrada (IN) boton = machine.Pin( 0, machine.Pin.IN ) # cambiar IN por PULL_UP para activar resistencia de pull-up while True: # bucle infinito # NOTA tal y como esta conectado el boton, pondra la linea a 0v si se pulsa y 3,3v si se libera estado_boton = boton.value() # devuelve 0 si esta a 0v, o 1 si esta a 3,3v led.value( estado_boton ) # hacemos que el led se encienda o apague funcion del estado del boton # recordamos nuevamente que por la conexion del boton a la placa, trabajamos con logica negativa (al reves de lo "logico") if estado_boton: print("- boton liberado") else: print("X boton pulsado") utime.sleep_ms(100) # hacemos una pausa para poder ver los prints
def reset(self): self.i2c_buffer[0] = RESET self.i2c_write(self.i2c_buffer) utime.sleep_ms(50)
''' @Author: Baron @Date: 2020-06-17 @LastEditTime: 2020-06-17 17:06:08 @Description: example for module utime @FilePath: example_utime_sleep_file.py ''' import utime import log # 设置日志输出级别 log.basicConfig(level=log.INFO) time_log = log.getLogger("Sleep") for i in [0, 1, 2, 3, 4, 5]: utime.sleep(1) # 休眠(单位 m) time_log.info(i) for i in [0, 1, 2, 3, 4, 5]: utime.sleep_ms(1000) # 休眠(单位 ms) time_log.info(i)
def open_slowly(self): '''缓慢释放夹子''' for angle in range(100, 150, 1): self.grab(angle=angle) utime.sleep_ms(20)
from machine import Pin, I2C import utime # Creado por Daniel Alvarez ([email protected]) para curso de Python de EOI (eoi.es) i2c = I2C( 1, sda=Pin(26), scl=Pin(32), freq=400000) # instanciamos y configuramos bus I2C en los pines sda y scl dispositivos_conectado = i2c.scan( ) # manda mensajes por el bus i2c a todas las direcciones para ver que dispositivos contestan # devuelve un listado de dispositivos conectados print( dispositivos_conectado ) # NOTA las direcciones las muestra en decimal, normalmente usaremos hexadecimal para trabajar con el i2c from apds9930 import APDS9930 sensor = APDS9930( i2c) # creamos una instancia del sensor y le pasamos el manejador del i2c # el manejador del i2c lo creamos aqui porque si tenemos varios sensores en el bus, le pasamos el mismo manejador a todos sensor.activar_proximidad( ) # este metodo modifica un registro interno del APDS9930 para activar el sensor de proximidad print("Acerca la mano al sensor para activarlo") while True: proximidad = sensor.get_proximidad() if proximidad is not 0: print("Activado! lectura {}".format(proximidad)) utime.sleep_ms(100) # para que no sature la consola con prints
def out(self, freq=0, tim=0): self.pwm.freq(freq) self.pwm.duty(tim) sleep_ms(tim)
def start(self): """ Starts the LoRaWAN nano gateway. """ self._log('Starting LoRaWAN nano gateway with id: {}', self.id) # setup WiFi as a station and connect self.wlan = WLAN(mode=WLAN.STA) self._connect_to_wifi() # get a time sync self._log('Syncing time with {} ...', self.ntp_server) self.rtc.ntp_sync(self.ntp_server, update_period=self.ntp_period) while not self.rtc.synced(): utime.sleep_ms(50) self._log("RTC NTP sync complete") # get the server IP and create an UDP socket self.server_ip = usocket.getaddrinfo(self.server, self.port)[0][-1] self._log('Opening UDP socket to {} ({}) port {}...', self.server, self.server_ip[0], self.server_ip[1]) self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.IPPROTO_UDP) self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1) self.sock.setblocking(False) # push the first time immediatelly self._push_data(self._make_stat_packet()) # create the alarms self.stat_alarm = Timer.Alarm( handler=lambda t: self._push_data(self._make_stat_packet()), s=60, periodic=True) self.pull_alarm = Timer.Alarm(handler=lambda u: self._pull_data(), s=25, periodic=True) # start the UDP receive thread self.udp_stop = False _thread.start_new_thread(self._udp_thread, ()) # initialize the LoRa radio in LORA mode self._log('Setting up the LoRa radio at {:.1f} Mhz using {}', self._freq_to_float(self.frequency), self.datarate) self.lora = LoRa(mode=LoRa.LORA, frequency=self.frequency, bandwidth=self.bw, sf=self.sf, preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True) # create a raw LoRa socket self.lora_sock = usocket.socket(usocket.AF_LORA, usocket.SOCK_RAW) self.lora_sock.setblocking(False) self.lora_tx_done = False self.lora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=self._lora_cb) self._log('LoRaWAN nano gateway online')
import machine import utime pin0 = machine.Pin(0, machine.Pin.OUT) pin2 = machine.Pin(2, machine.Pin.OUT) while True: for i in range(0, 10): pin0.off() pin2.on() utime.sleep_ms(60) pin0.on() pin2.off() utime.sleep_ms(60) pin0.on() pin2.on() utime.sleep_ms(500)
def default_wait(): ''' delay of 50 ms ''' sleep_ms(50)
print("---------------------------------------------------------------------") print("| Module HC-06 configuration |") print("| enter AT -- To test serial communication |") print("| enter AT+NAME?????? -- To modify the module name |") print("| enter AT+PIN???? -- To modify the module PIN code |") print("| enter AT+BAUD4 -- To modify the module communication speed|") print("| Note: 1 for 1200, 2 for 2400, 3 for 4800, 4 for 9600 |") print("| 5 for 19200, 6 for 38400, 7 for 57600, 8 for 115200 |") print("---------------------------------------------------------------------") while True: print("ENTER AT Commands: ") try: str = input() uart.write(str) utime.sleep_ms(100) except OSError: pass # wait for response start_time = utime.ticks_ms() timeout = False while not uart.any() and not timeout: if utime.ticks_diff(utime.ticks_ms(), start_time) > 500: timeout = True if timeout: print('Failed, response timed out') else: buf = uart.read() print("received:", buf) utime.sleep_ms(600)
def encender_led_aleatorio(self): aleatorio = random.getrandbits(12) aleatorio += 3000 time.sleep_ms(aleatorio) self.led.value(0)
def initialize(self): utime.sleep_ms(3) self.softreset() # print(self.getdeviceid()) if self.get_deviceid() is not 0x13: return 0
def _initialize(self) -> None: self.i2c.writeto(SHT31_DEVICE_ADDRESS, bytearray([CMD_SOFT_RESET_ADDR, CMD_SOFT_RESET_VAL])) # reset sleep_ms(2) # 0.5 to 1 ms according to datasheet
async def foo(): while True: await asyncio.sleep(0) utime.sleep_ms(10) # Emulate slow processing
play = __music__.play def old_pitch(self, freq, tim, pin=25): from machine import Pin, PWM from utime import sleep_ms try: pwm = PWM(Pin(pin)) pwm.freq(freq) # set frequency pwm.duty(tim) # set duty cycle sleep_ms(tim) finally: pwm.deinit() pitch = old_pitch set_tempo = __music__.set_tempo stop = __music__.stop if __name__ == '__main__': unit_test() play(NYAN) sleep_ms(1000) pitch(range(880, 1760, 16), 30) sleep_ms(50)
def unit_test(): tmp = music() tmp.play(POWER_UP) sleep_ms(500) tmp.play(POWER_UP) sleep_ms(1000) tmp.play(POWER_DOWN) sleep_ms(500) tmp.play(POWER_DOWN) sleep_ms(1000) tmp.pitch(range(880, 1760, 16), 30) sleep_ms(50) tmp.pitch(range(1760, 880, -16), 30) sleep_ms(50) tmp.play(BIRTHDAY) sleep_ms(15000) tmp.play(NYAN) sleep_ms(10000) tmp.play(PRELUDE) sleep_ms(10000) tmp.play(PYTHON) sleep_ms(10000) tmp.__del__()
def wait(self, delay): # Default wait implementation, to be overriden in subclasses # with IO scheduling if __debug__ and DEBUG: log.debug("Sleeping for: %s", delay) time.sleep_ms(delay)
##Author: Marcelo Soares Barroso ##Data: 01/07/2018 ##Objetivo: fazer um acendimento sequencial cuja velocidade seja crescente iniciando em 2 segundos a espera e diminuindo até 0,5 segundos. Utilize quatros estágios, e reinicie após a ocorrência dos mesmos. import utime import machine pin23 = machine.Pin(23, machine.Pin.OUT) pin22 = machine.Pin(22, machine.Pin.OUT) pin21 = machine.Pin(21, machine.Pin.OUT) pin18 = machine.Pin(18, machine.Pin.OUT) pin19 = machine.Pin(19, machine.Pin.OUT) while True: pin23.value(1) utime.sleep_ms(2000) pin23.value(0) pin22.value(1) utime.sleep_ms(2000) pin22.value(0) pin21.value(1) utime.sleep_ms(2000) pin21.value(0) pin18.value(1) utime.sleep_ms(2000) pin18.value(0) pin19.value(1) utime.sleep_ms(2000) pin23.value(0) pin22.value(0) pin21.value(0)
# print("red: {:03d}, green: {:03d}, blue: {:03d}".format(self.red, # self.green, # self.blue)) return (self.red, self.green, self.blue) pin = Pin(NEO_PIXEL_PIN, Pin.OUT) np = NeoPixel(pin, NO_OF_LEDS) brightness = 0.1 wheel = ColorWheel() wheel_pos = [None] * NO_OF_LEDS print("Each led shows all colors of the color wheel") print("The color wheel starting position of led i is i * 360° / no of leds") for led in range(NO_OF_LEDS): wheel_pos[led] = int(360 / NO_OF_LEDS * led) # print("wheel pos for led {:d}: {:d}".format(led,wheel_pos[led])) while True: for i in range(360): for led in range(NO_OF_LEDS): colors = wheel.colors((wheel_pos[led] + i) % 360) np[led] = (int(colors[0] * brightness), int(colors[1] * brightness), int(colors[2] * brightness)) np.write() sleep_ms(2)
def lire_pulsation(self): ppm = i2c.read(0x50, 1, False) sleep_ms(self._delay) if (self._debug): print("[debug] Pulsation : ", ppm) return ord(ppm)
from utime import sleep_ms, ticks_ms, ticks_add, ticks_diff, time import ntptime from umqtt.simple import MQTTClient import ubinascii, machine import urequests as requests import wifiportal np = NeoPixel(Pin(2), 24) np.write() for r in range(8): np[r] = (20, 0, 0) np[r + 8] = (0, 20, 0) np[r + 16] = (0, 0, 20) np.write() sleep_ms(50) wifiportal.captive_portal("RfidLock") try: ntptime.settime() except: pass for r in range(8): np[r] = (0, 0, 0) np[r + 8] = (0, 0, 0) np[r + 16] = (0, 0, 0) np.write() sleep_ms(50)
def do_menu(g): global module_name, vol, max_vol # all dislplay, buttons, paddle, sound logics are in game8266.mpy module SKIP_NAMES = ("boot", "main", "menu", "gameogo") files = [item[0] for item in os.ilistdir(".") if item[1] == 0x8000] module_names = [ filename.rsplit(".", 1)[0] for filename in files if (filename.endswith(".py") or filename.endswith(".mpy")) and not filename.startswith("_") ] module_names = [ module_name for module_name in module_names if not module_name in SKIP_NAMES ] module_names.sort() tot_file = len(module_names) COLOR_FG = g.tft.GREEN COLOR_BG = g.tft.BLACK COLOR_HH = g.tft.RED g.tft.font(g.tft.FONT_Ubuntu) fontW, fontH = g.tft.fontSize() rowH = fontH + 2 tot_rows = g.screenH // rowH - 1 screen_pos = 0 file_pos = 0 updateMenu = True launched = False while not launched: gc.collect() g.getBtn() g.setVol() if updateMenu: updateMenu = False g.tft.clear(g.tft.BLACK) g.tft.set_bg(COLOR_BG) g.tft.text(0, 0, 'M:{}'.format(gc.mem_free()), g.tft.RED) g.display_vol() i = 0 for j in range(file_pos, min(file_pos + tot_rows, tot_file)): if i == screen_pos: g.display_msg(0, rowH * (i + 1), str(j) + " " + module_names[j], COLOR_FG, COLOR_HH) else: g.display_msg(0, rowH * (i + 1), str(j) + " " + module_names[j], COLOR_FG, COLOR_BG) i += 1 if g.justPressed(g.btnU): if screen_pos > 0: g.display_msg( 0, rowH * (screen_pos + 1), str(file_pos + screen_pos) + " " + module_names[file_pos + screen_pos], COLOR_FG, COLOR_BG) screen_pos -= 1 g.display_msg( 0, rowH * (screen_pos + 1), str(file_pos + screen_pos) + " " + module_names[file_pos + screen_pos], COLOR_FG, COLOR_HH) else: if file_pos > 0: file_pos = max(0, file_pos - tot_rows) screen_pos = tot_rows - 1 updateMenu = True g.playTone('c4', tone_dur) if g.justPressed(g.btnD): if screen_pos < min(tot_file - file_pos - 1, tot_rows - 1): g.display_msg( 0, rowH * (screen_pos + 1), str(file_pos + screen_pos) + " " + module_names[file_pos + screen_pos], COLOR_FG, COLOR_BG) screen_pos = min(tot_file - 1, screen_pos + 1) g.display_msg( 0, rowH * (screen_pos + 1), str(file_pos + screen_pos) + " " + module_names[file_pos + screen_pos], COLOR_FG, COLOR_HH) else: if file_pos + tot_rows < tot_file: file_pos = min(tot_file, file_pos + tot_rows) screen_pos = 0 updateMenu = True g.playTone('e4', tone_dur) if g.justReleased(g.btnA): g.playTone('c5', tone_dur) g.tft.clear(g.tft.BLACK) g.center_msg( "launching {}".format(module_names[file_pos + screen_pos]), COLOR_FG, COLOR_BG) sleep_ms(1000) module_name = module_names[file_pos + screen_pos] return True if g.justReleased(g.btnL): g.playTone('d5', tone_dur) launched = True g.tft.clear(g.tft.BLACK) g.center_msg("Exited", COLOR_FG, COLOR_BG) return False sleep_ms(10)
def grab_slowly(self): '''缓慢夹取''' for angle in range(150, 100, -1): self.grab(angle=angle) utime.sleep_ms(20)
# file: ir_receiver_demo-1.py # https://medium.com/@rawat.s/micropython-programming-for-esp32-14-3474eeccdddd from machine import Pin import utime as time from ir_receiver import IR_RECV ir = IR_RECV(Pin(12), timeout=80) try: while True: codes = ir.read() for code in codes: print("Code: '{}'".format(code)) time.sleep_ms(300) except KeyboardInterrupt: pass finally: ir.deinit() print('Done')