예제 #1
0
파일: Tune.cpp 프로젝트: Snootlab/Tune
bool Tune::begin()
{
	// Pin configuration
	pinMode(DREQ, INPUT_PULLUP);
	pinMode(XDCS, OUTPUT);
	pinMode(XCS, OUTPUT);
	pinMode(SDCS, OUTPUT);
	
	// Deselect control & data ctrl
	digitalWrite(XCS, HIGH);
	digitalWrite(XDCS, HIGH);
	// Deselect SD's chip select
	digitalWrite(SDCS, HIGH);
	
	// SD card initialization
	if (!sd.begin(SDCS, SPI_HALF_SPEED))
	{
		sd.initErrorHalt(); // describe problem if there's one
		return 0; 
	}
	
	// Tracklisting also return the number of playable files
	Serial.print(listFiles());
	Serial.print(" tracks found, ");
	
	// SPI bus initialization
	SPI.begin();
	SPI.setDataMode(SPI_MODE0);
	// Both SCI and SDI read data MSB first
	SPI.setBitOrder(MSBFIRST);
	// From the datasheet, max SPI reads are CLKI/6. Here CLKI = 26MHz -> SPI max speed is 4.33MHz.
	// We'll take 16MHz/4 = 4MHz to be safe.
	// Plus it's the max recommended speed when using a resistor-based lvl converter with an SD card.
	SPI.setClockDivider(SPI_CLOCK_DIV4);
	SPI.transfer(0xFF);
	delay(10);
	
	// Codec initialization
	// Software reset
	setBit(SCI_MODE, SM_RESET);
	delay(5);
	// VS1022 "New mode" activation
	setBit(SCI_MODE, SM_SDINEW);
	// Clock setting (default is 24.576MHz)
	writeSCI(SCI_CLOCKF, 0x32, 0xC8);
	delay(5);
	
	// Wait until the chip is ready
	while (!digitalRead(DREQ));
	delay(100);
	
	// Set playState flag
	playState = idle;
	
	// Set volume to avoid hurt ears ;)
	setVolume(150);
	
	Serial.println("Tune ready !");
	return 1;
}
예제 #2
0
/**
 * Function starts the SD card service and makes sure that the appropriate directory
 * structure exists, then creates the file to use for logging data. Data will be logged
 * to a file called fileNamePrefix_0.csv or fileNamePrefix_0.bin (number will be incremented
 * for each new log file)
 *
 * @param chipSelectPin Arduino pin SD card reader CS pin is attached to
 * @param fileNamePrefix string to prefix at beginning of data file
 * @param csvData boolean flag whether we are writing csv data or binary data (used for filename)
 *
 * @return true if successful, false if failed
 */
bool beginDataLog(int chipSelectPin, const char *fileNamePrefix, bool csvData)
{
  bool ret;
  int i = 0;
  int max_len;
  char fileName[19];
  char prefix[8];
  char rootPath[] = "/data";


  if (_output_buffer != NULL) {
    delete []_output_buffer;
  }
  OUTPUT_BUF_SIZE = 512;
  _output_buffer = vol.cacheAddress()->output_buf;

  if (freeMemory() < 400) {
    strcpy_P(_getOutBuf(), sd_card_error);
    Serial.print(_getOutBuf());
    Serial.print(freeMemory());
    Serial.println(", need 400)");
    ret = false;
  } else {
    ret = sd.begin(chipSelectPin, SPI_FULL_SPEED);
  }

  //Filenames need to fit the 8.3 filename convention, so truncate down the
  //given filename if it is too long.
  memcpy(prefix, fileNamePrefix, 7);
  prefix[7] = '\0';

  if (ret) {
    if (!sd.exists(rootPath))
      ret = sd.mkdir(rootPath);
    if (ret) {
      while (true) {
	if (i < 10) {
	  max_len = 7;
	} else if (i < 100) {
	  max_len = 6;
	} else if (i < 1000) {
	  max_len = 5;
	} else {
	  break;
	}

	prefix[max_len - 1] = '\0';
	sprintf(fileName, "%s/%s%d.%s", rootPath, prefix, i,
		csvData ? "csv" : "bin");
	if (!sd.exists(fileName)) {
	  file = sd.open(fileName, FILE_WRITE);
	  break;
	}
	i++;
      }
    }
  }
  return file.isOpen();
}
예제 #3
0
void error(String message) {
  if(self.isInState(Start)) {
    sd.initErrorPrint(&terminal);
  } else {
    sd.errorPrint(&terminal);
  }
  terminal.flush();

  errorMessage = message;
  self.transitionTo(Error);
}
예제 #4
0
void fastLog(){
    if (blockNum == DATA_DIM-1){
        if (!sd.card()->isBusy()){
            if (!sd.card()->writeData((uint8_t*)&block)){
                error("fast write failed");
            }
            blockNum = 0;
        }
        else
            Serial.println("Card BUSY!");
    }
    else
        blockNum++;
}
예제 #5
0
void renderError() {
  Display.setTextColor(RED, BLACK);

  /***** Error Message *****/
  Display.setTextSize(1);
  Display.setCursor(1, 55);

  Display.println(errorMessage);

  if(self.isInState(Start)) {
    sd.initErrorPrint(&Display);
  } else {
    sd.errorPrint(&Display);
  }
}
예제 #6
0
void enterStart() {
  // Read configuration from Flash
  Time.zone(-6); // TODO: store in Flash and add configuration

  // Display splash screen
  Display.print("Mane Avis v");
  Display.println(MANE_AVIS_VERSION);
  Display.print("Firmware: ");
  Display.println(System.version());
  // TODO: display a real splash screen

  // Read alarms from SD card
  if(sd.exists(STORE)) {
    digitalWrite(D7, HIGH);
    if(!store.open(STORE, O_READ)) {
      error("Failed to open store");
      return;
    }

    String line;
    while((line = store.readStringUntil('\r')) != NULL) {
      alarms.add(line);
      store.read(); // clear '\n'
    }
  }

  store.close();
  digitalWrite(D7, LOW);
}
// Get the full path/filename of the GIF file with specified index
void getGIFFilenameByIndex(const char *directoryName, int index, char *pnBuffer) {

	char fname[30];

    // Make sure index is in range
    if ((index < 0) || (index >= numberOfFiles))
        return;

    File directory = sd.open(directoryName);
    if (!directory)
        return;

    File file = directory.openNextFile();
    while (file && (index >= 0)) {
        file.getName(fname, sizeof(fname));

        if (isAnimationFile(fname)) {
            index--;

            // Copy the directory name into the pathname buffer
            strcpy(pnBuffer, directoryName);

            // Append the filename to the pathname
            strcat(pnBuffer, fname);
        }

        file.close();
        file = directory.openNextFile();
    }

    file.close();
    directory.close();
}
// Enumerate and possibly display the animated GIF filenames in GIFS directory
int enumerateGIFFiles(const char *directoryName, boolean displayFilenames) {

	char fname[30];
	numberOfFiles = 0;

    File directory = sd.open(directoryName);
    if (!directory) {
        return -1;
    }

    File file = directory.openNextFile();
    while (file) {
		file.getName(fname, sizeof(fname));
  		Serial.println(fname);
        if (isAnimationFile(fname)) {
            numberOfFiles++;
            if (displayFilenames) {
                Serial.println(fname);
            }
        }
        file.close();
        file = directory.openNextFile();
    }

    file.close();
    directory.close();

    return numberOfFiles;
}
예제 #9
0
void SDcard::writefile(uint64_t timestamp_sd, int eeprom){
  
    myfile = SD.open("data.txt", FILE_WRITE);
    
    if (myfile) {
      myfile.print("G|");
      uint64_t xx = timestamp_sd/1000000000ULL;
      if (xx >0) myfile.print((long)xx);
      myfile.print((long)(timestamp_sd-xx*1000000000));
      myfile.print("|");
      myfile.print(eeprom);
      myfile.print("|");
      for(int i = 0; i<3;i++){ // nombre de capteurs = 3
        String data = this->mem->getNext();
        myfile.print(data);
        if (i!=2)
        myfile.print("|");
      }
      myfile.write('\n');
      //myfile.print("|H,");
      //myfile.println(value);
      myfile.close();
    }
    else {
      Serial.println("error opening data.txt");
    }
  }
예제 #10
0
void init() {
  close();
  #ifdef SDCARD
  if (!sd.begin(SD_CS, SPI_FULL_SPEED)) {
//    error_P("card.init");
    return;
  }
  #endif
}
예제 #11
0
uint32_t SD_GetFileSize(void)
{
    uint32_t retVal = 0;
    //TEST.TXT
    sdf.chdir();	// Change directory to root
    // OPEN the file for reading:
    if (!file.open("TEST.TXT", O_READ)) {
        sdf.errorHalt("opening FILE for read failed");
    }
    else
    {
        retVal = file.fileSize();
        file.close();

    }

    return retVal;
}
예제 #12
0
void init_SD(){
  if (!sd.begin(SDCARD_CSPIN, SPI_HALF_SPEED)) {
    f.SDCARD = 0; // If init fails, tell the code not to try to write on it
    debug[1] = 999;
  }
  else {
    f.SDCARD = 1;
    debug[1] = 000;
  }
}
예제 #13
0
  boolean put_handler(AtMegaWebServer& web_server) {
	const char* length_str = web_server.get_header_value("Content-Length");
	long length = atol(length_str);
	const char *path = web_server.get_path();

	SdFile file;
	if(!file.open(path, O_CREAT | O_WRITE | O_TRUNC)){
		 // maybe the folder must be created
		char *c = strrchr(path, '/');
		if(c){
			*c = 0;
			if(sdfat.mkdir(path)){
#if DEBUG
				Serial << "put_handler make DIR: ok " << path <<'\n';
#endif
				*c = '/';
				if(!file.open(path, O_CREAT | O_WRITE | O_TRUNC)){
#if DEBUG
					Serial << "put_handler open FILE: failed " << path <<'\n';
#endif
				}
			}
			*c = '/';
		}
	}
	if(file.isOpen()){

		EthernetClient client = web_server.get_client();
		long size = 0;
		int read = 0;
		while(size < length && web_server.waitClientAvailable()){
			read = client.read((uint8_t*)buffer, sizeof(buffer));
			file.write(buffer, read);
			size += read;
		}
		file.close();
#if DEBUG
		Serial << "file written: " << size << " of: " << length << '\n';
#endif
		if(size < length){
			web_server.sendHttpResult(404);
		}else{
			web_server.sendHttpResult(200);
			web_server << path;
		}

	}else{
		web_server.sendHttpResult(422); // assuming it's a bad filename (non 8.3 name)
#if DEBUG
		Serial << F("put_handler open file failed: send 422 ") << path <<'\n';
#endif
	}
	return true;
  }
예제 #14
0
void TicketflySDBeacon::SDBeaconSetup (SdFat& SD) {
	Serial.begin (9600);
  Serial.print(F("Initializing SD card..."));
	pinMode(10, OUTPUT);
	
  if (!SD.begin(4)) {
    Serial.println(F("initialization failed!"));
    return;
  }
  Serial.println(F("initialization done."));

}
예제 #15
0
파일: main.cpp 프로젝트: keax/SdFat
int main()
{

	// initialize the SD card at SPI_FULL_SPEED for best performance.
	// try SPI_HALF_SPEED if bus errors occur.
	if (!sd.begin(SD_ENABLE_PIN, SPI_FULL_SPEED)) sd.initErrorHalt();


	if (!myFile.open("test.txt", O_RDWR | O_CREAT | O_AT_END)) {
		sd.errorHalt("opening test.txt for write failed");
	}

	myFile.println("testing 1, 2, 3.");

	// close the file:
	myFile.close();

	while (1);

	return 0;
}
예제 #16
0
// Enumerate and possibly display the animated GIF filenames in GIFS directory
int enumerateGIFFiles(const char *directoryName, boolean displayFilenames) {

    numberOfFiles = 0;

    // Set the current working directory
    if (! sd.chdir(directoryName, true)) {
        sd.errorHalt("Could not change to gifs directory");
    }
    sd.vwd()->rewind();

    char fn[13];
    while (file.openNext(sd.vwd(), O_READ)) {
        file.getName(fn, 13);
        // If filename not deleted, count it
        if (fn[0] != '_') {
            numberOfFiles++;
            if (displayFilenames) {
                Serial.println(fn);
                delay(20);
            }
        }
        file.close();
    }
    // Set the current working directory
    if (! sd.chdir("/", true)) {
        sd.errorHalt("Could not change to root directory");
    }
    return numberOfFiles;
}
예제 #17
0
void TicketflySDBeacon::writeToSD (String writeThisString, String fileName, SdFat& SD) { 
	File myFile;
	const char* conversion = fileName.c_str();
	Serial.println (conversion);
	myFile = SD.open(conversion);
  if (myFile) {
    myFile.println(writeThisString);
    myFile.close();
  } 
	else {
    Serial.println(F("error opening example.txt"));
  }
}
예제 #18
0
  boolean delete_handler(AtMegaWebServer& web_server){
	const char *path = web_server.get_path();
#if DEBUG
	Serial << "delete_handler: " << path << '\n';
#endif
	int len = strlen(path);
	char *c = (char *)(path + len - 1);
	if(*c == '/') *c = 0;// remove tailing '/'

	if(sdfat.remove(path) || sdfat.rmdir(path)){
#if DEBUG
		Serial << "delete: " << path << '\n';
#endif
		web_server.sendHttpResult(200);
		web_server << path;
	}else{
		web_server.sendHttpResult(404);
#if DEBUG
		Serial << F("not exists or failed deleting: ") << path << '\n';
#endif
	}
	return true;
  }
예제 #19
0
파일: main.cpp 프로젝트: algedi/KUIopenAVR
void ScriviSd(void)
{
	int n;
	n = 0;
	if (!sd.init(SPI_HALF_SPEED, 10)) 
	{
		sd.initErrorHalt();
		return;
	}

	if (!myFile.open("test-1.txt", O_WRITE | O_CREAT | O_APPEND)) 
	{
		delay(800);
		digitalWrite(7, LOW);
		delay(200);
		digitalWrite(7, HIGH);
		delay(800);
		sd.errorHalt("opening test.txt for write failed");
		return;
	} 
//	Serial.println(nMin);

//	for(n = 0; n < nCount; n++)
//	{
//	myFile.print("TIME: ");
//	myFile.print(nMin);
//	myFile.print(" min. - VALUE    : ");
//	myFile.print(nValue[n]);
	myFile.println(" mTesla");
//	}
//	Serial.println("ScriviSd5");
//	nCount = 0;
//	nMin++;	

	myFile.close();
}
예제 #20
0
void SDcard::readfile(){

  // re-open the file for reading:
  myfile = SD.open("data.txt");
  if (myfile) {
    // read from the file until there's nothing else in it:
    while (myfile.available()) {
      Serial.write(myfile.read());
    }
    // close the file:
    myfile.close();
  } else {
    Serial.println("error opening data.txt");
  }
}
예제 #21
0
void SDcard::setup(){
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  
  Serial.print("Initializing SD card...");
  pinMode(10,OUTPUT);
  
  if (!SD.begin(4)) {
      Serial.println("Initialization failed!");
      return;
    }
    Serial.println("initialization done.");
}
예제 #22
0
boolean SD_ReadFile(const char *filename)
{
    uint32_t t_arrival = millis();
    boolean retVal = false;
    sdf.chdir();
    if (!file.open(filename, O_READ)) {
        sdf.errorHalt("opening FILE for read failed");
    }
    else
    {
        uint32_t len = file.fileSize();
        uint8_t index = 0;
        for(uint32_t i=0; i< len; i++)
        {
            int intData = file.read();
            char byteData;
            int base = 10u;
            //itoa(intData,&byteData,base);	// Convert to ASCII
            buffer[index] = (uint8_t)intData;//byteData;
            if(index < 63u) {
                index++;
            }
            else {
                usb_rawhid_send(buffer, 100u);
                index = 0;
            }

        }
        file.close();
        uint32_t t_exit = millis() - t_arrival;
        buffer[62] = (uint8_t)((t_exit & 0x000000FF)>>8);
        buffer[63] = (uint8_t)t_exit;
        usb_rawhid_send(buffer,100u);

    }
}
예제 #23
0
void TicketflySDBeacon::simpleReadSD (String fileName, SdFat& SD){ 
	File myFile;
	const char* conversion = fileName.c_str();
	myFile = SD.open(conversion, FILE_READ);
	if (myFile) {
	  while (myFile.available()) {
	    Serial.write(myFile.read());
	  }
	  myFile.close();
	} 
	else 
	{
	    Serial.print(F("Error opening "));
			Serial.println (fileName);
	 }
}
예제 #24
0
uint16_t SD_NumberOfFiles(void)
{
    uint16_t fileCount = 0;

    buffer[0] = 0x01;
    usb_rawhid_send(buffer, 100);
    while(file.openNext(sdf.vwd(), O_READ))
    {
        fileCount++;

        buffer[0]++;
        usb_rawhid_send(buffer, 100);

    }
    file.close();
    return fileCount;
}
예제 #25
0
// for renaming files and dirs
boolean move_handler(AtMegaWebServer& web_server){
	const char *path = web_server.get_path();

#if DEBUG
	Serial << F("move_handler filename: ") << path << '\n';
#endif
    const char* length_str = web_server.get_header_value("Content-Length");
    int len = atoi(length_str);

    Client& client = web_server.get_client();

    int i = 0;
    int baselen = 0;
    char* c;
    if((c = strrchr(path, '/'))) baselen = c - path + 1;
    char buf[baselen + len + 1];
    if(baselen) strncpy(buf, path, baselen);
    i = baselen;

    for(; i < (baselen + len) && web_server.waitClientAvailable(); i++) {
      buf[i] = client.read();// (char)
    }
    buf[i] = 0;
#if DEBUG
    Serial << buf << "|end: " << i << '\n';
#endif

    if(i == (len + baselen)){
      if(sdfat.rename(path, buf)){
#if DEBUG
      Serial << "renaming: " << path << " to: " << buf << '\n';
#endif
        web_server.sendHttpResult(200);
      	web_server << buf;
      }else{
#if DEBUG
        Serial << "renaming: failed\n" << buf << LF;
#endif
        web_server.sendHttpResult(422);
      }
    }else{
      web_server.sendHttpResult(404);
    }
    return true;
  }
예제 #26
0
void SD_ListFiles(void)
{

    Serial.begin(9600);
    while (!Serial) {}
    delay(1000);
    Serial.println();
    while (file.openNext(sdf.vwd(), O_READ)) {
        file.printFileSize(&Serial);
        Serial.write(' ');
        file.printModifyDateTime(&Serial);
        Serial.write(' ');
        file.printName(&Serial);
        if (file.isDir()) {
            // Indicate a directory.
            Serial.write('/');
        }
        Serial.println();
        file.close();
    }
}
boolean MP3Player::Setup_STA013(void)
{ 
  byte buf[2];
  
  if (!myFile.open("sta013.cfg", O_READ)) 
  {
    #if DEBUG
	sd.errorHalt("cfg file error");
	#endif 
	return false;
  }
  
  #if DEBUG
  Serial.println("setting STA013 from cfgfile");  
  #endif 
  
  
  while (myFile.available()) 
  {
    buf[0]=byte (myFile.read());
    buf[1]=byte (myFile.read()); 
    I2C_Write(buf[0], buf[1]);
    // Serial.write(buf[0]);
    // Serial.write(buf[1]);
  }  
  
  while(!myFile.close())
  {
	  #if DEBUG
	  Serial.println("close cfg file..");
	  #endif
  }
  
    
  #if DEBUG
  Serial.println("Setup STA013 Register Done..");     
  #endif 
  
  return true;
}
boolean MP3Player::Play(const char* SongName)
{  
  if(!PLAY)
  {
	k=65;
	if(!myFile.isOpen())
	{
		// open the file for read
		if (!myFile.open(SongName, O_READ)) 
		{
			#if DEBUG
			sd.errorHalt("open audio file failed");
			#endif 
			return false;
		}
	}
	else
		name = SongName;

	Run_STA013();
	delayMicroseconds(500000);
	Play_Pause(1);
  
	//AMPON();  

	#if DEBUG
	Serial.println("playing");
	#endif 
   
	filesize=myFile.fileSize();
	Timer1.initialize(30);// 30 us = can check data request and send a byte to STA013 at 1/30u = 33.33kHz
							// able to play a song up to 33.33 x 8 /1024 = 260 kbps
							// recommend play song at 200kbps or lower (such as 128 kbps)for stable performance
	PLAY=true; 
	Timer1.attachInterrupt(Callback);
  }

  return true;   
}
예제 #29
0
bool TicketflySDBeacon::searchDatabaseForTicket(String TicketString, SdFat& SD){ 
		File myFile;
		const char* TicketNo = TicketString.c_str();
		myFile = SD.open("example.txt");  
		if (myFile) {
    	char buf[16];
    	myFile.read(buf, 16);
    	if (strncmp(buf, TicketNo, 14) == 0)
    	{
      	Serial.println(F("Match!"));
      	return true;
    	}
    	else {
				Serial.println (F("No Match"));
      	return false;
    	}
    myFile.close();
  }
	else {
	Serial.println(F("error opening file"));
  }
}
예제 #30
0
파일: Tune.cpp 프로젝트: Snootlab/Tune
int Tune::play(char* trackName)
{
	if (isPlaying()) return 1;
	
	// Exit if track not found
	if (!track.open(trackName, O_READ))
	{
		sd.errorHalt("Track not found !");
		return 3;
	}
	
	playState = playback;
	
	// Reset decode time & bitrate from previous playback
	writeSCI(SCI_DECODE_TIME, 0);
	delay(100);
	
	skipTag(); // Skip ID3v2 tag if there's one
	
	feed(); // Feed VS1011e
	attachInterrupt(0, feed, RISING); // Let the interrupt handle the rest of the process
	
	return 0;
}