def main(): enabled = False led = machine.Pin(2, machine.Pin.OUT) trig = machine.Pin(12, machine.Pin.OUT) echo = machine.Pin(13, machine.Pin.IN) i2c = machine.I2C(scl=machine.Pin(5), sda=machine.Pin(4)) oled = ssd1306.SSD1306_I2C(128, 64, i2c, 0x3c) while True: trig.off() utime.sleep_us(2) trig.on() utime.sleep_us(10) trig.off() while echo.value() == 0: pass t1 = utime.ticks_us() while echo.value() == 1: pass t2 = utime.ticks_us() cm = (t2 - t1) / 58.0 print(cm) oled.fill(0) oled.text("Distanz: " + str(cm), 0, 0) oled.show() if enabled: led.off() else: led.on() utime.sleep_ms(1000) enabled = not enabled utime.sleep(2)
def write_object_stub(self, fp, object_expr: object, obj_name: str, indent: str): if object_expr in self.problematic: return items, errors = self.get_obj_attributes(object_expr) for name, rep, typ, obj in sorted(items, key=lambda x: x[0]): if name.startswith("__"): continue resetWDT() sleep_us(1) if typ in ["<class 'function'>", "<class 'bound_method'>"]: s = indent + "def " + name + "():\n" s += indent + " pass\n\n" fp.write(s) elif typ in ["<class 'str'>", "<class 'int'>", "<class 'float'>"]: s = indent + name + " = " + rep + "\n" fp.write(s) elif typ == "<class 'type'>" and indent == "": s = "\n" + indent + "class " + name + ":\n" s += indent + " ''\n" fp.write(s) self.write_object_stub(fp, obj, "{0}.{1}".format(obj_name, name), indent + " ") else: fp.write(indent + name + " = None\n") del items del errors try: del name, rep, typ, obj except (OSError, KeyError): pass
def __init__(self, i2c, address, oneline=False, charsize=LCD_5x8DOTS): self.i2c = i2c self.address = address self.disp_func = self.LCD_DISPLAYON # | 0x10 if not oneline: self.disp_func |= self.LCD_2LINE elif charsize != 0: # For 1-line displays you can choose another dotsize self.disp_func |= self.LCD_5x10DOTS # Wait for display init after power-on utime.sleep_ms(50) # 50ms # Send function set self.cmd(self.LCD_FUNCTIONSET | self.disp_func) utime.sleep_us(4500) ##time.sleep(0.0045) # 4.5ms self.cmd(self.LCD_FUNCTIONSET | self.disp_func) utime.sleep_us(150) ##time.sleep(0.000150) # 150µs = 0.15ms self.cmd(self.LCD_FUNCTIONSET | self.disp_func) self.cmd(self.LCD_FUNCTIONSET | self.disp_func) # Turn on the display self.disp_ctrl = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF self.display(True) # Clear it self.clear() # Set default text direction (left-to-right) self.disp_mode = self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT self.cmd(self.LCD_ENTRYMODESET | self.disp_mode)
def color(self, red, green, blue): pulsos = tuple( self._sacar_secuencia(green) + self._sacar_secuencia(red) + self._sacar_secuencia(blue)) self.rmt.write_pulses(pulsos, start=1) utime.sleep_us(50) self.rmt.write_pulses(pulsos, start=1)
def getPWR(self): #en RILIM = 130 KILIM = 365 GAIN = 12.12 self.p_SHDN_.value(1) utime.sleep_us(10) #Enable Delay Time from Shutdown #ADC.ATTN_0DB (0-1), ADC.ATTN_2_5DB(0-1.33), ADC.ATTN_6DB(0-2), ADC.ATTN_11DB(0-3.55) ILIM = VILIM = 0 ADC_GAIN = [0, 1.334, 1.995, 3.548] for i, e in reversed(list(enumerate(ADC_GAIN))): adc_ILIM = self.adc.channel(attn=i, pin='P20') ILIM = adc_ILIM() if ILIM < 2000 and i > 0: pass else: VILIM = adc_ILIM.voltage() break if ILIM > 0: PWIN_I = (KILIM * (VILIM / GAIN)) / (RILIM * 0.8) elif self._bq25895.pg_stat( ) > 0: #PYCOM mais prob avec ADC ESP32 pour faible valeur PWIN_I = 60.0 else: PWIN_I = 0 #print("ADC : {}, ADC_v = {}, PWIN_I : {}".format(adc_ILIM(), VILIM, PWIN_I) ) self.p_SHDN_.value(0) l.debug("BQ>ATTN:{}, ILIM:{}, PWIN_I:{}".format( ADC_GAINstr[i], ILIM, PWIN_I)) return PWIN_I
def write2LCD_8bits(self, register_select, byte_block, wait_time): time = utime.ticks_us() if(register_select): self.RS.on() # MSB if(byte_block & 128 > 0): self.D7.on() if(byte_block & 64 > 0): self.D6.on() if(byte_block & 32 > 0): self.D5.on() if(byte_block & 16 > 0): self.D4.on() # LSB if(byte_block & 8 > 0): self.D3.on() if(byte_block & 4 > 0): self.D2.on() if(byte_block & 2 > 0): self.D1.on() if(byte_block & 1 > 0): self.D0.on() self.E.on() if((time + wait_time) - utime.ticks_us() > 0): utime.sleep_us((time + wait_time) - utime.ticks_us()) self.E.off() self.RS.off() self.D7.off() self.D6.off() self.D5.off() self.D4.off()
def execute(self, packet): self.wake() # Wait tWHI + tWLO utime.sleep_us(WAKE_DELAY) # Send the command self._bus.writeto(self._address, b'\x03' + packet.to_buffer()) # Delay for execution time utime.sleep_ms(packet.delay) response = packet.response_data_mv # Receive the response self._bus.readfrom_into(self._address, response[0:1]) self._bus.readfrom_into(self._address, response[1:response[0]]) # Check response err, msg = self.is_error(response) if err != ATCA_STATUS.ATCA_SUCCESS: raise ValueError("execute: 0x{:02x} ({:s}) - {:s}".format( err, msg, ubinascii.hexlify(response), )) packet.response_data = response[:response[0]]
def test(): """Bouncing sprite.""" try: # Baud rate of 14500000 seems about the max BLK = Pin(BL_Pin, Pin.OUT) spi = SPI(baudrate=40000000, miso=Pin(MISO_Pin), mosi=Pin(MOSI_Pin, Pin.OUT), sck=Pin(SCLK_Pin, Pin.OUT)) display = ST7789(spi, 135, 240, cs=Pin(CS_Pin), dc=Pin(DC_Pin), rst=None) BLK.value(1) display.clear() # Load sprite logo = BouncingSprite('images/Python41x49.raw', 41, 49, 135, 240, 1, display) while True: timer = ticks_us() logo.update_pos() logo.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: display.cleanup()
def __init__(self, i2c, line=2, char_size=LCD_5x8DOTS): # public self.i2c = i2c # private self._disp_func = LCD_DISPLAYON | char_size | LCD_2LINE if line == 2 else LCD_1LINE self._disp_ctrl = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF self._disp_mode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT # wait display init after power-on sleep_ms(50) # send function set self.cmd(LCD_FUNCTIONSET | self._disp_func) sleep_us(4500) self.cmd(LCD_FUNCTIONSET | self._disp_func) sleep_us(150) self.cmd(LCD_FUNCTIONSET | self._disp_func) self.cmd(LCD_FUNCTIONSET | self._disp_func) # turn on the display self.display(True) # clear it self.clear() # set default text direction (left-to-right) self.cmd(LCD_ENTRYMODESET | self._disp_mode) # init RGB backlight self.i2c.writeto_mem(RGB_ADDR, REG_MODE1, b'\x00') self.i2c.writeto_mem(RGB_ADDR, REG_MODE2, b'\x20') self.i2c.writeto_mem(RGB_ADDR, REG_OUTPUT, b'\xaa')
def read_trace(self): self.sampleCount = 0 self.traceIndex = 0 self.trigCond = False if self.pulse_T < 1: delay = self.pulse_T * 1000 print("Waiting for trigger") while not self.trig(): pass else: print("Trigger seen") self.triggeredAt = self.traceIndex print("Triggered at trace buffer index ", self.triggeredAt) print("value: ", self.traceBuf[self.traceIndex - 1]) if self.no_trig: maxcount = 500 - 1 else: maxcount = 500 - self.trigPos print("maxcount: ", maxcount) for i in range(maxcount): value = self.adc.read() self.traceBuf[self.traceIndex] = value >> 4 # restrict to 8 bits self.traceIndex += 1 if self.traceIndex == 500: # traceBuf is a circular buffer self.traceIndex = 0 if self.pulse_T < 1: sleep_us(delay) else: sleep_ms(self.pulse_T) print("Writing data to disk") self.writeToDisk()
def distance_cm(self): '''Returns the distance from a rangefinder in cm''' self.pin.write_digital(0) utime.sleep_us(200) self.pin.write_digital(1) utime.sleep_us(500) self.pin.write_digital(0) init = utime.ticks_us() stop = init start = init flag = False timeout = 100000 while not self.pin.read_digital(): if utime.ticks_us() - init > timeout: return -1 start = utime.ticks_us() while self.pin.read_digital(): if utime.ticks_us() - start > timeout: return -1 stop = utime.ticks_us() distance = (stop - start) * 343 / 20000 print(stop, start) return distance
def main(): i = 0 while i <= 100: txt = '%04d' % i tm.show(txt, True) i += 1 utime.sleep_us(1000)
def measure(N=1000, delay=200): asum = 0 sqsum = 0 meanVolt = 0 sqmeanVolt = 0 rmsVolt = 0 stdDev = 0 for i in range(N): volt = apin.voltage() asum += volt sqsum += volt * volt sleep_us(delay) meanVolt = asum / N sqmeanVolt = sqsum / N rmsVolt = sqrt(sqmeanVolt) stdDev = sqrt(sqmeanVolt - (meanVolt * meanVolt)) print('meanVoltage:\t{:10.0f} mV'.format(meanVolt)) print('rmsVoltage:\t{:10.0f} mV'.format(rmsVolt)) print('stdDev:\t\t{:10.0f} mV'.format(stdDev))
def measure_distance(self): self.trigger.high() utime.sleep_us(10) self.trigger.low() pulse_time = machine.time_pulse_us(self.echo, 1, 50000) print(pulse_time) return pulse_time
def set_volume(self, volume): self.write_byte(0x0A) HighByte, LowByte = split(volume) self.write_byte(HighByte) self.write_byte(LowByte) self.write_byte(0x0C) sleep_us(2000)
def rotate_some(self, dir, times): ''' :param dir: :return: ''' print('Rotate') self.dir.value(dir) #print('it works2') for i in range(0, times): #print('it works3') self.stp.value(1) # to_log(1) #print('it works4') utime.sleep_us(1000) #print('it works5') self.stp.value(0) #print('it works6') # to_log(2) utime.sleep_us(1000)
def main(self, leg_geom): """Main loop body is in `self.app_control()` """ self.app_init_hardware() self.app_init_software(leg_geom) t0 = ticks_us() oldLoopStart = 0 print("Starting NUMA loop...") while True: #TODO timing? ??? loopStart = ticks_us() #print("------------------------LOOPSTART:", loopStart) desired_loop_time = self.app_control(loopStart) loopEnd = ticks_us() #print("------------------------LOOPEND:", loopEnd) if PRINT_DEBUG_LOOP: print("%ld" % (loopStart - oldLoopStart)) oldLoopStart = loopStart makeup_time = desired_loop_time - ticks_diff(loopEnd, loopStart) if makeup_time > 0: sleep_us(makeup_time) else: print("Slow loop, took:", (PROG_LOOP_TIME - makeup_time) / 1000, "ms (ideal loop time:", PROG_LOOP_TIME / 1000, ")") #print("Slow loop, exceeded looptime by:", -1 * makeup_time / 1000, "ms (ideal loop time:", PROG_LOOP_TIME/1000, ")") #sleep_us(PROG_LOOP_TIME - ticks_diff(loopEnd, loopStart)) if sysname == 'linux' or sysname == 'win32': #print("Simulation loopstart time:", loopStart, "us", "Uptime:", (loopStart - t0)/1e6) pass
def sendMessage(self, data,size = 32): reg = [0b10100000] self.csnLow() self.spi.write(bytearray([0b11100001])) self.csnHigh() self.csnLow() self.spi.write(bytearray(reg)) localData = bytearray(data) localData.extend(bytearray(size - len(localData))) self.spi.write(bytearray(localData)) self.csnHigh() self.ceHigh() utime.sleep_us(10) for i in range(0,10000): reg = self.readReg(7)[0] if reg & 0b00110000: break self.ceLow() self.writeReg(7,0b00110000) # Clear status flags.
def run_sensor(temp): # Make sure output is low trigger.value(0) utime.sleep_us(10) # Trigger 8 cycle sonic burst by setting trigger to high for 10us trigger.value(1) utime.sleep_us(10) trigger.value(0) # Wait for pulse to start on input pin. while echo() == 0: pass start = utime.ticks_us() # Run until input pin changes to low. while echo() == 1: pass finish = utime.ticks_us() utime.sleep_ms(10) # MCP9700A temperature sensor # T_A = temp.readTemp(analog_pin) if(isinstance(temp, str) == False): speed_sound = (331.4 + 0.6 * temp) * 0.0001 # cm/us else: speed_sound = (331.4 + 0.6 * 14.5) * 0.0001 # cm/us # Calculate and print out distance measured. return ((utime.ticks_diff(finish, start)) * speed_sound)/2
def continueWithDataCapture(i2cDev): # INITIALIZATION print("DEFAULT MODE:", getCurrentMode(i2cDev)) i2c.write(i2cDev, mag3110.CTRL_REG1, 0x00) utime.sleep_us(500) i2c.write(i2cDev, mag3110.CTRL_REG2, 0x80) print("NEW MODE:", getCurrentMode(i2cDev)) utime.sleep_us(500) setOffset(i2cDev, mag3110.OFF_X_MSB, mag3110.OFF_X_LSB, 0) utime.sleep_us(500) setOffset(i2cDev, mag3110.OFF_Y_MSB, mag3110.OFF_Y_LSB, 0) utime.sleep_us(500) setOffset(i2cDev, mag3110.OFF_Z_MSB, mag3110.OFF_Z_LSB, 0) utime.sleep_us(500) i2c.write(i2cDev, mag3110.CTRL_REG1, ((i2c.read(i2cDev, mag3110.CTRL_REG1)[0]) | mag3110.MAG3110_ACTIVE_MODE)) utime.sleep(1) count = 1 while (1 == 1): print(count, ":", readValues(i2cDev)) count += 1 utime.sleep(1)
def read_distance(self): self.motor_stop(LEFT_MOTOR) self.motor_stop(RIGHT_MOTOR) divider = 42 maxtime = 250 * divider pin2.read_digital() pin1.write_digital(0) utime.sleep_us(2) pin1.write_digital(1) utime.sleep_us(10) pin1.write_digital(0) duration = machine.time_pulse_us(pin2, 1, maxtime) distance = duration / divider color = (0, 255, 0) if distance <= 35: color = (255, 0, 0) elif distance > 35 and distance < 50: color = (255, 128, 0) for led in range(4): self.np[led] = color self.np.show() return distance
def read_raw_data(self, result): """ Reads the raw (uncompensated) data from the sensor. Args: result: array of length 3 or alike where the result will be stored, in temperature, pressure, humidity order Returns: None """ self._l1_barray[ 0] = self._mode_temperature << 5 | self._mode_pressure << 2 | BMP280_POWER_MODE_FORCED self.i2c.writeto_mem(self.address, BMP280_REGISTER_CONTROL, self._l1_barray) time.sleep_us(self.compute_delay_time()) # Wait the required time # burst readout from 0xF7 to 0xFC, recommended by datasheet # we read the 6 bytes (3 bytes each) self.i2c.readfrom_mem_into(self.address, 0xF7, self._l8_barray) readout = self._l8_barray # pressure(0xF7): ((msb << 16) | (lsb << 8) | xlsb) >> 4 raw_press = ((readout[0] << 16) | (readout[1] << 8) | readout[2]) >> 4 # temperature(0xFA): ((msb << 16) | (lsb << 8) | xlsb) >> 4 raw_temp = ((readout[3] << 16) | (readout[4] << 8) | readout[5]) >> 4 result[0] = raw_temp result[1] = raw_press
def loop(self, base_t=1000, clockwise=True, limit=400): n = 0 t = base_t cicle = 0 while True: self.tick(n) if clockwise: n += 1 else: n -= 1 if n > 8: n = 0 cicle += 1 elif n < 0: n = 8 cicle += 1 if cicle > 10 and cicle % 10 == 0: if t > 4: t = int(round(t * 0.9, 0)) if t < limit: t = limit if cicle > 10000: cicle = 0 if t > 0: utime.sleep_us(t)
def test(): """Bouncing box.""" try: # Baud rate of 40000000 seems about the max spi = SPI(1, baudrate=40000000, sck=Pin(14), mosi=Pin(13)) display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17)) display.clear() colors = [ color565(255, 0, 0), color565(0, 255, 0), color565(0, 0, 255), color565(255, 255, 0), color565(0, 255, 255), color565(255, 0, 255) ] sizes = [12, 11, 10, 9, 8, 7] boxes = [Box(239, 319, sizes[i], display, 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: display.cleanup()
def test(): """Bouncing box.""" display=Display(spi,SPI_CS,SPI_DC) try: display.clear() colors = [color565(255, 0, 0), color565(0, 255, 0), color565(0, 0, 255), color565(255, 255, 0), color565(0, 255, 255), color565(255, 0, 255)] sizes = [12, 11, 10, 9, 8, 7] boxes = [Box(128, 128, sizes[i], display, 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: display.cleanup()
def measurement(avg): global echo global trig measurements = [] for x in range(0,avg+1): trig.on() utime.sleep_us(10) trig.off() pulse_start=0 pulse_end=0 timeout = 10000 while echo.value() is 0 and timeout > 0: pulse_start = utime.ticks_us() timeout -= 1 timeout = 10000 while echo.value() is 1 and timeout > 0: pulse_end = utime.ticks_us() timeout -=1 if timeout > 0: pulse_duration = utime.ticks_diff(pulse_end,pulse_start)/(pow(10,6)) distance = pulse_duration * 17150 distance = round(distance, 2) measurements.append(distance) else: measurements.append(0) utime.sleep_us(10) return sum(measurements)/len(measurements)
def CheckDistance(): SpeedOfSoundInCM = 0.034 # begin the LOW/HIGH/LOW trigger output sequence Trig.low() utime.sleep_us(2) Trig.high() utime.sleep_us(10) Trig.low() exitLoop = False loopcount = 0 #used as a failsafe if the signal doesn't return # now we wait for the Echo pin to go high while Echo.value() == 0 and exitLoop == False: loopcount = loopcount + 1 delaytime = utime.ticks_us() # give up after 3,000 tries if loopcount > 3000 : exitLoop == True # we now a high if we did not timeout while Echo.value() == 1 and exitLoop == False: loopcount = loopcount + 1 receivetime = utime.ticks_us() # give up after 3,000 tries if loopcount > 3000 : exitLoop == True if exitLoop == True: #We failed somewhere return 0 else: distance = ((receivetime – delaytime) * SpeedOfSoundInCM) / 2 return distance
def _wait_(duration): global do_blinking while (duration > 0): utime.sleep_us(750) # adapted by feeling. longer due to other cmds duration = duration - 1 if (do_blinking == False): return
def distance_measure(): # trigger pulse LOW for 2us (just in case) trigger(0) utime.sleep_us(2) # trigger HIGH for a 10us pulse trigger(1) utime.sleep_us(10) trigger(0) # wait for the rising edge of the echo then start timer while echo() == 0: pass start = utime.ticks_us() # wait for end of echo pulse then stop timer while echo() == 1: pass finish = utime.ticks_us() # pause for 20ms to prevent overlapping echos utime.sleep_ms(20) # calculate distance by using time difference between start and stop # speed of sound 340m/s or .034cm/us. Time * .034cm/us = Distance sound travelled there and back # divide by two for distance to object detected. # Note: changing the multiplying factor to 0.0133858 for inches distance = ((utime.ticks_diff(start, finish)) * 0.0133858) / 2 return distance * -1
def make_payload(): pycom.rgbled(blue) #distance = distance_median() count = pycom.nvs_get('dist') utime.sleep_us(100) #randomize water distance distance = os.urandom(1)[0] print("distance = {0} inches".format(distance)) utime.sleep_ms(100) #subract 0.1V from battery voltage every 5 counts c = count v = pycom.nvs_get('v') if c % 5 == 0: v += 1 pycom.nvs_set('v', v) print("v={0}".format(v)) voltage = 4.0 - v * 0.1 print("Measured Voltage: {0}V".format(voltage)) #randomize flow rate x = os.urandom(1)[0] flow_rate = x % 4 if (flow_rate < 3): print(flow_rate) else: flow_rate -= 1 print(flow_rate) print("Flow Rate: {0}".format(flow_rate)) #generate encoded packet to send to webapp full_packet = ustruct.pack('f', count) + ustruct.pack( 'f', float(distance)) + ustruct.pack('f', voltage) + ustruct.pack( 'f', float(flow_rate)) return full_packet
def freq(self, freq=None): if freq is None: return int(25000000.0 / 4096 / (self._read(0xfe) - 0.5)) prescale = int(25000000.0 / 4096.0 / freq + 0.5) old_mode = self._read(0x00) # Mode 1 self._write(0x00, (old_mode & 0x7F) | 0x10) # Mode 1, sleep self._write(0xfe, prescale) # Prescale self._write(0x00, old_mode) # Mode 1 utime.sleep_us(5) self._write(0x00, old_mode | 0xa1) # Mode 1, autoincrement on
def start_listening(self): self.reg_write(CONFIG, self.reg_read(CONFIG) | PWR_UP | PRIM_RX) self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT) if self.pipe0_read_addr is not None: self.reg_write_bytes(RX_ADDR_P0, self.pipe0_read_addr) self.flush_rx() self.flush_tx() self.ce(1) utime.sleep_us(130)
def main(): # set internal clock rtc = settime(timezone_offset=TIMEZONE_OFFSET) year, month, day, hour, minute, second, *_ = rtc.now() trigger = Pin('GP5', mode=Pin.OUT) trigger.value(0) # initial trigger timer timer = Timer(3, mode=Timer.PERIODIC, width=32) timer_channel = timer.channel(Timer.A | Timer.B, period=30000000) timer_channel.irq(handler=lambda t: trigger.toggle(), trigger=Timer.TIMEOUT) try: while True: leds = clock2matrix(hour=hour, minute=minute).columns # led matrix multiplexing current_trigger = trigger.value() while trigger.value() == current_trigger: for col in leds: latch.value(0) # write current time spi.write(col) # update LEDs latch.value(1) sleep_ms(1) latch.value(0) spi.write(OFF) latch.value(1) sleep_us(50) latch.value(0) spi.write(OFF) latch.value(1) year, month, day, hour, minute, second, *_ = rtc.now() # update rtc at 04:00 if hour == 4 and minute == 0: rtc = settime(timezone_offset=TIMEZONE_OFFSET) except Exception as e: matrix_off() while True: print(e) sleep_ms(2000)
def send_start(self, buf): # power up self.reg_write(CONFIG, (self.reg_read(CONFIG) | PWR_UP) & ~PRIM_RX) utime.sleep_us(150) # send the data self.cs(0) self.spi.readinto(self.buf, W_TX_PAYLOAD) self.spi.write(buf) if len(buf) < self.payload_size: self.spi.write(b'\x00' * (self.payload_size - len(buf))) # pad out data self.cs(1) # enable the chip so it can send the data self.ce(1) utime.sleep_us(15) # needs to be >10us self.ce(0)
def hal_pulse_enable(self): """Pulse the enable line high, and then low again.""" self.enable_pin.value(0) sleep_us(1) self.enable_pin.value(1) sleep_us(1) # Enable pulse needs to be > 450 nsec self.enable_pin.value(0) sleep_us(100) # Commands need > 37us to settle
def test(): utime.sleep_us(10000)
import utime try: utime.sleep_ms except AttributeError: print("SKIP") raise SystemExit utime.sleep_ms(1) utime.sleep_us(1) print(utime.ticks_diff(utime.ticks_ms(), utime.ticks_ms()) <= 1) print(utime.ticks_diff(utime.ticks_us(), utime.ticks_us()) <= 500)