WaspSD Class Reference

WaspSD Class. More...

#include <WaspSD.h>

Collaboration diagram for WaspSD:

[legend]

Public Member Functions
	WaspSD ()
	class constructor
uint16_t	cleanFlags (void)
	It clears the flag.
uint8_t	isSD ()
	It checks if there is a SD Card in the slot.
void	ON ()
	It powers the SD card, initialize it and prepare it to work with.
void	OFF ()
	It powers off the SD card and closes the pointers.
char *	init ()
	It initializes the use of SD cards, looks into the root partition, opens the file system and initializes the public pointer that can be used to access the filesystem.
void	close ()
	It closes the directory, filesystem and partition pointers.
void	begin ()
	It sets switch and sd_present pin as output and input.
void	setMode (uint8_t mode)
	It sets power mode.
char *	print_disk_info ()
	It packs all the data about the disk into the buffer and returns it back. The buffer will then be available and offer the data to the developers as a human-readable encoded string.
offset_t	getDiskSize ()
	It gets the total disk size.
offset_t	getDiskFree ()
	It gets the free disk size.
uint8_t	cd (const char *command)
	It changes the directory.
uint8_t	cd (struct fat_dir_entry_struct subdir_entry)
	It changes the directory.
int8_t	numFiles ()
	It gets the amount of files in a directory.
char *	ls (void)
	It lists a directory.
char *	ls (int offset)
	It lists a directory.
char *	ls (int offset, int scope, uint8_t info)
	It lists a directory.
uint8_t	find_file_in_dir (const char *name, struct fat_dir_entry_struct *dir_entry)
	It tests existence of files in the dd folder.
uint8_t	mkdir (const char *dirname)
	It creates a directory.
uint8_t	isDir (struct fat_dir_entry_struct file_entry)
	It checks if an entry is a file or a directory.
int8_t	isDir (const char *dirname)
	It checks if an entry is a file or a directory.
uint8_t	del (const char *name)
	It deletes a file or a directory.
uint8_t	delDir (uint8_t depth)
	It deletes a directory.
uint8_t	delFile (struct fat_dir_entry_struct file_entry)
	It deletes a file.
struct fat_file_struct *	openFile (const char *filename)
	It opens a file.
void	closeFile (struct fat_file_struct *_fd)
	It closes a file.
int8_t	isFile (const char *filename)
	It tests the existence of a file in the current folder.
int32_t	numln (const char *filename)
	It gets the amount of lines in a file.
int32_t	getFileSize (const char *name)
	It gets the file size for filename in the current folder.
char *	getAttributes (const char *name)
	It gets the attributes for a directory or file entry.
char *	cat (const char *filename, int32_t offset, uint16_t scope)
	It dumps into the buffer the amount of bytes in scope after offset coming from filename.
uint8_t *	catBin (const char *filename, int32_t offset, uint16_t scope)
	It dumps into the bufferBin the amount of bytes in scope after offset coming from filename.
char *	catln (const char *filename, uint32_t offset, uint16_t scope)
	It dumps into the buffer the amount of lines in scope after offset lines coming from filename.
int32_t	indexOf (const char *filename, const char *pattern, uint32_t offset)
	It searches for first occurrence of a string in a file.
uint8_t	create (const char *filename)
	It creates a file.
uint8_t	writeSD (const char *filename, const char *str, int32_t offset)
	It writes strings to a file.
uint8_t	writeSD (const char *filename, uint8_t *str, int32_t offset)
	It writes integer array to a file.
uint8_t	writeSD (const char *filename, const char *str, int32_t offset, int16_t length)
	It writes strings to a file of a specific length.
uint8_t	append (const char *filename, const char *str)
	It writes strings at the end of files.
uint8_t	append (const char *filename, const char *str, uint16_t length)
	It writes strings at the end of files of a specific length.
uint8_t	append (const char *filename, uint8_t *str)
	It writes integer arrays at the end of files.
uint8_t	appendln (const char *filename, const char *str)
	It writes strings at the end of files adding an EOL.
uint8_t	appendln (const char *filename, uint8_t *str)
	It writes integer arrays at the end of files adding an EOL.
const char *	getLibVersion (void)
	It gets the library version.
Data Fields
char	buffer [DOS_BUFFER_SIZE]
	Variable : buffer containing the information coming from the card used to avoid calls to UART functions inside the library. Beware, there could be data longer than the buffer size.
uint8_t	bufferBin [BIN_BUFFER_SIZE]
	Variable : buffer containing the binary information coming from the card used to avoid calls to UART functions inside the library. Beware, there could be data longer than the buffer size.
uint16_t	flag
	Variable : flag storing the state of the SD card during initialization and operation.
uint8_t	_pwrMode
	Variable : It stores the SD power mode. Possible values are SD_ON or SD_OFF.
struct fat_fs_struct *	fs
	Structure pointer : filesystem pointer.
struct partition_struct *	partition
	Structure pointer : partition pointer.
struct fat_dir_struct *	dd
	Structure pointer : directory structure pointer.
struct fat_file_struct *	fd
	Structure pointer : generic file pointer.
offset_t	diskFree
	Variable : amount of free bytes in the drive.
offset_t	diskSize
	Variable : total byte size of the drive.

---

Detailed Description

WaspSD Class.

WaspSD Class defines all the variables and functions used to manage the SD Card

Definition at line 174 of file WaspSD.h.

---

Constructor & Destructor Documentation

WaspSD::WaspSD

(

)

class constructor

It does nothing

Parameters:

void

Returns:

void

Definition at line 32 of file WaspSD.cpp.

{
    // nothing to do
}

---

Member Function Documentation

uint16_t WaspSD::cleanFlags

(

void

)

It clears the flag.

It does nothing

Parameters:

void

Returns:

'flag' variable

Definition at line 1749 of file WaspSD.cpp.

References flag.

{
  flag = 0;
  return flag;
}

uint8_t WaspSD::isSD

(

)

It checks if there is a SD Card in the slot.

Parameters:

void

Returns:

'1' if SD is present, '0' otherwise

Definition at line 218 of file WaspSD.cpp.

References close(), digitalRead(), and SD_PRESENT.

Referenced by cat(), catBin(), catln(), cd(), create(), del(), find_file_in_dir(), getAttributes(), getDiskFree(), getDiskSize(), getFileSize(), indexOf(), init(), ls(), mkdir(), numFiles(), numln(), openFile(), print_disk_info(), and writeSD().

{
  if (digitalRead(SD_PRESENT))    return 1;
    
  // if the SD is not there, the best is to close all the pointers
  // just to avoid problems later one with calls to functions  
  close();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspSD::ON

(

void

)

It powers the SD card, initialize it and prepare it to work with.

Parameters:

void

Returns:

void

See also:

close(), begin()

Definition at line 44 of file WaspSD.cpp.

References begin(), init(), SD_ON, and setMode().

{
        begin();
        setMode(SD_ON);
        init();
}

Here is the call graph for this function:

void WaspSD::OFF

(

void

)

It powers off the SD card and closes the pointers.

Parameters:

void

Returns:

void

See also:

close(), begin()

Definition at line 57 of file WaspSD.cpp.

References close(), SD_OFF, and setMode().

{
        close();
        setMode(SD_OFF);
}

Here is the call graph for this function:

char * WaspSD::init

(

void

)

It initializes the use of SD cards, looks into the root partition, opens the file system and initializes the public pointer that can be used to access the filesystem.

Parameters:

void

Returns:

human readable string indicating success or possible errors that can be printed by the user directly

Definition at line 112 of file WaspSD.cpp.

References CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, fat_get_dir_entry_of_path(), fat_open(), fat_open_dir(), FILESYSTEM_FAILED, FILESYSTEM_FAILED_em, flag, fs, INIT_FAILED, INIT_FAILED_em, isSD(), NOTHING_FAILED, NOTHING_FAILED_em, partition, PARTITION_FAILED, PARTITION_FAILED_em, partition_open(), ROOT_DIR_FAILED, ROOT_DIR_FAILED_em, sd_raw_init(), sd_raw_read(), sd_raw_read_interval(), sd_raw_write(), and sd_raw_write_interval().

Referenced by ON(), WaspGPRS::readDataFTP(), and WaspGPRS::sendDataFTP().

{

  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    return CARD_NOT_PRESENT_em;
  }
  

  // proceed with initialization
  if(!sd_raw_init())
  {
    flag = INIT_FAILED;
    return INIT_FAILED_em;
  }
  

  // 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)
    {
      flag = PARTITION_FAILED;
      return PARTITION_FAILED_em;
    }
  }
  

  // open file system 
  fs = fat_open(partition);
  if(!fs)
  {
    flag = FILESYSTEM_FAILED;
    return FILESYSTEM_FAILED_em;
  }
  

  // open root directory
  struct fat_dir_entry_struct directory;
  fat_get_dir_entry_of_path(fs, "/", &directory);


  dd = fat_open_dir(fs, &directory);
  if(!dd)
  {
    flag = ROOT_DIR_FAILED;
    return ROOT_DIR_FAILED_em;
  }
  

  flag = NOTHING_FAILED;
  return NOTHING_FAILED_em;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspSD::close

(

void

)

It closes the directory, filesystem and partition pointers.

This function closes all the pointers in use in the library, so that they can be reused again after a call to init(). It becomes very useful if e.g. the card is removed and inserted again

Parameters:

void

Returns:

void

Definition at line 194 of file WaspSD.cpp.

References dd, fat_close(), fat_close_dir(), fs, INPUT, partition, partition_close(), pinMode(), SD_MISO, SD_MOSI, SD_SCK, and SD_SS.

Referenced by isSD(), OFF(), WaspGPRS::readDataFTP(), and WaspGPRS::sendDataFTP().

{
  // close dir 
  fat_close_dir(dd);

  // close file system 
  fat_close(fs);

  // close partition 
  partition_close(partition);
  
  pinMode(SD_SS,INPUT);
  pinMode(SD_SCK,INPUT);
  pinMode(SD_MISO,INPUT);
  pinMode(SD_MOSI,INPUT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspSD::begin

(

void

)

It sets switch and sd_present pin as output and input.

Parameters:

void

Returns:

void

Definition at line 67 of file WaspSD.cpp.

References INPUT, MEM_PW, OUTPUT, pinMode(), and SD_PRESENT.

Referenced by ON(), WaspGPRS::readDataFTP(), and WaspGPRS::sendDataFTP().

{
  // activate the power to the SD card
  pinMode(MEM_PW, OUTPUT);
  pinMode(SD_PRESENT, INPUT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspSD::setMode

(

uint8_t

mode

)

It sets power mode.

Parameters:

uint8_t

mode : SD_ON or SD_OFF

Returns:

void

Definition at line 80 of file WaspSD.cpp.

References _pwrMode, delay(), digitalWrite(), HIGH, LOW, MEM_PW, SD_OFF, and SD_ON.

Referenced by OFF(), ON(), WaspGPRS::readDataFTP(), and WaspGPRS::sendDataFTP().

{
        _pwrMode=mode;
        switch(_pwrMode)
        {
                case    SD_ON:
                        digitalWrite(MEM_PW, HIGH);
                        delay(10);
                        break;
                case    SD_OFF:
                        digitalWrite(MEM_PW,LOW);
                        break;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * WaspSD::print_disk_info

(

)

It packs all the data about the disk into the buffer and returns it back. The buffer will then be available and offer the data to the developers as a human-readable encoded string.

Parameters:

void

Returns:

human readable string indicating success or possible errors that can be printed by the user directly

Definition at line 307 of file WaspSD.cpp.

References buffer, sd_raw_info::capacity, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, diskFree, diskSize, fat_get_fs_free(), fat_get_fs_size(), flag, sd_raw_info::flag_copy, sd_raw_info::flag_write_protect, sd_raw_info::flag_write_protect_temp, sd_raw_info::format, fs, isSD(), sd_raw_info::manufacturer, sd_raw_info::manufacturing_month, sd_raw_info::manufacturing_year, sd_raw_info::oem, sd_raw_info::product, sd_raw_info::revision, sd_raw_get_info(), and sd_raw_info::serial.

{
    struct fat_fs_struct* _fs;
    _fs=fs;
    
    // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return buffer;
  }

    if(!fs)
        return 0;

    struct sd_raw_info disk_info;
    if(!sd_raw_get_info(&disk_info))
        return 0;

    // update the publicly available size-related variables
    diskFree = fat_get_fs_free(_fs);
    diskSize = fat_get_fs_size(_fs);
 
    sprintf(buffer, "" \
    "manuf:  0x%x\n" \   
    "oem:    %s\n" \     
    "prod:   %s\n" \     
    "rev:    %x\n" \     
    "serial: 0x%lx\n" \   
    "date:   %u/%u\n" \  
    "size:   %u MB\n" \
    "free:   %lu/%lu\n" \
    "copy:   %u\n" \     
    "wr.pr.: %u/%u\n" \  
    "format: %u\n",   
    disk_info.manufacturer,          
    (char*) disk_info.oem,           
    (char*) disk_info.product,       
    disk_info.revision,              
    disk_info.serial,                
    disk_info.manufacturing_month,    
    disk_info.manufacturing_year,    
    disk_info.capacity / 1024 / 1024,                
    diskFree>>16,
    diskSize>>16,
    disk_info.flag_copy,             
    disk_info.flag_write_protect_temp,
    disk_info.flag_write_protect,    
    disk_info.format);            
    
    return buffer;
}

Here is the call graph for this function:

offset_t WaspSD::getDiskSize

(

)

It gets the total disk size.

Parameters:

void

Returns:

the total size for the disk

Definition at line 235 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, diskSize, fat_get_fs_size(), flag, fs, and isSD().

{
    struct fat_fs_struct* _fs;            // filesystem pointer
    _fs=fs;
    
    // check if the card is there or not
    if (!isSD())
    {
        flag = CARD_NOT_PRESENT;
        sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
        return 0;
    }
 
  // update the publicly available size-related variables
    diskSize = fat_get_fs_size(_fs);
    return diskSize;
}

Here is the call graph for this function:

offset_t WaspSD::getDiskFree

(

)

It gets the free disk size.

Parameters:

void

Returns:

the total available space for the disk

Definition at line 260 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, diskFree, fat_get_fs_free(), flag, fs, and isSD().

{
    struct fat_fs_struct* _fs;
    _fs = fs;
  
    // check if the card is there or not
    if (!isSD())
    {
        flag = CARD_NOT_PRESENT;
        sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
        return 0;
    }

  // update the publicly available size-related variables
    diskFree = fat_get_fs_free(_fs);
    return diskFree;
}

Here is the call graph for this function:

uint8_t WaspSD::cd

(

const char *

command

)

It changes the directory.

Parameters:

const

char* command : the directory we want to change to

Returns:

'1' on success, '0' if error

See also:

cd(struct fat_dir_entry_struct subdir_entry)

Definition at line 394 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, fat_close_dir(), fat_open_dir(), find_file_in_dir(), flag, fs, and isSD().

Referenced by del(), numFiles(), WaspGPRS::readDataFTP(), and WaspGPRS::sendDataFTP().

{
    struct fat_fs_struct* _fs;
    _fs=fs;
    
    uint8_t exit=2;
    while(exit>0)
    {
        // check if the card is there or not
        if (!isSD())
        {
            flag = CARD_NOT_PRESENT;
            sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
            return 0;
        }
        struct fat_dir_entry_struct subdir_entry;
        if(find_file_in_dir(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;
                return 1;
            }
        }
        exit--;
        if(!exit) return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::cd

(

struct fat_dir_entry_struct

subdir_entry

)

It changes the directory.

Parameters:

struct

fat_dir_entry_struct subdir_entry : the directory we want to change to

Returns:

'1' on success, '0' if error

See also:

cd(const char* command)

Definition at line 376 of file WaspSD.cpp.

References dd, fat_close_dir(), fat_open_dir(), and fs.

{
    struct fat_fs_struct* _fs;
    _fs=fs;
    
    struct fat_dir_struct* dd_new = fat_open_dir(_fs, &subdir_entry);
    if(dd_new)
    {
        fat_close_dir(dd);
        dd = dd_new;
        return 1;
    }
    return 0;
}

Here is the call graph for this function:

int8_t WaspSD::numFiles

(

)

It gets the amount of files in a directory.

Parameters:

void

Returns:

'0' if no files, a negative value if error and a possitive value indicating the amount of files

Definition at line 1425 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, cd(), dd, fat_read_dir(), flag, and isSD().

{
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return -1;
  }

  uint8_t cont = -2;
  const char* command=".";
  struct fat_dir_entry_struct dir_entry;
  if(!(cd(command))) cont=0;
  while(fat_read_dir(dd, &dir_entry))
  {
    cont++;
  }

  return cont;
}

Here is the call graph for this function:

char * WaspSD::ls

(

void

)

It lists a directory.

Parameters:

void

Returns:

'buffer' variable containing the corresponding listing

See also:

ls(int offset), ls(int offset, int scope, uint8_t info)

Definition at line 629 of file WaspSD.cpp.

References SIZES.

Referenced by ls(), and WaspGPRS::readDataFTP().

{
  return ls(0,0, SIZES);    // calls DOS_ls to list files until filling the buffer
}

Here is the caller graph for this function:

char * WaspSD::ls

(

int

offset

)

It lists a directory.

Parameters:

int

offset : it jumps over "offset" filenames in the list

Returns:

'buffer' variable containing the corresponding listing

See also:

ls(void), ls(int offset, int scope, uint8_t info)

Definition at line 597 of file WaspSD.cpp.

References ls(), and SIZES.

{
  return ls(offset, 1, SIZES);  // call DOS_ls with just the offset parameter
}

Here is the call graph for this function:

char * WaspSD::ls	(	int	offset,
		int	scope,
		uint8_t	info = NAMES
	)

It lists a directory.

Parameters:

	int	offset : it jumps over "offset" filenames in the list
	int	scope : it includes a total of "scope" filenames in the buffer
	int	info : limits the amount of information to be sent back, ranges from NAMES, SIZES, to ATTRIBUTES

Returns:

'buffer' variable containing the corresponding listing

See also:

ls(void), ls(int offset)

Definition at line 457 of file WaspSD.cpp.

References ATTRIBUTES, fat_dir_entry_struct::attributes, buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, DOS_BUFFER_SIZE, FAT_ATTRIB_DIR, FAT_ATTRIB_READONLY, fat_read_dir(), fat_dir_entry_struct::file_size, flag, fs, isSD(), fat_dir_entry_struct::long_name, NAMES, SIZES, and TRUNCATED_DATA.

{
    struct fat_fs_struct* _fs;
    struct fat_dir_struct* _dd;
    _fs=fs;
    _dd=dd;
    
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return buffer;
  }
    
  // if scope is zero, then we should make it 
  // ridiculously big, so that it goes on reading forever
  if (scope <= 0) scope = 1000;
  
  flag &= ~(TRUNCATED_DATA);
  struct fat_dir_entry_struct dir_entry;
  
  // clean the offset (directory listings before the one requested)
  if (offset-- > 0) while(fat_read_dir(_dd, &dir_entry) && offset > 0) 
  {
      offset--;
  }

  // declare the variables needed to iterate the listings
  int buff_count = 0, j = 0, buff_size = 30, BUFF_SIZE = 30, dos_buff_left = DOS_BUFFER_SIZE;
  
  // iterate the directory
  // if there is a directory entry, then create a string out of it
  // and add it to the buffer
  while(fat_read_dir(_dd, &dir_entry) && scope > 0)
  {
    buff_size = BUFF_SIZE;
    
    // create the line variable
    char line[BUFF_SIZE];
    
    // fill in the variable with the corresponding string
    switch (info)
    {
      case NAMES:
        sprintf(line, "%s\n", dir_entry.long_name);
        break;
      case SIZES:
        sprintf(line, "%s%c\t%lu\n", dir_entry.long_name, dir_entry.attributes & FAT_ATTRIB_DIR ? '/' : ' ', dir_entry.file_size);
        break;
      case ATTRIBUTES:
        sprintf(line, "%c%c %s\t%lu\n", dir_entry.attributes & FAT_ATTRIB_DIR ? 'd' : '-', dir_entry.attributes & FAT_ATTRIB_READONLY ? 'r' : 'w', dir_entry.long_name, dir_entry.file_size);
        break;
      default:
        // by default print only filenames, like the linux "ls" command
        sprintf(line, "%s\n", dir_entry.long_name);
        break;
    }
    
    // add the line to the buffer (this won't work with another sprintf, libc-avr goes bananas)
    for (j=0; j < BUFF_SIZE; j++) 
    {
      if (j + buff_count < DOS_BUFFER_SIZE - 4) 
      {
        if (line[j] != '\0') buffer[j + buff_count] = line[j];
      
        // in case you reach end of string, jump off the loop
        if (buffer[j + buff_count] == '\n' || line[j] == '\0') 
        {
          buff_size = j + buff_count + 1;
          //continue;
          j = BUFF_SIZE;  // dirty way of leaving the loop
        }
      } 
      else
      {
        // in case we filled up the whole buffer, we add a
        // visual end of buffer indicator and leave the loop
        buffer[DOS_BUFFER_SIZE - 4] = '>';
        buffer[DOS_BUFFER_SIZE - 3] = '>';
        buffer[DOS_BUFFER_SIZE - 2] = '\n';
        buffer[DOS_BUFFER_SIZE - 1] = '\0';
        flag |= TRUNCATED_DATA; 

        // go to the end of the directory
        while(fat_read_dir(_dd, &dir_entry)); 
        return buffer;  // leave the function here
      }
    }
    buff_count = buff_size;
    scope--;
  }

  // add an end of string to the buffer
  buffer[buff_count] = '\0';
  
  // go to the end of the directory
  while(fat_read_dir(_dd, &dir_entry)); 

  // return the buffer as long as there is any
  // data inside, zero if the directory was empty or
  // if there was an error
  if (buff_count > 0) return buffer;
  return 0;
}

Here is the call graph for this function:

uint8_t WaspSD::find_file_in_dir	(	const char *	name,
		struct fat_dir_entry_struct *	dir_entry
	)

It tests existence of files in the dd folder.

Parameters:

	const	char* name : the file to find
	struct	fat_dir_entry_struct* dir_entry : the directory pointer to find the file in

Returns:

'1' if the file is availabe, '0' otherwise

Definition at line 643 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, fat_read_dir(), fat_reset_dir(), flag, isSD(), and fat_dir_entry_struct::long_name.

Referenced by cd(), del(), getAttributes(), getFileSize(), isDir(), isFile(), mkdir(), and openFile().

{
    struct fat_dir_struct* _dd;
    _dd=dd;
  // check if the card is there or not
    if (!isSD())
    {
        flag = CARD_NOT_PRESENT;
        sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
        return 0;
    }

    while(fat_read_dir(_dd, dir_entry))
    {
        if(strcmp(dir_entry->long_name, name) == 0)
        {
            fat_reset_dir(_dd);
            return 1;
        }
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::mkdir

(

const char *

dirname

)

It creates a directory.

Parameters:

const

char* dirname : the directory to create

Returns:

'1' on success, '0' otherwise

Definition at line 1396 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, DIR_CREATION_ERROR, fat_create_dir(), find_file_in_dir(), flag, and isSD().

{
    struct fat_dir_struct* _dd;
    _dd=dd;
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= DIR_CREATION_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return 0;
  }

  flag &= ~(DIR_CREATION_ERROR);
  struct fat_dir_entry_struct dir_entry;
  if( (find_file_in_dir(dirname,&dir_entry)) || (!fat_create_dir(_dd, dirname, &dir_entry)) )
  {
      flag |= DIR_CREATION_ERROR;
      return 0;
  }
  return 1;
}

Here is the call graph for this function:

uint8_t WaspSD::isDir

(

struct fat_dir_entry_struct

file_entry

)

It checks if an entry is a file or a directory.

Parameters:

struct

fat_dir_entry_struct file_entry : the entry to check

Returns:

'1' if it is a directory, '0' otherwise

See also:

isDir(const char* dirname)

Definition at line 1240 of file WaspSD.cpp.

References fat_dir_entry_struct::attributes, and FAT_ATTRIB_DIR.

Referenced by del(), and delDir().

{
    return dir_entry.attributes & FAT_ATTRIB_DIR ? 1 : 0;
}

Here is the caller graph for this function:

int8_t WaspSD::isDir

(

const char *

dirname

)

It checks if an entry is a file or a directory.

Parameters:

const

char* dirname : the entry to check

Returns:

'1' if it is a directory, '0' otherwise

See also:

isDir(struct fat_dir_entry_struct file_entry)

Definition at line 1252 of file WaspSD.cpp.

References fat_dir_entry_struct::attributes, FAT_ATTRIB_DIR, and find_file_in_dir().

{
    struct fat_dir_entry_struct dir_entry;
    if(find_file_in_dir(dirname,&dir_entry)) 
    {
        return dir_entry.attributes & FAT_ATTRIB_DIR ? 1 : 0;
    }
    return -1;
}

Here is the call graph for this function:

uint8_t WaspSD::del

(

const char *

name

)

It deletes a file or a directory.

It allows only erasing depth one directories, thus if the user calls to erase a directory with subdirs, it will exit with error without erasing the directory . It also allows erasing current directory "." under the same premises: it should contain no subdirectories or it will exit with error. Thanks to this function, together with delFile, delDir and isDir it is possible to create more complex delete functions that could iterate through any directory structure

Parameters:

const

char* name : the file or directory to delete

Returns:

'1' on success, '0' otherwise

See also:

delDir(uint8_t depth), delFile(struct fat_dir_entry_struct file_entry)

Definition at line 1321 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, cd(), delDir(), delFile(), find_file_in_dir(), flag, isDir(), isSD(), WaspUtils::strCmp(), and Utils.

Referenced by WaspGPS::saveEphems().

{
    
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return 0;
  }

  // first case: erase the contents in current directory
  if (Utils.strCmp(name,".\0",2) == 0)
  {
    return delDir(0);
  }
  
  // second case: erase whatever else
  struct fat_dir_entry_struct file_entry;
  if(find_file_in_dir(name,&file_entry))
  {
    if (isDir(file_entry))
    {
      if(!(cd(file_entry))) return 0;
      uint8_t aux = delDir(0);
      if(!(cd(".."))) return 0;
      if (aux) 
      {
        aux &= delFile(file_entry);
      }
      return aux;
    }
    else
      return delFile(file_entry);
  }
  
  // if you made this far, it gotta be an error
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::delDir

(

uint8_t

depth

)

It deletes a directory.

It allows only erasing depth one directories, thus if the user calls to erase a directory with subdirs, it will exit with error without erasing the directory . It also allows erasing current directory "." under the same premises: it should contain no subdirectories or it will exit with error. Thanks to this function, together with delFile, del and isDir it is possible to create more complex delete functions that could iterate through any directory structure

Parameters:

uint8_t

depth : is still not used, but function supports developers actualizations

Returns:

'1' on success, '0' otherwise

See also:

del(const char* name), delFile(struct fat_dir_entry_struct file_entry)

Definition at line 1283 of file WaspSD.cpp.

References dd, fat_delete_file(), fat_read_dir(), fs, isDir(), fat_dir_entry_struct::long_name, WaspUtils::strCmp(), and Utils.

Referenced by del().

{
  uint8_t exit = 1;
  struct fat_dir_entry_struct dir_entry;
  struct fat_dir_struct* _dd;
  struct fat_fs_struct* _fs;
  _fs=fs;
  _dd = dd;
  while(fat_read_dir(_dd, &dir_entry))
  {
    if (isDir(dir_entry) && !(Utils.strCmp(dir_entry.long_name,".\0",2) == 0 || Utils.strCmp(dir_entry.long_name,"..\0",3) == 0)) exit = 0;
  }
  if (exit) while(fat_read_dir(_dd, &dir_entry))
  {
    if (!(Utils.strCmp(dir_entry.long_name,".\0",2) == 0 || Utils.strCmp(dir_entry.long_name,"..\0",3) == 0)) 
    {
      exit &= fat_delete_file(_fs, &dir_entry);
    }
  }
  return exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::delFile

(

struct fat_dir_entry_struct

file_entry

)

It deletes a file.

Thanks to this function, together with delDir, del and isDir it is possible to create more complex delete functions that could iterate through any directory structure

Parameters:

struct

fat_dir_entry_struct file_entry : the file to delete

Returns:

'1' on success, '0' otherwise

See also:

del(const char* name), delDir(uint8_t depth)

Definition at line 1268 of file WaspSD.cpp.

References fat_delete_file(), and fs.

Referenced by del().

{
    struct fat_fs_struct* _fs;
    _fs=fs;
    if(fat_delete_file(_fs,&file_entry)) return 1;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct fat_file_struct * WaspSD::openFile

(

const char *

filename

)

[read]

It opens a file.

Parameters:

const

char* filename : the file to open

Returns:

'0' if error, file pointer on success

Definition at line 696 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, fat_open_file(), fd, FILE_OPEN_ERROR, find_file_in_dir(), flag, fs, and isSD().

Referenced by cat(), catBin(), catln(), indexOf(), numln(), and writeSD().

{

    struct fat_fs_struct* _fs;
    struct fat_dir_struct* _dd;
    _fs=fs;
    _dd=dd;
    struct fat_file_struct* _fd;
    _fd=fd;
    
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return 0;
  }

  flag &= ~(FILE_OPEN_ERROR);
  struct fat_dir_entry_struct file_entry;
    if(!find_file_in_dir(filename,&file_entry))
    {
        flag |= FILE_OPEN_ERROR;
        return 0;
    }

    _fd=fat_open_file(_fs,&file_entry);
    if(!_fd) return fat_open_file(_fs,&file_entry);
    return _fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspSD::closeFile

(

struct fat_file_struct *

_fd

)

It closes a file.

Parameters:

struct

fat_file_struct* _fd : the file to close

Returns:

void

Definition at line 734 of file WaspSD.cpp.

References fat_close_file().

{
    fat_close_file(_fd);
}

Here is the call graph for this function:

int8_t WaspSD::isFile

(

const char *

filename

)

It tests the existence of a file in the current folder.

Parameters:

const

char* filename : the file to check

Returns:

'1' on success, '0' if it is a directory, '-1' otherwise

Definition at line 677 of file WaspSD.cpp.

References fat_dir_entry_struct::attributes, FAT_ATTRIB_DIR, and find_file_in_dir().

Referenced by WaspGPS::saveEphems().

{
    struct fat_dir_entry_struct file_entry;
    if(find_file_in_dir(filename,&file_entry)) 
    {
        return file_entry.attributes & FAT_ATTRIB_DIR ? 0 : 1;
    }
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t WaspSD::numln

(

const char *

filename

)

It gets the amount of lines in a file.

Parameters:

const

char* filename : the file to check

Returns:

number of lines on success, '-1' otherwise

Definition at line 1696 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, fat_close_file(), fat_read_file(), fd, FILE_OPEN_ERROR, flag, isSD(), and openFile().

{
    struct fat_file_struct* _fd;
    _fd=fd;
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return -1;
  }
    
  flag &= ~(FILE_OPEN_ERROR);

  // search file in current directory and open it 
  // assign the file pointer to the general file pointer "fp"
  // exit if error and modify the general flag with FILE_OPEN_ERROR
  _fd = openFile(filename);
  if(!_fd)
  {
    sprintf(buffer, "error opening %s", filename);
    flag |= FILE_OPEN_ERROR;
    return -1;
  }

  byte maxBuffer = 1;  // size of the buffer to use when reading
  uint8_t bufferSD[maxBuffer];
  uint32_t cont = 0;
  
  // jump over offset lines
  uint8_t readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  while( readRet > 0)   
  {
    for(uint8_t i = 0; i < maxBuffer; ++i)
    {
      if (bufferSD[i] == '\n')
        cont++;
    }
    readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  }

  fat_close_file(_fd);

  return cont;

}

Here is the call graph for this function:

int32_t WaspSD::getFileSize

(

const char *

name

)

It gets the file size for filename in the current folder.

Parameters:

const

char* name : the file to check

Returns:

file size on success, '-1' otherwise

Definition at line 747 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, FILE_OPEN_ERROR, fat_dir_entry_struct::file_size, find_file_in_dir(), flag, and isSD().

Referenced by append(), and indexOf().

{
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return -1;
  }

  flag &= ~(FILE_OPEN_ERROR);
  struct fat_dir_entry_struct file_entry;
    if(!find_file_in_dir(name,&file_entry))
    {
        flag |= FILE_OPEN_ERROR;
        return -1;
    }

    return file_entry.file_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * WaspSD::getAttributes

(

const char *

name

)

It gets the attributes for a directory or file entry.

Parameters:

const

char* name : the file or directory to check

Returns:

returns the attributes for a directory or file entry in the current directory. The attributes are encoded with two characters:

• char #1: it is either "d" for a directory or "-" for a file entry
• char #2: is either "r" for read only, and "w" if the file/directory is also writeable If the file or directory is not available in the folder, it will answer "--"

Definition at line 781 of file WaspSD.cpp.

References fat_dir_entry_struct::attributes, buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, FAT_ATTRIB_DIR, FAT_ATTRIB_READONLY, FILE_OPEN_ERROR, find_file_in_dir(), flag, and isSD().

{
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return buffer;
  }

  flag &= ~(FILE_OPEN_ERROR);
  struct fat_dir_entry_struct file_entry;
    if(!find_file_in_dir(name,&file_entry))
    {
        flag |= FILE_OPEN_ERROR;
        return "--";
    }

    char attrib[2];
    sprintf(attrib, "%c%c", file_entry.attributes & FAT_ATTRIB_DIR ? 'd' : '-', file_entry.attributes & FAT_ATTRIB_READONLY ? 'r' : 'w');

    return attrib;
}

Here is the call graph for this function:

char * WaspSD::cat	(	const char *	filename,
		int32_t	offset,
		uint16_t	scope
	)

It dumps into the buffer the amount of bytes in scope after offset coming from filename.

There is a limitation in size, due to DOS_BUFFER_SIZE. If the data read was bigger than that, the function will include the characters ">>" at the end and activate the TRUNCATED_DATA value in the DOS.flag. It is recommened to check this value to assure data integrity.

Parameters:

	const	char* filename : the file to get the data from
	int32_t	offset : amount of bytes to jump before start dumping the data to the buffer
	uint16_t	scope : amount of bytes for dumping to the buffer

Returns:

'buffer' variable where the data has been dumped

See also:

catBin (const char* filename, int32_t offset, uint16_t scope), catln (const char* filename, uint32_t offset, uint16_t scope)

Definition at line 832 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, DOS_BUFFER_SIZE, fat_close_file(), fat_read_file(), fat_seek_file(), FAT_SEEK_SET, fd, FILE_OPEN_ERROR, flag, isSD(), openFile(), and TRUNCATED_DATA.

Referenced by WaspGPRS::sendDataFTP().

{
    struct fat_file_struct* _fd;
    _fd=fd;
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return buffer;
  }
    
  // if scope is zero, then we should make it 
  // ridiculously big, so that it goes on reading forever
  if (scope <= 0) scope = 1000;
  
  flag &= ~(TRUNCATED_DATA | FILE_OPEN_ERROR);

  // search file in current directory and open it 
  // assign the file pointer to the general file pointer "fp"
  // exit if error and modify the general flag with FILE_OPEN_ERROR
  _fd = openFile(filename);
  if(!_fd)
  {
    sprintf(buffer, "error opening %s", filename);
    flag |= FILE_OPEN_ERROR;
    return buffer;
  }

  // iterate through the file
  byte maxBuffer = 10;  // size of the buffer to use when reading
  uint8_t bufferSD[maxBuffer];
  uint32_t cont = 0;
  
  // first jump over the offset
  if(!fat_seek_file(_fd, &offset, FAT_SEEK_SET))
  {
          sprintf(buffer, "error seeking on: %s\n", filename);
          fat_close_file(_fd);
          return buffer;
  }
  
  uint8_t readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));

  // second, read the data and store it in the DOS.buffer
  // as long as there is room in it
  while(readRet > 0 && scope > 0 && cont < DOS_BUFFER_SIZE)
  {
    for(uint8_t i = 0; i < readRet; ++i)
    {
      buffer[cont++] = bufferSD[i];
      scope--;
      if( scope <=0 ) break;
      if( cont>=DOS_BUFFER_SIZE ) break;
    }
    if( readRet<maxBuffer ) break;
    readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  }
  if (cont < DOS_BUFFER_SIZE - 1) {
    buffer[cont++] = '\0';
  }
  else
  {
    // in case we filled up the whole buffer, we add a
    // visual end of buffer indicator and leave the loop
    buffer[DOS_BUFFER_SIZE - 4] = '>';
    buffer[DOS_BUFFER_SIZE - 3] = '>';
    buffer[DOS_BUFFER_SIZE - 2] = '\n';
    buffer[DOS_BUFFER_SIZE - 1] = '\0';
    flag |= TRUNCATED_DATA; 
  }

  fat_close_file(_fd);

  return buffer;

}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t * WaspSD::catBin	(	const char *	filename,
		int32_t	offset,
		uint16_t	scope
	)

It dumps into the bufferBin the amount of bytes in scope after offset coming from filename.

Parameters:

	const	char* filename : the file to get the data from
	int32_t	offset : amount of bytes to jump before start dumping the data to the buffer
	uint16_t	scope : amount of bytes for dumping to the buffer

Returns:

'bufferBin' variable where the data has been dumped

See also:

cat (const char* filename, int32_t offset, uint16_t scope), catln (const char* filename, uint32_t offset, uint16_t scope)

Definition at line 937 of file WaspSD.cpp.

References BIN_BUFFER_SIZE, buffer, bufferBin, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, fat_close_file(), fat_read_file(), fat_seek_file(), FAT_SEEK_SET, fd, FILE_OPEN_ERROR, flag, isSD(), openFile(), and TRUNCATED_DATA.

Referenced by WaspGPS::loadEphems().

{
        struct fat_file_struct* _fd;
        _fd=fd;
  // check if the card is there or not
        if (!isSD())
        {
                flag = CARD_NOT_PRESENT;
                flag |= FILE_OPEN_ERROR;
                sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
                return bufferBin;
        }
    
  // if scope is zero, then we should make it 
  // ridiculously big, so that it goes on reading forever
        if (scope <= 0) scope = 1000;
  
        flag &= ~(TRUNCATED_DATA | FILE_OPEN_ERROR);

  // search file in current directory and open it 
  // assign the file pointer to the general file pointer "fp"
  // exit if error and modify the general flag with FILE_OPEN_ERROR
        _fd = openFile(filename);
        if(!_fd)
        {
                sprintf(buffer, "error opening %s", filename);
                flag |= FILE_OPEN_ERROR;
                return bufferBin;
        }

  // iterate through the file
        byte maxBuffer = 1;  // size of the buffer to use when reading
        uint8_t bufferSD[maxBuffer];
        uint32_t cont = 0;
  
  // first jump over the offset
        if(!fat_seek_file(_fd, &offset, FAT_SEEK_SET))
        {
                sprintf(buffer, "error seeking on: %s\n", filename);
                fat_close_file(_fd);
                return bufferBin;
        }
  
        uint8_t readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));

  // second, read the data and store it in the DOS.buffer
  // as long as there is room in it
        while(readRet > 0 && scope > 0 && cont < BIN_BUFFER_SIZE)
        {
                for(uint8_t i = 0; i < maxBuffer; ++i)
                {
                        bufferBin[cont++] = bufferSD[i];
                        scope--;
                        readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
                }
        }

        fat_close_file(_fd);

        return bufferBin;

}

Here is the call graph for this function:

Here is the caller graph for this function:

char * WaspSD::catln	(	const char *	filename,
		uint32_t	offset,
		uint16_t	scope
	)

It dumps into the buffer the amount of lines in scope after offset lines coming from filename.

There is a limitation in size, due to DOS_BUFFER_SIZE. If the data read was bigger than that, the function will include the characters ">>" at the end and activate the TRUNCATED_DATA value in the DOS.flag. It is recommened to check this value to assure data integrity.

Parameters:

	const	char* filename : the file to get the data from
	uint32_t	offset : amount of lines to jump before start dumping the data to the buffer
	uint16_t	scope : amount of lines for dumping to the buffer

Returns:

'buffer' variable where the data has been dumped

See also:

cat (const char* filename, int32_t offset, uint16_t scope), catBin (const char* filename, int32_t offset, uint16_t scope)

Definition at line 1027 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, DOS_BUFFER_SIZE, fat_close_file(), fat_read_file(), fd, FILE_OPEN_ERROR, flag, isSD(), openFile(), and TRUNCATED_DATA.

{
    struct fat_file_struct* _fd;
    _fd=fd;
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return buffer;
  }
    
  // if scope is zero, then we should make it 
  // ridiculously big, so that it goes on reading forever
  if (scope <= 0) scope = 1000;
  
  flag &= ~(TRUNCATED_DATA | FILE_OPEN_ERROR);

  // search file in current directory and open it 
  // assign the file pointer to the general file pointer "fp"
  // exit if error and modify the general flag with FILE_OPEN_ERROR
  _fd = openFile(filename);
  if(!_fd)
  {
    sprintf(buffer, "error opening %s", filename);
    flag |= FILE_OPEN_ERROR;
    return buffer;
  }

  byte maxBuffer = 1;  // size of the buffer to use when reading
  uint8_t bufferSD[maxBuffer];
  uint32_t cont = 0;
  
  // jump over offset lines
  uint8_t readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  if (offset > 0) 
  {
    while( readRet > 0 && offset > 0)   
    {
      for(uint8_t i = 0; i < maxBuffer; ++i)
      {
        if (bufferSD[i] == '\n')
          offset--;
      }
      readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
    }

    // do not forget the first buffer  
    for(uint8_t i = 0; i < maxBuffer; ++i)
    {
      buffer[cont++] = bufferSD[i];
      if (bufferSD[i] == '\n')
        scope--;
    }

    readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  }
  
  // add to buffer scope lines
  while(readRet > 0 && scope > 0 && cont < DOS_BUFFER_SIZE)
  {
    for(uint8_t i = 0; i < maxBuffer; ++i)
    {
      buffer[cont++] = bufferSD[i];
      if (bufferSD[i] == '\n')
        scope--;
    }
    readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  }

  // are we at the end of the buffer yet?
  if (cont < DOS_BUFFER_SIZE - 1) {
    buffer[cont++] = '\0';
  }
  else
  {
    // in case we filled up the whole buffer, we add a
    // visual end of buffer indicator and leave the loop
    buffer[DOS_BUFFER_SIZE - 4] = '>';
    buffer[DOS_BUFFER_SIZE - 3] = '>';
    buffer[DOS_BUFFER_SIZE - 2] = '\n';
    buffer[DOS_BUFFER_SIZE - 1] = '\0';
    flag |= TRUNCATED_DATA; 
  }

  fat_close_file(_fd);

  return buffer;

}

Here is the call graph for this function:

int32_t WaspSD::indexOf	(	const char *	filename,
		const char *	pattern,
		uint32_t	offset
	)

It searches for first occurrence of a string in a file.

Parameters:

	const	char* filename : the file where looking for the pattern
	const	char* pattern : pattern to find
	uint32_t	offset : amount of bytes to jump before start looking for the pattern

Returns:

the amount of bytes to the pattern from the offset

Definition at line 1145 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, fat_close_file(), fat_read_file(), fd, FILE_OPEN_ERROR, flag, getFileSize(), isSD(), openFile(), WaspUtils::sizeOf(), WaspUtils::strCmp(), and Utils.

{
    struct fat_file_struct* _fd;
    _fd=fd;
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_OPEN_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return -1;
  }

  flag &= ~(FILE_OPEN_ERROR);

  // search file in current directory and open it 
  // assign the file pointer to the general file pointer "fp"
  // exit if error and modify the general flag with FILE_OPEN_ERROR
  _fd = openFile(filename);
  if(!_fd)
  {
    sprintf(buffer, "error opening %s", filename);
    flag |= FILE_OPEN_ERROR;
    return -1;
  }

  uint32_t limitSize = getFileSize(filename);

  uint8_t limitPattern = Utils.sizeOf(pattern);
  uint8_t bufferSD[1];
  uint8_t cmpPattern[limitPattern];
  uint8_t exit = 0, contPattern = 0;
  uint32_t cont = 0;

  // jump over the offset
  uint8_t readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  if (offset > 0) while(readRet > 0 && offset > 0) 
  { 
    readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
    offset--; 
    //cont++;  // we don't wanna count until we are done with the offset
  }

  // fill in the first buffer
  for(int j=0; j < limitPattern - 1; j++)
    if (readRet > 0)
    {
      cmpPattern[j] = bufferSD[0];
      readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
    }
    else
      exit = 1;  // exit if the filesize is smaller than the pattern

//to debug the code in the library it is possible to use the buffer together with sprintf, e.g.
//sprintf(buffer,"%s - %c%c%c%c - %lu - %u -%lu", pattern, cmpPattern[0], cmpPattern[1], cmpPattern[2], bufferSD[0], cont, limitPattern, limitSize);

  // run inside the buffer
  while(readRet > 0 && cont < limitSize && !exit)
  {
    // take the last position in the buffer
    cmpPattern[limitPattern-1] = bufferSD[0];
    
    // compare the strings, exit if found
//    if(strcmp((const char*) pattern, (const char*) cmpPattern) == 0)
    if(Utils.strCmp((const char*) pattern, (const char*) cmpPattern, limitPattern) == 0)
      exit = 1;
      
    // if not exit, increment counter
    if (!exit) 
      cont++;
      
    // shift cmpPattern to the left one position
    for(int j = 0; j < limitPattern - 1; j++) cmpPattern[j] = cmpPattern[j+1];
    
    // read the next buffer
    readRet = fat_read_file(_fd, bufferSD, sizeof(bufferSD));
  }

  fat_close_file(_fd);

  // in case we checked the whole buffer, we return error
  if (cont >= limitSize - 1) 
    return -1; 

  // otherwise we return the pattern's location
  return cont;

}

Here is the call graph for this function:

uint8_t WaspSD::create

(

const char *

filename

)

It creates a file.

Parameters:

const

char* filename : the file to create

Returns:

'1' on success, '0' otherwise

Definition at line 1367 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, dd, fat_create_file(), FILE_CREATION_ERROR, flag, and isSD().

Referenced by WaspGPRS::readDataFTP(), and WaspGPS::saveEphems().

{
    struct fat_dir_struct* _dd;
    _dd=dd;
  // check if the card is there or not
  if (!isSD())
  {
    flag = CARD_NOT_PRESENT;
    flag |= FILE_CREATION_ERROR;
    sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
    return 0;
  }

  flag &= ~(FILE_CREATION_ERROR);
  struct fat_dir_entry_struct file_entry;
  if(!fat_create_file(_dd, filename, &file_entry))
  {
      flag |= FILE_CREATION_ERROR;
      return 0;
  }
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::writeSD	(	const char *	filename,
		const char *	str,
		int32_t	offset
	)

It writes strings to a file.

Parameters:

	const	char* filename : the file to write to
	const	char* str : the string to write into the file
	int32_t	offset : amount of bytes to jump before start writing the string

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, const char* str), append(const char* filename, uint8_t* str), appendln(const char* filename, const char* str), appendln(const char* filename, uint8_t* str)

Definition at line 1535 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, fat_close_file(), fat_seek_file(), FAT_SEEK_SET, fat_write_file(), fd, FILE_WRITING_ERROR, flag, isSD(), openFile(), WaspUtils::sizeOf(), and Utils.

Referenced by append(), and WaspGPS::saveEphems().

{
    struct fat_file_struct* _fd;
    _fd=fd;
  // check if the card is there or not
    if (!isSD())
    {
        flag = CARD_NOT_PRESENT;
        flag |= FILE_WRITING_ERROR;
        sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
        return 0;
    }

    flag &= ~(FILE_WRITING_ERROR);
    uint8_t exit = 0;
  // search file in current directory and open it
    _fd = openFile(filename);
    if(!_fd)
    {
        sprintf(buffer, "error opening: %s\n", filename);
        exit = 1;
    }

    if(!exit) if(!fat_seek_file(_fd, &offset, FAT_SEEK_SET))
    {
        sprintf(buffer, "error seeking on: %s\n", filename);
        fat_close_file(_fd);
        exit = 1;
    }

    uint16_t data_len = Utils.sizeOf(str);

  // write text to file
    if(!exit) if(fat_write_file(_fd, (uint8_t*) str, data_len) != data_len)
    {
        sprintf(buffer, "error writing to: %s\n", filename);
        fat_close_file(_fd);
        exit = 1;
    }

    if(!exit) fat_close_file(_fd);
    else flag |= FILE_WRITING_ERROR;
    return !exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::writeSD	(	const char *	filename,
		uint8_t *	str,
		int32_t	offset
	)

It writes integer array to a file.

Parameters:

	const	char* filename : the file to write to
	uint8_t*	str : the integer array to write into the file
	int32_t	offset : amount of bytes to jump before start writing the string

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, const char* str, int32_t offset), append(const char* filename, const char* str), append(const char* filename, uint8_t* str), appendln(const char* filename, const char* str), appendln(const char* filename, uint8_t* str)

Definition at line 1588 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, fat_close_file(), fat_seek_file(), FAT_SEEK_SET, fat_write_file(), fd, FILE_WRITING_ERROR, flag, isSD(), and openFile().

{
        struct fat_file_struct* _fd;
        _fd=fd;
  // check if the card is there or not
        if (!isSD())
        {
                flag = CARD_NOT_PRESENT;
                flag |= FILE_WRITING_ERROR;
                sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
                return 0;
        }

        flag &= ~(FILE_WRITING_ERROR);
        uint8_t exit = 0;
  // search file in current directory and open it
        _fd = openFile(filename);
        if(!_fd)
        {
                sprintf(buffer, "error opening: %s\n", filename);
                exit = 1;
        }

        if(!exit) if(!fat_seek_file(_fd, &offset, FAT_SEEK_SET))
        {
                sprintf(buffer, "error seeking on: %s\n", filename);
                fat_close_file(_fd);
                exit = 1;
        }

        uint16_t data_len = 0;
        while( (str[data_len]!=0xAA) || (str[data_len+1]!=0xAA) ) data_len++;

  // write text to file
        if(!exit) if(fat_write_file(_fd, str, data_len) != data_len)
        {
                sprintf(buffer, "error writing to: %s\n", filename);
                fat_close_file(_fd);
                exit = 1;
        }

        if(!exit) fat_close_file(_fd);
        else flag |= FILE_WRITING_ERROR;
        return !exit;
}

Here is the call graph for this function:

uint8_t WaspSD::writeSD	(	const char *	filename,
		const char *	str,
		int32_t	offset,
		int16_t	length
	)

It writes strings to a file of a specific length.

Parameters:

	const	char* filename : the file to write to
	const	char* str : the string to write into the file
	int32_t	offset : amount of bytes to jump before start writing the string
	int16_t	length : amount of bytes to write to the file

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, const char* str), append(const char* filename, uint8_t* str), appendln(const char* filename, const char* str), appendln(const char* filename, uint8_t* str)

Definition at line 1643 of file WaspSD.cpp.

References buffer, CARD_NOT_PRESENT, CARD_NOT_PRESENT_em, fat_close_file(), fat_seek_file(), FAT_SEEK_SET, fat_write_file(), fd, FILE_WRITING_ERROR, flag, isSD(), and openFile().

{
        struct fat_file_struct* _fd;
        _fd=fd;
  // check if the card is there or not
        if (!isSD())
        {
                flag = CARD_NOT_PRESENT;
                flag |= FILE_WRITING_ERROR;
                sprintf(buffer,"%s", CARD_NOT_PRESENT_em);
                return 0;
        }

        flag &= ~(FILE_WRITING_ERROR);
        uint8_t exit = 0;
  // search file in current directory and open it
        _fd = openFile(filename);
        if(!_fd)
        {
                sprintf(buffer, "error opening: %s\n", filename);
                exit = 1;
        }

        if(!exit) if(!fat_seek_file(_fd, &offset, FAT_SEEK_SET))
        {
                sprintf(buffer, "error seeking on: %s\n", filename);
                fat_close_file(_fd);
                exit = 1;
        }

  // write text to file
        if(!exit) if(fat_write_file(_fd, (uint8_t*) str, length) != length)
        {
                sprintf(buffer, "error writing to: %s\n", filename);
                fat_close_file(_fd);
                exit = 1;
        }

        if(!exit) fat_close_file(_fd);
        else flag |= FILE_WRITING_ERROR;
        return !exit;
}

Here is the call graph for this function:

uint8_t WaspSD::append	(	const char *	filename,
		const char *	str
	)

It writes strings at the end of files.

Parameters:

	const	char* filename : the file to write to
	const	char* str : the string to write into the file

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, const char* str, int32_t offset), writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, uint8_t* str), appendln(const char* filename, const char* str), appendln(const char* filename, uint8_t* str)

Definition at line 1455 of file WaspSD.cpp.

References getFileSize(), and writeSD().

Referenced by appendln(), and WaspGPRS::readDataFTP().

{
    return writeSD(filename, str, getFileSize(filename));
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspSD::append	(	const char *	filename,
		const char *	str,
		uint16_t	length
	)

It writes strings at the end of files of a specific length.

Parameters:

	const	char* filename : the file to write to
	const	char* str : the string to write into the file
	uint16_t	length : the length to write

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, const char* str, int32_t offset), writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, uint8_t* str), appendln(const char* filename, const char* str), appendln(const char* filename, uint8_t* str)

Definition at line 1468 of file WaspSD.cpp.

References getFileSize(), and writeSD().

{
        return writeSD(filename, str, getFileSize(filename), length);
}

Here is the call graph for this function:

uint8_t WaspSD::append	(	const char *	filename,
		uint8_t *	str
	)

It writes integer arrays at the end of files.

Parameters:

	const	char* filename : the file to write to
	uint8_t*	str : the integer array to write into the file

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, const char* str, int32_t offset), writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, const char* str), appendln(const char* filename, const char* str), appendln(const char* filename, uint8_t* str)

Definition at line 1482 of file WaspSD.cpp.

References getFileSize(), and writeSD().

{
        return writeSD(filename, str, getFileSize(filename));
}

Here is the call graph for this function:

uint8_t WaspSD::appendln	(	const char *	filename,
		const char *	str
	)

It writes strings at the end of files adding an EOL.

Parameters:

	const	char* filename : the file to write to
	const	char* str : the string to write into the file

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, const char* str, int32_t offset), writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, const char* str), append(const char* filename, uint8_t* str), appendln(const char* filename, uint8_t* str)

Definition at line 1496 of file WaspSD.cpp.

References append().

{
    uint8_t exit = 0;
    exit = append(filename, str);
#ifndef FILESYSTEM_LINUX
    if (exit) exit &= append(filename, "\r");
#endif
    if (exit) exit &= append(filename, "\n");
    return exit;
}

Here is the call graph for this function:

uint8_t WaspSD::appendln	(	const char *	filename,
		uint8_t *	str
	)

It writes integer arrays at the end of files adding an EOL.

Parameters:

	const	char* filename : the file to write to
	uint8_t*	str : the integer array to write into the file

Returns:

'1' on success, '0' otherwise

See also:

writeSD(const char* filename, const char* str, int32_t offset), writeSD(const char* filename, uint8_t* str, int32_t offset), append(const char* filename, const char* str), append(const char* filename, uint8_t* str), appendln(const char* filename, const char* str)

Definition at line 1516 of file WaspSD.cpp.

References append().

{
        uint8_t exit = 0;
        exit = append(filename, str);
#ifndef FILESYSTEM_LINUX
        if (exit) exit &= append(filename, "\r");
#endif
        if (exit) exit &= append(filename, "\n");
        return exit;
}

Here is the call graph for this function:

const char* WaspSD::getLibVersion

(

void

)

[inline]

It gets the library version.

Parameters:

void

Returns:

the library version

Definition at line 610 of file WaspSD.h.

References VERSION.

{return VERSION;};

---

Field Documentation

char WaspSD::buffer[DOS_BUFFER_SIZE]

Variable : buffer containing the information coming from the card used to avoid calls to UART functions inside the library. Beware, there could be data longer than the buffer size.

Definition at line 183 of file WaspSD.h.

Referenced by cat(), catBin(), catln(), cd(), create(), del(), find_file_in_dir(), getAttributes(), getDiskFree(), getDiskSize(), getFileSize(), indexOf(), ls(), mkdir(), numFiles(), numln(), openFile(), print_disk_info(), WaspGPRS::sendDataFTP(), and writeSD().

uint8_t WaspSD::bufferBin[BIN_BUFFER_SIZE]

Variable : buffer containing the binary information coming from the card used to avoid calls to UART functions inside the library. Beware, there could be data longer than the buffer size.

Definition at line 188 of file WaspSD.h.

Referenced by catBin(), and WaspGPS::loadEphems().

uint16_t WaspSD::flag

Variable : flag storing the state of the SD card during initialization and operation.

Definition at line 193 of file WaspSD.h.

Referenced by cat(), catBin(), catln(), cd(), cleanFlags(), create(), del(), find_file_in_dir(), getAttributes(), getDiskFree(), getDiskSize(), getFileSize(), indexOf(), init(), WaspGPS::loadEphems(), ls(), mkdir(), numFiles(), numln(), openFile(), print_disk_info(), WaspGPS::saveEphems(), and writeSD().

uint8_t WaspSD::_pwrMode

Variable : It stores the SD power mode. Possible values are SD_ON or SD_OFF.

Definition at line 198 of file WaspSD.h.

Referenced by setMode().

struct fat_fs_struct* WaspSD::fs [read]

Structure pointer : filesystem pointer.

Definition at line 204 of file WaspSD.h.

Referenced by cd(), close(), delDir(), delFile(), getDiskFree(), getDiskSize(), init(), ls(), openFile(), and print_disk_info().

struct partition_struct* WaspSD::partition [read]

Structure pointer : partition pointer.

Definition at line 209 of file WaspSD.h.

Referenced by close(), and init().

struct fat_dir_struct* WaspSD::dd [read]

Structure pointer : directory structure pointer.

Definition at line 214 of file WaspSD.h.

Referenced by cd(), close(), create(), delDir(), find_file_in_dir(), init(), ls(), mkdir(), numFiles(), and openFile().

struct fat_file_struct* WaspSD::fd [read]

Structure pointer : generic file pointer.

Definition at line 219 of file WaspSD.h.

Referenced by cat(), catBin(), catln(), indexOf(), numln(), openFile(), and writeSD().

offset_t WaspSD::diskFree

Variable : amount of free bytes in the drive.

Definition at line 224 of file WaspSD.h.

Referenced by getDiskFree(), and print_disk_info().

offset_t WaspSD::diskSize

Variable : total byte size of the drive.

Definition at line 229 of file WaspSD.h.

Referenced by getDiskSize(), and print_disk_info().

---

The documentation for this class was generated from the following files:

• WaspSD.h
• WaspSD.cpp