Update adafruit_floppy

Author: jepler

lib/adafruit_floppy

@@ -28,6 +28,7 @@
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "common-hal/floppyio/__init__.h"
 
+#include <math.h>
 #include <stdint.h>
 
 #include "py/binary.h"
@@ -52,62 +53,117 @@
 //|     ...
 //|
 STATIC mp_obj_t floppyio_flux_readinto(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_buffer, ARG_data, ARG_index };
+    enum { ARG_buffer, ARG_data, ARG_index, ARG_index_wait };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_index, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_index_wait, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_WRITE);
+
     digitalio_digitalinout_obj_t *data = assert_digitalinout(args[ARG_data].u_obj);
     digitalio_digitalinout_obj_t *index = assert_digitalinout(args[ARG_index].u_obj);
 
-    return MP_OBJ_NEW_SMALL_INT(common_hal_floppyio_flux_readinto(bufinfo.buf, bufinfo.len, data, index));
+    mp_int_t index_wait_ms = args[ARG_index_wait].u_obj ?
+        MICROPY_FLOAT_C_FUN(round)(mp_arg_validate_type_float(args[ARG_index_wait].u_obj, MP_QSTR_index_wait) * 1000) :
+        MICROPY_FLOAT_CONST(.220);
+
+    return MP_OBJ_NEW_SMALL_INT(common_hal_floppyio_flux_readinto(bufinfo.buf, bufinfo.len, data, index, index_wait_ms));
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(floppyio_flux_readinto_obj, 0, floppyio_flux_readinto);
 
 //| def mfm_readinto(
-//|     buffer: WriteableBuffer, data: digitalio.DigitalInOut, index: digitalio.DigitalInOut
+//|     buffer: WriteableBuffer,
+//|     flux: ReadableBuffer,
+//|     flux_t1_nominal: int,
+//|     validity: bytearray | None = None,
+//|     clear_validity: bool = True,
 //| ) -> int:
-//|     """Read mfm blocks into the buffer.
+//|     """Decode MFM flux into the buffer
 //|
 //|     The track is assumed to consist of 512-byte sectors.
 //|
-//|     The function returns when all sectors have been successfully read, or
-//|     a number of index pulses have occurred.  Due to technical limitations, this
-//|     process may not be interruptible by KeyboardInterrupt.
+//|     The function returns the number of sectors successfully read. In addition,
+//|     it updates the ``validity`` buffer with information about which sectors
+//|     were read.
 //|
-//|     :param buffer: Read data into this buffer.  Must be a multiple of 512.
-//|     :param data: Pin on which the mfm data appears
-//|     :param index: Pin on which the index pulse appears
+//|     MFM encoding uses pulses of 3 widths, "T2", "T3" and "T4".
+//|     A 1440KiB disk in standard MFM format has "T2" pulses of 2000ns, "T3" pulses of 3000ns,
+//|     and "T4" pulses of 4000ns.
+//|
+//|     Parameters ``t2_max`` and ``t3_max`` are used to distinguish these pulses.
+//|     A pulse with ``p <= t2_max`` is a "T2" pulse,
+//|     a pulse with ``t2_max < p <= t3_max`` is a "T3" pulse,
+//|     and a pulse with ``t3_max < p`` is a "T4" pulse.
+//|
+//|     The following code can convert a number in nanoseconds to a number of samples
+//|     for a given sample rate:
+//|
+//|     . code-block:: py
+//|
+//|         def ns_to_count(ns, samplerate):
+//|             return round(ns * samplerate * 1e-9)
+//|
+//|      This means the following typical values are a good starting place for a 1.44MB floppy:
+//|
+//|     . code-block:: py
+//|
+//|         t2_max = ns_to_count(2500, samplerate) # Mid way between T2 and T3 length
+//|         t3_max = ns_to_count(3500, samplerate) # Mid way between T2 and T3 length
+//|
+//|     :param buffer: Read data into this buffer.  Byte length must be a multiple of 512.
+//|     :param flux: Flux data from a previous `flux_readinto` call
+//|     :param t2_max: Maximum time of a flux cell in counts.
+//|     :param t3_max: Nominal time of a flux cell in counts.
+//|     :param validity: Optional bytearray. For each sector successfully read, the corresponding validity entry is set to ``1`` and previously valid sectors are not decoded.
+//|     :param clear_validity: If `True`, clear the validity information before decoding and attempt to decode all sectors.
 //|     :return: The actual number of sectors read
 //|     """
 //|     ...
 //|
 STATIC mp_obj_t floppyio_mfm_readinto(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_buffer, ARG_data, ARG_index };
+    enum { ARG_buffer, ARG_flux, ARG_t2_max, ARG_t3_max, ARG_validity, ARG_clear_validity };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_index, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_flux, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_flux_t2_max, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_flux_t3_max, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_validity, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_clear_validity, MP_ARG_BOOL, {.u_bool = true } },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_WRITE);
-    digitalio_digitalinout_obj_t *data = assert_digitalinout(args[ARG_data].u_obj);
-    digitalio_digitalinout_obj_t *index = assert_digitalinout(args[ARG_index].u_obj);
-
     if (bufinfo.len % 512 != 0) {
         mp_raise_ValueError(MP_ERROR_TEXT("Buffer must be a multiple of 512 bytes"));
     }
     size_t n_sectors = bufinfo.len / 512;
-    return MP_OBJ_NEW_SMALL_INT(common_hal_floppyio_mfm_readinto(bufinfo.buf, n_sectors, data, index));
+
+    mp_buffer_info_t bufinfo_flux;
+    mp_get_buffer_raise(args[ARG_flux].u_obj, &bufinfo_flux, MP_BUFFER_READ);
+
+    mp_buffer_info_t bufinfo_validity;
+    uint8_t validity_buf[n_sectors];
+    if (args[ARG_validity].u_obj) {
+        mp_get_buffer_raise(args[ARG_validity].u_obj, &bufinfo_validity, MP_BUFFER_READ);
+        mp_arg_validate_length_min(bufinfo_validity.len, n_sectors, MP_QSTR_validity);
+        if (args[ARG_clear_validity].u_bool) {
+            memset(validity_buf, 0, sizeof(validity_buf));
+        }
+    } else {
+        bufinfo_validity.buf = &validity_buf;
+        bufinfo_validity.len = n_sectors;
+        memset(validity_buf, 0, sizeof(validity_buf));
+    }
+
+    return MP_OBJ_NEW_SMALL_INT(common_hal_floppyio_mfm_readinto(&bufinfo, &bufinfo_flux, bufinfo_validity.buf, args[ARG_t2_max].u_int, args[ARG_t3_max].u_int));
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(floppyio_mfm_readinto_obj, 0, floppyio_mfm_readinto);
 

shared-bindings/floppyio/__init__.c

@@ -26,7 +26,8 @@
 
 #pragma once
 
+#include "py/obj.h"
 #include "common-hal/digitalio/DigitalInOut.h"
 
-int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalinout_obj_t *data, digitalio_digitalinout_obj_t *index);
-int common_hal_floppyio_mfm_readinto(void *buf, size_t n_sector, digitalio_digitalinout_obj_t *data, digitalio_digitalinout_obj_t *index);
+int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalinout_obj_t *data, digitalio_digitalinout_obj_t *index, mp_int_t index_wait_ms);
+int common_hal_floppyio_mfm_readinto(const mp_buffer_info_t *buf, const mp_buffer_info_t *flux_buf, uint8_t *validity, size_t t2_max, size_t t3_max);

shared-bindings/floppyio/__init__.h

@@ -25,6 +25,7 @@
  */
 
 #include "py/runtime.h"
+#include "py/mphal.h"
 
 #include "shared-bindings/time/__init__.h"
 #include "shared-bindings/floppyio/__init__.h"
@@ -38,17 +39,18 @@
 #define T3_5 (FLOPPYIO_SAMPLERATE * 7 / 2 / 1000000)
 #endif
 
-#define MFM_IO_MMIO (1)
 #include "lib/adafruit_floppy/src/mfm_impl.h"
 
+MP_WEAK
 __attribute__((optimize("O3")))
-int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalinout_obj_t *data, digitalio_digitalinout_obj_t *index) {
+int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalinout_obj_t *data, digitalio_digitalinout_obj_t *index, mp_int_t index_wait_ms) {
     uint32_t index_mask;
     volatile uint32_t *index_port = common_hal_digitalio_digitalinout_get_reg(index, DIGITALINOUT_REG_READ, &index_mask);
 
     uint32_t data_mask;
     volatile uint32_t *data_port = common_hal_digitalio_digitalinout_get_reg(data, DIGITALINOUT_REG_READ, &data_mask);
 
+    uint32_t index_deadline_ms = mp_hal_ticks_ms() + index_wait_ms;
 #undef READ_INDEX
 #undef READ_DATA
 #define READ_INDEX() (!!(*index_port & index_mask))
@@ -62,6 +64,9 @@ int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalin
 
     // wait for index pulse low
     while (READ_INDEX()) { /* NOTHING */
+        if (supervisor_ticks_ms32() > index_deadline_ms) {
+            return 0;
+        }
     }
 
 
@@ -96,15 +101,17 @@ int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalin
     return pulses_ptr - pulses;
 }
 
-int common_hal_floppyio_mfm_readinto(void *buf, size_t n_sectors, digitalio_digitalinout_obj_t *data, digitalio_digitalinout_obj_t *index) {
-    mfm_io_t io;
-    io.index_port = common_hal_digitalio_digitalinout_get_reg(index, DIGITALINOUT_REG_READ, &io.index_mask);
-    io.data_port = common_hal_digitalio_digitalinout_get_reg(data, DIGITALINOUT_REG_READ, &io.data_mask);
-
-    common_hal_mcu_disable_interrupts();
-    uint8_t validity[n_sectors];
-    int result = read_track(io, n_sectors, buf, validity);
-    common_hal_mcu_enable_interrupts();
+int common_hal_floppyio_mfm_readinto(const mp_buffer_info_t *buf, const mp_buffer_info_t *flux_buf, uint8_t *validity, size_t t2_max, size_t t3_max) {
+    mfm_io_t io = {
+        .T2_max = t2_max,
+        .T3_max = t3_max,
+        .pulses = flux_buf->buf,
+        .n_pulses = flux_buf->len,
+        .sectors = buf->buf,
+        .sector_validity = validity,
+        .n_sectors = buf->len / 512,
+    };
+    int result = decode_track_mfm(&io);
 
     return result;
 }