libDaisy Documentation

Because SDRAM is not automatically zeroed and requires hardware initialization, you should not rely on constructors for data setup. Instead, use an Init function pattern.

1. Call DaisySeed::Init() first.
2. Call a custom initialization function to zero out or fill your SDRAM buffers.

Recommended Class Design Pattern: To make classes compatible with large external memory, design them to accept a pointer to a buffer during an initialization phase rather than allocating the buffer internally via a constructor. This allows the buffer to be declared in any memory region (internal or SDRAM) and passed in at runtime.

// Example of a class designed to accept an external buffer
class MyClass {
public:
    void Init(float* buffer, size_t size) {
        internal_buffer_ = buffer;
        buffer_size_ = size;
        // Perform manual initialization/zeroing here
    }
private:
    float *internal_buffer_;
    size_t buffer_size_;
};

// Usage:
DSY_SDRAM_BSS float my_sdram_buffer[1024];
MyClass my_instance;

// Inside your main setup/init function:
// 1. DaisySeed::Init();
// 2. my_instance.Init(my_sdram_buffer, 1024);

By default, floating point support is disabled to save memory. You have three primary ways to print floats:

1. Enable standard %f support

If you have sufficient flash memory, you can enable standard printf float support by adding a flag to your application's Makefile. This allows you to use the %f specifier directly.

Makefile flag: LDFLAGS += -u _printf_float

2. Use Logger macros (Low memory cost)

For minimal memory impact, use the FLT_FMT and FLT_VAR macros provided by the Logger class. These allow you to specify precision without the large overhead of the standard float library.

3. Use FixedCapStr (Flexible/UI focused)

Use the FixedCapStr class and its AppendFloat method. This is useful for building complex strings or UIs. You must ensure the template size is large enough for the resulting string.

Note: AppendFloat rounds to 2 decimal places by default unless a second argument is provided.

// Option 1: Standard %f (requires LDFLAGS += -u _printf_float)
float my_flt = 123.456f;
hw.PrintLine("My Float: %f", my_flt);

// Option 2: Macros (Low memory cost)
// Using fixed precision (3 decimal places)
hw.PrintLine("My Float: " FLT_FMT3, FLT_VAR3(my_flt));
// Using generic precision (6 decimal places)
hw.PrintLine("My Float: " FLT_FMT(6), FLT_VAR(6, my_flt));

// Option 3: FixedCapStr
FixedCapStr<16> str("Value: ");
str.AppendFloat(123.456f, 3); // 3 decimal places
hw.PrintLine(str);

Grace Period and LED Indicators

• Startup: Upon boot, the bootloader enters a 2.5-second 'grace period' indicated by sinusoidal LED blinks. During this time, it listens for DFU transactions over USB and scans connected media (SD/USB) for .bin files.
• Extending Grace Period: Press the BOOT button to extend the grace period indefinitely. The bootloader will respond with rapid blinks.
• Errors: If the bootloader encounters an error (e.g., an invalid program), the user LED will emit an SOS pattern.

Memory and Storage Details

• QSPI Flash: Programs are stored on the QSPI flash chip starting at address 0x90040000 (the first four 64kB sectors are reserved).
• SRAM Limits: The bootloader uses 32kB of SRAM for its own processes at the end of the region. Consequently, programs running in SRAM cannot exceed ~480kB.
• Media Search: The bootloader scans the root directory of connected media for any file ending in .bin. It checks SD cards before USB drives. If a valid .bin is found on an SD card, the USB drive search is skipped.

You can log information from your Daisy code to a computer via the built-in USB port. This is an effective way to debug without extra hardware.

To use this feature:

1. Initialize the hardware using hw.Init().
2. Enable logging using hw.StartLog().
3. Use hw.PrintLine() to send formatted strings to the serial monitor.

Important: Avoiding missed messages When the Daisy starts, it executes code immediately. If you connect your Serial Monitor after the program has already started, you might miss the initial output. To prevent this, call hw.StartLog(true). This tells the program to wait indefinitely until a USB Host (your computer) connects to the COM port before continuing execution.

#include "daisy_seed.h"
using namespace daisy;

DaisySeed hw;

int main(void) {
  hw.Init();

  // Passing 'true' makes the program wait for a USB connection
  // before proceeding, ensuring you don't miss early logs.
  hw.StartLog(true);

  hw.PrintLine("Hello World!");

  while(1) {}
}