Arduino SD card music player

lawrie 2018-07-13 18:05:06 UTC #1

Here is an Arduino example based on @r.miller's SDcard and QSPI examples to read an 8-bit WAV file from a FAT32 SD card and send it to the Ice40 via QSPI and play it on a speaker using the PWM_out code from the fpgafun site. Exciting video followed by the code.

github.com

lawrie/verilog_examples/blob/master/fpga/qspiplay/qspiplay.ino

#include <QSPI.h>
#include <FS.h>
#include <MyStorm.h>

const byte bitstream[] = {
#include "ice40bitstream.h"
};

bool configured;  // true if FPGA has been configured successfully

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 0);
  QSPI.begin(40000000, QSPI.Mode3);
  Serial.begin(9600);
    // configure the FPGA
  configured = myStorm.FPGAConfigure(bitstream, sizeof bitstream);
  while (!Serial) ; // wait for USB serial connection to be established
  
  DOSFS.begin();

This file has been truncated. show original

r.miller 2018-07-14 21:00:03 UTC #2

Nice and simple!

Is the audio clock provided by the delayMicroseconds(100); call, discounting the file read time? Or am I missing something?

Have you tried adding a QSPI interface to BlackSoC? I'd find that useful ...

lawrie 2018-07-15 06:04:40 UTC #3

I just experimented with the delay until the audio sounded about right. I should look in the WAV file header and find the bit rate and adjust the delay accordingly.. The 100 microseconds delay gives a rate of about 10Khz, whereas the file I used was 11.025KHz so the delay ought to be a bit less. I doubt if the file read time is significant and the QSPI transfer rate is so fast that I doubt it that is significant either.

I am currently trying the SD card reading in BlackSoC and have added a fat32 example that reads the file. Porting DOSFS to BlackSoC looked like too much work, so I just wrote low-level code to interpret the FAT32 file system sufficiently to read a file. I will probably add the audio out to BlackSoC. It currently has tone output but that won't work for playing audio files.

And yes, I will add QSPI to BlackSoC. I am not sure if I want it as a master or slave, or both. It currently has an SPI master. Your verilog code would make adding a QSPI slave easy, except that I am not sure what the best C interface for an SPI/QSPI slave would be and whether it needs to use interrupts.

lawrie 2018-07-15 08:17:54 UTC #4

Here is the BlackSoC version of this.

It reads the first file from the root directory of a FAT32 SD card and assumes that it is an 8-bit mono 11.025Khz wave file and plays in on a speaker on pin 34 (Pmod 11, top right pin). All sliders must be in OFF position to use the SD card reader. Lots of diagnostics showing the boot sector, volume ID, root directory, fat table and first sector of the file is output to the BlackSoC console in hex.

github.com

lawrie/icotools/blob/master/icosoc/examples/wavplay/main.c

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "icosoc.h"

// ========================================================================

bool sdcard_ccs_mode;

static void sdcard_cs(bool enable)
{
	if (enable) {
		// printf("SD Card EN=1\n");
		icosoc_sdcard_cs(0);
	} else {
		// printf("SD Card EN=0\n");
		icosoc_sdcard_cs(1);
	}
}

This file has been truncated. show original

lawrie 2018-07-15 12:56:39 UTC #5

Another thing I considered is whether an Arduino package for BlackSoC is a possibility. It could make it easier to program BlackSoC. There are Arduino packages for RISC-V processors such as the HiFive1. The simplest solution would be to configure the SoC with specific hardware such as a few instance of Serial, Wire and SPI. One SPI could go to the SD card pins and another to the STM32 SPI pins, etc. There would be one instance of QSPI. Digital pins could be done with mod_gpio but analog would need an ADC Pmod.

A more sophisticated implementation would analyse the program to see what interfaces it used and generate the appropriate SoC.

lawrie 2018-07-16 13:17:45 UTC #6

I have now added a QSPI slave to BlackSoC.

Here is the module:

github.com

lawrie/icotools/blob/master/icosoc/mod_qspi_slave/mod_qspi_slave.v

module icosoc_mod_qspi_slave #(
	parameter integer CLOCK_FREQ_HZ = 0,
	parameter integer CS_LENGTH = 32
) (
	input clk,
	input resetn,

	input [3:0] ctrl_wr,
	input ctrl_rd,
	input [15:0] ctrl_addr,
	input [31:0] ctrl_wdat,
	output reg [31:0] ctrl_rdat,
	output reg ctrl_done,

	inout [3:0] qd,
	inout qck,
	inout qss
);
	wire qck_in, qss_in;
	wire [7:0] tx_data, rx_data;

This file has been truncated. show original

And the example test program:

github.com

lawrie/icotools/blob/master/icosoc/examples/qspi_slave/main.c

#include <stdio.h>
#include <stdint.h>
#include "icosoc.h"

int main()
{

	for (uint8_t i = 0;; i++)
	{
		icosoc_leds(i);
		// Set the byte to send back
		icosoc_qspi_transmit(0xbd);
		// Call receive twice to see if we lose bytes
		uint32_t r = icosoc_qspi_receive();
		r = icosoc_qspi_receive();
		uint32_t count = r >> 8;
		uint8_t data = r & 0xff;

		printf("Received %02x %ld\n", data, count);

This file has been truncated. show original

And the Arduino program:

github.com

lawrie/icotools/blob/master/icosoc/examples/qspi_slave/qspiboot/qspiboot.ino

/*
 * Configure ICE40 with bitstream from offset 0x0801F000 in STM32 flash
 * (if present), and then repeatedly from Serial (USB CDC-ACM) port
 */

#include <MyStorm.h>
#include <QSPI.h>

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1);
  myStorm.FPGAConfigure((const byte*)0x0801F000, 135100);
  digitalWrite(LED_BUILTIN, 0);

  QSPI.begin(20000000, QSPI.Mode3);
  QSPI.beginTransaction();
}

This file has been truncated. show original

The Arduino program is a variant of the iceboot example as it needs to support the BlackSoC build cycle.

I had to reduce the QSPI speed a bit as data was being corrupted at 40Mhz, so it is now 20Mhz. That is because BlackSoC uses a 20Mhz clock, not the 100Mhz one.

The receive function is synchronous and returns the latest byte and a count of how many bytes were received since the last call. If the count is zero, there is no data. If it is 1, there is good data. Greater than one means data has been lost. The transmit function sets the byte to be sent back by the QSPI slave.

I am not sure how useful this interface is. It is usable for some things. Adding a fifo or an interrupt function or both might be a good idea.

lawrie 2018-07-16 15:48:44 UTC #7

Here is the Arduino + BlackSoc version of the music player:

It uses an Arduino program that combines the iceboot, SDcard and QSPI example programs. The Arduino program reads from USB1 and if it receives a bitstream (starting 0xff) it configures the Ice40, otherwise it treats the data as a filename, reads the file from the SD card and sends it to the Ice40, to do with it what it will. The qspiaudio example sends the bytes received to a speaker to play the audio file. It could do other things, like send it to a VGA text screen.

github.com

lawrie/icotools/blob/master/icosoc/examples/qspiaudio/qspisdboot/qspisdboot.ino

/*
 * Configure ICE40 with bitstream from offset 0x0801F000 in STM32 flash
 * (if present), and then repeatedly from Serial (USB CDC-ACM) port
 * If the first character read id not 0xFF then the input is a filename
 * to read from the SD card and send via QSPI to the Ice40.
 */

#include <MyStorm.h>
#include <QSPI.h>
#include <FS.h>

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1);
  myStorm.FPGAConfigure((const byte*)0x0801F000, 135100);
  digitalWrite(LED_BUILTIN, 0);
    
  while (!Serial) ; // wait for USB serial connection to be established

This file has been truncated. show original