def __main__(args): if len(args) < 3: print("Usage:") print("ramdisk <path> count block_size") print("eg. ramdisk /ram0 50 512") print(" mounts 25KB ramdisk to /ram0") return pth = args[2] bsize = 512 cnt = 50 if len(args) > 3: cnt = int(args[3]) if len(args) > 4: bsize = int(args[4]) if bsize * cnt < 512 * 50: print("Min disk size is {}KB".format(512 * 50 / 1024)) print("Entered {}KB".format(bsize * cnt / 1024)) return print("Creating filesystem of {}KB in {}".format(bsize * cnt / 1024, pth)) bdev = RAMDynBlockDev(bsize, cnt) uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, pth) _vfses[pth] = (vfs, bdev)
def test(bdev, vfs_class): print('test', vfs_class) # mkfs vfs_class.mkfs(bdev) # construction vfs = vfs_class(bdev) # mount uos.mount(vfs, '/lfs') # import with open('/lfs/lfsmod.py', 'w') as f: f.write('print("hello from lfs")\n') import lfsmod # import package uos.mkdir('/lfs/lfspkg') with open('/lfs/lfspkg/__init__.py', 'w') as f: f.write('print("package")\n') import lfspkg # umount uos.umount('/lfs') # clear imported modules sys.modules.clear()
def _card_state_change(self, pin): """ Need to debounce this :param pin: :return: """ if self._debounce: return self._debounce = True self._debounce_timer = Timer(-1) self._debounce_timer.init(period=DEBOUNCE_TIME, mode=Timer.ONE_SHOT, callback=self._remove_debounce) irq_state = disable_irq() if pin.value(): # No card present if self._card: # Card may not be present on boot enable_irq(irq_state) uos.umount(self._directory) irq_state = disable_irq() self._deinit_card() else: try: card = self._init_card() enable_irq(irq_state) uos.mount(card, self._directory) irq_state = disable_irq() except OSError: # Mount issue, probably EPERM pass enable_irq(irq_state)
def setup(): check_bootsec() print("Performing initial setup") uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/flash') uos.chdir('/flash') with open("boot.py", "w") as f: f.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) import badge, machine, esp, ugfx badge.init() ugfx.init() esp.rtcmem_write(0,0) esp.rtcmem_write(1,0) if machine.reset_cause() != machine.DEEPSLEEP_RESET: print("cold boot") import splash else: print("wake from sleep") load_me = esp.rtcmem_read_string() if load_me != "": print("starting %s", load_me) esp.rtcmem_write_string("") __import__(load_me) else: import splash """) return vfs
def record(self, duration = 4): if self.sd is not None: self.sleep(False) WAV_DATA_SIZE = duration * Mic.SAMPLES_PER_SECOND * Mic.BYTES_PER_SAMPLE wav_header = self.gen_wav_header(Mic.SAMPLES_PER_SECOND, Mic.BITS_PER_SAMPLE, 1, Mic.SAMPLES_PER_SECOND * duration) uos.mount(self.sd, "/") f = open('/mic_recording_'+str(random.randint(1,1000))+'.wav','wb') f.write(wav_header) now = utime.ticks_ms() mic_samples = bytearray(Mic.SAMPLE_BLOCK_SIZE) sd_samples = bytearray(Mic.SDCARD_SECTOR_SIZE) numread = 0 numwrite = 0 for _ in range(WAV_DATA_SIZE // Mic.SDCARD_SECTOR_SIZE): try: numread += self.audio.readinto(mic_samples) self.prune(mic_samples, sd_samples) numwrite += f.write(sd_samples) except KeyboardInterrupt: break elapsedTime = utime.ticks_diff(utime.ticks_ms(),now) f.close() uos.umount("/") self.sleep(True) print("Listo, bytes leídos: {}, bytes escritos: {}, \nduración segun ticks: {}, duración segun calculos {}".format(numread, numwrite, elapsedTime, numwrite/8000.0)) else: print("Por favor, añade una sd")
def setup(): check_bootsec() print("Performing initial setup") uos.VfsLfs2.mkfs(bdev) vfs = uos.VfsLfs2(bdev) uos.mount(vfs, "/") with open("webrepl_cfg.py", "w") as webrepl_cfg_file: webrepl_cfg_file.write("""\ PASS = '******' """) with open("boot.py", "w") as boot_file: boot_file.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) import esp import machine import time import sys import traceback print("Welcome to AidonMeterLogger console!") print("------------------------------------") """) with open("main.py", "w") as main_file: main_file.write("""\ from neo import Neo from meter_reader import MeterReader neo=Neo(13) neo.blue() handler=MeterReader(16) handler.run() """) return vfs
def test(bdev, vfs_class): print("test", vfs_class) # mkfs vfs_class.mkfs(bdev) # construction vfs = vfs_class(bdev) # mount uos.mount(vfs, "/lfs") # import with open("/lfs/lfsmod.py", "w") as f: f.write('print("hello from lfs")\n') import lfsmod # import package uos.mkdir("/lfs/lfspkg") with open("/lfs/lfspkg/__init__.py", "w") as f: f.write('print("package")\n') import lfspkg # chdir and import module from current directory (needs "" in sys.path) uos.mkdir("/lfs/subdir") uos.chdir("/lfs/subdir") uos.rename("/lfs/lfsmod.py", "/lfs/subdir/lfsmod2.py") import lfsmod2 # umount uos.umount("/lfs") # clear imported modules sys.modules.clear()
def mount(self): try: self.sd = SDCard(slot=3) uos.mount(self.sd,"/sd") return True except: return False
def setup(): check_bootsec() print("Performing initial setup") wifi() uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') with open("boot.py", "w") as f: f.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) import esp esp.osdebug(None) #import uos, machine #uos.dupterm(None, 1) # disable REPL on UART(0) import gc from machine import RTC try: if RTC().memory() == b"webrepl": raise import main import settings from homie.utils import disable_ap disable_ap() except Exception: import webrepl from homie.utils import enable_ap enable_ap() webrepl.start(password="******") gc.collect() """) return vfs
def mountflash(self): if self.flash is None: # Not being used return self.flash.begin() # Initialise. vfs = uos.VfsFat(self.flash) # Instantiate FAT filesystem uos.mount(vfs, self.flash.mountpoint) self.mounted = True
def setup(): check_bootsec() print("Performing initial setup") network.WLAN(network.AP_IF).active(False) uos.VfsLfs2.mkfs(bdev) vfs = uos.VfsLfs2(bdev) uos.mount(vfs, "/") return vfs
def setup(): check_bootsec() print("Performing initial setup") wifi() uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') with open("boot.py", "w") as f: f.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) #import esp #esp.osdebug(None) import gc #import webrepl #webrepl.start() import network apif = network.WLAN(network.AP_IF) staif = network.WLAN(network.STA_IF) apif.active(False) staif.active(False) gc.collect() """) with open("main.py", "w") as f: f.write("""\ import os import machine import axapp import axreadmfrc522 class Main(object): config = None server = None webroot = "/www" confbox = None app = None gpio = None mqcli = None def __init__(self): super(Main, self).__init__() self.initApp() def initApp(self): self.app = axapp.App() self.config = self.app.getConf() self.app.apifConncet() self.app.staifConnect() def run(self): axreadmfrc522.do_read( self.config) def main(): m = Main() m.run() main() """) return vfs
def setup(): check_bootsec() print("Performing initial setup") uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') # Make dobby config dir uos.mkdir('/conf') # make lib dir uos.mkdir('/lib') with open("boot.py", "w") as f: f.write("""\ # Print to clear serial on boot print("") print("") # Disable os debugging import esp esp.osdebug(None) """) with open("main.py", "w") as f: f.write("""\ # Import and run loader to check modules import loader # Run loader Loader = loader.Run() # get log queue from loader Log_Queue = Loader.Log_Queue # Delete the Loader and loader to free memory del Loader del loader # Import base system to get wifi up and download modules if needed import base # run base with loader.Run() as arguments, it will return a loader log to be published when connected Base = base.Run(Log_Queue) # delete the log queue del Log_Queue # Run base loop Base.Loop() # If we get to here something went wrong so lets reboot print() print() print() print() print() print("End of loop rebooting - we should not get to here") print() print() print() print() print() """) return vfs
def mountsd(mountpoint="/sd"): """ Mount command """ import uos import machine try: uos.mount(machine.SDCard(), mountpoint) print("Sd mounted on '%s'" % mountpoint) except: print("Cannot mount sd on '%s'" % mountpoint)
def __init__(self): self._name = "Westhill Laser Measument System" self._wlan = network.WLAN(network.STA_IF) self.connect_wifi() self._sd = machine.SDCard(slot=3, sck=machine.Pin(14), miso=machine.Pin(12) ,mosi=machine.Pin(13),cs=machine.Pin(15)) uos.mount(self._sd, SD_FILE) self._th_sensor = si7021.SI7021(4, 21) self._buzz = Buzzer(26)
def connect(host, port): global disk log("Connecting to " + host + ":" + str(port)) disk = Socketdisk(host, port) vfs = uos.VfsFat(disk) uos.mount(vfs, "/__livereload__") uos.chdir("/__livereload__") sys.path.insert(0, "/__livereload__/lib") sys.path.insert(0, "/__livereload__")
def _mount_initrd(num_blocks): try: import uos bdev = RAMBlockDev(512, num_blocks) uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') except: print("error: _mount_initrd")
def mount(self): sd = machine.SDCard(slot=3, sck=18, mosi=23, miso=38, cs=4) try: uos.mount(sd, "/sd") except Exception as exc: print("Exception:", exc.args[0]) print("/sd:", uos.listdir("/sd"))
def get_predict(filename,th,ts,tp): ts=ts+th tp=tp+ts #SD card setup #MOSI(IO23) MISO(19) SCK(18) spisd=SPI(-1,sck=Pin(18),mosi=Pin(23),miso=Pin(19)) #CS(5) sd=sdcard.SDCard(spisd,Pin(5)) uos.mount(sd,'/sd') #WiFi setup WIFI_SSID = 'OPPOA5s' WIFI_PASSWORD = '******' ap_if = network.WLAN(network.AP_IF) wifi = network.WLAN(network.STA_IF) ap_if.active(False) # connect the device to the WiFi network wifi.active(True) wifi.connect(WIFI_SSID, WIFI_PASSWORD) time.sleep(5) #Read data from csv file Data=[] label=[] no_Rows=0 filename="/sd/{}".format(filename) with open(filename,'r') as file: for line in file: if no_Rows <= ts & no_Rows > 0: line=line.rstrip('\n') line=line.rstrip('\r') Data.append(line.split(',')) no_Rows+=1 elif no_Rows == 0: line=line.rstrip('\n') line=line.rstrip('\r') label.append(line.split(',')) no_Rows+=1 else: no_Rows+=1 column = label[0] #Convert data into json format js = {"columns":column, "data":Data} jsd = json.dumps(js) dfj = json.loads(jsd) #url to cloud system url = 'https://test-torc.herokuapp.com/torc-extract/?th={}'.format(ts) result = urequests.post(url,data=jsd) print(result) print(result.text) #Unmount SD card and deactivate WiFi uos.umount('/sd') wifi.active(False) ap_if.active(True) return result.text[-3]
def setup(): check_bootsec() print("Performing initial setup") uos.VfsLfs2.mkfs(bdev) vfs = uos.VfsLfs2(bdev) uos.mount(vfs, "/") with open("boot.py", "w") as f: f.write( """\ # This file is executed on every boot (including wake-boot from deepsleep) #import esp #esp.osdebug(None) #import webrepl #webrepl.start() # Init LVGL import lvgl as lv lv.init() # Power Management from m5core2_power import Power power = Power() # LCD screen from ili9XXX import ili9341 lcd = ili9341(mosi=23, miso=38, clk=18, dc=15, cs=5, invert=True, rot=0x10, width=320, height=240, rst=-1, power=-1, backlight=-1) # Touch sensor from ft6x36 import ft6x36 touch = ft6x36(width=320, height=280) """ ) with open("board.py", "w") as f: f.write( """\ name = "m5core2" """ ) with open("main.py", "w") as f: f.write( """\ import lvgl as lv scr = lv.obj() btn = lv.btn(scr) btn.align(lv.ALIGN.CENTER, 0, 0) label = lv.label(btn) label.set_text("Button") lv.scr_load(scr) """ ) return vfs
def setup(): from machine import Pin import factory_reset import time check_bootsec() print("Performing initial setup") uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') factory_reset.reset() return vfs
def open(self): """ Open and mount sd card """ if self.opened == False: try: uos.mount(machine.SDCard(), self.mountpoint) print("Mount %s" % self.mountpoint) self.opened = True except Exception as error: # print(exception(error)) print("Cannot mount %s" % self.mountpoint) return self.opened
def mount_sd(): try: sd = machine.SD() try: # check if sd is already mounted os.stat('/sd') return True except: # not mounted: continue pass os.mount(sd, '/sd') return True except OSError: return False
def fstest(format=False): fram = get_fram() if format: uos.VfsFat.mkfs(fram) vfs = uos.VfsFat(fram) try: uos.mount(vfs, '/fram') except OSError: # Already mounted pass print('Contents of "/": {}'.format(uos.listdir('/'))) print('Contents of "/fram": {}'.format(uos.listdir('/fram'))) print(uos.statvfs('/fram'))
def fstest(format=False): eep = get_device() # ***** CODE FOR LITTLEFS ***** if format: uos.VfsLfs2.mkfs(eep) try: uos.mount(eep, '/fl_ext') except OSError: # Already mounted pass print('Contents of "/": {}'.format(uos.listdir('/'))) print('Contents of "/fl_ext": {}'.format(uos.listdir('/fl_ext'))) print(uos.statvfs('/fl_ext'))
def fstest(format=False): eep = get_eep() if format: uos.VfsFat.mkfs(eep) vfs = uos.VfsFat(eep) try: uos.mount(vfs, '/eeprom') except OSError: # Already mounted pass print('Contents of "/": {}'.format(uos.listdir('/'))) print('Contents of "/eeprom": {}'.format(uos.listdir('/eeprom'))) print(uos.statvfs('/eeprom'))
def init(): uos.mount(FileSystem(__path__), '/') sys.path.append('/lib') sys.path.append('/lib/micropython') for filename in sorted(uos.listdir("/boot")): context = {'__name__': '__main__', '__path__': __path__} # noinspection PyUnresolvedReferences execfile("/boot/" + filename, context) from shell import spawn spawn("/bin/python.py")
def setup(): check_bootsec() print("Performing initial setup") uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/flash') uos.chdir('/flash') with open("boot.py", "w") as f: f.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) """) return vfs
def test(bdev, vfs_class): print("test", vfs_class) # mkfs vfs_class.mkfs(bdev) # construction vfs = vfs_class(bdev) # mount uos.mount(vfs, "/lfs") # import with open("/lfs/lfsmod.py", "w") as f: f.write('print("hello from lfs")\n') import lfsmod # import package uos.mkdir("/lfs/lfspkg") with open("/lfs/lfspkg/__init__.py", "w") as f: f.write('print("package")\n') import lfspkg # chdir and import module from current directory (needs "" in sys.path) uos.mkdir("/lfs/subdir") uos.chdir("/lfs/subdir") uos.rename("/lfs/lfsmod.py", "/lfs/subdir/lfsmod2.py") import lfsmod2 # umount uos.umount("/lfs") # mount read-only vfs = vfs_class(bdev) uos.mount(vfs, "/lfs", readonly=True) # test reading works with open("/lfs/subdir/lfsmod2.py") as f: print("lfsmod2.py:", f.read()) # test writing fails try: open("/lfs/test_write", "w") except OSError as er: print(repr(er)) # umount uos.umount("/lfs") # clear imported modules usys.modules.clear()
def setupSDFileSystem(sd): # check /sd/sys in SD card if not isExists('/sd'): uos.mount(sd, '/sd') if not isExists(SYSDIR): uos.mkdir(SYSDIR) if not isExists(TMPDIR): uos.mkdir(TMPDIR) if not isExists(PHOTODIR): uos.mkdir(PHOTODIR) todaysPhotoDIR = getTodaysPhotoDIR() if not isExists(todaysPhotoDIR): uos.mkdir(todaysPhotoDIR) return True
def setup(): check_bootsec() print("Performing initial setup") wifi() uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') with open("boot.py", "w") as f: f.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) #import esp #esp.osdebug(None) import gc #import webrepl #webrepl.start() gc.collect() """) return vfs
except OSError: pass for path in uos.listdir('/'): uos.umount('/' + path) # stat root dir print(uos.stat('/')) # statvfs root dir; verify that f_namemax has a sensible size print(uos.statvfs('/')[9] >= 32) # getcwd when in root dir print(uos.getcwd()) # basic mounting and listdir uos.mount(Filesystem(1), '/test_mnt') print(uos.listdir()) # ilistdir i = uos.ilistdir() print(next(i)) try: next(i) except StopIteration: print('StopIteration') try: next(i) except StopIteration: print('StopIteration') # referencing the mount point in different ways
bdev = RAMFS(50) bdev2 = RAMFS(50) except MemoryError: print("SKIP") raise SystemExit # first we umount any existing mount points the target may have try: uos.umount('/') except OSError: pass for path in uos.listdir('/'): uos.umount('/' + path) uos.VfsFat.mkfs(bdev) uos.mount(bdev, '/') print(uos.getcwd()) f = open('test.txt', 'w') f.write('hello') f.close() print(uos.listdir()) print(uos.listdir('/')) print(uos.stat('')[:-3]) print(uos.stat('/')[:-3]) print(uos.stat('test.txt')[:-3]) print(uos.stat('/test.txt')[:-3]) f = open('/test.txt')
self.data[n * self.SEC_SIZE + i] = buf[i] def sync(self): pass def count(self): return len(self.data) // self.SEC_SIZE try: bdev = RAMFS_OLD(50) except MemoryError: print("SKIP") raise SystemExit uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, "/ramdisk") # file io with vfs.open("file.txt", "w") as f: f.write("hello!") print(list(vfs.ilistdir())) with vfs.open("file.txt", "r") as f: print(f.read()) vfs.remove("file.txt") print(list(vfs.ilistdir()))
import gc gc.threshold((gc.mem_free() + gc.mem_alloc()) // 4) import uos from flashbdev import bdev try: if bdev: uos.mount(bdev, '/') except OSError: import inisetup vfs = inisetup.setup() gc.collect()
import gc gc.threshold((gc.mem_free() + gc.mem_alloc()) // 4) import uos from flashbdev import bdev try: if bdev: vfs = uos.VfsFat(bdev) uos.mount(vfs, '/flash') uos.chdir('/flash') except OSError: import inisetup vfs = inisetup.setup() gc.collect()
pass def stat(self, path): print('stat', path) if path in self.files: return (32768, 0, 0, 0, 0, 0, 0, 0, 0, 0) raise OSError def open(self, path, mode): print('open', path, mode) return UserFile(self.files[path]) # create and mount a user filesystem user_files = { '/data.txt': b"some data in a text file\n", '/usermod1.py': b"print('in usermod1')\nimport usermod2", '/usermod2.py': b"print('in usermod2')", } uos.mount(UserFS(user_files), '/userfs') # open and read a file f = open('/userfs/data.txt') print(f.read()) # import files from the user filesystem sys.path.append('/userfs') import usermod1 # unmount and undo path addition uos.umount('/userfs') sys.path.pop()
#print("ioctl(%d, %r)" % (op, arg)) if op == 4: # BP_IOCTL_SEC_COUNT return len(self.data) // self.SEC_SIZE if op == 5: # BP_IOCTL_SEC_SIZE return self.SEC_SIZE try: bdev = RAMFS(50) except MemoryError: print("SKIP") raise SystemExit uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/ramdisk') uos.chdir('/ramdisk') try: vfs.mkdir("foo_dir") except OSError as e: print(e.args[0] == uerrno.EEXIST) try: vfs.remove("foo_dir") except OSError as e: print(e.args[0] == uerrno.EISDIR) try: vfs.remove("no_file.txt") except OSError as e: