TinyFATFS ..?

[picnoobie]

Non any1 provato TinyFAT da http://elm-chan.org/fsw/ff/00index_e.html
su un Pic.

Riesco a leggere / scrivere i settori, ma non può capire
come rendere il funzionamento del sistema di file.
Sto utilizzando Sandisk 256MB formattato FAT16.
Vorrei solo leggere / scrivere un file di testo

I'm using Student Edition MPLab7.52 C30.

grazie.

 

[picnoobie]

Sto facendo alcuni progressi sono ora in grado
di creare delle directory viste come cartelle in WinXP.
Ora sto cercando di creare file di testo vuoto, ma
nessuna fortuna ancora, allora cercherò, se ho potuto leggere.

 

[Gorkin]

Grande Fratello lavoro!Puoi condividere con noi?
Quali microcontroller sono utilizzati ora?Do You trovato problemi nel dichiarare di grandi dimensioni variabili di stack usando MPLAB C18 compiler?

Gorkin ...

 

[picnoobie]

Non è ciò che sembra:

controllare il mio post qui http://forum.microchip.com/tm.aspx?m=243523

è in corso, ma atleast per certo so che una parte del lib sta lavorando cioè rendere directory, è per questo che ho postato qui sperando di ottenere aiuta.

 

[picnoobie]

aggiornamento ...

Ho trovato la fonte del problema, non so ancora il
significato di quello che ho fatto, a parte che mi ha permesso di creare una directory e file txt.
Posso, ora, creare una directory all'interno di una dir, e un file all'interno di una directory.

a che fare: leggere file txt, fare una semplice interfaccia di comando.

Ecco il driver mmc, come quello che ho postato sul forum uChip:Codice:# include <p24HJ128GP510.h>

/ / # include "delay.h"

# include "diskio.h"/ / extern void stampa (char * str); / / stampa a lcd

/ / extern void cls (); / / Clear LCD

/ / lcd_gotoxy extern void (uint8 x, uint8 y); / / goto colonna lcd / riga/ * MMC / SD comando (in SPI) * /

# define CMD0 (0x40 0) / * GO_IDLE_STATE * /

# define cmd1 (0x40 1) / * SEND_OP_COND * /

# define CMD8 (0x40 8) / * SEND_IF_COND * /

# define CMD9 (0x40 9) / * SEND_CSD * /

# define CMD10 (0x40 10) / * SEND_CID * /

# define CMD12 (0x40 12) / * STOP_TRANSMISSION * /

# define CMD16 (0x40 16) / * SET_BLOCKLEN * /

# define CMD17 (0x40 17) / * READ_SINGLE_BLOCK * /

# define CMD18 (0x40 18) / * READ_MULTIPLE_BLOCK * /

# define CMD24 (0x40 24) / * WRITE_BLOCK * /

# define CMD25 (0x40 25) / * WRITE_MULTIPLE_BLOCK * /

# define CMD41 (0x40 41) / * SEND_OP_COND (ACMD) * /

# define CMD55 (0x40 55) / * APP_CMD * /

# define CMD58 (0x40 58) / * READ_OCR * // * Segnali di controllo (dipendente dalla piattaforma) * /

/ / # define CS _LATA4

# define SELECT () LATA & = ~ 16 / MMC * CS = L * /

# define Deseleziona () LATA | = 16 / * MMC CS = H * /

# define SOCKPORT PORTA / * porta di contatto Socket * /

# define SOCKWP PORTAbits.RA0 / * switch di protezione da scrittura (PB5) * /

# define SOCKINS PORTAbits.RA1 / * Card rilevare switch (PB4) * /

/ / # define isWriteProtect () (PORTAbits.RA0 & 0x01) / / _RA1 / * switch di protezione da scrittura (PB5) * /

/ / # define isCardDetect () (PORTAbits.RA1 & 0x01) / / _RA0 / * Card rilevare switch (PB4) * /

/ / # define WPTRIS TRISAbits.TRISA0

/ / # define INTRIS TRISAbits.TRISA1static volatile

DSTATUS Stat = STA_NOINIT; / * status di disco * /static volatile

BYTE Timer1, timer2; / * 100Hz timer decremento * /static

BYTE BlkAddr; / * 0: Byte affrontare, 1: Block Addressing * // / cfgSPI1Master (void);

/ / Wp BYTE, cd;void cfgSpi1Master (void)

(

/ / SPI1CON1 Registrati Impostazioni

SPI1CON1bits.DISSCK = 0; / / interno Serial Clock è abilitato.

SPI1CON1bits.DISSDO = 0; / / pin SDOx è controllato dal modulo.

SPI1CON1bits.SSEN = 0; / / SS pin non utilizzati

SPI1CON1bits.MODE16 = 0; / / La comunicazione è a livello di byte (8 bit).

SPI1CON1bits.SMP = 0; / Input / I dati sono campionati a metà di dati in tempo di uscita.

SPI1CON1bits.CKE = 1; / / modifiche di dati seriali in uscita sul passaggio da stato a stato di inattività clock clock attivo

SPI1CON1bits.CKP = 0; / / stato Inattivo per l'orologio è un livello basso, è stato attivo un elevato livello

SPI1CON1bits.MSTEN = 1; / / Master Mode EnabledSPI1CON1bits.SPRE2 = 1; / / 2:1 FCY = 40MHz 312KHz

SPI1CON1bits.SPRE1 = 1;

SPI1CON1bits.SPRE0 = 0;SPI1CON1bits.PPRE1 = 0; / / 64:1

SPI1CON1bits.PPRE0 = 0;/ / SPI1CON2 Registrati ImpostazioniSPI1CON2bits.FRMEN = 0; / / cornice Mode disabili

SPI1CON2bits.SPIFSD = 0; / / output sync Frame impulsi (master)

SPI1CON2bits.FRMPOL = 0; / / impulso di sincronismo Frame è attivo-basso

/ / SPI1CON2bits.FRMDLY = 0; / / impulso di sincronismo Frame precede clock po 'prima

/ / SPI1CON2bits.ENHBUF = 0; / / FIFO buffer disabili/ / SPI1STAT Registrati ImpostazioniSPI1STATbits.SPISIDL = 0; / / Continua il funzionamento del modulo in modo Standby

SPI1STATbits.BUFELM = 0; / / Buffer Length = 1 Word

SPI1STATbits.SPIROV = 0; / / No Overflow ricevere ha verificato

SPI1STATbits.SPIEN = 1; / / Enable SPI Module/ / Interrupt Controller Settings

IFS0bits.SPI1IF = 0; / / Clear SPI1 Interrupt Flag

IEC0bits.SPI1IE = 1; / / Attiva SPI1 Interrupt)/*================================================ =============================

Interrupt Service Routine.

================================================== ===========================*/

void __attribute__ ((__interrupt__)) _SPI1Interrupt (void)

(

IFS0bits.SPI1IF = 0;

)/ ** /

unsigned int SPI1_Read (void)

(

SPI1BUF = 0xFF; / / se SPI1BUF = 0x00, come era nella cartella lib spi lavoro che doesn '

while (! SPI1STATbits.SPIRBF);

SPI1STATbits.SPIROV = 0;

if (SPI1CON1bits.MODE16) (

return SPI1BUF;

else ()

return SPI1BUF &0xff;

))

/ ** /

void SPI1_Write (dati unsigned int)

(

if (SPI1CON1bits.MODE16) (

SPI1BUF = dati;

else ()

SPI1BUF = dati &0xff;

)

while (SPI1STATbits.SPITBF);

data = SPI1BUF;

)
/*------------------------------------------------ -----------------------*/

/ * Wait for card pronta * /

/*------------------------------------------------ -----------------------*/static

Wait_ready BYTE (void)

(

BYTE res;Timer2 = 50; / * Wait for pronto in timeout di 500 ms * /

SPI1_Read ();

fare

res = SPI1_Read ();

while ((res! = 0xFF) & & timer2);

return res;

)/ ** /

void CloseSPI1 (void)

(

/ / SELECT (); / * Wait for card ready * /

/ / wait_ready ();

/ / Deselezionare ();

/ / SPI1_Read ();

/ / Disattiva il bit di interrupt nel registro Interrupt Enable Control

IEC0bits.SPI1IE = 0;/ / Disattiva il modulo.
Tutti i perni controllate da funzioni portuali

SPI1STATbits.SPIEN = 0;/ / Disattiva il bit di flag di interrupt nel registro Interrupt Flag Control

IFS0bits.SPI1IF = 0;/ / Stat | = STA_NOINIT; / * Set STA_NOINIT * /)/*------------------------------------------------ -----------------------*/

/ * Ricevere un pacchetto di dati da MMC * /

/*------------------------------------------------ -----------------------*/static

BOOL rcvr_datablock (

BYTE * buff, / * buffer per memorizzare i dati ricevuti * /

uint16 BTR / * Byte count (devono essere ancora il numero) * /

)

(

BYTE token;Timer1 = 10;

do (/ * Wait for dati a pacchetto in timeout di 100 ms * /

token = SPI1_Read ();

) While ((token == 0xFF) & & Timer1);

if (token! = 0xFE) return FALSE; / * Se i dati non validi token, retutn con l'errore * /do (/ * Riceve il blocco di dati nel buffer * /

* buff = SPI1_Read ();

* buff = SPI1_Read ();

) While (BTR -= 2);

SPI1_Read (); / * Discard CRC * /

SPI1_Read ();return TRUE; / * Ritorna con successo * /

)
/*------------------------------------------------ -----------------------*/

/ * Invia un pacchetto di dati a MMC * /

/*------------------------------------------------ -----------------------*/# se _READONLY == 0

static

BOOL xmit_datablock (

const BYTE * buff, / * 512 byte di dati da trasmettere blocco * /

Token BYTE / * Data / Stop token * /

)

(

Resp BYTE, wc;if (wait_ready ()! = 0xFF) return FALSE;SPI1_Write (token); / * xmit dati token * /

if (token! = 0xFD) (/ * Is dati token * /

wc = 0;

do (/ * xmit i 512 byte di dati a blocchi di MMC * /

SPI1_Write (* buff );

SPI1_Write (* buff );

) While (- wc);

SPI1_Write (0xFF); / * CRC (Dummy) * /

SPI1_Write (0xFF);

/ / resp = SPI1_Read (); / * Reveive risposta di dati * //************************************************* *******************************

Questa è la parte che causa il problema

Non so ancora qual è il rovescio della medaglia commentando la

ma funziona per ora.

************************************************** ******************************/

SPI1_Read ();/ / se non ((resp & 0x1F)! = 0x05) / * In caso di accettazione, di ritorno con l'errore * /

/ / (

/ / _LATD0 = 1; / / debug

/ / Return FALSE;

/ /)

)return TRUE;

)

# endif / * _READONLY * //*------------------------------------------------ -----------------------*/

/ * Invia un pacchetto di comando per MMC * /

/*------------------------------------------------ -----------------------*/static

BYTE send_cmd (

BYTE cmd, / * byte di comando * /

Arg DWORD / * argomenti * /

)

(

N BYTE, res;if (wait_ready ()! = 0xFF) return 0xFF;/ * Invia il pacchetto di comando * /

SPI1_Write (cmd); / * Comando * /

SPI1_Write ((byte) (arg>> 24)); / * argomento [31 .. 24] * /

SPI1_Write ((byte) (arg>> 16)); / * argomento [23 .. 16] * /

SPI1_Write ((byte) (arg>> 8)); / * argomento [15 .. 8] * /

SPI1_Write ((byte) arg); / * argomento [7 .. 0] * /

n = 0;

if (cmd == CMD0) n = 0x95; / * CRC per CMD0 (0) * /

if (cmd == CMD8) n = 0x87; / * CRC per CMD8 (0x1AA) * /

SPI1_Write ;/ * Ricevuto la risposta di comando * /

if (cmd == CMD12) SPI1_Read (); / * Passa un byte di materiale durante la lettura di stop * /

n = 10; / * attesa di una risposta valida in timeout di 10 tentativi * /

fare

res = SPI1_Read ();

while ((RES & 0x80) & & - n);return res; / * Rientro con il valore di risposta * /

)/ *

static

int chk_power (void)

(

return (PORTE & 0x80)?
0: 1;

)

* /

/*------------------------------------------------ -----------------------*/

/ * Funzione Pubblica * //*-----------------------*/

/ * Inizializza disco Drive * /

/ * (Dipendente dalla piattaforma) * /

DSTATUS disk_initialize (

BYTE drv / * nmuber unità fisica (0) * /

)

(

N BYTE, f, OCR [4];Deseleziona (); / * CS = H * // / inizia con clk lento

SPI1CON1bits.SPRE2 = 1; / / 2:1 FCY = 40MHz doze 1:1 312KHz

SPI1CON1bits.SPRE1 = 1;

SPI1CON1bits.SPRE0 = 0;SPI1CON1bits.PPRE1 = 0; / / 64:1

SPI1CON1bits.PPRE0 = 0;IFS0bits.SPI1IF = 0; / / Clear SPI1 Interrupt Flag

SPI1STATbits.SPIROV = 0; / / No Overflow ricevere ha verificato

SPI1STATbits.SPIEN = 1; / / Enable SPI Modulefor (Timer1 = 1; Timer1; / * Wait for 10ms * // / Realizzato da SPI1STAT.SPIEN

/ / TRISFbits.TRISF6 = 0; / / Output RF6/SCK1

/ / TRISFbits.TRISF7 = 1; / / RF7/SDI1_E Input

/ / TRISFbits.TRISF8 = 0; / / Output RF8/SDO1_Eif (DRV) STA_NOINIT return; / * Supporta solo singolo disco * /

if (Stat & STA_NODISK) return Stat; / * No carta nella presa di corrente * /for (n = 10; n, n -) / * 80 orologi dummy * /

SPI1_Read ();SELECT (); / * CS = L * /f = 0;

if (send_cmd (CMD0, 0) == 1) (/ * Inserisci Stato Idle * /

Timer1 = 100; / * Inizializzazione timeout di 1000 ms * /if (send_cmd (CMD8, 0x1AA) == 1) (/ * DSC ver2 * /

for (n = 0; n <4; n )

ocr [n] = SPI1_Read ();

if (OCR [2] == 0x01 & & OCR [3] == 0xAA) (/ * La scheda può lavorare a distanza di 2,7 VDD-3.6V * /

do (

if (send_cmd (CMD55, 0) <= 1 & & send_cmd (CMD41, 1UL <<30) == 0)

break;

) While (Timer1);

if (Timer1 & & send_cmd (CMD58, 0) == 0) (/ * Check CCS bit * /

for (n = 0; n <4; n )

ocr [n] = SPI1_Read ();

f = (OCR [0] & 0x40)?
3: 1;

)

)

) Else (/ * DSC ver1 o MMC * /

if (send_cmd (CMD55, 0) <= 1 & & send_cmd (CMD41, 0) <= 1) f = 4; / * DSC?
* /

do (

if (! F & & send_cmd (cmd1, 0) == 0) break; / * per MMC * /

if (f & & send_cmd (CMD55, 0) <= 1 & & send_cmd (CMD41, 0) == 0) break; / * per DSC ver1 * /

) While (Timer1);

if (Timer1) f = 1;

)

if (f == 1 & & send_cmd (CMD16, 512)! = 0) / * Select R / W lunghezza del blocco * /

f = 0;

)Deseleziona (); / * CS = H * /

SPI1_Read (); / * Idle (Release DO) * /if (f & 1) (/ * Inizializzazione riuscita * /BlkAddr = (F & 2)?
1: 0; / * Get modo di indirizzamento * /

Stat & = ~ STA_NOINIT; / * STA_NOINIT Clear * /

/ / Stat = 0;

/ / accelerare spi clk

SPI1CON1bits.SPRE2 = 1; / / 1:1 FCY = 40MHz doze 1:1 10MHz

SPI1CON1bits.SPRE1 = 1;

SPI1CON1bits.SPRE0 = 1;SPI1CON1bits.PPRE1 = 1; / / 4:1

SPI1CON1bits.PPRE0 = 0;/ / cls ();

/ / stampa ( "MMC inizializzato \ n");

)

altro

(

/ / cls ();

/ / stampa ( "Not Found"); / / power_off ();

CloseSPI1 ();

)return Stat;

)/*--------------------*/

/ * Disk stato restituito * /DSTATUS disk_status (

BYTE drv / * nmuber unità fisica (0) * /

)

(

/ / if (DRV) STA_NOINIT return; / * Supporta solo singolo disco * /

/ return / Stat;

return (DRV)?
STA_NODISK: Stat;

)
/*------------------------------------------------ -----------------------*/

/ * Leggi Sector (s) * /

/*------------------------------------------------ -----------------------*/DRESULT disk_read (

BYTE drv, / * nmuber unità fisica (0) * /

BYTE * buff, / * puntatore al buffer di dati per memorizzare i dati letti * /

DWORD settore, / * numero del settore di avvio (LBA) * /

BYTE count / * count Sector (1 .. 255) * /

)

(

if (drv | |! count) return RES_PARERR;

if (Stat & STA_NOINIT) return RES_NOTRDY;if (! BlkAddr) settore *= 512; / * Convert to byte indirizzo, se necessario * /SELECT (); / * CS = L * /if (count == 1) (/ * unico blocco di lettura * /

if ((send_cmd (CMD17, settore) == 0) / * READ_SINGLE_BLOCK * /

& & Rcvr_datablock (buff, 512))

count = 0;

)

else (/ * Multiple blocco letto * /

if (send_cmd (CMD18, settore) == 0) (/ * READ_MULTIPLE_BLOCK * /

do (

if (! rcvr_datablock (buff, 512)) break;

buff = 512;

) While (- count);

send_cmd (CMD12, 0); / * STOP_TRANSMISSION * /

)

)Deseleziona (); / * CS = H * /

SPI1_Read (); / * Idle (Release DO) * /count (andata e ritorno? RES_ERROR: RES_OK);

)
/*------------------------------------------------ -----------------------*/

/ * Scrivere Settore (s) * /

/*------------------------------------------------ -----------------------*/# se _READONLY == 0

DRESULT disk_write (

BYTE drv, / * nmuber unità fisica (0) * /

const BYTE * buff, / * puntatore ai dati da scrivere * /

DWORD settore, / * numero del settore di avvio (LBA) * /

BYTE count / * count Sector (1 .. 255) * /

)

(
if (drv | |! count) return RES_PARERR;

if (Stat & STA_PROTECT) return RES_WRPRT;

if (Stat & STA_NOINIT) return RES_NOTRDY;if (! BlkAddr) settore *= 512; / * Convert to byte indirizzo, se necessario * /SELECT (); / * CS = L * /if (count == 1) (/ * unico blocco di scrittura * /

if ((send_cmd (CMD24, settore) == 0) / * WRITE_BLOCK * /

& & Xmit_datablock (buff, 0xFE))

count = 0

else (/ * blocco di più scrivere * /

if (send_cmd (CMD25, settore) == 0) (/ * WRITE_MULTIPLE_BLOCK * /

do (

if (! xmit_datablock (buff, 0xFC)) break;

buff = 512;

) While (- count);

if (! xmit_datablock (0, 0xFD)) / * STOP_TRAN token * /

count = 1;

)

)
Deseleziona (); / * CS = H * /

SPI1_Read (); / * Idle (Release DO) * /

count (andata e ritorno? RES_ERROR: RES_OK);

/ / return (count? RES_OK: RES_ERROR)

# endif / * _READONLY * /

/*------------------------------------------------ -----------------------*/

/ * Funzioni Varie * /

/*------------------------------------------------ -----------------------*/DRESULT disk_ioctl (

BYTE drv, / * nmuber unità fisica (0) * /

Ctrl BYTE, / * Codice di controllo * /

void * buff / * Buffer per inviare / ricevere dati di controllo * /

)

(

DRESULT res;

N BYTE, CSD [16];

WORD CSize;if (DRV) RES_PARERR return;

if (Stat & STA_NOINIT) return RES_NOTRDY;SELECT (); / * CS = L * /res = RES_ERROR;

switch (ctrl) (

GET_SECTOR_COUNT caso: / * Restituisce il numero di settori del disco (DWORD) * /

if ((send_cmd (CMD9, 0) == 0) & & rcvr_datablock (CSD, 16)) (

n = csd [0]>> 6;

switch (

case 0: / * CSD ver 1.xx * /

n = (CSD [5] & 15) (CSD ([10] & 128)>> 7) (CSD ([9] & 3) <<1) 2;

CSize = (CSD [8]>> 6) ((WORD) CSD [7] <<2) ((WORD) (CSD [6] & 3) <<10) 1;

* (DWORD *) buff = (DWORD) CSize <<(n - 9);

res = RES_OK;

break;

case 1: / * CSD ver 2.00 * /

CSize = csd [9] ((WORD) CSD [8] <<8) 1;

* (DWORD *) buff = (DWORD) CSize <<10;

res = RES_OK;

break;

)

)

break;GET_SECTOR_SIZE caso: / * Prendi i settori del disco (WORD) * /

* (WORD *) buff = 512;

res = RES_OK;

break;caso CTRL_SYNC: / * Assicurarsi che i dati sono stati scritti * /

if (wait_ready () == 0xFF)

res = RES_OK;

break;caso MMC_GET_CSD: / * Ricevi CSD come un blocco di dati (16 byte) * /

if ((send_cmd (CMD9, 0) == 0) / * READ_CSD * /

& & Rcvr_datablock (buff, 16 / 2))

res = RES_OK;

break;caso MMC_GET_CID: / * Ricevi CID come un blocco di dati (16 byte) * /

if ((send_cmd (CMD10, 0) == 0) / * READ_CID * /

& & Rcvr_datablock (buff, 16 / 2))

res = RES_OK;

break;MMC_GET_OCR caso: / * Ricevi OCR come resp R3 (4 byte) * /

if (send_cmd (CMD58, 0) == 0) (/ * READ_OCR * /

for (n = 0; n <4; n )

* ((BYTE *) buff n) = SPI1_Read ();

res = RES_OK;

)

break;default:

res = RES_PARERR;

)Deseleziona (); / * CS = H * /

SPI1_Read (); / * Idle (Release DO) * /return res;

)/*---------------------------------------*/

/ * Timer Device procedura di interruzione * /

/ * Questo deve essere chiamato in periodo di 10ms * /

/ * (Dipendente dalla piattaforma) * /void disk_timerproc (void)

(

static BYTE pv;

N BYTE, s;timer1 = n; / * 100Hz timer decremento * /

se Timer1 = - n;

timer2 n =;

se timer2 = - n;PV = n;

PV = SOCKPORT & (SOCKWP | SOCKINS); / / switch socket Sampleif (n == pv) (/ / avere contatti stalla?

s = stat;if (PV & SOCKWP) / / WP è H (protetto da scrittura)

s | = STA_PROTECT;

else / / WP è L (scrittura abilitato)

s & = ~ STA_PROTECT;if (PV & SOCKINS) / / INS = H (vuoto Socket)s | = (STA_NODISK | STA_NOINIT);

else / / INS = L (carta inserita)

s & = ~ STA_NODISK;Stat = s;

))

 

[picnoobie]

Volevo solo farvi sapere che ho ragazzi leggere correttamente
un file di testo.ma non posso ottenere le dimensioni del file.
Se riesco a ottenere le dimensioni del file ho potuto leggerlo dall'inizio alla fine,
adesso l'ho fatta hardcoded solo per ottenere qualcosa.heres mia prova principale:

Codice:FILINFO finfo;BYTE linebuf [80]; / * Console buffer di input * /FATFS FATFS; / * oggetto di sistema di file per ogni unità logica * /BYTE Buff [512]; / * buffer di lavoro * /

 

[robocardo]

picnoobie ha scritto:

Volevo solo farvi sapere che ho ragazzi leggere correttamente

un file di testo.
ma non posso ottenere le dimensioni del file.

Se riesco a ottenere le dimensioni del file ho potuto leggerlo dall'inizio alla fine,

adesso l'ho fatta hardcoded solo per ottenere qualcosa.heres mia prova principale:Codice:FILINFO finfo;BYTE linebuf [80]; / * Console buffer di input * /FATFS FATFS; / * oggetto di sistema di file per ogni unità logica * /BYTE Buff [512]; / * buffer di lavoro * /

 

[picnoobie]

link funziona ancora qui http://elm-chan.org/fsw/ff/00index_e.htmledit: ho attaccato, proprio nel caso di specie.
Ci dispiace, ma è necessario il login per visitare questo allegato