Bonjour, j'aurais besoin de votre aide, je suis débutant en programmation de pic.
Je souhaiterais programmer un pic pour qu'il puisse lire des informations sur une carte SD et les renvoyer vers plusieurs sorties.
Si quelqu'un a des exemples de code pour cela ce serais super simpa.
merci beaucoup
Salut,
j'ai bien galeré sur le sujet il n'y pas tres longtemps.
Je n'ai pas la derniere version de mon code sous la main.
Mais là il ne me manquait pas grandchose.
http://forums.futura-sciences.com/el...0-spi-fat.html
merci, c'est super simpa, je vais tester cela immédiatement
Voila mon code definitif.
Il manque peut etre qq declarations.
Il marche avec un 18f4550 et une sdcard 2Go sandisk
Attention pas de fat donc pas de lecture sur pc.
les variable casexx servent uniquement à verifier.
tous les includes ne sont certainement pas necessaires.
#include <p18cxxx.h>
#include "system\typedefs.h"
#include "system\usb\usb.h"
#include "io_cfg.h" // I/O pin mapping
#include "user.h"
#include "delays.h"
#include <spi.h>
#include <usart.h> // pour fonctions UART
#include <string.h> // pour strmcp
#include <stdio.h> // pour printf
#include <stdlib.h> // pour atoi
#define MAX_MSG 100
#define CAR_CR 0x0D
#define CAR_LF 0x0A
#define CAR_BS 0x08
#define SS_SDCARD PORTBbits.RB4
//prototype du gestionnaire d'interruption
void InterruptHandlerHigh (void);
char SPI(char d) // Envoie un caractère sur le SPI
{char a;
SSPBUF = d; // Envoie du caractère
//while (!SSPSTATbits.BF); // Attendre jusque envoi accompli
while (!PIR1bits.SSPIF);
PIR1bits.SSPIF=0;
return SSPBUF;} // Retourne le caractère reçu
char Command(char CMD,char ARG1,char ARG2,char ARG3,char ARG4,char CRC)
{ // Envoie une commande à la carte SD
char a;
SPI(0xFF);
SPI(0xFF);
SPI(CMD);
SPI(ARG1);
SPI(ARG2);
SPI(ARG3);
SPI(ARG4);
SPI(CRC);
SPI(0xFF);
return SPI(0xFF); // Retourne le dernier caractère reçu
}
char initSDCARD(void)
{int iii;
mode_spi_ok=0;
TRISCbits.TRISC7=0; // SDO declarer en sortie
TRISBbits.TRISB1=0; //SCK est declarer en sortie sur le maitre
SS_SDCARD=0;
SSPSTAT = SSPSTAT & 0b00111111; // registre port spi mode 11 osc/64
SSPCON1 = 0b00110010; //clock middle
SS_SDCARD=1;
for(iii=0;iii<20;iii++) {SPI(0xAA);}// initialise the MMC card into SPI mode by sending clks on
SS_SDCARD=0;
for(iii=0;iii<20;iii++) {SPI(0xFF);}// initialise the MMC card into SPI mode by sending clks on
if (Command(0x40,0,0,0,0,0x95) ==1) {mode_spi_ok=1;}
else
{while (SPI(0xff)!=1);
mode_spi_ok=2;}
SPI(0xff);
SPI(0xff);
while (Command(0x41,0,0,0,0,0xFF) !=0);
mode_spi_ok=3;
}
char EcritureSDCARD(void)
{
int iii;
char a;
SPI(0xff);
SPI(0xff);
SS_SDCARD=0; // on prend RB4 comme SS car RA5 est utilisé en AN
SPI(0xff);
SPI(0xff);
cmd_ecriture_recu=0;
if (Command(0x58,0x0,0x02,0x0,0x0 ,0xFF)==0x00) {cmd_ecriture_recu=1;}//commande ecriture CMD24
else {while (SPI(0xff)!=0x00);}
cmd_ecriture_recu=2;
//SPI(0xFF);
//SPI(0xFF);
SPI(0xFE);
for (iii=0;iii<512;iii++)
{if (iii==23) {SPI(23);}
else {SPI(0xCC);}} //donnée a ecrire
SPI(0xff);
SPI(0xff);
while ((SPI(0xff)&0x0F)!=0x05);
cmd_ecriture_recu=3;
while(SPI(0xFF) != 0xFF); // wait until MMC is not busy anymore
cmd_ecriture_recu=4;
//SS_SDCARD=1;
}
char LectureSDCARD(void)
{
int iii;
char reponse;
SPI(0xff);
SPI(0xff);
SS_SDCARD=0;
SPI(0xff);
SPI(0xff);
cmd_lecture_recu=0;
if (Command(0x51,0x0,0x02,0x0,0x0 ,0xFF)==0x00) {cmd_lecture_recu=1;}//commande lecture CMD17
else {while (SPI(0xff)!=0x00);}
cmd_lecture_recu=2;
while(SPI(0xFF)!=0xFE);
cmd_lecture_recu=3;
for (iii=0;iii<512;iii++)
//reponse=0xff;
//{while (reponse==0xff) {reponse=SPI(0xff);}
{reponse=SPI(0xff);
if (iii==11) {case11=reponse;}
if (iii==23) {case23=reponse;}
}
cmd_lecture_recu=4;
SPI(0xFF); // checksum
SPI(0xFF); // checksum
}
bien sur il faut appeler les fonctions.
Salut,
Tu as beaucoup de chance que l'écriture fonctionne avec une carte de plus d'1G...
A partir d'1G, la plupart des SDcard travaillent avec des pages indivisilbe d'1K en écriture et non 512octets.
David.
merci beaucoup
Salut DavidDB,
Oui j'ai vérifié c'est bien une 2 Go.
Pour l'instant j'ai juste ecrit un secteur de 512.
Je crois que c'est a partir de 2 Go que ça ce complique.
C'est pour ça que j'ai pris une 2Go.
Ben tu as de la chance...
La norme, c'est à partir d'1G que l'écriture se fait par secteur d'1K...
Vaut mieux se conformer à la norme, que de jouer avec le feu et voir son programme fonctionner de manière aléatoire en fonction de la marque et type de SDcard.
David.
Est tu surs de ce que tu avances et que tu ne confonds pas avec la taille des clusters en FAT16/FAT32?Envoyé par DavidDB
Lorsque j'ai développé ma librairie pour la gestion d une FAT sur les cartes SD je n'ai pas le souvenir d'être tombé face à ce genre de norme, en même temps la plus grosse carte que j'ai testé était une 512 Mo... Si t as de la doc sur le sujet je serais curieux de la lire.
Merci
Certain...
Regarde par exemple les SDcard de marque Toshiba à partir d'1G.
De mémoire, c'est à partir de la révision 3.xxx sur les SDcard que l'on parle de l'écriture des mémoires à partir d'1G
En dessous d'1G l'écriture est par bloc de 512octets et à partir d'1G l'écriture se fait par bloc de 1024octets; je parle bien de la procédure hardware interne à la SDcard et non de la gestion de fichiers.
Perso, je m'arrête aussi à 512Mo car un buffer d'1K pour de petit µC, c'est limite pour le reste du programme...
David.
Je viens d'ouvrir le datasheet d'une SDcard SanDisk et là il y a la possibilité de travailler en bloc de 512octets jusqu'à 2G...
David.
La seule chose dont je suis sure c'est qu'avec ce code j'ecris des secteurs de 512 octets sur une sd card sandisk de 2Go.
Sans Fat.
c'est bien ce qu'il me semblait. Mais c'est bon de m'avoir rafraichi la mémoire à ce sujet.
A+
