/* recursively delete entries */
bool SDCardEntry::deleteFirstEntry() {
if (!isDirectory())
return false;
fat_dir_struct *dd = fat_open_dir(SDCard.fs, &dir_entry);
if (dd == NULL)
return false;
SDCardEntry entry;
uint8_t ret;
again:
ret = fat_read_dir(dd, &entry.dir_entry);
if (!strcmp(entry.dir_entry.long_name, ".") ||
!strcmp(entry.dir_entry.long_name, "..")) {
goto again;
}
fat_close_dir(dd);
if (!ret) {
return false;
}
entry.setFromParentEntry(this);
return entry.deleteEntry(true);
}
bool SDCardFile::open(bool create) {
if (!exists) {
if (create) {
SDCardEntry parentDir(dir);
if (!parentDir.exists)
return false;
fat_dir_struct *dd = fat_open_dir(SDCard.fs, &parentDir.dir_entry);
if (!fat_create_file(dd, name, &dir_entry)
&& strcmp(name, dir_entry.long_name)) {
fat_close_dir(dd);
return false;
}
fat_close_dir(dd);
} else {
return false;
}
}
fd = fat_open_file(SDCard.fs, &dir_entry);
if (fd != NULL)
return true;
else
return false;
}
char init_filesystem(void)
{
//setup sd card slot
if(!sd_raw_init())
{
return 0;
}
//open first partition
partition = partition_open(sd_raw_read,
sd_raw_read_interval,
#if SD_RAW_WRITE_SUPPORT
sd_raw_write,
sd_raw_write_interval,
#else
0,
0,
#endif
0
);
if(!partition)
{
//If the partition did not open, assume the storage device
//is a "superfloppy", i.e. has no MBR.
partition = partition_open(sd_raw_read,
sd_raw_read_interval,
#if SD_RAW_WRITE_SUPPORT
sd_raw_write,
sd_raw_write_interval,
#else
0,
0,
#endif
-1
);
if(!partition)
{
return 0;
}
}
//Open file system
fs = fat_open(partition);
if(!fs)
{
return 0;
}
//Open root directory
fat_get_dir_entry_of_path(fs, "/", &dir_entry);
dd=fat_open_dir(fs, &dir_entry);
if(!dd)
{
return 0;
}
return 1;
}
bool openRoot()
{
// Open root directory
struct fat_dir_entry_struct rootdirectory;
fat_get_dir_entry_of_path(fs, "/", &rootdirectory);
dd = fat_open_dir(fs, &rootdirectory);
return dd != 0;
}
bool SDCardEntry::createSubDirectory(const char *path, struct fat_dir_entry_struct *new_entry) {
if (path[0] == '/')
path++;
fat_dir_struct *dd = fat_open_dir(SDCard.fs, &dir_entry);
if (dd == NULL)
return false;
char subDir[64];
while (1) {
const char *pos = strchr(path, '/');
if (pos == NULL) {
m_strncpy(subDir, path, sizeof(subDir) - 1);
} else {
int len = pos - path;
memcpy(subDir, path, len);
subDir[len] = '\0';
path = pos + 1;
}
struct fat_dir_entry_struct new_dir_entry;
int result = fat_create_dir(dd, subDir, &new_dir_entry);
if (result == 0 && strcmp(subDir, new_dir_entry.long_name)) {
fat_close_dir(dd);
return false;
} else {
memcpy(new_entry, &new_dir_entry, sizeof(new_dir_entry));
fat_close_dir(dd);
dd = fat_open_dir(SDCard.fs, &new_dir_entry);
if (dd == NULL) {
return false;
} else {
if (pos == NULL) {
sd_raw_sync();
fat_close_dir(dd);
return true;
}
}
}
}
}
/******************************************************************************
* User API
******************************************************************************/
char FAT::initialize()
{
//setup sd card slot
if(!sd_raw_init())
{
return 0;
}
PORTB |= (1<<0);
//open first partition
_partition = partition_open(sd_raw_read,
sd_raw_read_interval,
sd_raw_write,
sd_raw_write_interval,
0
);
if(!_partition)
{
//If the partition did not open, assume the storage device
//is a "superfloppy", i.e. has no MBR.
_partition = partition_open(sd_raw_read,
sd_raw_read_interval,
sd_raw_write,
sd_raw_write_interval,
-1
);
if(!_partition)
{
return 0;
}
}
//Open file system
//struct fat_fs_struct* fs = fat_open(partition);
_fs = fat_open(_partition);
if(!_fs)
{
return 0;
}
//Open root directory
//struct fat_dir_entry_struct directory;
fat_get_dir_entry_of_path(_fs, "/", &_directory);
//struct fat_dir_struct* dd = fat_open_dir(fs, &directory);
_dd=fat_open_dir(_fs, &_directory);
if(!_dd)
{
return 0;
}
return 1;
}
bool FatFsClass::changeDirectory(const char * file_name)
{
struct fat_dir_entry_struct directory;
if(fat_get_dir_entry_of_path(_fs, file_name, &directory)){
fat_close_dir(_dd);
_dd = fat_open_dir(_fs, &directory);
if(_dd){
return true;
}
}
return false;
}
uint8_t RepRapSDCard::open_root()
{
// Open root directory
struct fat_dir_entry_struct rootdirectory;
fat_get_dir_entry_of_path(fs, "/", &rootdirectory);
dd = fat_open_dir(fs, &rootdirectory);
if(!dd)
return 0;
return 1;
}
bool SDCardEntry::findFile(const char *name, struct fat_dir_entry_struct *entry) {
if (!isDirectory())
return false;
fat_dir_struct *dd = fat_open_dir(SDCard.fs, &dir_entry);
if (dd == NULL)
return false;
while (fat_read_dir(dd, entry)) {
if (strcmp(entry->long_name, name) == 0) {
fat_close_dir(dd);
return true;
}
}
fat_close_dir(dd);
return false;
}
int SDCardEntry::listDirectory(SDCardEntry entries[], int maxCount) {
if (!isDirectory())
return -1;
int entryCount = 0;
fat_dir_struct *dd = fat_open_dir(SDCard.fs, &dir_entry);
if (dd == NULL)
return -1;
while (fat_read_dir(dd, &entries[entryCount].dir_entry) && (entryCount < maxCount)) {
if (!strcmp(entries[entryCount].dir_entry.long_name, "."))
continue;
entries[entryCount].setFromParentEntry(this);
entryCount++;
}
fat_close_dir(dd);
return entryCount;
}
bool SDCardEntry::isEmpty() {
if (!isDirectory()) {
return false;
}
fat_dir_struct *dd = fat_open_dir(SDCard.fs, &dir_entry);
if (dd == NULL)
return -1;
uint8_t cnt = 0;
struct fat_dir_entry_struct entry;
uint8_t ret;
while ((ret = fat_read_dir(dd, &entry))) {
if (!strcmp(entry.long_name, ".") ||
!strcmp(entry.long_name, "..")) {
continue;
} else {
cnt++;
break;
}
}
fat_close_dir(dd);
return (cnt == 0);
}
int main()
{
/* we will just use ordinary idle mode */
set_sleep_mode(SLEEP_MODE_IDLE);
/* setup uart */
uart_init();
while(1)
{
/* setup sd card slot */
if(!sd_raw_init())
{
#if DEBUG
uart_puts_p(PSTR("MMC/SD initialization failed\n"));
#endif
continue;
}
/* open first partition */
struct partition_struct* partition = partition_open(sd_raw_read,
sd_raw_read_interval,
#if SD_RAW_WRITE_SUPPORT
sd_raw_write,
sd_raw_write_interval,
#else
0,
0,
#endif
0
);
if(!partition)
{
/* If the partition did not open, assume the storage device
* is a "superfloppy", i.e. has no MBR.
*/
partition = partition_open(sd_raw_read,
sd_raw_read_interval,
#if SD_RAW_WRITE_SUPPORT
sd_raw_write,
sd_raw_write_interval,
#else
0,
0,
#endif
-1
);
if(!partition)
{
#if DEBUG
uart_puts_p(PSTR("opening partition failed\n"));
#endif
continue;
}
}
/* open file system */
struct fat_fs_struct* fs = fat_open(partition);
if(!fs)
{
#if DEBUG
uart_puts_p(PSTR("opening filesystem failed\n"));
#endif
continue;
}
/* open root directory */
struct fat_dir_entry_struct directory;
fat_get_dir_entry_of_path(fs, "/", &directory);
struct fat_dir_struct* dd = fat_open_dir(fs, &directory);
if(!dd)
{
#if DEBUG
uart_puts_p(PSTR("opening root directory failed\n"));
#endif
continue;
}
/* print some card information as a boot message */
print_disk_info(fs);
/* provide a simple shell */
char buffer[24];
while(1)
{
/* print prompt */
uart_putc('>');
uart_putc(' ');
/* read command */
char* command = buffer;
if(read_line(command, sizeof(buffer)) < 1)
continue;
/* execute command */
if(strcmp_P(command, PSTR("init")) == 0)
{
break;
}
else if(strncmp_P(command, PSTR("cd "), 3) == 0)
{
command += 3;
if(command[0] == '\0')
continue;
/* change directory */
struct fat_dir_entry_struct subdir_entry;
if(find_file_in_dir(fs, dd, command, &subdir_entry))
{
struct fat_dir_struct* dd_new = fat_open_dir(fs, &subdir_entry);
if(dd_new)
{
fat_close_dir(dd);
dd = dd_new;
continue;
}
}
uart_puts_p(PSTR("directory not found: "));
uart_puts(command);
uart_putc('\n');
}
else if(strcmp_P(command, PSTR("ls")) == 0)
{
/* print directory listing */
struct fat_dir_entry_struct dir_entry;
while(fat_read_dir(dd, &dir_entry))
{
uint8_t spaces = sizeof(dir_entry.long_name) - strlen(dir_entry.long_name) + 4;
uart_puts(dir_entry.long_name);
uart_putc(dir_entry.attributes & FAT_ATTRIB_DIR ? '/' : ' ');
while(spaces--)
uart_putc(' ');
uart_putdw_dec(dir_entry.file_size);
uart_putc('\n');
}
}
else if(strncmp_P(command, PSTR("cat "), 4) == 0)
{
command += 4;
if(command[0] == '\0')
continue;
/* search file in current directory and open it */
struct fat_file_struct* fd = open_file_in_dir(fs, dd, command);
if(!fd)
{
uart_puts_p(PSTR("error opening "));
uart_puts(command);
uart_putc('\n');
continue;
}
/* print file contents */
uint8_t buffer[8];
uint32_t offset = 0;
while(fat_read_file(fd, buffer, sizeof(buffer)) > 0)
{
uart_putdw_hex(offset);
uart_putc(':');
for(uint8_t i = 0; i < 8; ++i)
{
uart_putc(' ');
uart_putc_hex(buffer[i]);
}
uart_putc('\n');
offset += 8;
}
fat_close_file(fd);
}
else if(strcmp_P(command, PSTR("disk")) == 0)
{
if(!print_disk_info(fs))
uart_puts_p(PSTR("error reading disk info\n"));
}
#if FAT_WRITE_SUPPORT
else if(strncmp_P(command, PSTR("rm "), 3) == 0)
{
command += 3;
if(command[0] == '\0')
continue;
struct fat_dir_entry_struct file_entry;
if(find_file_in_dir(fs, dd, command, &file_entry))
{
if(fat_delete_file(fs, &file_entry))
continue;
}
uart_puts_p(PSTR("error deleting file: "));
uart_puts(command);
uart_putc('\n');
}
else if(strncmp_P(command, PSTR("touch "), 6) == 0)
{
command += 6;
if(command[0] == '\0')
continue;
struct fat_dir_entry_struct file_entry;
if(!fat_create_file(dd, command, &file_entry))
{
uart_puts_p(PSTR("error creating file: "));
uart_puts(command);
uart_putc('\n');
}
}
else if(strncmp_P(command, PSTR("write "), 6) == 0)
{
command += 6;
if(command[0] == '\0')
continue;
char* offset_value = command;
while(*offset_value != ' ' && *offset_value != '\0')
++offset_value;
if(*offset_value == ' ')
*offset_value++ = '\0';
else
continue;
/* search file in current directory and open it */
struct fat_file_struct* fd = open_file_in_dir(fs, dd, command);
if(!fd)
{
uart_puts_p(PSTR("error opening "));
uart_puts(command);
uart_putc('\n');
continue;
}
int32_t offset = strtolong(offset_value);
if(!fat_seek_file(fd, &offset, FAT_SEEK_SET))
{
uart_puts_p(PSTR("error seeking on "));
uart_puts(command);
uart_putc('\n');
fat_close_file(fd);
continue;
}
/* read text from the shell and write it to the file */
uint8_t data_len;
while(1)
{
/* give a different prompt */
uart_putc('<');
uart_putc(' ');
/* read one line of text */
data_len = read_line(buffer, sizeof(buffer));
if(!data_len)
break;
/* write text to file */
if(fat_write_file(fd, (uint8_t*) buffer, data_len) != data_len)
{
uart_puts_p(PSTR("error writing to file\n"));
break;
}
}
fat_close_file(fd);
}
else if(strncmp_P(command, PSTR("mkdir "), 6) == 0)
{
command += 6;
if(command[0] == '\0')
continue;
struct fat_dir_entry_struct dir_entry;
if(!fat_create_dir(dd, command, &dir_entry))
{
uart_puts_p(PSTR("error creating directory: "));
uart_puts(command);
uart_putc('\n');
}
}
#endif
#if SD_RAW_WRITE_BUFFERING
else if(strcmp_P(command, PSTR("sync")) == 0)
{
if(!sd_raw_sync())
uart_puts_p(PSTR("error syncing disk\n"));
}
#endif
else if(strcmp_P(command, PSTR("sync")) == 0)
{
// vytvor adresar mereni_teploty
// nekonecna smycka - pomoci RTCka kazdou minutu odmer teplotu
}
else
{
uart_puts_p(PSTR("unknown command: "));
uart_puts(command);
uart_putc('\n');
}
}
/* close directory */
fat_close_dir(dd);
/* close file system */
fat_close(fs);
/* close partition */
partition_close(partition);
}
return 0;
}
int syscall_file_opendir(unsigned long *vdirdesc, char *dirname)
{
return fat_open_dir(vdirdesc, dirname);
}
