Retardo máximo alcanzable con el microcontrolador

El retraso puede ser tan largo como quieras. Si un temporizador no le proporciona la demora que necesita, simplemente incremente un registro o varios registros, cada vez que se desborda. Aquí hay un programa simple que usa Timer0 que ilustra la técnica:

        #include    "P16F88.INC"

#define LED 0

    errorlevel -302     ;suppress "not in bank 0" message

#define RB0 0
#define INIT_COUNT 0    ;gives (255 - 199) * 17.36 = 972 us between interrupts


    cblock  0x20
    tick_counter
    temp    
    endc

    ;reset vector
    org     0
    nop
    goto    main

    ;interrupt vector
    org     4
    banksel INTCON
    bcf     INTCON,TMR0IF   ;clear Timer0 interrupt flag
    movlw   0x00            ;re-initialise count
    movwf   TMR0
    decf    tick_counter,f
    retfie

main:
    banksel OPTION_REG
    movlw   b'00000111'     ;prescaler 1/128
    movwf   OPTION_REG      ;giving 7.3728 Mz/128 = 57600 Hz (period = 17.36 us)
    banksel TMR0
    movlw   0x00            ;initialise timer count value
    movwf   TMR0
    bsf     INTCON,GIE      ;enable global interrupt
    bsf     INTCON,TMR0IE   ;enable Timer0 interrupt
    banksel TRISB
    bcf     TRISB,LED   ;RB0 is LED output
    banksel 0

mainloop:
    goto    mainloop

    bsf     PORTB,LED
    call    dly
    bcf     PORTB,LED
    call    dly 
    goto    mainloop

dly:
    movlw   20
    movwf   tick_counter
dly1:
    movf    tick_counter,f
    skpz
    goto    dly1
    return

    end

No se especifica porque cualquier microcontrolador normal puede, por medio del software, crear un retraso esencialmente ilimitado, es decir, por un tiempo mucho más prolongado que el que existe un motivo para esperar que el circuito siga funcionando o que a alguien le importe el resultado. .

Esencialmente, encuentra algunos medios para generar un breve retraso, como hacer que el procesador ejecute unas pocas instrucciones o usar un temporizador de hardware, y luego usa un contador para hacerlo, sin embargo, muchas veces es necesario para completar el período del tiempo de retardo que desees.

Cada byte de registro disponible o almacenamiento de RAM para el valor de conteo aumentaría su retraso disponible en un factor de 256. Con tan poco como 64 bytes de RAM (la mayoría de los micros tienen varias veces eso), podría crear retrasos donde la edad de la tierra palidece en comparación.

El retraso máximo alcanzable se basa en una combinación del reloj del sistema y la RAM disponible.

Básicamente, puede crear variables grandes (por ejemplo, ints de 32 bits, ints de 64 bits) en una MCU de 8 bits al distribuir el int en varios segmentos de ram de 8 bits. Se requieren varias operaciones para realizar la suma o la multiplicación de dichos números (ya que debe iterar sobre los bytes individuales), pero la velocidad no es exactamente crítica aquí, por lo que está bien.

Entonces, suponiendo un reloj de 20 Mhz, ¿qué tamaño de variable necesita?

^{_{Estoy haciendo muchas asuspciones aquí. Primero, estoy asumiendo una paridad de instrucción de reloj. Muchas MCU requieren varios ciclos de reloj para ejecutar una sola instrucción, lo que reduciría la frecuencia de reloj efectiva. En segundo lugar, supongo que su contador base está aumentando a la misma velocidad que el reloj del sistema. Esto generalmente solo es cierto para los contadores de hardware. Tercero, los números que estoy usando para cosas (la duración de un año, etc.) son versiones redondeadas de los números reales. Por último, todo este ejercicio es bastante tonto.}}

\ $ 20 Mhz = 20 \ veces 10 ^ {6} = 20,000,000 \ $
Bueno, \ $ \ frac {log (20,000,000)} {log (2)} = 24.2534966642115 \ $, por lo que necesita ~ 24.25 bits para demorar un segundo.
2 horas = \ $ 2 * 60 * 60 = 7200 ~ \ $ segundos, por lo que necesita \ $ \ frac {log (20,000,000 * 7,200)} {log (2)} = 37.0672778554286 \ $, por lo que necesita 37.06 (o básicamente 38 bits) bits de RAM para representar un retraso de 2 horas.

Entonces ... Suponiendo que su microcontrolador tenga al menos 5 bytes de RAM, todos los dispositivos listados funcionarán.

Por diversión, veamos cuánto duraría un 64% de long long :

\ $ 2 ^ {64} = 18,446,744,073,709,551,616 \ $
\ $ 18,446,744,073,709,551,616 / 20,000,000 = ~ \ approx922337203685.478 ~~ \ $ Segundos
\ $ \ frac {922337203685} {60 * 60 * 24 * 365} = ~ \ approx29247.120 ~~ \ $ años

Entonces, con solo 8 bytes de memoria, parece que eres bueno durante al menos los próximos 30 mil años.

Otros ya explicaron que realmente no hay un límite para lo que puedes hacer, y Nombre falso hizo malabarismos con grandes números para mostrar que 5 bytes serían suficientes en cualquier controlador.

¡Qué desperdicio! :-) Al elegir cuidadosamente un microcontrolador, puede usar su temporizador para demoras de hasta 9 h con solo 1 byte de RAM.

Lo primero que debes hacer es controlar tu microcontrolador lo más lentamente posible. El MSP430 puede ejecutar un cristal de 32.768 kHz, que es el más lento que puede ir si quiere algo de exactitud (Los relojes más lentos no usarán un cristal.)

A continuación, use preescaladores. El MSP430 puede preescala la frecuencia de cristal \ $ \ div \ $ 8 para crear un reloj auxiliar \ $ ACLK \ $. \ $ ACLK \ $ entonces será 4096Hz. Puede usar \ $ ACLK \ $ para sincronizar un temporizador de 16 bits, pero también aquí tiene una opción de preescalador \ $ \ div \ $ 8. El uso de eso significa que el temporizador de 16 bits se registra en 512Hz. \ $ \ dfrac {2 ^ {16}} {512 Hz} \ $ = 128s. Por lo tanto, al usar un cristal de baja frecuencia y dos precalificadores, el temporizador se desbordará cada 128 segundos. El uso de un contador de 8 bits para contar el número de desbordamientos del temporizador le permite contar 256 \ $ \ veces \ $ 128s = 32768s, o más de 9 horas, con un solo byte.

Tenemos cuatro bancos de memoria, cada uno con ocho registros r0 a r7. Usando cualquier número de registros, podemos generar un retraso de hasta 10 horas