/* Description: Requrest for a specific file at a specified position within the directory The path argument is identical to the path which was provided to last call to "mas_sdfat_move_to_pwd" */ uint8_t mas_sdfat_get_nth_file(const char *path, uint16_t n, char *buf, uint8_t *is_dir) { uint16_t c = 0; if ( mas_sdfat_move_to_pwd(path) == 0 ) return 0; if ( mas_sdfat_file_is_open != 0 ) { mas_sdfat_file.close(); mas_sdfat_file_is_open = 0; } mas_sdfat_sd->vwd()->rewind(); while (mas_sdfat_file.openNext(mas_sdfat_sd->vwd(), O_READ)) { if ( n == c ) { mas_sdfat_file.getFilename(buf); buf[12] = '\0'; *is_dir = mas_sdfat_file.isDir(); mas_sdfat_file.close(); return 1; } c++; mas_sdfat_file.close(); } return 0; }
// grafix has to be stored at /gfx/ int speedo_disp::sd2ssd(char filename[10],int frame){ send_command(0x15); send_command(0x00); send_command(0x7F); send_command(0x75); send_command(0x00); send_command(0x3F); SdFile root; SdFile file; SdFile subdir; root.openRoot(&pSD->volume); if(!subdir.open(&root, "gfx", O_READ)) { return 1; }; if(!file.open(&subdir, filename, O_READ)) { return 2; }; unsigned long frame_seeker=(unsigned long)frame*64*64; if(!file.seekSet(frame_seeker)) { return 3; }; // ein bild ist 64*64 Byte groß, da wir 64 lines zu je 64*2*4 Bit Breite haben uint8_t buf[65]; //int n; //while ((n = file.read(buf, sizeof(byte)*64)) > 0) { for (int zeile=0; (file.read(buf, sizeof(byte)*64)>0) && zeile<64; zeile++ ) { for(int j=0;j<64;j++){ send_char(buf[j]); }; }; file.close(); subdir.close(); root.close(); return 0; };
// this little helper is used to traverse paths SdFile SDClass::getParentDir(const char *filepath, int *index) { // get parent directory SdFile d1 = root; // start with the mostparent, root! SdFile d2; // we'll use the pointers to swap between the two objects SdFile *parent = &d1; SdFile *subdir = &d2; const char *origpath = filepath; while (strchr(filepath, '/')) { // get rid of leading /'s if (filepath[0] == '/') { filepath++; continue; } if (!strchr(filepath, '/')) { // it was in the root directory, so leave now break; } // extract just the name of the next subdirectory uint8_t idx = strchr(filepath, '/') - filepath; if (idx > 12) idx = 12; // dont let them specify long names char subdirname[13]; strncpy(subdirname, filepath, idx); subdirname[idx] = 0; // close the subdir (we reuse them) if open subdir->close(); if (!subdir->open(parent, subdirname, O_READ)) { // failed to open one of the subdirectories return SdFile(); } // move forward to the next subdirectory filepath += idx; // we reuse the objects, close it. parent->close(); // swap the pointers SdFile *t = parent; parent = subdir; subdir = t; } *index = (int) (filepath - origpath); // parent is now the parent diretory of the file! return *parent; }
idigi_callback_status_t iDigiFileSystem::app_process_file_stat(idigi_file_stat_request_t * const request_data, idigi_file_stat_response_t * const response_data) { idigi_file_stat_t *pstat = &response_data->statbuf; idigi_callback_status_t status = idigi_callback_continue; SdFile entry = DigiSD.open(request_data->path); if (!entry.isOpen()) { APP_DEBUG("stat cannot open: %s\n", request_data->path); goto done; } pstat->last_modified = 0; // Last modified date unsupported: pstat->hash_alg = idigi_file_hash_none; // File hash not supported pstat->file_size = (size_t) entry.fileSize(); pstat->flags = 0; if (entry.isDir()) pstat->flags |= IDIGI_FILE_IS_DIR; else pstat->flags |= IDIGI_FILE_IS_REG; entry.close(); done: return status; }
void HAL::syncEEPROM() { // store to disk if changed millis_t time = millis(); if (eprSyncTime && (time - eprSyncTime > 15000)) // Buffer writes only every 15 seconds to pool writes { eprSyncTime = 0; bool failed = false; if (!sd.sdactive) // not mounted { if (eepromFile.isOpen()) eepromFile.close(); Com::printErrorF("Could not write eeprom to sd card - no sd card mounted"); Com::println(); return; } if (!eepromFile.seekSet(0)) failed = true; if(!failed && !eepromFile.write(virtualEeprom, EEPROM_BYTES) == EEPROM_BYTES) failed = true; if(failed) { Com::printErrorF("Could not write eeprom to sd card"); Com::println(); } } }
void LogTemps(){ if (!file.open(root, filename, O_CREAT | O_APPEND | O_WRITE)) { //error(“open”); } // write values to the file sensorsa.requestTemperatures(); sensorsb.requestTemperatures(); sensorsc.requestTemperatures(); sensorsd.requestTemperatures(); file.print(now() ); file.print("|"); file.print(sensorsa.getTempCByIndex(0)); file.print("|"); file.print(sensorsb.getTempCByIndex(0)); file.print("|"); file.print(sensorsc.getTempCByIndex(0)); file.print("|"); file.print(sensorsd.getTempCByIndex(0)); file.print("\n"); if (!file.close() || file.writeError){ // error(“close/write”); } }
int WiFiCmdRobot::WiFiSendPicture (int16_t n) { int ret=SUCCESS; int16_t nbytes; uint8_t buf[PAYLOAD_SIZE]; char filename[12+1]; Serial.print("n: "); Serial.println(n); // Open the file sprintf(filename, "PICT%02d.jpg", n); if (!FilePicture.open(&root, filename, O_READ)) return FILE_OPEN_ERROR; Serial.print("Open file: "); Serial.println(filename); // read from the file until there's nothing else in it: while ((nbytes = FilePicture.read(buf, sizeof(buf))) > 0 && ret == SUCCESS) { for (unsigned int idx = 0; idx<nbytes;idx++) { tcpClient.print(buf[idx]); } }// while //Close file if (!FilePicture.close()) return FILE_CLOSE_ERROR; return SUCCESS; }
// 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; }
void readSettings() { int n,cc; char ch, buff[24]; char buff2[80]; unsigned int ndx=0; int read=0; if (!settingsFile.open(&root, settingsFileName, O_READ)) { console.printf("DBG: Creating New Settings File\r\n"); console.flush(); writeSettings(); return; } console.printf("DBG: Opened Settings File: %s\r\n",settingsFileName); settingsFile.seekSet(0); while ((read=settingsFile.read(buff, sizeof(buff))) > 0) { //console.printf("DBG: READ %d\r\n",read); console.flush(); for (cc=0; cc < read ; cc++) { ch=buff[cc]; //console.putChar(ch); console.flush(); buff2[ndx]=ch; if (ndx<MAX_INPUT_LINE) {ndx++;} if (ch=='\n'){//console.putChar('\r'); if(ndx) { ndx--; // eat the newline. } buff2[ndx]='\0'; //console.puts(buff2); if ((ndx>4) && buff2[3]=='!') {//fix this when the files are better buff2[3]='\0'; n=lookupIndex(buff2); switch (n) { case _NPW_: networkSetPassword(buff2+4); break; case _NJN_: Watchdog_Reset(); networkJoin(buff2 +4); break; case _PKY_: strncpy(pachubeKey, buff2+4, MAX_PATCHUBE_KEY_LENGHT-1); break; case _PFD_: strncpy(pachubeFeed, buff2+4, MAX_PATCHUBE_FEED_LENGHT-1); break; default: break; } } ndx=0; } } } console.printf("DBG: Finished with Settings File: %s\r\n",settingsFileName); settingsFile.close(); }
/** * Get a long pretty path based on a DOS 8.3 path */ void CardReader::printLongPath(char *path) { lsAction = LS_GetFilename; int i, pathLen = strlen(path); // SERIAL_ECHOPGM("Full Path: "); SERIAL_ECHOLN(path); // Zero out slashes to make segments for (i = 0; i < pathLen; i++) if (path[i] == '/') path[i] = '\0'; SdFile diveDir = root; // start from the root for segment 1 for (i = 0; i < pathLen;) { if (path[i] == '\0') i++; // move past a single nul char *segment = &path[i]; // The segment after most slashes // If a segment is empty (extra-slash) then exit if (!*segment) break; // Go to the next segment while (path[++i]) { } // SERIAL_ECHOPGM("Looking for segment: "); SERIAL_ECHOLN(segment); // Find the item, setting the long filename diveDir.rewind(); lsDive("", diveDir, segment); // Print /LongNamePart to serial output SERIAL_PROTOCOLCHAR('/'); SERIAL_PROTOCOL(longFilename[0] ? longFilename : "???"); // If the filename was printed then that's it if (!filenameIsDir) break; // SERIAL_ECHOPGM("Opening dir: "); SERIAL_ECHOLN(segment); // Open the sub-item as the new dive parent SdFile dir; if (!dir.open(diveDir, segment, O_READ)) { SERIAL_EOL; SERIAL_ECHO_START; SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR); SERIAL_ECHO(segment); break; } diveDir.close(); diveDir = dir; } // while i<pathLen SERIAL_EOL; }
File SDClass::open(const char *filepath, uint8_t mode) { /* Open the supplied file path for reading or writing. The file content can be accessed via the `file` property of the `SDClass` object--this property is currently a standard `SdFile` object from `sdfatlib`. Defaults to read only. If `write` is true, default action (when `append` is true) is to append data to the end of the file. If `append` is false then the file will be truncated first. If the file does not exist and it is opened for writing the file will be created. An attempt to open a file for reading that does not exist is an error. */ int pathidx; // do the interative search SdFile parentdir = getParentDir(filepath, &pathidx); // no more subdirs! filepath += pathidx; if (! filepath[0]) { // it was the directory itself! return File(parentdir, "/"); } // Open the file itself SdFile file; // failed to open a subdir! if (!parentdir.isOpen()) return File(); if ( ! file.open(parentdir, filepath, mode)) { return File(); } // close the parent parentdir.close(); if (mode & (O_APPEND | O_WRITE)) file.seekSet(file.fileSize()); return File(file, filepath); }
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; }
void loop() { uint32_t t; double r; Serial.println("Type any character to start"); while (!Serial.available()) SPARK_WLAN_Loop(); while (Serial.available()) Serial.read(); // open or create file - truncate existing file. if (!file.open(&root, "BENCH.DAT", O_CREAT | O_TRUNC | O_RDWR)) { error("open failed"); } // fill buf with known data for (uint16_t i = 0; i < (BUF_SIZE-2); i++) { buf[i] = 'A' + (i % 26); } buf[BUF_SIZE-2] = '\r'; buf[BUF_SIZE-1] = '\n'; Serial.print("File size "); Serial.print(FILE_SIZE_MB); Serial.println(" MB"); uint32_t n = FILE_SIZE/sizeof(buf); Serial.println("Starting write test. Please wait up to a minute"); // do write test t = millis(); for (uint32_t i = 0; i < n; i++) { if (file.write(buf, sizeof(buf)) != sizeof(buf)) { error("write failed"); } } t = millis() - t; file.sync(); r = (double)file.fileSize()/t; Serial.print("Write "); Serial.print(r); Serial.println(" kB/sec"); Serial.println(); Serial.println("Starting read test. Please wait up to a minute"); // do read test file.rewind(); t = millis(); for (uint32_t i = 0; i < n; i++) { if (file.read(buf, sizeof(buf)) != sizeof(buf)) { error("read failed"); } } t = millis() - t; r = (double)file.fileSize()/t; Serial.print("Read "); Serial.print(r); Serial.println(" kB/sec"); Serial.println("Done"); file.close(); }
void HAL::importEEPROM() { if (eepromFile.isOpen()) eepromFile.close(); if (!eepromFile.open("eeprom.bin", O_RDWR | O_CREAT | O_SYNC) || eepromFile.read(virtualEeprom, EEPROM_BYTES) != EEPROM_BYTES) { Com::printFLN(Com::tOpenFailedFile, "eeprom.bin"); } else { Com::printFLN("EEPROM read from sd card."); } EEPROM::readDataFromEEPROM(true); }
// Get the full path/filename of the GIF file with specified index void getGIFFilenameByIndex(const char *directoryName, int index, char *pnBuffer) { char filename[13]; // Make sure index is in range if ((index >= 0) && (index < numberOfFiles)) { // Set the current working directory if (! sd.chdir(directoryName, true)) { sd.errorHalt("Could not change to gifs directory"); } // Make sure file is closed before starting file.close(); // Rewind the directory to the beginning sd.vwd()->rewind(); while ((file.openNext(sd.vwd(), O_READ)) && (index >= 0)) { file.getName(filename, 13); // If filename is not marked as deleted, count it if ((filename[0] != '_') && (filename[0] != '~')) { index--; } file.close(); } // Set the current working directory back to root if (! sd.chdir("/", true)) { sd.errorHalt("Could not change to root directory"); } // Copy the directory name into the pathname buffer strcpy(pnBuffer, directoryName); // Append the filename to the pathname strcat(pnBuffer, filename); } }
idigi_callback_status_t iDigiFileSystem::app_process_file_close(idigi_file_request_t * const request_data, idigi_file_response_t * const response_data) { idigi_callback_status_t status = idigi_callback_continue; SdFile *file = (SdFile *) request_data->handle; file->close(); APP_DEBUG("close %p\n", (void *) file); free(file); return status; }
idigi_callback_status_t iDigiFileSystem::app_process_file_closedir(idigi_file_request_t * const request_data, idigi_file_response_t * const response_data) { SdFile *dir = (SdFile *) request_data->handle; APP_DEBUG("closedir %p\n", (void *) dir); if (dir->isOpen()) dir->close(); free(dir); return idigi_callback_continue; }
int wctx(long flen) { int thisblklen; int sectnum, attempts, firstch; long charssent; //DSERIAL.println("\nwctx"); charssent = 0; firstsec=TRUE; thisblklen = blklen; vfile(F("wctx:file length=%ld"), flen); while ((firstch=readline(Rxtimeout))!=NAK && firstch != WANTCRC && firstch != WANTG && firstch!=TIMEOUT && firstch!=CAN) ; if (firstch==CAN) { zperr("Receiver CANcelled"); return ERROR; } if (firstch==WANTCRC) Crcflg=TRUE; if (firstch==WANTG) Crcflg=TRUE; sectnum=0; for (;;) { if (flen <= (charssent + 896L)) thisblklen = 128; if ( !filbuf(txbuf, thisblklen)) break; if (wcputsec(txbuf, ++sectnum, thisblklen)==ERROR) return ERROR; charssent += thisblklen; } //fclose(in); fout.close(); attempts=0; do { purgeline(); sendline(EOT); //fflush(stdout); ++attempts; } while ((firstch=(readline(Rxtimeout)) != ACK) && attempts < Tx_RETRYMAX); if (attempts == Tx_RETRYMAX) { zperr("No ACK on EOT"); return ERROR; } else return OK; }
bool FileSystem::initSDCard() { boolean status; if (root.isOpen()) root.close(); // allows repeated calls // First, detect the card status = card.init(pinCS); // Audio shield has SD card SD on pin 10 if (status) { Serial.println("SD card is connected :-)"); } else { Serial.println("SD card is not connected or unusable :-("); sdCardInitialized = false; return sdCardInitialized; } // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32 if (!volume.init(card)) { Serial.println( "Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card"); sdCardInitialized = false; return sdCardInitialized; } root.openRoot(volume); // print the type and size of the first FAT-type volume Serial.print("\nVolume type is FAT"); Serial.println(volume.fatType(), DEC); Serial.println(); float size = volume.blocksPerCluster() * volume.clusterCount(); size = size * (512.0 / 1e6); // convert blocks to millions of bytes Serial.print("File system space is "); Serial.print(size); Serial.println(" Mbytes."); status = SD.begin(pinCS); // Audio shield has SD card CS on pin 10 if (status) { Serial.println("SD library is able to access the filesystem"); } else { Serial.println("SD library can not access the filesystem!"); Serial.println( "Please report this problem, with the make & model of your SD card."); Serial.println( " http://forum.pjrc.com/forums/4-Suggestions-amp-Bug-Reports"); } sdCardInitialized = true; return sdCardInitialized; }
boolean callback_pathExists(SdFile& parentDir, char *filePathComponent, boolean isLastComponent, void *object) { /* */ SdFile child; boolean exists = child.open(parentDir, filePathComponent, O_RDONLY); if (exists) { child.close(); } return exists; }
boolean get_handler(AtMegaWebServer& web_server){ const char* filename = web_server.get_path(); #if DEBUG Serial << F("file_handler path: ") << filename << '\n'; #endif if (!filename) { web_server.sendHttpResult(404); #if DEBUG Serial << F("Could not parse URL"); #endif return true; } if(filename[0] == '/' && filename[1] == 0){ // root dir, file.open() will fail listDirectory(web_server, SdBaseFile::cwd()); return true; } SdFile file; if(file.open(filename, O_READ)){ #if DEBUG Serial << "file isOpen: " << filename << '\n'; #endif if (file.isDir()) { listDirectory(web_server, &file); } else { AtMegaWebServer::MimeType mime_type = AtMegaWebServer::get_mime_type_from_filename(filename); // If you want to send a file with a non-supported MimeType you can: // web_server.sendHttpResult(200, 0, "Content-Type: image/tiff" CRLF); web_server.sendHttpResult(200, mime_type); #if DEBUG Serial << F("Read file "); Serial.println(filename); #endif web_server.send_file(file); } file.close(); }else{ web_server.sendHttpResult(404); } return true; }
uint16_t mas_sdfat_get_directory_file_cnt(const char *path) { uint8_t cnt; cnt = 0; if ( mas_sdfat_move_to_pwd(path) == 0 ) return 0; if ( mas_sdfat_file_is_open != 0 ) { mas_sdfat_file.close(); mas_sdfat_file_is_open = 0; } mas_sdfat_sd->vwd()->rewind(); while (mas_sdfat_file.openNext(mas_sdfat_sd->vwd(), O_READ)) { cnt++; mas_sdfat_file.close(); if ( cnt == 0x0ffff ) break; } return cnt; }
bool change_to_dir(const char *dir) { SdFile newdir; bool result = false; //Goto parent directory //@NOTE: This is a fix to make this work. Should be replaced with //proper handling. Limitation: setting::max_folder_depth subfolders //ERROR if (strcmp_P(dir, F("..")) == 0) { if (strcmp_P(dir, PSTR("..")) == 0) { result = true; currentDirectory.close(); if (!currentDirectory.openRoot(&volume)) { systemError(error_code::root_init); } int8_t index = getNextFolderTreeIndex() - 1; if (index >= 0) { for (int8_t iTemp = 0; iTemp < index; iTemp++){ result = newdir.open(¤tDirectory, folderTree[iTemp], O_READ); if (!result){ break; } currentDirectory = newdir; //Point to new directory newdir.close(); } memset(folderTree[index], 0, 11); } if (((feedback_mode & setting::extended_info) > 0) && (result == false)){ NewSerial.print(F("cannot cd to parent directory: ")); NewSerial.println(dir); } }else { result = newdir.open(¤tDirectory, dir, O_READ); if (!result) { if ((feedback_mode & setting::extended_info) > 0){ NewSerial.print(F("directory not found: ")); NewSerial.println(dir); } }else { currentDirectory = newdir; //Point to new directory int8_t index = getNextFolderTreeIndex(); if (index >= 0){ strncpy(folderTree[index], dir, 11); } } } return result; }
void setup(void) { Serial.begin(BPS_115200); Serial.println(); PgmPrintln("Type any character to start"); while (!Serial.available()); //PgmPrint("FreeRam: "); //Serial.println(FreeRam()); // initialize the SD card at SPI_HALF_SPEED to avoid bus errors with // breadboards. use SPI_FULL_SPEED for better performance. if (!card.init(SPI_HALF_SPEED)) error("card.init failed"); // initialize a FAT volume if (!volume.init(&card)) error("volume.init failed"); // open the root directory if (!root.openRoot(&volume)) error("openRoot failed"); strcpy_P(buf, PSTR("APPEND.TXT")); // open for read if (!from.open(&root, buf, O_READ)) { PgmPrint("Can't open "); Serial.println(buf); PgmPrintln("Run the append example to create the file."); error("from.open failed"); } strcpy_P(buf, PSTR("ACOPY.TXT")); // create if needed, truncate to zero length, open for write if (!copy.open(&root, buf, O_CREAT | O_TRUNC | O_WRITE)) { error("copy.open failed"); } // count for printing periods uint16_t p = 0; int16_t n; while ((n = from.read(buf, sizeof(buf))) > 0) { if (copy.write(buf, n) != n) error("write failed"); // print progress periods if (!(p++ % 25)) Serial.print('.'); if (!(p % 500)) Serial.println(); } Serial.println(); if (n != 0) error ("read"); // force write of directory entry and last data if (!copy.close()) error("copy.close failed"); PgmPrintln("Copy done."); }
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; }
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; }
void MP3Player::Halt() { Timer1.detachInterrupt(); PLAY=false; while(!myFile.close()) { #if DEBUG Serial.println("close audio file"); #endif } //AMPSHUTDOWN(); #if DEBUG Serial.println("finish"); #endif delayMicroseconds(100000); name = ""; if(isPlayAll) PlayTrack("",0,""); }
boolean callback_pathExists(SdFile& parentDir, char *filePathComponent, boolean isLastComponent, void *object) { /* Callback used to determine if a file/directory exists in parent directory. Returns true if file path exists. */ SdFile child; boolean exists = child.open(parentDir, filePathComponent, O_RDONLY); if (exists) { child.close(); } return exists; }
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(); } }
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; }