class Range_Finder(): duration = 0 distance = 0 def __init__(self, echo_pin, trigger_pin): # Initialise the Range Finder self.__echo_pin = Pin(echo_pin, Pin.IN) self.__trigger_pin = Pin(trigger_pin, Pin.OUT) def ping(self): self.__trigger_pin.low() sleep_us(2) self.__trigger_pin.high() sleep_us(5) self.__trigger_pin.low() signalon = 0 signaloff = 0 while self.__echo_pin.value() == 0: signaloff = ticks_us() while self.__echo_pin.value() == 1: signalon = ticks_us() elapsed_micros = signalon - signaloff self.duration = elapsed_micros self.distance = (elapsed_micros * 0.343) / 2 return self.distance
class HCSR04: """HC-SR04 ultrasonic ranging module class.""" def __init__(self, trig_Pin, echo_Pin): """Initialize Input(echo) and Output(trig) Pins.""" self._trig = Pin(trig_Pin, Pin.OUT) self._echo = Pin(echo_Pin, Pin.IN) self._sound_speed = 340 # m/s def _pulse(self): """Trigger ultrasonic module with 10us pulse.""" self._trig.high() sleep_us(10) self._trig.low() def distance(self): """Measure pulse length and return calculated distance [m].""" self._pulse() try: pulse_width_s = time_pulse_us(self._echo, Pin.high, 30000) / 1000000 except OSError: # Measurement timed out return None dist_m = (pulse_width_s / 2) * self._sound_speed return dist_m def calibration(self, known_dist_m): """Calibrate speed of sound.""" self._sound_speed = known_dist_m / self.distance() * self._sound_speed print("Speed of sound was successfully calibrated! \n" + "Current value: " + str(self._sound_speed) + " m/s")
class Motor(object): """the motor class has the name attribute and a forward duty and backward duty""" def __init__(self, name): """Sets up two motors for a robot car :param name: left or right """ if name == "left": self.pin_speed = 4 self.pin_direction = 2 elif name == "right": self.pin_speed = 5 self.pin_direction = 0 self.motor = PWM(Pin(self.pin_speed), freq=1000, duty=0) self.d = 1023 self.speed = PWM(Pin(self.pin_speed), freq=1000, duty=0) self.direction = Pin(self.pin_direction, Pin.OUT) self.name = name def forward(self): self.direction.low() self.speed.duty(self.d) def backward(self): self.direction.high() self.speed.duty(self.d) def stop(self): self.speed.duty(0) def dutyset(self, value): if 0 <= value <= 1023: self.d = value
def init_robot(): print("Imported Libraries") print("Initializing...") # Turn on Light led = Pin(25, Pin.OUT) led.high() # DRIVER INITIALIZATION btn = button.Button(BUTTON_PIN) bzz = buzzer.Buzzer(BUZZER_PIN) motors = motor.TwoWheel(MOTOR_PINS, AXIL_LENGTH) threshold = max(UNIT_SIZE) - MIN_SENSOR_WIDTH ping_sensors = list( map(lambda pins: ping.PingProximitySensor(pins, threshold), PING_PINS)) ping_collection = ping.PingProxCollection(ping_sensors) dht_sensor = dht.DHT11(Pin(20)) # MAZE INITIALIZATION maze = Maze(MAZE_SIZE) # ROBOT INITIALIZATION robot = Robot(btn, bzz, motors, ping_collection, dht_sensor, maze, UNIT_SIZE, SOLUTIONS, threshold) utime.sleep_ms(100) led.low() print("Pico Initialized") robot.Start()
def identify(self, period_ms=1000): led = Pin(25, Pin.OUT) while True: led.high() sleep_ms(period_ms // 2) led.low() sleep_ms(period_ms // 2)
class Stepper: def __init__(self, id, dir_pin, step_pin, step_callback=None): self.dir_pin = Pin(dir_pin, Pin.OUT) # at 1_000_000Hz clock a single instruction is 1us self._sm = rp2.StateMachine(id, stepper, freq=1_000_000, set_base=Pin(step_pin, Pin.OUT)) if step_callback is not None: self._sm.irq(step_callback) self._sm.put(0) self._sm.active(1) def set_steps_per_second(self, steps_per_second): if steps_per_second == 0: self._sm.put(0) return if steps_per_second > 0: self.dir_pin.high() elif steps_per_second < 0: self.dir_pin.low() delay = abs( round(1_000_000 / steps_per_second) ) - 10 # there are 10 instructions in the program for each step self._sm.put(delay)
def app(): GPIO0 = 5 pinLED = Pin(GPIO0, Pin.OUT) pinLED.low() # connecteren met netwerk wifi.connectWIFI() if socketServer.start() == False: wifi.disconnectWIFI() return 0 while True: status = socketServer.waitCn() if status < 0: print("Wrong command") elif status == 0: print("Halt ESP") break else: socketServer.sendData("OK") res = socketServer.readData() pinLED.value(int(res)) socketServer.sendData("OK") socketServer.stopClient() pinLED.low() wifi.disconnectWIFI()
class Stepper: """ Handles A4988 hardware driver for bipolar stepper motors """ def __init__(self, dir_pin, step_pin): self.step_pin = Pin(step_pin, Pin.OUT) self.dir_pin = Pin(dir_pin, Pin.OUT) self.dir = 0 self.pulserate = 100 self.count = 0 self.speed = 0 def do_step(self): # called by timer interrupt every 100us if self.dir == 0: return self.count = (self.count + 1) % self.pulserate if self.count == 0: self.step_pin.high() pass self.step_pin.low() def set_speed(self, speed): self.speed = speed # set direction if self.speed > 0: self.dir = 1 self.dir_pin.high() elif self.speed < 0: self.dir = -1 self.dir_pin.low() else: self.dir = 0 if abs(self.speed) > 0: self.pulserate = 10000 // abs(self.speed)
class motor(object): def __init__(self, name): self.forward_speed = 1023 if name == "left": self.pin_speed = 4 self.pin_direction = 2 elif name == "right": self.pin_speed = 5 self.pin_direction = 0 self.speed = PWM(Pin(self.pin_speed), freq=1000, duty=0) self.direction = Pin(self.pin_direction, Pin.OUT) self.name = name def forward(self): self.direction.low() self.duty(1023) def backward(self): self.direction.high() self.duty(1023) def stop(self): self.duty(0) def duty(self, d): PWM(Pin(self.pin_speed), freq=1000, duty=d) def set_forward_speed(self, duty): self.forward_speed = duty
class motor(object): """the motor class has the name attribute and a forward duty and backward duty""" def __init__(self, name, forward_duty, backward_duty): if name == "left": self.pin_speed = 4 self.pin_direction = 2 elif name == "right": self.pin_speed = 5 self.pin_direction = 0 self.speed = PWM(Pin(self.pin_speed), freq=1000, duty=0) self.direction = Pin(self.pin_direction, Pin.OUT) self.name = name self.forward_duty = forward_duty self.backward_duty = backward_duty def forward(self): """turns a motor on in the forward direction""" self.direction.low() self.duty(self.forward_duty) def backward(self): """turns a motor on in the backward direction""" self.direction.high() self.duty(self.backward_duty) def stop(self): """stops a motor""" self.duty(0) def duty(self, d): """specifies the duty associated with the pin """ PWM(Pin(self.pin_speed), freq=1000, duty=d)
def Out(self, state): pin = Pin(self.pin, Pin.OUT) if state == True: pin.high() else: pin.low()
def run(): led1 = Pin('LED1', Pin.OUT_PP) while 1: led1 = Pin('LED1', Pin.OUT_PP) led1.high() # turn on time.sleep(2) led1.low() # turn off time.sleep(2)
def run(): print('demo digital I/O') led = Pin('LED1', Pin.OUT_PP) button = Pin('SW', Pin.IN) while 1: state = button.value() if state == 1: led.high() else: led.low()
def flashLed2Times(): p2 = Pin(2, Pin.OUT) p2.high() t.sleep(2) p2.low() t.sleep(2) p2.high() t.sleep(2) p2.low() t.sleep(2) p2.high()
def toggleled(): p0 = Pin(0, Pin.OUT) p0.high() sleep(1) p0.low() sleep(1) p0.high() sleep(1) p0.low() sleep(1) p0.high() sleep(1)
class LED: LED1 = 1 LED2 = 2 LED3 = 4 LED4 = 8 def __init__(self): self.led1 = Pin('PA8', Pin.OUT, Pin.PULL_NONE) self.led2 = Pin('PA7', Pin.OUT, Pin.PULL_NONE) self.led3 = Pin('PA6', Pin.OUT, Pin.PULL_NONE) self.led4 = Pin('PA5', Pin.OUT, Pin.PULL_NONE) def out_bdigit(self, led_data): if (led_data & self.LED1) == 0: self.led1.low() else: self.led1.high() if (led_data & self.LED2) == 0: self.led2.low() else: self.led2.high() if (led_data & self.LED3) == 0: self.led3.low() else: self.led3.high() if (led_data & self.LED4) == 0: self.led4.low() else: self.led4.high()
def main(use_stream=False): s = socket.socket() # Binding to all interfaces - server will be accessible to other hosts! ai = socket.getaddrinfo("0.0.0.0", 8080) print("Bind address info:", ai) addr = ai[0][-1] #prepping LED pin p = Pin(2,Pin.OUT) # p.high() # time.sleep(1) # p.low() s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(addr) s.listen(5) print("Listening, connect your browser to http://<this_host>:8080/") counter = 0 while True: res = s.accept() client_s = res[0] client_addr = res[1] print("Client address:", client_addr) print("Client socket:", client_s) print("Request:") if use_stream: # MicroPython socket objects support stream (aka file) interface # directly. #print(client_s.read(4096)) val = client_s.read(4096) print(val) client_s.write(CONTENT % counter) else: #print(client_s.recv(4096)) val = client_s.recv(4096) print(val) client_s.send(CONTENT % counter) if "GET /toggle" in val: print("Toggling!") p.high() time.sleep(1) p.low() machine.reset() client_s.close() counter += 1 print()
def do_connect(): sta_if = network.WLAN(network.STA_IF) p2 = Pin(2, Pin.OUT) sta_if.active(False) if not sta_if.isconnected(): p2.low() print('connecting to network...') sta_if.active(True) sta_if.connect('TurnipSmart', 'turnip2016') while not sta_if.isconnected(): pass if sta_if.isconnected(): print('connect success') p2.high() print('network config:', sta_if.ifconfig())
class Relay(object): def __init__(self, pin_number=5): self._pin = Pin(pin_number, Pin.OUT) @property def status(self): return 'on' if self.state else 'off' @property def state(self): return self._pin.value() @state.setter def state(self, status): self._pin.high() if status else self._pin.low() def toggle(self): self.state = not self.state def activate(self): self.state = True def deactivate(self): self.state = False def pulse(self, timeout=1): self.activate() time.sleep(float(timeout)) self.deactivate()
class motor2(object): """the motor class has the name attribute and a forward duty and backward duty""" def __init__(self, name): """ Sets up two motors for a robot car :param name: :param forward_duty: :param backward_duty: :param pin_left_speed: :param pin_left_direction: :param pin_right_speed: :param pin_right_direction: """ if name == "left": self.pin_speed = 4 self.pin_direction = 2 elif name == "right": self.pin_speed = 5 self.pin_direction = 0 self.d = 0 self.speed = PWM(Pin(self.pin_speed), freq=1000, duty=self.d) self.direction = Pin(self.pin_direction, Pin.OUT) self.name = name def forward(self): """turns a motor on in the forward direction""" self.direction.low() self.duty(self.d) def backward(self): """turns a motor on in the backward direction""" self.direction.high() self.duty(self.d) def stop(self): """stops a motor""" self.duty(0) def duty(self, value): """ specifies the duty associated with the pin :param value: the duty value """ if 0 <= value <= 1023: ### BUG ? this shoudl set the duty and not create a new PWM???? Check self.d = value
def led_init(): global led1, led2, led3, led4 led1 = Pin('PA8', Pin.OUT, Pin.PULL_NONE) led2 = Pin('PA7', Pin.OUT, Pin.PULL_NONE) led3 = Pin('PA6', Pin.OUT, Pin.PULL_NONE) led4 = Pin('PA5', Pin.OUT, Pin.PULL_NONE) led1.low() led2.low() led3.low() led4.low()
class ComLight: def __init__(self, com, pin, name, room): self.pin = Pin(pin, Pin.OUT) self.pin.low() self.com = com self.topic = '/' + room + '/lights/' + name com.subscribe(self.topic, self._on_msg) def _on_msg(self, msg): val = msg[0] - 48 if val == 1: self.pin.high() elif val == 0: self.pin.low() def gather_info(self): return (('sub', 'light', self.topic, 'Send char of 0 or 1 to turn off or on'),) def tick(self): pass
class motor(): """Control a motor connected to the L298N Dual motor controller.""" def __init__(self, forward, backward, speed): """forward pin name, backward pin name, speed = (pin name, timer#) Need to make sure the given timer # is associated with the speed pin or an exception will be raised. The speed pin must support PWM. #Examples: m1 = motor('Y1', 'Y2', ('Y3', 4)) m2 = motor('Y5', 'Y6', ('Y4', 4)) """ self._forward = Pin(forward, Pin.OUT_PP) self._backward = Pin(backward, Pin.OUT_PP) self._speedControl = pwm(speed[0], speed[1]) self._speed = 0 @property def speed(self): return self._speed @speed.setter def speed(self, value): self._speed = value if (value == 0): self._forward.low() self._backward.low() elif (value < 0): self._forward.low() self._backward.high() else: self._forward.high() self._backward.low() self._speedControl.pulse_width_percent = min(100, abs(value)) def brake(self): """ Brake the motor by sending power both directions. """ self._forward.high() self._backward.high() self._speedControl.pulse_width_percent = 100 delay(1000) self.speed = 0
import pyb from machine import SPI,Pin from pyb import UART import json #GU620模块初始化 N1 = Pin('Y6', Pin.OUT_PP)#定义通信系统启动引脚 N1.low() pyb.delay(2000) N1.high() pyb.delay(10000)#拉高拉低引脚,启动通信系统 u2 = UART(4,115200,timeout = 50)#定义串口4,设置 波特率为115200 #初始化 HTTP 应用 u2.write('AT+HTTPINIT\r\n') getURLCMD = 'AT+HTTPPARA=1,"http://old.tpyboard.com/v702/httptest.php?t=123456"\r\n' #getURLCMD = 'AT+HTTPPARA=1,"https://www.baidu.com"\r\n' while True: if u2.any() > 0: dataRead = u2.read() print('_dataRead:',dataRead) print('-'*30) if dataRead.find(b'OK') > -1: #AT命令执行成功 #判断是执行的哪一步操作 if dataRead.find(b'AT+HTTPINIT') > -1: #初始化HTTP成功 #设置 HTTP 参数值 设置url u2.write(getURLCMD) elif dataRead.find(b'AT+HTTPPARA=1') > -1: #HTTP参数设置成功 #发起GET请求获取数据
""" Programme Blink d'une LED Branchement de la LED (pate +) entre la borne S7 (4ème broche en partant du haut à gauche - USB vers le haut) et la masse (pate -) borne (1ère broche en bas à gauche - USB vers le haut) """ from machine import Pin import time # On initialise la sortie 7 pour piloter la led maLED = Pin( "S7", Pin.OUT ) while True: #Equivalent de la boucle loop en arduino print("je commence mon blink") # On affiche dans Putty le texte Je commence mon blink maLED.high() #La broche S7 au niveau haut - la led est allumée time.sleep_ms(500) #Attendre 500 ms maLED.low() #La broche S7 au niveau bas - la led est éteinte time.sleep_ms(500) #Attendre 500 ms
class ST7735(): def __init__(self, spi, rst=4, ce=5, dc=16, offset=0, c_mode='RGB'): self._rst = Pin(rst, Pin.OUT) # 4 self._ce = Pin(ce, Pin.OUT) # 5 self._ce.high() self._dc = Pin(dc, Pin.OUT) # 16 self._dc.high() self._offset = offset self._x = 0 self._y = 0 self._width = ST7735_TFTWIDTH self._height = ST7735_TFTHEIGHT self._color = 0 self._bground = 0x64bd if c_mode == 'RGB': self._color_mode = ST7735_MADCTL_RGB else: self._color_mode = ST7735_MADCTL_BGR # SPI self._spi = spi def command(self, c): b = bytearray(1) b[0] = c self._dc.low() self._ce.low() self._spi.write(b) # write 1 byte on MOSI self._ce.high() # print ('C {0:2x}'.format(c)) def data(self, c): b = bytearray(1) b[0] = c self._dc.high() self._ce.low() self._spi.write(b) # write 1 byte on MOSI self._ce.high() # print ('D {0:2x}'.format(c)) def reset(self): self._rst.low() time.sleep_ms(50) # sleep for 50 milliseconds self._rst.high() time.sleep_ms(50) # sleep for 50 milliseconds # begin def begin(self): self.reset() commands = bytearray([ # Initialization commands for 7735B screens ST7735_SWRESET, DELAY, # 1: Software reset, 0 args, w/delay 150, # 150 ms delay ST7735_SLPOUT, DELAY, # 2: Out of sleep mode, 0 args, w/delay 255, # 500 ms delay ST7735_FRMCTR1, 3, # 3: Frame rate ctrl - normal mode, 3 args: 0x01, 0x2C, 0x2D, # Rate = fosc/(1x2+40) * (LINE+2C+2D) ST7735_FRMCTR2, 3, # 4: Frame rate control - idle mode, 3 args: 0x01, 0x2C, 0x2D, # Rate = fosc/(1x2+40) * (LINE+2C+2D) ST7735_FRMCTR3, 6, # 5: Frame rate ctrl - partial mode, 6 args: 0x01, 0x2C, 0x2D, # Dot inversion mode 0x01, 0x2C, 0x2D, # Line inversion mode ST7735_INVCTR, 1, # 6: Display inversion ctrl, 1 arg, no delay: 0x07, # No inversion ST7735_PWCTR1, 3, # 7: Power control, 3 args, no delay: 0xA2, 0x02, # -4.6V 0x84, # AUTO mode ST7735_PWCTR2, 1, # 8: Power control, 1 arg, no delay: 0xC5, # VGH25 = 2.4C VGSEL = -10 VGH = 3 * AVDD ST7735_PWCTR3, 2, # 9: Power control, 2 args, no delay: 0x0A, # Opamp current small 0x00, # Boost frequency ST7735_PWCTR4, 2, # 10: Power control, 2 args, no delay: 0x8A, # BCLK/2, Opamp current small & Medium low 0x2A, ST7735_PWCTR5, 2, # 11: Power control, 2 args, no delay: 0x8A, 0xEE, ST7735_VMCTR1, 1, # 12: Power control, 1 arg, no delay: 0x0E, ST7735_INVOFF, 0, # 13: Don't invert display, no args, no delay ST7735_MADCTL, 1, # 14: Memory access control (directions), 1 arg: 0xC8, # row addr/col addr, bottom to top refresh ST7735_COLMOD, 1, # 15: set color mode, 1 arg, no delay: 0x05, # 16-bit color ST7735_CASET, 4, # 1: Column addr set, 4 args, no delay: 0x00, 0x00, # XSTART = 0 0x00, 0x7F, # XEND = 127 ST7735_RASET, 4, # 2: Row addr set, 4 args, no delay: 0x00, 0x00, # XSTART = 0 0x00, 0x9F, # XEND = 159 ST7735_GMCTRP1, 16, # 1: Magical unicorn dust, 16 args, no delay: 0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d, 0x29, 0x25, 0x2B, 0x39, 0x00, 0x01, 0x03, 0x10, ST7735_GMCTRN1, 16, # 2: Sparkles and rainbows, 16 args, no delay: 0x03, 0x1d, 0x07, 0x06, 0x2E, 0x2C, 0x29, 0x2D, 0x2E, 0x2E, 0x37, 0x3F, 0x00, 0x00, 0x02, 0x10, ST7735_NORON, DELAY, # 3: Normal display on, no args, w/delay 10, # 10 ms delay ST7735_DISPON, DELAY, # 4: Main screen turn on, no args w/delay 100, # 100 ms delay ST7735_MADCTL, 1, # change MADCTL color filter 0xC0 | self._color_mode ]) argcount = 0 cmd = 1 delay = 0 for c in commands: if argcount == 0: # no arguments collected if delay: # if a delay flagged this is delay value if c == 255: # if delay is 255ms make it 500ms c = 500 time.sleep_ms(c) delay = 0 else: if cmd == 1: # need to send command byte self.command(c) # send coommand cmd = 0 # clear flag to show command sent else: argcount = c & (0xff ^ DELAY ) # Clear delay bit and get arguments delay = c & DELAY # set if delay required cmd = 1 # flag command now complete else: # arguments to send self.data(c) # send argument argcount -= 1 # decrement the counter # display def set_addr_window(self, x0, y0, x1, y1): self.command(ST7735_CASET) # Column addr setim self.data(0x00) self.data(x0 + self._offset) # XSTART self.data(0x00) self.data(x1 + self._offset) # XEND self.command(ST7735_RASET) # Row addr set self.data(0x00) self.data(y0 + self._offset) # YSTART self.data(0x00) self.data(y1 + self._offset) # YEND self.command(ST7735_RAMWR) # write to RAM def pixel(self, x, y, color): if (x < 0) or (x >= self._width) or (y < 0) or (y >= self._height): return self.set_addr_window(x, y, x + 1, y + 1) a = (color >> 8) + ((color & 0xff) << 8) # reverse bytes b = bytearray(a.to_bytes(2)) self._dc.high() self._ce.low() self._spi.write(b) # write 1 byte on MOSI self._ce.high() def draw_block(self, x, y, w, h, color): size = w * h max_rows = math.floor(500 / h) rows = 0 while rows < h: block_rows = min(max_rows, h - rows) b = bytes([color >> 8, color & 0xff]) * w * block_rows self.draw_bmp(x, y + rows, w, block_rows, b) rows = rows + max_rows def draw_bmp(self, x, y, w, h, buffer): if ((x >= self._width) or (y >= self._height)): return if (x + w - 1) >= self._width: w = self._width - x if (y + h - 1) >= self._height: h = self._height - y self.set_addr_window(x, y, x + w - 1, y + h - 1) self._dc.high() self._ce.low() self._spi.write(buffer) # write bytes on MOSI self._ce.high() def fill_screen(self, color): self.draw_block(0, 0, self._width, self._height, color) def p_char(self, x, y, ch): fp = (ord(ch) - 0x20) * 5 f = open('font5x7.fnt', 'rb') f.seek(fp) b = f.read(5) char_buf = bytearray(b) char_buf.append(0) # make 8x6 image char_image = bytearray() for bit in range(8): for c in range(6): if ((char_buf[c] >> bit) & 1) > 0: char_image.append(self._color >> 8) char_image.append(self._color & 0xff) else: char_image.append(self._bground >> 8) char_image.append(self._bground & 0xff) self.draw_bmp(x, y, 6, 8, char_image) def p_string(self, x, y, str): for ch in (str): self.p_char(x, y, ch) x += 6 def rgb_to_565(self, r, g, b): return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3) def set_rotation(self, m): self.command(ST7735_MADCTL) rotation = m % 4 # can't be higher than 3 if rotation == 0: self.data(ST7735_MADCTL_MX | ST7735_MADCTL_MY | self._color_mode) self._width = ST7735_TFTWIDTH self._height = ST7735_TFTHEIGHT elif rotation == 1: self.data(ST7735_MADCTL_MY | ST7735_MADCTL_MV | self._color_mode) self._width = ST7735_TFTHEIGHT self._height = ST7735_TFTWIDTH elif rotation == 2: self.data(self._color_mode) self._width = ST7735_TFTWIDTH self._height = ST7735_TFTHEIGHT elif rotation == 3: self.data(ST7735_MADCTL_MX | ST7735_MADCTL_MV | self._color_mode) self._width = ST7735_TFTHEIGHT self._height = ST7735_TFTWIDTH
pin_14 = Pin(14, Pin.OUT, value = 0) pin_12 = Pin(12, Pin.OUT, value = 0) pin_13 = Pin(13, Pin.OUT, value = 0) pin_15 = Pin(15, Pin.OUT, value = 0) pin_16 = Pin(16, Pin.OUT, value = 0) pin_5 = Pin(5, Pin.OUT, value = 0) pin_4 = Pin(4, Pin.OUT, value = 0) pin_0 = Pin(0, Pin.OUT, value = 0) while True: pin_14.high() sleep_ms(500) pin_14.low() sleep_ms(500) pin_12.high() sleep_ms(500) pin_12.low() sleep_ms(500) pin_13.high() sleep_ms(500) pin_13.low() sleep_ms(500) pin_15.high() sleep_ms(500) pin_15.low() sleep_ms(500) pin_16.high() sleep_ms(500)
from machine import Pin import utime greenLED = Pin(16, Pin.OUT) redLED = Pin(17, Pin.OUT) trigger = Pin(18, Pin.OUT) echo = Pin(19, Pin.IN) def ultra(): signalon = 0 signaloff = 0 trigger.low() utime.sleep_us(2) trigger.high() utime.sleep_us(5) trigger.low() while echo.value() == 0: signaloff = utime.ticks_us() while echo.value() == 1: signalon = utime.ticks_us() timepassed = signalon - signaloff distance = (timepassed * 0.0343) / 2 if distance < 15: redLED.low() greenLED.high() else: greenLED.low() redLED.high() print("The distance from object is ", +
# Websocket URI to connect to WS_URI = 'ws://f7461512.ngrok.io:80/socket' # ESSID/Password for the wifi network ESSID = 'ssid' PASSWORD = '******' # Mapping of internal pin number to labels D3 = 0 D4 = 2 D8 = 15 # Lock is connected to D3 LOCK = Pin(D3, Pin.OUT) LOCK.low() # Indicator is connected to D4 INDICATOR = Pin(D4, Pin.OUT) INDICATOR.low() # Button is connected to D8 BUTTON = Pin(D8, Pin.IN, Pin.PULL_UP) # Interval at which the timer task runs (millis) TIMER_INTERVAL = 100 # Number of ticks to wait with the lock open # (OPEN_DELAY * TIMER_INTERVAL / 1000) seconds OPEN_DELAY = 20
def led_on(): led = Pin(PIN_LED, Pin.OUT) led.low()
from machine import Pin, SPI import time import ubinascii vref = 3.3 cs = Pin(15, Pin.OUT) cs.high() hspi = SPI(1, baudrate=1600000, polarity=0, phase=0) value = bytearray(2) while True: data = bytearray(2) wget = b'\xA0\x00' cs.low() hspi.write(b'\x01') hspi.write(b'\xA0') data = hspi.read(1) # data = hspi.write_readinto(wget, data) cs.high() print(str(int(ubinascii.hexlify(data & b'\x0fff'))*vref/4096)) time.sleep(1) # data = data*vref/4096 # time.sleep(1) # print(str(data & b'\x0fff'))
def turn_off_wifi_led(): from machine import Pin pin = Pin(WIFI_LED_PIN, Pin.OUT) pin.low()
class ILI9341: def __init__(self, width, height): self.width = width self.height = height self.pages = self.height // 8 self.buffer = bytearray(self.pages * self.width) self.framebuf = framebuf.FrameBuffer(self.buffer, self.width, self.height, framebuf.MONO_VLSB) self.spi = SPI(0) # chip select self.cs = Pin("P16", mode=Pin.OUT, pull=Pin.PULL_UP) # command self.dc = Pin("P17", mode=Pin.OUT, pull=Pin.PULL_UP) # initialize all pins high self.cs.high() self.dc.high() self.spi.init(baudrate=8000000, phase=0, polarity=0) self.init_display() def init_display(self): time.sleep_ms(500) self.write_cmd(0x01) time.sleep_ms(200) self.write_cmd(0xCF) self.write_data(bytearray([0x00, 0x8B, 0x30])) self.write_cmd(0xED) self.write_data(bytearray([0x67, 0x03, 0x12, 0x81])) self.write_cmd(0xE8) self.write_data(bytearray([0x85, 0x10, 0x7A])) self.write_cmd(0xCB) self.write_data(bytearray([0x39, 0x2C, 0x00, 0x34, 0x02])) self.write_cmd(0xF7) self.write_data(bytearray([0x20])) self.write_cmd(0xEA) self.write_data(bytearray([0x00, 0x00])) # Power control self.write_cmd(0xC0) # VRH[5:0] self.write_data(bytearray([0x1B])) # Power control self.write_cmd(0xC1) # SAP[2:0];BT[3:0] self.write_data(bytearray([0x10])) # VCM control self.write_cmd(0xC5) self.write_data(bytearray([0x3F, 0x3C])) # VCM control2 self.write_cmd(0xC7) self.write_data(bytearray([0xB7])) # Memory Access Control self.write_cmd(0x36) self.write_data(bytearray([0x08])) self.write_cmd(0x3A) self.write_data(bytearray([0x55])) self.write_cmd(0xB1) self.write_data(bytearray([0x00, 0x1B])) # Display Function Control self.write_cmd(0xB6) self.write_data(bytearray([0x0A, 0xA2])) # 3Gamma Function Disable self.write_cmd(0xF2) self.write_data(bytearray([0x00])) # Gamma curve selected self.write_cmd(0x26) self.write_data(bytearray([0x01])) # Set Gamma self.write_cmd(0xE0) self.write_data(bytearray([0x0F, 0x2A, 0x28, 0x08, 0x0E, 0x08, 0x54, 0XA9, 0x43, 0x0A, 0x0F, 0x00, 0x00, 0x00, 0x00])) # Set Gamma self.write_cmd(0XE1) self.write_data(bytearray([0x00, 0x15, 0x17, 0x07, 0x11, 0x06, 0x2B, 0x56, 0x3C, 0x05, 0x10, 0x0F, 0x3F, 0x3F, 0x0F])) # Exit Sleep self.write_cmd(0x11) time.sleep_ms(120) # Display on self.write_cmd(0x29) time.sleep_ms(500) self.fill(0) def show(self): # set col self.write_cmd(0x2A) self.write_data(bytearray([0x00, 0x00])) self.write_data(bytearray([0x00, 0xef])) # set page self.write_cmd(0x2B) self.write_data(bytearray([0x00, 0x00])) self.write_data(bytearray([0x01, 0x3f])) self.write_cmd(0x2c); num_of_pixels = self.height * self.width for row in range(0, self.pages): for pixel_pos in range(0, 8): for col in range(0, self.width): compressed_pixel = self.buffer[row * 240 + col] if ((compressed_pixel >> pixel_pos) & 0x1) == 0: self.write_data(bytearray([0x00, 0x00])) else: self.write_data(bytearray([0xFF, 0xFF])) def fill(self, col): self.framebuf.fill(col) def pixel(self, x, y, col): self.framebuf.pixel(x, y, col) def scroll(self, dx, dy): self.framebuf.scroll(dx, dy) def text(self, string, x, y, col=1): self.framebuf.text(string, x, y, col) def write_cmd(self, cmd): self.dc.low() self.cs.low() self.spi.write(bytearray([cmd])) self.cs.high() def write_data(self, buf): self.dc.high() self.cs.low() self.spi.write(buf) self.cs.high()
from machine import Pin import time p2 = Pin(2, Pin.OUT) # create output pin on GPIO2 p2.value(1) # set pin to high while True: p2.low() # set pin to low p2.value() time.sleep(3) # sleep for 3 second p2.high() # set pin to high p2.value() time.sleep(3) # sleep for 3 second
p.high() response = RestServer.Response() response.code(200) response.contentType("text/plain") response.data("Aberto") return response.build() def close(): p.low() response = RestServer.Response() response.code(200) response.contentType("text/plain") response.data("Fechado") return response.build() paths = {"/open":open, "/close":close} p.high() wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect('Vilar', 'defarias') while not wlan.isconnected(): pass p.low() server = RestServer.Server(8000) server.auth("YTpi") server.start(paths)