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 self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL_HUM, self._l1_barray) self._l1_barray[0] = self._mode << 5 | self._mode << 2 | 1 self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL, self._l1_barray) sleep_time = 1250 + 2300 * (1 << self._mode) sleep_time = sleep_time + 2300 * (1 << self._mode) + 575 sleep_time = sleep_time + 2300 * (1 << self._mode) + 575 time.sleep_us(sleep_time) # Wait the required time # burst readout from 0xF7 to 0xFE, recommended by datasheet 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 # humidity(0xFD): (msb << 8) | lsb raw_hum = (readout[6] << 8) | readout[7] result[0] = raw_temp result[1] = raw_press result[2] = raw_hum
def awaitReset(self): try: try: machine.time_pulse_us(self.pin, 1) except: self.err = 'Not Connected' return False t = machine.time_pulse_us(self.pin, 0) if t < 480: self.err = 'Very short reset ' + str(t) + 'us' return False except: self.err = 'Very long reset' return False self.pin.init(self.pin.OUT_OD) self.pin.low() time.sleep_us(60) # let it float self.pin.init(self.pin.IN, self.pin.PULL_NONE) time.sleep_us(5) if self.pin.value() == 0: self.err = 'No presence response from door' return False else: return True
def read_battery_voltage(self): self.set_bits_in_memory(ADCON0_ADDR, _ADCON0_GO_nDONE_MASK) time.sleep_us(50) while self.peek_memory(ADCON0_ADDR) & _ADCON0_GO_nDONE_MASK: time.sleep_us(100) adc_val = (self.peek_memory(ADRESH_ADDR) << 2) + (self.peek_memory(ADRESL_ADDR) >> 6) return (((adc_val * 3.3 * 280) / 1023) / 180) + 0.01 # add 10mV to compensate for the drop in the FET
def _wait(self): count = 0 time.sleep_us(10) while self.i2c.readfrom(I2C_SLAVE_ADDR, 1)[0] != 0xFF: time.sleep_us(100) count += 1 if (count > 500): # timeout after 50ms raise Exception('Pytrack board timeout')
def refresh(self): """ Start a new measurement. """ self._cs.off() time.sleep_us(10) self._cs.on() self._last_measurement_start = time.ticks_ms()
def __start( self, addr ): """ Start a SPI transaction @ addr """ # Start new transaction self.ssel.value( 1 ) #sleep_ms( 1 ) # 1 Ms between SPI transaction seems right sleep_us( 10 ) self.ssel.value( 0 ) self.spi.write( ustruct.pack( '>H', addr) ) # Convert address in MSB and LSB
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 time.sleep_us(5) self._write(0x00, old_mode | 0xa1) # Mode 1, autoincrement on
def createChar(self, location, charmap): # Write to CGRAM of new characters # Only 8 locations 0-7 location &= 0x7 self.command(HD44780LCD.LCD_SETCGRAMADDR | (location << 3)) time.sleep_us(40) for i in range(8): self.write(charmap[i]) time.sleep_us(40)
def custom_char(self, location, charmap): """Write a character to one of the 8 CGRAM locations, available as chr(0) through chr(7). """ location &= 0x7 self.hal_write_command(self.LCD_CGRAM | (location << 3)) time.sleep_us(40) for i in range(8): self.hal_write_data(charmap[i]) time.sleep_us(40) self.move_to(self.cursor_x, self.cursor_y)
def getval(pin): """readout a dht11/22 sensor""" ms = [1] * 300 pin(0) time.sleep_us(20000) pin(1) irqf = disable_irq() for i in range(len(ms)): ms[i] = pin() # sample input and store value enable_irq(irqf) return ms
def recvAndProcessCmd(self): # self.waitForRequestfake(False) r = self.recv() if r == 0x33: if not self.sendData(self.rom): return False return True else: print("Received: {}".format(r)) self.err = 'Did not receive 0x33' time.sleep_us(1000000) return False
def checkdist(self): self.trig.value(0) self.echo.value(0) self.trig.value(1) time.sleep_us(10) self.trig.value(0) while(self.echo.value()==0): pass t1=time.ticks_us() while(self.echo.value()==1): pass t2=time.ticks_us() return round(time.ticks_diff(t2,t1)/10000*340/2,2)
def rotate(RPM, angle): if(RPM > 20): print("RPM should less than 20") return delay = int(60*1000*1000/4096/RPM) steps = int(512*abs(angle)/360) if angle < 0: direction = -1 else: direction = 1 for i in range(steps): for step in seq[::direction]: set_step(step) sleep_us(delay)
def sendBit(self, bit): try: machine.time_pulse_us(self.pin, 0, timeout_us=60) except: self.err = 'Write timeslot timeout' return if bit & 1: return else: self.pin.low() self.pin.init(self.pin.OUT_OD) time.sleep_us(60) self.pin.init(self.pin.IN, self.pin.PULL_NONE) return
def distance_in_cm(self): # Send a 10us pulse self.trigger.on() sleep_us(10) self.trigger.off() # Wait for the pulse and calc its duration time_pulse = time_pulse_us(self.echo, 1, self.timeout) if time_pulse < 0: raise MeasurementTimeout(self.timeout) # Divide the duration of the pulse by 2 (round-trip) and then divide it # by 29 us/cm (speed of sound = ~340 m/s) return (time_pulse / 2) / 29
def measure(): Trig.low() sleep_us(15) Trig.high() sleep_us(15) Trig.low() while(Echo.value() == 0): start = ticks_us() while(Echo.value() == 1): end = ticks_us() duration = end - start dist = 0.03435 * 0.5 * duration print("duration: " + str(duration) + ", " + \ "distance: " + str(dist)) return dist
def wait_response(self): start = time.ticks_ms() while 1: try: self.i2c.readfrom_into(self.addr, self.buf1) n = self.buf1[0] break except OSError as er: time.sleep_us(500) if time.ticks_diff(time.ticks_ms(), start) > 5000: raise Exception('timeout') if n >= 129: raise Exception(n) if n == 0: return b'' else: return self.i2c.readfrom(self.addr, n)
def send_command(self, ins, p1, p2, data=None, expected=None): # These command variables are always sent cmd = struct.pack('3B', ins, p1, p2) # Looks like data is only sent with the length (Lc) if data: assert len(data) <= 251 # Thus speaks the datasheet cmd += struct.pack('B', len(data)) cmd += data # Expected data is either not present at all, 0 for null-terminated, or a number for fixed if expected is not None: cmd += struct.pack('B', expected) if self.debug: print("Sending: " + hexlify(cmd).decode()) self.spi.write(cmd) # Wait for a little while time.sleep_us(15) # This should take at most 14.5us while self.tc_busy_bar() == 0: machine.idle() # Request a response if expected is not None: if expected > 0: result_bytes = self.spi.read(2 + expected) else: result_bytes = self.spi.read(EPD.MAX_READ) strlen = result_bytes.find(b'\x00') result_bytes = result_bytes[:strlen] + result_bytes[strlen+1:strlen+3] else: result_bytes = self.spi.read(2) if self.debug: print("Received: " + hexlify(result_bytes).decode()) (result,) = struct.unpack_from('>H', result_bytes[-2:]) if result != EPD.SW_NORMAL_PROCESSING: raise ValueError("Bad result code: 0x%x" % result) return result_bytes[:-2]
def _send_pulse_and_wait(self): """ Send the pulse to trigger and listen on echo pin. We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received. """ self.trigger.value(0) # Stabilize the sensor time.sleep_us(5) self.trigger.value(1) # Send a 10us pulse. time.sleep_us(10) self.trigger.value(0) try: pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us) return pulse_time except OSError as ex: if ex.args[0] == 110: # 110 = ETIMEDOUT raise OSError('Out of range') raise ex
def write8(self, value, char_mode=False): """Write 8-bit value in character or data mode. Value should be an int value from 0-255, and char_mode is True if character data or False if non-character data (default). """ # One millisecond delay to prevent writing too quickly. time.sleep_us(1000) # Set character / data bit. self._rs(char_mode) # Write upper 4 bits. self._d4((value >> 4) & 1) self._d5((value >> 5) & 1) self._d6((value >> 6) & 1) self._d7((value >> 7) & 1) self._pulse_enable() # Write lower 4 bits. self._d4(value & 1) self._d5((value >> 1) & 1) self._d6((value >> 2) & 1) self._d7((value >> 3) & 1) self._pulse_enable()
def breath(): Brightness = 90 Inhale = 800 Pulse = Inhale*1000/Brightness for i in range(Brightness): p.low() sleep_us(i*10) p.high() sleep_us(int(Pulse) - i*10) for i in range(Brightness, 0, -1): p.low() sleep_us(i*10) p.high() sleep_us(int(Pulse) - i*10)
def _pulse_enable(self): # Pulse the clock enable line off, on, off to send command. self._en(0) time.sleep_us(5) self._en(1) time.sleep_us(5) self._en(0) time.sleep_us(50)
def read(self): """ Reads last measurement and starts a new one. If new measurement is not ready yet, returns last value. Note: The last measurement can be quite old (e.g. since last call to `read`). To refresh measurement, call `refresh` and wait for `ready` to become True before reading. :return: Measured temperature """ # Check if new reading is available if self.ready(): # Bring CS pin low to start protocol for reading result of # the conversion process. Forcing the pin down outputs # first (dummy) sign bit 15. self._cs.off() time.sleep_us(10) # Read temperature bits 14-3 from MAX6675. value = 0 for i in range(12): # SCK should resemble clock signal and new SO value # is presented at falling edge self._cycle_sck() value += self._so.value() << (11 - i) # Read the TC Input pin to check if the input is open self._cycle_sck() self._error = self._so.value() # Read the last two bits to complete protocol for i in range(2): self._cycle_sck() # Finish protocol and start new measurement self._cs.on() self._last_measurement_start = time.ticks_ms() self._last_read_temp = value * 0.25 return self._last_read_temp
def shiftOut(self, data, latch=True): # print(data) for bit in range(8): print(bit) if 0 == (data & (1<<bit)): self._dataPin.value(0) print("low") else: self._dataPin.value(1) print("high") self._clockPin.value(0) time.sleep_us(1) self._clockPin.value(1) time.sleep_us(10) if(latch): self._latchPin.value(0) time.sleep_us(1) self._latchPin.value(1) time.sleep_us(1)
def sleep_us(self, useconds): try: time.sleep_us(useconds) except AttributeError: machine.udelay(useconds)
def _wake(self): self._cmd(_RDP) time.sleep_us(100)
def _write_byte(self, b): for i in range(8): self.dio.write_digital((b >> i) & 1) time.sleep_us(TM1637_DELAY) self.clk.write_digital(1) time.sleep_us(TM1637_DELAY) self.clk.write_digital(0) time.sleep_us(TM1637_DELAY) self.clk.write_digital(0) time.sleep_us(TM1637_DELAY) self.clk.write_digital(1) time.sleep_us(TM1637_DELAY) self.clk.write_digital(0) time.sleep_us(TM1637_DELAY)
def __init__(self, clk, dio): self.clk = clk self.dio = dio time.sleep_us(TM1637_DELAY) self._write_data_cmd() self._write_dsp_ctrl()
def send_id(out_signal, pin_name): L2 = Pin(pin_name, mode=Pin.AF_PP, af=Pin.AF1_TIM2) timer = Timer(2, freq=38000) ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0.5) sleep_us(9000) ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0) sleep_us(4500) for i in out_signal: if i == "0": ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0.5) sleep_us(560) ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0) sleep_us(565) else: ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0.5) sleep_us(560) ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0) sleep_us(1690) ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0.5) sleep_us(560) ch = timer.channel(1, Timer.PWM, pin=L2, pulse_width_percent=0)
def initg(self): '''Initialize a green tab version.''' self._reset() self._writecommand(TFT.SWRESET) #Software reset. time.sleep_us(150) self._writecommand(TFT.SLPOUT) #out of sleep mode. time.sleep_us(255) data3 = bytearray([0x01, 0x2C, 0x2D ]) #fastest refresh, 6 lines front, 3 lines back. self._writecommand(TFT.FRMCTR1) #Frame rate control. self._writedata(data3) self._writecommand(TFT.FRMCTR2) #Frame rate control. self._writedata(data3) data6 = bytearray([0x01, 0x2c, 0x2d, 0x01, 0x2c, 0x2d]) self._writecommand(TFT.FRMCTR3) #Frame rate control. self._writedata(data6) time.sleep_us(10) self._writecommand(TFT.INVCTR) #Display inversion control self._writedata(bytearray([0x07])) self._writecommand(TFT.PWCTR1) #Power control data3[0] = 0xA2 data3[1] = 0x02 data3[2] = 0x84 self._writedata(data3) self._writecommand(TFT.PWCTR2) #Power control self._writedata(bytearray([0xC5])) data2 = bytearray(2) self._writecommand(TFT.PWCTR3) #Power control data2[0] = 0x0A #Opamp current small data2[1] = 0x00 #Boost frequency self._writedata(data2) self._writecommand(TFT.PWCTR4) #Power control data2[0] = 0x8A #Opamp current small data2[1] = 0x2A #Boost frequency self._writedata(data2) self._writecommand(TFT.PWCTR5) #Power control data2[0] = 0x8A #Opamp current small data2[1] = 0xEE #Boost frequency self._writedata(data2) self._writecommand(TFT.VMCTR1) #Power control self._writedata(bytearray([0x0E])) self._writecommand(TFT.INVOFF) self._setMADCTL() self._writecommand(TFT.COLMOD) self._writedata(bytearray([0x05])) self._writecommand(TFT.CASET) #Column address set. self.windowLocData[0] = 0x00 self.windowLocData[1] = 0x01 #Start at row/column 1. self.windowLocData[2] = 0x00 self.windowLocData[3] = self._size[0] - 1 self._writedata(self.windowLocData) self._writecommand(TFT.RASET) #Row address set. self.windowLocData[3] = self._size[1] - 1 self._writedata(self.windowLocData) dataGMCTRP = bytearray([ 0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d, 0x29, 0x25, 0x2b, 0x39, 0x00, 0x01, 0x03, 0x10 ]) self._writecommand(TFT.GMCTRP1) self._writedata(dataGMCTRP) dataGMCTRN = bytearray([ 0x03, 0x1d, 0x07, 0x06, 0x2e, 0x2c, 0x29, 0x2d, 0x2e, 0x2e, 0x37, 0x3f, 0x00, 0x00, 0x02, 0x10 ]) self._writecommand(TFT.GMCTRN1) self._writedata(dataGMCTRN) self._writecommand(TFT.NORON) #Normal display on. time.sleep_us(10) self._writecommand(TFT.DISPON) time.sleep_us(100) self.cs(1)
def _cycle_sck(self): self._sck.on() time.sleep_us(1) self._sck.off() time.sleep_us(1)
def _pulse(self): """Trigger ultrasonic module with 10us pulse.""" self._trig.value(1) sleep_us(10) self._trig.value(0)
def _cycle_sck(self): self._sck(1) time.sleep_us(1) self._sck(0) time.sleep_us(1)
from machine import Pin from neopixel import NeoPixel pin = Pin(15, Pin.OUT) # set GPIO0 to output to drive NeoPixels np = NeoPixel(pin, 8) # create NeoPixel driver on GPIO0 for 8 pixels np[0] = (255, 255, 255) # set the first pixel to white np.write() # write data to all pixels r, g, b = np[0] # get first pixel colour for i in range(8): np[i] = (255, 255, 255) np.write() import time time.sleep(1) # sleep for 1 second time.sleep_ms(500) # sleep for 500 milliseconds time.sleep_us(10) # sleep for 10 microseconds def fita(r,g,b): for i in range(8): np[i] = (r,g,b) np.write() def yellow(): for i in range(255): fita(i,i,0) time.sleep_ms(100) def yellow(): for i in range(255): fita(i,i,0)
def octopus_demo(): print() #global notInitServo notInitServo = True global oled global fet ###beep(pwm0,500,100) # start beep #tim.init(period=1000, mode=Timer.ONE_SHOT, callback=lambda t:print("test timer - thread delay")) #tim.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(2)) printOctopus() print("Hello, this is basic octopusLAB example") print(" (Press Ctrl+C to abort | CTRL+D to soft reboot)") print() time.sleep_us(10) # sleep for 10 microseconds led.blink(500) time.sleep_ms(300) # 1s start = time.ticks_ms() run = True while run: sel = mainMenu() piezzo.beep(1000, 50) if sel == "a": print("analog input test: ") pin_an = Pin(pinout.ANALOG_PIN, Pin.IN) adc = machine.ADC(pin_an) an = adc.read() print("RAW: " + str(an)) # TODO improve mapping formula, doc: https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/peripherals/adc.html print("volts: {0:.2f} V".format(an / 4096 * 10.74), 20, 50) if sel == "b": count = 5 for _ in range(count): piezzo.beep(500, 100) led.blink(500) if sel == "bt": butt1 = Pin(pinout.BUTT1_PIN, Pin.IN, Pin.PULL_UP) butt2 = Pin(pinout.BUTT2_PIN, Pin.IN, Pin.PULL_UP) butt3 = Pin(pinout.BUTT3_PIN, Pin.IN, Pin.PULL_UP) count = 10 for _ in range(count): print("b1-" + str(butt1.value())), print("b2-" + str(butt2.value())), print("b3-" + str(butt3.value())) piezzo.beep(500, 100) led.blink(500) if sel == "c": clt() printOctopus() if sel == "f": print("file info /dir/ls:") # print(os.listdir()) print("> lib: " + str(os.listdir("lib"))) print("> util: " + str(os.listdir("util"))) print("> pinouts: " + str(os.listdir("pinouts"))) i2c_scann() if sel == "i": print("System info:") print("> octopus() ver: " + ver) from util.sys_info import sys_info sys_info() if sel == "m": time.sleep_ms(500) from util.buzzer.melody import mario piezzo.play_melody(mario) piezzo.nosound() if sel == "r1": RGBtest() if sel == "r8": np = rgb_init(8) Rainbow() if sel == "r80": NUMBER_LED = 8 np = rgb_init(NUMBER_LED) for i in range(NUMBER_LED): np[i] = (1, 0, 0) time.sleep_ms(1) # REVIEW: np.write() if sel == "s": from util.setup import setup setup() if sel == "t": print("temperature >") from lib.temperature import TemperatureSensor ts = TemperatureSensor(pinout.ONE_WIRE_PIN) temp = ts.read_temp() # print to console print(temp) if sel == "w": w_connect() if sel == "wr1": w_connect() np = rgb_init(1) import urequests import json url1 = "http://octopuslab.cz/api/ws.json" print(url1) r1 = urequests.post(url1) j = json.loads(r1.text) time.sleep_ms(2000) print(j["r"]) np[0] = (j["r"], j["g"], j["b"]) #R np.write() if sel == "q": print("machine.reset() and Exit") time.sleep_ms(1000) machine.reset() run = False if sel == "d": printOctopus() print(">>> Display test submenu") print('=' * 30) print("--- [od] --- oled display test") print("--- [os] --- oled 3segment") print("--- [oi] --- oled display image") print("--- [m7] --- max display 8x7-segm") print("--- [m8] --- max display 8x8-matrix") print("--- [sd] --- serial display") print("-+- [nd] -+- Nextion display") print("-+- [id] -+- ink display") print('=' * 30) sel_d = input("select: ") if sel_d == "od": print("oled display test >") oled_intit() oled.fill(1) oled.show() time.sleep_ms(300) oled.fill(0) # reset display oled.show() # write text on x, y oled.text('OLED test', 25, 10) oled.text(get_hhmm(":", rtc), 45, 29) #time HH:MM oled.hline(0, 50, 128, 1) oled.text("octopusLAB 2018", 5, 55) #time HH:MM oled.show() time.sleep_ms(1000) if sel_d == "os": print("oled segment test >") oled_intit() #from util.display_segment import * #??? for num in range(10): threeDigits(oled, 20 + num, True, True) time.sleep_ms(50) if sel_d == "oi": print("oled image test >") oled_intit() import framebuf IMAGE_WIDTH = 63 IMAGE_HEIGHT = 63 with open('assets/octopus_image.pbm', 'rb') as f: f.readline() # Magic number f.readline() # Creator comment f.readline() # Dimensions data = bytearray(f.read()) fbuf = framebuf.FrameBuffer(data, IMAGE_WIDTH, IMAGE_HEIGHT, framebuf.MONO_HLSB) # To display just blit it to the display's framebuffer (note you need to invert, since ON pixels are dark on a normal screen, light on OLED). oled.invert(1) oled.blit(fbuf, 0, 0) oled.text("Octopus", 66, 6) oled.text("Lab", 82, 16) oled.text("Micro", 74, 35) oled.text("Python", 70, 45) oled.show() if sel_d == "m7": from lib.max7219_8digit import Display #spi = SPI(-1, baudrate=100000, polarity=1, phase=0, sck=Pin(14), mosi=Pin(13), miso=Pin(2)) #ss = Pin(15, Pin.OUT) d7 = Display(spi, ss) d7.write_to_buffer('12345678') d7.display() if sel_d == "m8": from lib.max7219 import Matrix8x8 d8 = Matrix8x8(spi, ss, 1) #1/4 #print("SPI device already in use") count = 6 for i in range(count): d8.fill(0) d8.text(str(i), 0, 0, 1) d8.show() print(i) time.sleep_ms(500) d8.fill(0) d8.show() if sel_d == "sd": from machine import UART uart = UART(2, 9600) #UART2 > #U2TXD(SERVO1/PWM1_PIN) uart.write('C') #test quick clear display uart.write('W7') #change color uart.write('h30') #horizontal line uart.write('h230') #horizontal line uart.write('R0') uart.write('W2') #color uart.write('QoctopusLAB - UART2 test*') time.sleep_ms(100) uart.write('R2') uart.write('W1') #color uart.write('QESP32 & ROBOTboard*') time.sleep_ms(100) uart.write('R5') uart.write('W2') #color num = 9 for i in range(num): uart.write('Q') uart.write(str(num - i - 1)) uart.write('*') time.sleep_ms(500) if sel == "r": printOctopus() print() print('=' * 30) print(">>> Boards special test") print('.' * 30) print(" Robot board") print("--- [dc] --- dc motor test") print("--- [se] --- servo") print("--- [sm] --- step motor") print('.' * 30) print(" IoT board") print("--- [re] --- relay test") print("--- [fa] --- pwm fan test") print("--- [li] --- led fade in") print("--- [lo] --- led fade out") print("--- [lp] --- led pulse") print('=' * 30) sel_r = input("select: ") if sel_r == "dc": print("dc motor test >") a1 = Pin(pinout.MOTOR_1A, Pin.OUT) a2 = Pin(pinout.MOTOR_2A, Pin.OUT) a12 = Pin(pinout.MOTOR_12EN, Pin.OUT) a3 = Pin(pinout.MOTOR_3A, Pin.OUT) a4 = Pin(pinout.MOTOR_4A, Pin.OUT) a34 = Pin(pinout.MOTOR_34EN, Pin.OUT) a34.value(0) a12.value(1) print("a12:10") a1.value(1) a2.value(0) time.sleep_ms(3000) print("a12:01") a1.value(0) a2.value(1) time.sleep_ms(3000) a12.value(0) a34.value(1) print("a34:01") a3.value(0) a4.value(1) time.sleep_ms(3000) print("a12:10") a3.value(1) a4.value(0) time.sleep_ms(3000) a34.value(0) if sel_r == "se": print("servo1 test >") #pwm_center = int(pinout.SERVO_MIN + (pinout.SERVO_MAX-pinout.SERVO_MIN)/2) pwm_center = 60 #if notInitServo: print("init-servo:") pin_servo1 = Pin(pinout.PWM1_PIN, Pin.OUT) servo1 = PWM(pin_servo1, freq=50, duty=pwm_center) print("OK") time.sleep_ms(1500) #notInitServo = False time.sleep_ms(1500) servo1.duty(SERVO_MAX) time.sleep_ms(1500) servo1.duty(SERVO_MIN) time.sleep_ms(1500) print("degree45") set_degree(servo1, 45) if sel_r == "sm": from lib.sm28byj48 import SM28BYJ48 #PCF address = 35 #33-0x21/35-0x23 ADDRESS = 0x23 # motor id 1 or 2 MOTOR_ID1 = 1 #MOTOR_ID2 = 2 i2c_sda = Pin(pinout.I2C_SDA_PIN, Pin.IN, Pin.PULL_UP) i2c_scl = Pin(pinout.I2C_SCL_PIN, Pin.OUT, Pin.PULL_UP) i2c = machine.I2C(scl=i2c_scl, sda=i2c_sda, freq=100000) # 100kHz as Expander is slow :( motor1 = SM28BYJ48(i2c, ADDRESS, MOTOR_ID1) # turn right 90 deg motor1.turn_degree(90) # turn left 90 deg motor1.turn_degree(90, 1) if sel_r == "re": print("relay test >") rel = Pin(pinout.RELAY_PIN, Pin.OUT) rel.value(1) time.sleep_ms(3000) rel.value(0) if sel_r == "li": if not fet: fet = Pin(pinout.MFET_PIN, Pin.OUT) print("led - pwm fade in - test >") #lf = PWM(Pin(pinout.MFET_PIN)) #lf.duty(0) #lf.freq(5000) #time.sleep_ms(1000) #for i in range(100): # lf.duty(i*10) # time.sleep_ms(20) fade_in(fet, 500, 5) if sel_r == "lo": if not fet: fet = Pin(pinout.MFET_PIN, Pin.OUT) print("led - pwm fade out - test >") #lf = PWM(Pin(pinout.MFET_PIN)) #lf.duty(1000) #lf.freq(5000) #time.sleep_ms(1000) #for i in range(100): # lf.duty(1000-i*10) # time.sleep_ms(20) fade_out(fet, 500, 5) if sel_r == "lp": lf = PWM(Pin(pinout.MFET_PIN)) for i in range(5): pulse(lf, 200) if sel == "p": printOctopus() print() print(">>> Projects submenu") print('=' * 30) print("--- [1] --- temporary") print("--- [2] --- todo") print("--- [3] --- ") print('=' * 30) sel_p = input("select: ") if sel_p == "1": print("project 1 >") delta = time.ticks_diff(time.ticks_ms(), start) # compute time difference print("> delta time: " + str(delta)) piezzo.beep(2000, 50) print("all OK, press CTRL+D to soft reboot") led.blink(50)
def delay_read(self): time.sleep_us(self.CTRL_BYTE_DELAY)
def _wait(self): time.sleep_us(100) while self.i2c.readfrom(I2C_SLAVE_ADDR, 1)[0] != 0xFF: time.sleep_us(100)
import time # put to sleep = wait #time.sleep(1) # sleep for 1 second #time.sleep_ms(500) # sleep for 500 milliseconds #time.sleep_us(10) # sleep for 10 microseconds # compute delta time start = time.ticks_ms() # get millisecond counter time.sleep_us(100) delta = time.ticks_diff(time.ticks_ms(), start) # compute time difference print(delta) # must be about 100
def initr(self): '''Initialize a red tab version.''' self._reset() self._writecommand(TFT.SWRESET) #Software reset. time.sleep_us(150) self._writecommand(TFT.SLPOUT) #out of sleep mode. time.sleep_us(500) data3 = bytearray([0x01, 0x2C, 0x2D ]) #fastest refresh, 6 lines front, 3 lines back. self._writecommand(TFT.FRMCTR1) #Frame rate control. self._writedata(data3) self._writecommand(TFT.FRMCTR2) #Frame rate control. self._writedata(data3) data6 = bytearray([0x01, 0x2c, 0x2d, 0x01, 0x2c, 0x2d]) self._writecommand(TFT.FRMCTR3) #Frame rate control. self._writedata(data6) time.sleep_us(10) data1 = bytearray(1) self._writecommand(TFT.INVCTR) #Display inversion control data1[0] = 0x07 #Line inversion. self._writedata(data1) self._writecommand(TFT.PWCTR1) #Power control data3[0] = 0xA2 data3[1] = 0x02 data3[2] = 0x84 self._writedata(data3) self._writecommand(TFT.PWCTR2) #Power control data1[0] = 0xC5 #VGH = 14.7V, VGL = -7.35V self._writedata(data1) data2 = bytearray(2) self._writecommand(TFT.PWCTR3) #Power control data2[0] = 0x0A #Opamp current small data2[1] = 0x00 #Boost frequency self._writedata(data2) self._writecommand(TFT.PWCTR4) #Power control data2[0] = 0x8A #Opamp current small data2[1] = 0x2A #Boost frequency self._writedata(data2) self._writecommand(TFT.PWCTR5) #Power control data2[0] = 0x8A #Opamp current small data2[1] = 0xEE #Boost frequency self._writedata(data2) self._writecommand(TFT.VMCTR1) #Power control data1[0] = 0x0E self._writedata(data1) self._writecommand(TFT.INVOFF) self._writecommand(TFT.MADCTL) #Power control data1[0] = 0xC8 self._writedata(data1) self._writecommand(TFT.COLMOD) data1[0] = 0x05 self._writedata(data1) self._writecommand(TFT.CASET) #Column address set. self.windowLocData[0] = 0x00 self.windowLocData[1] = 0x00 self.windowLocData[2] = 0x00 self.windowLocData[3] = self._size[0] - 1 self._writedata(self.windowLocData) self._writecommand(TFT.RASET) #Row address set. self.windowLocData[3] = self._size[1] - 1 self._writedata(self.windowLocData) dataGMCTRP = bytearray([ 0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22, 0x1f, 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10 ]) self._writecommand(TFT.GMCTRP1) self._writedata(dataGMCTRP) dataGMCTRN = bytearray([ 0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e, 0x30, 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10 ]) self._writecommand(TFT.GMCTRN1) self._writedata(dataGMCTRN) time.sleep_us(10) self._writecommand(TFT.DISPON) time.sleep_us(100) self._writecommand(TFT.NORON) #Normal display on. time.sleep_us(10) self.cs(1)
def initb(self): '''Initialize blue tab version.''' self._size = (ScreenSize[0] + 2, ScreenSize[1] + 1) self._reset() self._writecommand(TFT.SWRESET) #Software reset. time.sleep_us(50) self._writecommand(TFT.SLPOUT) #out of sleep mode. time.sleep_us(500) data1 = bytearray(1) self._writecommand(TFT.COLMOD) #Set color mode. data1[0] = 0x05 #16 bit color. self._writedata(data1) time.sleep_us(10) data3 = bytearray([0x00, 0x06, 0x03 ]) #fastest refresh, 6 lines front, 3 lines back. self._writecommand(TFT.FRMCTR1) #Frame rate control. self._writedata(data3) time.sleep_us(10) self._writecommand(TFT.MADCTL) data1[0] = 0x08 #row address/col address, bottom to top refresh self._writedata(data1) data2 = bytearray(2) self._writecommand(TFT.DISSET5) #Display settings data2[ 0] = 0x15 #1 clock cycle nonoverlap, 2 cycle gate rise, 3 cycle oscil, equalize data2[1] = 0x02 #fix on VTL self._writedata(data2) self._writecommand(TFT.INVCTR) #Display inversion control data1[0] = 0x00 #Line inversion. self._writedata(data1) self._writecommand(TFT.PWCTR1) #Power control data2[0] = 0x02 #GVDD = 4.7V data2[1] = 0x70 #1.0uA self._writedata(data2) time.sleep_us(10) self._writecommand(TFT.PWCTR2) #Power control data1[0] = 0x05 #VGH = 14.7V, VGL = -7.35V self._writedata(data1) self._writecommand(TFT.PWCTR3) #Power control data2[0] = 0x01 #Opamp current small data2[1] = 0x02 #Boost frequency self._writedata(data2) self._writecommand(TFT.VMCTR1) #Power control data2[0] = 0x3C #VCOMH = 4V data2[1] = 0x38 #VCOML = -1.1V self._writedata(data2) time.sleep_us(10) self._writecommand(TFT.PWCTR6) #Power control data2[0] = 0x11 data2[1] = 0x15 self._writedata(data2) #These different values don't seem to make a difference. # dataGMCTRP = bytearray([0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22, 0x1f, # 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10]) dataGMCTRP = bytearray([ 0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d, 0x29, 0x25, 0x2b, 0x39, 0x00, 0x01, 0x03, 0x10 ]) self._writecommand(TFT.GMCTRP1) self._writedata(dataGMCTRP) # dataGMCTRN = bytearray([0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e, 0x30, # 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10]) dataGMCTRN = bytearray([ 0x03, 0x1d, 0x07, 0x06, 0x2e, 0x2c, 0x29, 0x2d, 0x2e, 0x2e, 0x37, 0x3f, 0x00, 0x00, 0x02, 0x10 ]) self._writecommand(TFT.GMCTRN1) self._writedata(dataGMCTRN) time.sleep_us(10) self._writecommand(TFT.CASET) #Column address set. self.windowLocData[0] = 0x00 self.windowLocData[1] = 2 #Start at column 2 self.windowLocData[2] = 0x00 self.windowLocData[3] = self._size[0] - 1 self._writedata(self.windowLocData) self._writecommand(TFT.RASET) #Row address set. self.windowLocData[1] = 1 #Start at row 2. self.windowLocData[3] = self._size[1] - 1 self._writedata(self.windowLocData) self._writecommand(TFT.NORON) #Normal display on. time.sleep_us(10) self._writecommand(TFT.RAMWR) time.sleep_us(500) self._writecommand(TFT.DISPON) self.cs(1) time.sleep_us(500)
def main(): # main function BUZZER.value(1) # set Buzzer Pin to HIGH time.sleep_us(half_cycle) # first half of the time period BUZZER.value(0) # set Buzzer Pin to LOW time.sleep_us(half_cycle) # second half of the time period
def initb2(self): '''Initialize another blue tab version.''' self._size = (ScreenSize[0] + 2, ScreenSize[1] + 1) self._offset[0] = 2 self._offset[1] = 1 self._reset() self._writecommand(TFT.SWRESET) #Software reset. time.sleep_us(50) self._writecommand(TFT.SLPOUT) #out of sleep mode. time.sleep_us(500) data3 = bytearray([0x01, 0x2C, 0x2D]) # self._writecommand(TFT.FRMCTR1) #Frame rate control. self._writedata(data3) time.sleep_us(10) self._writecommand(TFT.FRMCTR2) #Frame rate control. self._writedata(data3) time.sleep_us(10) self._writecommand(TFT.FRMCTR3) #Frame rate control. self._writedata(data3) time.sleep_us(10) self._writecommand(TFT.INVCTR) #Display inversion control data1 = bytearray(1) # data1[0] = 0x07 self._writedata(data1) self._writecommand(TFT.PWCTR1) #Power control data3[0] = 0xA2 # data3[1] = 0x02 # data3[2] = 0x84 # self._writedata(data3) time.sleep_us(10) self._writecommand(TFT.PWCTR2) #Power control data1[0] = 0xC5 # self._writedata(data1) self._writecommand(TFT.PWCTR3) #Power control data2 = bytearray(2) data2[0] = 0x0A # data2[1] = 0x00 # self._writedata(data2) self._writecommand(TFT.PWCTR4) #Power control data2[0] = 0x8A # data2[1] = 0x2A # self._writedata(data2) self._writecommand(TFT.PWCTR5) #Power control data2[0] = 0x8A # data2[1] = 0xEE # self._writedata(data2) self._writecommand(TFT.VMCTR1) #Power control data1[0] = 0x0E # self._writedata(data1) time.sleep_us(10) self._writecommand(TFT.MADCTL) data1[0] = 0xC8 #row address/col address, bottom to top refresh self._writedata(data1) #These different values don't seem to make a difference. # dataGMCTRP = bytearray([0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22, 0x1f, # 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10]) dataGMCTRP = bytearray([ 0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d, 0x29, 0x25, 0x2b, 0x39, 0x00, 0x01, 0x03, 0x10 ]) self._writecommand(TFT.GMCTRP1) self._writedata(dataGMCTRP) # dataGMCTRN = bytearray([0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e, 0x30, # 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10]) dataGMCTRN = bytearray([ 0x03, 0x1d, 0x07, 0x06, 0x2e, 0x2c, 0x29, 0x2d, 0x2e, 0x2e, 0x37, 0x3f, 0x00, 0x00, 0x02, 0x10 ]) self._writecommand(TFT.GMCTRN1) self._writedata(dataGMCTRN) time.sleep_us(10) self._writecommand(TFT.CASET) #Column address set. self.windowLocData[0] = 0x00 self.windowLocData[1] = 0x02 #Start at column 2 self.windowLocData[2] = 0x00 self.windowLocData[3] = self._size[0] - 1 self._writedata(self.windowLocData) self._writecommand(TFT.RASET) #Row address set. self.windowLocData[1] = 0x01 #Start at row 2. self.windowLocData[3] = self._size[1] - 1 self._writedata(self.windowLocData) data1 = bytearray(1) self._writecommand(TFT.COLMOD) #Set color mode. data1[0] = 0x05 #16 bit color. self._writedata(data1) time.sleep_us(10) self._writecommand(TFT.NORON) #Normal display on. time.sleep_us(10) self._writecommand(TFT.RAMWR) time.sleep_us(500) self._writecommand(TFT.DISPON) self.cs(1) time.sleep_us(500)
def measure(self, printflag=False, n=12, on1=0, off1=0, on2=0, off2=0): #take a reading """ Performs a measurement of conductivity across a four-pole probe. Parameters ---------- saveflag: boolean, optional Flag to determine if output is saved for calibration, default false n: int, optional Number of adc readings to take for the measurement, default = 12 on1: int, optional time in microseconds that power pin 1 is on before taking a reading, default = 0 off1: int, optional time in microseconds that power pin 1 is turned off before turning on power pin, default = 0 on2: int, optional time in microseconds that power pin 2 is on before taking a reading, default = 0 off2: int,optional time in microseconds that power pin 2 is turned off before turning on power pin, default = 0 Returns ------- resistance1 : float Apparent resistance computed using normal polarity. resistance2 : float Apparent resistance computed using reverse polarity. temperature : float Temperature (degrees C) conductivity : float Conductivity. Note ---- Also sets the value for temperature, conductivity, counts, and resistances """ #pre-allocate arrays for counts to be read into imeas1 = arr.array('l', [0] * n) imeas2 = arr.array('l', [0] * n) p3meas1 = arr.array('l', [0] * n) p3meas2 = arr.array('l', [0] * n) p4meas1 = arr.array('l', [0] * n) p4meas2 = arr.array('l', [0] * n) starttime = time.ticks_us() for i in range(n): self.gpio1.high() time.sleep_us(on1) imeas1[i] = (self.adc3_current.read_u16() >> 4) p3meas1[i] = (self.adc1.read_u16() >> 4) p4meas1[i] = (self.adc2.read_u16() >> 4) self.gpio1.low() time.sleep_us(off1) self.gpio2.high() time.sleep_us(on2) imeas2[i] = (self.adc3_current.read_u16() >> 4) p3meas2[i] = (self.adc1.read_u16() >> 4) p4meas2[i] = (self.adc2.read_u16() >> 4) self.gpio2.low() time.sleep_us(off2) endtime = time.ticks_us() elapsed_time = endtime - starttime #pre-allocate arrays for current, voltage drop across poles, and resistance, for flow each direction i1 = arr.array('f', [0] * n) i2 = arr.array('f', [0] * n) V1 = arr.array('f', [0] * n) V2 = arr.array('f', [0] * n) R1 = arr.array('f', [0] * n) R2 = arr.array('f', [0] * n) #compute current, voltage, and resistance for each sample (do outside sampling loop to maintain sampling timing) for i in range(n): try: i1[i] = imeas1[i] / 4095 * 3.3 / self.con_resistance i2[i] = (3.3 - imeas2[i] / 4095 * 3.3) / self.con_resistance V1[i] = (p3meas1[i] - p4meas1[i]) / 4095 * 3.3 V2[i] = (p4meas2[i] - p3meas2[i]) / 4095 * 3.3 R1[i] = V1[i] / i1[i] R2[i] = V2[i] / i2[i] except: R1[i] = -999999 R2[i] = -999999 print('Error in resistance computation') #clean data by sampling middle two quartiles upper_index = math.ceil(3 * n / 4) lower_index = math.floor(n / 4) sampled_length = (upper_index - lower_index) self.resistance1 = sum( sorted(R1)[lower_index:upper_index]) / sampled_length self.resistance2 = sum( sorted(R2)[lower_index:upper_index]) / sampled_length icount1 = sum(sorted(imeas1)[lower_index:upper_index]) / sampled_length probe3count1 = sum( sorted(p3meas1)[lower_index:upper_index]) / sampled_length probe4count1 = sum( sorted(p4meas1)[lower_index:upper_index]) / sampled_length icount2 = sum(sorted(imeas2)[lower_index:upper_index]) / sampled_length probe3count2 = sum( sorted(p3meas2)[lower_index:upper_index]) / sampled_length probe4count2 = sum( sorted(p4meas2)[lower_index:upper_index]) / sampled_length #call thermistor reading, with 400 adc readings per measurement #self.T = thermistor_ac.temperature(self.adc_therm, self.therm_power, self.therm_ground, self.therm_resistance, 400) #self.k = self.conductivity(self.resistance2,self.A,self.B,self.C) #self.S = self.salinity(self.T, self.k) #self.k25 = self.k25(self.k,self.T) if printflag: for i in range(n): print( 'R1 = %s, R2 = %s, V1 = %s, V2 = %s, i1 = %s, i2 = %s, p3count1 = %s, p3count2 = %s, p4count1 = %s, p4count2 = %s' % (R1[i], R2[i], V1[i], V2[i], i1[i], i2[i], p3meas1[i], p3meas2[i], p4meas1[i], p4meas2[i])) print('elapsed time = %s micro seconds' % (elapsed_time)) print('speed = %s Hz' % (n / elapsed_time * 1000000)) return (self.resistance1, self.resistance2, icount1, probe3count1, probe4count1, icount2, probe3count2, probe4count2)
def _write_byte(self, dat): self.cs.value(1) time.sleep_us(DELAY_US) self._buf1[0] = dat self.spi.write(self._buf1) self.cs.value(0)
def spin_ms(self, dur_ms=0, period_ms=-1, callback=None): """ If not using a Timer to call `update()` regularly, calling `spin()` once per main loop and everywhere else instead of `time.sleep_ms()` is an alternative to keep the robotling board updated. e.g. "spin(period_ms=50, callback=myfunction)"" is setting it up, "spin(100)"" (~sleep for 100 ms) or "spin()" keeps it running. """ #print("spin_ms(", dur_ms, period_ms, ");", self._spin_t_last_ms) if self._spin_period_ms > 0: p_ms = self._spin_period_ms p_us = p_ms * 1000 d_us = dur_ms * 1000 if dur_ms > 0 and dur_ms < (p_ms - APPROX_UPDATE_DUR_MS): time.sleep_ms(int(dur_ms)) elif dur_ms >= (p_ms - APPROX_UPDATE_DUR_MS): # Sleep for given time while updating the board regularily; start by # sleeping for the remainder of the time to the next update ... t_us = time.ticks_us() dt_ms = time.ticks_diff(time.ticks_ms(), self._spin_t_last_ms) if dt_ms > 0 and dt_ms < p_ms: time.sleep_ms(dt_ms) # Update self.update() self._spin_t_last_ms = time.ticks_ms() # Check if sleep time is left ... d_us = d_us - int(time.ticks_diff(time.ticks_us(), t_us)) if d_us <= 0: return # ... and if so, pass the remaining time by updating at regular # intervals while time.ticks_diff(time.ticks_us(), t_us) < (d_us - p_us): time.sleep_us(p_us) self.update() # Remember time of last update self._spin_t_last_ms = time.ticks_ms() else: # No sleep duration given, thus just check if time is up and if so, # call update and remember time d_ms = time.ticks_diff(time.ticks_ms(), self._spin_t_last_ms) if d_ms > self._spin_period_ms: self.update() self._spin_t_last_ms = time.ticks_ms() elif period_ms > 0: # Set up spin parameters and return self._spin_period_ms = period_ms self._spin_callback = callback self._spinTracker.reset(period_ms) self._spin_t_last_ms = time.ticks_ms() else: # Spin parameters not setup, therefore just sleep time.sleep_ms(dur_ms)
def uart1_handler(uart_o): global uart1_irq global uart1_int_count if uart1_irq.flags() & UART.RX_ANY: uart1_int_count += 1 uart0_irq = uart0.irq(trigger=UART.RX_ANY, handler=uart0_handler) uart1_irq = uart1.irq(trigger=UART.RX_ANY, handler=uart1_handler) uart0.write(b"123") # wait for the characters to be received while not uart1.any(): pass time.sleep_us(100) print(uart1.any() == 3) print(uart1_int_count > 0) print(uart1_irq.flags() == 0) print(uart0_irq.flags() == 0) print(uart1.read() == b"123") uart1.write(b"12345") # wait for the characters to be received while not uart0.any(): pass time.sleep_us(100) print(uart0.any() == 5) print(uart0_int_count > 0) print(uart0_irq.flags() == 0)
def _start(self): self.dio(0) sleep_us(TM1637_DELAY) self.clk(0) sleep_us(TM1637_DELAY)
def _stop(self): self.dio.write_digital(0) time.sleep_us(TM1637_DELAY) self.clk.write_digital(1) time.sleep_us(TM1637_DELAY) self.dio.write_digital(1)
def _stop(self): self.dio(0) sleep_us(TM1637_DELAY) self.clk(1) sleep_us(TM1637_DELAY) self.dio(1)
def send_recv(self, opcode=None, p1=0, p2=0, body=b'', resp_len=1, delay=None): # # Send a command block and read response. Sometimes a delay is needed. # # use a special setup packet to WRITE a command/value to device under test # see ../ae.h for struct aeCmdResponse_t assert len(body) <= 77 assert 1 <= resp_len <= 65, resp_len assert opcode # organize packet: # flag, len, op, p1, p2, (body), crc1, crc2 pkt = ustruct.pack('BBBBH', IOFLAG_CMD, 1 + 1 + 1 + 2 + len(body) + 2, opcode, p1, p2) pkt += body pkt += crc16w(pkt[1:]) pkt = self.serialize(pkt) ow = self.ow ow.write(b'\x00') # WAKEUP token ow.read() # thow out old garbage sleep_us(2500) # tWHI: 2.5ms min ow.write(pkt) sleep_us(40) # tTURNAROUND (80) if delay is None: # delay is required, but complete table is annoying if opcode in (OP.DeriveKey, OP.ECDH, OP.PrivWrite, OP.Sign): delay = 60 elif opcode in (OP.GenKey, ): delay = 120 else: delay = 20 # delay for chip to do its maths sleep_ms(delay) while 1: # read back response ow.write(b'\x00') # WAKEUP token while ow.any(): ow.read(1) # thow out old garbage sleep_us(2500) # tWHI: 2.5ms min ow.write(self.x88) # expect back # - the TX token (echo) # - length byte # - 1+ body # - 2 bytes CRC # resp = ow.read(8 * (1 + 1 + resp_len + 2)) if not resp: # chip wasn't ready yet: retry continue resp = self.deserialize(resp, 1) #print("resp: %r" % resp) if len(resp) < 4: # chip wasn't ready? Noise? raise WrongResponseLength(len(resp)) if resp_len != resp[0] - 3: if (resp[0] == 4) and (crc16w(resp[:-2]) == resp[-2:]): # probably an error response raise ChipErrorResponse(hex(resp[1])) #print("wr len: %r" % resp) raise WrongResponseLength(len(resp)) # check CRC, over all but last two bytes. expect = crc16w(resp[:-2]) if expect != resp[-2:]: raise CRCError() return resp[1:-2]
def _write_byte(self, b): for i in range(8): self.dio((b >> i) & 1) sleep_us(TM1637_DELAY) self.clk(1) sleep_us(TM1637_DELAY) self.clk(0) sleep_us(TM1637_DELAY) self.clk(0) sleep_us(TM1637_DELAY) self.clk(1) sleep_us(TM1637_DELAY) self.clk(0) sleep_us(TM1637_DELAY)
def send_byte(byte): sda=Pin(14,mode=Pin.OUT) scl=Pin(2,mode=Pin.OUT) scl.off() for i in range(8): if byte&0X80: sda.on() #print(1) else: sda.off() #print(0) byte<<=1 time.sleep_us(1) scl.on() time.sleep_us(2) scl.off() time.sleep_us(1) sda.on() sda=Pin(14,mode=Pin.IN) time.sleep_us(1) scl.on() ack=sda.value() time.sleep_us(2) scl.off() time.sleep_us(1) if ack: print('device no response!') #print ('ack=',ack) return ack
def btnPressed(pin): led.toggle() time.sleep_us(100)
print(temp_dht22, " ºC") print(hum_dht22, " %") #####----- Water flow HC-SR04 -----##### trig = Pin(4, Pin.OUT) echo = Pin(2, Pin.IN) timeout_us = 25000 # no need to wait more then sensor's range limit (4,00 m) sensor_hight = 150 # cm trig.value(1) sleep_us(10) trig.value(0) duration = time_pulse_us(echo, 1, timeout_us) if duration < 0: print("Out of range") else: # To calculate the distance we get the pulse_time and divide it by 2 # (the pulse walk the distance twice) # the sound speed on air (343.2 m/s), that It's equivalent to # 0.034320 cm/us that is 1cm each 29.1us # Calculate the Speed of Sound in M/S sound_comp = 331.4 + (0.606 * temp_dht22) + (0.0124 * hum_dht22) # print(sound_comp, " sound_comp")
def sad(): print("Sad!") csPin.value(0) time.sleep_us(500) spi.write(0x00) spi.write(0x00) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x01) spi.write(0x01) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) time.sleep_us(500) csPin.value(1)
def happy(): print("Happy!") csPin.value(0) time.sleep_us(500) spi.write(0x00) spi.write(0x02) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x02) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x02) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x01) spi.write(0x01) spi.write(0x01) spi.write(0x01) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) spi.write(0x00) time.sleep_us(500) csPin.value(1)
def sleep_us(time_us): return time.sleep_us(time_us)
def pulse(X=0): outPin.value(1) time.sleep_us(1) outPin.value(0)