4-Kanal-Software-PWM mit Atmega16 zur Steuerung von 4 ESCs für bürstenlose Gleichstrommotoren

Die Ursache des Problems: OCR1A-Doppelpufferung

Ihr Programm schlägt fehl, weil OCR1A in allen PWM-Timer-Modi doppelt gepuffert ist und Sie einen solchen Modus verwenden (Fast PWM, TOP = ICR1). Wenn Sie einen neuen Wert in OCR1A schreiben, ändern Sie nicht wirklich den Wert, der von der Timer-Hardware verwendet wird. Stattdessen wird der in OCR1A gespeicherte Wert erst dann in das separate "Schattenregister" kopiert, das tatsächlich vom Timer verwendet wird, wenn der Zählerwert TOP erreicht und wieder bei Null beginnt. Dies ist sehr nützlich, um störungsfreie Hardware-PWM zu erzeugen, verhindert jedoch das, was Sie versuchen (mehrere OCR1A-Aktualisierungen pro Timer-Zyklus).

Da dieses OCR1A-Update nur einmal pro Timer-Zyklus (bei 50 Hz) erfolgt und Ihr Interrupt-Code 4 Verzögerungen von 1000 μs - 2000 μs + eine lange Verzögerung erzeugen soll, erhalten Sie am Ende eine PWM-Periode von 100 ms (5 Timer-Zyklen) und eine hohe Zeit von ~20 ms.

Die Lösung besteht darin, den Timer auf einen Nicht-PWM-Modus zu konfigurieren. Der für Ihr Programm am besten geeignete Modus ist Clear Timer on Compare Match (CTC, TOP = ICR1), der nahezu identisch funktioniert, aber OCR1A und OCR1B nicht doppelt puffert. Die WGM-Bits in TCCR1A und TCCR1B sollten auf 1100 gesetzt werden, um dies zu erreichen (siehe Datenblatt für Details).

Andere kleinere Probleme:

• Wenn Sie in einer Interrupt-Service-Routine auf eine Variable zugreifen, müssen Sie die Variable deklarieren volatile. Das Weglassen des Schlüsselworts (unter anderem) ermöglicht es dem Compiler, Optimierungen vorzunehmen, die davon ausgehen, dass nur der Hauptprogrammfluss den Zustand ändern kann.

• PIND4, PIND5, PIND6und PIND7wie von Ihrem Code verwendet werden nicht in den von AVR-GCC bereitgestellten Registerdefinitionen gefunden. Die allgemeineren Makros PINx, PORTxund DDRxwerden in "portpins.h" deklariert.

• Die Ablauflogik könnte klarer geschrieben werden. Ihr aktueller Code hat 4 explizite Zustände in der Sequenz (einen für jeden Ausgangspin), von denen der letzte für zwei Vergleichsübereinstimmungen verwendet wird: Der erste, um den Ausgang von Kanal 4 niedrig zu setzen, und der zweite, um zu warten, bis die Sequenz neu gestartet werden soll. Dies geschieht seltsamerweise, indem ein bestimmter OCR1A-Wert (1000) als Flag verwendet wird. Das hat mich eine Weile am Kopf kratzen lassen.

• Dies mag meinungsbasiert sein, aber ich würde eher uint8_t, int16_tund Freunde verwenden als zB unsigned charoder shortin eingebetteter Software. Auf diese Weise wissen Sie und andere genau, wie groß Ihre Variablen sind, und sie sind auch weniger ausführlich.

• Ihr Codebeispiel sollte <avr/io.h>and enthalten <avr/interrupt.h>und eine Funktionsdeklaration für bereitstellen void initESCs(). initUSART()ist überflüssig.

Wenn ich Ihren Code richtig verstehe, haben Sie Timer1 im schnellen PWM-Modus mit OCR1A, um die PWM-Einschaltdauer und ICR1 für den Zeitraum zu messen. Wenn OCR1A mit dem aktuellen Timerwert übereinstimmt, löst es einen Interrupt aus. Sie laden es dann mit einer längeren Zeit neu, die Idee ist, dass es den Timer 1 ~ 2 ms später für den nächsten Servoimpuls abgleicht.

Das Problem bei dieser Technik besteht darin, dass das Ausgangsvergleichsregister in PWM-Modi doppelt gepuffert und mit der PWM-Periode synchronisiert ist, sodass das Schreiben darauf während des aktuellen PWM-Zyklus nur im nächsten Zyklus Auswirkungen hat . Dies ist im Datenblatt auf Seite 98 beschrieben:-

Das OCR1x-Register wird doppelt gepuffert, wenn einer der zwölf Pulsweitenmodulationsmodi (PWM) verwendet wird... Die doppelte Pufferung synchronisiert die Aktualisierung des OCR1x-Vergleichsregisters entweder mit OBEN oder mit UNTEN der Zählsequenz. Die Synchronisation verhindert das Auftreten von unsymmetrischen PWM-Pulsen mit ungerader Länge

Anstatt also 1~2 ms nach dem Schreiben in OCR1A einen Interrupt zu erhalten, erhalten Sie ihn 20 ms + 1~2 ms später.

Ich bin mir nicht sicher, ob es möglich ist, dies mit einem Nicht-PWM-Timer-Modus auf Ihre Weise zu tun, aber es könnte einfacher sein, einfach einen einfachen Timer zu verwenden, um jeden Impuls separat zu timen, dann alle Zeiten zu addieren und von 20 ms abzuziehen, um zu erhalten die letzte Pausenzeit.

Viele moderne ESCs können mit Frequenzen von 250 Hz oder höher umgehen, sodass Sie vielleicht sogar damit durchkommen, die Impulse so schnell wie möglich nacheinander herauszudrücken.

• Das erste, was Sie tun müssen, ist, sich JEDE Art von Umfang zu besorgen. Sie können einen DSO138 kaufen – ich habe mehrere davon gekauft und zusammengebaut, um sie an Freunde zu verschenken. Sie sind billig und können für Ihre Bedürfnisse funktionieren. (Es probiert bei$1\:\textrm{MHz}$und unterstützt nur etwa$200\:\textrm{kHz}$, aber das mag für das, was Sie vor sich haben, in Ordnung sein.) Oder Sie können etwas schickeres kaufen, das an einen PC angeschlossen werden kann, wie ein Hantek 6022BE. Oder Sie kaufen einfach ein billiges, gebrauchtes Oszilloskop. Es gibt eine Reihe von Websites, auf denen Sie nach guten Preisen suchen können, von denen ich sicher bin, dass Sie viele kennen. Aber der Punkt hier ist, dass Sie, wenn Sie an Code arbeiten, um etwas Wichtiges wie dieses zu tun, wirklich etwas haben MÜSSEN, mit dem Sie beobachten und messen können, was Sie produzieren. Und Ihre Bedürfnisse sind fußläufig, also kostet es Sie keinen Arm und kein Bein. Wahrscheinlich weniger als die Kosten für einen ESC-Controller. Lohnt sich.
• Der ATmega16 hat vier PWMs. Ein PWM auf jedem der zwei 8-Bit-Timer und nur zwei weitere PWMs auf dem 16-Bit-Timer1. Ich verstehe also, warum Sie versuchen, dies in der Software mit Timer1 zu tun. Es gibt keinen anderen Weg.

Was ich in Ihrem Code NICHT sehe, ist eine Warteschlange jeglicher Art. Und du brauchst einen, denke ich.

So würde ich dies als Softwaredesignlösung angehen:

1. Entscheiden Sie sich für eine bestimmte Auflösung für meine vier PWM-Ausgänge. Ich bin kein Experte für ESC-Controller und weiß nicht, welche Auflösung sie verwenden, wenn sie die empfangene Impulsbreite interpretieren. Aber ich denke, ich kann aus Ihrer Verwendung von 1000 und 2000 schließen, dass Sie eine Genauigkeit bis auf die Mikrosekunde wünschen. Kurz gesagt, Sie können festlegen$1.001\:\textrm{ms}$und einstellen$1.583\:\textrm{ms}$, aber Sie können nicht festlegen$1.6057\:\textrm{ms}$.
2. Sobald Sie die erforderliche Auflösung kennen, können Sie Timer1 einrichten, um diese Auflösung bereitzustellen. Dies richtet nur die Zählerrate des Timers ein. (Es verursacht selbst keine Interrupts. Das passiert, wenn Sie die Erfassung/den Vergleich einrichten.) In diesem Fall gehe ich davon aus, dass Sie Timer1 so eingerichtet haben, dass er mit einer Rate von zählt$1\:\textrm{MHz}$. (Nein, ich werde nicht das Datenblatt auf dem ATmega16 recherchieren und versuchen herauszufinden, was Sie tatsächlich in Ihrem obigen Code getan haben. Stattdessen sage ich Ihnen, was Sie tun müssen.)
3. Nun, da die Auflösung bestimmt und Timer1 richtig konfiguriert ist, um a bereitzustellen$1\:\textrm{MHz}$Gegenkurs richten Sie eine sogenannte „Delta-Warteschlange“ ein. Sie können darüber in Douglas Comers (dem Erfinder) Buch über XINU lesen, das Mitte der 1980er Jahre datiert wurde, wenn Sie an einer Quelle der Idee interessiert sind. Sie benötigen vier Einträge in der Warteschlange. Einer für jeden Ihrer PWM-Ausgangspins, einzeln.
4. Nennen wir die$20\:\textrm{ms}$Intervall-Thread,$P_0$. Die anderen vier werden es sein$P_1\dots P_4$.
5. Ihnen stehen zwei Erfassungs-/Vergleichsregister zur Verfügung. Es wäre wahrscheinlich bequemer, beide zu verwenden. Einer von ihnen wird zugewiesen$P_0$für seine regelmäßige$20\:\textrm{ms}$Fall. Weisen wir OCR1A zu$P_0$, setzen Sie diesen Wert also auf 20000 und richten Sie ihn nach Möglichkeit für das automatische Neuladen ein. (Wenn nicht, tun Sie es in der Software.) Dadurch wird die Basis eingerichtet$20\:\textrm{ms}$zeitliche Koordinierung.
6. $P_0$Folgendes tun: (a) Alle PWM-Ausgänge auf HIGH treiben. (b) Fügen Sie jeweils ein$P_1\dots P_4$in die Warteschlange, die jetzt immer leer ist, basierend auf ihren Periodenwerten. (c) Löschen Sie den Timer-Zähler. (d) OCR1B mit dem Zeitgeberwert des ersten Eintrags in der Delta-Warteschlange laden und das OCR1B-Unterbrechungsereignis freigeben. (e) Beenden. (Möglicherweise muss etwas getan werden, um das nächste Interrupt-Ereignis zu aktivieren. Aber das müssen Sie selbst herausfinden.)
7. Beim OCR1B-Ereignis treiben Sie den zugehörigen Pin LOW. Entfernt den aktuellen Eintrag aus der Warteschlange. Während es verbleibende Einträge in der Warteschlange gibt und während die verbleibenden "Ticks" (Delta-Wert) genau Null sind, treiben Sie den zugeordneten Stift auf LOW und entfernen Sie den Eintrag aus der Warteschlange. Jetzt ist Ihnen einer von zwei Fällen garantiert: (a) es gibt keine verbleibenden Warteschlangeneinträge – in diesem Fall kehren Sie einfach zurück, da nichts mehr zu tun ist. (b) es verbleibende Warteschlangeneinträge und der oberste enthält einen Zeitgeberwert ungleich Null – lade diesen Wert in OCR1B und stelle sicher, dass er erneut unterbrechen kann, und kehre dann einfach zurück.

Dass es. Der ganze Prozess. Die Delta-Warteschlange ist so eingerichtet, dass sie einen „Tick“-Wert hält, der die Zählung in Mikrosekunden für das nächste Ereignis ist, das auftritt. Wenn Sie einen Eintrag in die Warteschlange einfügen, subtrahieren Sie vor dem Einfügen alle "Ticks" (Delta-Wert) in vorherigen Einträgen. Lassen Sie mich dies an einem Beispiel demonstrieren, um dies zu verdeutlichen.

Angenommen, der Zeitwert für$P_1\dots P_4$sind: 1573, 2000, 1206 und 1573. Dann würde die Warteschlange so aussehen (ohne den zugehörigen Pin, der auch hier benötigt wird):

Das ist in der Reihenfolge der Warteschlange aufgeführt. Ich würde jedoch ein Array mit fünf Elementen mit Indizes von 0 bis 4 erstellen, wobei [0] als Warteschlange zugewiesen wird$head$Zeiger. Die obige Warteschlange möchte also Folgendes in Array-Reihenfolge:

Wenn$P_0$macht sich daran, alle vier in die Warteschlange einzufügen (die leer ist, wenn$P_0$beginnt, da alle$P_1 \dots p_4$zu diesem Zeitpunkt alle abgelaufen sind), das ist die resultierende Warteschlange, wenn$P_0$beendet und kehrt von seinem Interrupt-Ereignis zurück. Aber kurz vor dem Ausstieg, wie erwähnt,$P_0$lädt den ersten OCR1B-Wert in die Warteschlange (hier 1206) und platziert ihn in OCR1B.

Wenn das OCR1B-Ereignis ausgelöst wird, teilt der erste Eintrag in der Warteschlange dem Code mit, welcher Pin auf LOW getrieben werden soll. Dann wird der Eintrag aus der Warteschlange entfernt. Für das erste OCR1B-Ereignis entfernt dies den 1206-Eintrag, wodurch der Delta-Wert von 367 verbleibt, der nicht null ist. Daher wird jetzt der OCR1B-Wert von 1573 in OCR1B geladen.

Wenn das nächste Ereignis eintritt, wird das OCR1B-Ereignis nun auch diesen zugeordneten Pin auf LOW treiben und diesen Eintrag aus der Warteschlange entfernen. Jetzt hat der nächste Eintrag einen Delta-Wert von 0 drin. Aus diesem Grund MUSS es bedeuten, dass es einen anderen Pin gibt, um LOW zu fahren, sodass das OCR1B-Ereignis fortgesetzt wird und diesen Pin ebenfalls auf LOW treibt und diesen Eintrag aus der Warteschlange entfernt. An diesem Punkt gibt es nur einen verbleibenden Eintrag in der Warteschlange, der den Delta-Wert 427 hat, der ebenfalls nicht Null ist. Der Code lädt nun den OCR1B-Wert von 2000 in das Vergleichsregister OCR1B und wird beendet.

Das letzte OCR1B-Ereignis wird nun ausgelöst und der Code treibt diesen Pin ebenfalls auf LOW und entfernt den Eintrag. Es sind keine Einträge mehr vorhanden. Der Code wird also einfach beendet. Es ist alles erledigt und es bleibt nur noch zu warten, bis das OCR1A-Ereignis erneut auftritt.

Das ist der Prozess zu folgen, denke ich.

Hier ist ein Beispiel dafür, wie ich die Warteschlangen dafür einrichten könnte, insbesondere das Veranschaulichen, wie in die Delta-Warteschlange eingefügt wird. Die Funktion qinsert() erledigt diese Aufgabe. ich hatte$P_0$Rufen Sie qinsert() für jede der vier PWMs als Teil ihrer Aufgabe auf.

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;
}