fs

File system bindings for ESP32 Provides file and directory operations including read, write, and directory listing

AssemblyScript

export enum FsError {
  Ok = 0,
  NotFound = 1,
  PermissionDenied = 2,
  InvalidArg = 3,
  IoError = 4,
  NoMemory = 5,
  Exists = 6,
  NotDir = 7,
  IsDir = 8
}

export enum DirentType {
  Unknown = 0,
  File = 1,
  Dir = 2,
  Chr = 3,
  Blk = 4,
  Fifo = 5,
  Sock = 6,
  Lnk = 7
}


// @ts-ignore
@external("fs", "fs_open")
export declare function fsOpen(path: u32, flags: u32): u32;


// @ts-ignore
@external("fs", "fs_close")
export declare function fsClose(file: u32): i32;


// @ts-ignore
@external("fs", "fs_read")
export declare function fsRead(file: u32, buffer: u32, size: u32): i32;


// @ts-ignore
@external("fs", "fs_write")
export declare function fsWrite(file: u32, buffer: u32, size: u32): i32;


// @ts-ignore
@external("fs", "fs_unlink")
export declare function fsUnlink(path: u32): i32;


// @ts-ignore
@external("fs", "fs_fseek")
export declare function fsFseek(file: u32, offset: i32, whence: i32): i32;


// @ts-ignore
@external("fs", "fs_ftell")
export declare function fsFtell(file: u32): i32;


// @ts-ignore
@external("fs", "fs_opendir")
export declare function fsOpendir(path: u32): u32;


// @ts-ignore
@external("fs", "fs_readdir")
export declare function fsReaddir(dir: u32): u32;


// @ts-ignore
@external("fs", "fs_dirent_get_name")
export declare function fsDirentGetName(dirent: u32): u32;


// @ts-ignore
@external("fs", "fs_dirent_get_type")
export declare function fsDirentGetType(dirent: u32): i32;


// @ts-ignore
@external("fs", "fs_dirent_get_ino")
export declare function fsDirentGetIno(dirent: u32): i32;


// @ts-ignore
@external("fs", "fs_closedir")
export declare function fsClosedir(dir: u32): i32;

Zig

pub const FsError = enum(u32) {
  ok = 0,
  notFound = 1,
  permissionDenied = 2,
  invalidArg = 3,
  ioError = 4,
  noMemory = 5,
  exists = 6,
  notDir = 7,
  isDir = 8
};

pub const DirentType = enum(u32) {
  unknown = 0,
  file = 1,
  dir = 2,
  chr = 3,
  blk = 4,
  fifo = 5,
  sock = 6,
  lnk = 7
};


pub extern "fs" fn fs_open(path: u32, flags: u32) u32;

pub extern "fs" fn fs_close(file: u32) i32;

pub extern "fs" fn fs_read(file: u32, buffer: u32, size: u32) i32;

pub extern "fs" fn fs_write(file: u32, buffer: u32, size: u32) i32;

pub extern "fs" fn fs_unlink(path: u32) i32;

pub extern "fs" fn fs_fseek(file: u32, offset: i32, whence: i32) i32;

pub extern "fs" fn fs_ftell(file: u32) i32;

pub extern "fs" fn fs_opendir(path: u32) u32;

pub extern "fs" fn fs_readdir(dir: u32) u32;

pub extern "fs" fn fs_dirent_get_name(dirent: u32) u32;

pub extern "fs" fn fs_dirent_get_type(dirent: u32) i32;

pub extern "fs" fn fs_dirent_get_ino(dirent: u32) i32;

pub extern "fs" fn fs_closedir(dir: u32) i32;

Rust

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum FsError {
  Ok = 0,
  NotFound = 1,
  PermissionDenied = 2,
  InvalidArg = 3,
  IoError = 4,
  NoMemory = 5,
  Exists = 6,
  NotDir = 7,
  IsDir = 8
}

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum DirentType {
  Unknown = 0,
  File = 1,
  Dir = 2,
  Chr = 3,
  Blk = 4,
  Fifo = 5,
  Sock = 6,
  Lnk = 7
}

#[link(wasm_import_module = "fs")]
extern "C" { 
  #[link_name = "fs_open"]
  fn unsafe_fs_open(path: u32, flags: u32) -> u32;

  #[link_name = "fs_close"]
  fn unsafe_fs_close(file: u32) -> i32;

  #[link_name = "fs_read"]
  fn unsafe_fs_read(file: u32, buffer: u32, size: u32) -> i32;

  #[link_name = "fs_write"]
  fn unsafe_fs_write(file: u32, buffer: u32, size: u32) -> i32;

  #[link_name = "fs_unlink"]
  fn unsafe_fs_unlink(path: u32) -> i32;

  #[link_name = "fs_fseek"]
  fn unsafe_fs_fseek(file: u32, offset: i32, whence: i32) -> i32;

  #[link_name = "fs_ftell"]
  fn unsafe_fs_ftell(file: u32) -> i32;

  #[link_name = "fs_opendir"]
  fn unsafe_fs_opendir(path: u32) -> u32;

  #[link_name = "fs_readdir"]
  fn unsafe_fs_readdir(dir: u32) -> u32;

  #[link_name = "fs_dirent_get_name"]
  fn unsafe_fs_dirent_get_name(dirent: u32) -> u32;

  #[link_name = "fs_dirent_get_type"]
  fn unsafe_fs_dirent_get_type(dirent: u32) -> i32;

  #[link_name = "fs_dirent_get_ino"]
  fn unsafe_fs_dirent_get_ino(dirent: u32) -> i32;

  #[link_name = "fs_closedir"]
  fn unsafe_fs_closedir(dir: u32) -> i32;
}

pub fn fs_open(path: u32, flags: u32) -> u32 {
  unsafe {
    return unsafe_fs_open(path, flags);
  }
}


pub fn fs_close(file: u32) -> i32 {
  unsafe {
    return unsafe_fs_close(file);
  }
}


pub fn fs_read(file: u32, buffer: u32, size: u32) -> i32 {
  unsafe {
    return unsafe_fs_read(file, buffer, size);
  }
}


pub fn fs_write(file: u32, buffer: u32, size: u32) -> i32 {
  unsafe {
    return unsafe_fs_write(file, buffer, size);
  }
}


pub fn fs_unlink(path: u32) -> i32 {
  unsafe {
    return unsafe_fs_unlink(path);
  }
}


pub fn fs_fseek(file: u32, offset: i32, whence: i32) -> i32 {
  unsafe {
    return unsafe_fs_fseek(file, offset, whence);
  }
}


pub fn fs_ftell(file: u32) -> i32 {
  unsafe {
    return unsafe_fs_ftell(file);
  }
}


pub fn fs_opendir(path: u32) -> u32 {
  unsafe {
    return unsafe_fs_opendir(path);
  }
}


pub fn fs_readdir(dir: u32) -> u32 {
  unsafe {
    return unsafe_fs_readdir(dir);
  }
}


pub fn fs_dirent_get_name(dirent: u32) -> u32 {
  unsafe {
    return unsafe_fs_dirent_get_name(dirent);
  }
}


pub fn fs_dirent_get_type(dirent: u32) -> i32 {
  unsafe {
    return unsafe_fs_dirent_get_type(dirent);
  }
}


pub fn fs_dirent_get_ino(dirent: u32) -> i32 {
  unsafe {
    return unsafe_fs_dirent_get_ino(dirent);
  }
}


pub fn fs_closedir(dir: u32) -> i32 {
  unsafe {
    return unsafe_fs_closedir(dir);
  }
}

TinyGo

package fs

type FsError uint32
const (
  Ok FsError = 0
  NotFound FsError = 1
  PermissionDenied FsError = 2
  InvalidArg FsError = 3
  IoError FsError = 4
  NoMemory FsError = 5
  Exists FsError = 6
  NotDir FsError = 7
  IsDir FsError = 8
)
type DirentType uint32
const (
  Unknown DirentType = 0
  File DirentType = 1
  Dir DirentType = 2
  Chr DirentType = 3
  Blk DirentType = 4
  Fifo DirentType = 5
  Sock DirentType = 6
  Lnk DirentType = 7
)


//go:wasmimport fs fs_open
func FsOpen(Path uint32, Flags uint32) uint32;

//go:wasmimport fs fs_close
func FsClose(File uint32) int32;

//go:wasmimport fs fs_read
func FsRead(File uint32, Buffer uint32, Size uint32) int32;

//go:wasmimport fs fs_write
func FsWrite(File uint32, Buffer uint32, Size uint32) int32;

//go:wasmimport fs fs_unlink
func FsUnlink(Path uint32) int32;

//go:wasmimport fs fs_fseek
func FsFseek(File uint32, Offset int32, Whence int32) int32;

//go:wasmimport fs fs_ftell
func FsFtell(File uint32) int32;

//go:wasmimport fs fs_opendir
func FsOpendir(Path uint32) uint32;

//go:wasmimport fs fs_readdir
func FsReaddir(Dir uint32) uint32;

//go:wasmimport fs fs_dirent_get_name
func FsDirentGetName(Dirent uint32) uint32;

//go:wasmimport fs fs_dirent_get_type
func FsDirentGetType(Dirent uint32) int32;

//go:wasmimport fs fs_dirent_get_ino
func FsDirentGetIno(Dirent uint32) int32;

//go:wasmimport fs fs_closedir
func FsClosedir(Dir uint32) int32;

C

typedef enum {
  FS_ERROR_OK,
  FS_ERROR_NOT_FOUND,
  FS_ERROR_PERMISSION_DENIED,
  FS_ERROR_INVALID_ARG,
  FS_ERROR_IO_ERROR,
  FS_ERROR_NO_MEMORY,
  FS_ERROR_EXISTS,
  FS_ERROR_NOT_DIR,
  FS_ERROR_IS_DIR
} fs_error_t;

typedef enum {
  DIRENT_TYPE_UNKNOWN,
  DIRENT_TYPE_FILE,
  DIRENT_TYPE_DIR,
  DIRENT_TYPE_CHR,
  DIRENT_TYPE_BLK,
  DIRENT_TYPE_FIFO,
  DIRENT_TYPE_SOCK,
  DIRENT_TYPE_LNK
} dirent_type_t;


__attribute__((import_module("fs")))
__attribute__((import_name("fs_open")))
extern unsigned int fs_open(unsigned int path, unsigned int flags);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_close")))
extern int fs_close(unsigned int file);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_read")))
extern int fs_read(unsigned int file, unsigned int buffer, unsigned int size);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_write")))
extern int fs_write(unsigned int file, unsigned int buffer, unsigned int size);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_unlink")))
extern int fs_unlink(unsigned int path);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_fseek")))
extern int fs_fseek(unsigned int file, int offset, int whence);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_ftell")))
extern int fs_ftell(unsigned int file);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_opendir")))
extern unsigned int fs_opendir(unsigned int path);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_readdir")))
extern unsigned int fs_readdir(unsigned int dir);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_dirent_get_name")))
extern unsigned int fs_dirent_get_name(unsigned int dirent);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_dirent_get_type")))
extern int fs_dirent_get_type(unsigned int dirent);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_dirent_get_ino")))
extern int fs_dirent_get_ino(unsigned int dirent);


__attribute__((import_module("fs")))
__attribute__((import_name("fs_closedir")))
extern int fs_closedir(unsigned int dir);

C++

typedef enum {
  FS_ERROR_OK,
  FS_ERROR_NOT_FOUND,
  FS_ERROR_PERMISSION_DENIED,
  FS_ERROR_INVALID_ARG,
  FS_ERROR_IO_ERROR,
  FS_ERROR_NO_MEMORY,
  FS_ERROR_EXISTS,
  FS_ERROR_NOT_DIR,
  FS_ERROR_IS_DIR
} fs_error_t;

typedef enum {
  DIRENT_TYPE_UNKNOWN,
  DIRENT_TYPE_FILE,
  DIRENT_TYPE_DIR,
  DIRENT_TYPE_CHR,
  DIRENT_TYPE_BLK,
  DIRENT_TYPE_FIFO,
  DIRENT_TYPE_SOCK,
  DIRENT_TYPE_LNK
} dirent_type_t;

extern "C" {
  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_open")))
  extern unsigned int fs_open(unsigned int path, unsigned int flags);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_close")))
  extern int fs_close(unsigned int file);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_read")))
  extern int fs_read(unsigned int file, unsigned int buffer, unsigned int size);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_write")))
  extern int fs_write(unsigned int file, unsigned int buffer, unsigned int size);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_unlink")))
  extern int fs_unlink(unsigned int path);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_fseek")))
  extern int fs_fseek(unsigned int file, int offset, int whence);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_ftell")))
  extern int fs_ftell(unsigned int file);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_opendir")))
  extern unsigned int fs_opendir(unsigned int path);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_readdir")))
  extern unsigned int fs_readdir(unsigned int dir);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_dirent_get_name")))
  extern unsigned int fs_dirent_get_name(unsigned int dirent);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_dirent_get_type")))
  extern int fs_dirent_get_type(unsigned int dirent);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_dirent_get_ino")))
  extern int fs_dirent_get_ino(unsigned int dirent);

  __attribute__((import_module("fs")))
  __attribute__((import_name("fs_closedir")))
  extern int fs_closedir(unsigned int dir);
}