mirror of
https://github.com/arabine/open-story-teller.git
synced 2025-12-06 17:09:06 +01:00
347 lines
11 KiB
C++
347 lines
11 KiB
C++
/*
|
|
This reads a wave file from an SD card and plays it using the I2S interface to
|
|
a MAX08357 I2S Amp Breakout board.
|
|
|
|
Circuit:
|
|
* Arduino/Genuino Zero, MKRZero or MKR1000 board
|
|
* SD breakout or shield connected
|
|
* MAX08357:
|
|
* GND connected GND
|
|
* VIN connected 5V
|
|
* LRC connected to pin 0 (Zero) or pin 3 (MKR1000, MKRZero)
|
|
* BCLK connected to pin 1 (Zero) or pin 2 (MKR1000, MKRZero)
|
|
* DIN connected to pin 9 (Zero) or pin A6 (MKR1000, MKRZero)
|
|
|
|
created 15 November 2016
|
|
by Sandeep Mistry
|
|
*/
|
|
|
|
#include <SdFat.h>
|
|
#include <ArduinoSound.h>
|
|
|
|
// filename of wave file to play
|
|
const char filename[] = "castemere_mono.wav";
|
|
|
|
// SD_FAT_TYPE = 0 for SdFat/File as defined in SdFatConfig.h,
|
|
// 1 for FAT16/FAT32, 2 for exFAT, 3 for FAT16/FAT32 and exFAT.
|
|
#define SD_FAT_TYPE 2
|
|
//
|
|
// Set DISABLE_CHIP_SELECT to disable a second SPI device.
|
|
// For example, with the Ethernet shield, set DISABLE_CHIP_SELECT
|
|
// to 10 to disable the Ethernet controller.
|
|
const int8_t DISABLE_CHIP_SELECT = -1;
|
|
//
|
|
// Test with reduced SPI speed for breadboards. SD_SCK_MHZ(4) will select
|
|
// the highest speed supported by the board that is not over 4 MHz.
|
|
// Change SPI_SPEED to SD_SCK_MHZ(50) for best performance.
|
|
#define SPI_SPEED SD_SCK_MHZ(24)
|
|
//------------------------------------------------------------------------------
|
|
|
|
SdFat sd;
|
|
// SD card chip select
|
|
int chipSelect = 28;
|
|
|
|
// variable representing the Wave File
|
|
SDWaveFile waveFile(sd, filename);
|
|
|
|
void setup() {
|
|
// Open serial communications and wait for port to open:
|
|
Serial.begin(9600);
|
|
while (!Serial) {
|
|
; // wait for serial port to connect. Needed for native USB port only
|
|
}
|
|
|
|
if (!sd.begin(chipSelect, SPI_SPEED)) {
|
|
if (sd.card()->errorCode()) {
|
|
Serial.println("SD initialization failed.");
|
|
// cout << F(
|
|
// "\nSD initialization failed.\n"
|
|
// "Do not reformat the card!\n"
|
|
// "Is the card correctly inserted?\n"
|
|
// "Is chipSelect set to the correct value?\n"
|
|
// "Does another SPI device need to be disabled?\n"
|
|
// "Is there a wiring/soldering problem?\n");
|
|
// cout << F("\nerrorCode: ") << hex << showbase;
|
|
// cout << int(sd.card()->errorCode());
|
|
// cout << F(", errorData: ") << int(sd.card()->errorData());
|
|
// cout << dec << noshowbase << endl;
|
|
return;
|
|
}
|
|
Serial.println("Card successfully initialized.");
|
|
if (sd.vol()->fatType() == 0) {
|
|
Serial.println("Can't find a valid FAT16/FAT32 partition.");
|
|
return;
|
|
}
|
|
Serial.println("Can't determine error type.");
|
|
return;
|
|
}
|
|
|
|
// check if the WaveFile is valid
|
|
if (!waveFile) {
|
|
Serial.println("wave file is invalid!");
|
|
while (1); // do nothing
|
|
}
|
|
|
|
// print out some info. about the wave file
|
|
Serial.print("Bits per sample = ");
|
|
Serial.println(waveFile.bitsPerSample());
|
|
|
|
long channels = waveFile.channels();
|
|
Serial.print("Channels = ");
|
|
Serial.println(channels);
|
|
|
|
long sampleRate = waveFile.sampleRate();
|
|
Serial.print("Sample rate = ");
|
|
Serial.print(sampleRate);
|
|
Serial.println(" Hz");
|
|
|
|
long duration = waveFile.duration();
|
|
Serial.print("Duration = ");
|
|
Serial.print(duration);
|
|
Serial.println(" seconds");
|
|
|
|
// adjust the playback volume
|
|
AudioOutI2S.volume(5);
|
|
|
|
// check if the I2S output can play the wave file
|
|
if (!AudioOutI2S.canPlay(waveFile)) {
|
|
Serial.println("unable to play wave file using I2S!");
|
|
while (1); // do nothing
|
|
}
|
|
|
|
// start playback
|
|
Serial.println("starting playback");
|
|
AudioOutI2S.play(waveFile);
|
|
}
|
|
|
|
void loop() {
|
|
// check if playback is still going on
|
|
if (!AudioOutI2S.isPlaying()) {
|
|
// playback has stopped
|
|
|
|
Serial.println("playback stopped");
|
|
while (1); // do nothing
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
|
|
// ============================================ SD EXAMPLE
|
|
|
|
// Quick hardware test for SPI card access.
|
|
//
|
|
#include <SPI.h>
|
|
#include "SdFat.h"
|
|
#include "sdios.h"
|
|
|
|
// SD_FAT_TYPE = 0 for SdFat/File as defined in SdFatConfig.h,
|
|
// 1 for FAT16/FAT32, 2 for exFAT, 3 for FAT16/FAT32 and exFAT.
|
|
#define SD_FAT_TYPE 2
|
|
//
|
|
// Set DISABLE_CHIP_SELECT to disable a second SPI device.
|
|
// For example, with the Ethernet shield, set DISABLE_CHIP_SELECT
|
|
// to 10 to disable the Ethernet controller.
|
|
const int8_t DISABLE_CHIP_SELECT = -1;
|
|
//
|
|
// Test with reduced SPI speed for breadboards. SD_SCK_MHZ(4) will select
|
|
// the highest speed supported by the board that is not over 4 MHz.
|
|
// Change SPI_SPEED to SD_SCK_MHZ(50) for best performance.
|
|
#define SPI_SPEED SD_SCK_MHZ(24)
|
|
//------------------------------------------------------------------------------
|
|
#if SD_FAT_TYPE == 0
|
|
SdFat sd;
|
|
File file;
|
|
#elif SD_FAT_TYPE == 1
|
|
SdFat32 sd;
|
|
File32 file;
|
|
#elif SD_FAT_TYPE == 2
|
|
SdExFat sd;
|
|
ExFile file;
|
|
#elif SD_FAT_TYPE == 3
|
|
SdFs sd;
|
|
FsFile file;
|
|
#else // SD_FAT_TYPE
|
|
#error Invalid SD_FAT_TYPE
|
|
#endif // SD_FAT_TYPE
|
|
// Serial streams
|
|
ArduinoOutStream cout(Serial);
|
|
|
|
// input buffer for line
|
|
char cinBuf[40];
|
|
ArduinoInStream cin(Serial, cinBuf, sizeof(cinBuf));
|
|
|
|
// SD card chip select
|
|
int chipSelect = 28;
|
|
|
|
void cardOrSpeed() {
|
|
cout << F("Try another SD card or reduce the SPI bus speed.\n");
|
|
cout << F("Edit SPI_SPEED in this program to change it.\n");
|
|
}
|
|
|
|
void reformatMsg() {
|
|
cout << F("Try reformatting the card. For best results use\n");
|
|
cout << F("the SdFormatter program in SdFat/examples or download\n");
|
|
cout << F("and use SDFormatter from www.sdcard.org/downloads.\n");
|
|
}
|
|
|
|
void setup() {
|
|
Serial.begin(115200);
|
|
|
|
// Wait for USB Serial
|
|
while (!Serial) {
|
|
SysCall::yield();
|
|
}
|
|
cout << F("\nSPI pins:\n");
|
|
cout << F("MISO: ") << int(MISO) << endl;
|
|
cout << F("MOSI: ") << int(MOSI) << endl;
|
|
cout << F("SCK: ") << int(SCK) << endl;
|
|
cout << F("SS: ") << int(SS) << endl;
|
|
#ifdef SDCARD_SS_PIN
|
|
cout << F("SDCARD_SS_PIN: ") << int(SDCARD_SS_PIN) << endl;
|
|
#endif // SDCARD_SS_PIN
|
|
|
|
if (DISABLE_CHIP_SELECT < 0) {
|
|
cout << F(
|
|
"\nBe sure to edit DISABLE_CHIP_SELECT if you have\n"
|
|
"a second SPI device. For example, with the Ethernet\n"
|
|
"shield, DISABLE_CHIP_SELECT should be set to 10\n"
|
|
"to disable the Ethernet controller.\n");
|
|
}
|
|
cout << F(
|
|
"\nSD chip select is the key hardware option.\n"
|
|
"Common values are:\n"
|
|
"Arduino Ethernet shield, pin 4\n"
|
|
"Sparkfun SD shield, pin 8\n"
|
|
"Adafruit SD shields and modules, pin 10\n");
|
|
}
|
|
|
|
bool firstTry = true;
|
|
void loop() {
|
|
// Read any existing Serial data.
|
|
do {
|
|
delay(10);
|
|
} while (Serial.available() && Serial.read() >= 0);
|
|
|
|
if (!firstTry) {
|
|
cout << F("\nRestarting\n");
|
|
}
|
|
firstTry = false;
|
|
|
|
|
|
// cout << F("\nEnter the chip select pin number: ");
|
|
// while (!Serial.available()) {
|
|
// SysCall::yield();
|
|
// }
|
|
// cin.readline();
|
|
// if (cin >> chipSelect) {
|
|
// cout << chipSelect << endl;
|
|
// } else {
|
|
// cout << F("\nInvalid pin number\n");
|
|
// return;
|
|
// }
|
|
|
|
|
|
if (DISABLE_CHIP_SELECT < 0) {
|
|
cout << F(
|
|
"\nAssuming the SD is the only SPI device.\n"
|
|
"Edit DISABLE_CHIP_SELECT to disable another device.\n");
|
|
} else {
|
|
cout << F("\nDisabling SPI device on pin ");
|
|
cout << int(DISABLE_CHIP_SELECT) << endl;
|
|
pinMode(DISABLE_CHIP_SELECT, OUTPUT);
|
|
digitalWrite(DISABLE_CHIP_SELECT, HIGH);
|
|
}
|
|
if (!sd.begin(chipSelect, SPI_SPEED)) {
|
|
if (sd.card()->errorCode()) {
|
|
cout << F(
|
|
"\nSD initialization failed.\n"
|
|
"Do not reformat the card!\n"
|
|
"Is the card correctly inserted?\n"
|
|
"Is chipSelect set to the correct value?\n"
|
|
"Does another SPI device need to be disabled?\n"
|
|
"Is there a wiring/soldering problem?\n");
|
|
cout << F("\nerrorCode: ") << hex << showbase;
|
|
cout << int(sd.card()->errorCode());
|
|
cout << F(", errorData: ") << int(sd.card()->errorData());
|
|
cout << dec << noshowbase << endl;
|
|
return;
|
|
}
|
|
cout << F("\nCard successfully initialized.\n");
|
|
if (sd.vol()->fatType() == 0) {
|
|
cout << F("Can't find a valid FAT16/FAT32 partition.\n");
|
|
reformatMsg();
|
|
return;
|
|
}
|
|
cout << F("Can't determine error type\n");
|
|
return;
|
|
}
|
|
cout << F("\nCard successfully initialized.\n");
|
|
cout << endl;
|
|
|
|
uint32_t size = sd.card()->sectorCount();
|
|
if (size == 0) {
|
|
cout << F("Can't determine the card size.\n");
|
|
cardOrSpeed();
|
|
return;
|
|
}
|
|
uint32_t sizeMB = 0.000512 * size + 0.5;
|
|
cout << F("Card size: ") << sizeMB;
|
|
cout << F(" MB (MB = 1,000,000 bytes)\n");
|
|
cout << endl;
|
|
cout << F("Volume is FAT") << int(sd.vol()->fatType());
|
|
cout << F(", Cluster size (bytes): ") << sd.vol()->bytesPerCluster();
|
|
cout << endl << endl;
|
|
|
|
cout << F("Files found (date time size name):\n");
|
|
sd.ls(LS_R | LS_DATE | LS_SIZE);
|
|
|
|
if ((sizeMB > 1100 && sd.vol()->sectorsPerCluster() < 64)
|
|
|| (sizeMB < 2200 && sd.vol()->fatType() == 32)) {
|
|
cout << F("\nThis card should be reformatted for best performance.\n");
|
|
cout << F("Use a cluster size of 32 KB for cards larger than 1 GB.\n");
|
|
cout << F("Only cards larger than 2 GB should be formatted FAT32.\n");
|
|
reformatMsg();
|
|
return;
|
|
}
|
|
// Read any extra Serial data.
|
|
do {
|
|
delay(10);
|
|
} while (Serial.available() && Serial.read() >= 0);
|
|
cout << F("\nSuccess! Type any character to restart.\n");
|
|
while (!Serial.available()) {
|
|
SysCall::yield();
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
* EXEMPLE 1
|
|
|
|
#include "Arduino.h"
|
|
|
|
// the setup function runs once when you press reset or power the board
|
|
void setup() {
|
|
// initialize digital pin LED_BUILTIN as an output.
|
|
pinMode(0, OUTPUT);
|
|
|
|
SerialUSB.begin(9600);
|
|
}
|
|
|
|
// the loop function runs over and over again forever
|
|
void loop()
|
|
{
|
|
digitalWrite(0, HIGH); // turn the LED on (HIGH is the voltage level)
|
|
delay(1000); // wait for a second
|
|
digitalWrite(0, LOW); // turn the LED off by making the voltage LOW
|
|
delay(1000); // wait for a second
|
|
SerialUSB.println("Hello, Arduino!");
|
|
}
|
|
|
|
*/
|