mX mbed BaseBoard audio

Dependencies:   mbed

Files at this revision

API Documentation at this revision

Comitter:
ashwin_athani
Date:
Wed Dec 08 06:21:06 2010 +0000
Commit message:

Changed in this revision

FATFileSystem.lib Show annotated file Show diff for this revision Revisions of this file
SDFileSystem.cpp Show annotated file Show diff for this revision Revisions of this file
SDFileSystem.h Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 6c621d41bf07 FATFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem.lib	Wed Dec 08 06:21:06 2010 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_unsupported/code/fatfilesystem/
\ No newline at end of file
diff -r 000000000000 -r 6c621d41bf07 SDFileSystem.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.cpp	Wed Dec 08 06:21:06 2010 +0000
@@ -0,0 +1,300 @@
+/* mbed Microcontroller Library - SDFileSystem
+ * Copyright (c) 2008-2009, sford
+ *
+ * Introduction
+ * ------------
+ * SD and MMC cards support a number of interfaces, but common to them all
+ * is one based on SPI. This is the one I'm implmenting because it means
+ * it is much more portable even though not so performant, and we already 
+ * have the mbed SPI Interface!
+ *
+ * The main reference I'm using is Chapter 7, "SPI Mode" of: 
+ *  http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+ *
+ * SPI Startup
+ * -----------
+ * The SD card powers up in SD mode. The SPI interface mode is selected by
+ * asserting CS low and sending the reset command (CMD0). The card will 
+ * respond with a (R1) response.
+ *
+ * CMD8 is optionally sent to determine the voltage range supported, and 
+ * indirectly determine whether it is a version 1.x SD/non-SD card or 
+ * version 2.x. I'll just ignore this for now.
+ *
+ * ACMD41 is repeatedly issued to initialise the card, until "in idle"
+ * (bit 0) of the R1 response goes to '0', indicating it is initialised.
+ *
+ * You should also indicate whether the host supports High Capicity cards,
+ * and check whether the card is high capacity - i'll also ignore this
+ *
+ * SPI Protocol
+ * ------------
+ * The SD SPI protocol is based on transactions made up of 8-bit words, with
+ * the host starting every bus transaction by asserting the CS signal low. The
+ * card always responds to commands, data blocks and errors.
+ * 
+ * The protocol supports a CRC, but by default it is off (except for the 
+ * first reset CMD0, where the CRC can just be pre-calculated, and CMD8)
+ * I'll leave the CRC off I think! 
+ * 
+ * Standard capacity cards have variable data block sizes, whereas High 
+ * Capacity cards fix the size of data block to 512 bytes. I'll therefore
+ * just always use the Standard Capacity cards with a block size of 512 bytes.
+ * This is set with CMD16.
+ *
+ * You can read and write single blocks (CMD17, CMD25) or multiple blocks 
+ * (CMD18, CMD25). For simplicity, I'll just use single block accesses. When
+ * the card gets a read command, it responds with a response token, and then 
+ * a data token or an error.
+ * 
+ * SPI Command Format
+ * ------------------
+ * Commands are 6-bytes long, containing the command, 32-bit argument, and CRC.
+ *
+ * +---------------+------------+------------+-----------+----------+--------------+
+ * | 01 | cmd[5:0] | arg[31:24] | arg[23:16] | arg[15:8] | arg[7:0] | crc[6:0] | 1 |
+ * +---------------+------------+------------+-----------+----------+--------------+
+ *
+ * As I'm not using CRC, I can fix that byte to what is needed for CMD0 (0x95)
+ *
+ * All Application Specific commands shall be preceded with APP_CMD (CMD55).
+ *
+ * SPI Response Format
+ * -------------------
+ * The main response format (R1) is a status byte (normally zero). Key flags:
+ *  idle - 1 if the card is in an idle state/initialising 
+ *  cmd  - 1 if an illegal command code was detected
+ *
+ *    +-------------------------------------------------+
+ * R1 | 0 | arg | addr | seq | crc | cmd | erase | idle |
+ *    +-------------------------------------------------+
+ *
+ * R1b is the same, except it is followed by a busy signal (zeros) until
+ * the first non-zero byte when it is ready again.
+ *
+ * Data Response Token
+ * -------------------
+ * Every data block written to the card is acknowledged by a byte 
+ * response token
+ *
+ * +----------------------+
+ * | xxx | 0 | status | 1 |
+ * +----------------------+
+ *              010 - OK!
+ *              101 - CRC Error
+ *              110 - Write Error
+ *
+ * Single Block Read and Write
+ * ---------------------------
+ *
+ * Block transfers have a byte header, followed by the data, followed
+ * by a 16-bit CRC. In our case, the data will always be 512 bytes.
+ *  
+ * +------+---------+---------+- -  - -+---------+-----------+----------+
+ * | 0xFE | data[0] | data[1] |        | data[n] | crc[15:8] | crc[7:0] | 
+ * +------+---------+---------+- -  - -+---------+-----------+----------+
+ */
+ 
+#include "SDFileSystem.h"
+
+#define SD_COMMAND_TIMEOUT 5000
+
+SDFileSystem::SDFileSystem(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name) :
+  FATFileSystem(name), _spi(mosi, miso, sclk), _cs(cs) {
+      _cs = 1; 
+}
+
+int SDFileSystem::disk_initialize() {
+
+    _spi.frequency(100000); // Set to 100kHz for initialisation
+    
+    // Initialise the card by clocking it with cs = 1
+    _cs = 1;
+    for(int i=0; i<16; i++) {   
+        _spi.write(0xFF);
+    }
+
+    // send CMD0, should return with all zeros except IDLE STATE set (bit 0)
+    if(_cmd(0, 0) != 0x01) { 
+        fprintf(stderr, "Not in idle state\n");
+        return 1;
+    }
+    
+    // ACMD41 to give host capacity support (repeat until not busy)
+    // ACMD41 is application specific command, so we send APP_CMD (CMD55) beforehand
+    for(int i=0;; i++) {
+        _cmd(55, 0); 
+        int response = _cmd(41, 0);
+        if(response == 0) { 
+            break;
+        } else if(i > SD_COMMAND_TIMEOUT) {
+            fprintf(stderr, "Timeout waiting for card\n");
+            return 1;
+        }    
+    }
+
+    _sectors = _sd_sectors();
+
+    // Set block length to 512 (CMD16)
+    if(_cmd(16, 512) != 0) {
+        fprintf(stderr, "Set block timeout\n");
+        return 1;
+    }
+        
+    _spi.frequency(1000000); // Set to 1MHz for data transfer
+    return 0;
+}
+
+int SDFileSystem::disk_write(const char *buffer, int block_number) {
+    // set write address for single block (CMD24)
+    if(_cmd(24, block_number * 512) != 0) {
+        return 1;
+    }
+
+    // send the data block
+    _write(buffer, 512);    
+    return 0;    
+}
+
+int SDFileSystem::disk_read(char *buffer, int block_number) {        
+    // set read address for single block (CMD17)
+    if(_cmd(17, block_number * 512) != 0) {
+        return 1;
+    }
+    
+    // receive the data
+    _read(buffer, 512);
+    return 0;
+}
+
+int SDFileSystem::disk_status() { return 0; }
+int SDFileSystem::disk_sync() { return 0; }
+int SDFileSystem::disk_sectors() { return _sectors; }
+
+// PRIVATE FUNCTIONS
+
+int SDFileSystem::_cmd(int cmd, int arg) {
+    _cs = 0; 
+
+    // send a command
+    _spi.write(0x40 | cmd);
+    _spi.write(arg >> 24);
+    _spi.write(arg >> 16);
+    _spi.write(arg >> 8);
+    _spi.write(arg >> 0);
+    _spi.write(0x95);
+
+    // wait for the repsonse (response[7] == 0)
+    for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+        int response = _spi.write(0xFF);
+        if(!(response & 0x80)) {
+            _cs = 1;
+            _spi.write(0xFF);
+            return response;
+        }
+    }
+    _cs = 1;
+    _spi.write(0xFF);
+    return -1; // timeout
+}
+
+int SDFileSystem::_read(char *buffer, int length) {
+    _cs = 0;
+
+    // read until start byte (0xFF)
+    while(_spi.write(0xFF) != 0xFE);
+
+    // read data
+    for(int i=0; i<length; i++) {
+        buffer[i] = _spi.write(0xFF);
+    }
+    _spi.write(0xFF); // checksum
+    _spi.write(0xFF);
+
+    _cs = 1;    
+    _spi.write(0xFF);
+    return 0;
+}
+
+int SDFileSystem::_write(const char *buffer, int length) {
+    _cs = 0;
+    
+    // indicate start of block
+    _spi.write(0xFE);
+    
+    // write the data
+    for(int i=0; i<length; i++) {
+        _spi.write(buffer[i]);
+    }
+    
+    // write the checksum
+    _spi.write(0xFF); 
+    _spi.write(0xFF);
+
+    // check the repsonse token
+    if((_spi.write(0xFF) & 0x1F) != 0x05) {
+        _cs = 1;
+        _spi.write(0xFF);        
+        return 1;
+    }
+
+    // wait for write to finish
+    while(_spi.write(0xFF) == 0);
+
+    _cs = 1; 
+    _spi.write(0xFF);
+    return 0;
+}
+
+static int ext_bits(char *data, int msb, int lsb) {
+    int bits = 0;
+    int size = 1 + msb - lsb; 
+    for(int i=0; i<size; i++) {
+        int position = lsb + i;
+        int byte = 15 - (position >> 3);
+        int bit = position & 0x7;
+        int value = (data[byte] >> bit) & 1;
+        bits |= value << i;
+    }
+    return bits;
+}
+
+int SDFileSystem::_sd_sectors() {
+
+    // CMD9, Response R2 (R1 byte + 16-byte block read)
+    if(_cmd(9, 0) != 0) {
+        fprintf(stderr, "Didn't get a response from the disk\n");
+        return 0;
+    }
+    
+    char csd[16];    
+    if(_read(csd, 16) != 0) {
+        fprintf(stderr, "Couldn't read csd response from disk\n");
+        return 0;
+    }
+
+    // csd_structure : csd[127:126]
+    // c_size        : csd[73:62]
+    // c_size_mult   : csd[49:47]
+    // read_bl_len   : csd[83:80] 
+
+    int csd_structure = ext_bits(csd, 127, 126);
+    int c_size = ext_bits(csd, 73, 62);
+    int c_size_mult = ext_bits(csd, 49, 47);
+    int read_bl_len = ext_bits(csd, 83, 80);
+    
+    if(csd_structure != 0) {
+        fprintf(stderr, "This disk tastes funny! I only know about type 0 CSD structures");
+        return 0;
+    }
+                            
+    int blocks = (c_size + 1) * (1 << (c_size_mult + 2));
+    int block_size = 1 << read_bl_len;
+
+    if(block_size != 512) {
+        fprintf(stderr, "This disk tastes funny! I only like 512-byte blocks");
+        return 0;
+    }
+    
+    return blocks;
+}
diff -r 000000000000 -r 6c621d41bf07 SDFileSystem.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.h	Wed Dec 08 06:21:06 2010 +0000
@@ -0,0 +1,56 @@
+/* mbed Microcontroller Library - SDFileSystem
+ * Copyright (c) 2008-2009, sford
+ */
+
+#ifndef SDFILESYSTEM_H
+#define SDFILESYSTEM_H
+
+#include "mbed.h"
+#include "FATFileSystem.h"
+
+/* Class: SDFileSystem
+ *  Access the filesystem on an SD Card using SPI
+ *
+ * Example:
+ * > SDFileSystem sd(p5, p6, p7, p12, "sd");
+ * > 
+ * > int main() {
+ * >     FILE *fp = fopen("/sd/myfile.txt", "w");
+ * >     fprintf(fp, "Hello World!\n");
+ * >     fclose(fp);
+ * > }
+ */
+class SDFileSystem : public FATFileSystem {
+public:
+
+    /* Constructor: SDFileSystem
+     *  Create the File System for accessing an SD Card using SPI
+     *
+     * Variables:
+     *  mosi - SPI mosi pin connected to SD Card
+     *  miso - SPI miso pin conencted to SD Card
+     *  sclk - SPI sclk pin connected to SD Card
+     *  cs   - DigitalOut pin used as SD Card chip select
+   *  name - The name used to access the filesystem
+     */
+    SDFileSystem(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name);
+    virtual int disk_initialize();
+    virtual int disk_write(const char *buffer, int block_number);
+    virtual int disk_read(char *buffer, int block_number);    
+    virtual int disk_status();
+    virtual int disk_sync();
+    virtual int disk_sectors();
+
+protected:
+
+    int _cmd(int cmd, int arg);
+    int _read(char *buffer, int length);
+    int _write(const char *buffer, int length);
+    int _sd_sectors();
+    int _sectors;
+    
+    SPI _spi;
+    DigitalOut _cs;     
+};
+
+#endif
diff -r 000000000000 -r 6c621d41bf07 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Dec 08 06:21:06 2010 +0000
@@ -0,0 +1,189 @@
+#include "mbed.h"
+#include "SDFileSystem.h"
+
+AnalogOut DACout(p18);
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+DigitalOut led3(LED3);
+DigitalOut led4(p8);
+DigitalOut digout(LED4);
+Ticker tick;
+//SDFileSystem sd(p11, p12, p13, p14, "sd");
+SDFileSystem sd(p5, p6, p7, p8, "sd"); // NGX mbed base board
+
+#define SAMPLE_FREQ 40000
+#define BUF_SIZE (SAMPLE_FREQ/10)
+#define SLICE_BUF_SIZE 1
+
+void dac_out(void);
+void play_wave(char *);
+void cleanup(char *);
+void fill_adc_buf(short *, unsigned);
+void swapword(unsigned *);
+
+// a FIFO for the DAC
+short DAC_fifo[256];
+short DAC_wptr;
+short DAC_rptr;
+short DAC_on;
+
+typedef struct uFMT_STRUCT {
+  short comp_code;
+  short num_channels;
+  unsigned sample_rate;
+  unsigned avg_Bps;
+  short block_align;
+  short sig_bps;
+} FMT_STRUCT;
+
+
+int main() {
+  led1=0; wait(.5); led1=1; wait(.5); led1=0;
+  printf("Hello, world!\n");
+  play_wave("/sd/forest.wav");
+  printf("Back from forest\n");
+  printf("Goodbye, world!\n");
+  led1=1; wait(.5); led1=0; wait(.5); led1=1;
+}
+  
+void play_wave(char *wavname)
+{
+        unsigned chunk_id,chunk_size,channel;
+//        unsigned *data_wptr,data,samp_int,i;
+        unsigned data,samp_int,i;
+        short dac_data;
+        char *slice_buf;
+        short *data_sptr;
+//        char *data_bptr;
+        FMT_STRUCT wav_format;
+        FILE *wavfile;
+        long slice,num_slices;
+  DAC_wptr=0;
+  DAC_rptr=0;
+  for (i=0;i<256;i+=2) {
+    DAC_fifo[i]=0;
+    DAC_fifo[i+1]=3000;
+  }
+  DAC_wptr=4;
+  DAC_on=0;
+
+  led1=led2=led3=led4=0;
+  
+  printf("Playing wave file '%s'\n",wavname);
+
+  wavfile=fopen(wavname,"rb");
+  if (!wavfile) {
+    printf("Unable to open wav file '%s'\n",wavname);
+    exit(1);
+  }
+
+  fread(&chunk_id,4,1,wavfile);
+  fread(&chunk_size,4,1,wavfile);
+  while (!feof(wavfile)) {
+    printf("Read chunk ID 0x%x, size 0x%x\n",chunk_id,chunk_size);
+    switch (chunk_id) {
+      case 0x46464952:
+        fread(&data,4,1,wavfile);
+        printf("RIFF chunk\n");
+        printf("  chunk size %d (0x%x)\n",chunk_size,chunk_size);
+        printf("  RIFF type 0x%x\n",data);
+        break;
+      case 0x20746d66:
+        fread(&wav_format,sizeof(wav_format),1,wavfile);
+        printf("FORMAT chunk\n");
+        printf("  chunk size %d (0x%x)\n",chunk_size,chunk_size);
+        printf("  compression code %d\n",wav_format.comp_code);
+        printf("  %d channels\n",wav_format.num_channels);
+        printf("  %d samples/sec\n",wav_format.sample_rate);
+        printf("  %d bytes/sec\n",wav_format.avg_Bps);
+        printf("  block align %d\n",wav_format.block_align);
+        printf("  %d bits per sample\n",wav_format.sig_bps);
+        if (chunk_size > sizeof(wav_format))
+          fseek(wavfile,chunk_size-sizeof(wav_format),SEEK_CUR);
+// create a slice buffer large enough to hold multiple slices
+        slice_buf=(char *)malloc(wav_format.block_align*SLICE_BUF_SIZE);
+        if (!slice_buf) {
+          printf("Unable to malloc slice buffer");
+          exit(1);
+        }
+        break;
+      case 0x61746164:
+        slice_buf=(char *)malloc(wav_format.block_align*SLICE_BUF_SIZE);
+        if (!slice_buf) {
+          printf("Unable to malloc slice buffer");
+          exit(1);
+        }        num_slices=chunk_size/wav_format.block_align;
+        printf("DATA chunk\n");
+        printf("  chunk size %d (0x%x)\n",chunk_size,chunk_size);
+        printf("  %d slices\n",num_slices);
+        printf("  Ideal sample interval=%d\n",(unsigned)(1000000.0/wav_format.sample_rate));
+        samp_int=1000000/(wav_format.sample_rate);
+        printf("  programmed interrupt tick interval=%d\n",samp_int);
+
+// starting up ticker to write samples out -- no printfs until tick.detach is called
+        tick.attach_us(&dac_out, samp_int); 
+        DAC_on=1; 
+        led2=1;
+        for (slice=0;slice<num_slices;slice+=SLICE_BUF_SIZE) {
+          fread(slice_buf,wav_format.block_align*SLICE_BUF_SIZE,1,wavfile);
+          if (feof(wavfile)) {
+            printf("Oops -- not enough slices in the wave file\n");
+            exit(1);
+          }
+          data_sptr=(short *)slice_buf;
+          for (i=0;i<SLICE_BUF_SIZE;i++) {
+            dac_data=0;
+
+// for a stereo wave file average the two channels.
+            for (channel=0;channel<wav_format.num_channels;channel++) {
+              switch (wav_format.sig_bps) {
+                case 16:
+                  dac_data+=(  ((int)(*data_sptr++)) +32768)>>5;
+                  break;
+              }
+            }
+            dac_data>>=1;
+            DAC_fifo[DAC_wptr]=dac_data;
+            DAC_wptr=(DAC_wptr+1) & 0xff;
+            while (DAC_wptr==DAC_rptr) {
+              led1=1;
+            }
+            led1=0;
+          }
+        }
+        DAC_on=0;
+        led2=0;
+        tick.detach();
+        printf("Ticker detached\n");
+        led3=1;
+        free(slice_buf);
+        break;
+      case 0x5453494c:
+        printf("INFO chunk, size %d\n",chunk_size);
+        fseek(wavfile,chunk_size,SEEK_CUR);
+        break;
+      default:
+        printf("unknown chunk type 0x%x, size %d\n",chunk_id,chunk_size);
+        data=fseek(wavfile,chunk_size,SEEK_CUR);
+        break;
+    }
+    fread(&chunk_id,4,1,wavfile);
+    fread(&chunk_size,4,1,wavfile);
+  }
+  printf("Done with wave file\n");
+  fclose(wavfile);
+  led1=0;
+}
+
+
+void dac_out()
+{
+  if (DAC_on) {
+    digout=1;
+    DACout.write_u16(DAC_fifo[DAC_rptr]);
+    DAC_rptr=(DAC_rptr+1) & 0xff;
+    digout=0;
+  }
+}
+
+    
diff -r 000000000000 -r 6c621d41bf07 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Wed Dec 08 06:21:06 2010 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/49a220cc26e0