Software PWM de 4 canales usando Atmega16 para controlar 4 ESC para motores de CC sin escobillas

La causa del problema: el doble almacenamiento en búfer OCR1A

Su programa falla porque OCR1A tiene doble búfer en todos los modos de temporizador PWM y está utilizando dicho modo (Fast PWM, TOP = ICR1). Cuando escribe un nuevo valor en OCR1A, en realidad no cambia el valor utilizado por el hardware del temporizador. En cambio, el valor almacenado en OCR1A se copia en el "registro de sombra" separado que realmente usa el temporizador solo una vez que el valor del contador llega a TOP y se reinicia desde cero nuevamente. Esto es muy útil para generar PWM de hardware sin fallas, pero evita lo que está tratando de hacer (múltiples actualizaciones de OCR1A por ciclo de temporizador).

Dado que esta actualización de OCR1A ocurre solo una vez por ciclo de temporizador (a 50 Hz) y se supone que su código de interrupción genera 4 1000 μs - 2000 μs retrasos + un retraso largo, termina con un período PWM de 100 ms (5 ciclos de temporizador) y un tiempo alto de ~20 ms.

La solución es configurar el temporizador en un modo no PWM. El modo que mejor se adapta a su programa es el temporizador claro en la coincidencia de comparación (CTC, TOP = ICR1) que funciona casi de manera idéntica pero no duplica el búfer de OCR1A y ​​OCR1B. Los bits WGM que se encuentran en TCCR1A y ​​TCCR1B deben configurarse en 1100 para lograr esto (consulte la hoja de datos para obtener más detalles).

Otros problemas menores:

• Si accede a una variable en una rutina de servicio de interrupción, debe declarar la variable volatile. Omitir la palabra clave (entre otras cosas) permite que el compilador realice optimizaciones que asumen que solo el flujo del programa principal puede modificar el estado.

• PIND4, PIND5y tal como los utiliza su código no se encuentran en las definiciones de registro proporcionadas por AVR-GCC PIND6. PIND7Las macros más genéricas PINxse PORTxdeclaran DDRxen "portpins.h".

• La lógica de secuenciación podría escribirse de manera más clara. Su código actual tiene 4 estados explícitos en la secuencia (uno para cada pin de salida), de los cuales el último se usa para dos coincidencias de comparación: la primera para establecer la salida del canal 4 en baja y la segunda para esperar hasta que la secuencia se reinicie. Esto se hace extrañamente usando un valor OCR1A específico (1000) como bandera. Esto me tuvo rascándome la cabeza por un tiempo.

• Esto podría estar basado en opiniones, pero usaría uint8_t, int16_ty amigos en lugar de, por ejemplo unsigned char, o shorten software integrado. De esta manera, usted y los demás sabrán exactamente qué tan grandes son sus variables, y también son menos detalladas.

• Su ejemplo de código debe incluir <avr/io.h>y <avr/interrupt.h>, y debe proporcionar una declaración de función para void initESCs(). initUSART()es superfluo

Si entiendo su código correctamente, tiene Timer1 en modo Fast PWM usando OCR1A para medir el tiempo de trabajo de PWM e ICR1 para el período. Cuando OCR1A coincide con el valor actual del temporizador, activa una interrupción. Luego lo vuelve a cargar con un tiempo más largo, la idea es que coincida con el temporizador 1 ~ 2 ms más tarde para el próximo pulso de servo.

El problema con esta técnica es que en los modos PWM, el registro de comparación de salida tiene doble búfer y se sincroniza con el período PWM, por lo que escribirlo durante el ciclo PWM actual solo tendrá efecto en el próximo ciclo . Esto se describe en la hoja de datos en la página 98:-

El registro OCR1x tiene doble búfer cuando se usa cualquiera de los doce modos de modulación de ancho de pulso (PWM)... El doble búfer sincroniza la actualización del registro de comparación OCR1x con la parte SUPERIOR o INFERIOR de la secuencia de conteo. La sincronización evita la aparición de pulsos PWM no simétricos y de longitud impar

Entonces, en lugar de obtener una interrupción 1 ~ 2 ms después de escribir en OCR1A, la obtiene 20 ms + 1 ~ 2 ms después.

No estoy seguro de si es posible hacerlo a su manera usando un modo de temporizador que no sea PWM, pero podría ser más fácil usar un temporizador básico para cronometrar cada pulso por separado, luego sume todos los tiempos y reste de 20 ms para obtener el tiempo de pausa final.

Muchos ESC modernos pueden manejar frecuencias de 250 Hz o más, por lo que incluso puede salirse con la suya simplemente empujando los pulsos lo más rápido posible uno tras otro.

• Lo primero que debe hacer es obtener CUALQUIER tipo de alcance. Puedes comprar un DSO138. Compré y ensamblé varios de estos para regalarlos a mis amigos. Son baratos y pueden funcionar para sus necesidades. (Muestra en$1\:\textrm{MHz}$y solo admite sobre$200\:\textrm{kHz}$, pero eso puede estar bien para lo que tiene por delante). O puede obtener algo un poco más elegante que se conecte a una PC, como un Hantek 6022BE. O simplemente puede comprar un osciloscopio usado barato. Hay varios sitios para buscar buenos precios, muchos de los cuales estoy seguro que conoces. Pero el punto aquí es que si estás trabajando en un código para hacer algo importante para ti como este, realmente NECESITAS tener algo que te permita observar y medir lo que estás produciendo. Y tus necesidades son pedestres, así que no te cuesta un ojo de la cara. Probablemente menos que el costo de un controlador ESC. Vale la pena hacer.
• El ATmega16 tiene cuatro PWM. Un PWM en cada uno de los dos temporizadores de 8 bits y solo dos PWM más en el Timer1 de 16 bits. Entonces entiendo por qué está tratando de hacer esto en el software, usando Timer1. No hay otra manera de ir.

Lo que NO veo en su código es una cola de ningún tipo. Y necesitas uno, creo.

Así es como abordaría esto como una solución de diseño de software:

1. Decidir sobre una resolución específica para mis cuatro salidas PWM. No soy un experto en controladores ESC y no sé qué resolución usan al interpretar el ancho de pulso que reciben. Pero creo que puedo inferir de su uso de 1000 y 2000 para sugerir que desea precisión hasta el microsegundo. Así que, en resumen, puede establecer$1.001\:\textrm{ms}$y establecer$1.583\:\textrm{ms}$, pero no puede establecer$1.6057\:\textrm{ms}$.
2. Una vez que conozca la resolución requerida, puede configurar Timer1 para proporcionar esa resolución. Esto solo configura la velocidad del contador del temporizador. (No causa ninguna interrupción, por sí mismo. Eso sucede cuando configura la captura/comparación). En este caso, asumiré que ha configurado el Temporizador1 para contar a una velocidad de$1\:\textrm{MHz}$. (No, no voy a investigar la hoja de datos del ATmega16 y tratar de averiguar lo que realmente hizo en su código anterior. En su lugar, le diré lo que debe hacer).
3. Ahora que la resolución está determinada y el Timer1 está configurado correctamente para proporcionar una$1\:\textrm{MHz}$tasa de contador, configura lo que se llama una 'cola delta'. Puede leer sobre ellos en el libro de Douglas Comer (el inventor) sobre XINU, fechado a mediados de la década de 1980, si está interesado en una fuente de la idea. Necesitará cuatro entradas en la cola. Uno para cada uno de sus pines de salida PWM, individualmente.
4. Llamemos al$20\:\textrm{ms}$hilo de intervalo,$P_0$. Los otros cuatro serán$P_1\dots P_4$.
5. Tiene dos registros de captura/comparación disponibles. Probablemente sería más conveniente usar ambos. Uno de ellos es asignado a$P_0$por su habitual$20\:\textrm{ms}$evento. Asignemos OCR1A a$P_0$, así que establezca ese valor en 20000 y configúrelo para la recarga automática, si es posible. (Si no, hágalo en el software.) Esto configurará el básico$20\:\textrm{ms}$momento.
6. $P_0$hará lo siguiente: (a) Poner todas las salidas PWM en ALTO. (b) Inserte cada uno de$P_1\dots P_4$en la cola, que por ahora siempre está vacía, en función de sus valores de período. (c) Borre el contador del temporizador. (d) Cargue OCR1B con el valor del temporizador de la primera entrada en la cola delta y habilite el evento de interrupción OCR1B. (f) Salida. (Es posible que deba hacer algo para habilitar el próximo evento de interrupción. Pero eso depende de usted).
7. En el evento OCR1B, conduce el pin asociado BAJO. Elimina la entrada actual de la cola. Mientras haya entradas restantes en la cola y mientras los 'ticks' restantes (valor delta) sean exactamente cero, coloque el pin asociado en BAJO y elimine la entrada de la cola. Ahora, tiene garantizado uno de estos dos casos: (a) no quedan entradas en la cola; en este caso, simplemente regrese, ya que no hay nada más que hacer. (b) quedan entradas en la cola y la superior tiene un valor de temporizador distinto de cero: cargue este valor en OCR1B y asegúrese de que pueda volver a interrumpir, luego simplemente regrese.

eso. Todo el proceso. La cola delta está configurada para contener un valor de 'marca', que es el conteo en microsegundos para que ocurra el próximo evento. Al insertar una entrada en la cola, resta todos los 'ticks' (valor delta) de las entradas anteriores antes de insertarla. Así que permítanme demostrar con un ejemplo para dejar esto claro.

Supongamos que el valor de tiempo para$P_1\dots P_4$son: 1573, 2000, 1206 y 1573. Entonces la cola se vería así (sin incluir el pin asociado, que también se requiere aquí):

Eso está listado en orden de cola. Sin embargo, crearía una matriz de cinco elementos con índices del 0 al 4, con [0] asignado como la cola$head$puntero. Entonces, a la cola anterior le gustaría lo siguiente en orden de matriz:

Cuando$P_0$establece la inserción de los cuatro en la cola (que está vacía cuando$P_0$comienza, ya que todos$P_1 \dots p_4$tienen en este momento todo caducado), esa es la cola resultante cuando$P_0$sale y regresa de su evento de interrupción. Pero justo antes de salir, como se mencionó,$P_0$cargará el primer valor OCR1B en la cola (1206 aquí) y lo colocará en OCR1B.

Cuando se activa el evento OCR1B, la primera entrada en la cola le dice al código qué pin debe conducir a BAJO. Luego, la entrada se elimina de la cola. Para el primer evento OCR1B, esto elimina la entrada 1206, dejando el valor delta de 367, que no es cero. Entonces, el valor OCR1B de 1573 ahora se carga en OCR1B.

Cuando ocurra el próximo evento, el evento OCR1B ahora también impulsará ese pin asociado a BAJO y eliminará esa entrada de la cola. Ahora, la siguiente entrada tiene un valor delta de 0. Debido a eso, DEBE significar que hay otro pin para conducir BAJO, por lo que el evento OCR1B continúa y también conduce ese pin BAJO y elimina esa entrada de la cola. En este punto, solo queda una entrada en la cola, que tiene el valor delta 427, que también es distinto de cero. Entonces, el código ahora carga el valor OCR1B de 2000 en el registro de comparación, OCR1B, y sale.

El último evento OCR1B ahora se activa y el código también activa ese pin BAJO y elimina la entrada. No hay más entradas. Entonces el código simplemente sale. Todo está hecho y lo único que queda es esperar a que vuelva a ocurrir el evento OCR1A.

Ese es el proceso a seguir, creo.

Aquí hay un ejemplo de cómo podría configurar las colas para esto, sobre todo ilustrando cómo insertar en la cola delta. La función qinsert() hace este trabajo. Tendría$P_0$llame a qinsert() para cada uno de los cuatro PWM, como parte de su trabajo.

uint8_t qp[5];          /* prior in queue reference */
uint8_t qn[5];          /* next in queue reference */
uint16_t qk[5];         /* delta value */
uint16_t qv[5];         /* OCR1B value */
uint8_t qpin[5];        /* pin position 0..7 */

void qinit( void ) {

    qn[0]= qp[0]= 0;
    qk[0]= 0xFFFF;

    return;
}

uint8_t qinsert( uint8_t node, uint16_t key ) {
    uint8_t prv= 0, nxt;
    uint16_t nxtkey;

        qv[node]= key; /* optional, depending on overall design */
        for ( nxt= qn[prv]; (nxtkey= qk[nxt]) < key; prv= nxt, nxt= qn[nxt] )
            key -= nxtkey;
        if ( nxt != 0 )
            qk[nxt]= nxtkey - key;
        qk[node]= key;
        qp[node]= prv;
        qn[node]= nxt;
        qp[nxt]= qn[prv]= node;

    return node;
}

uint8_t qunlink( uint8_t node ) {
    uint8_t prv= qp[node], nxt= qn[node];

        qn[prv]= nxt;
        qp[nxt]= prv;

    return node;
}