Per l'utilizzo della memoria SD, la scelta del Filesystem è inevitabilmente ricaduta su uno di tipo FAT; in questo modo è possibile
caricare i file direttamente da pc.
Nel file fat16.c è implementato il supporto a FAT16, realizzando la stessa interfaccia di MPFS, in modo tale da essere compatibile con esso (per ora in sola lettura).
Ciò significa che i metodi di questo file hanno lo stesso nome, parametri e comportamento di quelli presenti nel file MPFS.c.

Per meglio comprendere il funzionamento del codice, vediamo com'è organizzata una generica memoria di massa.
Inannzitutto, la memoria è divisa in settori solitamente costituiti da 512byte; più settori insieme formano
un cluster, la cui dimensione viene stabilita durante la creazione della partizione, e scritta in un apposito campo del Filesystem.
Il cluster è l'unità di base della FAT16, ad esempio un file di dimensione nulla, occupa comunque un intero cluster.
Il primo settore è denominato MBR (Master Boot Record), e contiene principalmente codice eseguibile per il lancio del sistema operativo.
Il nostro interesse, però, ricade su una piccola porzione di questo settore, ovvero la Partition Table, nella quale troviamo informazioni sulle partizioni.
In particolare, da un campo di tale tabella si può ricavare la locazione d'inizio della partizione, e quindi del Filesystem.

Tali informazioni sulle partizioni sono così formate:

Quindi il campo che vogliamo leggere è il byte 0x1C6 del primo settore.

A questo punto possiamo leggere il primo settore della FAT16 (detto Boot Record), nel quale troviamo
numerose informazioni che devono essere salvate in alcune varibili.

Abbiamo già visto il MBR e il FBR, mentre per quando riguarda le altre zone:

• FAT (File Allocation Table): nel Filesystem FAT16, come in molti altri, i cluster che formano un file
  non sono necessariamente contigui, ma sono spesso frammentati (cioè sparsi dove capita nel disco); per questo motivo esiste
  l'area denominata FAT, la quale contiene liste concatenate che permettono di rimettere in ordine i cluster di un singolo file.
• FAT2: è semplicemente una copia di sicurezza della FAT.
• Root Directory: contiene l'elenco dei file contenuti nella directory radice del disco.
• Data Area: qui è dove si trovano i file.

Nel Filesystem MPFS i file sono contigui, quindi per semplificare il codice, nello stack Microchip un file è indentificato
dal suo indirizzo nella memoria (ma viene chiamato handle). Nel caso della FAT16, però, tale informazione non è
sufficiente, o meglio, richiederebbe di effettuare diversi calcoli ogni volta che si deve eseguire una lettura dalla memoria;
per tale motivo, è presente una tabella (denominata handleTable) contenente alcune informazioni. La define MAX_OPENED_FILES
determina la dimensione massima della tabella.

typedef struct {
	BYTE  attrib;
	WORD  cluster;		// cluster in DataArea
	BYTE  sector;   	// sector in cluster
	WORD  byte;		// byte in sector;
	DWORD filesize;
} handleEntry;

handleEntry handleTable[MAX_OPENED_FILES];

Giunti qui, possiamo vedere l'inizializzazione del driver FAT16:

/* partition data */
DWORD partitionStart;	
BYTE  clusterSize;		// sectors per cluster
DWORD fatStart;
DWORD rootStart;
DWORD dataArea;
BYTE  rootSize;

BOOL FATInit() {
	char* buf_pt = &sd_buffer[0];
	char i;

	sdPresent = SDInit();

	if (!sdPresent)
		return FALSE;

	SDReadSector(0);
	partitionStart = *(DWORD*)(buf_pt+0x1C6);

	SDReadSector(partitionStart);
	clusterSize = buf_pt[0x0D];	
	fatStart = partitionStart + *(WORD*)(buf_pt+0x0E);
	rootStart = fatStart + (*(WORD*)(buf_pt+0x16)) * buf_pt[0x10];
	rootSize = *(WORD*)(buf_pt+0x11) * sizeof(dirEntry) / SECTOR_SIZE;
	dataArea = rootStart + rootSize;

	for (i = 0; i < MAX_OPENED_FILES; i++)
		handleTable[i].attrib = FREE_HANDLE;

	mpfsOpenCount = 0;

	return TRUE;
}

Oltre ad inizializzare la memoria SD e la tabella degli Handle, vengono calcolati alcuni indirizzi caratteristici del Filesystem:

Questi indirizzi e dimensioni sono espressi in settori di 512byte.

Una directory è costituita da elementi della stessa dimensione (32 byte)
che, per quanto concerne i file con nomi corti (8+3), contengono questi campi:

In particolare i campi Nome ed Estensione sono sempre scritti in maiscuolo, ed i caratteri non presenti
sono riempiti con il carattere spazio (0x20 in esadecimale). Ad esempio il file Pippo.txt sarà scritto nella forma

PIPPO   TXT     50 49 50 50 4F 20 20 20 54 58 54

Il metodo MPFSOpen cerca un file nella memoria, e se lo trova crea un handle e lo restituisce al chiamante:

MPFS MPFSOpen(BYTE* name){
	BYTE scount, ecount;
	dirEntry* entry;
	char* buf_pt = &sd_buffer[0];
	char i;
	char name_ext[11];

	if (!sdPresent) return MPFS_INVALID;

	for (i=0; i<11; i++)
		name_ext[i] = 0x20;
	
	for (i=0; i<8 && *name!='.' && *name; i++)
		name_ext[i] = toupper(*name++);

	if (*name == '.') {
		name++;
		for (i=8; i<11 && *name; i++)
			name_ext[i] = toupper(*name++);
	}

	scount = 0;
	while (scount < rootSize) {
		SDReadSector(rootStart + scount);

		ecount = 16;
		entry = (dirEntry*)buf_pt;
		while (ecount--) {
			if (entry->attrib == 0x0F) goto next;
// Long File Name
			if (entry->name_ext[0] == 0x00 || entry->name_ext[0] == 0xE5) goto next;
// Empty Entry
			if (memcmp((void*)name_ext, (void*)entry->name_ext, 11) == 0) { 	// found!
				for (i=0; i < MAX_OPENED_FILES && handleTable[i].attrib!=FREE_HANDLE; i++);
				if (i == MAX_OPENED_FILES) return MPFS_NOT_AVAILABLE;
				handleTable[i].attrib = USED_HANDLE;
				handleTable[i].cluster = entry->cluster;
				handleTable[i].filesize = entry->size;	
				handleTable[i].sector = 0;   	
				handleTable[i].byte = 0;
				mpfsOpenCount++;
				return i;
			}
		next:
			entry++;
		}

		scount++;
	}

	return MPFS_INVALID;
}

Nella prima parte, il nome del file viene scritto nella forma 8+3 vista in precedenza. In questo modo sarà
possibile confrontarlo con quelli presenti nella Root Directory. A questo punto vengono lette tutte le entry (elementi)
della Directory, partendo dal primo settore ed eventualmente leggendo i settori successivi.
Quando il confronto tra il nome del file cercato e quello letto dalla memoria ha esito positivo, viene cercato un handle libero
nella tabella, quindi vengono salvati alcuni dati:

• filesize: la dimensione del file in byte.
• cluster: il primo cluster del file nella Data Area.
• sector: inizializzato a zero perchè tiene traccia di quale settore stiamo leggendo all'interno dello stesso cluster
• byte: analogamente a sector, tiene traccia dell'ultimo byte letto all'interno del settore.

Con MPFSGetBegin il driver si prepara a leggere il file aperto con MPFSOpen, caricando nel buffer il settore
del file puntato dalle varibili salvate nella tabella:

BOOL MPFSGetBegin(MPFS handle){
	if (handle >= MAX_OPENED_FILES || handleTable[handle].attrib != USED_HANDLE)
		return FALSE;		
// invalid handle

 	if (handleTable[handle].filesize == 0)
		return TRUE;

	_currentHandle = handle;
	SDReadSector(dataArea + 
(handleTable[handle].cluster-2)*clusterSize + handleTable[handle].sector);

	return TRUE;
}

Da notare che i cluster iniziano da 2 e non da zero, inoltre il numero di cluster non è un indirizzo assoluto rispetto all'intera memoria
ma è relativo alla Data Area, quindi all'indirizzo da caricare va sommato l'indirizzo della Data Area.

La funzione MPFSGet legge e restituisce un byte del file alla volta. Se tale byte si trova caricato nel buffer
della memoria SD, è sufficiente leggerlo da lì, altrimenti bisogna calcolare il prossimo settore da caricare. Quest'ultimo
se si trova all'interno dello stesso cluster sarà semplicemente il successivo, altrimenti è necessario leggere la FAT per individuare il prossimo cluster.

BYTE MPFSGet() {
	char* buf_pt = &sd_buffer[0];
	BYTE b = 0;
	WORD tmp;

	if (_currentHandle == MPFS_INVALID)
		return 0;

	if (handleTable[_currentHandle].byte >= SECTOR_SIZE) {
		handleTable[_currentHandle].byte = 0;
		handleTable[_currentHandle].sector++;
		if (handleTable[_currentHandle].sector >= clusterSize) {
			tmp = handleTable[_currentHandle].cluster;
			SDReadSector(fatStart + tmp / (SECTOR_SIZE /2) );		
// read FAT Area
			handleTable[_currentHandle].cluster = *(WORD*)(buf_pt + (tmp % (SECTOR_SIZE/2)) * 2);
// next cluster in chain
			handleTable[_currentHandle].sector = 0;
		}
		SDReadSector(dataArea + (handleTable[_currentHandle].cluster-2)*clusterSize +
handleTable[_currentHandle].sector);
	}


	b = buf_pt[handleTable[_currentHandle].byte++];
	handleTable[_currentHandle].filesize--;

	return b;
}

Nella FAT, ad ogni parola di 16 bit corrisponde un cluster. Per fare un esempio, se stiamo leggendo il file che inizia al cluster 4 (cioè il 5°),
per conoscere il prossimo cluster del file, sarà sufficiente leggere la parola corrispondente nella FAT, ovvero la 5°. L'ultima parola di una catena
è 0xFFFF.
Essendo le parole di 16bit, in un settore della FAT sono presenti 256 elementi; perciò per sapere quale settore della FAT è necessario
caricare viene eseguito questo calcolo:

cluster_corrente / (SECTOR_SIZE /2)

A questo punto, possiamo conoscere il prossimo cluster leggendo la parola numero

(cluster_corrente % (SECTOR_SIZE/2)) * 2

all'interno di tale settore.

Altri metodi:

void MPFSClose() {
	mpfsOpenCount--;	// decrementa il numero di file aperti
	handleTable[_currentHandle].attrib = FREE_HANDLE;  // libera l'handle
}

BOOL MPFSIsEOF(void) {
	return (handleTable[_currentHandle].filesize == -1);  // se la dimensione è -1, il file è finito
}

Ti potrebbe interessare anche:

Esegui programmi in parallelo su microcontrollori multi-core con supporto AMP

Lo standard Amba-LITE – Un modello sintetizzabile di periferiche master e slave

Ottimizzazione del codice firmware

Articoli Correlati

FTPmicro Tutorial – Esempio pratico

FTPmicro Tutorial – SMTP

FTPmicro Tutorial – SD.c