MicroPython

• A

  Not getting Sensor Readings in Pysense with FiPy Module
  fipy raspberry pi pysense micorpython • • Archana Kadam

  79
  79
  Posts
  3096
  Views

  

  @archana-kadam

  Normal LTE no.. unless you use a WiFi-LTE router (MiFi) or external LTE modem.

• I

  btree lib support
  micorpython modules • • InverseEffect

  8
  8
  Posts
  94
  Views

  I

  @frida If jou are referring to Pycom's nvram key-value pair then no because it can only store a single 32bit int as the value. I want to save more information.

• G

  threading - thread starts, but main does not run
  thread threading • • gregcope

  9
  9
  Posts
  177
  Views

  G

  @seb said in threading - thread starts, but main does not run:

  https://github.com/pycom/pycom-libraries/issues

  Ta.

  Opened;

  https://github.com/pycom/pycom-micropython-sigfox/issues/158

• A

  Sending sensor data to server using LoRa
  lora fipy pysense • • Archana Kadam

  9
  9
  Posts
  204
  Views

  A

  @sympatron
  Hello,

  We have already included the urequests.py file in lib folder as well as changed the line 53 to
  ai = usocket.getaddrinfo(host, port)

  But still getting the below error with the same code which is shared previously.

  Traceback (most recent call last):
  File "<stdin>", line 47, in <module>
  File "urequests.py", line 100, in request
  File "urequests.py", line 58, in request
  OSError: -1

  Please reply as soon as possible. Your help will be appreciable.

• J

  Serial communication on GPIO pin
  gpio sdi-12 serial • • jmpratt

  6
  6
  Posts
  296
  Views

  J

  @jmpratt Would you mind providing me a link for the hardware you used? I was thinking of using the RS485 library and a 485 to uart breakout board.

• G

  threading error (NameError: name 'xxx' is not defined)
  threading thread • • gregcope

  4
  4
  Posts
  79
  Views

  T

  Functions and methods are actually different things and exist in different scopes.
  You can't look up a method by name without the self. (or similiar) prefix. Unless you bind it to another name in the current scope.

  The same applies to class methods.

• S

  SSL Connection to AWS IoT from ESP8266(Micropython)
  micropython aws ssl mqtt • • sunrise17

  19
  19
  Posts
  929
  Views

  

  @sunrise17
  you must modify esp_get_revision - i do not have guide but on the forum you can find such posted by
  @robert-hh
  https://forum.pycom.io/post/13828

• S

  Only a power cycle works to reset
  reset • • smbunn

  1
  1
  Posts
  47
  Views

  No one has replied

• A

  LoRa Specification Module
  lora lopy lora fipy micropython pycom • • Archana Kadam

  5
  5
  Posts
  109
  Views

  A

  @rskoniec
  Thank You sir

• M

  External SD Card
  sd card • • Manju2391

  20
  20
  Posts
  1550
  Views

  N

  @robert-hh said in External SD Card:

  """ MicroPython driver for SD cards using SPI bus. Requires an SPI bus and a CS pin. Provides readblocks and writeblocks methods so the device can be mounted as a filesystem. Example usage on xxPy: import machine, sdcard, os sd = sdcard.SDCard(machine.SPI(0), machine.Pin("P9")) os.mount(sd, '/sd2') os.listdir('/sd2') """ from micropython import const import time _CMD_TIMEOUT = const(100) _R1_IDLE_STATE = const(1 << 0) #R1_ERASE_RESET = const(1 << 1) _R1_ILLEGAL_COMMAND = const(1 << 2) #R1_COM_CRC_ERROR = const(1 << 3) #R1_ERASE_SEQUENCE_ERROR = const(1 << 4) #R1_ADDRESS_ERROR = const(1 << 5) #R1_PARAMETER_ERROR = const(1 << 6) _TOKEN_CMD25 = const(0xfc) _TOKEN_STOP_TRAN = const(0xfd) _TOKEN_DATA = const(0xfe) class SDCard: def __init__(self, spi, cs): self.spi = spi self.cs = cs self.cmdbuf = bytearray(6) self.dummybuf = bytearray(512) for i in range(512): self.dummybuf[i] = 0xff self.dummybuf_memoryview = memoryview(self.dummybuf) # initialise the card self.init_card() def init_spi(self, baudrate): master = self.spi.MASTER self.spi.init(master, baudrate=baudrate, phase=0, polarity=0) def init_card(self): # init CS pin self.cs.init(self.cs.OUT, value=1) # init SPI bus; use low data rate for initialisation self.init_spi(100000) # clock card at least 100 cycles with cs high for i in range(16): self.spi.write(b'\xff') # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts) for _ in range(5): if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE: break else: raise OSError("no SD card") # CMD8: determine card version r = self.cmd(8, 0x01aa, 0x87, 4) if r == _R1_IDLE_STATE: self.init_card_v2() elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND): self.init_card_v1() else: raise OSError("couldn't determine SD card version") # get the number of sectors # CMD9: response R2 (R1 byte + 16-byte block read) if self.cmd(9, 0, 0, 0, False) != 0: raise OSError("no response from SD card") csd = bytearray(16) self.readinto(csd) if csd[0] & 0xc0 != 0x40: raise OSError("SD card CSD format not supported") self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 2014 #print('sectors', self.sectors) # CMD16: set block length to 512 bytes if self.cmd(16, 512, 0) != 0: raise OSError("can't set 512 block size") # set to high data rate now that it's initialised #self.init_spi(100000) #self.init_spi(40000000) def init_card_v1(self): for i in range(_CMD_TIMEOUT): self.cmd(55, 0, 0) if self.cmd(41, 0, 0) == 0: self.cdv = 512 #print("[SDCard] v1 card") return raise OSError("timeout waiting for v1 card") def init_card_v2(self): for i in range(_CMD_TIMEOUT): time.sleep_ms(50) self.cmd(58, 0, 0, 4) self.cmd(55, 0, 0) if self.cmd(41, 0x40000000, 0) == 0: self.cmd(58, 0, 0, 4) self.cdv = 1 #print("[SDCard] v2 card") return raise OSError("timeout waiting for v2 card") def cmd(self, cmd, arg, crc, final=0, release=True): self.cs(0) # create and send the command buf = self.cmdbuf buf[0] = 0x40 | cmd buf[1] = arg >> 24 buf[2] = arg >> 16 buf[3] = arg >> 8 buf[4] = arg buf[5] = crc self.spi.write(buf) # wait for the response (response[7] == 0) for i in range(_CMD_TIMEOUT): response = self.spi.read(1, write=0xff)[0] if not (response & 0x80): # this could be a big-endian integer that we are getting here for j in range(final): self.spi.write(b'\xff') if release: self.cs(1) self.spi.write(b'\xff') return response # timeout self.cs(1) self.spi.write(b'\xff') return -1 def cmd_nodata(self, cmd): self.spi.write(cmd) self.spi.read(1, write=0xff) # ignore stuff byte for _ in range(_CMD_TIMEOUT): if self.spi.read(1, write=0xff)[0] == 0xff: self.cs(1) self.spi.write(b'\xff') return 0 # OK self.cs(1) self.spi.write(b'\xff') return 1 # timeout def readinto(self, buf): self.cs(0) # read until start byte (0xff) while self.spi.read(1, write=0xff)[0] != 0xfe: pass # read data mv = self.dummybuf_memoryview[:len(buf)] self.spi.write_readinto(mv, buf) # read checksum self.spi.write(b'\xff') self.spi.write(b'\xff') self.cs(1) self.spi.write(b'\xff') def write(self, token, buf): self.cs(0) # send: start of block, data, checksum self.spi.read(1, token) self.spi.write(buf) self.spi.write(b'\xff') self.spi.write(b'\xff') # check the response if (self.spi.read(1, 0xff)[0] & 0x1f) != 0x05: self.cs(1) self.spi.write(b'\xff') return # wait for write to finish while self.spi.read(1, 0xff)[0] == 0: pass self.cs(1) self.spi.write(b'\xff') def write_token(self, token): self.cs(0) self.spi.read(1, token) self.spi.write(b'\xff') # wait for write to finish while self.spi.read(1, 0xff)[0] == 0x00: pass self.cs(1) self.spi.write(b'\xff') def count(self): return self.sectors def readblocks(self, block_num, buf): nblocks, err = divmod(len(buf), 512) assert nblocks and not err, 'Buffer length is invalid' if nblocks == 1: # CMD17: set read address for single block if self.cmd(17, block_num * self.cdv, 0) != 0: return 1 # receive the data self.readinto(buf) else: # CMD18: set read address for multiple blocks if self.cmd(18, block_num * self.cdv, 0) != 0: return 1 offset = 0 mv = memoryview(buf) while nblocks: self.readinto(mv[offset : offset + 512]) offset += 512 nblocks -= 1 return self.cmd_nodata(b'\x0c') # cmd 12 return 0 def writeblocks(self, block_num, buf): nblocks, err = divmod(len(buf), 512) assert nblocks and not err, 'Buffer length is invalid' if nblocks == 1: # CMD24: set write address for single block if self.cmd(24, block_num * self.cdv, 0) != 0: return 1 # send the data self.write(_TOKEN_DATA, buf) else: # CMD25: set write address for first block if self.cmd(25, block_num * self.cdv, 0) != 0: return 1 # send the data offset = 0 mv = memoryview(buf) while nblocks: self.write(_TOKEN_CMD25, mv[offset : offset + 512]) offset += 512 nblocks -= 1 self.write_token(_TOKEN_STOP_TRAN) return 0

  I know this is a bit old but I just got an SD card module (https://www.sparkfun.com/products/13743) and was trying to get it working with my FiPy. I was running into a lot of issues but was able to make some headway using the library you pasted @robert-hh and thought I would share my results in case other people wanted to get it working.

  However, I did have some errors with the library and had to make the following changes:

  The pins you used are not the default pins for the SPI init call. So I created my own SPI instance with the pin allocation you had in the post (since I already had them like that) and passed that instance into the SDCard constructor rather than machine.SPI(0). I also removed the additional spi init calls.

  I had to set the SPI baudrate to 1000000 instead of 100000

  I had to declare the CS pin as an instance outside of the library and pass it in similar to the SPI above.

  The command to check idle state at the start of the library self.cmd(0, 0, 0x95) would never return a value of 1. I don't know where the reference of these commands were but testing the other commands manually all returned values as expected. So I commented out the entire block that checks for the SD card or raises the 'no SD card' error. I found that I still need to run this command regardless, I get the same set of (4?) different values that repeat each time it is called. They never equal 1 but I let the code continue and command out the error block. Not calling the 0x95 command will not allow the next set of command to work correctly.

  Doing the above I have gotten my external SD card board working fine with the FiPy. For reference below are my library and how I call it.

  """ MicroPython driver for SD cards using SPI bus. Requires an SPI bus and a CS pin. Provides readblocks and writeblocks methods so the device can be mounted as a filesystem. Example usage on xxPy: import machine, sdcard, os sd = sdcard.SDCard(machine.SPI(0), machine.Pin("P9")) os.mount(sd, '/sd2') os.listdir('/sd2') """ from micropython import const import time _CMD_TIMEOUT = const(100) _R1_IDLE_STATE = const(1 << 0) #R1_ERASE_RESET = const(1 << 1) _R1_ILLEGAL_COMMAND = const(1 << 2) #R1_COM_CRC_ERROR = const(1 << 3) #R1_ERASE_SEQUENCE_ERROR = const(1 << 4) #R1_ADDRESS_ERROR = const(1 << 5) #R1_PARAMETER_ERROR = const(1 << 6) _TOKEN_CMD25 = const(0xfc) _TOKEN_STOP_TRAN = const(0xfd) _TOKEN_DATA = const(0xfe) class SDCard: def __init__(self, spi, cs): self.spi = spi self.cs = cs self.cmdbuf = bytearray(6) self.dummybuf = bytearray(512) for i in range(512): self.dummybuf[i] = 0xff self.dummybuf_memoryview = memoryview(self.dummybuf) # initialise the card self.init_card() def init_spi(self, baudrate): master = self.spi.MASTER self.spi.init(master, baudrate=baudrate, phase=0, polarity=0) def init_card(self): # init CS pin #self.cs.init(self.cs.OUT, value=0) # init SPI bus; use low data rate for initialisation #self.init_spi(100000) # clock card at least 100 cycles with cs high for i in range(16): self.spi.write(b'\xff') # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts) for _ in range(5): if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE: break ''' else: raise OSError("no SD card") ''' # CMD8: determine card version r = self.cmd(8, 0x01aa, 0x87, 4) if r == _R1_IDLE_STATE: self.init_card_v2() elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND): self.init_card_v1() else: raise OSError("couldn't determine SD card version") # get the number of sectors # CMD9: response R2 (R1 byte + 16-byte block read) if self.cmd(9, 0, 0, 0, False) != 0: raise OSError("no response from SD card") csd = bytearray(16) self.readinto(csd) if csd[0] & 0xc0 != 0x40: raise OSError("SD card CSD format not supported") self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 2014 #print('sectors', self.sectors) # CMD16: set block length to 512 bytes if self.cmd(16, 512, 0) != 0: raise OSError("can't set 512 block size") # set to high data rate now that it's initialised #self.init_spi(100000) #self.init_spi(40000000) def init_card_v1(self): for i in range(_CMD_TIMEOUT): self.cmd(55, 0, 0) if self.cmd(41, 0, 0) == 0: self.cdv = 512 #print("[SDCard] v1 card") return raise OSError("timeout waiting for v1 card") def init_card_v2(self): for i in range(_CMD_TIMEOUT): time.sleep_ms(50) self.cmd(58, 0, 0, 4) self.cmd(55, 0, 0) if self.cmd(41, 0x40000000, 0) == 0: self.cmd(58, 0, 0, 4) self.cdv = 1 #print("[SDCard] v2 card") return raise OSError("timeout waiting for v2 card") def cmd(self, cmd, arg, crc, final=0, release=True): self.cs(0) # create and send the command buf = self.cmdbuf buf[0] = 0x40 | cmd buf[1] = arg >> 24 buf[2] = arg >> 16 buf[3] = arg >> 8 buf[4] = arg buf[5] = crc self.spi.write(buf) # wait for the response (response[7] == 0) for i in range(_CMD_TIMEOUT): response = self.spi.read(1, write=0xff)[0] if not (response & 0x80): # this could be a big-endian integer that we are getting here for j in range(final): self.spi.write(b'\xff') if release: self.cs(1) self.spi.write(b'\xff') return response # timeout self.cs(1) self.spi.write(b'\xff') return -1 def cmd_nodata(self, cmd): self.spi.write(cmd) self.spi.read(1, write=0xff) # ignore stuff byte for _ in range(_CMD_TIMEOUT): if self.spi.read(1, write=0xff)[0] == 0xff: self.cs(1) self.spi.write(b'\xff') return 0 # OK self.cs(1) self.spi.write(b'\xff') return 1 # timeout def readinto(self, buf): self.cs(0) # read until start byte (0xff) while self.spi.read(1, write=0xff)[0] != 0xfe: pass # read data mv = self.dummybuf_memoryview[:len(buf)] self.spi.write_readinto(mv, buf) # read checksum self.spi.write(b'\xff') self.spi.write(b'\xff') self.cs(1) self.spi.write(b'\xff') def write(self, token, buf): self.cs(0) # send: start of block, data, checksum self.spi.read(1, token) self.spi.write(buf) self.spi.write(b'\xff') self.spi.write(b'\xff') # check the response if (self.spi.read(1, 0xff)[0] & 0x1f) != 0x05: self.cs(1) self.spi.write(b'\xff') return # wait for write to finish while self.spi.read(1, 0xff)[0] == 0: pass self.cs(1) self.spi.write(b'\xff') def write_token(self, token): self.cs(0) self.spi.read(1, token) self.spi.write(b'\xff') # wait for write to finish while self.spi.read(1, 0xff)[0] == 0x00: pass self.cs(1) self.spi.write(b'\xff') def count(self): return self.sectors def readblocks(self, block_num, buf): nblocks, err = divmod(len(buf), 512) assert nblocks and not err, 'Buffer length is invalid' if nblocks == 1: # CMD17: set read address for single block if self.cmd(17, block_num * self.cdv, 0) != 0: return 1 # receive the data self.readinto(buf) else: # CMD18: set read address for multiple blocks if self.cmd(18, block_num * self.cdv, 0) != 0: return 1 offset = 0 mv = memoryview(buf) while nblocks: self.readinto(mv[offset : offset + 512]) offset += 512 nblocks -= 1 return self.cmd_nodata(b'\x0c') # cmd 12 return 0 def writeblocks(self, block_num, buf): nblocks, err = divmod(len(buf), 512) assert nblocks and not err, 'Buffer length is invalid' if nblocks == 1: # CMD24: set write address for single block if self.cmd(24, block_num * self.cdv, 0) != 0: return 1 # send the data self.write(_TOKEN_DATA, buf) else: # CMD25: set write address for first block if self.cmd(25, block_num * self.cdv, 0) != 0: return 1 # send the data offset = 0 mv = memoryview(buf) while nblocks: self.write(_TOKEN_CMD25, mv[offset : offset + 512]) offset += 512 nblocks -= 1 self.write_token(_TOKEN_STOP_TRAN) return 0 from machine import SPI from machine import Pin import machine, sdcard, os spi = SPI(0, mode=SPI.MASTER, baudrate=1000000, polarity=0, phase=0, pins=('P10','P11','P12')) cs = Pin('P9', Pin.OUT) sd = sdcard.SDCard(spi, cs) os.mount(sd, "/card")

  I could probably tidy up the library to initialise the SPI and CS properly internally but this got me going at least.

• K

  Using an IO pin interrupt + Alarm
  lopy pytrack pin interrupt alarm • • kbman99

  3
  3
  Posts
  134
  Views

  K

  @gregcope Wondering if it might be useful to simply start a thread for everything. If I spawn an alarm in one thread, an interrupt in another and so on, I may be able to avoid the issue of blocking.

  The major issue is that since some of the functions I need to run can take 20 seconds or so, I don't want one to block another from running and have to wait a whole other interval for the respective functions to be run. Especially since there are multiple interrupts and one or two alarms.

  So would simply running a function that spawns an alarm within a separate thread make it so that the alarm itself is contained in that thread indefinitely?

• J

  USB or UART
  uart usb serial • • jmpratt

  6
  6
  Posts
  329
  Views

  S

  @livius It features a MAX3421E USB host controller chip and USB-A port. We created this board to communicate with existing serial-over-USB (CDC, or communications device class) devices. Adding support for other USB "drivers" is a matter of understanding the USB endpoints and writing the implementation in MicroPython.

  Update: Check out the First look: USB Host Expansion Board by Semireg

• J

  Would somebody have a library for Irrometer Watermark 200ss?
  lopy irrometer watermark 200ss library • • jclo13

  3
  3
  Posts
  136
  Views

  J

  @livius thank you to answer, I will try it.

• F

  working example of dupterm with log file on /sd needed (or logging module that supports filenames)
  logging filename dupterm • • fsergeys

  2
  2
  Posts
  108
  Views

  

  @fsergeys

  Is there a particular reason you need to capture stdout/stderr vs. just writing your log straight to the file?

• B

  Capturing console messages to a log
  console • • BetterAuto

  4
  4
  Posts
  347
  Views

  

  Check out sys.print_exception, that might be able to help with printing out exceptions and traceback

• T

  ujson module missing dump(obj, stream) function - is this planned ?
  ujson • • timh

  1
  1
  Posts
  65
  Views

  No one has replied

• R

  jupyer kernel
  jupyer • • robmarkcole

  6
  6
  Posts
  698
  Views

  R

  Ok by following this guide and using the config below I have my LoPy running through a Jupyter notebook.
  In kernel.json:

  { "argv": ["python3", "-m", "jupyter_micropython_kernel", "/dev/cu.usbmodemPy343431", "115200", "-f", "{connection_file}"], "display_name": "MicroPython", "language": "micropython" }
• D

  LWM2M protocol!
  iot server client m2m lopy lwm2m • • Devang Sharma

  9
  9
  Posts
  522
  Views

  R

  @ahaw021

  Do you host your library somewhere? I have been running a pure C LWM2M client on bare-metal ESP32 with satisfying results. The implementation is based on https://github.com/Openhab-Nodes/libWakaamaEmb with DTLS support. I need to explore the possibility to use MicroPython as a base for LWM2M Hackathon.

  Cheers!

• J

  Mock libraries for supporting linter in VSC
  linter modules mock emulation • • Jardar

  1
  1
  Posts
  100
  Views

  No one has replied

• R

  Seek help about programming: How to send ultrasonic sensor data to gateway using LoRa OTAA ?
  lopy expansion board otaa ultrasonic sens lora • • Rachelsimida

  15
  15
  Posts
  469
  Views

  

  @rachelsimida

  You can still use the ESP32's deep sleep to lower the modules current consumption down to 15mA, but with a deep sleep shield this will go down to 15uA or so. If your teacher ordered direct from pycom or not he should have received deep sleep shields with his order. If not he can request some for free by emailing salessupport@pycom.io