Vitesse d'exécution Arduino Due

[cubitus_54]

Bonsoir,

Je fais quelques essais sur une carte Arduino Due, elle est constituée d'un Microcontrôleur AT91SAM3X8E tournant à 84MHz

Sous l'interface IDE Arduino 1.6.7 je mets le programme suivant :

void loop() {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
Et le résultat n'est pas à la hauteur... j'ai en sortie un signal rectangulaire de 181kHz...
J'ai loupé un truc ?

Merci
-----

[fdamien12]

Non, c'est juste que les fonctions fournies par la lib Arduino ne sont pas du tout optimisées par la vitesse, mais pour les débutants.
Il y a des tonnes de vérifications, etc...

Je savais qu'elles étaient très lentes, mais à ce point là ! ce serait bien que quelqu'un puisse faire l'essai avec un Arduino à base d'ATMega pour regarder si on trouve le même ordre de grandeur de rapport entre fréquence d'horloge et fréquence de sortie.

Si tu écris directement dans les registres, cela devrait aller nettement plus vite.

A+

edit: faute de frappe

[cubitus_54]

Oui j'en ai bien l'impression...
Sir une Arduino 2560 Mega à 16M la fréquence est de 64kHz

Avec un autre compilateur sur 2560 j'arrive à 1.33M ce qui est plus cohérent.
Par contre il ne compile pas pour la Due....

[vincent66]

Et il y en a qui se demandent encore pourquoi la majorité d'entre nous en avons ras la casquette de ces questions pour arduino, qui devraient être pausées sur un site dédié...

[A voir en vidéo sur Futura]

[cubitus_54]

Et il y en a qui se demandent encore pourquoi la majorité d'entre nous en avons ras la casquette de ces questions pour arduino, qui devraient être pausées sur un site dédié...

Qu'est-ce qui te dérange ?

• Que ce soit une question sur un microcontrôleur ?
• Que la carte de développement s'appelle Arduino ?
• Que la question soit du niveau débutant ?

Si tu n'as pas l'intention de contribuer à une discussion, le plus simple est de ne pas y répondre...

[invite3a1051d7]

Bonjour,
dans la mesure ou le titre du sujet precise bien le contexte ( "Arduino , picaxe, emeteur ,radio fm ....) je pense que toutes les questions ont leur place sur ce forum .

personnellement je m’intéresse a toute sorte de programmation et j'y trouve un interet .
je shunte les sujet qui ne n' interressent pas .
quand au temps d'execution il depend du langage employé .
pour des temps optimun on n'echappe pas à l'assembleur .
personnellement pour mesurer le temps de reaction j'utilise un petit analyseur logique
cordialement
Alain

[cubitus_54]

Merci alainav1

Pour faire un peu avancer le sujet :

sur 2560 Mega :

void loop() {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}

donne 64kHz

void loop() {
PORTB =0x0;
PORTB =0x80;
}

donne 1MHz

void loop() {
while (1)
{
PORTB =0x0;
PORTB =0x80;
}
}

Donne 4Mhz, je pense que la on est au maximum avec une horloge à 16MHz

Pour l'Arduino Due (AT91SAM3X8E)

void loop() {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}

donne 181kHz

Je n'ai pas encore trouvé la bonne instruction pour la suite du test... (je débute avec ce microcontroleur )

[Biname]

Oui, digitalWrite c'est le pompon point de vue vitesse !
Il faut utiliser autre chose, setBit et clearBit sur un Arduino ATMEGA 328P a 16MHz environ un million de boucles par seconde avec digitalWrite on tombe à 110000 boucles par seconde ... ??? il me semble avoir vu pire ???
Dans mon code on voit que Arduino gère une horloge avec millis() ... et d'autres choses !

*/
void setup() {
  // initialize digital pin 13 as an output.
  Serial.begin(115200);
  pinMode(13, OUTPUT);
}

void loop() {
long n, tstart, tstop ;
tstart = millis();
//
// avec bitSet/bitClear
for (n=0; n<=1000000; n++){
  bitSet(PORTB,5);
  bitClear(PORTB,5);
  }
tstop = millis();
Serial.print ("1000000 commutations avec setBit/ClearBit en ms : "); //  resultats 328P 16MHz : 1068ms
Serial.println (tstop - tstart);
//
// avec digitalWrite
tstart = millis();
for (n=0; n<=1000000; n++){
  digitalWrite(13, HIGH);
  digitalWrite(13, LOW);
  }
tstop = millis();
Serial.print ("1000000 commutations avec digital.Write High/Low en ms : "); // resultats 328P 16MHz : 8769ms
Serial.println (tstop - tstart);
}

L'intérêt d'Arduino, ce sont ses librairies et ses cartes et modules à deux balles (328P pro mini/nano 1.3€ maintenant).

Biname

[cubitus_54]

Le plus efficace est PORTB=xxx

bitSet ou bitClear est un peu plus lent, dans mon test 2.7MHz
Je pense que cette commande ajoute une instruction de masquage pour gérer un bit sur les 8.


Ce serait quoi l'équivalent pour AT91SAM3X8E ????

[cubitus_54]

J'ai trouvé un bout de code pour la Due (ce n'est pas simple en 32 bits...)

const unsigned int imThePin = 13; //e.g. digital Pin 13

    Pio* imThePort = g_APinDescription[imThePin].pPort; 
    unsigned int imTheMask = g_APinDescription[imThePin].ulPin; 


    imThePort->PIO_SODR = imTheMask; 
    imThePort->PIO_CODR = imTheMask;

J’obtiens presque 17MHz
Mega Due.png

[Biname]

Salut,

Le plus efficace est PORTB=xxx
bitSet ou bitClear est un peu plus lent, dans mon test 2.7MHz
Je pense que cette commande ajoute une instruction de masquage pour gérer un bit sur les 8.

Je ne pense pas mais il est possible d'utiliser l'assembleur avec

  asm ("sbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (5) );
  asm ("cbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (5) );

... du vieux code, je ne m'y replonge pas ,
ou utiliser

#define CLR(x,y) (x&=(~(1<<y)))
#define SET(x,y) (x|=(1<<y))
#define _BV(bit) (1 << (bit)) 

SET(PORTB,5);
CLR(PORTB,5);

Qui, ici, donnent les mêmes temps que bitSet et bitClear !

4MHz avec ta boucle, difficile faire mieux pour un 16 MHz ! Mon code incrémente un entier long (32 bits), boucle et tourne encore à 1 MHZ ... pas mal non plus pour un 8 bits.

Biname

[cubitus_54]

J'ai sorti la boucle de l'équation,

J'ai répété une dizaine de fois la même paire d'instructions...

En blanc 4MHz (124 ns par instruction)
Ton instruction Set ou CLR (en assembleur ou en C le résultat est identique)

asm ("sbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (7) );
asm ("cbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (7) );
asm ("sbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (7) );
asm ("cbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (7) );
asm ("sbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (7) );
asm ("cbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (7) );


En jaune 8Mhz (62 ns par instruction)
Écriture du port entier

PORTB=0;
PORTB=0x80;
PORTB=0;
PORTB=0x80;
PORTB=0;
PORTB=0x80;

[Biname]

J'ai ça aussi que je ne comprenais plus mais pour ATMEL 8 bits

  asm ("sbi 0x5, 5"); //PORTB = 0x5 ou 5 :-), PIN13 = bit5 portB
  asm ("cbi 0x5, 5"); //PORTB = 0x5 ou 5 :-), PIN13 = bit5 portB

Les constantes PORTB et BIT5 doivent être définies par Arduino ????

Selon la doc ATMEL, l'instruction SBI nécessiterait :

"Words: 1 (2 bytes)
Cycles: 2
Cycles XMEGA: 1
Cycles Reduced Core tinyAVR:1"

Un ou deux cycles ???selon le processeur. Un ATMEGA 328P à 16 MHz, un cycle = 63ns

Et un Relativ Jump
"Words: 1 (2 bytes)
Cycles: 2"

La boucle SBI/CBI/JR = 1 + 1 + 2 = 4 cycles sur un 328P. A 16 MHz, ça qui donne tes 4 MHz.

Le compilateur Arduino n'est pas aussi pourri que ça !

Biname

[bobflux]

imThePort->PIO_SODR = imTheMask;
imThePort->PIO_CODR = imTheMask;[/CODE]

Pour un ARM cortex le mieux est d'utiliser ces registres-là effectivement, si le masque a plusieurs bit.

Si le masque a un seul bit, il est possible de modifier 1 bit en accédant à une certaine adresse (le bit dépend de l'adresse), cf la doc