Pinguino Micro - utilisation carte SD sous mplab

[invite89610da7]

Bonjour à tous,
Je suis un peu désespéré, j'arrive à écrire sur carte SD avec l'IDE pinguino, mais je ne la trouve pas très performante pour développer un projet un peu plus poussé, du coup je travail sur MPLAB avec XC32.
Mais le problème, c'est que je n'arrive pas à écrire sur la carte SD, j'ai un problème d'initialisation du CS (il ne fait pas ce que je veux), j'ai vu que c'est le port TDI/AN13/PMA10/RB13 : j'ai peur qu'un autre périphérique l'utilise (principalement le JTAG qui utilise TDI). Je voulais savoir comment le désactiver et rendre disponible uniquement RB13.

Pour info, voici les codes (permettant de faire varier RB13 cycliquement) (changement contrôlé à l'oscillo :
Celui qui fonctionne sur pinguino :

void setup() {
    //run once:
    _RB13 = 1;
    _TRISB13 = 0;
    }

void loop() {
    //run repeatedly:
    int a;
delay(1);
_RB13 = 1;
delay(1);
_RB13 = 0;
    }

Celui qui ne fonctionne pas sur MPLAB X :

int main(int argc, char** argv) {
    _RB13 = 0;
    _TRISB13 = 0;
    while (1){
        _RB13=0;
        int i=0;
        while(i<1000);
        _RB13=1;
        while(i<1000);
    }
    return (EXIT_SUCCESS);
}

Si vous avez une astuce, je suis preneur car je ne trouve rien du tout.

Merci d'avance
Pierre
-----

[paulfjujo]

bonjour,

on ne met pas une declaration a l'interieur d'une boucle!
int i=0;
et de plus,a quel moment cette variable i est incrementee
il y aurait pas un gros oubli.. genre i++

[invite89610da7]

Effectivement, désolé c'est vrai que j'ai testé plein de choses, et j'ai pas du mettre le bon code, le voila corrigé mais ça marche toujours pas !!!

#include <stdio.h>
#include <stdlib.h>
#include <plib.h>

int main(int argc, char** argv) {
    _TRISB13 = 0;
    int i=0;
    while (1){
        _RB13=0;
        i=0;
        while(i<1000)
            i++;
        _RB13=1;
        i=0;
        while(i<1000)
            i++;
    }
    return (EXIT_SUCCESS);
}

C'est un peu plus propre !

[paulfjujo]

je ne connais pas les PIC32
Au fait quelle est la reference du MCU utilisé dans le Pinguino ?

voir toutes les fonctins possible du portB dans la datasheet
Quid des entrees Analogiques, configurees par defaut ?


Mais n'y aurait-il pas le meme distinguo qu'avec les PIC18F
utilisation de LATBbits.LATBx pour activer les sorties et PORTBbits.RBx pour les entrees..
a verifier dans le "MCU".h

[A voir en vidéo sur Futura]

[invite830075ec]

Salut, pour inhiber le Jtag, qui par défaut est actif

DDPCONbits.JTAGEN = 0;

[invite830075ec]

La pin AN13/RB13 est analogique par défaut. Pour la passer en numérique, mettre à 1 le bit 13 de AD1PCFG.

Pour passer toutes les pins AN en numérique,
AD1PCFG = 0xffff;

[invite89610da7]

Salut, pour inhiber le Jtag, qui par défaut est actif

DDPCONbits.JTAGEN = 0;

Merci, effectivement, ça permet d'inhiber le Jtag et du coup, j'arrive à modifier le pin, par contre je n'arrive pas encore à initialiser la carte SD, j'envoi un CMD(0) pour reset la carte et la mettre en communication SPI, mais elle ne répond pas.

int sendSDCmd( unsigned char c, unsigned a)
// c    command code
// a    byte address of data block
{
    int i, r;

    // enable SD card
    enableSD();

    // send a comand packet (6 bytes)
    writeSPI( c | 0x40);    // send command
    writeSPI( a>>24);       // msb of the address
    writeSPI( a>>16);
    writeSPI( a>>8);
    writeSPI( a);           // lsb

    writeSPI( 0x95);        // send CMD0 CRC

    // now wait for a response, allow for up to 8 bytes delay
    for( i=0; i<8; i++)
    {
        r = readSPI();
        if ( r != 0xFF)
            break;
    }
    return ( r);
}

Je passe le protocole à l'analyseur logique et le writeSPI fonctionne bien, j'ai bien les 8 coups d'horloge, mais rien en retour.

[invite830075ec]

Crée une boucle avec time-out, afin de lancer plusieurs fois la commande, elle ne répond pas forcément tout de suite, d'expérience.
Tu as regardé la librairie Fatfs ?

[invite830075ec]

SPI à 400kHz durant initialisation de la carte

[invite89610da7]

J'ai du mal à la comprendre et j'ai l'impression qu'il y a plusieurs versions sur le net et je n'arrive pas bien à les implémenter. Du coup j'étais parti de la base avec livre Exploring the PIC et les sources day 14 et 15 http://www.exploringpic32.com/resources/SDlib.zip. Mais ça n'a pas l'air de marcher.
Si vous avez une librairie correct de FatFS, et un peu documenté sur son utilisation je suis preneur.
Merci d'avance

[invite89610da7]

En fait, en relisant la notice de FatFS sur leur site, la partie où je garlère est la partie bas niveau : disk_initialize... et SPI...
Je continu mes recherches, mais si vous avez des conseils, c'est cool

[invite830075ec]

Ta routine me semble correcte. Vérifie toutes tes connexions, dans l'ordre CS, DI, Vcc, CK, Vss, DO

Voici ma config SPI pour les 2 vitesses.
#define FPB GetPeripheralClock()
SPISD_BRG = highspeed ? FPB/2/20000000-1 /* Fsck=20MHz */ : FPB/2/400000-1; /* Fsck=400kHz */
SPISD_CON = 0x8120; // no frame, spi on, 8bit, SMP=0, CKE=1, CKP=0, master (sample middle)
La boucle de répétition des commandes d'initialisation est peut être superflue, mais ça aide au moins pour les premiers essais, si certaines passent mal.

La librairie FatFS existe en version standard, ou en version light, avec très faible utilisation de la mémoire.
Tu peux aussi regarder la librairie Microchip, mais moins agréable à lire.

[invite830075ec]

Et ne pas oublier de réveiller la carte avant de l'utiliser

CS=1;
for (i=0; i<10; i++) WriteSpi(0xff); // réveiller la sdcard, 80 clk avec cs off

[invite89610da7]

Merci pour ces informations, mais j'ai l'impression que c'est ce que je fais, mais j'ai toujours un timeout, voici mon sdmmc.c et après le sdmmc.h
sdmmc.c

#define FPB GetPeripheralClock()
// I/O definitions
#define SDWP    0    // Write Protect input
#define SDCD    0    // Card Detect input
#define SDCS    _RB13    // Card Select output

// SD card commands
#define RESET           0 // a.k.a. GO_IDLE (CMD0)
#define INIT            1 // a.k.a. SEND_OP_COND (CMD1)
#define READ_SINGLE     17
#define WRITE_SINGLE    24

// additional commands (not used)
#define SEND_CSD        9
#define SEND_CID        10
#define SET_BLEN        16
#define APP_CMD         55
#define SEND_APP_OP     41

// SD card responses
#define DATA_START      0xFE
#define DATA_ACCEPT     0x05

// timeouts
#define I_TIMEOUT       100000
#define R_TIMEOUT       25000
#define W_TIMEOUT       250000

static BOOL highspeed = FALSE;

void initSD( void)
{
    SDCS = 1;           // initially keep the SD card disabled
    _TRISB13 = 0;        // make Card select an output pin

    // init the spi module for a slow (safe) clock speed first
    SPI2CON = 0x8120;   // ON, CKE=1; CKP=0, sample middle
    SPI2BRG = highspeed ? FPB/2/20000000-1 /* Fsck=20MHz */ : FPB/2/400000-1; /* Fsck=400kHz *///71;       // clock = Fpb/144 = 250kHz

}   // initSD


// send one byte of data and receive one back at the same time
unsigned char writeSPI( unsigned char b)
{
    SPI2BUF = b;                  // write to buffer for TX
    while( !SPI2STATbits.SPIRBF); // wait transfer complete
    return SPI2BUF;               // read the received value
}// writeSPI

#define readSPI()   writeSPI( 0xFF)
#define clockSPI()  writeSPI( 0xFF)
#define disableSD() SDCS = 1; clockSPI()
#define enableSD()  SDCS = 0


int sendSDCmd( unsigned char c, unsigned a)
// c    command code
// a    byte address of data block
{
    int i, r;

    // enable SD card
    enableSD();

    // send a comand packet (6 bytes)
    writeSPI( c | 0x40);    // send command
    writeSPI( a>>24);       // msb of the address
    writeSPI( a>>16);
    writeSPI( a>>8);
    writeSPI( a);           // lsb

    writeSPI( 0x95);        // send CMD0 CRC

    // now wait for a response, allow for up to 8 bytes delay
    for( i=0; i<8; i++)
    {
        r = readSPI();
        if ( r != 0xFF)
            break;
    }
    return (r);

/* return response
    FF - timeout
    00 - command accepted
    01 - command received, card in idle state after RESET

other codes:
    bit 0 = Idle state
    bit 1 = Erase Reset
    bit 2 = Illegal command
    bit 3 = Communication CRC error
    bit 4 = Erase sequence error
    bit 5 = Address error
    bit 6 = Parameter error
    bit 7 = Always 0
*/
    // NOTE CSCD is still low!
} // sendSDCmd


int initMedia( void)
// returns 0 if successful
//          E_COMMAND_ACK   failed to acknowledge reset command
//          E_INIT_TIMEOUT  failed to initialize
{
    int i, r;

    // 1. with the card NOT selected
    disableSD();

    // 2. send 80 clock cycles start up
    for ( i=0; i<10; i++)
        clockSPI();

    // 3. now select the card
    enableSD();

    // 4. send a single RESET command
    r = sendSDCmd( RESET, 0); disableSD();
    if ( r != 1)                // must return Idle
        return E_COMMAND_ACK;   // comand rejected
    // 5. send repeatedly INIT until Idle terminates
    for (i=0; i<I_TIMEOUT; i++){
        r = sendSDCmd(INIT, 0); disableSD();
        if ( !r)
            break;
    }
    if ( i == I_TIMEOUT)
        return E_INIT_TIMEOUT;  // init timed out

    return 0;
} // init media

sdmmc.h

#include <plib.h>

// Init ERROR code definitions
#define E_COMMAND_ACK       0x80
#define E_INIT_TIMEOUT      0x81


typedef unsigned  LBA;  // logic block address, 32 bit wide

void initSD( void);     // initializes I/O pins and SPI
int initMedia( void);   // initializes the SD/MMC memory device

C'est prise de tete !!

[invite830075ec]

Ton programme marche, la commande 0 retourne bien 1, j'ai pas testé plus loin pour le moment.
Mon câblage :
sd CS -> pic SS
sd DI -> pic SDO
sd Vcc -> 3,3V
sd CK -> pic SCK
sd Vss -> gnd
sd DO -> pic SDI (4,7k vers Vcc)
Le tout à 400kHz

la pin CD de détection de la sdcard est optionelle et nécessite aussi une 4,7k vers Vcc, si elle est utilisée

[invite89610da7]

Merci pour toutes ces informations,
En fait j'utilise une carte pinguino micro dont les docs sont ici (arduino like). Je pense qu'il n'y a pas de problème de câblage car en passant par l'interface pinguino ca marche mais je n'arrive pas a faire des programmes clairs et lisibles (tout doit être dans un seul fichier) du coup je préfère mplab.

Sinon la fonction 0 dont tu parles est bien "sendSDCmd( RESET, 0)" effectivement j'ai l'impression qu'elle fonctionne, mon blocage est dans le "initMedia()". La carte sd ne répond rien et "i == I_TIMEOUT" est vrai, iniMedia retourne 0x81.

Sinon je te mon programme complet pour avoir un avis critique : pour l'instant j'ai juste des fichiers permettant d'activer les périphérique que je souhaite pour ne pas avoir a tou reprogrammer à chaque fois.

Peut-être que le problème vient aussi de la config des pragma ?

#pragma config FPLLMUL  = MUL_20        // PLL Multiplier
#pragma config FPLLIDIV = DIV_2         // PLL Input Divider
#pragma config UPLLIDIV = DIV_2         // USB PLL Input Divider
#pragma config UPLLEN = ON         // USB PLL Enable
#pragma config FPLLODIV = DIV_1         // PLL Output Divider
#pragma config FPBDIV   = DIV_1         // Peripheral Clock divisor
#pragma config FWDTEN   = OFF            // Watchdog Timer
#pragma config WDTPS    = PS32768        // Watchdog Timer Postscale (32,768 sec.)
#pragma config FCKSM    = CSECME        // Clock Switching & Fail Safe Clock Monitor
#pragma config OSCIOFNC = OFF           // CLKO Output Signal Active on the OSCO Pin
#pragma config POSCMOD  = HS            // Primary Oscillator
#pragma config FSOSCEN  = ON            // Secondary Oscillator Enable (KLO was off)
#pragma config FNOSC    = PRIPLL        // Oscillator Selection
#pragma config CP       = OFF           // Code Protect
#pragma config BWP      = OFF           // Boot Flash Write Protect
#pragma config PWP      = OFF           // Program Flash Write Protect
#pragma config ICESEL   = ICS_PGx2      // ICE/ICD Comm Channel Select
#pragma config DEBUG    = OFF            // Background Debugger Enable

Voici aussi le main

int main(int argc, char** argv) {
    SYSTEMConfigPerformance(GetSystemFreq() - 1);
    INTEnableSystemMultiVectoredInt();

    DDPCONbits.JTAGEN = 0;
    AD1PCFG = 0x2000;

    int res = 0;
    initUART();
    initSD();
    res = initMedia();
    LATDINV = 0x02;
    while(1){
        LATDINV = 0x02;
        delayms(1000);
    }

    return (EXIT_SUCCESS);
}

et le system.h pour les fréquences du microC:

/* Microcontroller MIPs (FCY) */
#define SYS_FREQ     80000000UL
#define FCY          SYS_FREQ

/******************************************************************************/
/* User Functions                                                             */
/******************************************************************************/
#define	GetPeripheralClock()		(SYS_FREQ/(1 << OSCCONbits.PBDIV))
#define GetSystemFreq()                   (SYS_FREQ)

Merci d'avance pour cette aide précieuse (ça fait plusieurs mois que je galère dessus et j'avais mis de côté, mais cette fois j'en ai absolument besoin, du coup il faut que j'y arrive !!!)

[invite830075ec]

Ca fait pareil chez moi, la commande INIT (CMD1) ne passe pas.

Regarde le contenu de la fonction disk_initialize() de FatFs. Elle utilise cette commande seulement si c'est une carte MMC, pas SD. Je te conseille d'intégrer cette fonction à ton soft, et la suivre pas à pas avec le debugger, pour voir si elle se passe bien. Elle détecte les 3 types de carte MMC, SDv1, Sdv2

La librairie FatFs marche très bien, une fois la configuration du port SPI correctement faite selon le hard utilisé.

PS Tu l'as acheté ou cette carte et combien coûte le port ?

[invite830075ec]

http://ww1.microchip.com/downloads/e..._v01_00_01.zip

[invite89610da7]

J'ai acheté la carte chez Olimex (https://www.olimex.com/Products/Duin...INGUINO-MICRO/), j'ai acheté chez eux environ 150€ de matériel avec livraison rapide (UPS Express Saver Z2) à 17€.

Je vais regarder la librairie demain, mais as-tu quelques piste sur les éléments à rajouter ou à modifier.

[invite830075ec]

Il est vrai que que la nouvelle présentation de FatFs n'est pas évidente à comprendre, il faut la configurer à la main selon le contexte, pas facile quand on découvre tout ça.
Malheureusement je n'ai pas l'orignal de la version d'il y a 2 ans que j'avais utilisée, je n'ai que ma version bidouillée. Je vais lui offrir une nouvelle jeunesse, patience.

[invite89610da7]

Je vais essayer d'être patient !! Sinon, j'ai réussi à la faire fonctionner : j'ai trouvé ces deux sujets suivant qui proposent la même implémentation pour PIC32 :
http://www.digikey.fr/techxchange/docs/DOC-2550
http://www.microchip.com/forums/m563218.aspx

Je n'ai eu quasiment rien à changer, et le liens et nombre de fichier corresponds à la doc de FatFS.

Je l'utilise comme ça :

//Initialize Disk
    disk_initialize(0);

    //Mount Filesystem
    f_mount(0, &fs);

    fr=f_open(&fil, "test.txt", FA_OPEN_ALWAYS|FA_READ|FA_WRITE);
    if (!fr){
        f_lseek(&fil, fil.fsize);

        bytes_to_write = strlen(buffer);
        fr = f_write(&fil, buffer, bytes_to_write, &bytes_written);
        f_sync(&fil);

        f_close(&fil);
        // umount
        f_mount(0,NULL);
        SPI2CONCLR = 0x8000; //SPI2 off
        if (bytes_to_write == bytes_written)
            writeString(UART1,"écriture du fichier terminé");
    }else{
        writeString(UART1,"*** File not found or card not in read (on write) ***");
    }

Est-ce de la bonne manière ?

Du coup j'avance comme ça, par contre je suis preneur de suivre ce que tu fais car j'aimerai un peu mieux comprendre le fonctionnement de tout ça !!!
Encore merci pour ton aide.

PS : sinon, tu travailles dans quoi ? Tu programmes toute la journée sur PIC ?

[invite830075ec]

J'ai beaucoup travaillé sur Pic, et sur d'autres processeurs. Là je suis sur GNU/Linux et pas grand chose ne sort de concret car je passe tout mon temps à regarder ce qu'il y a dedans.

Si tu l'a fait fonctionner, tant mieux car difficile de me replonger dans mes vieux softs, ça s'oublie vite ces choses.
Le principe est simple, tu formates ta carte sur un PC en FAT16 ou FAT32, puis tu mets la carte sur ton pic.

La librairie FatFs doit te proposer des fonctions pour :
- monter la partition FAT
- se ballader dans les dossiers
- accéder à un fichier open/read/write/close

Surtout vérifie que le disk_initialize() se passe bien, car c'est lui qui détecte le type de carte, afin de lire correctement la ou les partitions, et d'attaquer la fat.

[invite89610da7]

Et tu travailles à ton compte ?

De mon côté, je démarre une active, et c'est vrai que c'est très long de développer (surtout quand on démarre), du coup je suis intéressé par connaître de personnes compétentes dans ces domaines et savoir comment ils s'y prennent !!

Je travaille aussi sous linux depuis un certain temps, j'ai réalisé de petits scripts me simplifiant la vie, mais je ne suis pas rentrée plus en profondeur, peut-être un jour !!!
Tu as des objectifs précis ou c'est de la formation ?