PIC32 DMA+SPI = Un probleme pour RISC

[invite8ee4d94b]

Bonjour a tous et surtout toi RISC qui je pense "risc" d'etre de bon conseils ,

Je tente d’établir une communication SPI entre deux microcontroleur PIC32 en utilisant la DMA.

La communication dans le sens Maitre -> Slave est ok .

La communication dans le sens Slave -> maître est ok , juste pour le premier transfert !!! Ensuite et ce pour tous les transferts qui suivent, les réponses reçues par le maître sont toujours décalées de un octet.

Je précise que c'est le maître qui génère le transfert "a la main" ( utilisant la fonction StartTranfert de la bibliothèque périphérique C32 (bit CFORCE) ).

L'esclave est quant à lui en mode automatique : une fois le transfert fait, il attend le prochain train d'impulsion du maître.

Voici la chronologie des évènements visualisé à l'aide de points d’arrêt (placé dans les interruption de transmission du maître et de l'esclave) et d'un scope:

1. Démarrage de l'esclave, il initialise ses channel DMA Rx et Tx .
2. Buffer de 28octet est prêt à être envoyé: Buf[0]=1, Buf[27]=1.

3. Démarrage du maître, il initialise ses channel DMA Rx et Tx .
4. Buffer de 28octet est prêt à être envoyé: Buf[0]=1, Buf[27]=1.

5. INTERRUPTION des deux cartes . Pas de problemes le buffer du maître contient bien : Rxmaster Buf[0]=1, Rxmaster Buf[27]=1.

Observation: au scope comme dans le debugger tout c'est bien déroulé...mais c'était sans compter sur la suite.

6. On relance l'esclave qui vient d'incrémenter les data a envoyer: Tx Slave Buf[0]=2, Tx Slave Buf[27]=2.

7. On relance le maître qui va généré 10ms plus tard un nouveaux transfert.

8. INTERRUPTION des deux cartes . Problème: Rxmaster Buf[0]=1, Rxmaster Buf[27]=2.

9.On relance l'esclave qui vient d'incrémenter les data a envoyer: Tx Slave Buf[0]=3, Tx Slave Buf[27]=3.

10. On relance le maître qui va généré 10ms plus tard un nouveaux transfert.

11. INTERRUPTION des deux cartes . Problème: Rxmaster Buf[0]=2, Rxmaster Buf[27]=3.




Il y a donc bien un problème de décalage à partir du deuxième envoi ...

J'ai vérifier plusieurs fois mes initialisations qui semblent correctes, peut être faut-il jouer avec les registres DCHxSIZ pour "tricher" et éviter ce problème de décalage...

Mais dans ce cas je comprends pas pourquoi le premier transfert ce déroule bien et pas la reste. Si je poste c'est que tout ce que j'ai essayer n'a pas suffit et meme si j'utilise un dummy byte, c'est pas tres propre et ca ne me donne pas la raison du pourquoi du comment...

Merci de m'éclairer de vos lumières !!!
-----

[invite8ee4d94b]

Ollaaa j'ai du en effrayer plus d'un avec ce sujet je pense !

Personne n'a deja utiliser le spi couplé à la dma ?

J'ai donné beaucoup d'informations volontairement pour illustrer mon propos mais si vous avez des idées d'ordre général sur le sujet qui pourrait éclairer ma lanterne cela pourrait m'être grandement bénéfique .

Merci !!!

[invite5637435c]

Bonjour,

attend que RISC passe vu que c'est lui que tu demandes.

[invite8ee4d94b]

hehe effectivement, je sais qu'il est assez affûté sur ces sujets là.

Je viens d'appeler Microchip directement, à priori, il faudrait mettre un nombre n-1 d'octets lors de la phase d'init , ce que j'avais déjà essayer mais cela ne donne rien le problème est le même voir encore plus décalé ou limite ça fait un chenillard lol, a chaque coup je vois les data avancer dans le buffer.

[A voir en vidéo sur Futura]

[invite66c1ab93]

Bonsoir,
J'ai déjà utilisé la DMA et je n'ai pas eu de soucis, mais pas avec le bus SPI.
Peux tu poster ton code pour voir comment tu initialises.
Précises également ton compilateur ainsi que la version ...
Mickael

[invite5637435c]

hehe effectivement, je sais qu'il est assez affûté sur ces sujets là.

Je viens d'appeler Microchip directement, à priori, il faudrait mettre un nombre n-1 d'octets lors de la phase d'init , ce que j'avais déjà essayer mais cela ne donne rien le problème est le même voir encore plus décalé ou limite ça fait un chenillard lol, a chaque coup je vois les data avancer dans le buffer.

Tu m'étonnes.
Je suis bien surpris que tu aies pu avoir Microchip directement... et surtout quelqu'un qui s'y connaisse.

[RISC]

Salut,

J'ai malheureusement pas de pistes pour toi...
Je te recommande d'aller poser ta question sur le forum dédié aux PIC32;=)

a+

[invite8ee4d94b]

Avoir directement microchip c'est possible ( je travaille dans une société d'électronique, ça aide un peu)

Avoir quelqu’un qui s'y connaît c'est fort possible ( si tu arrives à avoir un formateur qui connaît ses produits).

Et voici mes routines d'init. Je rappelle que j'ai deux ethernet starter kit qui communique ensemble via SPI. Un pic est maître l'autre esclave. Chaque pic utilise deux channel DMA : un pour Tx l'autre pour Rx.

Le maître a son channel Tx en mode manuel . Les trois autres channel sont en mode Automatique. C'est l'appel à la fonction Start Transfer sur le channel Tx du maître qui doit tout déclencher (en théorie). Cela fonctionne bien mais j'ai toujours mon problème de réception des octets décalés...

Une dernière remarque: le DmaCHannelSourcePoiter ( DCH1SPTR) du channel dma Tx de l'esclave ne revient pas à 0 une fois que j'ai sauter dans mon interruption... Il le devrait je pense car il devrait se replacer sur le premier element de l'adresse source. J'ai bidouiller avec les 4 buffer size pour essayer de tomber juste mais je suis sois complètement décalé, soit il manque des octets... En plus , en toute logique, les 4 channels devrait avoir un nombre de transaction égale avant de sauter en interruption.

voici le code:

TRANSMISSION DU MAITRE:

void init_DMA_ch_ram_to_spi_1 (void){

    // open and configure the DMA channel.
    DmaChnOpen(DMA_RAM_SPI1, DMA_CHN_PRI3, DMA_OPEN_DEFAULT);

    // set the events: we want the SPI transmit buffer empty interrupt to start our transfer
    DmaChnSetEventControl(DMA_RAM_SPI1, DMA_EV_START_IRQ_EN|DMA_EV_START_IRQ(_SPI1_TX_IRQ));

    DmaChnSetTxfer(DMA_RAM_SPI1, txferTxBuff_a, (void*)&SPI1BUF, 3 /*sizeof(txferTxBuff_a)*/, 1, 1);

    DmaChnSetEvEnableFlags(DMA_RAM_SPI1, DMA_EV_BLOCK_DONE);    // enable the transfer done interrupt, when all buffer transferred

    INTSetVectorPriority(INT_VECTOR_DMA(DMA_RAM_SPI1), INT_PRIORITY_LEVEL_7);        // set INT controller priority
    INTSetVectorSubPriority(INT_VECTOR_DMA(DMA_RAM_SPI1), INT_SUB_PRIORITY_LEVEL_3);        // set INT controller sub-priority

    INTEnable(INT_SOURCE_DMA(DMA_RAM_SPI1), INT_ENABLED);        // enable the chn interrupt in the INT controller

}

RECEPTION DU MAITRE

void init_DMA_ch_spi_1_to_ram(void){

    // open and configure the DMA channel.
    DmaChnOpen(DMA_SPI1_RAM, DMA_CHN_PRI2, DMA_OPEN_AUTO );

    // set the events: we want the SPI receive buffer full interrupt to start our transfer
    DmaChnSetEventControl(DMA_SPI1_RAM , DMA_EV_START_IRQ_EN | DMA_EV_START_IRQ(_SPI1_RX_IRQ));
    
    DmaChnSetTxfer( DMA_SPI1_RAM , (void*)&SPI1BUF, txferRxBuff_a, 1, 3 /*sizeof(txferRxBuff_a)*/, 1);

    DmaChnSetEvEnableFlags(DMA_SPI1_RAM, DMA_EV_BLOCK_DONE);    // enable the transfer done interrupt, when all buffer transferred

    INTEnableSystemMultiVectoredInt();

    INTSetVectorPriority(INT_VECTOR_DMA(DMA_SPI1_RAM), INT_PRIORITY_LEVEL_7);        // set INT controller priority
    INTSetVectorSubPriority(INT_VECTOR_DMA(DMA_SPI1_RAM), INT_SUB_PRIORITY_LEVEL_2);        // set INT controller sub-priority

    INTEnable(INT_SOURCE_DMA(DMA_SPI1_RAM), INT_ENABLED);        // enable the chn interrupt in the INT controller

    DmaRxIntFlag_a=0;            // clear the interrupt flag we're  waiting on
    INTClearFlag(INT_SOURCE_DMA(DMA_SPI1_RAM));    // acknowledge the INT controller, we're servicing int

    DmaChnEnable(DMA_SPI1_RAM);    // enable the DMA channel
    
            
}

TRANSMISSION ESCLAVE

void init_DMA_ch_ram_to_spi (void){

	// open and configure the DMA channel.
	DmaChnOpen(DMA_RAM_SPI1, DMA_CHN_PRI3, DMA_OPEN_AUTO);

	// set the events: we want the SPI transmit buffer empty interrupt to start our transfer
	DmaChnSetEventControl(DMA_RAM_SPI1, DMA_EV_START_IRQ_EN|DMA_EV_START_IRQ(_SPI1_TX_IRQ));

	DmaChnSetTxfer(DMA_RAM_SPI1, txferTxBuff, (void*)&SPI1BUF,/* sizeof(txferTxBuff)*/3, 1 , 1);

	DmaChnSetEvEnableFlags(DMA_RAM_SPI1, DMA_EV_BLOCK_DONE);	// enable the transfer done interrupt, when all buffer transferred

	INTSetVectorPriority(INT_VECTOR_DMA(DMA_RAM_SPI1), INT_PRIORITY_LEVEL_7);		// set INT controller priority
	INTSetVectorSubPriority(INT_VECTOR_DMA(DMA_RAM_SPI1), INT_SUB_PRIORITY_LEVEL_3);		// set INT controller sub-priority

	INTEnable(INT_SOURCE_DMA(DMA_RAM_SPI1), INT_ENABLED);		// enable the chn interrupt in the INT controller

	DmaChnEnable(DMA_RAM_SPI1);	// enable the DMA channel
//	DmaChnStartTxfer(DMA_RAM_SPI1,DMA_WAIT_BLOCK,0);
}

RECEPTION ESCLAVE

void init_DMA_ch_spi_to_ram(void){

	// open and configure the DMA channel.
	DmaChnOpen(DMA_SPI1_RAM, DMA_CHN_PRI2, DMA_OPEN_AUTO );

	// set the events: we want the SPI receive buffer full interrupt to start our transfer
	DmaChnSetEventControl(DMA_SPI1_RAM , DMA_EV_START_IRQ_EN | DMA_EV_START_IRQ(_SPI1_RX_IRQ));
	
	DmaChnSetTxfer( DMA_SPI1_RAM , (void*)&SPI1BUF, txferRxBuff, 1, 3 /* sizeof(txferRxBuff)*/, 1);

	DmaChnSetEvEnableFlags(DMA_SPI1_RAM, DMA_EV_BLOCK_DONE );	// enable the transfer done interrupt, when all buffer transferred

	INTEnableSystemMultiVectoredInt();

	INTSetVectorPriority(INT_VECTOR_DMA(DMA_SPI1_RAM), INT_PRIORITY_LEVEL_7);		// set INT controller priority
	INTSetVectorSubPriority(INT_VECTOR_DMA(DMA_SPI1_RAM), INT_SUB_PRIORITY_LEVEL_2);		// set INT controller sub-priority

	INTEnable(INT_SOURCE_DMA(DMA_SPI1_RAM), INT_ENABLED);		// enable the chn interrupt in the INT controller

	DmaRxIntFlag=0;			// clear the interrupt flag we're  waiting on

	DmaChnEnable(DMA_SPI1_RAM);	// enable the DMA channel
	
}

Merci pour le temps que vous accordez à mon soucis