implement USB MSC, add FatFs library for debug mass storage functionality.

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "firmware/pico-sdk"]
 	path = firmware/pico-sdk
 	url = https://github.com/raspberrypi/pico-sdk
+[submodule "firmware/fatfs"]
+	path = firmware/fatfs
+	url = https://github.com/abbrev/fatfs

firmware/CMakeLists.txt

@@ -9,6 +9,28 @@ project(trackball)
 # initialize the Raspberry Pi Pico SDK
 pico_sdk_init()
 
+# copy FatFS source files to build dir, so we can use our own ffconf.h
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/fatfs/source/ff.c
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
+    COPYONLY
+)
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/fatfs/source/ff.h
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.h
+    COPYONLY
+)
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/fatfs/source/diskio.h
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs/diskio.h
+    COPYONLY
+)
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/fatfs/source/ffunicode.c
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c
+    COPYONLY
+)
+
 add_executable(trackball)
 
 target_sources(trackball PUBLIC
@@ -21,11 +43,19 @@ target_sources(trackball PUBLIC
     src/usb_cdc.c
     src/usb_descriptors.c
     src/usb_hid.c
+    src/usb_msc.c
+    src/fat_disk.c
+    src/debug.c
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c
 )
 
 # Make sure TinyUSB can find tusb_config.h
 target_include_directories(trackball PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
 
+# Make sure FatFS can find ffconf.h
+target_include_directories(trackball PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/fatfs)
+
 target_compile_options(trackball PUBLIC
     -Wall
     -Werror

firmware/fatfs

@@ -0,0 +1 @@
+Subproject commit 010b83715f3896827af14b811c77cc1d2edee8c5

firmware/include/debug.h

@@ -0,0 +1,14 @@
+/*
+ * debug.h
+ */
+
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+int debug_msc_mount(void);
+int debug_msc_unmount(void);
+
+void debug_msc_stats(void);
+void debug_msc_pmw3360(void);
+
+#endif // __DEBUG_H__

firmware/include/fat_disk.h

@@ -0,0 +1,10 @@
+/* 
+ * fat_disk.h
+ */
+
+#define DISK_BLOCK_COUNT 256
+#define DISK_BLOCK_SIZE 512
+
+void fat_disk_init(void);
+
+uint8_t *fat_disk_get_sector(uint32_t sector);

firmware/include/ffconf.h

@@ -0,0 +1,296 @@
+/*---------------------------------------------------------------------------/
+/  Configurations of FatFs Module
+/---------------------------------------------------------------------------*/
+
+#define FFCONF_DEF	80286	/* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_READONLY	0
+/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
+/  Read-only configuration removes writing API functions, f_write(), f_sync(),
+/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
+/  and optional writing functions as well. */
+
+
+#define FF_FS_MINIMIZE	0
+/* This option defines minimization level to remove some basic API functions.
+/
+/   0: Basic functions are fully enabled.
+/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
+/      are removed.
+/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
+/   3: f_lseek() function is removed in addition to 2. */
+
+
+#define FF_USE_FIND		0
+/* This option switches filtered directory read functions, f_findfirst() and
+/  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
+
+
+#define FF_USE_MKFS		1
+/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FASTSEEK	0
+/* This option switches fast seek function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_EXPAND	0
+/* This option switches f_expand function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_CHMOD	0
+/* This option switches attribute manipulation functions, f_chmod() and f_utime().
+/  (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */
+
+
+#define FF_USE_LABEL	1
+/* This option switches volume label functions, f_getlabel() and f_setlabel().
+/  (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FORWARD	0
+/* This option switches f_forward() function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_STRFUNC	0
+#define FF_PRINT_LLI	1
+#define FF_PRINT_FLOAT	1
+#define FF_STRF_ENCODE	3
+/* FF_USE_STRFUNC switches string functions, f_gets(), f_putc(), f_puts() and
+/  f_printf().
+/
+/   0: Disable. FF_PRINT_LLI, FF_PRINT_FLOAT and FF_STRF_ENCODE have no effect.
+/   1: Enable without LF-CRLF conversion.
+/   2: Enable with LF-CRLF conversion.
+/
+/  FF_PRINT_LLI = 1 makes f_printf() support long long argument and FF_PRINT_FLOAT = 1/2
+/  makes f_printf() support floating point argument. These features want C99 or later.
+/  When FF_LFN_UNICODE >= 1 with LFN enabled, string functions convert the character
+/  encoding in it. FF_STRF_ENCODE selects assumption of character encoding ON THE FILE
+/  to be read/written via those functions.
+/
+/   0: ANSI/OEM in current CP
+/   1: Unicode in UTF-16LE
+/   2: Unicode in UTF-16BE
+/   3: Unicode in UTF-8
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_CODE_PAGE	850
+/* This option specifies the OEM code page to be used on the target system.
+/  Incorrect code page setting can cause a file open failure.
+/
+/   437 - U.S.
+/   720 - Arabic
+/   737 - Greek
+/   771 - KBL
+/   775 - Baltic
+/   850 - Latin 1
+/   852 - Latin 2
+/   855 - Cyrillic
+/   857 - Turkish
+/   860 - Portuguese
+/   861 - Icelandic
+/   862 - Hebrew
+/   863 - Canadian French
+/   864 - Arabic
+/   865 - Nordic
+/   866 - Russian
+/   869 - Greek 2
+/   932 - Japanese (DBCS)
+/   936 - Simplified Chinese (DBCS)
+/   949 - Korean (DBCS)
+/   950 - Traditional Chinese (DBCS)
+/     0 - Include all code pages above and configured by f_setcp()
+*/
+
+
+#define FF_USE_LFN		3
+#define FF_MAX_LFN		255
+/* The FF_USE_LFN switches the support for LFN (long file name).
+/
+/   0: Disable LFN. FF_MAX_LFN has no effect.
+/   1: Enable LFN with static  working buffer on the BSS. Always NOT thread-safe.
+/   2: Enable LFN with dynamic working buffer on the STACK.
+/   3: Enable LFN with dynamic working buffer on the HEAP.
+/
+/  To enable the LFN, ffunicode.c needs to be added to the project. The LFN function
+/  requiers certain internal working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
+/  additional (FF_MAX_LFN + 44) / 15 * 32 bytes when exFAT is enabled.
+/  The FF_MAX_LFN defines size of the working buffer in UTF-16 code unit and it can
+/  be in range of 12 to 255. It is recommended to be set it 255 to fully support LFN
+/  specification.
+/  When use stack for the working buffer, take care on stack overflow. When use heap
+/  memory for the working buffer, memory management functions, ff_memalloc() and
+/  ff_memfree() exemplified in ffsystem.c, need to be added to the project. */
+
+
+#define FF_LFN_UNICODE	2
+/* This option switches the character encoding on the API when LFN is enabled.
+/
+/   0: ANSI/OEM in current CP (TCHAR = char)
+/   1: Unicode in UTF-16 (TCHAR = WCHAR)
+/   2: Unicode in UTF-8 (TCHAR = char)
+/   3: Unicode in UTF-32 (TCHAR = DWORD)
+/
+/  Also behavior of string I/O functions will be affected by this option.
+/  When LFN is not enabled, this option has no effect. */
+
+
+#define FF_LFN_BUF		255
+#define FF_SFN_BUF		12
+/* This set of options defines size of file name members in the FILINFO structure
+/  which is used to read out directory items. These values should be suffcient for
+/  the file names to read. The maximum possible length of the read file name depends
+/  on character encoding. When LFN is not enabled, these options have no effect. */
+
+
+#define FF_FS_RPATH		0
+/* This option configures support for relative path.
+/
+/   0: Disable relative path and remove related functions.
+/   1: Enable relative path. f_chdir() and f_chdrive() are available.
+/   2: f_getcwd() function is available in addition to 1.
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ Drive/Volume Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_VOLUMES		1
+/* Number of volumes (logical drives) to be used. (1-10) */
+
+
+#define FF_STR_VOLUME_ID	0
+#define FF_VOLUME_STRS		"RAM","NAND","CF","SD","SD2","USB","USB2","USB3"
+/* FF_STR_VOLUME_ID switches support for volume ID in arbitrary strings.
+/  When FF_STR_VOLUME_ID is set to 1 or 2, arbitrary strings can be used as drive
+/  number in the path name. FF_VOLUME_STRS defines the volume ID strings for each
+/  logical drives. Number of items must not be less than FF_VOLUMES. Valid
+/  characters for the volume ID strings are A-Z, a-z and 0-9, however, they are
+/  compared in case-insensitive. If FF_STR_VOLUME_ID >= 1 and FF_VOLUME_STRS is
+/  not defined, a user defined volume string table is needed as:
+/
+/  const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
+*/
+
+
+#define FF_MULTI_PARTITION	0
+/* This option switches support for multiple volumes on the physical drive.
+/  By default (0), each logical drive number is bound to the same physical drive
+/  number and only an FAT volume found on the physical drive will be mounted.
+/  When this function is enabled (1), each logical drive number can be bound to
+/  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
+/  function will be available. */
+
+
+#define FF_MIN_SS		512
+#define FF_MAX_SS		512
+/* This set of options configures the range of sector size to be supported. (512,
+/  1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
+/  harddisk, but a larger value may be required for on-board flash memory and some
+/  type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
+/  for variable sector size mode and disk_ioctl() function needs to implement
+/  GET_SECTOR_SIZE command. */
+
+
+#define FF_LBA64		0
+/* This option switches support for 64-bit LBA. (0:Disable or 1:Enable)
+/  To enable the 64-bit LBA, also exFAT needs to be enabled. (FF_FS_EXFAT == 1) */
+
+
+#define FF_MIN_GPT		0x10000000
+/* Minimum number of sectors to switch GPT as partitioning format in f_mkfs and
+/  f_fdisk function. 0x100000000 max. This option has no effect when FF_LBA64 == 0. */
+
+
+#define FF_USE_TRIM		0
+/* This option switches support for ATA-TRIM. (0:Disable or 1:Enable)
+/  To enable Trim function, also CTRL_TRIM command should be implemented to the
+/  disk_ioctl() function. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_TINY		0
+/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
+/  At the tiny configuration, size of file object (FIL) is shrinked FF_MAX_SS bytes.
+/  Instead of private sector buffer eliminated from the file object, common sector
+/  buffer in the filesystem object (FATFS) is used for the file data transfer. */
+
+
+#define FF_FS_EXFAT		0
+/* This option switches support for exFAT filesystem. (0:Disable or 1:Enable)
+/  To enable exFAT, also LFN needs to be enabled. (FF_USE_LFN >= 1)
+/  Note that enabling exFAT discards ANSI C (C89) compatibility. */
+
+
+#define FF_FS_NORTC		1
+#define FF_NORTC_MON	1
+#define FF_NORTC_MDAY	1
+#define FF_NORTC_YEAR	2022
+/* The option FF_FS_NORTC switches timestamp feature. If the system does not have
+/  an RTC or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable the
+/  timestamp feature. Every object modified by FatFs will have a fixed timestamp
+/  defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
+/  To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
+/  added to the project to read current time form real-time clock. FF_NORTC_MON,
+/  FF_NORTC_MDAY and FF_NORTC_YEAR have no effect.
+/  These options have no effect in read-only configuration (FF_FS_READONLY = 1). */
+
+
+#define FF_FS_NOFSINFO	0
+/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
+/  option, and f_getfree() function at the first time after volume mount will force
+/  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
+/
+/  bit0=0: Use free cluster count in the FSINFO if available.
+/  bit0=1: Do not trust free cluster count in the FSINFO.
+/  bit1=0: Use last allocated cluster number in the FSINFO if available.
+/  bit1=1: Do not trust last allocated cluster number in the FSINFO.
+*/
+
+
+#define FF_FS_LOCK		0
+/* The option FF_FS_LOCK switches file lock function to control duplicated file open
+/  and illegal operation to open objects. This option must be 0 when FF_FS_READONLY
+/  is 1.
+/
+/  0:  Disable file lock function. To avoid volume corruption, application program
+/      should avoid illegal open, remove and rename to the open objects.
+/  >0: Enable file lock function. The value defines how many files/sub-directories
+/      can be opened simultaneously under file lock control. Note that the file
+/      lock control is independent of re-entrancy. */
+
+
+#define FF_FS_REENTRANT	0
+#define FF_FS_TIMEOUT	1000
+/* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
+/  module itself. Note that regardless of this option, file access to different
+/  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
+/  and f_fdisk() function, are always not re-entrant. Only file/directory access
+/  to the same volume is under control of this featuer.
+/
+/   0: Disable re-entrancy. FF_FS_TIMEOUT have no effect.
+/   1: Enable re-entrancy. Also user provided synchronization handlers,
+/      ff_mutex_create(), ff_mutex_delete(), ff_mutex_take() and ff_mutex_give()
+/      function, must be added to the project. Samples are available in ffsystem.c.
+/
+/  The FF_FS_TIMEOUT defines timeout period in unit of O/S time tick.
+*/
+
+
+
+/*--- End of configuration options ---*/

firmware/include/log.h

@@ -18,6 +18,8 @@
 #define println(fmt, ...) debug_log(false, fmt "\r\n", ##__VA_ARGS__)
 
 void debug_log(bool log, const char *format, ...) __attribute__((format(printf, 2, 3)));
+
 void log_dump_to_usb(void);
+void log_dump_to_disk(void);
 
 #endif // __LOG_H__

firmware/include/pmw3360.h

@@ -33,8 +33,8 @@ uint8_t pmw_get_sensitivity(void);
 #define PMW_SENSE_TO_CPI(sense) (100 + (sense * 100))
 #define PMW_CPI_TO_SENSE(cpi) ((cpi / 100) - 1)
 
-void pmw_print_status(void);
-void pmw_dump_data(void);
+void pmw_print_status(char *buff, size_t len);
+void pmw_dump_data(bool serial);
 
 ssize_t pmw_frame_capture(uint8_t *buff, size_t buffsize);
 #define PMW_FRAME_CAPTURE_LEN 1296

firmware/include/tusb_config.h

@@ -97,7 +97,7 @@
 //------------- CLASS -------------//
 #define CFG_TUD_HID               1
 #define CFG_TUD_CDC               1
-#define CFG_TUD_MSC               0
+#define CFG_TUD_MSC               1
 #define CFG_TUD_MIDI              0
 #define CFG_TUD_VENDOR            0
 
@@ -111,6 +111,9 @@
 // CDC Endpoint transfer buffer size, more is faster
 #define CFG_TUD_CDC_EP_BUFSIZE   (TUD_OPT_HIGH_SPEED ? 512 : 64)
 
+// MSC Buffer size of Device Mass storage
+#define CFG_TUD_MSC_EP_BUFSIZE   512
+
 #ifdef __cplusplus
  }
 #endif

firmware/include/usb_msc.h

@@ -0,0 +1,11 @@
+/*
+ * usb_msc.h
+ */
+
+#ifndef __USB_MSC_H__
+#define __USB_MSC_H__
+
+bool msc_is_medium_available(void);
+void msc_set_medium_available(bool state);
+
+#endif // __USB_MSC_H__

firmware/src/console.c

@@ -10,6 +10,8 @@
 #include "log.h"
 #include "pmw3360.h"
 #include "util.h"
+#include "usb_msc.h"
+#include "debug.h"
 #include "console.h"
 
 #define CNSL_BUFF_SIZE 1024
@@ -59,13 +61,18 @@ static void cnsl_interpret(const char *line) {
         println("   \\x18 - reset to bootloader");
         println(" repeat - repeat last command every %d milliseconds", CNSL_REPEAT_MS);
         println("   help - print this message");
+        println("  stats - put statistics on mass storage medium");
+        println("   data - put PMW3360 data on mass storage medium");
+        println("  mount - make mass storage medium (un)available");
         println("Press Enter with no input to repeat last command.");
         println("Use repeat to continuously execute last command.");
         println("Stop this by calling repeat again.");
     } else if (strcmp(line, "pmws") == 0) {
-        pmw_print_status();
+        char status_buff[1024];
+        pmw_print_status(status_buff, sizeof(status_buff));
+        print("%s", status_buff);
     } else if (strcmp(line, "pmwd") == 0) {
-        pmw_dump_data();
+        pmw_dump_data(true);
     } else if (strcmp(line, "pmwf") == 0) {
         uint8_t frame[PMW_FRAME_CAPTURE_LEN];
         ssize_t r = pmw_frame_capture(frame, PMW_FRAME_CAPTURE_LEN);
@@ -102,9 +109,40 @@ static void cnsl_interpret(const char *line) {
         }
     } else if (strcmp(line, "reset") == 0) {
         reset_to_main();
+    } else if ((strcmp(line, "stats") == 0) || (strcmp(line, "data") == 0)) {
+        if (msc_is_medium_available()) {
+            println("Currently mounted. Unplugging now.");
+            msc_set_medium_available(false);
+        }
+
+        if (debug_msc_mount() != 0) {
+            println("Error mounting file system.");
+            println();
+            return;
+        }
+
+        println("Writing data to file system");
+
+        if (strcmp(line, "data") == 0) {
+            debug_msc_pmw3360();
+        }
+
+        debug_msc_stats();
+
+        if (debug_msc_unmount() != 0) {
+            println("Error unmounting file system.");
+        }
+
+        println("Done. Plugging in now.");
+        msc_set_medium_available(true);
+    } else if (strcmp(line, "mount") == 0) {
+        bool state = msc_is_medium_available();
+        println("Currently %s. %s now.",
+                state ? "mounted" : "unmounted",
+                state ? "Unplugging" : "Plugging in");
+        msc_set_medium_available(!state);
     } else {
         println("unknown command \"%s\"", line);
-        return;
     }
 
     println();

firmware/src/debug.c

@@ -0,0 +1,108 @@
+/*
+ * debug.c
+ */
+
+#include <string.h>
+#include "pico/stdlib.h"
+#include "ff.h"
+
+#include "config.h"
+#include "log.h"
+#include "pmw3360.h"
+#include "debug.h"
+
+static FATFS fs;
+static bool mounted = false;
+
+int debug_msc_mount(void) {
+    if (mounted) {
+        debug("already mounted");
+        return 0;
+    }
+
+    FRESULT res = f_mount(&fs, "", 0);
+    if (res != FR_OK) {
+        debug("error: f_mount returned %d", res);
+        mounted = false;
+        return -1;
+    }
+
+    mounted = true;
+    return 0;
+}
+
+int debug_msc_unmount(void) {
+    if (!mounted) {
+        debug("already unmounted");
+        return 0;
+    }
+
+    FRESULT res = f_mount(0, "", 0);
+    if (res != FR_OK) {
+        debug("error: f_mount returned %d", res);
+        return -1;
+    }
+
+    mounted = false;
+    return 0;
+}
+
+static void debug_msc_pmw_stats(void) {
+    FIL file;
+    FRESULT res = f_open(&file, "pmw_stats.txt", FA_CREATE_ALWAYS | FA_WRITE);
+    if (res != FR_OK) {
+        debug("error: f_open returned %d", res);
+        return;
+    }
+
+    char status_buff[1024];
+    pmw_print_status(status_buff, sizeof(status_buff));
+    size_t len = strlen(status_buff);
+
+    UINT bw;
+    res = f_write(&file, status_buff, len, &bw);
+    if ((res != FR_OK) || (bw != len)) {
+        debug("error: f_write returned %d", res);
+    }
+
+    res = f_close(&file);
+    if (res != FR_OK) {
+        debug("error: f_close returned %d", res);
+    }
+}
+
+void debug_msc_stats(void) {
+    debug_msc_pmw_stats();
+    log_dump_to_disk();
+}
+
+static void debug_msc_pmw3360_frame(void) {
+    FIL file;
+    FRESULT res = f_open(&file, "pmw_frame.bin", FA_CREATE_ALWAYS | FA_WRITE);
+    if (res != FR_OK) {
+        debug("error: f_open returned %d", res);
+        return;
+    }
+
+    uint8_t frame[PMW_FRAME_CAPTURE_LEN];
+    ssize_t r = pmw_frame_capture(frame, PMW_FRAME_CAPTURE_LEN);
+    if (r != PMW_FRAME_CAPTURE_LEN) {
+        debug("error: pmw_frame_capture %d != %d", r, PMW_FRAME_CAPTURE_LEN);
+    } else {
+        UINT bw;
+        res = f_write(&file, frame, r, &bw);
+        if ((res != FR_OK) || (bw != r)) {
+            debug("error: f_write returned %d", res);
+        }
+    }
+
+    res = f_close(&file);
+    if (res != FR_OK) {
+        debug("error: f_close returned %d", res);
+    }
+}
+
+void debug_msc_pmw3360(void) {
+    pmw_dump_data(false);
+    debug_msc_pmw3360_frame();
+}

firmware/src/fat_disk.c

@@ -0,0 +1,116 @@
+/* 
+ * fat_disk.c
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "pico/stdlib.h"
+#include "ff.h"
+#include "diskio.h"
+
+#include "config.h"
+#include "log.h"
+#include "fat_disk.h"
+
+static uint8_t disk[DISK_BLOCK_COUNT * DISK_BLOCK_SIZE];
+
+void fat_disk_init(void) {
+    BYTE work[FF_MAX_SS];
+    FRESULT res = f_mkfs("", 0, work, sizeof(work));
+    if (res != FR_OK) {
+        debug("error: f_mkfs returned %d", res);
+        return;
+    }
+}
+
+uint8_t *fat_disk_get_sector(uint32_t sector) {
+    return disk + (sector * DISK_BLOCK_SIZE);
+}
+
+/*
+ * FatFS ffsystem.c
+ */
+
+void* ff_memalloc(UINT msize) {
+    return malloc((size_t)msize);
+}
+
+void ff_memfree(void* mblock) {
+    free(mblock);
+}
+
+/*
+ * FatFS diskio.c
+ */
+
+DSTATUS disk_status(BYTE pdrv) {
+    if (pdrv != 0) {
+        debug("invalid drive number %d", pdrv);
+        return STA_NODISK;
+    }
+
+    return 0;
+}
+
+DSTATUS disk_initialize(BYTE pdrv) {
+    if (pdrv != 0) {
+        debug("invalid drive number %d", pdrv);
+        return STA_NODISK;
+    }
+
+    return 0;
+}
+
+DRESULT disk_read(BYTE pdrv, BYTE *buff, LBA_t sector, UINT count) {
+    if (pdrv != 0) {
+        debug("invalid drive number %d", pdrv);
+        return RES_PARERR;
+    }
+
+    if ((sector + count) > DISK_BLOCK_COUNT) {
+        debug("invalid read ((%lu + %u) > %u)", sector, count, DISK_BLOCK_COUNT);
+        return RES_ERROR;
+    }
+
+    memcpy(buff, disk + (sector * DISK_BLOCK_SIZE), count * DISK_BLOCK_SIZE);
+    return RES_OK;
+}
+
+DRESULT disk_write(BYTE pdrv, const BYTE *buff, LBA_t sector, UINT count) {
+    if (pdrv != 0) {
+        debug("invalid drive number %d", pdrv);
+        return RES_PARERR;
+    }
+
+    if ((sector + count) > DISK_BLOCK_COUNT) {
+        debug("invalid read ((%lu + %u) > %u)", sector, count, DISK_BLOCK_COUNT);
+        return RES_ERROR;
+    }
+
+    memcpy(disk + (sector * DISK_BLOCK_SIZE), buff, count * DISK_BLOCK_SIZE);
+    return RES_OK;
+}
+
+DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff) {
+    if (pdrv != 0) {
+        debug("invalid drive number %d", pdrv);
+        return RES_PARERR;
+    }
+
+    switch (cmd) {
+        case GET_SECTOR_COUNT:
+            *((LBA_t *)buff) = DISK_BLOCK_COUNT;
+            break;
+
+        case GET_SECTOR_SIZE:
+            *((WORD *)buff) = DISK_BLOCK_SIZE;
+            break;
+
+        case GET_BLOCK_SIZE:
+            *((DWORD *)buff) = 1; // non flash memory media
+            break;
+    }
+
+    return RES_OK;
+}

firmware/src/log.c

@@ -5,6 +5,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include "pico/stdlib.h"
+#include "ff.h"
 
 #include "config.h"
 #include "usb_cdc.h"
@@ -54,6 +55,39 @@ void log_dump_to_usb(void) {
     }
 }
 
+void log_dump_to_disk(void) {
+    FIL file;
+    FRESULT res = f_open(&file, "log.txt", FA_CREATE_ALWAYS | FA_WRITE);
+    if (res != FR_OK) {
+        debug("error: f_open returned %d", res);
+        return;
+    }
+
+    UINT bw;
+
+    if (head > tail) {
+        res = f_write(&file, log_buff + tail, head - tail, &bw);
+        if ((res != FR_OK) || (bw != head - tail)) {
+            debug("error: f_write (A) returned %d", res);
+        }
+    } else if (head < tail) {
+        res = f_write(&file, log_buff + tail, sizeof(log_buff) - tail, &bw);
+        if ((res != FR_OK) || (bw != sizeof(log_buff) - tail)) {
+            debug("error: f_write (B) returned %d", res);
+        } else {
+            res = f_write(&file, log_buff, head, &bw);
+            if ((res != FR_OK) || (bw != head)) {
+                debug("error: f_write (C) returned %d", res);
+            }
+        }
+    }
+
+    res = f_close(&file);
+    if (res != FR_OK) {
+        debug("error: f_close returned %d", res);
+    }
+}
+
 static int format_debug_log(char *buff, size_t len, const char *format, va_list args) {
     int l = vsnprintf(buff, len, format, args);
 

firmware/src/main.c

@@ -11,6 +11,7 @@
 #include "log.h"
 #include "usb.h"
 #include "pmw3360.h"
+#include "fat_disk.h"
 
 int main(void) {
     heartbeat_init();
@@ -22,6 +23,10 @@ int main(void) {
         debug("reset by watchdog");
     }
 
+    debug("fat_disk_init");
+    fat_disk_init();
+
+    debug("pmw_init");
     if (pmw_init() != 0) {
         debug("error initializing PMW3360");
     }

firmware/src/pmw3360.c

@@ -17,10 +17,12 @@
  * The Pico GPIO (and therefore SPI) cannot be used at 5v.
  */
 
+#include <stdio.h>
 #include "pico/stdlib.h"
 #include "pico/binary_info.h"
 #include "hardware/spi.h"
 #include "hardware/watchdog.h"
+#include "ff.h"
 
 #include "config.h"
 #include "log.h"
@@ -51,25 +53,27 @@ static uint64_t pmw_irq_count_rest2 = 0;
 static uint64_t pmw_irq_count_rest3 = 0;
 #endif // PMW_IRQ_COUNTERS
 
-void pmw_print_status(void) {
+void pmw_print_status(char *buff, size_t len) {
+    size_t pos = 0;
+
     bool com = pmw_is_alive();
     if (com) {
-        println("Communication to PMW3360 is working");
+        pos += snprintf(buff + pos, len - pos, "Communication to PMW3360 is working\r\n");
     } else {
-        println("ERROR: can not communicate to PMW3360");
+        pos += snprintf(buff + pos, len - pos, "ERROR: can not communicate to PMW3360\r\n");
     }
 
 #ifdef PMW_IRQ_COUNTERS
-    println("Interrupt statistics:");
-    println("    pmw_irq_cnt_all = %llu", pmw_irq_count_all);
-    println(" pmw_irq_cnt_motion = %llu", pmw_irq_count_motion);
-    println("pmw_irq_cnt_no_move = %llu", pmw_irq_count_no_motion);
-    println("pmw_irq_cnt_surface = %llu", pmw_irq_count_on_surface);
-    println(" pmw_irq_cnt_lifted = %llu", pmw_irq_count_lifted);
-    println("    pmw_irq_cnt_run = %llu", pmw_irq_count_run);
-    println("  pmw_irq_cnt_rest1 = %llu", pmw_irq_count_rest1);
-    println("  pmw_irq_cnt_rest2 = %llu", pmw_irq_count_rest2);
-    println("  pmw_irq_cnt_rest3 = %llu", pmw_irq_count_rest3);
+    pos += snprintf(buff + pos, len - pos, "Interrupt statistics:\r\n");
+    pos += snprintf(buff + pos, len - pos, "    pmw_irq_cnt_all = %llu\r\n", pmw_irq_count_all);
+    pos += snprintf(buff + pos, len - pos, " pmw_irq_cnt_motion = %llu\r\n", pmw_irq_count_motion);
+    pos += snprintf(buff + pos, len - pos, "pmw_irq_cnt_no_move = %llu\r\n", pmw_irq_count_no_motion);
+    pos += snprintf(buff + pos, len - pos, "pmw_irq_cnt_surface = %llu\r\n", pmw_irq_count_on_surface);
+    pos += snprintf(buff + pos, len - pos, " pmw_irq_cnt_lifted = %llu\r\n", pmw_irq_count_lifted);
+    pos += snprintf(buff + pos, len - pos, "    pmw_irq_cnt_run = %llu\r\n", pmw_irq_count_run);
+    pos += snprintf(buff + pos, len - pos, "  pmw_irq_cnt_rest1 = %llu\r\n", pmw_irq_count_rest1);
+    pos += snprintf(buff + pos, len - pos, "  pmw_irq_cnt_rest2 = %llu\r\n", pmw_irq_count_rest2);
+    pos += snprintf(buff + pos, len - pos, "  pmw_irq_cnt_rest3 = %llu\r\n", pmw_irq_count_rest3);
 #endif // PMW_IRQ_COUNTERS
 }
 
@@ -384,9 +388,29 @@ ssize_t pmw_frame_capture(uint8_t *buff, size_t buffsize) {
     return PMW_FRAME_CAPTURE_LEN;
 }
 
-#define PMW_DATA_DUMP_SAMPLES 5000
+#define PMW_DATA_DUMP_SAMPLES 1000
+
+#define PRINTRAW(fmt, ...) {                             \
+    if (serial) {                                        \
+        print(fmt, ##__VA_ARGS__);                       \
+    } else {                                             \
+        int n = snprintf(line, 100, fmt, ##__VA_ARGS__); \
+        UINT bw;                                         \
+        f_write(&file, line, n, &bw);                    \
+    }                                                    \
+}
+
+void pmw_dump_data(bool serial) {
+    char line[100];
+    FIL file;
+    if (!serial) {
+        FRESULT res = f_open(&file, "pmw_data.csv", FA_CREATE_ALWAYS | FA_WRITE);
+        if (res != FR_OK) {
+            debug("error: f_open returned %d", res);
+            return;
+        }
+    }
 
-void pmw_dump_data(void) {
     struct pmw_motion_report buff[PMW_DATA_DUMP_SAMPLES];
 
     println("Will now capture %u data samples from PMW3360", PMW_DATA_DUMP_SAMPLES);
@@ -403,8 +427,14 @@ void pmw_dump_data(void) {
         buff[i] = pmw_motion_read();
     }
 
-    println();
-    println("time,motion,observation,delta_x,delta_y,squal,raw_sum,raw_max,raw_min,shutter");
+    if (serial) {
+        println();
+    } else {
+        println("Now writing data");
+    }
+
+    PRINTRAW("time,motion,observation,delta_x,delta_y,squal,raw_sum,raw_max,raw_min,shutter\r\n");
+
     for (size_t i = 0; i < PMW_DATA_DUMP_SAMPLES; i++) {
         watchdog_update();
 
@@ -412,20 +442,30 @@ void pmw_dump_data(void) {
         uint16_t delta_y_raw = buff[i].delta_y_l | (buff[i].delta_y_h << 8);
         uint16_t shutter_raw = buff[i].shutter_lower | (buff[i].shutter_upper << 8);
 
-        print("%llu,", to_us_since_boot(get_absolute_time()));
-        print("%u,", buff[i].motion);
-        print("%u,", buff[i].observation);
-        print("%ld,", convert_two_complement(delta_x_raw));
-        print("%ld,", convert_two_complement(delta_y_raw));
-        print("%u,", buff[i].squal);
-        print("%u,", buff[i].raw_data_sum);
-        print("%u,", buff[i].maximum_raw_data);
-        print("%u,", buff[i].minimum_raw_data);
-        println("%u", shutter_raw);
+        PRINTRAW("%llu,", to_us_since_boot(get_absolute_time()));
+        PRINTRAW("%u,", buff[i].motion);
+        PRINTRAW("%u,", buff[i].observation);
+        PRINTRAW("%ld,", convert_two_complement(delta_x_raw));
+        PRINTRAW("%ld,", convert_two_complement(delta_y_raw));
+        PRINTRAW("%u,", buff[i].squal);
+        PRINTRAW("%u,", buff[i].raw_data_sum);
+        PRINTRAW("%u,", buff[i].maximum_raw_data);
+        PRINTRAW("%u,", buff[i].minimum_raw_data);
+        PRINTRAW("%u\r\n", shutter_raw);
+    }
+
+    if (serial) {
+        println();
     }
-    println();
 
     pmw_irq_start();
+
+    if (!serial) {
+        FRESULT res = f_close(&file);
+        if (res != FR_OK) {
+            debug("error: f_close returned %d", res);
+        }
+    }
 }
 
 int pmw_init(void) {

firmware/src/usb.c

@@ -27,6 +27,7 @@
 #include "tusb.h"
 
 #include "config.h"
+#include "log.h"
 #include "usb_descriptors.h"
 #include "usb_cdc.h"
 #include "usb_hid.h"
@@ -46,19 +47,22 @@ void usb_run(void) {
 
 // Invoked when device is mounted
 void tud_mount_cb(void) {
+    debug("device mounted");
 }
 
 // Invoked when device is unmounted
 void tud_umount_cb(void) {
+    debug("device unmounted");
 }
 
 // Invoked when usb bus is suspended
 // remote_wakeup_en : if host allow us  to perform remote wakeup
 // Within 7ms, device must draw an average of current less than 2.5 mA from bus
 void tud_suspend_cb(bool remote_wakeup_en) {
-    (void) remote_wakeup_en;
+    debug("device suspended wakeup=%d", remote_wakeup_en);
 }
 
 // Invoked when usb bus is resumed
 void tud_resume_cb(void) {
+    debug("device resumed");
 }

firmware/src/usb_descriptors.c

@@ -110,15 +110,18 @@ enum {
     ITF_NUM_CDC = 0,
     ITF_NUM_CDC_DATA,
     ITF_NUM_HID,
+    ITF_NUM_MSC,
     ITF_NUM_TOTAL
 };
 
-#define  CONFIG_TOTAL_LEN  (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_DESC_LEN)
+#define  CONFIG_TOTAL_LEN  (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_DESC_LEN + TUD_MSC_DESC_LEN)
 
 #define EPNUM_HID       0x81
 #define EPNUM_CDC_NOTIF 0x82
 #define EPNUM_CDC_OUT   0x02
 #define EPNUM_CDC_IN    0x83
+#define EPNUM_MSC_OUT   0x03
+#define EPNUM_MSC_IN    0x84
 
 uint8_t const desc_configuration[] = {
     // Config number, interface count, string index, total length, attribute, power in mA
@@ -128,7 +131,10 @@ uint8_t const desc_configuration[] = {
     TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 4, EPNUM_CDC_NOTIF, 8, EPNUM_CDC_OUT, EPNUM_CDC_IN, 64),
 
     // Interface number, string index, protocol, report descriptor len, EP In address, size & polling interval
-    TUD_HID_DESCRIPTOR(ITF_NUM_HID, 0, HID_ITF_PROTOCOL_NONE, sizeof(desc_hid_report), EPNUM_HID, CFG_TUD_HID_EP_BUFSIZE, 5)
+    TUD_HID_DESCRIPTOR(ITF_NUM_HID, 5, HID_ITF_PROTOCOL_NONE, sizeof(desc_hid_report), EPNUM_HID, CFG_TUD_HID_EP_BUFSIZE, 5),
+
+    // Interface number, string index, EP Out & EP In address, EP size
+    TUD_MSC_DESCRIPTOR(ITF_NUM_MSC, 6, EPNUM_MSC_OUT, EPNUM_MSC_IN, 64),
 };
 
 #if TUD_OPT_HIGH_SPEED
@@ -203,6 +209,8 @@ char const* string_desc_arr [] = {
     "Trackball",                   // 2: Product
     string_pico_serial,            // 3: Serials, should use chip ID
     "Debug Serial",                // 4: CDC Interface
+    "Input Device",                // 5: HID Interface
+    "Debug Memory",                // 6: MSC Interface
 };
 
 static uint16_t _desc_str[32];

firmware/src/usb_msc.c

@@ -0,0 +1,184 @@
+/* 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "bsp/board.h"
+#include "tusb.h"
+
+#include "config.h"
+#include "fat_disk.h"
+#include "log.h"
+
+static bool ejected = false;
+static bool medium_available = false;
+
+bool msc_is_medium_available(void) {
+    return medium_available;
+}
+
+void msc_set_medium_available(bool state) {
+    medium_available = state;
+    if (state) {
+        ejected = false;
+    }
+}
+
+// Invoked when received SCSI_CMD_INQUIRY
+// Application fill vendor id, product id and revision
+// with string up to 8, 16, 4 characters respectively
+void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8],
+        uint8_t product_id[16], uint8_t product_rev[4]) {
+    (void) lun;
+
+    const char vid[] = "xythobuz";
+    const char pid[] = "Debug Storage";
+    const char rev[] = "0.01";
+
+    memcpy(vendor_id  , vid, strlen(vid));
+    memcpy(product_id , pid, strlen(pid));
+    memcpy(product_rev, rev, strlen(rev));
+}
+
+// Invoked when received Test Unit Ready command.
+// return true allowing host to read/write this LUN e.g SD card inserted
+bool tud_msc_test_unit_ready_cb(uint8_t lun) {
+    if (ejected || !medium_available) {
+        // Additional Sense 3A-00 is NOT_FOUND
+        tud_msc_set_sense(lun, SCSI_SENSE_NOT_READY, 0x3a, 0x00);
+        return false;
+    }
+
+    return true;
+}
+
+// Invoked when received SCSI_CMD_READ_CAPACITY_10 and
+// SCSI_CMD_READ_FORMAT_CAPACITY to determine the disk size
+// Application update block count and block size
+void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_size) {
+    (void) lun;
+
+    *block_count = DISK_BLOCK_COUNT;
+    *block_size  = DISK_BLOCK_SIZE;
+}
+
+// Invoked when received Start Stop Unit command
+// - Start = 0 : stopped power mode, if load_eject = 1 : unload disk storage
+// - Start = 1 : active mode, if load_eject = 1 : load disk storage
+bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition,
+        bool start, bool load_eject) {
+    (void) lun;
+    (void) power_condition;
+
+    if (start) {
+        // load disk storage
+        debug("load disk storage %d", load_eject);
+    } else {
+        // unload disk storage
+        debug("unload disk storage %d", load_eject);
+        ejected = true;
+    }
+
+    return true;
+}
+
+// Callback invoked when received READ10 command.
+// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
+int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba,
+        uint32_t offset, void* buffer, uint32_t bufsize) {
+    (void) lun;
+
+    // out of ramdisk
+    if (lba >= DISK_BLOCK_COUNT) {
+        return -1;
+    }
+
+    // TODO better range checking and length calculation?
+
+    uint8_t const* addr = fat_disk_get_sector(lba) + offset;
+    memcpy(buffer, addr, bufsize);
+
+    return (int32_t) bufsize;
+}
+
+bool tud_msc_is_writable_cb (uint8_t lun) {
+    (void) lun;
+
+    return true;
+}
+
+// Callback invoked when received WRITE10 command.
+// Process data in buffer to disk's storage and return number of written bytes
+int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba,
+        uint32_t offset, uint8_t* buffer, uint32_t bufsize) {
+    (void) lun;
+
+    // out of ramdisk
+    if (lba >= DISK_BLOCK_COUNT) {
+        return -1;
+    }
+
+    // TODO better range checking and length calculation?
+
+    uint8_t* addr = fat_disk_get_sector(lba) + offset;
+    memcpy(addr, buffer, bufsize);
+
+    return (int32_t) bufsize;
+}
+
+// Callback invoked when received an SCSI command not in built-in list below
+// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
+// - READ10 and WRITE10 has their own callbacks and MUST not be handled here
+int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16],
+        void* buffer, uint16_t bufsize) {
+    void const* response = NULL;
+    int32_t resplen = 0;
+
+    // most scsi handled is input
+    bool in_xfer = true;
+
+    switch (scsi_cmd[0]) {
+    default:
+        // Set Sense = Invalid Command Operation
+        tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
+
+        // negative means error -> tinyusb could stall and/or response with failed status
+        resplen = -1;
+        break;
+    }
+
+    // return resplen must not larger than bufsize
+    if (resplen > bufsize) {
+        resplen = bufsize;
+    }
+
+    if (response && (resplen > 0)) {
+        if (in_xfer) {
+            memcpy(buffer, response, (size_t) resplen);
+        } else {
+            // SCSI output
+        }
+    }
+
+    return (int32_t) resplen;
+}