Run the script from the flash using file system?

[synapticonashaikh]

Hi all, I'm working on a project where I've taken the minimal port and updated the HAL layer concerning the processor (XMOS XCORE) I'm working on. The processor interfaced with an external SPI flash which we are using for a storage system. All the FileSystem APIs, like Fopen, Fread, and Fwrite, are available. Right now, I'm reading the script from the storage system, copying it into an array and then passing it to the Python executor to execute it. This process consumes an extra large buffer, which is highly unsuitable as we shall be reaching close to the maximum capacity.
Hence, I like to know, instead of reading the script from the file system manually, if there is already a developed API available. And I can link it to the filesystem APIs.

Current code overview:
I have disabled the compiler (MICROPY_ENABLE_COMPILER). And I'm running a ".mpy" file.

#if MICROPY_ENABLE_GC
    static char heap[_STATIC_HEAP_SIZE];
#endif
void FnRunTheCommand(char *ByteCode, uint32_t CodeLen)
{
    #if MICROPY_ENABLE_GC
        gc_init(heap, heap + sizeof(heap));
    #endif
    /*init the mp stack*/
    mp_init( );

    mp_reader_t reader;
    mp_reader_new_mem(&reader,(byte *)ByteCode, CodeLen, 0);
    mp_module_context_t *context = m_new_obj(mp_module_context_t);
    context->module.globals = mp_globals_get();
    mp_compiled_module_t compiled_module;
    compiled_module.context = context;
    mp_raw_code_load(&reader, &compiled_module);
    mp_obj_t module_fun = mp_make_function_from_raw_code(compiled_module.rc, context, NULL);
    mp_call_function_0(module_fun);

    /*deinit*/
    mp_deinit( );    
}

Calling the filesystem APIs to read the script from storage.

void FnRunTheSCript(void)
{
    char FileName []= "UserScript.mpy", RXcommand[1000];
    memset(RXcommand,'\0',  sizeof(RXcommand));            
    int fileD = i_filesystem.open_file (FileName ,strlen(FileName) ,SPIFFS_O_RDONLY);
    int FileS = i_filesystem.get_file_size(fileD);
    int fileR = i_filesystem.read(fileD,RXcommand,FileS);
    int fileC = i_filesystem.close_file(fileD);
    FnRunTheCommand(RXcommand,FileS);    
}

[cwalther]

I am planning to do the same thing on the embed port for the Playdate filesystem at some point, but haven’t started writing any code yet, so this is mostly speculation.

You should be able to write a MicroPython filesystem driver that delegates to your i_filesystem.open_file etc. API by starting from vfs_posix.c, which does the same thing for the POSIX file API.

If you don’t insist on using SPIFFS, you could also write a block device driver for your flash and use the built-in LittleFS or FAT drivers on it.

I’m not sure if there is any way around copying the mpy file to RAM however, if your flash is not memory-mapped. If you’re not doing it explicitly, it probably just happens internally.

[dlech]

I’m not sure if there is any way around copying the mpy file to RAM however

Not yet, but work in progress: #8381

[cwalther]

But that only works for addressable (memory-mapped) flash, right?

[dlech]

correct