diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/README.md b/app/resources/plugins/MCH22BToolchain/mch2022-tools/README.md
index 9dc076941..99b906347 100644
--- a/app/resources/plugins/MCH22BToolchain/mch2022-tools/README.md
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/README.md
@@ -3,34 +3,92 @@ This directory contains command line tools for use with your badge.
 
 To use them, you will need to `pip install pyusb`.
 
-### AppFS
+### Application management
 The AppFS contains binary ESP32 apps - standalone firmwares that can be booted and used as apps.
 
-`webusb_ls.py`  
+`app_list.py`
+
 Lists all apps on the AppFS.
 
-`webusb_push.py {target_name} {filename} [--run]`  
+`app_push.py {file} {name} {title} {version} [--run]`
+
 Installs an ESP32 app to the AppFS.
 The `--run` flag will also immediately start the app after installing.
 
-`webusb_boot.py {app_name}`  
+`app_pull.py {name} {target}`
+
+Downloads the ESP32 app binary to your computer, the file will be saved at the location provided as target.
+
+`app_run.py {name}`
+
 Boots an ESP32 app with the specified name.
 
-`webusb_rm.py {app_name}`  
+`webusb_remove.py {app_name}`
+
 Removes an ESP32 app from the AppFS.
 
-### Filesystem
-`webusb_fat_ls.py [path]`  
+### FAT filesystem
+`filesystem_list.py [path] [--recursive]`
+
 Returns a directory listing for the specified path.
 
-`webusb_fat_push.py {filename} {target_location}`  
-Uploads a local file to the FAT filesystem.  
-`target_location` should always start with `/flash` or `/sdcard` and include the target filename.
+`filesystem_push.py {name} {target}`
+
+Uploads file `{name}` to location `{target}` on the filesystem of the badge.
+`target` should always start with `/internal` or `/sd` and the target path should always end with a filename.
+
+`filesystem_pull.py {name} {target}`
+
+Downloads file `{name}` from the filesystem of the badge to location `{target}` on your computer.
+`name` should always start with `/internal` or `/sd` and the path should always end with a filename.
+
+`filesystem_remove.py {name}`
+
+Removes a file or a directory from the filesystem of the badge. In case of a directory the directory is removed recursively.
+`name` should always start with `/internal` or `/sd`.
+
+`filesystem_create_directory.py {name}`
+
+Creates a directory on the filesystem of the badge.
+`name` should always start with `/internal` or `/sd`.
+
+`filesystem_exists.py {name}`
+
+Checks if a file exists on the filesystem of the badge.
+`name` should always start with `/internal` or `/sd`.
+
+### Configuration management
+
+`configuration_list.py [namespace]`
+
+Lists all configuration entries in the NVS partition of the badge. The optional `namespace` argument allows for filtering the results, returning only the entries in the provided namespace.
+
+`configuration_read.py {namespace} {key} {type}`
+
+Reads the value of a configuration entry with key `{key}` in namespace `{namespace}`. Valid types are u8 (8-bit unsigned integer), i8 (8-bit signed integer), u16 (16-bit unsigned integer), i16 (16-bit signed integer), u32 (32-bit unsigned integer), i32 (32-bit signed integer), u64 (64-bit unsigned integer), i64 (64-bit signed integer), string (a text string) and blob (binary data).
+
+Note that reading entries of type `blob` will output raw binary data to stdout. You might want to pipe the output to another program (`python configuration_read.py example example blob | xxd`) or to a file (`python configuration_read.py example example blob > data.bin`).
+
+`configuration_write.py {namespace} {key} {type} [value]`
+
+Writes the value of a configuration entry with key `{key}` in namespace `{namespace}`. Valid types are u8 (8-bit unsigned integer), i8 (8-bit signed integer), u16 (16-bit unsigned integer), i16 (16-bit signed integer), u32 (32-bit unsigned integer), i32 (32-bit signed integer), u64 (64-bit unsigned integer), i64 (64-bit signed integer), string (a text string) and blob (binary data).
+
+The value can either be provided using optional command line argument `[value]` or by writing a value to stdin (`echo "test" | python configuration_write.py owner nickname string`). Writing to stdin can also be used for storing binary data to a configuration entry of type `blob`.
+
+`configuration_remove.py {namespace} {key}`
+
+Removes a configuration entry with key `{key}` in namespace `{namespace}` from the NVS partition.
 
 ### FPGA
-`webusb_fpga.py {filename} [bindings]`  
-Loads a bit stream from a file into the FPGA.
+`fpga.py {filename} [bindings]`
+
+Loads a bit stream from a file into the FPGA. This tool also allows for uploading and presenting files to the FPGA via the SPI interface that connects the FPGA to the ESP32.
+
+### Other
+`exit.py`
+
+Reboots the badge, exiting webusb mode.
+
+`information.py`
 
-### General
-`webusb_reset.py`  
-Reboots the device.
+Returns usage information about the FAT filesystems and the AppFS filesystem
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_list.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_list.py
new file mode 100755
index 000000000..117a55668
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_list.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+from webusb import *
+import argparse
+import sys
+import time
+
+def listapps():
+    applist = badge.app_list()
+    if not applist == None:
+        print("\x1b[4m{: <48}\x1b[0m \x1b[4m{: <64}\x1b[0m \x1b[4m{: <8}\x1b[0m \x1b[4m{: <10}\x1b[0m".format("Name", "Title", "Version", "Size"))
+        for app in applist:
+            size = str(app["size"]) + " B"
+            if app["size"] > 1024:
+                size = str(round(app["size"] / 1024, 2)) + " KB"
+            print("{: <48} {: <64} {: <8} {: <10}".format(app["name"].decode("ascii", errors="ignore"), app["title"].decode("ascii", errors="ignore"), str(app["version"]), size))
+    else:
+        print(location.decode("ascii") + " ** Failed to load application list **")
+
+parser = argparse.ArgumentParser(description='MCH2022 badge application list tool')
+args = parser.parse_args()
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+listapps()
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_pull.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_pull.py
new file mode 100755
index 000000000..02ed9a30b
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_pull.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge app download tool')
+parser.add_argument("name", help="Remote app")
+parser.add_argument("target", help="Local file")
+args = parser.parse_args()
+
+name = args.name
+target = args.target
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.app_read(name.encode("ascii", "ignore"))
+
+if result:
+    with open(target, "wb") as f:
+        f.write(result)
+        f.truncate(len(result))
+    print("App downloaded succesfully")
+else:
+    print("Failed to download app")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_push.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_push.py
new file mode 100755
index 000000000..215ad8629
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_push.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge app upload tool')
+parser.add_argument("file", help="Application binary")
+parser.add_argument("name", help="Application name")
+parser.add_argument("title", help="Application title")
+parser.add_argument("version", type=int, help="Application version")
+parser.add_argument('--run', '-r', '-R', action='store_true', help="Run application after uploading")
+args = parser.parse_args()
+
+name = args.name.encode("ascii", "ignore")
+title = args.title.encode("ascii", "ignore")
+version = args.version
+if version < 0:
+    version = 0
+
+with open(args.file, "rb") as f:
+    data = f.read()
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.app_write(name, title, version, data)
+
+if result:
+    print("App installed succesfully")
+else:
+    print("Failed to install app")
+    sys.exit(1)
+
+if args.run:
+    result = badge.app_run(name)
+
+    if result:
+        badge.reset(False)
+        print("Started")
+    else:
+        print("Failed to start")
+        sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_remove.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_remove.py
new file mode 100755
index 000000000..7d28967bb
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_remove.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge app removal tool')
+parser.add_argument("name", help="Name of app to be removed")
+args = parser.parse_args()
+
+name = args.name
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.app_remove(name.encode('ascii', "ignore"))
+
+if result:
+    print("Removed")
+else:
+    print("Failed to remove")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_run.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_run.py
new file mode 100755
index 000000000..bcfc4f892
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/app_run.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge app run tool')
+parser.add_argument("name", help="Name of app to be started")
+parser.add_argument("--command", "-c", help="String to be stored in memory", required=False)
+args = parser.parse_args()
+
+name = args.name
+command = args.command
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.app_run(name.encode('ascii', "ignore"), command.encode('ascii', "ignore") if command else None)
+
+if result:
+    badge.reset(False)
+    print("Started")
+else:
+    print("Failed to start")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_list.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_list.py
new file mode 100755
index 000000000..9328bbdee
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_list.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge NVS list tool')
+parser.add_argument("namespace", help="Namespace", nargs='?', default=None)
+args = parser.parse_args()
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+print("\x1b[4m{: <32}\x1b[0m \x1b[4m{: <32}\x1b[0m \x1b[4m{: <8}\x1b[0m \x1b[4m{: <10}\x1b[0m \x1b[4m{: <32}\x1b[0m".format("Namespace", "Key", "Type", "Size", "Value"))
+badge.printGarbage = True
+if args.namespace:
+    entries = badge.nvs_list(args.namespace)
+else:
+    entries = badge.nvs_list()
+
+if not entries:
+    print("Failed to read data")
+else:
+    for namespace in entries:
+        for entry in entries[namespace]:
+            value = "(skipped)"
+            if entry["size"] < 64 and badge.nvs_should_read(entry["type"]):
+                value = str(badge.nvs_read(namespace, entry["key"], entry["type"]))
+            print("{: <32} {: <32} {: <8} {:10d} {}".format(namespace, entry["key"], badge.nvs_type_to_name(entry["type"]), entry["size"], value))
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_read.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_read.py
new file mode 100755
index 000000000..d4c2b6f78
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_read.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+from webusb import *
+import argparse
+import sys
+import time
+import sys
+
+parser = argparse.ArgumentParser(description='MCH2022 badge NVS read tool')
+parser.add_argument("namespace", help="Namespace")
+parser.add_argument("key", help="Key")
+parser.add_argument("type", help="Type, one of u8, i8, u16, i16, u32, i32, u64, i64, string or blob")
+args = parser.parse_args()
+
+badge = Badge()
+
+type_name = args.type.lower()
+type_number = badge.nvs_name_to_type(type_name)
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+value = badge.nvs_read(args.namespace, args.key, type_number)
+
+if type_name == "blob":
+    sys.stdout.buffer.write(value)
+else:
+    print(value)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_remove.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_remove.py
new file mode 100755
index 000000000..dcc015f8e
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_remove.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+from webusb import *
+import argparse
+import sys
+import time
+import sys
+
+parser = argparse.ArgumentParser(description='MCH2022 badge NVS remove tool')
+parser.add_argument("namespace", help="Namespace")
+parser.add_argument("key", help="Key")
+args = parser.parse_args()
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.nvs_remove(args.namespace, args.key)
+
+if result:
+    print("Entry removed")
+else:
+    print("Failed to remove entry")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_write.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_write.py
new file mode 100755
index 000000000..be1b92887
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/configuration_write.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+from webusb import *
+import argparse
+import sys
+import time
+import sys
+
+parser = argparse.ArgumentParser(description='MCH2022 badge NVS write tool')
+parser.add_argument("namespace", help="Namespace")
+parser.add_argument("key", help="Key")
+parser.add_argument("type", help="Type, one of u8, i8, u16, i16, u32, i32, u64, i64, string or blob")
+parser.add_argument("value", help="Value, optional. If no value is provided the application will read from stdin", nargs='?', default=None)
+args = parser.parse_args()
+
+value = args.value
+
+if not value:
+    value = sys.stdin.buffer.read()
+
+badge = Badge()
+
+type_name = args.type.lower()
+type_number = badge.nvs_name_to_type(type_name)
+
+if type_name in ["u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64"]:
+    value = int(value)
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.nvs_write(args.namespace, args.key, type_number, value)
+
+if result:
+    print("Value stored")
+else:
+    print("Failed to store value")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/generate_tls_cert.sh b/app/resources/plugins/MCH22BToolchain/mch2022-tools/development/generate_tls_cert.sh
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/generate_tls_cert.sh
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/development/generate_tls_cert.sh
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/exit.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/exit.py
new file mode 100755
index 000000000..6e5c4dd34
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/exit.py
@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+from webusb import *
+badge = Badge()
+badge.reset()
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_create_directory.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_create_directory.py
new file mode 100755
index 000000000..dd42df2fe
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_create_directory.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem directory creation tool')
+parser.add_argument("name", help="directory name")
+args = parser.parse_args()
+
+name = args.name
+
+if not (name.startswith("/internal") or name.startswith("/sd")):
+    print("Path should always start with /internal or /sd")
+    sys.exit(1)
+
+if name.endswith("/"):
+    name = name[:-1]
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.fs_create_directory(name.encode('ascii', "ignore"))
+
+if result:
+    print("Directory created")
+else:
+    print("Failed to create directory")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_exists.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_exists.py
new file mode 100755
index 000000000..3e0ac78e9
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_exists.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem file exists check tool')
+parser.add_argument("name", help="Name of file")
+args = parser.parse_args()
+
+name = args.name
+
+if not (name.startswith("/internal") or name.startswith("/sd")):
+    print("Path should always start with /internal or /sd")
+    sys.exit(1)
+
+if name.endswith("/"):
+    name = name[:-1]
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.fs_file_exists(name.encode('ascii', "ignore"))
+
+if result:
+    print("File exists")
+else:
+    print("File does not exist")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_list.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_list.py
new file mode 100755
index 000000000..0c6e18830
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_list.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+from webusb import *
+import argparse
+import sys
+import time
+
+def listdir(location, recursive = False):
+    filelist = badge.fs_list(location)
+    if not filelist == None:
+        for f in filelist:
+            sizestring = ""
+            modifiedstring = ""
+            if f["stat"]:
+                if f["type"] != 2:
+                    s = f["stat"]["size"]
+                    if s >= 1024:
+                        sizestring = str(round(s / 1024, 2)) + " KB"
+                    else:
+                        sizestring = str(s) + " B"
+                modifiedstring = datetime.utcfromtimestamp(f["stat"]["modified"]).strftime('%Y-%m-%d %H:%M:%S')
+            typestring = "File"
+            if f["type"] == 2:
+                typestring = "Dir"
+            newlocation = location + b"/" + f["name"]
+            locationstring = newlocation.decode("ascii", errors="ignore")
+            print("{: <5} {: <64} {: <12} {: <19}".format(typestring, locationstring, sizestring, modifiedstring))
+            if f["type"] == 2 and recursive:
+                listdir(newlocation, recursive)
+    else:
+        print(location.decode("ascii") + " ** Failed to open directory **")
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem directory list tool')
+parser.add_argument("name", help="directory name")
+parser.add_argument('--recursive', '-r', '-R', action='store_true')
+args = parser.parse_args()
+
+name = args.name
+recursive = args.recursive
+
+if name == "/":
+    print("\x1b[4m{: <5}\x1b[0m \x1b[4m{: <64}\x1b[0m \x1b[4m{: <12}\x1b[0m \x1b[4m{: <19}\x1b[0m".format("Type", "Name", "Size", "Modified"))
+    print("{: <5} {: <64} {: <12} {: <19}".format("Dir", "/internal", "", ""))
+    print("{: <5} {: <64} {: <12} {: <19}".format("Dir", "/sd", "", ""))
+    sys.exit(0)
+
+if not (name.startswith("/internal") or name.startswith("/sd")):
+    print("Path should always start with /internal or /sd")
+    sys.exit(1)
+
+if name.endswith("/"):
+    name = name[:-1]
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+print("\x1b[4m{: <5}\x1b[0m \x1b[4m{: <64}\x1b[0m \x1b[4m{: <12}\x1b[0m \x1b[4m{: <19}\x1b[0m".format("Type", "Name", "Size", "Modified"))
+listdir(name.encode("ascii"), recursive)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_pull.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_pull.py
new file mode 100755
index 000000000..4c039d57d
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_pull.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem file download tool')
+parser.add_argument("name", help="Remote file")
+parser.add_argument("target", help="Local file")
+args = parser.parse_args()
+
+name = args.name
+target = args.target
+
+if not (name.startswith("/internal") or name.startswith("/sd")):
+    print("Path should always start with /internal or /sd")
+    sys.exit(1)
+
+if name.endswith("/"):
+    name = name[:-1]
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.fs_read_file(name.encode("ascii", "ignore"))
+
+if result:
+    with open(target, "wb") as f:
+        f.write(result)
+        f.truncate(len(result))
+    print("File downloaded succesfully")
+else:
+    print("Failed to download file")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_push.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_push.py
new file mode 100755
index 000000000..25984bf10
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_push.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem file upload tool')
+parser.add_argument("name", help="Local file")
+parser.add_argument("target", help="Remote file")
+args = parser.parse_args()
+
+name = args.name
+target = args.target
+
+with open(name, "rb") as f:
+    data = f.read()
+
+if not (target.startswith("/internal") or target.startswith("/sd")):
+    print("Path should always start with /internal or /sd")
+    sys.exit(1)
+
+if target.endswith("/"):
+    target = target[:-1]
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.fs_write_file(target.encode("ascii", "ignore"), data)
+
+if result:
+    print("File pushed succesfully")
+else:
+    print("Failed to push file")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_remove.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_remove.py
new file mode 100755
index 000000000..61fca56e0
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/filesystem_remove.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem file removal tool')
+parser.add_argument("name", help="Name of file or directory to be removed")
+args = parser.parse_args()
+
+name = args.name
+
+if not (name.startswith("/internal") or name.startswith("/sd")):
+    print("Path should always start with /internal or /sd")
+    sys.exit(1)
+
+if name.endswith("/"):
+    name = name[:-1]
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+result = badge.fs_remove(name.encode('ascii', "ignore"))
+
+if result:
+    print("Removed")
+else:
+    print("Failed to remove")
+    sys.exit(1)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fpga.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fpga.py
similarity index 92%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fpga.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fpga.py
index e89303c1e..f226f376b 100755
--- a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fpga.py
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fpga.py
@@ -76,15 +76,18 @@ def usb_tx(title, data):
 else:
     print("ESP32 already in FPGA download mode, connecting...")
 
-while True:
-    data = None
+requested_len = 4 + 4 - 1 # 2 times "FPGA" if we are unlucky and "PGAFPGA" got transmitted
+data = bytearray()
+timeout = time.monotonic() + 5
+
+while (data.find(b'FPGA') == -1):
+    if len(data) >= requested_len * 50 or time.monotonic() > timeout: # ~50 tries or 5 seconds
+        raise ValueError("Badge does not answer")
     try:
-        data = bytes(esp32_ep_in.read(32))
+        data += bytes(esp32_ep_in.read(32))
     except Exception as e:
         #print(e)
         pass
-    if (data == b"FPGA"):
-        break
 
 esp32_ep_out.write(b'FPGA')
 
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb.py
new file mode 100644
index 000000000..b9ffdd6fd
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb.py
@@ -0,0 +1,335 @@
+import os
+import sys
+import usb.core
+import usb.util
+from enum import Enum
+import struct
+import time
+
+# Print iterations progress
+def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█', printEnd = "\r"):
+    """
+    Call in a loop to create terminal progress bar
+    @params:
+        iteration   - Required  : current iteration (Int)
+        total       - Required  : total iterations (Int)
+        prefix      - Optional  : prefix string (Str)
+        suffix      - Optional  : suffix string (Str)
+        decimals    - Optional  : positive number of decimals in percent complete (Int)
+        length      - Optional  : character length of bar (Int)
+        fill        - Optional  : bar fill character (Str)
+        printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
+    """
+    percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
+    filledLength = int(length * iteration // total)
+    bar = fill * filledLength + '-' * (length - filledLength)
+    print(f'\r{prefix} |{bar}| {percent}% {suffix}', end = printEnd)
+    # Print New Line on Complete
+    if iteration == total:
+        print()
+
+def printProgressTime(
+    totalMilliSeconds,
+    steps=10,
+    prefix="",
+    suffix="",
+    decimals=1,
+    length=20,
+    fill="█",
+    printEnd="\r",
+):
+    """
+    prints progress while sleeping totalMilliSeconds, bar is updated every `steps` milliseconds
+    other params
+    """
+    for i in range(0, totalMilliSeconds, steps):
+        printProgressBar(
+            i,
+            totalMilliSeconds - steps,
+            prefix,
+            suffix,
+            decimals,
+            length,
+            fill,
+            printEnd,
+        )
+        time.sleep(steps / 1000)
+
+class Commands(Enum):
+    EXECFILE = 0
+    HEARTBEAT = 1
+    APPFSBOOT = 3
+    GETDIR = 4096
+    READFILE = 4097
+    WRITEFILE = 4098
+    DELFILE = 4099
+    DUPLFILE = 4100
+    MVFILE = 4101
+    MAKEDIR = 4102
+    APPFSFDIR = 4103
+    APPFSDEL = 4104
+    APPFSWRITE = 4105
+
+class WebUSBPacket():
+    def __init__(self, command, message_id, payload=None):
+        self.command = command
+        self.message_id = message_id
+        if (payload == None):
+            self.payload = b""
+        else:
+            self.payload = payload
+
+    def getMessage(self):
+        return self._generateHeader() + self.payload 
+
+    def _generateHeader(self):
+        return struct.pack("<HIHI", self.command.value, len(self.payload), 0xADDE, self.message_id)
+
+class WebUSB():
+    def __init__(self, boot = True):
+        if os.name == 'nt':
+            from usb.backend import libusb1
+            lube = libusb1.get_backend(find_library=lambda x: os.path.dirname(__file__) + "\\libusb-1.0.dll")
+            self.device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a, backend=lube)
+        elif sys.platform == 'darwin' and os.path.exists('/opt/homebrew/Cellar/libusb'):
+            from usb.backend import libusb1
+            max_version = max(os.listdir('/opt/homebrew/Cellar/libusb/'))
+            lube = libusb1.get_backend(find_library=lambda x: f'/opt/homebrew/Cellar/libusb/{max_version}/lib/libusb-1.0.dylib')
+            self.device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a, backend=lube)
+        else:
+            self.device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a)
+
+        if self.device is None:
+            raise ValueError("Badge not found")
+
+        self.configuration = self.device.get_active_configuration()
+        self.webusb_esp32   = self.configuration[(4,0)]
+        self.ep_out = usb.util.find_descriptor(self.webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT)
+        self.ep_in  = usb.util.find_descriptor(self.webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN)
+
+        self.REQUEST_TYPE_CLASS_TO_INTERFACE = usb.util.CTRL_TYPE_CLASS + usb.util.CTRL_RECIPIENT_INTERFACE
+        self.REQUEST_STATE    = 0x22
+        self.REQUEST_RESET    = 0x23
+        self.REQUEST_BAUDRATE = 0x24
+        self.REQUEST_MODE     = 0x25
+
+        self.TIMEOUT = 60
+        self.PAYLOADHEADERLEN = 12
+
+        if boot:
+            self.bootWebUSB()
+        self.message_id = 1
+
+    def getMessageId(self):
+        self.message_id += 1
+        return self.message_id
+
+    
+    def bootWebUSB(self):
+        """
+        Boots the badge into webusb mode
+        """
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_STATE, 0x0001, self.webusb_esp32.bInterfaceNumber)
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_MODE, 0x0001, self.webusb_esp32.bInterfaceNumber)
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_RESET, 0x0000, self.webusb_esp32.bInterfaceNumber)
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_BAUDRATE, 9216, self.webusb_esp32.bInterfaceNumber)
+   
+        print("Booting into WebUSB, please wait ...")                          
+        printProgressTime(4000)  # Wait for the badge to have boot into webusb mode  
+        while True:
+            try:
+                self.ep_in.read(128)
+            except Exception as e:
+                break
+
+    def receiveResponse(self, show_hourglass=False):
+        """
+        receveives the response, for longish response times,
+        you can keep the user occupied by setting show_hourglass to True
+        """
+        response = bytes([])
+        starttime = time.time()
+        anim = 0
+        while (time.time() - starttime) < self.TIMEOUT:
+            if show_hourglass:
+                print(f"\rWaiting for response { (1+(anim%3)) * '.'}   ", end="\r")
+                anim += 1
+
+            data = None
+            try:
+                data = bytes(self.ep_in.read(128))
+            except Exception as e:
+                pass
+            
+            if data != None:
+                response += data
+            
+            if len(response) >= self.PAYLOADHEADERLEN:
+                if show_hourglass:
+                    print()
+                command, payloadlen, verif, message_id = struct.unpack_from("<HIHI", response)
+                if verif != 0xADDE:
+                    raise Exception("Failed verification")
+                if len(response) >= (payloadlen + self.PAYLOADHEADERLEN):
+                    return (command, message_id, response[self.PAYLOADHEADERLEN:])
+        raise Exception("Timeout in receiving")
+
+    
+    def sendPacket(self, packet, transfersize=2048, show_response_hourglass=False):
+        transfersize = 2048
+        msg = packet.getMessage()
+        starttime = time.time()
+
+        if len(msg) > transfersize:
+            printProgressBar(0, len(msg) // transfersize, length=20)
+        for i in range(0, len(msg), transfersize):
+            self.ep_out.write(msg[i:i+transfersize])
+            time.sleep(0.01)
+            if len(msg) > transfersize:
+                printProgressBar(i//transfersize, len(msg) // transfersize, length=20)
+        #self.ep_out.write(packet.getMessage())
+        print(f"transfer speed: {(len(msg)/(time.time()-starttime)/1024):0.2f} kb/s")
+        command, message_id, data = self.receiveResponse(show_hourglass=show_response_hourglass)
+        if message_id != packet.message_id:
+            raise Exception("Mismatch in id")
+        if command != packet.command.value:
+            raise Exception("Mismatch in command")
+        return data
+
+    def sendHeartbeat(self):
+        """
+        Send heartbeat towards the badges
+
+        parameters:
+            None
+
+        returns:
+            bool : True if badge responded, false if no response
+        """
+
+        data = self.sendPacket(WebUSBPacket(Commands.HEARTBEAT, self.getMessageId()))
+        return data.decode().rstrip('\x00') == "ok"
+
+    def getFSDir(self, dir):
+        """
+        Get files and directories on the badge filesystem
+
+        parameters:
+            dir (str) : Directory to get contents from
+
+        returns:
+            res (dict) : Dict containing 'dir' which is the requested directory, 'files' list of files in the directory, 'dirs' list of directories
+
+        """
+
+        data = self.sendPacket(WebUSBPacket(Commands.GETDIR, self.getMessageId(), dir.encode(encoding='ascii')))
+        data = data.decode()
+        data = data.split("\n")
+        result = dict()
+        result["dir"] = data[0]
+        result["files"] = list()
+        result["dirs"] = list()
+        for i in range(1, len(data)):
+            fd = data[i]
+            if fd[0] == "f":
+                result["files"].append(fd[1:])
+            else:
+                result["dirs"].append(fd[1:])
+        return result
+
+    def pushFSfile(self, filename, file):
+        """
+        Upload file to fs
+        root path should /flash or /sdcard
+
+        parameters:
+            filename (str) : name of the file
+            file (bytes) : file contents as byte array
+
+        returns:
+            bool : true if file was uploaded
+        """
+
+        payload = filename.encode(encoding='ascii') + b"\x00" + file
+        data = self.sendPacket(WebUSBPacket(Commands.WRITEFILE, self.getMessageId(), payload))
+        return data.decode().rstrip('\x00') == "ok"
+
+    def appfsUpload(self, appname, file):
+        """
+        Upload app to appfs
+
+        parameters:
+            appname (str) : name of the app
+            file (bytes) : the app to be upload
+        
+        returns:
+            bool : true if app was uploaded succesfully
+        """
+
+        payload = appname.encode(encoding="ascii") + b"\x00" + file
+        data = self.sendPacket(WebUSBPacket(Commands.APPFSWRITE, self.getMessageId(), payload), show_response_hourglass=True)
+        return data.decode().rstrip('\x00') == "ok"
+    
+    def appfsRemove(self, appname):
+        """
+        Remove app from appfs
+
+        parameters:
+            appname (str) : name of the app to be removed
+        
+        returns:
+            bool : true if app was deleted succesfully
+        """
+        
+        payload = appname.encode(encoding="ascii") + b"\x00"
+        data = self.sendPacket(WebUSBPacket(Commands.APPFSDEL, self.getMessageId(), payload))
+        return data.decode().rstrip('\x00') == "ok"
+
+    def appfsExecute(self, appname):
+        """
+        Execute app from appfs
+
+        parameters:
+            appname (str) : name of the app to be executed
+
+        returns:
+            bool : true if app was executed
+        
+        """
+        
+
+        payload = appname.encode(encoding="ascii") + b"\x00"
+        data = self.sendPacket(WebUSBPacket(Commands.APPFSBOOT, self.getMessageId(), payload))
+        return data.decode().rstrip('\x00') == "ok"
+
+    def appfsList(self):
+        """
+        Get apps from appfs
+
+        parameters:
+            None
+        
+        returns:
+            list : list of dicts containing 'name' and 'size'
+        """
+
+        data = self.sendPacket(WebUSBPacket(Commands.APPFSFDIR, self.getMessageId()))
+        num_apps, = struct.unpack_from("<I", data)
+        data = data[4:]
+        res = list()
+        for i in range(0, num_apps):
+            appsize, lenname = struct.unpack_from("<II", data)
+            data = data[8:]
+            name = data[0:lenname].decode(encoding="ascii")
+            data = data[lenname:]
+            res.append({"name":name, "size":appsize})
+        return res
+
+    def disconnect(self):
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_BAUDRATE, 1152, self.webusb_esp32.bInterfaceNumber)
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_MODE, 0x0000, self.webusb_esp32.bInterfaceNumber)
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_STATE, 0x0000, self.webusb_esp32.bInterfaceNumber)
+
+
+    def reset(self):
+        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_RESET, 0x0000, self.webusb_esp32.bInterfaceNumber)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_ls.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_appfs_ls.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_ls.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_appfs_ls.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_boot.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_boot.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_boot.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_boot.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fat_ls.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_ls.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fat_ls.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_ls.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_mkdir.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_mkdir.py
new file mode 100755
index 000000000..2988e13eb
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_mkdir.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+
+import os
+import usb.core
+import usb.util
+import binascii
+import time
+import sys
+import struct
+import argparse
+
+parser = argparse.ArgumentParser(description='MCH2022 badge FAT filesystem mkdir tool')
+parser.add_argument("path", help="Folder to create")
+args = parser.parse_args()
+
+# Defined in webusb_task.c of the RP2040 firmware
+REQUEST_STATE          = 0x22
+REQUEST_RESET          = 0x23
+REQUEST_BAUDRATE       = 0x24
+REQUEST_MODE           = 0x25
+REQUEST_MODE_GET       = 0x26
+REQUEST_FW_VERSION_GET = 0x27
+
+WEBUSB_MODE_NEW_WEBUSB = 0x03
+
+if os.name == 'nt':
+    from usb.backend import libusb1
+    be = libusb1.get_backend(find_library=lambda x: os.path.dirname(__file__) + "\\libusb-1.0.dll")
+    device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a, backend=be)
+else:
+    device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a)
+
+if device is None:
+    raise ValueError("Badge not found")
+
+configuration = device.get_active_configuration()
+
+webusb_esp32 = configuration[(4,0)]
+
+esp32_ep_out = usb.util.find_descriptor(webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT)
+esp32_ep_in  = usb.util.find_descriptor(webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN)
+
+request_type_in = usb.util.build_request_type(usb.util.CTRL_IN, usb.util.CTRL_TYPE_CLASS, usb.util.CTRL_RECIPIENT_INTERFACE)
+request_type_out = usb.util.build_request_type(usb.util.CTRL_OUT, usb.util.CTRL_TYPE_CLASS, usb.util.CTRL_RECIPIENT_INTERFACE)
+
+# Connect
+device.ctrl_transfer(request_type_out, REQUEST_STATE, 0x0001, webusb_esp32.bInterfaceNumber)
+
+# Read WebUSB mode
+current_mode = int(device.ctrl_transfer(request_type_in, REQUEST_MODE_GET, 0, webusb_esp32.bInterfaceNumber, 1)[0])
+
+if current_mode != WEBUSB_MODE_NEW_WEBUSB:
+    print("Starting...")
+    device.ctrl_transfer(request_type_out, REQUEST_MODE, WEBUSB_MODE_NEW_WEBUSB, webusb_esp32.bInterfaceNumber)
+    device.ctrl_transfer(request_type_out, REQUEST_RESET, 0x0000, webusb_esp32.bInterfaceNumber)
+    device.ctrl_transfer(request_type_out, REQUEST_BAUDRATE, 1152, webusb_esp32.bInterfaceNumber)
+    time.sleep(4)
+
+data_buffer = b""
+
+magic = 0xFEEDF00D
+
+def handle_packet(identifier, command, payload):
+    command_ascii = struct.pack("<I", command)
+    if (command_ascii == b"OKOK"):
+        #print("Command received, processing...")
+        pass
+    elif (command_ascii == b"FSMD"):
+        if payload[0] == 1:
+            print("Succesfully created directory")
+        else:
+            print("Failed to create directory")
+
+def parse_response(new_data = b""):
+    global data_buffer
+    data_buffer += new_data
+    
+    if len(data_buffer) < 20: # length of header
+        # Not enough data
+        return
+    
+    while len(data_buffer) >= 20:
+        header = struct.unpack("<IIIII", data_buffer[:20])
+        if header[0] != magic:
+            data_buffer = data_buffer[1:]
+            continue
+        identifier = header[1]
+        command = header[2]
+        command_ascii = struct.pack("<I", command)
+        payload_length = header[3]
+        payload_crc = header[4]
+        if (len(data_buffer) - 20) < payload_length:
+            print("Got header, not enough data")
+            break
+        data_buffer = data_buffer[20:]
+        payload = data_buffer[:payload_length]
+        data_buffer = data_buffer[payload_length:]
+        payload_crc_check = binascii.crc32(payload)
+        if payload_crc != payload_crc_check:
+            print("Payload CRC doesn't match", payload_crc, payload_crc_check)
+            continue
+        #print("Packet", identifier, command, command_ascii, payload)
+        handle_packet(identifier, command, payload)
+
+path = args.path
+
+if (path.startswith("/flash")):
+    path = "/internal" + path[6:]
+if (path.startswith("/sdcard")):
+    path = "/sd" + path[7:]
+# Remove trailing /
+if path.endswith("/"):
+    path = path[:-1]
+
+print(path)
+
+payload = path.encode("ascii")
+esp32_ep_out.write(struct.pack("<IIIII", magic, 0x00000000, int.from_bytes(b"FSMD", "little"), len(payload), binascii.crc32(payload)))
+esp32_ep_out.write(payload)
+
+data = bytes([])
+t = 2000
+while t > 0:
+    try:
+        new_data = bytes(esp32_ep_in.read(esp32_ep_in.wMaxPacketSize, 20))
+        data += new_data
+        if len(new_data) > 0:
+            t = 20
+    except Exception as e:
+        t-=1
+
+parse_response(data)
+
+device.ctrl_transfer(request_type_out, REQUEST_STATE, 0x0000, webusb_esp32.bInterfaceNumber)
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fat_push.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_push.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_fat_push.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_fat_push.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_push.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_push.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_push.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_push.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_reset.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_reset.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_reset.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_reset.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_rm.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_rm.py
similarity index 100%
rename from app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb_rm.py
rename to app/resources/plugins/MCH22BToolchain/mch2022-tools/fsoverbus/webusb_rm.py
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/information.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/information.py
new file mode 100644
index 000000000..7618567a3
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/information.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+from webusb import *
+import argparse
+import sys
+import time
+
+parser = argparse.ArgumentParser(description='MCH2022 badge filesystem info tool')
+args = parser.parse_args()
+
+badge = Badge()
+
+if not badge.begin():
+    print("Failed to connect")
+    sys.exit(1)
+
+try:
+    info = badge.info().split(" ")
+    print("Device name:             {}".format(info[0]))
+    print("Firmware version:        {}".format(info[1]))
+except:
+    pass
+
+result = badge.fs_state()
+
+internal_size = result["internal"]["size"]
+internal_free = result["internal"]["free"]
+sdcard_size = result["sd"]["size"]
+sdcard_free = result["sd"]["free"]
+appfs_size = result["app"]["size"]
+appfs_free = result["app"]["free"]
+
+badge.printProgressBar(appfs_size - appfs_free,       appfs_size,    'Internal APP filesystem: {: <32}'.format('{} of {} KB used'.format(int((appfs_size-appfs_free) / 1024), int(appfs_size / 1024))), '', 0, printEnd="\r\n")
+badge.printProgressBar(internal_size - internal_free, internal_size, 'Internal FAT filesystem: {: <32}'.format('{} of {} KB used'.format(int((internal_size-internal_free) / 1024), int(internal_size / 1024))), '', 0, printEnd="\r\n")
+if sdcard_size > 0:
+    badge.printProgressBar(sdcard_size - sdcard_free,     sdcard_size,   'SD card  FAT filesystem: {: <32}'.format('{} of {} KB used'.format(int((sdcard_size-sdcard_free) / 1024), int(sdcard_size / 1024))), '', 0, printEnd="\r\n")
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/shell.nix b/app/resources/plugins/MCH22BToolchain/mch2022-tools/shell.nix
new file mode 100644
index 000000000..f428ec428
--- /dev/null
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/shell.nix
@@ -0,0 +1,7 @@
+{ pkgs ? import <nixpkgs> {} }:
+
+pkgs.mkShell {
+  packages = [
+    (pkgs.python3.withPackages (ps: [ ps.pyusb ]))
+  ];
+}
diff --git a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb.py b/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb.py
old mode 100644
new mode 100755
index e0b8b8d68..73ed159e5
--- a/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb.py
+++ b/app/resources/plugins/MCH22BToolchain/mch2022-tools/webusb.py
@@ -1,329 +1,751 @@
+#!/usr/bin/env python3
+
 import os
 import usb.core
 import usb.util
-from enum import Enum
-import struct
+import binascii
 import time
+import sys
+import struct
+from datetime import datetime
+
+class Badge:
+    # Defined in webusb_task.c of the RP2040 firmware
+    REQUEST_STATE          = 0x22
+    REQUEST_RESET          = 0x23
+    REQUEST_BAUDRATE       = 0x24
+    REQUEST_MODE           = 0x25
+    REQUEST_MODE_GET       = 0x26
+    REQUEST_FW_VERSION_GET = 0x27
+
+    # Defined in main.c of the ESP32 firmware
+    BOOT_MODE_NORMAL        = 0x00
+    BOOT_MODE_WEBUSB_LEGACY = 0x01
+    BOOT_MODE_FPGA_DOWNLOAD = 0x02
+    BOOT_MODE_WEBUSB        = 0x03
+    
+    MAGIC = 0xFEEDF00D
 
-# Print iterations progress
-def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█', printEnd = "\r"):
-    """
-    Call in a loop to create terminal progress bar
-    @params:
-        iteration   - Required  : current iteration (Int)
-        total       - Required  : total iterations (Int)
-        prefix      - Optional  : prefix string (Str)
-        suffix      - Optional  : suffix string (Str)
-        decimals    - Optional  : positive number of decimals in percent complete (Int)
-        length      - Optional  : character length of bar (Int)
-        fill        - Optional  : bar fill character (Str)
-        printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
-    """
-    percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
-    filledLength = int(length * iteration // total)
-    bar = fill * filledLength + '-' * (length - filledLength)
-    print(f'\r{prefix} |{bar}| {percent}% {suffix}', end = printEnd)
-    # Print New Line on Complete
-    if iteration == total:
-        print()
-
-def printProgressTime(
-    totalMilliSeconds,
-    steps=10,
-    prefix="",
-    suffix="",
-    decimals=1,
-    length=20,
-    fill="█",
-    printEnd="\r",
-):
-    """
-    prints progress while sleeping totalMilliSeconds, bar is updated every `steps` milliseconds
-    other params
-    """
-    for i in range(0, totalMilliSeconds, steps):
-        printProgressBar(
-            i,
-            totalMilliSeconds - steps,
-            prefix,
-            suffix,
-            decimals,
-            length,
-            fill,
-            printEnd,
-        )
-        time.sleep(steps / 1000)
-
-class Commands(Enum):
-    EXECFILE = 0
-    HEARTBEAT = 1
-    APPFSBOOT = 3
-    GETDIR = 4096
-    READFILE = 4097
-    WRITEFILE = 4098
-    DELFILE = 4099
-    DUPLFILE = 4100
-    MVFILE = 4101
-    MAKEDIR = 4102
-    APPFSFDIR = 4103
-    APPFSDEL = 4104
-    APPFSWRITE = 4105
-
-class WebUSBPacket():
-    def __init__(self, command, message_id, payload=None):
-        self.command = command
-        self.message_id = message_id
-        if (payload == None):
-            self.payload = b""
-        else:
-            self.payload = payload
-
-    def getMessage(self):
-        return self._generateHeader() + self.payload 
-
-    def _generateHeader(self):
-        return struct.pack("<HIHI", self.command.value, len(self.payload), 0xADDE, self.message_id)
-
-class WebUSB():
-    def __init__(self, boot = True):
+    def __init__(self):
         if os.name == 'nt':
             from usb.backend import libusb1
-            lube = libusb1.get_backend(find_library=lambda x: os.path.dirname(__file__) + "\\libusb-1.0.dll")
-            self.device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a, backend=lube)
+            be = libusb1.get_backend(find_library=lambda x: os.path.dirname(__file__) + "\\libusb-1.0.dll")
+            self.device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a, backend=be)
         else:
             self.device = usb.core.find(idVendor=0x16d0, idProduct=0x0f9a)
 
         if self.device is None:
             raise ValueError("Badge not found")
 
-        self.configuration = self.device.get_active_configuration()
-        self.webusb_esp32   = self.configuration[(4,0)]
-        self.ep_out = usb.util.find_descriptor(self.webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT)
-        self.ep_in  = usb.util.find_descriptor(self.webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN)
+        configuration = self.device.get_active_configuration()
 
-        self.REQUEST_TYPE_CLASS_TO_INTERFACE = usb.util.CTRL_TYPE_CLASS + usb.util.CTRL_RECIPIENT_INTERFACE
-        self.REQUEST_STATE    = 0x22
-        self.REQUEST_RESET    = 0x23
-        self.REQUEST_BAUDRATE = 0x24
-        self.REQUEST_MODE     = 0x25
+        self.webusb_esp32 = configuration[(4,0)]
 
-        self.TIMEOUT = 60
-        self.PAYLOADHEADERLEN = 12
+        self.esp32_ep_out = usb.util.find_descriptor(self.webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT)
+        self.esp32_ep_in  = usb.util.find_descriptor(self.webusb_esp32, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN)
 
-        if boot:
-            self.bootWebUSB()
-        self.message_id = 1
+        self.request_type_in = usb.util.build_request_type(usb.util.CTRL_IN, usb.util.CTRL_TYPE_CLASS, usb.util.CTRL_RECIPIENT_INTERFACE)
+        self.request_type_out = usb.util.build_request_type(usb.util.CTRL_OUT, usb.util.CTRL_TYPE_CLASS, usb.util.CTRL_RECIPIENT_INTERFACE)
+        
+        self.rx_data = bytes([])
+        self.packets = []
 
-    def getMessageId(self):
-        self.message_id += 1
-        return self.message_id
+        self.printGarbage = False
 
-    
-    def bootWebUSB(self):
+    def printProgressBar(self, iteration, total, prefix = '', suffix = '', decimals = 1, length = 50, fill = '█', printEnd = "\r"):
         """
-        Boots the badge into webusb mode
+        Call in a loop to create terminal progress bar
+        @params:
+            iteration   - Required  : current iteration (Int)
+            total       - Required  : total iterations (Int)
+            prefix      - Optional  : prefix string (Str)
+            suffix      - Optional  : suffix string (Str)
+            decimals    - Optional  : positive number of decimals in percent complete (Int)
+            length      - Optional  : character length of bar (Int)
+            fill        - Optional  : bar fill character (Str)
+            printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
         """
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_STATE, 0x0001, self.webusb_esp32.bInterfaceNumber)
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_MODE, 0x0001, self.webusb_esp32.bInterfaceNumber)
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_RESET, 0x0000, self.webusb_esp32.bInterfaceNumber)
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_BAUDRATE, 9216, self.webusb_esp32.bInterfaceNumber)
-   
-        print("Booting into WebUSB, please wait ...")                          
-        printProgressTime(4000)  # Wait for the badge to have boot into webusb mode  
-        while True:
+        percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
+        filledLength = int(length * iteration // total)
+        bar = fill * filledLength + '-' * (length - filledLength)
+        print(f'\r{prefix} |{bar}| {percent}% {suffix}', end = printEnd)
+        # Print New Line on Complete
+        if iteration == total and printEnd != "\r\n":
+            print()
+
+    def begin(self):
+        if not self.sync():
+            self.start_webusb()
+            for i in range(20):
+                if i == 10:
+                    self.reset()
+                    self.start_webusb()
+                    time.sleep(0.5)
+                self.printProgressBar(i, 20, 'Connecting...', '', 0)
+                if self.sync():
+                    self.printProgressBar(20, 20, 'Connecting...', '', 0)
+                    return True
+                time.sleep(0.1)
+            return False
+        return True
+
+    def send_packet(self, command = b"XXXX", payload = bytes([]), flush = True):
+        if flush:
+            self.receive_packets(1)
+            self.packets = []
+        self.esp32_ep_out.write(struct.pack("<IIIII", self.MAGIC, 0x00000000, int.from_bytes(command, "little"), len(payload), binascii.crc32(payload)))
+        if len(payload) > 0:
+            self.esp32_ep_out.write(payload)
+
+    def receive_data(self, timeout = 100):
+        while timeout > 0:
             try:
-                self.ep_in.read(128)
+                new_data = bytes(self.esp32_ep_in.read(self.esp32_ep_in.wMaxPacketSize, 5))
+                self.rx_data += new_data
+                if len(new_data) > 0:
+                    timeout = 5
             except Exception as e:
+                timeout-=1
+
+    def receive_packets(self, timeout = 100):
+        garbage = bytearray()
+        self.receive_data(timeout)
+        if len(self.rx_data) < 20: # length of header
+            return False
+        while len(self.rx_data) >= 20:
+            header = struct.unpack("<IIIII", self.rx_data[:20])
+            if header[0] != self.MAGIC:
+                garbage.append(self.rx_data[0])
+                self.rx_data = self.rx_data[1:]
+                continue
+            identifier = header[1]
+            command = header[2]
+            command_ascii = struct.pack("<I", command)
+            payload_length = header[3]
+            payload_crc = header[4]
+            if (len(self.rx_data) - 20) < payload_length:
+                print("Got header, not enough data")
                 break
-
-    def receiveResponse(self, show_hourglass=False):
-        """
-        receveives the response, for longish response times,
-        you can keep the user occupied by setting show_hourglass to True
-        """
-        response = bytes([])
-        starttime = time.time()
-        anim = 0
-        while (time.time() - starttime) < self.TIMEOUT:
-            if show_hourglass:
-                print(f"\rWaiting for response { (1+(anim%3)) * '.'}   ", end="\r")
-                anim += 1
-
-            data = None
-            try:
-                data = bytes(self.ep_in.read(128))
-            except Exception as e:
-                pass
-            
-            if data != None:
-                response += data
-            
-            if len(response) >= self.PAYLOADHEADERLEN:
-                if show_hourglass:
-                    print()
-                command, payloadlen, verif, message_id = struct.unpack_from("<HIHI", response)
-                if verif != 0xADDE:
-                    raise Exception("Failed verification")
-                if len(response) >= (payloadlen + self.PAYLOADHEADERLEN):
-                    return (command, message_id, response[self.PAYLOADHEADERLEN:])
-        raise Exception("Timeout in receiving")
-
+            #print("Receive payload length", command_ascii, payload_length)
+            self.rx_data = self.rx_data[20:]
+            payload = self.rx_data[:payload_length]
+            self.rx_data = self.rx_data[payload_length:]
+            payload_crc_check = binascii.crc32(payload)
+            if payload_crc != payload_crc_check:
+                #print("payload", payload)
+                print("Payload CRC doesn't match {:08X} {:08X}".format(payload_crc, payload_crc_check))
+                #continue
+            self.packets.append({
+                "identifier": identifier,
+                "command": command_ascii,
+                "payload": payload
+            })
+        if len(garbage) > 0 and self.printGarbage:
+            print("Garbage:", garbage, garbage.decode("ascii", "ignore"))
+        return True
     
-    def sendPacket(self, packet, transfersize=2048, show_response_hourglass=False):
-        transfersize = 2048
-        msg = packet.getMessage()
-        starttime = time.time()
-
-        if len(msg) > transfersize:
-            printProgressBar(0, len(msg) // transfersize, length=20)
-        for i in range(0, len(msg), transfersize):
-            self.ep_out.write(msg[i:i+transfersize])
-            time.sleep(0.01)
-            if len(msg) > transfersize:
-                printProgressBar(i//transfersize, len(msg) // transfersize, length=20)
-        #self.ep_out.write(packet.getMessage())
-        print(f"transfer speed: {(len(msg)/(time.time()-starttime)/1024):0.2f} kb/s")
-        command, message_id, data = self.receiveResponse(show_hourglass=show_response_hourglass)
-        if message_id != packet.message_id:
-            raise Exception("Mismatch in id")
-        if command != packet.command.value:
-            raise Exception("Mismatch in command")
-        return data
-
-    def sendHeartbeat(self):
-        """
-        Send heartbeat towards the badges
-
-        parameters:
-            None
-
-        returns:
-            bool : True if badge responded, false if no response
-        """
-
-        data = self.sendPacket(WebUSBPacket(Commands.HEARTBEAT, self.getMessageId()))
-        return data.decode().rstrip('\x00') == "ok"
-
-    def getFSDir(self, dir):
-        """
-        Get files and directories on the badge filesystem
-
-        parameters:
-            dir (str) : Directory to get contents from
-
-        returns:
-            res (dict) : Dict containing 'dir' which is the requested directory, 'files' list of files in the directory, 'dirs' list of directories
-
-        """
-
-        data = self.sendPacket(WebUSBPacket(Commands.GETDIR, self.getMessageId(), dir.encode(encoding='ascii')))
-        data = data.decode()
-        data = data.split("\n")
-        result = dict()
-        result["dir"] = data[0]
-        result["files"] = list()
-        result["dirs"] = list()
-        for i in range(1, len(data)):
-            fd = data[i]
-            if fd[0] == "f":
-                result["files"].append(fd[1:])
-            else:
-                result["dirs"].append(fd[1:])
-        return result
-
-    def pushFSfile(self, filename, file):
-        """
-        Upload file to fs
-        root path should /flash or /sdcard
-
-        parameters:
-            filename (str) : name of the file
-            file (bytes) : file contents as byte array
-
-        returns:
-            bool : true if file was uploaded
-        """
-
-        payload = filename.encode(encoding='ascii') + b"\x00" + file
-        data = self.sendPacket(WebUSBPacket(Commands.WRITEFILE, self.getMessageId(), payload))
-        return data.decode().rstrip('\x00') == "ok"
-
-    def appfsUpload(self, appname, file):
-        """
-        Upload app to appfs
-
-        parameters:
-            appname (str) : name of the app
-            file (bytes) : the app to be upload
-        
-        returns:
-            bool : true if app was uploaded succesfully
-        """
-
-        payload = appname.encode(encoding="ascii") + b"\x00" + file
-        data = self.sendPacket(WebUSBPacket(Commands.APPFSWRITE, self.getMessageId(), payload), show_response_hourglass=True)
-        return data.decode().rstrip('\x00') == "ok"
+    def receive_packet(self, timeout = 100):
+        self.receive_packets(timeout)
+        packet = None
+        if len(self.packets) > 0:
+            packet = self.packets[0]
+            self.packets = self.packets[1:]
+        return packet
     
-    def appfsRemove(self, appname):
-        """
-        Remove app from appfs
-
-        parameters:
-            appname (str) : name of the app to be removed
+    def peek_packet(self, timeout = 100):
+        self.receive_packets(timeout)
+        packet = None
+        if len(self.packets) > 0:
+            packet = self.packets[0]
+        return packet
+    
+    def sync(self):
+        self.receive_packets()
+        self.packets = []
+        self.send_packet(b"SYNC")
+        response = self.receive_packet()
+        if not response:
+            return False
+        if not response["command"] == b"SYNC":
+            return False
+        if  len(response["payload"]) != 2 or (struct.unpack("<H", response["payload"])[0] < 0x0001):
+            print("Please update your MCH2022 badge to firmware version 2.0.1 or newer. This firmware is currently available on the experimental update channel only.")
+            print("To install go to Settings > Install experimental firmware on your badge.")
+            print()
+            print("The tools for older firmwares can be found in the 'fsoverbus' subfolder of this repository")
+            sys.exit(1)
+            return False
+        return True
+
+    def ping(self, payload):
+        self.send_packet(b"PING", payload)
+        response = self.receive_packet()
+        if not response:
+            return False
+        if not response["command"] == b"PING":
+            print("No PING", response["command"])
+            return False
+        if not response["payload"] == payload:
+            print("Payload mismatch", payload, response["payload"])
+            for i in range(len(payload)):
+                print(i, int(payload[i]), int(response["payload"][i]))
+            return False
+        return True
+
+    def info(self):
+        self.send_packet(b"INFO")
+        response = self.receive_packet()
+        if not response:
+            return False
+        if not response["command"] == b"INFO":
+            print("No INFO", response["command"])
+            return False
+        return response["payload"].decode("ascii", "ignore")
+    
+    def fs_list(self, payload):
+        self.send_packet(b"FSLS", payload + b"\0")
+        response = self.receive_packet()
+        if not response:
+            print("No response")
+            return None
+        if not response["command"] == b"FSLS":
+            if not response["command"] == b"ERR5": # Failed to open directory
+                print("No FSLS", response["command"])
+            return None
+        payload = response["payload"]
+
+        output = []
         
-        returns:
-            bool : true if app was deleted succesfully
-        """
+        while len(payload) > 0:
+            data = payload[:1 + 4]
+            payload = payload[1 + 4:]
+            (item_type, item_name_length) = struct.unpack("<BI", data)
+            name = payload[:item_name_length]
+            payload = payload[item_name_length:]
+            data = payload[:4 + 4 + 8]
+            payload = payload[4 + 4 + 8:]
+            (stat_res, item_size, item_modified) = struct.unpack("<iIQ", data)
+            stat = None
+            if stat_res == 0:
+                stat = {
+                    "size": item_size,
+                    "modified": item_modified
+                }
+            item = {
+                "type": item_type,
+                "name": name,
+                "stat": stat
+            }
+            output.append(item)
+        return output
+
+    def fs_file_exists(self, name):
+        self.send_packet(b"FSEX", name)
+        response = self.receive_packet()
+        if not response:
+            print("No response to FSEX")
+            return False
+        if not response["command"] == b"FSEX":
+            print("No FSEX", response["command"])
+            return False
+        payload = response["payload"]
+        if not len(payload) == 1:
+            print("Wrong payload length")
+            return False
+        return True if payload[0] else False
+
+    def fs_create_directory(self, name):
+        self.send_packet(b"FSMD", name)
+        response = self.receive_packet()
+        if not response:
+            print("No response to FSMD")
+            return False
+        if not response["command"] == b"FSMD":
+            print("No FSMD", response["command"])
+            return False
+        payload = response["payload"]
+        if not len(payload) == 1:
+            print("Wrong payload length")
+            return False
+        return True if payload[0] else False
+
+    def fs_remove(self, name):
+        self.send_packet(b"FSRM", name)
+        response = self.receive_packet(10000)
+        if not response:
+            print("No response to FSRM")
+            return False
+        if not response["command"] == b"FSRM":
+            print("No FSRM", response["command"])
+            return False
+        payload = response["payload"]
+        if not len(payload) == 1:
+            print("Wrong payload length")
+            return False
+        return True if payload[0] else False
+
+    def fs_state(self):
+        self.send_packet(b"FSST")
+        response = self.receive_packet()
+        if not response:
+            print("No response to FSST")
+            return False
+        if not response["command"] == b"FSST":
+            print("No FSST", response["command"])
+            return False
+        payload = response["payload"]
+        (internal_size, internal_free, sdcard_size, sdcard_free, appfs_size, appfs_free) = struct.unpack("<QQQQQQ", payload)
+        return {
+            "internal": {
+                "size": internal_size,
+                "free": internal_free
+            },
+            "sd": {
+                "size": sdcard_size,
+                "free": sdcard_free
+            },
+            "app": {
+                "size": appfs_size,
+                "free": appfs_free
+            }
+        }
+    def fs_write_file(self, name, data):
+        self.send_packet(b"FSFW", name)
+        response = self.receive_packet()
+        if not response:
+            print("No response FSFW")
+            return False
+        if not response["command"] == b"FSFW":
+            print("No FSFW", response["command"])
+            return False
+        payload = response["payload"]
+        if not payload[0]:
+            print("Failed to open file")
+            return False
+        position = 0
+
+        total = len(data)
+        while True:
+            chunk = data[position:position+8192]
+            if len(chunk) < 1:
+                break
+            self.printProgressBar(position, total, 'Writing...', '{} of {} bytes'.format(position, total), 0)
+            position += 8192
+            sent = self.fs_write_chunk(chunk)
+            if sent != len(chunk):
+                print("Failed to send data", sent, len(chunk))
+                self.fs_close_file()
+                return False
+        self.fs_close_file()
+        self.printProgressBar(100, 100, 'Writing...', '', 0)
+        return True
+
+    def fs_write_chunk(self, data):
+        self.send_packet(b"CHNK", data)
+        response = self.receive_packet()
+        if not response:
+            print("No response CHNK write")
+            return False
+        if not response["command"] == b"CHNK":
+            print("No CHNK", response["command"])
+            return False
+        return struct.unpack("<I", response["payload"])[0]
+
+    def fs_read_file(self, name):
+        self.send_packet(b"FSFR", name)
+        response = self.receive_packet()
+        if not response:
+            print("No response FSFR")
+            return False
+        if not response["command"] == b"FSFR":
+            print("No FSFR", response["command"])
+            return False
+        payload = response["payload"]
+        if not payload[0]:
+            return False
         
-        payload = appname.encode(encoding="ascii") + b"\x00"
-        data = self.sendPacket(WebUSBPacket(Commands.APPFSDEL, self.getMessageId(), payload))
-        return data.decode().rstrip('\x00') == "ok"
+        data = bytearray()
 
-    def appfsExecute(self, appname):
-        """
-        Execute app from appfs
+        while True:
+            datanew = self.read_chunk()
+            if datanew == None:
+                print("Read error!")
+                return False
+            data += datanew
+            self.printProgressBar(0, 100, 'Reading...', '{} bytes'.format(len(data)), 0)
+            if len(datanew) < 1:
+                break
+        self.printProgressBar(100, 100, 'Reading...', '{} bytes'.format(len(data)), 0)
+        self.fs_close_file()
+        return data
 
-        parameters:
-            appname (str) : name of the app to be executed
+    def fs_close_file(self):
+        self.send_packet(b"FSFC")
+        response = self.receive_packet()
+        if not response:
+            print("No response to FSFC")
+            return False
+        if not response["command"] == b"FSFC":
+            print("No FSFC", response["command"])
+            return False
+        payload = response["payload"]
+        if not len(payload) == 1:
+            print("Wrong payload length")
+            return False
+        return True if payload[0] else False
+    
+    def read_chunk(self):
+        self.send_packet(b"CHNK")
+        response = self.receive_packet()
+        if not response:
+            print("No response CHNK read")
+            return False
+        if not response["command"] == b"CHNK":
+            print("No CHNK", response["command"])
+            return False
+        payload = response["payload"]
+        return payload
+
+    def app_list(self):
+        self.send_packet(b"APPL")
+        response = self.receive_packet()
+        if not response:
+            print("No response")
+            return None
+        if not response["command"] == b"APPL":
+            print("No APPL", response["command"])
+            return None
+        payload = response["payload"]
+
+        output = []
+
+        while len(payload) > 0:
+            name_length = header = struct.unpack("<H", payload[:2])[0]
+            payload = payload[2:]
+            name = payload[:name_length]
+            payload = payload[name_length:]
+            title_length = header = struct.unpack("<H", payload[:2])[0]
+            payload = payload[2:]
+            title = payload[:title_length]
+            payload = payload[title_length:]
+            (version, size) = struct.unpack("<HI", payload[:6])
+            payload = payload[6:]
+
+            output.append({
+                "name": name,
+                "title": title,
+                "version": version,
+                "size": size
+            })
+        return output
+
+    def app_read(self, name):
+        self.send_packet(b"APPR", name)
+        response = self.receive_packet()
+        if not response:
+            print("No response APPR")
+            return False
+        if not response["command"] == b"APPR":
+            print("No APPR", response["command"])
+            return False
+        payload = response["payload"]
+        if not payload[0]:
+            return False
+
+        data = bytearray()
 
-        returns:
-            bool : true if app was executed
-        
-        """
-        
+        while True:
+            datanew = self.read_chunk()
+            if datanew == None:
+                print("Read error!")
+                return False
+            data += datanew
+            self.printProgressBar(0, 100, 'Reading...', '{} bytes'.format(len(data)), 0)
+            if len(datanew) < 1:
+                break
+        self.printProgressBar(100, 100, 'Reading...', '{} bytes'.format(len(data)), 0)
+        self.fs_close_file()
+        return data
 
-        payload = appname.encode(encoding="ascii") + b"\x00"
-        data = self.sendPacket(WebUSBPacket(Commands.APPFSBOOT, self.getMessageId(), payload))
-        return data.decode().rstrip('\x00') == "ok"
+    def app_write(self, name, title, version, data):
+        print("Preparing...")
+        payload = struct.pack("<B", len(name)) + name + struct.pack("<B", len(title)) + title + struct.pack("<LH", len(data), version)
+        self.send_packet(b"APPW", payload)
+        response = self.receive_packet(10000)
+        if not response:
+            print("No response APPW")
+            return False
+        if not response["command"] == b"APPW":
+            print("No APPW", response["command"])
+            return False
+        payload = response["payload"]
+        if not payload[0]:
+            print("Failed to open file")
+            return False
+        position = 0
+
+        total = len(data)
+        while True:
+            chunk = data[position:position+8192]
+            if len(chunk) < 1:
+                break
+            self.printProgressBar(position, total, 'Writing...', '{} of {} bytes'.format(position, total), 0)
+            position += 8192
+            sent = self.fs_write_chunk(chunk)
+            if sent != len(chunk):
+                print("Failed to send data", sent, len(chunk))
+                self.fs_close_file()
+                return False
+        self.fs_close_file()
+        self.printProgressBar(100, 100, 'Writing...', '', 0)
+        return True
+
+    def app_remove(self, name):
+        self.send_packet(b"APPD", name)
+        response = self.receive_packet(10000)
+        if not response:
+            print("No response to APPD")
+            return False
+        if not response["command"] == b"APPD":
+            print("No APPD", response["command"])
+            return False
+        payload = response["payload"]
+        if not len(payload) == 1:
+            print("Wrong payload length")
+            return False
+        return True if payload[0] else False
+
+    def app_run(self, name, command = None):
+        if command:
+            self.send_packet(b"APPX", name + b"\0" + command)
+        else:
+            self.send_packet(b"APPX", name)
+        response = self.receive_packet()
+        if not response:
+            print("No response to APPX")
+            return False
+        if not response["command"] == b"APPX":
+            print("No APPX", response["command"])
+            return False
+        payload = response["payload"]
+        if not len(payload) == 1:
+            print("Wrong payload length")
+            return False
+        return True if payload[0] else False
+
+    def nvs_list(self, namespace = None):
+        if namespace:
+            self.send_packet(b"NVSL", namespace.encode("ascii", "ignore"))
+        else:
+            self.send_packet(b"NVSL")
+        response = self.receive_packet()
+        if not response:
+            print("No response to NVSL")
+            return None
+        if not response["command"] == b"NVSL":
+            print("No NVSL", response["command"])
+            return None
+        payload = response["payload"]
+
+        output = {}
+
+        while len(payload) > 0:
+            namespace_name_length = struct.unpack("<H", payload[:2])[0]
+            payload = payload[2:]
+            namespace_name = payload[:namespace_name_length].decode("ascii", "ignore")
+            payload = payload[namespace_name_length:]
+            key_length = struct.unpack("<H", payload[:2])[0]
+            payload = payload[2:]
+            key = payload[:key_length].decode("ascii", "ignore")
+            payload = payload[key_length:]
+            value_type = struct.unpack("<B", payload[:1])[0]
+            payload = payload[1:]
+            value_size = struct.unpack("<L", payload[:4])[0]
+            payload = payload[4:]
+            if not namespace_name in output:
+                output[namespace_name] = []
+            output[namespace_name].append({
+                "key": key,
+                "type": value_type,
+                "size": value_size
+            })
+        return output
+
+    def nvs_read(self, namespace, key, type_number):
+        payload = bytearray()
+        payload += struct.pack("<B", len(namespace))
+        payload += namespace.encode("ascii", "ignore")
+        payload += struct.pack("<B", len(key))
+        payload += key.encode("ascii", "ignore")
+        payload += struct.pack("<B", type_number)
+        self.send_packet(b"NVSR", payload)
+        response = self.receive_packet()
+        if not response:
+            print("No response to NVSR")
+            return None
+        if not response["command"] == b"NVSR":
+            print("No NVSR", response["command"])
+            return None
+        result = response["payload"]
+        if type_number == 0x01:
+            return struct.unpack("<B", result)[0]
+        if type_number == 0x11:
+            return struct.unpack("<b", result)[0]
+        if type_number == 0x02:
+            return struct.unpack("<H", result)[0]
+        if type_number == 0x12:
+            return struct.unpack("<h", result)[0]
+        if type_number == 0x04:
+            return struct.unpack("<I", result)[0]
+        if type_number == 0x14:
+            return struct.unpack("<i", result)[0]
+        if type_number == 0x08:
+            return struct.unpack("<Q", result)[0]
+        if type_number == 0x18:
+            return struct.unpack("<q", result)[0]
+        if type_number == 0x21:
+            return result.decode("utf-8", "ignore")
+        return result
 
-    def appfsList(self):
-        """
-        Get apps from appfs
+    def nvs_write(self, namespace, key, type_number, value):
+        payload = bytearray()
+        payload += struct.pack("<B", len(namespace))
+        payload += namespace.encode("ascii", "ignore")
+        payload += struct.pack("<B", len(key))
+        payload += key.encode("ascii", "ignore")
+        payload += struct.pack("<B", type_number)
+        if type_number == 0x01:
+            payload += struct.pack("<B", value)
+        elif type_number == 0x11:
+            payload += struct.pack("<b", value)
+        elif type_number == 0x02:
+            payload += struct.pack("<H", value)
+        elif type_number == 0x12:
+            payload += struct.pack("<h", value)
+        elif type_number == 0x04:
+            payload += struct.pack("<I", value)
+        elif type_number == 0x14:
+            payload += struct.pack("<i", value)
+        elif type_number == 0x08:
+            payload += struct.pack("<Q", value)
+        elif type_number == 0x18:
+            payload += struct.pack("<q", value)
+        elif type_number == 0x21:
+            if type(value) == bytes or type(value) == bytearray:
+                payload += value
+            else:
+                payload += value.encode("utf-8", "ignore")
+        elif type_number == 0x42:
+            payload += bytes(value)
+        else:
+            raise ValueError("Invalid type")
+        self.send_packet(b"NVSW", payload)
+        response = self.receive_packet()
+        if not response:
+            print("No response to NVSW")
+            return None
+        if not response["command"] == b"NVSW":
+            print("No NVSW", response["command"])
+            return None
+        result = response["payload"]
+        return result
 
-        parameters:
-            None
-        
-        returns:
-            list : list of dicts containing 'name' and 'size'
-        """
+    def nvs_remove(self, namespace, key):
+        payload = bytearray()
+        payload += struct.pack("<B", len(namespace))
+        payload += namespace.encode("ascii", "ignore")
+        payload += struct.pack("<B", len(key))
+        payload += key.encode("ascii", "ignore")
+        self.send_packet(b"NVSD", payload)
+        response = self.receive_packet()
+        if not response:
+            print("No response to NVSD")
+            return None
+        if not response["command"] == b"NVSD":
+            print("No NVSD", response["command"])
+            return None
+        result = response["payload"]
+        return result
 
-        data = self.sendPacket(WebUSBPacket(Commands.APPFSFDIR, self.getMessageId()))
-        num_apps, = struct.unpack_from("<I", data)
-        data = data[4:]
-        res = list()
-        for i in range(0, num_apps):
-            appsize, lenname = struct.unpack_from("<II", data)
-            data = data[8:]
-            name = data[0:lenname].decode(encoding="ascii")
-            data = data[lenname:]
-            res.append({"name":name, "size":appsize})
-        return res
-
-    def disconnect(self):
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_BAUDRATE, 1152, self.webusb_esp32.bInterfaceNumber)
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_MODE, 0x0000, self.webusb_esp32.bInterfaceNumber)
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_STATE, 0x0000, self.webusb_esp32.bInterfaceNumber)
-
-
-    def reset(self):
-        self.device.ctrl_transfer(self.REQUEST_TYPE_CLASS_TO_INTERFACE, self.REQUEST_RESET, 0x0000, self.webusb_esp32.bInterfaceNumber)
+    def nvs_type_to_name(self, type_number):
+        if type_number == 0x01:
+            return "u8"
+        if type_number == 0x11:
+            return "i8"
+        if type_number == 0x02:
+            return "u16"
+        if type_number == 0x12:
+            return "i16"
+        if type_number == 0x04:
+            return "u32"
+        if type_number == 0x14:
+            return "i32"
+        if type_number == 0x08:
+            return "u64"
+        if type_number == 0x18:
+            return "i64"
+        if type_number == 0x21:
+            return "string"
+        if type_number == 0x42:
+            return "blob"
+        return str(type_number)
+
+    def nvs_name_to_type(self, type_name):
+        if type_name == "u8":
+            return 0x01
+        if type_name == "i8":
+            return 0x11
+        if type_name == "u16":
+            return 0x02
+        if type_name == "i16":
+            return 0x12
+        if type_name == "u32":
+            return 0x04
+        if type_name == "i32":
+            return 0x14
+        if type_name == "u64":
+            return 0x08
+        if type_name == "i64":
+            return 0x18
+        if type_name == "string":
+            return 0x21
+        if type_name == "blob":
+            return 0x42
+        raise ValueError("Invalid type name")
+
+    def nvs_should_read(self, type_number):
+        if type_number == 0x01:
+            return True
+        if type_number == 0x11:
+            return True
+        if type_number == 0x02:
+            return True
+        if type_number == 0x12:
+            return True
+        if type_number == 0x04:
+            return True
+        if type_number == 0x14:
+            return True
+        if type_number == 0x08:
+            return True
+        if type_number == 0x18:
+            return True
+        if type_number == 0x21:
+            return True
+        return False
+
+    def reset(self, reset_esp = True):
+        self.device.ctrl_transfer(self.request_type_out, self.REQUEST_STATE, 0x0000, self.webusb_esp32.bInterfaceNumber) # Connect
+        self.device.ctrl_transfer(self.request_type_out, self.REQUEST_MODE, self.BOOT_MODE_NORMAL, self.webusb_esp32.bInterfaceNumber)
+        if reset_esp:
+            self.device.ctrl_transfer(self.request_type_out, self.REQUEST_RESET, 0x0000, self.webusb_esp32.bInterfaceNumber)
+        self.device.ctrl_transfer(self.request_type_out, self.REQUEST_BAUDRATE, 1152, self.webusb_esp32.bInterfaceNumber)
+    
+    def start_webusb(self):
+        self.device.ctrl_transfer(self.request_type_out, self.REQUEST_STATE, 0x0001, self.webusb_esp32.bInterfaceNumber) # Connect
+        current_mode = int(self.device.ctrl_transfer(self.request_type_in, self.REQUEST_MODE_GET, 0, self.webusb_esp32.bInterfaceNumber, 1)[0]) # Read WebUSB mode
+
+        if current_mode != self.BOOT_MODE_WEBUSB:
+            self.device.ctrl_transfer(self.request_type_out, self.REQUEST_MODE, self.BOOT_MODE_WEBUSB, self.webusb_esp32.bInterfaceNumber)
+            self.device.ctrl_transfer(self.request_type_out, self.REQUEST_RESET, 0x0000, self.webusb_esp32.bInterfaceNumber)
+            self.device.ctrl_transfer(self.request_type_out, self.REQUEST_BAUDRATE, 9216, self.webusb_esp32.bInterfaceNumber)
diff --git a/app/resources/plugins/MCH22BToolchain/mch22bMT.js b/app/resources/plugins/MCH22BToolchain/mch22bMT.js
index 059f51315..855f6975d 100644
--- a/app/resources/plugins/MCH22BToolchain/mch22bMT.js
+++ b/app/resources/plugins/MCH22BToolchain/mch22bMT.js
@@ -17,7 +17,7 @@ function upload(data) {
     let cstatus = -1;
 
     let uploader = hd.joinPath(env.DEFAULT_PLUGIN_DIR, 'MCH22BToolchain/mch2022-tools');
-    uploader = hd.joinPath(uploader, 'webusb_fpga.py');
+    uploader = hd.joinPath(uploader, 'fpga.py');
 
     let python = 'python3';//  hd.joinPath(env.ENV_BIN_DIR,'python3');
 
diff --git a/app/scripts/services/tools.js b/app/scripts/services/tools.js
index 696fdd988..044578035 100644
--- a/app/scripts/services/tools.js
+++ b/app/scripts/services/tools.js
@@ -137,7 +137,7 @@ angular
                 let bitstream = hd.joinPath(common.BUILD_DIR, 'hardware.bin');
 
                 let uploader = hd.joinPath(common.DEFAULT_PLUGIN_DIR, 'mch2022-tools');
-                uploader = hd.joinPath(uploader, 'webusb_fpga');
+                uploader = hd.joinPath(uploader, 'fpga');
 
                 let python = hd.joinPath(common.ENV_BIN_DIR, 'python3');