Seeduino Xiao SAMD DAC

I was curious how well I could make the Seeeduino Xiao DAC work well.

Parts:

Hookup is pretty simple:

Xiao SAMD21 Pin1 (DAC/A0)LM386 “In” Pin
Xiao SAMD21 (5V)LM386 “VCC” pin
Xiao SAMD21 (GND)LM386 “GND” post (either)

Then attach your speaker to the screw-terminal. Red to + Black to -.

Given the small cheap speaker I’m not expecting much. The sound is pretty rough and the inexpensive construction makes it act essentially like a low-pass filter.

float x = 0; // Value to take the sin of
float increment = 0.04;  // Value to increment x by each time

void setup() 
{
  analogWriteResolution(10); // Set analog out resolution to max, 10-bits

  Serial.begin(9600);
}

void loop() 
{
  // Generate a voltage value between 0 and 1023. 
  // Let's scale a sin wave between those values:
  // Offset by 511.5, then multiply sin by 511.5.
  int dacVoltage = (int)(511.5 + 511.5 * sin(x));
  x += increment; // Increase value of x
  // Generate a voltage between 0 and 3.3V.
  // 0= 0V, 1023=3.3V, 512=1.65V, etc.
  analogWrite(DAC_PIN, dacVoltage);
  delay(1);

}

Kinda disappointing… No timing, 1000 Hz means my highest frequency will be very low. 2*pi/0.04= 157, so I won’t get more than a few Hertz out of this (I had to bump that increment up to around 20 to even hear anything).

Here are the issues I see:

  1. Computing sin(x) on the fly takes non-zero time. Esp loading a floating point library on what I presume is an integer processor.
  2. Obviously, I want my samples to be applied at exactly regular intervals. delay(1) will be delay(1ms)+time-it-takes-to-process.

So maybe I can set up a buffer with a timer?

First let’s check pointer access:

[Datasheet] page 74

  char mypointer[10];

  analogWrite(DAC_PIN, dacVoltage);
  Serial.println(dacVoltage,DEC);

  unsigned char * p1 = (unsigned char *) 0x42004808;
  unsigned char * p2 = (unsigned char *) 0x42004809;
  short p = *p1 + (short) 256* (*p2);
  siprintf(mypointer,"%u",p);
  Serial.write(mypointer);
  Serial.write("\n");

Gives the expected values:

Actually, maybe I can get away with just a timer.

https://github.com/adafruit/Adafruit_ZeroTimer/blob/master/examples/timer_callback/timer_callback.ino Shows a timer example which seems to work.

So now I can build my notes and play them, right? Not so fast… only have 32K of sram (per Datasheet).

10-bit samples, I want to play “notes” from middle-C to C5. A5 is 440 Hz and I’d like to play at least 4 samples per wavelength (Nyquists’s theorem requires >2, the more the better but this is a cheap speaker anyway). So let’s aim for 10. That’s about 5000 samples/second. Unfortunately with only 32K of sram and 10-bit samples this complicates things. A few options:

  1. Dynamically compute the value of the sine wave.
  2. Dynamically change the timer count, so the same ‘sinewave’ gets pushed in faster/slower as the frequency changes.
  3. Packing the bytes or dropping to 8-bits.
  4. Lookup Tables in Program memory.

Let’s try the lookup tables. A quick python script should generate me the samples I need. Since there’s only 32K of SRAM, I want my arrays to be stored in program memory. There should be a linker directive for that:

#include <avr/pgmspace.h> 
typedef char * NoteWaveform_t;
NoteWaveform_t Note_C4 PROGMEM = { ... };

At least that’s what I found online. But it didn’t work. My SRAM still filled up. Turns out the PROGMEM Macro was blank. I ended up digging into the linker and doing by hand:

#define TEXTSECTION __attribute((section(".text")))
NoteWaveform_t Note_C4 TEXTSECTION= { 
   .... };

seems to work. Be sure to use const so that the compiler knows it shouldn’t try to (accidentally) update the waveforms.

Quick first-week-of-Music-Theory-101: A440 (what you hear orchestras tune to right before the conductor comes out) is the A5 key on your piano. C4 is the C before it and is “middle C”. Each key, black or white, is twelfth-root-of-two (or about 1.0595) times (to the right) or divided by (to the left) from the adjacent key’s frequency. So twelve keys is an octave (the A below middle C is 220 Hz). You can build up frequency tables pretty easily from that information.

I updated analogWriteResolution to 8 bits. Middle-C is 3 half-steps above A220, so 220*(1.0595)^3 = ~261.13, I’m sampling at 5000 samples/second, and my samples should go from 128 up to 255 then down to 0 and back up. 

for i in range (fs):
    128 + 127*sin(2*3.1415*i*ft/fs)

This will give me one-second worth of middle-C. fs is my sample frequency (5000) and ft is my desired tone frequency (261.3).

Happy Birthday (looks like it’s in public Domain now) is a pretty useful test song. The data structure is the note and the number of beats (yeah yeah I know).

Here is the github and Video.