void setup() { // set up Serial library at 9600 bps Serial.begin(9600); if (!card.init()) { error("Card init. failed!"); } if (!vol.init(card)) { error("No partition!"); } if (!root.openRoot(vol)) { error("Couldn't open dir"); } PgmPrintln("Files found:"); root.ls(); // declare the Pins pinMode(readyLEDPin, OUTPUT); // pinMode(blowLEDPin, OUTPUT); // pinMode(waitLEDPin, OUTPUT); pinMode(level0LEDPin, OUTPUT); pinMode(level1LEDPin, OUTPUT); pinMode(level2LEDPin, OUTPUT); pinMode(level3LEDPin, OUTPUT); pinMode(buttonPin, INPUT); initialButtonState = digitalRead(buttonPin); Serial.println("initial switch value= " + initialButtonState); ///***** set the char mode based on the pot position initialPot = analogRead(PotPin); Serial.println("initial pot value= " + initialPot); range = map(initialPot, 0, 1024, 0, 3); Serial.println("initial pot range is: " + range); switch (range) { case 0: // your hand is on the sensor mode = 0; Serial.println("initial mode set to 0: princess"); break; case 1: // your hand is close to the sensor mode = 1; Serial.println("initial mode set to 1: pirate"); break; case 2: // your hand is a few inches from the sensor mode = 2; Serial.println("initial mode set to 2: halloween"); break; case 3: // your hand is nowhere near the sensor mode = 3; Serial.println("initial mode set to 3: insult"); break; } }
/* * play recursively - possible stack overflow if subdirectories too nested */ void play(FatReader &dir) { FatReader file; while (dir.readDir(dirBuf) > 0) { // Read every file in the directory one at a time // Skip it if not a subdirectory and not a .WAV file if (!DIR_IS_SUBDIR(dirBuf) && strncmp_P((char *)&dirBuf.name[8], PSTR("WAV"), 3)) { continue; } Serial.println(); // clear out a new line for (uint8_t i = 0; i < dirLevel; i++) { Serial.write(' '); // this is for prettyprinting, put spaces in front } if (!file.open(vol, dirBuf)) { // open the file in the directory error("file.open failed"); // something went wrong } if (file.isDir()) { // check if we opened a new directory putstring("Subdir: "); printEntryName(dirBuf); Serial.println(); dirLevel += 2; // add more spaces // play files in subdirectory play(file); // recursive! dirLevel -= 2; } else { // Aha! we found a file that isnt a directory putstring("Playing "); printEntryName(dirBuf); // print it out if (!wave.create(file)) { // Figure out, is it a WAV proper? putstring(" Not a valid WAV"); // ok skip it } else { Serial.println(); // Hooray it IS a WAV proper! wave.play(); // make some noise! uint8_t n = 0; while (wave.isplaying) {// playing occurs in interrupts, so we print dots in realtime putstring("."); if (!(++n % 32))Serial.println(); delay(100); } sdErrorCheck(); // everything OK? // if (wave.errors)Serial.println(wave.errors); // wave decoding errors } } } }
//////////////////////////////////// SETUP void setup() { Serial.begin(9600); // set up Serial library at 9600 bps for debugging putstring_nl("\nWave test!"); // say we woke up! putstring("Free RAM: "); // This can help with debugging, running out of RAM is bad Serial.println(FreeRam()); // if (!card.init(true)) { //play with 4 MHz spi if 8MHz isn't working for you if (!card.init()) { //play with 8 MHz spi (default faster!) error("Card init. failed!"); // Something went wrong, lets print out why } // enable optimize read - some cards may timeout. Disable if you're having problems card.partialBlockRead(true); // Now we will look for a FAT partition! uint8_t part; for (part = 0; part < 5; part++) { // we have up to 5 slots to look in if (vol.init(card, part)) break; // we found one, lets bail } if (part == 5) { // if we ended up not finding one :( error("No valid FAT partition!"); // Something went wrong, lets print out why } // Lets tell the user about what we found putstring("Using partition "); Serial.print(part, DEC); putstring(", type is FAT"); Serial.println(vol.fatType(), DEC); // FAT16 or FAT32? // Try to open the root directory if (!root.openRoot(vol)) { error("Can't open root dir!"); // Something went wrong, } // Whew! We got past the tough parts. putstring_nl("Files found (* = fragmented):"); // Print out all of the files in all the directories. root.ls(LS_R | LS_FLAG_FRAGMENTED); }
int Jukebox2::fileCount(FatReader &dir){ //Serial.print("WTF!"); int count = 0; FatReader tempFile; dir_t dirBuf; // buffer for directory reads dir.rewind(); while (dir.readDir(dirBuf) > 0) { // Read every file in the directory one at a time //Serial.print("QQQ!"); // Skip it if not a subdirectory and not a .WAV file if (!DIR_IS_SUBDIR(dirBuf) && strncmp_P((char *)&dirBuf.name[8], PSTR("WAV"), 3)) { continue; } if (!tempFile.open(vol, dirBuf)) { // open the file in the directory Serial.print("file.open failed"); // something went wrong } if (tempFile.isDir()) { // check if we opened a new directory } else{ count++; } } dir.rewind(); Serial.print("Count was:"); Serial.println(count); return count; }
/* * Open and start playing a WAV file */ void playfile(char *name) { if (wave.isplaying) {// already playing something, so stop it! wave.stop(); // stop it } if (!file.open(root, name)) { PgmPrint("Couldn't open file "); Serial.print(name); return; } if (!wave.create(file)) { PgmPrintln("Not a valid WAV"); return; } // ok time to play! wave.play(); }
void Jukebox2::PlayRandomSound(FatReader &dir){ //Serial.print("OMG!"); int count = 0; FatReader tempFile; dir_t dirBuf; // buffer for directory reads int r = random(1,fileCount(dir)); dir.rewind(); while (dir.readDir(dirBuf) > 0) { // Read every file in the directory one at a time //Serial.print("LOL!"); //Serial.println(r); // Skip it if not a subdirectory and not a .WAV file if (!DIR_IS_SUBDIR(dirBuf) && strncmp_P((char *)&dirBuf.name[8], PSTR("WAV"), 3)) { continue; } if (!tempFile.open(vol, dirBuf)) { // open the file in the directory Serial.print("file.open failed"); // something went wrong } if (tempFile.isDir()) { // check if we opened a new directory } else { count++; if(count == r){ Serial.println("found a sound!"); PlaySound(dirBuf); dir.rewind(); return; } } } Serial.println("Never found a sound!"); Serial.print("Rand was:"); Serial.println(r); }
/** * Read a wave file's metadata and initialize member variables. * * \param[in] f A open FatReader instance for the wave file. * * \return The value one, true, is returned for success and * the value zero, false, is returned for failure. Reasons * for failure include I/O error, an invalid wave file or a wave * file with features that WaveHC does not support. */ uint8_t WaveHC::create(FatReader &f) { // 18 byte buffer // can use this since Arduino and RIFF are Little Endian union { struct { char id[4]; uint32_t size; char data[4]; } riff; // riff chunk struct { uint16_t compress; uint16_t channels; uint32_t sampleRate; uint32_t bytesPerSecond; uint16_t blockAlign; uint16_t bitsPerSample; uint16_t extraBytes; } fmt; // fmt data } buf; #if OPTIMIZE_CONTIGUOUS // set optimized read for contiguous files f.optimizeContiguous(); #endif // OPTIMIZE_CONTIGUOUS // must start with WAVE header if (f.read(&buf, 12) != 12 || strncmp(buf.riff.id, "RIFF", 4) || strncmp(buf.riff.data, "WAVE", 4)) { return false; } // next chunk must be fmt if (f.read(&buf, 8) != 8 || strncmp(buf.riff.id, "fmt ", 4)) { return false; } // fmt chunk size must be 16 or 18 uint16_t size = buf.riff.size; if (size == 16 || size == 18) { if (f.read(&buf, size) != (int16_t)size) { return false; } } else { // compressed data - force error buf.fmt.compress = 0; } if (buf.fmt.compress != 1 || (size == 18 && buf.fmt.extraBytes != 0)) { putstring_nl("Compression not supported"); return false; } Channels = buf.fmt.channels; if (Channels > 2) { putstring_nl("Not mono/stereo!"); return false; } else if (Channels > 1) { putstring_nl(" Warning stereo file!"); } BitsPerSample = buf.fmt.bitsPerSample; if (BitsPerSample > 16) { putstring_nl("More than 16 bits per sample!"); return false; } dwSamplesPerSec = buf.fmt.sampleRate; uint32_t clockRate = dwSamplesPerSec*Channels; uint32_t byteRate = clockRate*BitsPerSample/8; #if RATE_ERROR_LEVEL > 0 if (clockRate > MAX_CLOCK_RATE || byteRate > MAX_BYTE_RATE) { putstring_nl("Sample rate too high!"); if (RATE_ERROR_LEVEL > 1) { return false; } } else if (byteRate > 44100 && !f.isContiguous()) { putstring_nl("High rate fragmented file!"); if (RATE_ERROR_LEVEL > 1) { return false; } } #endif // RATE_ERROR_LEVEL > 0 fd = &f; errors = 0; isplaying = 0; remainingBytesInChunk = 0; #if DVOLUME volume = 0; #endif //DVOLUME // position to data return readWaveData(0, 0) < 0 ? false: true; }
//////////////////////////////////// LOOP void loop() { root.rewind(); play(root); }