PIC32 utilisation de la DMA

[invite4f7ba01b]

Bonjour,

Après une bonne journée de lecture intensive de la doc de la DMA du PIC32, il y a quelques points que je ne comprends pas.

Quelles sont les rôles des "DMA channel x Cell" et des "Block transfer"? J'ai vu dans la doc où ces termes étaient définies mais bon ça tilt pas dans ma petite cervelle

Le but aussi de cette question est de trouver la manière d'initialiser le DMA channel 0 par exemple pour transférer les données d'un tableau défini de la manière suivante : unsigned long spectrum [2050] = {0,....0} vers un autre tableau unsigned long spectrum_DMA [2050] à chaque réception d'une chaîne de caractère de l'UART2.

j'ai eu beau analyser tous les exemples de codes fournis au sujet de la DMA, il n'y a que des transferts de tableau de char.

Après j'aurais aussi besoin à chaque interruption Timer de transférer le contenu du tableau de long "spectrum" vers la liaison spi ou UART. Par contre la, j'ai une autre question. Faut il que je prévoie de convertir mon tableau de long en tableau de char?

J'ai commencé à faire quelques initialisations dans un premier temps mais sans utiliser d'interruption mais en forçant le début du transfert.




void DMATransfer()
{
unsigned long dmascr = 0;
unsigned long dmadest = 0;

dmascr =(unsigned long) spectrum; // cast de l'adresse du tableau en long
dmadest =(unsigned long) spectrum_DMA;

IEC1CLR = 0x00020000; // disable DMA channel 0 interrupts
IFS1CLR = 0x00020000; // clear existing DMA channel 0 interrupt flag
IEC1CLR = 0x00010000; // disable DMA channel 0 interrupts
IFS1CLR = 0x00010000; // clear existing DMA channel 0 interrupt flag
DMACONSET = 0x00008000; // enable the DMA controller
DCH0CON = 0x3; // channel off, pri 3, no chaining
DCH0ECON = 0; // no start or stop irq?s, no pattern match

// program the transfer
DCH0DSA = dmascr; // Transfer destination physical address
DCH0SSA = dmadest; // Transfer source physical address

DCH0SSIZ = 2050; // Block transfer source size bytes
DCH0DSIZ = 2050; // Block transfer destination size bytes

DCH0CSIZ = 2050; // Cell transfer bytes

DCH0INTCLR = 0X00FF00FF; // clear existing events, disable all interrupts
DCH0INTbits.CHBCIE = 1; // Channel Block Transfer Complete Interrupt Enable bit

DCH0CONSET = 0x80; // turn channel on

// initiate a transfer
DCH0ECONSET = 0x00000080; // set CFORCE to 1

while(IFS1bits.DMA0IF == 0); // Wait DMA to complete

DMACONCLR = 0x00008000; // Disable the DMA controller
}


Bonne journée et merci d'avance pour le coup de pouces!

detube78
-----

[RISC]

Salut,

Pour répondre à ta première question :
============================== ==================
Event – any system event that can initiate or abort a DMA transfer

Transaction – a single word transfer (up to 4 bytes) comprised of read and write operations

Cell transfer – the number of bytes transferred when a DMA channel has an event request data be moved. After completing the cell the DMA channel returns to waiting for a new event. (one or more transactions can be in each cell)

Block Transfer – one or more Cell transfers. When a Block is completed the channel is disabled.
============================== ==================
Le block est un ensemble de cellules, La cellule un ensemble de transactions et la transaction un transfert de base (1/2 ou 4 octets en fonction du périphérique)

Le bus principal (Bus Matrix) fait 128 bits ( 4 x 32 ) mais tu ne peux transferer au maximum que 32 bits par cycle ( 4 octets )
Vu du DMA il se "fout" de ce qu'il y a dans ton tableau...par contre il faut que le périphérique soit compatible avec la taille choisie.

Concernant l'initialisation du DMA, je te recommande de démarrer avec un exemple de code, cela te permettra de gagner tu temps ;=)
Les exemples de code se trouve ici (tu filtres par coeur "PIC32") et tu trouveras au moins un exemple de code pour DMA.

Je me suis "amusé" une fois à faire un effet de goutte d'eau sur 8 leds. Cela ne prend absolument aucun cycle au processeur ;=)


a+

[invite4f7ba01b]

Merci RISC pour l'éclaircissement. Maintenant ça tilt!

D'après la réponse que tu m'as fait et si j'ai bien compris ta réponse, le contrôleur DMA s'en fiche si je veux transférer du char en donnée (dans ce cas il s'adaptera tout seul et transfèrera qu'un octet de chaque case mémoire) et si je veux transférer du long (idem sauf qu'il transférera les 4 octets de la case mémoire) Dans ce dernier cas nous sommes au max des possibilités du bus 128 bits,non?

Mon initialisation que j'ai mise dans mon premier message marcherait donc dans le transfert.

Question piège, ce bus est il lui aussi cadencé à 80MHz? si c'est le cas ça fait une grosse puissance de transfert (4 octets toutes les 12,5 ns...... ça laisse rêveur)

Dans le cas où je veux transférer ces données long vers l'uart par un autre channel de la DMA, c'est lui aussi qui fait la tripaille pour transférer octet par octet mes données long?

[RISC]

Salut,

comme je l'ai dit, le bus interne fait 4 x 32 bits. Donc au maximum 32 bits / cycle pour un canal DMA.
Si tes données sont plus longues que 32 bits (long int) il faudra donc 2 cycles
Les PIC32 peuvent faire jusqu'à 4 transactions par cycle si les sources et destinations des transferts sont différents.
Il y a bien sûr quelques cycles d'arbitration mais globalement cela donne une bande passante très importante.
Dans les PIC32MX795 (Ethernet/USB/2 x CAN), chacun de ces périphériques a ses propres canaux de DMA pour éviter de "piocher" dans les canaux DMA de l'utilisateur ;=)
Cette bande passante est nécessaire pour pouvoir "suivre" le nombre élevé de périphériques ;=)
Avec l'ethernet, il est possible d'atteindre 72MBits/s en UDP avec la stack TCP/IP !

Utiliser les PIC32 sans DMA c'est mettre un moteur de BMW sur un chassis de 2CV ;=)

a+

[A voir en vidéo sur Futura]

[invite4f7ba01b]

Mes données sont des unsigned long. Est-ce que le compilateur xc32 considère ça comme un long int, ça je ne sais pas mais même s'il prend deux coups d'horloges ça me va très bien!

[RISC]

Salut,

Autant pour moi. J'ai revérifié le manuel du compilo XC32 les unsigned long int sont sur 32 bits donc 1 seul cycle ;=)

a+

[invite4f7ba01b]

Merci beaucoup RISC,

Effectivement le contrôleur de DMA se fiche de savoir quel format de données nous voulons transférer du moment que nous paramétrons le bon nombre de bytes à transférer.

ça fonctionne très bien! La DMA met un peu moins de 200µs pour transférer mes 8200 octets (2050 unsigned long) soit un transfert à 40Mo/s sans utiliser le CPU, c'est quand même génial! Je vais aussi faire des essais pour utiliser le DMA et ma liaison UART qui tourne à 2Mbaud.

Par contre j'ai fais un essai de performances et le memcpy est un peu plus de 2 fois plus rapide que la DMA. Par contre ça use du cycle CPU mais quelqu'un sait pourquoi memcpy est plus rapide?

Je vous tiens informer des avancées de mes tests!

Bonne journée!

detube78

[RISC]

Salut,

Il y a énormément de paramètres qui peuvent influencer les performances des PIC32 et des DMA.
Le cas de la copie mémoire à mémoire est le plus "désavantageux" pour le DMA car le code est linéaire et donc le nombre de "stalls" dans le cache est minimum.

Il y a une arbitration interne de tous les périphériques qui se trouve sur le bus matrix.

Comment as-tu mesuré le temps d'exécution ?

As-tu utilisé la macro SYSTEMConfigPerformance( Fosc ) au début de ton programme lors de l'initialisation ?

a+

[invite4f7ba01b]

Salut RISC,

Non je n'ai pas mis cette fonction, je n'ai utilisé que SYSTEMConfig. Qu'apportes la fonction SYSTEMConfigPerformance?

Pour mesurer le temps je pilote une sortie en la maintenant à 1 jusqu'à l'apparition d'une interruption de la DMA channel 0. Idem pour le memcpy borné par les mêmes instructions de pilotage.

A+

Detube78

[RISC]

Salut,

Peux-tu faire voir ton code d'initialisation ????

C'est TRES TRES IMPORTANT de correctement initialiser le PIC32 pour qu'il fonctionne de manière optimale....
Tu peux très facilement perdre un facteur 2 à 5 en perf si il n'est pas initialisé correctement !
SYSTEMConfig ne fait qu'une partie du boulot...donc il faut encore quelques lignes de code derrière.

SYSTEMCOnfigPerformance doit être utilisé dans chaque programme PIC32 avec entre () la valeur de Fosc (généralement 80.000.000).
Cette fonction fait appel en interne à plusieurs CENTAINES d'instructions assembleur ;=)

Voir la documentation des librairies

a+

PS : tu utilises bien le compilateur XC32 ? (dernière version = v1.21)

[invite4f7ba01b]

Salut!

Ah bon, je ne pensais pas qu'il y avait moyen de l'optimiser aux petits oignons. Effectivement j'utilise la dernière version du compilateur xc32 v 1.21. Je l'ai installé depuis que quelques jours avant j'étais sur MPLAB IDE.

Mon code d'initialisation est le suivant:

#include <plib.h>
#include "uart.h"
#include "system.h"
#include <peripheral/spi.h>
#include <stdio.h>
// Configuration Bit settings
// SYSCLK = 80 MHz (10 MHz Crystal/ FPLLIDIV * FPLLMUL / FPLLODIV)
// PBCLK = 40 MHz
// Primary Osc w/PLL (XT+,HS+,EC+PLL)
// WDT OFF
// Other options are don't care
//
#pragma config FPLLMUL = MUL_16, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF // 10MHz --> /2 --> 5MHz --> *16 --> 80MHz
#pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_2
#define SYS_FREQ (80000000L)


int main(void)
{
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE); // change the flash wait states, RAM wait state and enable prefetch cache
// SYSTEMConfigPerformance(Fosc);
init_IO_PIC32 (); // Initialisation
spi2init (); // Initialisation bus spi 2 Réglage seuil
UART1_init (); // Initialisation Uart 1 Périphérique PC
INTConfigureSystem(INT_SYSTEM_ CONFIG_MULT_VECTOR);
INTEnableInterrupts();
write_register_LMP_8 (0x20, 0x02,0x00); // commande : 2 adress : 0 (DAC A) seuil à 27mV
UART1PrintString("Device init \r\n");
// IEC0bits.INT2IE = 0; // disable int 2 interrupt
// INTCONbits.INT2EP = 1; // rising edge
// IPC2bits.INT2IP = 2;
// IPC2bits.INT2IS = 3;

while (1)
{
//UART1PrintString("ERROR \r\n");
// UART1PutHexWord (0x55);
//ID_msg= UART1GetChar();
//UART1PutHexWord(ID_msg);
//PutCharacter(UART1GetChar());
//UART1PutChar(UART1GetChar());
//if(IFS0bits.U1RXIF == 0 ) { UART1PrintString("BOUCLE \r\n"); } else { UART1PrintString("ERROR \r\n"); }
}
}

Je suis preneur pour des infos pour utiliser au max les performances du PIC32.

detube78

[RISC]

Salut,

La macro SYSTEMConfig force les valeurs que tu choisis pour les paramètres. Si tu es sür de toi c'est OK
Il vaut beaucoup mieux utiliser SYSTEMConfigPerformance car cette macro calcule pour toi automatiquement les meilleurs paramètres (wait states, cache,...). PBDIV est forcé à 1 (il est généralement meilleur au niveau conso de mettre PBDIV à 1:2).

Donc moi je mets cette séquence en début de main :

void main(void) 
{
        SYSTEMConfigPerformance(SYS_FREQ);   // optimisation automatique de la performance pour la fréquence choisie
	DDPCONbits.JTAGEN = 0;                        // désactiver le JTAG actif au reset pour libérer les broches
...

Au niveau du choix du quartz il vaut mieux choisir un multiple de 4MHz sachant que la PLL accepte entre 4 et 5Mz.
La raison est que certains PIC32 qui possède l'USB on besoin de 4MHz à l'entrée ce qui permet d'ateindre 4 x 24 = 96MHz /2 = 48MHz

Quel référence de PIC32 utilises-tu ?

Pour les interruptions il y a une banque shadow de 32 registres en plus qu'il faut utiliser car elle permet des changements de contexte plus rapide (pas besoin de sauver les registres, il suffit de changer de banque).

Il existe plein d'exemples de code pour les PIC32 qui permettent de gagner du temps pour gérer certains périphs ou faire des choses astucieuces (exécuter du code à partir de la RAM, changer la base de la table des interruptions,....)

a+

[invite4f7ba01b]

Est-ce qu'il faut éviter de mettre SYSTEMConfigPerformance(SYS_FR EQ); avec SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);?

J'avais qu'un quartz de 10MHz donc j'ai du paramétrer tout pour avoir la fréquence au max.

J’utilise le PIC32MX695F512L. Il a l'air super puissant. Personnellement je débute dans le PIC32. Je l'ai pris parce qu'après j'aimerais mettre un serveur web avec une page html. J'ai encore un long chemin à faire. ça m'intéresserait de savoir où tu peux trouver les exemples de codes pour optimiser le fonctionner du micro surtout que j'utilises pas mal d'interruption (2 Timers, 2 UART, 1 interruption externe) Plus c'est rapide et bien optimiser mieux c'est.

Detube78

[RISC]

Salut,

Si tu utilises SYSTEMCOnfigPerformance(...) tu n'as besoin de rien d'autres (voir mon programme ci-dessus)

Tu trouveras les exemples de code ici : http://www.microchip.com/codeexamples et tu filtres par coeur "PIC32"
Il existe 40 ou 50 exemples pour les PIC32 faciles à mettre en oeuvre.

Quelle carte utilises-tu ?

Si tu veux faire un webserveur, je te recommande d'utiliser le projet Demo App ou Webvend qui sont dans les librairies gratuites téléchargeables ici :http://www.microchip.com/MLA.

Après installation tu vas dans ce répertoire : c:\microchip_solutions_v2013-02-15\TCPIP\
Les projets sont ....musclés (entre 50 à 80 fichiers sources)

a+

[invite4f7ba01b]

J’essaierais en rentrant de vacances de mettre que la fonction SYSTEMCOnfigPerformance.

J'ai une carte home made avec un FPGA, un gps et d'autres joyeusetés. Par contre j'ai acheté des cartes de dev Ethernet starter kit et si dessus je peux accéder directement aux paramètres de mon système de mesure. Fini la liaison série traditionnelle

D'ailleurs je me demandais si ça avait déjà été fait de pouvoir programmer un PIC32 directement par la liaison ethernet. Tu me diras, il existe des bootloaders pour USB donc pourquoi pas ethernet.

Bonne soirée

A+

[RISC]

Salut,

Les bootloaders USB, Ethernet, CAN UART, carte SD...existent pour les PIC32. Certains gratuits, d'autres open source ou payants.
Tu trouveras dans les notes d'application pour PIC32, une note d'application très intéressante car elle fait 5 types de bootloaders et la partie communication est séparée de la partie bootloader ce qui permet de l'adapter pour d'autres types de bootloders : AN1388 .
Elle fait : UART, carte SD, Ethernet, USB HOST sur clé USB, USB device ;=)

a+

[invite4f7ba01b]

Me revoici de vacances et avec quelques nouvelles.

Alors j'ai essayé le transfert de la DMA d'un tableau de valeur vers l'uart1 et ça marchote.

voici ma fonction:

void DMA_Transfer_tablong_to_UART1( unsigned int size)
{
// int dmaFlags=0;
unsigned char Buff[30] = { 75, 56 ,57, 11 , 57 , 12 ,58 , 13 , 59 ,14 , 60 , 15 , 61 , 16 , 62 , 17 , 63 , 18 , 64 , 19 , 65 , 20 , 66 , 21 , 67 , 22 , 68 , 23 , 69 , 24 };

IEC1CLR = 0x00020000; // disable DMA channel 0 interrupts
IFS1CLR = 0x00020000; // clear existing DMA channel 0 interrupt flag
DMACONSET = 0x00008000; // enable the DMA controller
DCH1CON = 0x3; // channel off, pri 3, no chaining
DCH1ECON = 0; // no start or stop irq?s, no pattern match

DCH1DSA = KVA_TO_PA(&U1TXREG) ; // DESTINATION ADRESS
DCH0SSA = KVA_TO_PA(Buff) ; // SOURCE ADRESS
DCH1SSIZ=size; // source size
DCH1DSIZ=1; // dst size is 1 byte 0
DCH1CSIZ=1; // one byte per UART transfer request 1

DCH1INTCLR = 0X00FF00FF; // clear existing events, disable all interrupts
DCH1INTbits.CHCCIE = 1; // Cell Transfer Complete Interrupt Enable bit
DCH1ECONbits.CHSIRQ=_UART1_TX_ IRQ ;
DCH1ECONbits.SIRQEN=1;
//--------------------------------------------- DMA0 Interrupt initialisation ---------------------------------------------

IPC9CLR=0x00001F00; // clear the DMA channel 1 priority and sub-priority
IPC9SET=0x00001600; // set DMA channel 1 priority 5 and sub-priority 2
IEC1SET=0x00020000; // enable DMA channel 1 interrupt
//-----------------------------------------------------------------------------------------------------------------------------------------------------------
DCH1CONSET = 0x80; // turn channel on

// initiate a transfer
DCH1ECONSET = 0x00000080; // set CFORCE to 1

PORTAbits.RA9 = 1;
}

Au niveau de size, j'ai mis 10.

Sauf que pas de bol, le caractère A s'affiche sur l'interface série et rien d'autre...

Je vais continuer à creuser la question mais si vous avez une explication ou idée du pourquoi, n'hésitez pas!

Merci

detube78

[invite4f7ba01b]

Bon finalement il ne faut pas travailler juste en rentrant de vacances

J'ai trouvé ce qui ne marchait pas finalement. En fait au lieu de DCH0SSA, c'était DCH1SSA et pour DCH1CSIZ il faut mettre 0. ça fonctionne bien.
Prochaine étape, utiliser la DMA avec la liaison SPI pour mes mémoire flash et fram.

Bonne journée!

Au passage merci RISC pour les infos sur la DMA. La suite d'ici quelques jours!

detube78

[invite4f7ba01b]

Quand un problème est résolu, un autre apparaît.

J'observe la chose suivante. Si au niveau de size je mets de 1 à 9 tout va bien, le nombre de caractère correspond. Par contre dès que j'essaie d'en envoyer 10 voir plus, j'ai toujours 9 caractères qui s'affichent sur l'interface série.... J'utilise real term pour scruter la liaison série.

Comme d'habitude je creuse la question mais bon si quelqu'un peut m'expliquer pourquoi j'observe cela, je prends

Bonne après midi!

detube78

[invite4f7ba01b]

Je continue mon monologue
Problème résolu, j'ai trouvé pourquoi cela s'arrêtait. La FIFO de l'uart de transmission était pleine. Pour que cela marche de mon côté, voici le code final. Attention tout de même à votre configuration matérielle (oscillateur, réf de PIC)

/****************************** ****************************** * INITIALISATION UART 1 ****************************** ****************************** ************/
void UART1_init (void)
{
// 2 000 000 Baud U1BRG = 4 et BRGH = 1 173 57600
/***************************** Désactivation interruption UART 1 ****************************** ******/
IEC0bits.U1RXIE = 0;
IEC0bits.U1TXIE = 0;
IEC0bits.U1EIE = 0;
/***************************** Clear flag interruption UART 1 ****************************** *********/
IFS0bits.U1RXIF = 0; // Clear Uart1 RX flag
IFS0bits.U1TXIF = 0; // Clear Uart1 TX flag
IFS0bits.U1EIF = 0; // Clear Uart1 eRROR fla

U1MODEbits.ON = 0; // Désactivation module UART 1
U1BRG = 86; // 500 000 baud avec FPB = 40MHz (4 -> 500 000 baud) (0 -> 2500000)
/****************************** Paramétrage UART 1 Mode Register ****************************** ******/
U1MODEbits.SIDL = 0; // Continue operation Idle Mode
U1MODEbits.IREN = 0; // IrDA is disables
U1MODEbits.RTSMD = 0;
U1MODEbits.UEN = 0; // TX & RX pins are enabled and used; CTS,RTS/UxBCLK pins controlled by PORTx register
U1MODEbits.WAKE = 0; // Wake-up disabled
U1MODEbits.LPBACK = 0; // Loopback mode is disabled
U1MODEbits.ABAUD = 0; // Baud rate measurement disabled or completed
U1MODEbits.RXINV = 0; // UxRX Idle state is ‘1’
U1MODEbits.BRGH = 1; // Standard Speed mode – 16x baud clock enabled
U1MODEbits.PDSEL = 0; // 8-bit data, no parity
U1MODEbits.STSEL = 0; // 1 Stop bit
/****************************** Paramétrage UART 1 Status Register ****************************** ***/
U1STA = 0;
U1STAbits.ADM_EN = 0; // Automatic Address Detect mode is disabled
U1STAbits.ADDR = 0;
U1STAbits.UTXISEL0 = 1;
U1STAbits.UTXISEL1 = 0;
U1STAbits.UTXINV = 0; // UxTX Idle state is ‘1’
U1STAbits.URXEN = 1; // UARTx receiver is enabled. UxRX pin is controlled by UARTx (if ON = 1)
U1STAbits.UTXBRK = 0; // Break transmission is disabled or completed
U1STAbits.UTXEN = 1; // UARTx transmitter is enabled. UxTX pin is controlled by UARTx (if ON = 1)
U1STAbits.URXISEL0 = 0; // Interrupt flag bit is set when a character is received
U1STAbits.URXISEL1 = 0;
U1STAbits.ADDEN = 0; // Address Detect mode is disabled

IFS0bits.U1RXIF = 0; // Clear Uart1 RX flag
IFS0bits.U1TXIF = 0; // Clear Uart1 TX flag
IFS0bits.U1EIF = 0; // Clear Uart1 eRROR flag
U1MODEbits.ON = 1;
IEC0bits.U1RXIE = 1;
IEC0bits.U1TXIE = 0;
IEC0bits.U1EIE = 0;
IPC6bits.U1IP = 2; // priorité niveau 2
IPC6bits.U1IS = 0; // sous priorité niveau 0
}



/****************************** **************************** DMA CHANNEL 1 POUR TRANSFERER TABLEAU DE CHAR VERS UART1 ****************************** ******/
void DMA_Transfer_tablong_to_UART1( unsigned int size)
{
// int dmaFlags=0;
DCH1ECONbits.CFORCE = 0; // set CFORCE to 1
DMACONbits.ON = 1;
IEC1bits.DMA1IE = 0; // disable DMA channel 0 interrupts
IFS1bits.DMA1IF = 0; // clear existing DMA channel 0 interrupt flag
DCH1CONbits.CHEN = 0;
DCH1CONbits.CHPRI = 3; // channel off, pri 3, no chaining
DCH1ECONbits.CHSIRQ = 28; // start on UART1 TX irq , no pattern match
DCH1ECONbits.SIRQEN = 1;

DCH1SSA = KVA_TO_PA((void*)&myBuff_uart1[0]); // SOURCE ADRESS
DCH1DSA = KVA_TO_PA((void*)&U1TXREG); // DESTINATION ADRESS

// Source Size
DCH1SSIZ = size; // This is how many bytes you want to send out in a block transfer for UART transmitter
// Destination Size
DCH1DSIZ = 1; // This is how many bytes come from the destination - i.e. U3ATXREG
// Cell Size
DCH1CSIZ = 1; // Transfer 1 byte from txBuf to U3ATXREG at a time 0


DCH1INT &= ~(0x00FF00FF); // clear existing events, disable all interrupts DCH1INTCLR = 0X00FF00FF;
DCH1INTbits.CHBCIE = 1; // Block Transfer Complete Interrupt Enable bit

// Interrupt Setup
IPC9CLR=0x00001F00; // clear the DMA channel 1 priority and sub-priority
IPC9bits.DMA1IP = 5; // set DMA channel 1 priority 5
IPC9bits.DMA1IS = 1; // set DMA channel 1 sub-priority 1
IEC1bits.DMA1IE = 1; // enable DMA channel 1 interrupt

DCH1CONbits.CHEN = 1; // turn channel on

// initiate a transfer
DCH1ECONbits.CFORCE = 1; // set CFORCE to 1

//PORTAbits.RA9 = 1;
}

bonne journée et merci RISC!

detube78

[RISC]

Salut,


Quel PIC32 utilises-tu ?
Quel compilateur ?

Je te recommande d'utiliser les librairies plutot que de programmer les registres à la mimine ;=).

Exemple ici.

a+

[invite4f7ba01b]

Salut!
Alors j'utilise le PIC32MX695F512L. Je suis sur MPLAB X IDE et le compilateur XC32 v1.21
Soit dit en passant, l'interface et le compilo sont de bonnes qualités.
Je pense que je vais reprendre ton code pour l'effet goutte d'eau pour une appli maison C'est ma fille qui va être contente!

Oui mes petites mimines ont la fâcheuse habitude de programmer tous les registres. Après ça percute mieux dans mon cerveau même si parfois c'est mieux d'utiliser les fonctions toutes prêtes surtout pour la config du microcontrôleur.

Je suis quand même content du résultat de mon programme car j'envoie 8ko de données sur la liaison série provenant de la RAM interne au PIC32 à 2Mbits/s sans occuper le CPU. Merci pour tes lumières RISC!