Wire-free Miniscope v4

The wire-free Miniscope v4 is a battery powered, data logging Miniscope based around the original wired Miniscope v4 project. All code, CAD, and PCB files can be found at https://github.com/Aharoni-Lab/Miniscope-v4-Wire-Free

Specifications

• Weight:
• Size:
• Field of View:
• Recording Resolution:
• Recording Length:
• Record Triggering:

MCU Firmware Walkthrough

The microcontroller (MCU) used in the Wire-Free Miniscope v4 is an ATSAMD51. It sits between the Python 480 CMOS image sensor and the micro SD Card and handles all on-board control and operation of the Miniscope. The firmware uses a combination of custom written driver and ones imported using ATMEL SMART.

Initialization

• atmel_start_init()
  • This function calls init_mcu() which sets up clocks, configs and enable DMA, and enables/disables cache.
  • This function also sets up the initial configurations mainly defined by the ATMEL SMART interface. This includes setting GPIO direction and mode and initalizing the ADC, external interrupts, PPC, USART, PWM, SYSTick, and Timers.
  • This function also does some minor stuff to initalize the sd_mmc stack.
• Next we do some additional manual configuration of the PWM mode, enabling the 3.3V external regulator, and enabling the ADC.
• Due to pin limitations when using both the PCC module and SD Card module, we don't have access to directly using the SERCOM I2C functionality of this particular MCU. This means we need to implement I2C ourselves using a "Big Back" approach. We set this all up in I2C_BB_init() and all of the I2C Big Bang functionality is done in i2c_bb.c.
• Next we setup timers that let us keep track of the time in milliseconds, TIMER_0_taks1, and check the Lipo battery voltage every once-in-a-while, TIMER_0_task2.
• Next we construct our DMA/Buffer linked lists in linkedListInit(). More information on this can be found below.
• Next we wait until we detect an SD Card in mounted on the PCB, read the header memory block (block 1022) using loadSDCardHeader(), and configure the SDHC module to run using ADMA.
• Next we setup the Python 480 by toggling its reset pin, sending it initial register values using python480Init(), and then configuring its registers for subsampling, gain, FPS, etc.
• Finally, we write some initial configuration information into SD card memory block 1023 and then set deviceState = DEVICE_STATE_START_RECORDING to trigger the event to begin recording imaging data.

Buffers

The MCU firmware creates a circular buffer to fill and hold pixel data. This set of buffers should each have a size a multiple of 512 bytes so that each can be nicely written into an SD Card whose memory blocks are 512 bytes in size. Outside of the constraint that each buffer should be some multiple of 512 bytes there are no other constraints in terms of number of buffers or buffer size relative to image sensor frame size.

The circular buffers are defined globally within main.c :

COMPILER_ALIGNED(4)
volatile uint32_t dataBuffer[NUM_BUFFERS][BUFFER_BLOCK_LENGTH * BLOCK_SIZE_IN_WORDS]; //Allocate memory for DMA image buffers

This set of buffers gets circularly iterated through using DMA linked lists as pixel data arrives from the image sensor. Once a buffer is full, or once the end of a frame arrives and we have a partially filled buffer, the buffer becomes available to be written to the SD Card using ADMA.

State Machine

// ---------- Device State Definitions -------
#define DEVICE_STATE_IDLE				1<<1
#define DEVICE_STATE_START_RECORDING	1<<2
#define DEVICE_STATE_RECORDING			1<<3
#define DEVICE_STATE_STOP_RECORDING		1<<4
#define DEVICE_STATE_CHARGING			1<<5
#define DEVICE_STATE_CONFIG_LOADED		1<<6
#define DEVICE_STATE_ERROR				1<<7
#define DEVICE_STATE_LOW_VOLTAGE		1<<8
#define DEVICE_STATE_START_RECORDING_WAITING	1<<9
#define DEVICE_STATE_SDCARD_WRITE_ERROR			1<<10
#define DEVICE_STATE_SDCARD_INIT_WRITE_ERROR	1<<11

• The device state initially starts off in DEVICE_STATE_IDLE.
• To begin recording, the device start needs to be set to DEVICE_STATE_START_RECORDING. This lets the MCU know that we need to prepare everything to start a new recording session.
• Once the MCU prepares itself, it moves its device state to DEVICE_STATE_START_RECORDING_WAITING. This state is managed within the frameValid_cb function and makes the MCU wait until the end of the last frame is received before enabling the PCC DMA so that data buffers can start being filled and counted when the start of the next frame begins to arrive. Once the MCU enables the PCC DMA, it will move the device state to DEVICE_STATE_RECORDING.
• Once the MCU moves into the device = DEVICE_STATE_RECORDING, management of detecting newly filled buffers and sending those over to the SD Card is all handed within the function void recording(). recording() is continuously called within the while loop in main().

Callback Functions

Callback functions handle specific events within the MCU that generate interrupts. Roughly speaking, when certain interrupts happen, the MCU will jump from wherever it is currently in its code, to the callback function linked to this interrupt event. Callback functions are denoted with a '_cb' at the end of their function name:

// callbacks
static void millisecondTimer_cb(const struct timer_task *const timer_task);
static void checkBattVoltage_cb(const struct timer_task *const timer_task);

static void battCharging_cb(void);
static void irReceive_cb(void);
static void pushButton_cb(void);
static void frameValid_cb(void);

Many of these callback functions are connected to a specific external interrupt (basically the input on an MCU pin changing a certain way) which is done near the top of main():

// Setup callbacks for external interrupts
	ext_irq_register(PIN_PB22, irReceive_cb);
	ext_irq_register(PIN_PB23, battCharging_cb);
	ext_irq_register(PIN_PB14, frameValid_cb);
	ext_irq_register(PIN_PA25, pushButton_cb);

The DMA callback function is pcc_dma_cb() and gets linked to the DMA interrupt in main() using camera_async_register_callback.

DMA

The MCU using Direct Memory Access (DMA) to stream pixel data into memory from the image sensor as well as write imaging data from memory into the SD Card. For pixel data coming from the image sensor, the MCU uses its Parallel Capture Controller (PCC) with DMA to handle an 8-bit parallel pixel bus. For writing imaging data into the SD Card, the MCU uses its ADMA to move raw data in the MCU memory into the SD Card storage blocks.

PCC DMA (Image Sensor -> MCU Memory)

Linked List DMA Descriptors

COMPILER_ALIGNED(16) // Taken from hpl_dmac.c but I think this could be '8' since descriptors need to be 64bit aligned from data sheet
volatile DmacDescriptor linkedList[NUM_BUFFERS];

PCC DMA Callback

Once a DMA transfer has completed, the pcc_dma_cb function gets called. This callback function will update the header portion of the last written into buffer using the setBufferHeader function and increment the bufferCount and frameBufferCount.

SD Card ADMA (MCU Memory -> SD Card)

Writing and reading from the SD Card takes advantage of ADMA. I can't quite remember what all the differences are here between ADMA and regular DMA but it took a while to get up and running. To get everything up and running in the firmware, I added two additional functions in sd_mmc.c:

• sd_mmc_err_t sd_mmc_write_with_ADMA(uint8_t slot, uint32_t start, uint32_t *descAdd, uint16_t nb_block)
• sd_mmc_err_t sd_mmc_wait_end_of_ADMA_write(bool abort)