Retraso máximo alcanzable con microcontrolador

El retraso puede ser tan largo como quieras. Si un temporizador no le da el retraso que necesita, simplemente incremente un registro, o varios registros, cada vez que se desborde. 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, de mucho más tiempo del que hay razón para esperar que el circuito aún esté operativo o que alguien se preocupe por el resultado.

Esencialmente, encuentra algún medio para generar un retraso breve, como hacer que el procesador ejecute algunas instrucciones, o usar un temporizador de hardware, y luego usa un contador para hacerlo cuantas veces sea necesario para compensar el período de retraso. tu deseo

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 solo 64 bytes de RAM (la mayoría de los micros tienen varias veces eso), podría crear retrasos donde el la edad de la tierra palidece en comparación.

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

¡Un desperdicio! :-) Al elegir cuidadosamente un microcontrolador, puede usar su temporizador con hasta 9 horas de retraso con solo 1 byte de RAM.

Lo primero que debe hacer es sincronizar su microcontrolador lo más lento posible. El MSP430 puede funcionar con un cristal de 32,768 kHz, que es lo más lento que puede utilizar si desea cierta precisión. (Los relojes más lentos no usarán un cristal).

A continuación, utilice preescaladores. El MSP430 puede preescalar la frecuencia del cristal$\div$8 para crear un reloj auxiliar$ACLK$.$ACLK$entonces será 4096Hz. Puedes usar$ACLK$para cronometrar un temporizador de 16 bits, pero también aquí tienes un$\div$Opción de 8 preescaladores. Usar eso significa que el temporizador de 16 bits se sincroniza a 512 Hz.$\dfrac{2^{16}}{512 Hz}$= 128 s. Entonces, usando un cristal de baja frecuencia y dos preescaladores, el temporizador se desbordará cada 128 s. El uso de un contador de 8 bits para contar el número de desbordamientos del temporizador le permite contar 256$\times$128s = 32768s, o más de 9 horas, con un solo byte.

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, entradas de 32 bits, entradas de 64 bits) en una MCU de 8 bits al distribuir la int en varios segmentos de RAM de 8 bits. Se necesitan 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 suposiciones aquí. Primero, asumo 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 velocidad de reloj efectiva. En segundo lugar, asumo que su contador base se incrementa al mismo ritmo que el reloj del sistema. Esto generalmente solo es cierto para los contadores de hardware. Tercero, los números que estoy usando para las 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\times 10^{6} = 20,000,000$
Bien,$\frac{log(20,000,000)}{log(2)} = 24.2534966642115$, por lo que necesita ~24,25 bits para retrasar 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 enumerados funcionarán.

Por diversión, veamos cuánto long longduraría una de 64 bits:

$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 estarás bien durante al menos los próximos 30 mil años.

Tenemos cuatro bancos de memoria cada uno con ocho registros r0 a r7. Utilizando cualquier número de registros podemos generar retrasos incluso de 10 horas