FAT16/examples/FAT16_WriteExample/FAT16_WriteExample.pde

   1 /*
   2 FAT16 WriteFile Example Sketch
   3 SparkFun Electronics
   4 Written by Ryan Owens
   5 3/16/2010
   6
   7 Code Description: Uses an Arduino Duemillanove or Arduino Pro to write a string to a file.
   8
   9 Circuit Description: Uses the SparkFun microSD shield. (http://www.sparkfun.com/commerce/product_info.php?products_id=9520)
  10
  11 Attributions: Special thanks to Roland Riegel for providing an open source FAT library
  12 for AVR microcontrollers. See more of his projects here:
  13 http://www.roland-riegel.de/
  14
  15 This code is provided under the Creative Commons Attribution License. More information can be found here:
  16 http://creativecommons.org/licenses/by/3.0/
  17
  18 (Use our code freely! Please just remember to give us credit where it's due. Thanks!)
  19 */
  20
  21 //Add libraries to support FAT16 on the SD Card.
  22 //(Note: If you already have these libraries installed in the directory, they'll have to remove in order to compile this.)
  23 #include <byteordering.h>
  24 #include <fat.h>
  25 #include <fat_config.h>
  26 #include <partition.h>
  27 #include <partition_config.h>
  28 #include <sd-reader_config.h>
  29 #include <sd_raw.h>
  30 #include <sd_raw_config.h>
  31
  32 //Define the pin numbers
  33 #define CS    8
  34 #define MOSI    11
  35 #define MISO    12
  36 #define SCK    13
  37
  38 //This is the amount of data to be fetched from the SD card for each read.
  39 #define BUFFERSIZE      256
  40
  41 char buffer[BUFFERSIZE]="Testing\n";
  42 char file_name[30];
  43
  44 struct fat_dir_struct* dd;              //FAT16 directory
  45 struct fat_dir_entry_struct dir_entry;  //FAT16 directory entry (A.K.A. a file)
  46
  47 struct fat_fs_struct* fs;               //FAT16 File System
  48 struct partition_struct* partition;     //FAT16 Partition
  49
  50 struct fat_file_struct * file_handle;   //FAT16 File Handle
  51
  52 void setup()
  53 {
  54     //Set up the pins for the Serial communication
  55     pinMode(0, INPUT);
  56     pinMode(1, OUTPUT);
  57     Serial.begin(9600);
  58
  59     //Set up the pins for the microSD shield
  60     pinMode(CS, OUTPUT);
  61     pinMode(MOSI, OUTPUT);
  62     pinMode(MISO, INPUT);
  63     pinMode(SCK, OUTPUT);
  64     pinMode(10, OUTPUT);
  65 }
  66
  67 void loop()
  68 {
  69   int bytes_read=0; //Keeps track of how many bytes are read when accessing a file on the SD card.
  70   int count=0;
  71
  72   init_filesystem();    //Initialize the FAT16 file system on the SD card.
  73
  74   //Create a file named Test.txt. If the file already exists, delete it and create a new one.
  75   if(!fat_create_file(dd, "Test.txt", &dir_entry)){
  76       fat_delete_file(fs, &dir_entry);
  77       fat_create_file(dd, "Test.txt", &dir_entry);
  78   }
  79   //Open the file that's just been created
  80   file_handle=open_file_in_dir(fs, dd, "Test.txt");
  81   //Write some initial data to the file
  82   fat_write_file(file_handle, (const uint8_t*)buffer, strlen(buffer));
  83   sd_raw_sync();    //An SD sync must be performed after each write operation
  84   fat_close_file(file_handle);    //Close the file.
  85   while(1){
  86       //Open the file (now we're at the beginning of the file again.
  87       open_file_in_dir(fs, dd, "Test.txt");
  88       //Read the contents of the file (up to 512 bytes)
  89       bytes_read = fat_read_file(file_handle, (uint8_t*)buffer, BUFFERSIZE);
  90       //Print the contents of the file
  91       Serial.println((const char*)buffer);
  92       //Now go to the end of the file to write some data.
  93       fat_seek_file(file_handle, 0, FAT_SEEK_END);
  94       sprintf(buffer, "%d", count++);
  95       //Write the new 'buffer' string to the end of the file
  96       fat_write_file(file_handle, (const uint8_t*)buffer, strlen(buffer));
  97       sd_raw_sync();
  98       //Close the file, we're finished!
  99       fat_close_file(file_handle);
 100       delay(1000);
 101   }
 102
 103   while(1);
 104 }
 105
 106 uint8_t find_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name, struct fat_dir_entry_struct* dir_entry)
 107 {
 108         fat_reset_dir(dd);      //Make sure to start from the beginning of the directory!
 109     while(fat_read_dir(dd, dir_entry))
 110     {
 111         if(strcmp(dir_entry->long_name, name) == 0)
 112         {
 113             //fat_reset_dir(dd);
 114             return 1;
 115         }
 116     }
 117
 118     return 0;
 119 }
 120
 121 struct fat_file_struct* open_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name)
 122 {
 123     struct fat_dir_entry_struct file_entry;
 124     if(!find_file_in_dir(fs, dd, name, &file_entry))
 125         return 0;
 126
 127     return fat_open_file(fs, &file_entry);
 128 }
 129
 130 char init_filesystem(void)
 131 {
 132         //setup sd card slot
 133         if(!sd_raw_init())
 134         {
 135                 return 0;
 136         }
 137
 138         //open first partition
 139         partition = partition_open(sd_raw_read,
 140                                                                         sd_raw_read_interval,
 141 #if SD_RAW_WRITE_SUPPORT
 142                                                                         sd_raw_write,
 143                                                                         sd_raw_write_interval,
 144 #else
 145                                                                         0,
 146                                                                         0,
 147 #endif
 148                                                                         0
 149                                                            );
 150
 151         if(!partition)
 152         {
 153                 //If the partition did not open, assume the storage device
 154                 //is a "superfloppy", i.e. has no MBR.
 155                 partition = partition_open(sd_raw_read,
 156                                                                    sd_raw_read_interval,
 157 #if SD_RAW_WRITE_SUPPORT
 158                                                                    sd_raw_write,
 159                                                                    sd_raw_write_interval,
 160 #else
 161                                                                    0,
 162                                                                    0,
 163 #endif
 164                                                                    -1
 165                                                                   );
 166                 if(!partition)
 167                 {
 168                         return 0;
 169                 }
 170         }
 171
 172         //Open file system
 173         fs = fat_open(partition);
 174         if(!fs)
 175         {
 176                 return 0;
 177         }
 178
 179         //Open root directory
 180         fat_get_dir_entry_of_path(fs, "/", &dir_entry);
 181         dd=fat_open_dir(fs, &dir_entry);
 182
 183         if(!dd)
 184         {
 185                 return 0;
 186         }
 187         return 1;
 188 }
 189
 190 char get_next_filename(struct fat_dir_struct* cur_dir, char * new_file)
 191 {
 192     //'dir_entry' is a global variable of type directory_entry_struct
 193
 194     //Get the next file from the root directory
 195     if(fat_read_dir(cur_dir, &dir_entry))
 196     {
 197         sprintf(new_file, "%s", dir_entry.long_name);
 198         Serial.println((const char *)new_file);
 199         return 1;
 200     }
 201     //If another file isn't found, return 0
 202     return 0;
 203 }
 204
 205 \r