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:
