Répondre à la discussion
Affichage des résultats 1 à 14 sur 14

dsPIC et Bus SPI...



  1. #1
    Crepuscule3

    dsPIC et Bus SPI...


    ------

    Bonjour à tous,

    Je me lance actuellement sur ma première application mettant en oeuvre une communication par bus SPI avec deux PICs : 24HJ12GP202 et 24HJ12GP01. Ce sont les même à la seule différence du nombre de pattes. Par ailleurs, certains vont me dire... "mais ce ne sont pas des dsPIC!". Non, en effet, mais l'utilisation en est quasiment la même.

    Voilà donc ce que je tente de faire mais qui ne marche pas:

    Je tente de faire une communication entre eux. Mettant déjà exercé sur la communication RS232 via l'UART de ces PIC, pour vérifier que la communication fonctionne bien , j'utilise le port série de mon ordi pour visualiser les réponses du SPI.
    Le GP201 a été déclaré comme maître et le GP202 comme esclave. En gros, le maître envoie toutes les secondes (environ), le code 10 ou le code 120 (choisis de façon hasardeuse). Dès qu'il a envoyer un code, il attend la réponse de l'esclave engendrée par le code qu'il vient de lui envoyer. Ainsi, sur interruption, lorsque l'esclave reçoit 10 il renvoie la valeur d'un compteur qui s'incrémente en partant de 0 à chaque réception de code 10. Lorsqu'il reçoit 120 en envoie la valeur d'un compte à rebour qui se décrémente en partant de 255 à chaque réception de code 120. Ainsi, lorsque le maître envoie le code 10, il reçoit la valeur du compteur qu'il m'envoie ensuite sur le port série de l'ordi suivit d'une virgule. Lorsqu'il envoie le code 120, il reçoit la valeur du compte à rebour qu'il m'envoie ensuite sur le port série de l'ordi suivit d'un retour à la ligne.
    Ainsi donc, je dois normalement observer quelque chose comme ça:
    0,255
    1,254
    2,253
    3,252
    4,251
    ...
    254,1
    255,0
    0,255
    1,254
    ...


    Le truc c'est que ça ne marche pas... peut-être ais-je loupé un truc dans le fonctionnement du SPI...

    or, je reçois:

    ,
    ,
    ,
    ,
    ,

    et quelques fois des trucs bisards...

    ,
    ,-
    ,
    ¤,
    ,
    ,




    Pour le maître, je l'ai configuré de la façon suivante:


    void InitSPI(void)
    {
    SPI1STATbits.SPIEN = 0;
    SPI1STATbits.SPISIDL = 0;
    SPI1STATbits.SPIROV = 0;

    SPI1CON1bits.DISSCK = 0;
    SPI1CON1bits.DISSDO = 0;
    SPI1CON1bits.MODE16 = 0;
    SPI1CON1bits.SMP = 0;
    SPI1CON1bits.CKE = 0;
    SPI1CON1bits.SSEN = 0;
    SPI1CON1bits.CKP = 0;
    SPI1CON1bits.MSTEN = 1;
    SPI1CON1bits.SPRE = 0;
    SPI1CON1bits.PPRE = 0;
    _SPIEN = 1;
    }


    voici le main du maître:

    int main(void)
    {
    InitUC();
    for (b = 0; b < 256; b++) Tab[b] = b;
    while(1)
    {
    if (i == 250000)
    {
    while (_SPITBF == 1);
    SPI1BUF = 0b00001010;
    SPI1STATbits.SPIROV = 0;
    while (_SPIRBF != 1);
    VarTemp = SPI1BUF;
    for (a = 0; a < 256; a++)
    {
    if (VarTemp == Tab[a]) ReponseSPI = Tab[a];
    }
    while (_UTXBF == 1);
    U1TXREG = ReponseSPI;
    while (_UTXBF == 1);
    U1TXREG = 0x2C;
    }
    if (i == 500000)
    {
    while (_SPITBF == 1);
    SPI1BUF = 0b10100000;
    SPI1STATbits.SPIROV = 0;
    while (_SPIRBF == 0);
    VarTemp = SPI1BUF;
    for (a = 0; a < 256; a++)
    {
    if (VarTemp == Tab[a]) ReponseSPI = Tab[a];
    }
    while (_UTXBF == 1);
    U1TXREG = ReponseSPI;
    while (_UTXBF == 1);
    U1TXREG = 0x0D;
    while (_UTXBF == 1);
    U1TXREG = 0x0A;
    }
    i++;
    if (i > 500000)
    {
    i = 0;
    }
    }
    return 1;
    }


    J'ai configuré l'esclave de la façon suivante :

    void InitSPI(void)
    {
    SPI1STATbits.SPIEN = 0;
    SPI1STATbits.SPISIDL = 0;

    SPI1CON1bits.DISSCK = 1;
    SPI1CON1bits.DISSDO = 0;
    SPI1CON1bits.MODE16 = 0;
    SPI1CON1bits.SMP = 0;
    SPI1CON1bits.CKE = 0;
    SPI1CON1bits.SSEN = 0;
    SPI1CON1bits.CKP = 0;
    SPI1CON1bits.MSTEN = 0;
    SPI1CON1bits.SPRE = 0;
    SPI1CON1bits.PPRE = 0;
    _SPIEN = 1;
    _SPI1IE = 1;
    }



    L'interruption du SPI:

    void __attribute__((__interrupt__, no_auto_psv)) _SPI1Interrupt(void)
    {
    SPI1STATbits.SPIROV = 0;
    while (_SPIRBF == 0);
    ReceptionSPI = SPI1BUF;
    _SPI1IF = 0;
    }


    Le main de l'esclave:

    int main(void)
    {
    InitUC();
    for (i = 0; i < 256; i++) Tab[i] = i;
    while(1)
    {
    if (ReceptionSPI == 10)
    {
    Counter++;
    while (_SPITBF == 1);
    SPI1BUF = Tab[Counter];
    ReceptionSPI = 0;
    }
    if (ReceptionSPI == 160)
    {
    Countdown--;
    while(_SPITBF == 1);
    SPI1BUF = Tab[Countdown];
    ReceptionSPI = 0;
    }
    }
    return 1;
    }


    Voilà en gros...
    Si quelqu'un saurait ce qu'il ne va pas, merci de m'expliquer...

    Cordialement

    Crepuscule3

    -----

  2. Publicité
  3. #2
    BastienBastien
    Invité

    Re : dsPIC et Bus SPI...

    Bonsoir,

    Ca ne va pas résoudre ton problème, mais ce qui est sûr, c'est que sur ton PC, tu affiches le contenu de la variable en temps que 'char'. Fais-le en temps que 'int' et là, tu verras un nombre.

    Quel est le code ASCII des symboles bizarres que tu reçois ?

  4. #3
    RISC

    Re : dsPIC et Bus SPI...

    Salut,

    Citation Envoyé par Crepuscule3 Voir le message
    Bonjour à tous,

    Je me lance actuellement sur ma première application mettant en oeuvre une communication par bus SPI avec deux PICs : 24HJ12GP202 et 24HJ12GP01. Ce sont les même à la seule différence du nombre de pattes. Par ailleurs, certains vont me dire... "mais ce ne sont pas des dsPIC!". Non, en effet, mais l'utilisation en est quasiment la même.
    C'est exact, la différence que j'ai trouvée c'est que les PIC24H ne possèdent pas les instructions dsPIC. Pour le reste ils sont complètement compatibles. J'ai déjà fait tourner du code binaire dsPIC33 n'utilisant pas la partie dsPIC sur des PIC24H ;=)

    Citation Envoyé par Crepuscule3 Voir le message
    Voilà donc ce que je tente de faire mais qui ne marche pas:

    Je tente de faire une communication entre eux. Mettant déjà exercé sur la communication RS232 via l'UART de ces PIC, pour vérifier que la communication fonctionne bien , j'utilise le port série de mon ordi pour visualiser les réponses du SPI.
    Regarde ici : http://www.microchip.com/codeexamples.
    Si tu regardes les exemples de code pour les dsPIC33, tu trouveras des morceaux de code pour le SPI.

    Tu peux également utiliser les librairies pour les périphériques qui sont intégrées en standard dans le compilateur C30 :
    http://www.microchip.com/stellent/id...cName=en023586

    J'utilise aussi pour la mise au point le Pickit Serial Analyzer qui gère plusieurs bus et permet une mise au point facile des PB de communications.

    a+
    Dernière modification par RISC ; 18/04/2008 à 00h30. Motif: addition

  5. #4
    Crepuscule3

    Re : dsPIC et Bus SPI...

    Bonjour,

    Merci pour votre aide, cependant, j'avais déjà pensé à ce cas. C'est pour cela qu'ensuite je suis passé en 'char', car je souhaitais envoyer le caractère et non le code ascii. Quoiqu'il en soit, si le problème concernait simplement l'affichage en code ascii ou non, vu que j'envoie un compteur qui va jusqu'à 255 et un compte à rebour qui part de 255, je devrais au moins avooir les bons caractères au bout d'un moment (les 32 premiers caractères de la table ASCII n'étant pas forcément affichables, à partir de 33, je devrais au moins voir des caractères comme : !"#$%&'()...) et inversement pour le compte à rebour. Au lieu de cela, j'ai un '-' une fois de temps en temps... donc j'ai bien quelques codes envoyés sur l'UART mais pas les bons, ils n'ont rien à voir avec ce que je veux envoyer.

    ... La vérité est ailleurs...

    Merci quand même!

    Crepuscule3

  6. A voir en vidéo sur Futura
  7. Comparatifs

    Gagnez du temps et de l'argent grâce à nos comparatifs de produits. Parmi nos sujets :
  8. #5
    Crepuscule3

    Re : dsPIC et Bus SPI...

    Bonjour,

    J'ai aussi pensé à chercher des exemples sur le net. Pour les exemples de microchip, je les ai déjà tous téléchargés. Cependant, ils ne correspondent pas à ce que je veux faire car ils utilisent les dma pour mettre en oeuvre le SPI (ce que je n'ai pas avec le PIC 24HJ12GP201/202). Ensuite, il st vrai que je peux utiliser des librairies de C30, mais le but de ce programme est de réussir à le faire par moi même sans utiliser de fonctions toutes faites (qui ne marchent pas toujours bien qui plus est).
    Je sais, c'est plus chiant de faire comme ça, mais c'est dans un but d'apprentissage que je fais tout ça, donc... c'est un choix mais je ne veux pas utiliser les fonctions du c30.

    En revanche, j'ai quand même réussit à trouver un exemple de code proche de ce que j'avais fait (la coincidence fait que le code provient d'un prof de ma fac que j'ai eu l'année dernière), mais bien que similaire, apparement ça marche pour son programme à lui mais pas le mien. Quelque chose diffère mais je ne sais pas quoi (il n'y a que l'initialisation des registres du SPI qui diffèrent un peu mais j'ai déjà regardé avec la datasheet et je ne vois pas en quoi cela pourrais géner).
    Voici le site trouvé : http://www.baghli.com/dspic_intro.php

    C'est pour cela que j'ai posté cette question. J'espère que quelqu'un aura une idée de ce qui se passe.

    EN REVANCHE, il se peut que le problème provienne de l'interruption. Il semblerait que je ne rentre pas dedans. Pourquoi? That is the question!

    Voilà, en gros.

    Si quelqu'un a une idée, merci de me faire signe.

    Cordialement

    Crepuscule3

  9. #6
    Crepuscule3

    Re : dsPIC et Bus SPI...

    Personne n'aurait d'idée?

  10. Publicité
  11. #7
    RISC

    Re : dsPIC et Bus SPI...

    Bonjour,

    Citation Envoyé par Crepuscule3 Voir le message
    Bonjour,

    J'ai aussi pensé à chercher des exemples sur le net. Pour les exemples de microchip, je les ai déjà tous téléchargés. Cependant, ils ne correspondent pas à ce que je veux faire car ils utilisent les dma pour mettre en oeuvre le SPI (ce que je n'ai pas avec le PIC 24HJ12GP201/202).
    Es-tu sur d'avoir bien regardé ?
    L'exemple CE136 "SPI WITHOUT DMA" devrait fonctionner directement sur ton PIC24H... :
    http://www.microchip.com/stellent/id...GE&nodeId=2622

    Si ton problème est avec les interruptions, c'est facile à tester. Tu mets un point d'arrêt à l'entrée...
    N'oublie pas que dans les 16 bits il faut gérer (initialiser) les niveaux de priorité (0 à 7)de chacune des interruptions.
    Vérifie bien cela et fais voir tes lignes de code ou tu initialise cela.
    Par défaut je crois que les périph sont au niveau 4 alors que le main est au niveau 0.

    a+

  12. #8
    Crepuscule3

    Unhappy Re : dsPIC et Bus SPI...

    voici le programme complet du Maître (le main) :

    -------------------------------------------------------------------------
    /****************************** ****************************** *****/
    /* Nom du fichier : Main.c */
    /****************************** ****************************** *****/

    #include "Gateway.h"

    /****************************** ****************************** **********/
    /* Configuration du µC */
    /****************************** ****************************** **********/
    _FBS(BSS_NO_FLASH & BWRP_WRPROTECT_OFF); // Pas de segment de boot et pas de protection en écriture
    _FGS(GSS_OFF & GCP_OFF & GWRP_OFF); // Pas de protection du code
    _FOSCSEL(FNOSC_PRIPLL & IESO_OFF); // Oscillateur principal avec PLL et 1 vitesse de l'oscillateur au démarrage
    _FOSC(FCKSM_CSDCMD & IOL1WAY_OFF & OSCIOFNC_ON & POSCMD_XT); // Pas de clock switching ni de clock monitor,Oscillateur en mode XT
    _FWDT(FWDTEN_OFF & WINDIS_OFF); // WatchDog inactif
    _FPOR(FPWRT_PWR1 & ALTI2C_ON); // POR = 0ms, I²C avec mappage original

    #define FCY 25000000
    #define BAUDRATE 115200
    #define BRGVAL ((FCY/BAUDRATE)/16)-1


    dword i = 0;
    int a = 0;
    int b = 0;
    int Freq = 6;
    char MIPS = 25;
    byte ReponseSPI = 0;
    int Tab[16] = {'0','1','2','3','4','5','6',' 7','8','9','A', 'B','C','D','E','F'};
    byte VarTemp = 0;

    char InitPLL(int quartz, char Fcy)
    {
    char N1=2, M=2, N2=1; // N1=>PLLPRE, M=>PLLDIV, N2=>PLLPOST

    // Sécurités //

    if((Fcy<7) || (Fcy>40)) // page 78 de la datasheet est dit que Fcy doit être comprise entre 6.25 et 40 MIPS.
    return 1; // Si on est pas dans cet intervalle, on retourne 1.

    if((quartz<2) || (quartz>264)) // A la sortie de PLLPRE on doit être entre 0.8 et 8MHz. Sachant que dans PLLPRE
    return 2; // on peut diviser la fréquence du quartz par un nombre comprit entre 2 et 33, on a
    // donc la fréquence du quartz devant être comprise entre 2 et 264MHz (0.8*2=1.6 soit
    // presque 2MHz et 8*33=264MHz)

    while((quartz/N1)>8)N1++; // A la sortie de PLLPRE, nous devons avoir une fréquence comprise entre 0.8 et 8MHz.
    // Donc quartz/N1 doit être inférieur à 8.

    while(((Fcy<<1)<<N2)<100)N2++; // Permet de déterminer N2
    if(N2==3) N2++;

    // Paramétrage des oscillateurs //

    M = ((Fcy<<1)<<N2)/(quartz/N1); // Détermine M;

    _PLLPRE = N1-2; // Affectation de PLLPRE avec la valeur N1 déterminé précédemment
    _PLLPOST = N2-1; // Affectation de PLLPOST avec la valeur N2 déterminé précédemment
    _PLLDIV = M-2; // Affectation de PLLDIV avec la valeur M déterminé précédemment

    return 0; // Indique que tous c'est correctement déroulé
    }




    void InitPort(void)
    {
    IOpin8 = 8; // Patte 8 du PIC --> SCK1OUT (SPI1 Clock Output)
    IOpin10 = 7; // Patte10 du PIC --> SDO1 (SPI1 Data Output)
    IOpin11 = 8; // Patte11 du PIC --> SDI1 (SPI1 Data Input)
    IOpin12 = 9; // Patte12 du PIC --> SS1OUT (SPI1 Slave Select Output)
    IOpin15 = 3; // Patte15 du PIC --> U1TX (UART1 Transmission)
    _NSTDIS = 0;
    }



    void Config_UART(void)
    {
    U1MODEbits.UARTEN = 0; // UARTx pin déconnectée . Toutes les pins UARTx sont commandées par les port latches. Conso mini
    U1MODEbits.USIDL = 0; // Continue les opérations du module même en mode idle
    U1MODEbits.IREN = 0; // Encodeur et décodeur de trame infrarouge (IrDA) déconnecté
    U1MODEbits.UEN = 0; // UARTx Enable bits
    U1MODEbits.WAKE = 0; // Wake-up on Start bit Detect During Sleep Mode Enable bit
    U1MODEbits.LPBACK = 0; // Loopback Mode déconnecté
    U1MODEbits.ABAUD = 0; // Auto-Baud déconnecté
    U1MODEbits.BRGH = 0; // prescaler de 16
    U1MODEbits.PDSEL = 0; // Trames 8 bits, pas de bit de parité
    U1MODEbits.STSEL = 0; // Stop Bit Selection bit
    U1BRG = BRGVAL; // Baud rate définit à 115200 bauds/s soit 1800 octets/s. ATTENTION : error = 0,45%. Voir datasheet p.144

    /* Configure DRA transfert (par de reception, on veut juste envoyer) */
    U1STAbits.UTXEN = 0; // Transmit Enable bit
    U1STAbits.UTXISEL0 = 1; // Interruption lorsqu'un caractère est transféré et que par conséquent le buffer est vide
    U1STAbits.UTXISEL1 = 0;
    U1STAbits.ADDEN = 0; // Address Character Detect bit (bit 8 of received data = 1)

    /* Déclenche transmission RS232 */
    U1MODEbits.UARTEN = 1; // UARTx dispo. Toutes les pins de l'UART sont définies par UEN<1:0>
    U1STAbits.UTXEN = 1; // Transmission TX dispo. Pin UxTX controllé par l'UART

    IEC0bits.SPI1EIE = 0; // Requete d'interruption d'erreur désactivée
    }

    void InitSPI(void)
    {

    SPI1STATbits.SPISIDL= 0;
    SPI1STATbits.SPIROV = 0;

    SPI1CON1bits.DISSCK = 1;
    SPI1CON1bits.DISSDO = 0;
    SPI1CON1bits.MODE16 = 1;
    SPI1CON1bits.SMP = 0;
    SPI1CON1bits.CKE = 0;
    SPI1CON1bits.SSEN = 0;
    SPI1CON1bits.CKP = 0;
    SPI1CON1bits.MSTEN = 1;
    SPI1STATbits.SPIEN = 1;
    SPI1BUF = 0x0000;

    }


    void InitUC(void)
    {
    InitPLL(Freq, MIPS);
    InitPort();
    Config_UART();
    InitSPI();
    }



    int main(void)
    {
    InitUC();
    for (b = 0; b < 10; b++) Tab[b] = b+48;
    for (b = 11; b < 16; b++) Tab[b] = b+65;
    while(1)
    {
    if (i == 250000)
    {
    while (_SPITBF == 1);
    SPI1BUF = 10;
    while (_SPIRBF != 1);
    if (_SPIROV == 1) _SPIROV = 0;
    VarTemp = SPI1BUF;
    for (a = 0; a < 16; a++)
    {
    if (VarTemp == Tab[a]) ReponseSPI = Tab[a];
    }
    while (_UTXBF == 1);
    U1TXREG = ReponseSPI;
    while (_UTXBF == 1);
    U1TXREG = 0x2C;
    }
    if (i == 500000)
    {
    while (_SPITBF == 1);
    SPI1BUF = 160;
    while (_SPIRBF == 0);
    if (_SPIROV == 1) _SPIROV = 0;
    VarTemp = SPI1BUF;
    for (a = 0; a < 16; a++)
    {
    if (VarTemp == Tab[a]) ReponseSPI = Tab[a];
    }
    while (_UTXBF == 1);
    U1TXREG = ReponseSPI;
    while (_UTXBF == 1);
    U1TXREG = 0x0D;
    while (_UTXBF == 1);
    U1TXREG = 0x0A;
    }
    i++;
    if (i > 500000)
    {
    i = 0;
    }
    }
    return 1;
    }

    --------------------------------------------------------------------------


    Et voici maintenant le programme complet de l'esclave :

    --------------------------------------------------------------------------
    /****************************** ****************************** *****/
    /* Nom du fichier : Main.c */
    /****************************** ****************************** *****/

    #include "Gateway.h"

    /****************************** ****************************** **********/
    /* Configuration du µC */
    /****************************** ****************************** **********/
    _FBS(BSS_NO_FLASH & BWRP_WRPROTECT_OFF); // Pas de segment de boot et pas de protection en écriture
    _FGS(GSS_OFF & GCP_OFF & GWRP_OFF); // Pas de protection du code
    _FOSCSEL(FNOSC_PRIPLL & IESO_OFF); // Oscillateur principal avec PLL et 1 vitesse de l'oscillateur au démarrage
    _FOSC(FCKSM_CSDCMD & IOL1WAY_OFF & OSCIOFNC_ON & POSCMD_XT); // Pas de clock switching ni de clock monitor,Oscillateur en mode XT
    _FWDT(FWDTEN_OFF & WINDIS_OFF); // WatchDog inactif
    _FPOR(FPWRT_PWR1 & ALTI2C_ON); // POR = 0ms, I²C avec mappage original

    int i = 0;
    int Freq = 8;
    char MIPS = 25;
    int ReceptionSPI = 0;
    byte Counter = 0;
    byte Countdown = 16;
    int Tab[16] = {0};

    void __attribute__((__interrupt__, no_auto_psv)) _SPI1Interrupt(void)
    {
    while (_SPIRBF == 0);
    ReceptionSPI = SPI1BUF;
    _SPI1IF = 0;
    }




    char InitPLL(int quartz, char Fcy)
    {
    char N1=2, M=2, N2=1; // N1=>PLLPRE, M=>PLLDIV, N2=>PLLPOST

    // Sécurités //

    if((Fcy<7) || (Fcy>40)) // page 78 de la datasheet est dit que Fcy doit être comprise entre 6.25 et 40 MIPS.
    return 1; // Si on est pas dans cet intervalle, on retourne 1.

    if((quartz<2) || (quartz>264)) // A la sortie de PLLPRE on doit être entre 0.8 et 8MHz. Sachant que dans PLLPRE
    return 2; // on peut diviser la fréquence du quartz par un nombre comprit entre 2 et 33, on a
    // donc la fréquence du quartz devant être comprise entre 2 et 264MHz (0.8*2=1.6 soit
    // presque 2MHz et 8*33=264MHz)

    while((quartz/N1)>8)N1++; // A la sortie de PLLPRE, nous devons avoir une fréquence comprise entre 0.8 et 8MHz.
    // Donc quartz/N1 doit être inférieur à 8.

    while(((Fcy<<1)<<N2)<100)N2++; // Permet de déterminer N2
    if(N2==3) N2++;

    // Paramétrage des oscillateurs //

    M = ((Fcy<<1)<<N2)/(quartz/N1); // Détermine M;

    _PLLPRE = N1-2; // Affectation de PLLPRE avec la valeur N1 déterminé précédemment
    _PLLPOST = N2-1; // Affectation de PLLPOST avec la valeur N2 déterminé précédemment
    _PLLDIV = M-2; // Affectation de PLLDIV avec la valeur M déterminé précédemment

    return 0; // Indique que tous c'est correctement déroulé
    }




    void InitPort(void)
    {
    IOpin6 = 2; //_SCK1R
    IOpin7 = 7;
    IOpin26 = 15; //_SDI1R
    IOpin15 = 6; //_SS1R
    _NSTDIS = 0;
    }




    void InitSPI(void)
    {
    SPI1BUF = 0x0000;
    IFS0bits.SPI1IF = 0;
    IEC0bits.SPI1IE = 0;

    SPI1STATbits.SPISIDL= 0;

    SPI1CON1bits.DISSCK = 0;
    SPI1CON1bits.DISSDO = 0;
    SPI1CON1bits.MODE16 = 1;
    SPI1CON1bits.SMP = 0;
    SPI1CON1bits.CKE = 0;
    SPI1CON1bits.SSEN = 0;
    SPI1CON1bits.CKP = 0;
    SPI1CON1bits.MSTEN = 0;
    SPI1STATbits.SPIROV = 0;
    SPI1STATbits.SPIEN = 1;

    IFS0bits.SPI1IF = 0;
    IEC0bits.SPI1IE = 1;
    }


    void InitUC(void)
    {
    InitPLL(Freq, MIPS);
    InitPort();
    InitSPI();
    _SPIEN = 1;
    _SPI1IE = 1;
    }



    int main(void)
    {
    InitUC();
    for (i = 0; i < 10; i++) Tab[i] = i+48;
    for (i = 10; i < 16; i++) Tab[i] = i+65;
    while(1)
    {
    while (_SPIRBF == 0);
    if (_SPIROV == 1) _SPIROV = 0;
    ReceptionSPI = SPI1BUF;
    if (ReceptionSPI == 10)
    {
    while (_SPITBF == 1);
    SPI1BUF = Tab[Counter];
    ReceptionSPI = 0;
    Counter++;
    if (Counter > 15) Counter = 0;
    }
    if (ReceptionSPI == 160)
    {
    while(_SPITBF == 1);
    SPI1BUF = Tab[Countdown];
    ReceptionSPI = 0;
    if (Countdown < 1) Countdown = 15;
    Countdown--;
    }
    }
    return 1;
    }


    --------------------------------------------------------------------------

    Voilà donc comment j'essais de les faire communiquer. Ce sont mes programmes avec les dernière modifications. J'ai testé l'UART, il m'affiche bien ce que je souhaite. Le problème ne vient pas de là.

    Par ailleurs, j'avais déjà testé l'interruption avec un point d'arret et c'est pour ça que je disais que je ne rentrais pas dedans.

    Qui plus est, je viens de changer un petit branchement électrique... je n'utilise plus la broche SSx. Sur l'esclave, j'ai relié cette broche à la masse et sur le maître, à une résistance de protection et à l'alim Vdd = 3.3V.

    Je viens de tester ces nouvelles versions de programme... j'obtiens toujours l'affichage seul d'une virgule et rien du tout autour. Mon affichage de virgule et de retour à la ligne se fait bien sur l'UART mais pas ma communication SPI.

    Quelqu'un saurait-il pourquoi? J'ai déjà fait plein de recherches sur Internet, mais je ne trouve rien sur le sujet... tout du moins, qui sois assez démonstratif pour mon problème...

    Cordialement

    Crepuscule3

  13. #9
    Crepuscule3

    Re : dsPIC et Bus SPI...

    Personne n'a d'idée ou n'a déjà fait cela?

  14. #10
    Crepuscule3

    Re : dsPIC et Bus SPI...

    Vraiment aucune idée? Je ne trouve désespérément pas ce qu'il ne va pas...

  15. #11
    Youscoul

    Re : dsPIC et Bus SPI...

    Bonjour,

    Je vois que la discussion date de longtemps, mais je voudrais savoir si t'avais pu resoudre ton problème communication avec la SPI slave.

    Actuellement, je travaille sur un projet maison et j'ai le même comportement que toi. Selement, je passe par le DMA associé à mon SPI.

    Ou si quelqu'un d'autre peut m'aider sur le problème.

    En effet, je dispose dejà d'une carte qui communique en SPI en tant maitre (tout est ok). Je voudrais communiquer avec en developpant l'application SPI Slave sur ma carte (dsPIC33FJ256GP506, FCY = 20MHz, SPI1 avec DMA0 pour TX et DMA1 pour RX).

    A la mise sous tension, je dois juste activer une PIN pour signaler au maître que je suis pret à communiquer. Après il m'envoie une trame de 16 octets du genre (01 05 00 01 00 00 00 00 00 00 00 00 00 00 00 00) mais bizzarement je reçois que (DC 00 DC 00 DC 00 DC 00 DC 00 DC 00 DC 00 DC 00).

    Quelqu'un aurait une idée de ce qui m'arrive.

    Merci.

  16. #12
    DAUDET78

    Re : dsPIC et Bus SPI...

    Notre ami Crepuscule3 est aux abonnés absents depuis le Dernière activité 08/09/2009 12h57 ...... quasiment 4 ans
    J'aime pas le Grec

  17. Publicité
  18. #13
    RISC

    Re : dsPIC et Bus SPI...

    Salut Youscoul,

    Tentes ta chance ici : http://www.microchip.com/CodeExamples et tu filtres les exemples pour les dsPIC33F/E. tu trouveras plusieurs exemples de code SPI pour les dsPIC33.

    A+
    Ma marotte ? les microcontrôleurs ;=)

  19. #14
    Youscoul

    Re : dsPIC et Bus SPI...

    Merci RISC,

    J'ai trouvé sur le site de miicrochip des examples avec SPI et DMA.
    Je recois une trame correcte du maître (même si j'ai toujours les DC DC DC DC DC DC DC....) venant du maitre. Je pense que c'est un problème du mâitre car même avec un analyseur SPI j'observe des DC DC DC DC DC DC....

    Par contre lorsque ma SPI slave recois une trame coherente, je voudrais just renvoyer la même au maitre, cela pour verifier que mon DMA transmission est bien configuré. Mais bizzarement, je n'arrive pas à transmettre, du moins j'observe des données bizzares sur mon analyseur. Même en fixant la data à 5555, j'observe que des octets bizzares.

    Donc, du moment où je copie les données dans mon DMA buffer, je donne la taille à transmettre et je donne le top de départ est ce que je devrais faire autre chose avec la SPI en mode transmission ?

    Voici ma fonction de transmission :

    void Tx_function()
    {
    /* Copy SPI receive frame to send in transmit buffer */
    memcpy(SPI1_TransmitBuffer, SPI1_ReceiveBuffer, 16);

    /* Wait end of transfer if necessary */
    while (DMA0REQbits.FORCE == 1)
    {
    ;
    }

    /* Set size of bytes to be sent */
    DMA0CNT = (length - 1);

    /* Channel enabled */
    DMA0CONbits.CHEN = 1;

    /* Start SPI transmission thank to DMA */
    DMA0REQbits.FORCE = 1;
    }

    Merci d'avance

Discussions similaires

  1. liaison SPI et bus I2C
    Par cimbomlu dans le forum Électronique
    Réponses: 1
    Dernier message: 27/02/2008, 13h55
  2. Bus SPI
    Par KHEOPS1982 dans le forum Électronique
    Réponses: 2
    Dernier message: 14/02/2008, 21h11
  3. ATtiny45 : bus SPI : ports spéciaux ?
    Par Sevenup dans le forum Électronique
    Réponses: 0
    Dernier message: 26/09/2007, 17h41
  4. Influence resistance serie bus SPI
    Par mick_74 dans le forum Électronique
    Réponses: 2
    Dernier message: 14/10/2006, 10h51
  5. Liaison RS232, Bus I2C et SPI.
    Par SiD dans le forum Électronique
    Réponses: 1
    Dernier message: 01/06/2003, 18h31
Découvrez nos comparatifs produits sur l'informatique et les technologies.