Tom Coxon
Test of Embedded Artists LPCXpresso baseboard ethernet, SD card, audio and OLED display facilities. The program displays the day, date and time on the baseboard OLED and sounds the Big Ben chimes on the hour and quarter hour. On initial startup the program checks that the mbed clock is set and that the chime wav files can be accessed on the SD card. If not it asks to be connected to the internet to obtain the current time and to download the wav files to the SD card.
Dependencies: EthernetNetIf NTPClient_NetServices mbed EAOLED
Revision 0:f61e8db0570d, committed 2010-08-14
- Comitter:
- tom_coxon
- Date:
- Sat Aug 14 10:33:13 2010 +0000
- Commit message:
Changed in this revision
diff -r 000000000000 -r f61e8db0570d EAOLED.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/EAOLED.lib Sat Aug 14 10:33:13 2010 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/simon/code/EAOLED/#8fe8b0fe5134
diff -r 000000000000 -r f61e8db0570d EthernetNetIf.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/EthernetNetIf.lib Sat Aug 14 10:33:13 2010 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/donatien/code/EthernetNetIf/#bc7df6da7589
diff -r 000000000000 -r f61e8db0570d FATFileSystem.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/FATFileSystem.lib Sat Aug 14 10:33:13 2010 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_unsupported/code/fatfilesystem/ \ No newline at end of file
diff -r 000000000000 -r f61e8db0570d HTTPClient.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HTTPClient.lib Sat Aug 14 10:33:13 2010 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/donatien/code/HTTPClient/#d97a4fc01c86
diff -r 000000000000 -r f61e8db0570d NTPClient.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NTPClient.lib Sat Aug 14 10:33:13 2010 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/donatien/code/NTPClient/#7c3f1199256a
diff -r 000000000000 -r f61e8db0570d SDHCFileSystem.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SDHCFileSystem.cpp Sat Aug 14 10:33:13 2010 +0000
@@ -0,0 +1,495 @@
+/* mbed SDFileSystem Library, for providing file access to SD cards
+ * Copyright (c) 2008-2010, sford
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* 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] |
+ * +------+---------+---------+- - - -+---------+-----------+----------+
+ */
+
+ /*
+ * Comment: Changes for SDHC support till 32GB
+ * Name: KB
+ * Date: 07/24/2010
+ * Release: 0.1
+ */
+
+#include "SDHCFileSystem.h"
+
+#define DEBUG
+#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;
+}
+
+#define R1_IDLE_STATE (1 << 0)
+#define R1_ERASE_RESET (1 << 1)
+#define R1_ILLEGAL_COMMAND (1 << 2)
+#define R1_COM_CRC_ERROR (1 << 3)
+#define R1_ERASE_SEQUENCE_ERROR (1 << 4)
+#define R1_ADDRESS_ERROR (1 << 5)
+#define R1_PARAMETER_ERROR (1 << 6)
+
+// Types
+// - v1.x Standard Capacity
+// - v2.x Standard Capacity
+// - v2.x High Capacity
+// - Not recognised as an SD Card
+
+#define SDCARD_FAIL 0
+#define SDCARD_V1 1
+#define SDCARD_V2 2
+#define SDCARD_V2HC 3
+
+int SDFileSystem::initialise_card() {
+ // Set to 100kHz for initialisation, and clock card with cs = 1
+ _spi.frequency(100000);
+ _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) != R1_IDLE_STATE) {
+ fprintf(stderr, "No disk, or could not put SD card in to SPI idle state\n");
+ return SDCARD_FAIL;
+ }
+
+ // send CMD8 to determine whther it is ver 2.x
+ int r = _cmd8();
+ if(r == R1_IDLE_STATE) {
+ return initialise_card_v2();
+ } else if(r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND)) {
+ return initialise_card_v1();
+ } else {
+ fprintf(stderr, "Not in idle state after sending CMD8 (not an SD card?)\n");
+ return SDCARD_FAIL;
+ }
+}
+
+int SDFileSystem::initialise_card_v1() {
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ _cmd(55, 0);
+ if(_cmd(41, 0) == 0) {
+ cdv = 512;
+ #ifdef DEBUG
+ printf("\n\rInit: SEDCARD_V1\n\r");
+ #endif
+ return SDCARD_V1;
+ }
+ }
+
+ fprintf(stderr, "Timeout waiting for v1.x card\n");
+ return SDCARD_FAIL;
+}
+
+int SDFileSystem::initialise_card_v2() {
+
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ wait_ms(50);
+ _cmd58();
+ _cmd(55, 0);
+ if(_cmd(41, 0x40000000) == 0) {
+ _cmd58();
+ #ifdef DEBUG
+ printf("\n\rInit: SDCARD_V2\n\r");
+ #endif
+ cdv = 1;
+ return SDCARD_V2;
+ }
+ }
+
+ fprintf(stderr, "Timeout waiting for v2.x card\n");
+ return SDCARD_FAIL;
+}
+
+int SDFileSystem::disk_initialize() {
+
+ int i = initialise_card();
+ #ifdef DEBUG
+ printf("init card = %d\n", i);
+ #endif
+ _sectors = _sd_sectors();
+
+ // Set block length to 512 (CMD16)
+ if(_cmd(16, 512) != 0) {
+ fprintf(stderr, "Set 512-byte block timed out\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 * cdv) != 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 * cdv) != 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::_cmdx(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)) {
+ return response;
+ }
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return -1; // timeout
+}
+
+
+int SDFileSystem::_cmd58() {
+ _cs = 0;
+ int arg = 0;
+
+ // send a command
+ _spi.write(0x40 | 58);
+ _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)) {
+ int ocr = _spi.write(0xFF) << 24;
+ ocr |= _spi.write(0xFF) << 16;
+ ocr |= _spi.write(0xFF) << 8;
+ ocr |= _spi.write(0xFF) << 0;
+// printf("OCR = 0x%08X\n", ocr);
+ _cs = 1;
+ _spi.write(0xFF);
+ return response;
+ }
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return -1; // timeout
+}
+
+int SDFileSystem::_cmd8() {
+ _cs = 0;
+
+ // send a command
+ _spi.write(0x40 | 8); // CMD8
+ _spi.write(0x00); // reserved
+ _spi.write(0x00); // reserved
+ _spi.write(0x01); // 3.3v
+ _spi.write(0xAA); // check pattern
+ _spi.write(0x87); // crc
+
+ // wait for the repsonse (response[7] == 0)
+ for(int i=0; i<SD_COMMAND_TIMEOUT * 1000; i++) {
+ char response[5];
+ response[0] = _spi.write(0xFF);
+ if(!(response[0] & 0x80)) {
+ for(int j=1; j<5; j++) {
+ response[i] = _spi.write(0xFF);
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return response[0];
+ }
+ }
+ _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() {
+
+ int c_size, c_size_mult, read_bl_len;
+ int block_len, mult, blocknr, capacity;
+ int blocks, hc_c_size;
+ uint64_t hc_capacity;
+
+ // CMD9, Response R2 (R1 byte + 16-byte block read)
+ if(_cmdx(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] - the *maximum* read block length
+
+ int csd_structure = ext_bits(csd, 127, 126);
+
+ #ifdef DEBUG
+ printf("\n\rCSD_STRUCT = %d\n", csd_structure);
+ #endif
+
+ switch (csd_structure){
+ case 0:
+ cdv = 512;
+ c_size = ext_bits(csd, 73, 62);
+ c_size_mult = ext_bits(csd, 49, 47);
+ read_bl_len = ext_bits(csd, 83, 80);
+
+ block_len = 1 << read_bl_len;
+ mult = 1 << (c_size_mult + 2);
+ blocknr = (c_size + 1) * mult;
+ capacity = blocknr * block_len;
+ blocks = capacity / 512;
+ #ifdef DEBUG
+ printf("\n\rSDCard\n\rc_size: %.4X \n\rcapacity: %.ld \n\rsectors: %d\n\r", c_size, capacity, blocks);
+ #endif
+ break;
+
+ case 1:
+ cdv = 1;
+ hc_c_size = ext_bits(csd, 63, 48);
+ int hc_read_bl_len = ext_bits(csd, 83, 80);
+ hc_capacity = hc_c_size+1;
+ blocks = (hc_c_size+1)*1024;
+ #ifdef DEBUG
+ printf("\n\rSDHC Card \n\rhc_c_size: %.4X \n\rcapacity: %.lld \n\rsectors: %d\n\r", hc_c_size, hc_capacity*512*1024, blocks);
+ #endif
+ break;
+
+ default:
+ fprintf(stderr, "This disk tastes funny! I only know about type 0 CSD structures\n");
+ return 0;
+ // break;
+ };
+ return blocks;
+}
diff -r 000000000000 -r f61e8db0570d SDHCFileSystem.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SDHCFileSystem.h Sat Aug 14 10:33:13 2010 +0000
@@ -0,0 +1,86 @@
+/* mbed SDFileSystem Library, for providing file access to SD cards
+ * Copyright (c) 2008-2010, sford
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MBED_SDHCFILESYSTEM_H
+#define MBED_SDHCFILESYSTEM_H
+
+#include "mbed.h"
+#include "FATFileSystem.h"
+
+/* Double Words */
+typedef unsigned long long uint64_t;
+typedef long long sint64_t;
+
+/** Access the filesystem on an SD Card using SPI
+ *
+ * @code
+ * #include "mbed.h"
+ * #include "SDFileSystem.h"
+ *
+ * SDFileSystem sd(p5, p6, p7, p12, "sd"); // mosi, miso, sclk, cs
+ *
+ * int main() {
+ * FILE *fp = fopen("/sd/myfile.txt", "w");
+ * fprintf(fp, "Hello World!\n");
+ * fclose(fp);
+ * }
+ */
+class SDFileSystem : public FATFileSystem {
+public:
+
+ /** Create the File System for accessing an SD Card using SPI
+ *
+ * @param mosi SPI mosi pin connected to SD Card
+ * @param miso SPI miso pin conencted to SD Card
+ * @param sclk SPI sclk pin connected to SD Card
+ * @param cs DigitalOut pin used as SD Card chip select
+ * @param name The name used to access the virtual 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 _cmdx(int cmd, int arg);
+ int _cmd8();
+ int _cmd58();
+ int initialise_card();
+ int initialise_card_v1();
+ int initialise_card_v2();
+
+ int _read(char *buffer, int length);
+ int _write(const char *buffer, int length);
+ int _sd_sectors();
+ int _sectors;
+
+ SPI _spi;
+ DigitalOut _cs;
+ int cdv;
+};
+
+#endif
diff -r 000000000000 -r f61e8db0570d main.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Sat Aug 14 10:33:13 2010 +0000
@@ -0,0 +1,291 @@
+/* EA_BigBen
+
+ Just for fun this turns the Embedded Artists LPCXpresso baseboard into a Big Ben substitute.
+
+ Well OK it is a little smaller and the sound is a little tinnier than the real thing but it works.
+
+ This pulls together the following test programs for the Embedded Artists LPCXpresso baseboard:
+
+ EA_InternetClock (now superseded by this program)
+ EA_WavPlayer
+ EA_DownloadToSD
+
+ The program displays the day, date and time on the baseboard OLED and sounds the Big Ben chimes
+ on the hour and quarter hour.
+
+ On initial startup the program checks that the mbed clock is set and that the wav files can be accessed
+ on the SD card. If not it asks to be connected to the internet to obtain the current time and to download
+ the wav files to the SD card.
+
+ The wav file player works with uncompressed wav files with 8 or 16 bit sample sizes.
+
+ Setup of the baseboard:
+
+ Please set all jumpers on board to the default case except for
+ the following:
+
+ Audio setup:
+
+ 1. Insert a jumper in J31 to connect signal PIO1_2 to the low
+ pass filer as described in section 4.7.2. of base board users
+ guide.
+
+ 2. Insert three jumpers in J33 to connect PIO3_0, PIO3_1 and
+ PIO3_2 to control the amplifier as described in section 4.8
+ of base board users guide.
+
+ 3. Insert a jumper in J32 and remove any from J34 to use the
+ internal speaker as described in section 4.8
+ of base board users guide.
+
+ SD Card setup:
+
+ 4. Insert all five jumpers in J39 as described in section 4.3.3
+ of base board users guide.
+
+ 5. Remove jumper marked "A" in J55 In order to connect PIO1_11
+ to CS signal of J40 (the SPI-SSEL signal) as described in section 4.3.3
+ of base board users guide.
+
+ OLED setup:
+
+ 1. The LCPXpresso board does not provide the data/command signal to the mbed.
+ To provide this signal please connect a jumper wire from PIO2_7 of baseboard mbed socket
+ (empty 2nd hole below mbed pin 21) to to PIO2_5 (on J6 right side ninth hole from bottom).
+
+*/
+
+#include "mbed.h"
+#include "wavplayer.h"
+#include "SDHCFileSystem.h"
+#include "EthernetNetIf.h"
+#include "NTPClient.h"
+#include "EAOLED.h"
+#include "HTTPClient.h"
+
+int debug = 0;
+
+EthernetNetIf eth;
+NTPClient ntp;
+HTTPClient http;
+
+int ethernetUp = 0;//flag ethernet status 1 = up 0 = down
+
+WavPlayer myWavPlayer;
+
+EAOLED oled(p5, p21, p7, p8, p25); // mosi, dnc, sclk, cs, power
+
+SDFileSystem sd(p5, p6, p7, p24, "sd");//mosi, miso, sclk, cs, name
+
+DigitalOut led1(LED1);
+//DigitalOut led2(LED2);
+//DigitalOut led3(LED3);
+DigitalOut led4(LED4);
+
+Ticker secTicker;
+Ticker blink;
+
+int hour, minute, second, bongCount;
+
+char day[12];
+char dmy[12];
+char hms[12];
+
+
+void startUpMsgToOLED() {
+ oled.cls();
+ oled.locate(0,1);
+ oled.printf(" mbed clock\n");
+ oled.locate(0,3);
+ oled.printf(" connect\n");
+ oled.locate(0,5);
+ oled.printf(" ethernet\n");
+ oled.locate(0,7);
+ oled.printf(" to start..\n");
+}
+
+//sets up ethernet connection only once
+void ethernetSetup() {
+ if (!ethernetUp) {
+ printf("Connecting to network ...\r\n");
+ EthernetErr ethErr = eth.setup();
+ if (ethErr) {
+ printf("Error %d in setup.\r\n", ethErr);
+ }
+ printf("Network interface is up\r\n");
+ ethernetUp = 1;
+ }
+}
+
+//blinks led4 during download
+void blinkLED4() {
+ led4 = !led4;
+}
+
+void downloadFileToSD(char *url, char *path) {
+ oled.cls();
+ oled.locate(0,1);
+ oled.printf("Downloading\n");
+ oled.locate(0,3);
+ oled.printf(" Wav files\n");
+ oled.locate(0,5);
+ oled.printf("Please wait\n");
+
+ HTTPFile httpfile(path);
+
+ printf("Downloading to ");
+ printf("%s", path);
+ printf(" please wait ... \r\n");
+
+ blink.attach(& blinkLED4, 0.5);
+
+ HTTPResult result = http.get(url, &httpfile);
+
+ if (result == HTTP_OK) {
+ printf("File downloaded OK\r\n");
+ } else {
+ printf("Error during download %d\r\n", result);
+ }
+
+ blink.detach();
+
+ led4 = 0;
+}
+
+void downloadFiles() {
+
+ ethernetSetup();
+
+ printf("\r\n----------- Starting file download ------------\r\n");
+
+ downloadFileToSD("http://homepage.ntlworld.com/green_bean/mbed/bong.wav", "/sd/bong.wav" );
+ downloadFileToSD("http://homepage.ntlworld.com/green_bean/mbed/quarter.wav", "/sd/quarter.wav" );
+ downloadFileToSD("http://homepage.ntlworld.com/green_bean/mbed/hour.wav", "/sd/hour.wav" );
+
+ printf("-------------- Files downloaded ------------\r\n");
+
+}
+
+void checkChimeWavFilesExist() {
+ int filesExist = 1;//default exist
+ FILE *fp1 = fopen("/sd/bong.wav", "rb");
+ if (fp1 == NULL) {
+ filesExist = 0;
+ } else fclose(fp1);
+ FILE *fp2 = fopen("/sd/quarter.wav", "rb");
+ if (fp2 == NULL) {
+ filesExist = 0;
+ } else fclose(fp2);
+ FILE *fp3 = fopen("/sd/hour.wav", "rb");
+ if (fp3 == NULL) {
+ filesExist = 0;
+ } else fclose(fp3);
+
+ if (!filesExist) downloadFiles();
+}
+
+void setmbedClock() {
+
+ startUpMsgToOLED();
+ printf("Setting mbed clock\r\n");
+
+ ethernetSetup();
+
+ printf("Connecting to time server...\r\n");
+
+ Host server(IpAddr(), 123, "0.uk.pool.ntp.org");
+ ntp.setTime(server);
+
+ printf("Time updated\r\n");
+ oled.cls();
+}
+
+void updateTimeDisplay() {
+
+ time_t seconds;
+ seconds = time(NULL);
+
+ struct tm *timeStruct = localtime(&seconds);
+
+ if (timeStruct->tm_isdst) {//daylight savings is on add one hour
+ seconds+=3600;
+ tm *timeStruct = localtime(&seconds);
+ }
+
+ strftime(day,sizeof(day)," %A ", timeStruct);//localtime(&seconds));
+ strftime(dmy,sizeof(dmy),"%d/%m/%Y", timeStruct);//localtime(&seconds));
+ strftime(hms,sizeof(hms),"%H:%M:%S", timeStruct);//localtime(&seconds));
+
+ //global hour, minute & second used in main() to set chimes
+ hour = timeStruct->tm_hour;
+ minute = timeStruct->tm_min;
+ second = timeStruct->tm_sec;
+
+ if (debug == 1) printf("%s %s %s\r\n", hms,day,dmy);
+
+ oled.locate((12-strlen(day))/2,1);
+ oled.printf("%s", day);
+ oled.locate((12-strlen(hms))/2,4);
+ oled.printf("%s", hms);
+ oled.locate((12-strlen(dmy))/2,7);
+ oled.printf("%s", dmy);
+
+}
+
+void checkIfChimesRequired() {
+
+ //check if time to sound hour
+ if (minute == 59 && second == 34) {
+ second ++; // ensure does not reenter this before updateTime
+ secTicker.detach();
+ myWavPlayer.play_wave("/sd/hour.wav");
+ secTicker.attach(& updateTimeDisplay, 1);
+ bongCount = (hour % 12) + 1; // No. bongs to count the hours
+ //check if time to sound quarter hour
+ } else if (minute % 15 == 0 && second == 0 ) { // will not strike on hour as caught above
+ second ++; // ensure does not reenter this before updateTime
+ secTicker.detach();
+ myWavPlayer.play_wave("/sd/quarter.wav");
+ secTicker.attach(& updateTimeDisplay, 1);
+ //check if time for next hour bong
+ } else if (bongCount > 0 && second % 5 == 0) {
+ second ++; // ensure does not reenter this before updateTime
+ secTicker.detach();
+ myWavPlayer.play_wave("/sd/bong.wav");
+ bongCount --;
+ secTicker.attach(& updateTimeDisplay, 1);
+ }
+}
+
+int main() {
+
+ printf("\r\n------ Starting Big Ben -------\r\n");
+
+ startUpMsgToOLED();
+
+ //Check if chime wav files are on SD card if not download them
+ checkChimeWavFilesExist();
+
+ //Check if clock already set if < year 1990 assume needs setting
+ time_t seconds = time(NULL);
+ if (seconds < 630720000) {
+ setmbedClock();
+ }
+ oled.cls();
+
+
+ // starting ticker to update time display once per second
+ secTicker.attach(& updateTimeDisplay, 1);
+
+ // On startup the quarter hour chime will play to ensure the SD card can be read
+ // if you do not want this to happen remove the comment from the following line
+ // second = 1; // so does not sound the quarter hour on first start
+
+ while (1) {
+
+ checkIfChimesRequired();
+
+ wait(0.1);
+ }
+
+}
diff -r 000000000000 -r f61e8db0570d mbed.bld --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Sat Aug 14 10:33:13 2010 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed/builds/9114680c05da
diff -r 000000000000 -r f61e8db0570d wavplayer.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wavplayer.cpp Sat Aug 14 10:33:13 2010 +0000
@@ -0,0 +1,152 @@
+/*
+ Library wave file player by Tom Coxon
+
+ Based on WAVEplayer by Vlad Cazan/Stephan Rochon modified by Tom Coxon to:
+
+ 1. Run correctly on the Embedded Artists LPCXpresso baseboard.
+ 2. To play 8 bit sample size in addition to original 16 bit
+ 3. To be more fault tolerant when playing wav files.
+*/
+
+#include "wavplayer.h"
+
+Ticker tick;
+
+AnalogOut DACout(p18);
+
+void WavPlayer::dac_out() {
+ if (DAC_on) {
+ DACout.write_u16(DAC_fifo[DAC_rptr]);
+ DAC_rptr=(DAC_rptr+1) & 0xff;
+ }
+}
+
+//void play_wave(char *wavname) {
+void WavPlayer::play_wave(char *wavname) {
+ unsigned chunk_id,chunk_size,channel;
+ unsigned data,samp_int,i;
+ short dac_data;
+ char *slice_buf;
+ short *data_sptr;
+ FMT_STRUCT wav_format;
+ FILE *wavfile;
+ long slice,num_slices;
+ DAC_wptr=0;
+ DAC_rptr=0;
+
+ size_t result;
+
+ for (i=0;i<256;i+=2) {
+ DAC_fifo[i]=0;
+ DAC_fifo[i+1]=3000;
+ }
+ DAC_wptr=4;
+ DAC_on=0;
+
+ printf("Playing wave file '%s'\r\n",wavname);
+
+ wavfile=fopen(wavname,"rb");
+ if (!wavfile) {
+ printf("Unable to open wav file '%s'\r\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\r\n",chunk_id,chunk_size);
+ switch (chunk_id) {
+ case 0x46464952:
+ fread(&data,4,1,wavfile);
+ printf("RIFF chunk\r\n");
+ printf(" chunk size %d (0x%x)\r\n",chunk_size,chunk_size);
+ printf(" RIFF type 0x%x\r\n",data);
+ break;
+ case 0x20746d66:
+ fread(&wav_format,sizeof(wav_format),1,wavfile);
+ printf("FORMAT chunk\r\n");
+ printf(" chunk size %d (0x%x)\r\n",chunk_size,chunk_size);
+ printf(" compression code %d\r\n",wav_format.comp_code);
+ printf(" %d channels\r\n",wav_format.num_channels);
+ printf(" %d samples/sec\r\n",wav_format.sample_rate);
+ printf(" %d bytes/sec\r\n",wav_format.avg_Bps);
+ printf(" block align %d\r\n",wav_format.block_align);
+ printf(" %d bits per sample\r\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\r\n");
+ printf(" chunk size %d (0x%x)\r\n",chunk_size,chunk_size);
+ printf(" %d slices\r\n",num_slices);
+ printf(" Ideal sample interval=%d\r\n",(unsigned)(1000000.0/wav_format.sample_rate));
+ samp_int=1000000/(wav_format.sample_rate);
+ printf(" programmed interrupt tick interval=%d\r\n",samp_int);
+
+// starting up ticker to write samples out -- no printfs until tick.detach is called
+ tick.attach_us(this,&WavPlayer::dac_out, samp_int);
+ DAC_on=1;
+ for (slice=0;slice<num_slices;slice+=SLICE_BUF_SIZE) {
+
+ result = fread(slice_buf,wav_format.block_align*SLICE_BUF_SIZE,1,wavfile);
+ if (feof(wavfile)) {
+ printf("Oops -- not enough slices in the wave file\r\n");
+ if (result) ;//just to stop compiler complaining that we have not used result
+ break;
+ }
+
+ 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 );
+ break;
+ case 8:
+ dac_data+=( ((int)(*data_sptr++)) +32768 <<8);
+ break;
+ }
+ }
+ DAC_fifo[DAC_wptr]=dac_data;
+ DAC_wptr=(DAC_wptr+1) & 0xff;
+ while (DAC_wptr==DAC_rptr) {
+ wait_us(10);
+ }
+ }
+ }
+ DAC_on=0;
+ tick.detach();
+ printf("Ticker detached\r\n");
+ free(slice_buf);
+ break;
+ case 0x5453494c:
+ printf("INFO chunk, size %d\r\n",chunk_size);
+ fseek(wavfile,chunk_size,SEEK_CUR);
+ break;
+ default:
+ printf("unknown chunk type 0x%x, size %d\r\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 ++++++++++\r\n");
+ fclose(wavfile);
+}
+
diff -r 000000000000 -r f61e8db0570d wavplayer.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wavplayer.h Sat Aug 14 10:33:13 2010 +0000
@@ -0,0 +1,51 @@
+/*
+ Library wave file player by Tom Coxon
+
+ Based on WAVEplayer by Vlad Cazan/Stephan Rochon modified by Tom Coxon to:
+
+ 1. Run correctly on the Embedded Artists LPCXpresso baseboard.
+ 2. To play 8 bit sample size in addition to original 16 bit
+ 3. To be more fault tolerant when playing wav files.
+*/
+
+#ifndef WAVPLAYER_H
+#define WAVPLAYER_H
+
+#include "mbed.h"
+
+#define SAMPLE_FREQ 40000
+#define BUF_SIZE (SAMPLE_FREQ/10)
+#define SLICE_BUF_SIZE 1
+
+typedef struct uFMT_STRUCT {
+ short comp_code;
+ short num_channels;
+ unsigned sample_rate;
+ unsigned avg_Bps;
+ short block_align;
+ short sig_bps;
+} FMT_STRUCT;
+
+class WavPlayer {
+
+public:
+
+ void play_wave(char *wavname);
+
+private:
+
+ 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;
+
+ void dac_out();
+
+};
+
+#endif