¿Es posible encontrar el tiempo que toman los millis?

13

La función millisse estaría ejecutando en el lapso de más de 100 microsegundos o menos. ¿Hay alguna manera confiable de medir el tiempo que toma una sola llamada millis?

Un enfoque que viene a la mente es usar micros, sin embargo, un llamado a microsincluir también el tiempo que toma la llamada a la función de microssí mismo, por lo que, dependiendo de cuánto tiempo tome el micros, la medición millispuede estar desactivada.

Necesito encontrar esto porque una aplicación en la que estoy trabajando requiere mediciones precisas de tiempo para cada paso dado en el código, incluido millis.

time  millis 
— Asheeshr
fuente
¿Puedes aclarar lo que estás preguntando aquí? ¿Está tratando de obtener tiempos precisos de millis () o está tratando de calcular cuánto tiempo se tarda en llamar a la función millis ()?
— Cybergibbons
@Cybergibbons Cuánto tiempo miilislleva una llamada .
— asheeshr

Respuestas:

21

Si desea saber exactamente cuánto tiempo tomará algo, solo hay una solución: ¡mire el desmontaje!

Comenzando con el código mínimo: 

void setup(){};

volatile uint16_t x;
void loop()
{
  x = millis();

}

Este código compilado y luego alimentado avr-objdump -Sproduce un desmontaje documentado. Aquí están los extractos interesantes:

void loop() produce: 

000000a8 <loop>:
  a8:   0e 94 a7 00     call    0x14e   ; 0x14e <millis>
  ac:   60 93 00 01     sts 0x0100, r22
  b0:   70 93 01 01     sts 0x0101, r23
  b4:   80 93 02 01     sts 0x0102, r24
  b8:   90 93 03 01     sts 0x0103, r25
  bc:   08 95           ret

Que es una llamada a función ( call), cuatro copias (que copian cada uno de los bytes en el uint32_tvalor de retorno de millis()(tenga en cuenta que los documentos arduino llaman a esto a long, pero son incorrectos para no especificar explícitamente los tamaños de las variables)), y finalmente el función de retorno.

callrequiere 4 ciclos de reloj, y cada uno stsrequiere 2 ciclos de reloj, por lo que tenemos un mínimo de 12 ciclos de reloj solo para la sobrecarga de llamadas de función.

Ahora, veamos el desmontaje de la <millis>función, que se encuentra en 0x14e: 

unsigned long millis()
{
    unsigned long m;
    uint8_t oldSREG = SREG;
 14e:   8f b7           in  r24, 0x3f   ; 63

    // disable interrupts while we read timer0_millis or we might get an
    // inconsistent value (e.g. in the middle of a write to timer0_millis)
    cli();
 150:   f8 94           cli
    m = timer0_millis;
 152:   20 91 08 01     lds r18, 0x0108
 156:   30 91 09 01     lds r19, 0x0109
 15a:   40 91 0a 01     lds r20, 0x010A
 15e:   50 91 0b 01     lds r21, 0x010B
    SREG = oldSREG;
 162:   8f bf           out 0x3f, r24   ; 63

    return m;
}
 164:   b9 01           movw    r22, r18
 166:   ca 01           movw    r24, r20
 168:   08 95           ret

Como puede ver, la millis()función es bastante simple:

  1. in guarda la configuración del registro de interrupción (1 ciclo)
  2. cli apaga las interrupciones (1 ciclo)
  3. lds Copie uno de los 4 bytes del valor actual del contador mili en un registro temporal (2 ciclos de reloj)
  4. lds Byte 2 (2 ciclos de reloj)
  5. lds Byte 3 (2 ciclos de reloj)
  6. lds Byte 4 (2 ciclos de reloj)
  7. out restaurar la configuración de interrupción (1 ciclo de reloj)
  8. movw shuffle registra alrededor (1 ciclo de reloj)
  9. movw y nuevamente (1 ciclo de reloj)
  10. ret regreso de la subrutina (4 ciclos)

Entonces, si los sumamos todos, tenemos un total de 17 ciclos de reloj en la millis()función en sí, más una sobrecarga de llamadas de 12, para un total de 29 ciclos de reloj.

Suponiendo una velocidad de reloj de 16 Mhz (la mayoría de los arduinos), cada ciclo de reloj es 1 / 16e6segundos, o 0.0000000625 segundos, que es 62.5 nanosegundos. 62.5 ns * 29 = 1.812 microsegundos.

Por lo tanto, el tiempo de ejecución total para una sola millis()llamada en la mayoría de los Arduinos será de 1.812 microsegundos .

Referencia de ensamblaje AVR

Como nota al margen, ¡hay espacio para la optimización aquí! Si actualiza la unsigned long millis(){}definición de la función para que sea inline unsigned long millis(){}, eliminaría la sobrecarga de la llamada (a costa de un tamaño de código ligeramente mayor). Además, parece que el compilador está haciendo dos movimientos innecesarios (las dos movwllamadas, pero no lo he mirado tan de cerca).

Realmente, considerando que la sobrecarga de la llamada a la función son 5 instrucciones, y el contenido real de la millis()función es solo 6 instrucciones, creo que la millis()función realmente debería ser inlinepor defecto, pero la base de código Arduino está bastante mal optimizada.

Aquí está el desensamblaje completo para cualquier persona interesada: 

sketch_feb13a.cpp.elf:     file format elf32-avr


Disassembly of section .text:

00000000 <__vectors>:
    SREG = oldSREG;

    return m;
}

unsigned long micros() {
   0:   0c 94 34 00     jmp 0x68    ; 0x68 <__ctors_end>
   4:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
   8:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
   c:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  10:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  14:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  18:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  1c:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  20:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  24:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  28:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  2c:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  30:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  34:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  38:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  3c:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  40:   0c 94 5f 00     jmp 0xbe    ; 0xbe <__vector_16>
  44:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  48:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  4c:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  50:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  54:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  58:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  5c:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  60:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>
  64:   0c 94 51 00     jmp 0xa2    ; 0xa2 <__bad_interrupt>

00000068 <__ctors_end>:
  68:   11 24           eor r1, r1
  6a:   1f be           out 0x3f, r1    ; 63
  6c:   cf ef           ldi r28, 0xFF   ; 255
  6e:   d8 e0           ldi r29, 0x08   ; 8
  70:   de bf           out 0x3e, r29   ; 62
  72:   cd bf           out 0x3d, r28   ; 61

00000074 <__do_copy_data>:
  74:   11 e0           ldi r17, 0x01   ; 1
  76:   a0 e0           ldi r26, 0x00   ; 0
  78:   b1 e0           ldi r27, 0x01   ; 1
  7a:   e2 e0           ldi r30, 0x02   ; 2
  7c:   f2 e0           ldi r31, 0x02   ; 2
  7e:   02 c0           rjmp    .+4         ; 0x84 <.do_copy_data_start>

00000080 <.do_copy_data_loop>:
  80:   05 90           lpm r0, Z+
  82:   0d 92           st  X+, r0

00000084 <.do_copy_data_start>:
  84:   a0 30           cpi r26, 0x00   ; 0
  86:   b1 07           cpc r27, r17
  88:   d9 f7           brne    .-10        ; 0x80 <.do_copy_data_loop>

0000008a <__do_clear_bss>:
  8a:   11 e0           ldi r17, 0x01   ; 1
  8c:   a0 e0           ldi r26, 0x00   ; 0
  8e:   b1 e0           ldi r27, 0x01   ; 1
  90:   01 c0           rjmp    .+2         ; 0x94 <.do_clear_bss_start>

00000092 <.do_clear_bss_loop>:
  92:   1d 92           st  X+, r1

00000094 <.do_clear_bss_start>:
  94:   ad 30           cpi r26, 0x0D   ; 13
  96:   b1 07           cpc r27, r17
  98:   e1 f7           brne    .-8         ; 0x92 <.do_clear_bss_loop>
  9a:   0e 94 f0 00     call    0x1e0   ; 0x1e0 <main>
  9e:   0c 94 ff 00     jmp 0x1fe   ; 0x1fe <_exit>

000000a2 <__bad_interrupt>:
  a2:   0c 94 00 00     jmp 0   ; 0x0 <__vectors>

000000a6 <setup>:
  a6:   08 95           ret

000000a8 <loop>:
  a8:   0e 94 a7 00     call    0x14e   ; 0x14e <millis>
  ac:   60 93 00 01     sts 0x0100, r22
  b0:   70 93 01 01     sts 0x0101, r23
  b4:   80 93 02 01     sts 0x0102, r24
  b8:   90 93 03 01     sts 0x0103, r25
  bc:   08 95           ret

000000be <__vector_16>:
#if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
ISR(TIM0_OVF_vect)
#else
ISR(TIMER0_OVF_vect)
#endif
{
  be:   1f 92           push    r1
  c0:   0f 92           push    r0
  c2:   0f b6           in  r0, 0x3f    ; 63
  c4:   0f 92           push    r0
  c6:   11 24           eor r1, r1
  c8:   2f 93           push    r18
  ca:   3f 93           push    r19
  cc:   8f 93           push    r24
  ce:   9f 93           push    r25
  d0:   af 93           push    r26
  d2:   bf 93           push    r27
    // copy these to local variables so they can be stored in registers
    // (volatile variables must be read from memory on every access)
    unsigned long m = timer0_millis;
  d4:   80 91 08 01     lds r24, 0x0108
  d8:   90 91 09 01     lds r25, 0x0109
  dc:   a0 91 0a 01     lds r26, 0x010A
  e0:   b0 91 0b 01     lds r27, 0x010B
    unsigned char f = timer0_fract;
  e4:   30 91 0c 01     lds r19, 0x010C

    m += MILLIS_INC;
  e8:   01 96           adiw    r24, 0x01   ; 1
  ea:   a1 1d           adc r26, r1
  ec:   b1 1d           adc r27, r1
    f += FRACT_INC;
  ee:   23 2f           mov r18, r19
  f0:   2d 5f           subi    r18, 0xFD   ; 253
    if (f >= FRACT_MAX) {
  f2:   2d 37           cpi r18, 0x7D   ; 125
  f4:   20 f0           brcs    .+8         ; 0xfe <__vector_16+0x40>
        f -= FRACT_MAX;
  f6:   2d 57           subi    r18, 0x7D   ; 125
        m += 1;
  f8:   01 96           adiw    r24, 0x01   ; 1
  fa:   a1 1d           adc r26, r1
  fc:   b1 1d           adc r27, r1
    }

    timer0_fract = f;
  fe:   20 93 0c 01     sts 0x010C, r18
    timer0_millis = m;
 102:   80 93 08 01     sts 0x0108, r24
 106:   90 93 09 01     sts 0x0109, r25
 10a:   a0 93 0a 01     sts 0x010A, r26
 10e:   b0 93 0b 01     sts 0x010B, r27
    timer0_overflow_count++;
 112:   80 91 04 01     lds r24, 0x0104
 116:   90 91 05 01     lds r25, 0x0105
 11a:   a0 91 06 01     lds r26, 0x0106
 11e:   b0 91 07 01     lds r27, 0x0107
 122:   01 96           adiw    r24, 0x01   ; 1
 124:   a1 1d           adc r26, r1
 126:   b1 1d           adc r27, r1
 128:   80 93 04 01     sts 0x0104, r24
 12c:   90 93 05 01     sts 0x0105, r25
 130:   a0 93 06 01     sts 0x0106, r26
 134:   b0 93 07 01     sts 0x0107, r27
}
 138:   bf 91           pop r27
 13a:   af 91           pop r26
 13c:   9f 91           pop r25
 13e:   8f 91           pop r24
 140:   3f 91           pop r19
 142:   2f 91           pop r18
 144:   0f 90           pop r0
 146:   0f be           out 0x3f, r0    ; 63
 148:   0f 90           pop r0
 14a:   1f 90           pop r1
 14c:   18 95           reti

0000014e <millis>:

unsigned long millis()
{
    unsigned long m;
    uint8_t oldSREG = SREG;
 14e:   8f b7           in  r24, 0x3f   ; 63

    // disable interrupts while we read timer0_millis or we might get an
    // inconsistent value (e.g. in the middle of a write to timer0_millis)
    cli();
 150:   f8 94           cli
    m = timer0_millis;
 152:   20 91 08 01     lds r18, 0x0108
 156:   30 91 09 01     lds r19, 0x0109
 15a:   40 91 0a 01     lds r20, 0x010A
 15e:   50 91 0b 01     lds r21, 0x010B
    SREG = oldSREG;
 162:   8f bf           out 0x3f, r24   ; 63

    return m;
}
 164:   b9 01           movw    r22, r18
 166:   ca 01           movw    r24, r20
 168:   08 95           ret

0000016a <init>:

void init()
{
    // this needs to be called before setup() or some functions won't
    // work there
    sei();
 16a:   78 94           sei

    // on the ATmega168, timer 0 is also used for fast hardware pwm
    // (using phase-correct PWM would mean that timer 0 overflowed half as often
    // resulting in different millis() behavior on the ATmega8 and ATmega168)
#if defined(TCCR0A) && defined(WGM01)
    sbi(TCCR0A, WGM01);
 16c:   84 b5           in  r24, 0x24   ; 36
 16e:   82 60           ori r24, 0x02   ; 2
 170:   84 bd           out 0x24, r24   ; 36
    sbi(TCCR0A, WGM00);
 172:   84 b5           in  r24, 0x24   ; 36
 174:   81 60           ori r24, 0x01   ; 1
 176:   84 bd           out 0x24, r24   ; 36
    // this combination is for the standard atmega8
    sbi(TCCR0, CS01);
    sbi(TCCR0, CS00);
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
    // this combination is for the standard 168/328/1280/2560
    sbi(TCCR0B, CS01);
 178:   85 b5           in  r24, 0x25   ; 37
 17a:   82 60           ori r24, 0x02   ; 2
 17c:   85 bd           out 0x25, r24   ; 37
    sbi(TCCR0B, CS00);
 17e:   85 b5           in  r24, 0x25   ; 37
 180:   81 60           ori r24, 0x01   ; 1
 182:   85 bd           out 0x25, r24   ; 37

    // enable timer 0 overflow interrupt
#if defined(TIMSK) && defined(TOIE0)
    sbi(TIMSK, TOIE0);
#elif defined(TIMSK0) && defined(TOIE0)
    sbi(TIMSK0, TOIE0);
 184:   ee e6           ldi r30, 0x6E   ; 110
 186:   f0 e0           ldi r31, 0x00   ; 0
 188:   80 81           ld  r24, Z
 18a:   81 60           ori r24, 0x01   ; 1
 18c:   80 83           st  Z, r24
    // this is better for motors as it ensures an even waveform
    // note, however, that fast pwm mode can achieve a frequency of up
    // 8 MHz (with a 16 MHz clock) at 50% duty cycle

#if defined(TCCR1B) && defined(CS11) && defined(CS10)
    TCCR1B = 0;
 18e:   e1 e8           ldi r30, 0x81   ; 129
 190:   f0 e0           ldi r31, 0x00   ; 0
 192:   10 82           st  Z, r1

    // set timer 1 prescale factor to 64
    sbi(TCCR1B, CS11);
 194:   80 81           ld  r24, Z
 196:   82 60           ori r24, 0x02   ; 2
 198:   80 83           st  Z, r24
#if F_CPU >= 8000000L
    sbi(TCCR1B, CS10);
 19a:   80 81           ld  r24, Z
 19c:   81 60           ori r24, 0x01   ; 1
 19e:   80 83           st  Z, r24
    sbi(TCCR1, CS10);
#endif
#endif
    // put timer 1 in 8-bit phase correct pwm mode
#if defined(TCCR1A) && defined(WGM10)
    sbi(TCCR1A, WGM10);
 1a0:   e0 e8           ldi r30, 0x80   ; 128
 1a2:   f0 e0           ldi r31, 0x00   ; 0
 1a4:   80 81           ld  r24, Z
 1a6:   81 60           ori r24, 0x01   ; 1
 1a8:   80 83           st  Z, r24

    // set timer 2 prescale factor to 64
#if defined(TCCR2) && defined(CS22)
    sbi(TCCR2, CS22);
#elif defined(TCCR2B) && defined(CS22)
    sbi(TCCR2B, CS22);
 1aa:   e1 eb           ldi r30, 0xB1   ; 177
 1ac:   f0 e0           ldi r31, 0x00   ; 0
 1ae:   80 81           ld  r24, Z
 1b0:   84 60           ori r24, 0x04   ; 4
 1b2:   80 83           st  Z, r24

    // configure timer 2 for phase correct pwm (8-bit)
#if defined(TCCR2) && defined(WGM20)
    sbi(TCCR2, WGM20);
#elif defined(TCCR2A) && defined(WGM20)
    sbi(TCCR2A, WGM20);
 1b4:   e0 eb           ldi r30, 0xB0   ; 176
 1b6:   f0 e0           ldi r31, 0x00   ; 0
 1b8:   80 81           ld  r24, Z
 1ba:   81 60           ori r24, 0x01   ; 1
 1bc:   80 83           st  Z, r24
#if defined(ADCSRA)
    // set a2d prescale factor to 128
    // 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
    // XXX: this will not work properly for other clock speeds, and
    // this code should use F_CPU to determine the prescale factor.
    sbi(ADCSRA, ADPS2);
 1be:   ea e7           ldi r30, 0x7A   ; 122
 1c0:   f0 e0           ldi r31, 0x00   ; 0
 1c2:   80 81           ld  r24, Z
 1c4:   84 60           ori r24, 0x04   ; 4
 1c6:   80 83           st  Z, r24
    sbi(ADCSRA, ADPS1);
 1c8:   80 81           ld  r24, Z
 1ca:   82 60           ori r24, 0x02   ; 2
 1cc:   80 83           st  Z, r24
    sbi(ADCSRA, ADPS0);
 1ce:   80 81           ld  r24, Z
 1d0:   81 60           ori r24, 0x01   ; 1
 1d2:   80 83           st  Z, r24

    // enable a2d conversions
    sbi(ADCSRA, ADEN);
 1d4:   80 81           ld  r24, Z
 1d6:   80 68           ori r24, 0x80   ; 128
 1d8:   80 83           st  Z, r24
    // here so they can be used as normal digital i/o; they will be
    // reconnected in Serial.begin()
#if defined(UCSRB)
    UCSRB = 0;
#elif defined(UCSR0B)
    UCSR0B = 0;
 1da:   10 92 c1 00     sts 0x00C1, r1
#endif
}
 1de:   08 95           ret

000001e0 <main>:
#include <Arduino.h>

int main(void)
 1e0:   cf 93           push    r28
 1e2:   df 93           push    r29
{
    init();
 1e4:   0e 94 b5 00     call    0x16a   ; 0x16a <init>

#if defined(USBCON)
    USBDevice.attach();
#endif

    setup();
 1e8:   0e 94 53 00     call    0xa6    ; 0xa6 <setup>

    for (;;) {
        loop();
        if (serialEventRun) serialEventRun();
 1ec:   c0 e0           ldi r28, 0x00   ; 0
 1ee:   d0 e0           ldi r29, 0x00   ; 0
#endif

    setup();

    for (;;) {
        loop();
 1f0:   0e 94 54 00     call    0xa8    ; 0xa8 <loop>
        if (serialEventRun) serialEventRun();
 1f4:   20 97           sbiw    r28, 0x00   ; 0
 1f6:   e1 f3           breq    .-8         ; 0x1f0 <main+0x10>
 1f8:   0e 94 00 00     call    0   ; 0x0 <__vectors>
 1fc:   f9 cf           rjmp    .-14        ; 0x1f0 <main+0x10>

000001fe <_exit>:
 1fe:   f8 94           cli

00000200 <__stop_program>:
 200:   ff cf           rjmp    .-2         ; 0x200 <__stop_program>
— Connor Wolf
fuente
Wow, gran respuesta! +1
— El chico con el sombrero
1) Los cuatro stsno deben contarse como gastos generales de llamadas: este es el costo de almacenar el resultado en una variable volátil, que normalmente no haría. 2) En mi sistema (Arduino 1.0.5, gcc 4.8.2), no tengo el movws. Entonces el costo de la llamada millis()es: 4 ciclos de sobrecarga de la llamada + 15 ciclos en millis()sí mismo = 19 ciclos en total (≈ 1.188 µs @ 16 MHz).
— Edgar Bonet
1
@EdgarBonet - Eso no tiene sentido, xes un uint16_t. Debe ser de 2 copias como máximo si esa es la causa. De todos modos, la pregunta es cuánto tiempo millis()toma cuando se usa , no cuando se llama mientras se ignora el resultado. Como cualquier uso práctico implicará hacer algo con el resultado, forcé el resultado a almacenarse mediante volatile. Normalmente, se lograría el mismo efecto con el uso posterior de la variable que se establece en el valor de retorno de la llamada, pero no quería que esa llamada adicional ocupara espacio en la respuesta.
— Connor Wolf
Esto uint16_ten la fuente no coincide con el ensamblado (4 bytes almacenados en la RAM). Probablemente haya publicado la fuente y el desmontaje de dos versiones diferentes.
— Edgar Bonet
@ConnorWolf Increíble respuesta y explicación. ¡Gracias!
— Lefteris
8

Escriba un boceto que mil veces 1000, no haciendo un bucle, sino copiando y pegando. Mida eso y compárelo con el tiempo real esperado. Tenga en cuenta que los resultados pueden variar con diferentes versiones del IDE (y su compilador en particular).

Otra opción es alternar un pin IO antes y después de la llamada millis, luego medir el tiempo para un valor muy pequeño y un valor algo mayor. Compare los tiempos medidos y calcule los gastos generales.

La forma más precisa es echar un vistazo a la lista de desmontaje, el código generado. Pero eso no es para los débiles de corazón. Tendrá que estudiar cuidadosamente la hoja de datos cuánto dura cada ciclo de instrucción.

— jippie
fuente
¿Cómo medirías el tiempo que tardan 1000 millis()llamadas?
— apnorton
¿Sabes que millis () es suministrado por una interrupción en timer0 que incrementa una variable interna cada tick?
— TheDoctor
@TheDoctor con el que me mezclé delay, tienes razón. Pero la idea sigue siendo la misma, puede programar una gran cantidad de llamadas y promediarlas. Sin embargo, apagar las interrupciones a nivel mundial puede no ser una muy buena idea; o)
— jippie
Asegúrese de que su conjunto de datos sea lo suficientemente grande, ya que la impresión de caracteres en la serie tarda unos milisegundos. No recuerdo la hora exacta, pero creo que es algo así como ~ 0.6ms por personaje enviado a Serial.
— Steven10172
@ Steven10172 puede cronometrar una cadena vacía contra una cadena de 1000 veces (o más), luego conoce el delta y la medición es más precisa.
— jippie
3

En segundo lugar, llamo a Millis repetidamente y luego comparo lo real con lo esperado.

Habrá algunos gastos generales mínimos, pero disminuirá en importancia cuanto más veces llame a millis ().

Si miras 

C:\Program Files (x86)\Arduino\Arduino ERW 1.0.5\hardware\arduino\cores\arduino\wiring.c

Puede ver que millis () es muy pequeño con solo 4 instrucciones (cli is simply # define cli() \__asm__ \__volatile__ ("cli" ::))y un retorno.

Lo llamaría aproximadamente 10 millones de veces usando un bucle FOR que tiene un volátil como condicional. La palabra clave volátil evitará que el compilador intente cualquier optimización en el propio ciclo.

No garantizo que lo siguiente sea sintácticamente perfecto ...

int temp1,temp2;
temp1=millis();
for (volatile unsigned int j=0;j<1000000;++j){
temp2=millis();}
Serial.print("Execution time = ");
Serial.print((temp2-temp1,DEC);
Serial.print("ms");

Supongo que eso toma ~ 900ms o aproximadamente 56us por llamada a millis. (No tengo un cajero automático a mano aruduino.

— 80HD
fuente
1
Debe cambiar int temp1,temp2;a volatile int temp1,temp2;para evitar que el compilador los optimice potencialmente.
— Connor Wolf
Buena llamada a lo volátil. Definitivamente quise poner eso y luego no lo hice. También debería haber mencionado que la forma de hacer un punto de referencia más adecuado es ejecutar un ciclo vacío, registrar ese tiempo de ejecución y luego ejecutar el ciclo nuevamente mientras se hace el trabajo. Resta la diferencia, divide por el número de iteraciones, y ahí está tu tiempo de ejecución altamente preciso.
— 80HD
Ese tipo de punto de referencia solo funciona en un sistema que nunca se adelanta a la ejecución de su código. El entorno arduino por defecto tiene interrupciones periódicas que se ejecutarán periódicamente. Una mejor solución sería alternar un pin en cada ejecución, y usar un temporizador de alta resolución de algún tipo para medir la velocidad de alternancia al ejecutar y no ejecutar el código en cuestión, tomar el tiempo de ejecución mínimo en varias muestras para cada , reste la línea de base, y tratar de que como su tiempo de ejecución. Asumiendo que su tiempo de ejecución es más corto que el tiempo mínimo entre interrupciones.
— Connor Wolf
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.