Im ersten Teils Ich habe versucht, Hobby-Elektronikern, die aus den Shorts von Arduino herausgewachsen sind, zu erklären, wie und warum sie Datenblätter und andere Dokumentationen zu Mikrocontrollern lesen sollten. Der Text ist ziemlich lang geworden, daher habe ich versprochen, praktische Beispiele in einem separaten Artikel zu zeigen. Nun, was soll's, ich habe mich als Pilz bezeichnet...

Heute zeige ich, wie man mit Hilfe von Datenblättern ziemlich einfache, aber notwendige Aufgaben für viele Projekte auf den STM32 (Blue Pill) und STM8 Controllern löst. Alle Demo-Projekte sind meinen Lieblings-LEDs gewidmet, die wir in großen Mengen aktivieren werden, wozu wir verschiedene interessante Peripheriegeräte einbeziehen müssen.

Der Text ist wieder sehr umfangreich geworden, daher mache ich zur besseren Übersicht ein Inhaltsverzeichnis:

STM32 Blue Pill: 16 LEDs mit DM634 Treiber
STM8: Sechs PWM-Pins einstellen
STM8: 8 RGB-LEDs an drei Pins, Interrupts

Haftungsausschluss: Ich bin kein Ingenieur und beanspruche kein tiefes Wissen in Elektronik, der Artikel richtet sich an Gleichgesinnte wie mich. Tatsächlich habe ich als Zielgruppe mich selbst vor zwei Jahren betrachtet. Wenn mir damals jemand gesagt hätte, dass es nicht schlimm ist, die Datenblätter eines unbekannten Chips zu lesen, hätte ich nicht viel Zeit mit der Suche nach Codefragmente im Internet und der Erfindung von Provisorien mit Scheren und Pflastern verschwenden müssen.

Im Mittelpunkt dieses Artikels stehen die Datenblätter und nicht die Projekte, daher könnte der Code nicht besonders sauber sein und oft provisorisch wirken. Die Projekte selbst sind sehr einfach, auch wenn sie sich gut für die erste Bekanntschaft mit einem neuen Chip eignen.

Ich hoffe, dass mein Artikel jemandem in einer ähnlichen Phase des Einstiegs in das Hobby helfen wird.

STM32

16 LEDs mit DM634 und SPI

Ein kleines Projekt unter Verwendung des Blue Pill (STM32F103C8T6) und des LED-Treibers DM634. Mithilfe von Datenblättern werden wir den Treiber, die IO-Ports von STM verstehen und SPI einrichten.

DM634

Taiwanesischer Chip mit 16 16-Bit PWM-Ausgängen, kann in Ketten verbunden werden. Das kleinere 12-Bit Modell ist aus einem einheimischen Projekt bekannt. Lightpack. Zu seiner Zeit, als ich zwischen DM63x und dem bekannten TLC5940 wählte, entschied ich mich aus mehreren Gründen für DM: 1) Der TLC auf AliExpress ist sicher eine Fälschung, dieser hier nicht; 2) Der DM hat eine eigenständige PWM mit eigenem Frequenzgenerator; 3) Ich konnte ihn günstig in Moskau kaufen, anstatt auf ein Paket von Ali zu warten. Und natürlich war es interessant, selbst zu lernen, wie man den Chip steuert, anstatt eine fertige Bibliothek zu nutzen. Die Chips sind jetzt hauptsächlich im SSOP24-Gehäuse verfügbar, was es einfach macht, sie auf einen Adapter zu löten.

Da der Hersteller taiwanesisch ist, Datenblatt ist die Beschreibung des Chips in einem Chinesisch-Englisch verfasst, deshalb wird es lustig. Zuerst schauen wir uns das Pinout an (Pin Connection), um zu verstehen, an welches Bein was angeschlossen wird, und die Beschreibung der Pins (Pin-Beschreibung). 16 Pins:

Stromquelle für Stromfluss (Open Drain)

Sink / Open-drain output – Drain; Stromquelle für den Stromfluss; Ausgänge, die im aktiven Zustand mit der Erde verbunden sind – die LEDs werden an den Treiber mit den Kathoden angeschlossen. Elektrisch gesehen ist dies natürlich kein „Open Drain“ (open drain), aber in den Datenblättern wird diese Bezeichnung für Pins im Drain-Modus oft verwendet.

Externe Widerstände zwischen REXT und GND zur Einstellung des Ausgangsstroms

Zwischen dem Pin REXT und der Erde wird ein Referenzwiderstand installiert, der den inneren Widerstand der Ausgänge steuert, siehe Diagramm auf Seite 9 des Datenblatts. Bei DM634 kann dieser Widerstand auch softwaregesteuert eingestellt werden, um die Gesamthelligkeit (global brightness); ich werde hier nicht ins Detail gehen, sondern einfach einen Widerstand von 2.2 – 3 kOhm einfügen.

Um zu verstehen, wie man den Chip steuert, schauen wir uns die Beschreibung der Geräteschnittstelle an:

Aha, da ist er, das Chinesisch-Englisch in seiner vollen Pracht. Das zu übersetzen ist problematisch; man kann es jedoch verstehen, wenn man möchte. Aber es gibt einen anderen Weg – wir schauen uns an, wie die Verbindung im Datenblatt zum funktional ähnlichen TLC5940 beschrieben wird:

… Zur Eingabe von Daten in das Gerät sind nur drei Pins erforderlich. Die steigende Flanke des SCLK-Signals verschiebt die Daten vom Pin SIN in den internen Register. Nachdem alle Daten geladen sind, fixiert ein kurzer hoher Signalimpuls XLAT die nacheinander übertragenen Daten in den internen Registern. Die internen Register sind Flanken-triggerte Register, die auf das Signal XLAT reagieren. Alle Daten werden mit dem höchstwertigen Bit zuerst übertragen.

Latch – Schieber/Latch/Fixator.
Steigende Flanke – die steigende Flanke des Impulses
MSB zuerst – den höchsten (äußeren linken) Bit nach vorne.
Daten takten – Daten sequenziell (bitweise) übertragen.

Das Wort latch kommt häufig in der Dokumentation zu Chips vor und wird unterschiedlich übersetzt, daher erlaube ich mir zur Verständigung

eine kleine EinführungDer LED-Treiber ist im Grunde ein Schieberegister. "Verschiebung" (Shift) im Namen bedeutet die bitweise Verschiebung von Daten innerhalb des Geräts: jedes neu eingefügte Bit schiebt die gesamte Reihe vor sich her. Da während der Verschiebung niemand ein chaotisches Blitzen der LEDs beobachten möchte, geschieht der Prozess in Pufferregistern, die von einem Arbeitsverschluss (latch) getrennt sind – das ist sozusagen ein Vorzimmer, in dem die Bits in die richtige Reihenfolge gebracht werden. Wenn alles bereit ist, öffnet sich der Verschluss, und die Bits werden zur Arbeit geschickt, wobei sie die vorherige Charge ersetzen. Das Wort latch impliziert in der Dokumentation zu Mikrochips fast immer solch einen Verschluss, unabhängig von den Kombinationen, in denen es verwendet wird.

So erfolgt die Datenübertragung im DM634: Wir setzen den Eingang DAI auf das höchste Bit der weitesten LED, ziehen DCK hoch und runter; setzen den Eingang DAI auf das nächste Bit, ziehen DCK; und so weiter, bis alle Bits übertragen sind (eingetaktet), danach ziehen wir LAT. Das kann man manuell machen (bit-bang), aber es ist besser, ein speziell dafür optimiertes SPI-Interface zu verwenden, das glücklicherweise auf unserem STM32 in zwei Exemplaren verfügbar ist.

Die blaue Tablet STM32F103

Einführung: Die STM32-Controller sind deutlich komplizierter als Atmega328, als man vielleicht denken könnte. Dabei ist aus Energiespargründen zu Beginn fast alle Peripherie deaktiviert, und die Taktfrequenz beträgt 8 MHz von der internen Quelle. Glücklicherweise haben die Programmierer von STM einen Code geschrieben, der den Chip auf die "berechneten" 72 MHz bringt, und die Autoren aller mir bekannten IDEs haben ihn in das Initialisierungsverfahren integriert, sodass wir nichts takten müssen (aber es wäre möglich, wenn man es wirklich möchte). Die Peripherie müssen wir jedoch aktivieren.

Dokumentation: Auf dem Blue Pill ist der beliebte Chip STM32F103C8T6 installiert, und es gibt zwei nützliche Dokumente dazu:

• Datenblatt für die Mikrokontroller STM32F103x8 und STM32F103xB;
• Handbuch für die gesamte Reihe STM32F103 und darüber hinaus.

Im Datenblatt sind für uns folgende Punkte interessant:

• Pinouts – Pinbelegungen der Chips – für den Fall, dass wir Platinen selbst herstellen möchten.
• Memory Map – eine Speicherkartierung für einen bestimmten Chip. Im Referenzhandbuch gibt es eine Karte für die gesamte Produktreihe, in der Register erwähnt werden, die in unserem nicht vorhanden sind.
• Tabelle der Pin-Deklarationen – eine Aufzählung der Haupt- und Alternativfunktionen der Pins; für die "blaue Pille" kann man im Internet praktischere Bilder mit einer Liste der Pins und ihrer Funktionen finden. Daher sofort nach dem Blue Pill Pinout googeln und solch ein Bild bereithalten:

NB: Auf dem Bild aus dem Internet gab es einen Fehler, der in den Kommentaren angemerkt wurde, dafür danke. Das Bild wurde ersetzt, aber das ist eine Lektion – Informationen, die nicht aus Datenblättern stammen, sollten besser überprüft werden.

Das Datenblatt entfernen, das Referenzhandbuch öffnen und ab jetzt nur noch damit arbeiten.
Handlungsablauf: Wir kümmern uns um den Standard-Ein- und Ausgang, konfigurieren SPI und aktivieren die benötigten Peripheriegeräte.

Ein- und Ausgang

Bei der Atmega328 ist der Ein- und Ausgang äußerst einfach umgesetzt, weshalb die Fülle an Optionen bei STM32 verwirren kann. Derzeit benötigen wir nur die Ausgänge, aber selbst davon gibt es vier Varianten:

Offener Kollektor, Push-Pull, alternativer Push-Pull, alternativer offener Kollektor

"Push-Pull" (push-pull) – der vertraute Ausgang von Arduino, der Pin kann entweder den Wert HIGH oder LOW annehmen. Bei "offenem Kollektor" entstehen jedoch bei der Bereitstellung von Paketen in Distributionen schafft. Insbesondere verbieten die Nutzungsbedingungen der Marken von Mozilla die Beibehaltung des Projektnamens im Falle von Änderungen oder der Anwendung von Patches. Distributionen können das Paket nur unter den Namen Rust und Cargo verbreiten, wenn es aus den Original-Quelltexten erstellt wurde, andernfalls ist eine vorherige schriftliche Genehmigung des Rust Core Team erforderlich oder der Name muss geändert werden. Diese Besonderheit erschwert die schnelle und eigenverantwortliche Behebung von Fehlern und Schwachstellen in Paketen mit Rust und Cargo ohne Abstimmung von Änderungen mit dem Upstream., obwohl es in Wirklichkeit ganz einfach ist:

Konfiguration des Ausgangs / wenn der Port als Ausgang eingestellt ist: / Ausgangspuffer aktiviert: / – offener Kollektor-Modus: "0" im Ausgangsregister aktiviert N-MOS, "1" im Ausgangsregister lässt den Port im Hi-Z-Modus (P-MOS wird nicht aktiviert) / – Push-Pull-Modus: "0" im Ausgangsregister aktiviert N-MOS, "1" im Ausgangsregister aktiviert P-MOS.

Der gesamte Unterschied zwischen offenem Kollektor (open drain) und Push-Pull (push-pull) besteht darin, dass der erste Pin keinen Zustand HIGH annehmen kann: Wenn man eine Eins in das Ausgangsregister schreibt, wechselt er in den Hochimpedanzmodus (high impedance, floating). Bei der Einspeisung von Null verhält sich der Pin in beiden Modi sowohl logisch als auch elektrisch gleich.

Im normalen Ausgabemodus gibt der Pin einfach den Inhalt des Ausgangsregisters wieder. Im "alternativen" Modus wird er von der entsprechenden Peripherie gesteuert (siehe 9.1.4):

Wenn das Bit des Ports als Ausgang der alternativen Funktion konfiguriert ist, wird das Ausgangsregister deaktiviert und der Pin wird mit dem Ausgangssignal der Peripherie verbunden.

Die alternativen Funktionen jedes Pins sind beschrieben in Pin Definitions Das Datenblatt ist auf dem heruntergeladenen Bild zu finden. Auf die Frage, was zu tun ist, wenn ein Pin mehrere alternative Funktionen hat, beantwortet eine Fußnote im Datenblatt:

Wenn mehrere Peripherieblöcke denselben Pin verwenden, sollte zur Vermeidung von Konflikten zwischen den alternativen Funktionen immer nur ein Peripherieblock gleichzeitig verwendet werden, indem man durch das Aktivierungsbit der Peripherietaktung (im entsprechenden RCC-Register) umschaltet.

Zusätzlich haben die Pins im Ausgangsmodus eine weitere Taktgeschwindigkeit. Dies ist ein weiteres Energiesparmerkmal, in unserem Fall stellen wir einfach auf Maximum und vergessen es.

Also: Wir verwenden SPI, das bedeutet, zwei Pins (für Daten und Takt) sollten die 'alternative Funktion Ziehen-Schieben' haben, und ein weiterer (LAT) – 'gewöhnliches Ziehen-Schieben'. Aber bevor wir sie zuweisen, klären wir das SPI.

SPI

Noch eine kleine Bildungseinheit

SPI oder Serial Peripheral Interface (serielle Peripherieschnittstelle) ist eine einfache und sehr effektive Schnittstelle zur Kommunikation zwischen Mikrocontrollern und der Außenwelt. Das Prinzip seiner Funktionsweise wurde bereits oben beschrieben, dort, wo es um den chinesischen LED-Treiber geht (im Referenzhandbuch siehe Abschnitt 25). SPI kann im Master- ('Besitzer') und Slave-('Sklave') Modus betrieben werden. SPI bietet vier grundlegende Kanäle, von denen nicht alle genutzt werden können:

• MOSI, Master Output / Slave Input: Dieser Pin gibt im Master-Modus aus und empfängt im Slave-Modus Daten;
• MISO, Master Input / Slave Output: Im Master-Modus empfängt er, im Slave-Modus gibt er aus;
• SCK, Serial Clock: Dieser legt die Datenübertragungsrate im Master fest oder empfängt das Taktsignal im Slave. Er bestimmt im Grunde die Bits;
• SS, Slave Select: Über diesen Kanal erfährt der Slave, dass er angesprochen wird. Bei STM32 wird dies als NSS bezeichnet, wobei N = negativ, d.h. der Controller wird zum Slave, wenn in diesem Kanal Masse liegt. Funktioniert gut im Modus Open Drain Output, aber das ist eine andere Geschichte.

Wie alles andere ist auch SPI auf STM32 funktional reich und macht es etwas kompliziert, es zu verstehen. Zum Beispiel kann es nicht nur im SPI-Modus, sondern auch im I2S-Modus arbeiten, wobei die Beschreibungen in der Dokumentation durcheinander gehen, das Überflüssige muss rechtzeitig herausgefiltert werden. Unsere Aufgabe ist jedoch extrem einfach: Wir müssen nur Daten senden, indem wir nur MOSI und SCK verwenden. Gehe zu Abschnitt 25.3.4 (Half-Duplex-Kommunikation), wo wir finden 1 Takt und 1 unidirektionales Datenkabel (1 Takt und 1 unidirektionaler Datenstrom):

In diesem Modus verwendet die Anwendung SPI entweder im Modus nur Senden oder nur Empfangen. Der Modus nur Senden ähnelt dem Duplexmodus: Daten werden über den Sendepin (MOSI im Master-Modus oder MISO im Slave-Modus) übertragen, während der Empfängerpins (MISO oder MOSI entsprechend) als normale I/O-Pins verwendet werden können. In diesem Fall muss die Anwendung den Rx-Puffer ignorieren (wenn er gelesen wird, sind keine übertragenen Daten vorhanden).

Toll, der Pin MISO ist jetzt frei, wir schließen das Signal LAT an. Lassen Sie uns mit dem Slave Select befassen, der auf STM32 programmatisch gesteuert werden kann, was äußerst praktisch ist. Lesen wir den gleichnamigen Absatz im Abschnitt 25.3.1 SPI Allgemeine Beschreibung:

Programmgesteuerte Steuerung von NSS (SSM = 1) / Informationen zur Slave-Auswahl befinden sich im Bit SSI des Registers SPI_CR1. Der externe Pin NSS bleibt für andere Anforderungen der Anwendung frei.

Es ist an der Zeit, in die Register zu schreiben. Ich habe mich entschieden, SPI2 zu verwenden, wir suchen in den technischen Unterlagen nach seiner Basisadresse – im Abschnitt 3.3 Adresskarte:

Nun, dann fangen wir an:

#define _SPI2_(mem_offset) (*(volatile uint32_t *)(0x40003800 + (mem_offset)))

Öffnen Sie Abschnitt 25.3.3 mit dem vielversprechenden Titel „Einrichtung von SPI im Master-Modus“:

1. Stellen Sie die Taktrate des seriellen Interfaces über die Bits BR[2:0] im Register SPI_CR1 ein.

Die Register sind im gleichnamigen Abschnitt des Referenzhandbuchs zusammengefasst. Der Adressversatz (Adressverschiebung) im CR1 beträgt 0x00. Standardmäßig sind alle Bits zurückgesetzt (Rücksetzwert 0x0000):

Die Bits BR legen den Teiler der Taktrate des Controllers fest und bestimmen so die Frequenz, mit der SPI arbeitet. Die Frequenz des STM32 beträgt 72 MHz, der LED-Treiber arbeitet gemäß seinem Datenblatt mit einer Frequenz von bis zu 25 MHz, also muss auf vier geteilt werden (BR[2:0] = 001).

#define _SPI_CR1 0x00

#define BR_0        0x0008
#define BR_1        0x0010
#define BR_2        0x0020

_SPI2_ (_SPI_CR1) |= BR_0;// pclk/4

2. Stellen Sie die Bits CPOL und CPHA ein, um die Beziehungen zwischen Datenübertragung und Taktung des seriellen Interfaces zu bestimmen (siehe Diagramm auf Seite 240).

Da wir hier das Datenblatt lesen und keine Schaltpläne betrachten, lassen Sie uns besser die textuelle Beschreibung der Bits CPOL und CPHA auf Seite 704 (SPI Allgemeine Beschreibung) studieren:

Phase und Polarität des Taktsignals
Mit den Bits CPOL und CPHA des Registers SPI_CR1 können vier Varianten von Timing-Beziehungen programmiert werden. Das Bit CPOL (Polarität des Taktsignals) steuert den Zustand des Taktsignals, wenn keine Daten übertragen werden. Dieses Bit steuert die Master- und Slave-Modi. Wenn CPOL zurückgesetzt ist, befindet sich der Pin SCK im Ruhezustand auf einem niedrigen Pegel. Wenn das Bit CPOL gesetzt ist, befindet sich der Pin SCK im Ruhezustand auf einem hohen Pegel.
Wenn das CPHA-Bit (Taktsignalphase) gesetzt ist, fungiert die zweite Flanke des SCK-Signals (fallend, wenn CPOL zurückgesetzt ist, oder steigend, wenn CPOL gesetzt ist) als Strobe für das höchstwertige Bit. Die Daten werden bei der zweiten Änderung des Taktsignals erfasst. Wenn das CPHA-Bit zurückgesetzt ist, wird die vordere Flanke des SCK-Signals (fallend, wenn CPOL gesetzt ist, oder steigend, wenn CPOL zurückgesetzt ist) als Strobe für das höchstwertige Bit verwendet. Die Daten werden bei der ersten Änderung des Taktsignals erfasst.

Mit diesen Erkenntnissen kommen wir zu dem Schluss, dass beide Bits Null bleiben müssen, da das SCK-Signal niedrig bleiben soll, wenn es nicht verwendet wird, während die Daten bei der vorderen Flanke des Impulses übertragen werden (siehe Rising Edge im DM634-Datenblatt).

Übrigens sind wir hier zum ersten Mal auf eine Lexikbesonderheit in den ST-Datenblättern gestoßen: dort wird der Ausdruck „bit auf null zurücksetzen“ geschrieben to reset a bit, nicht to clear a bit, wie beispielsweise bei der Atmega.

3. Setzen Sie das DFF-Bit zur Festlegung des 8-Bit- oder 16-Bit-Datenblockformats.

Ich habe absichtlich den 16-Bit-DM634 gewählt, um mir die Übertragung von 12-Bit-PWM-Daten, wie beim DM633, zu ersparen. Es macht Sinn, das DFF auf Eins zu setzen:

#define DFF         0x0800

_SPI2_ (_SPI_CR1) |= DFF; // 16-bit mode

4. Konfigurieren Sie das LSBFIRST-Bit im SPI_CR1-Register, um das Blockformat festzulegen.

LSBFIRST, wie der Name schon sagt, konfiguriert die Übertragung mit dem niederwertigsten Bit zuerst. Aber der DM634 möchte die Daten beginnend mit dem höchstwertigen Bit empfangen. Daher lassen wir es zurückgesetzt.

5. Im Hardwaremodus, wenn ein Eingangs-Pin NSS erforderlich ist, legen Sie während der gesamten Byte-Übertragungssequenz ein hohes Signal an den NSS-Pin an. Im Softwaremodus setzen Sie die Bits SSM und SSI im SPI_CR1-Register. Soll der NSS-Pin als Ausgang arbeiten, muss nur das Bit SSOE gesetzt werden.

Setzen Sie SSM und SSI, um den Hardwaremodus des NSS zu ignorieren:

#define SSI         0x0100
#define SSM         0x0200

_SPI2_ (_SPI_CR1) |= SSM | SSI; //enable software control of SS, SS high

6. Die Bits MSTR und SPE müssen gesetzt sein (sie bleiben nur gesetzt, wenn am NSS ein hohes Signal angelegt wird).

Mit diesen Bits ernennen wir unseren SPI zum Master und aktivieren ihn:

#define MSTR        0x0004
#define SPE         0x0040

_SPI2_ (_SPI_CR1) |= MSTR; //SPI master
//когда все готово, включаем SPI
_SPI2_ (_SPI_CR1) |= SPE;

SPI konfiguriert, lassen Sie uns sofort Funktionen schreiben, die Bytes an den Treiber senden. Lassen Sie uns mit 25.3.3 "Konfiguration von SPI im Mastermodus" fortfahren:

Übertragungsreihenfolge der Daten
Die Übertragung beginnt, wenn ein Byte in den Tx-Puffer geschrieben wird.
Das Datenbyte wird in das Schieberegister geladen in parallelem Modus (aus dem internen Bus) während der Übertragung des ersten Bits, wonach es übertragen wird. sequentieller im MOSI-Pin-Modus, entweder mit dem ersten oder letzten Bit zuerst, abhängig von der Einstellung des LSBFIRST-Bits im CPI_CR1-Register. Das TXE-Flag wird nach der Datenübertragung gesetzt. vom Tx-Puffer in das Shift-Register, und es wird auch eine Unterbrechung erzeugt, wenn das TXEIE-Bit im CPI_CR1-Register gesetzt ist.

Ich habe einige Wörter in der Übersetzung hervorgehoben, um auf eine Besonderheit der Implementierung von SPI in STM-Controllern hinzuweisen. Bei der Atmega wird das TXE-Flag (Tx leer, Tx ist leer und bereit, Daten zu empfangen) erst gesetzt, nachdem das gesamte Byte gesendet wurde nach außen.Hier hingegen wird dieses Flag gesetzt, nachdem das Byte in das interne Shift-Register geschoben wurde. Da es dort alle Bits gleichzeitig (parallel) hinein geschoben wird und die Daten dann sequentiell übertragen werden, wird TXE gesetzt, bevor das Byte vollständig gesendet wurde. Das ist wichtig, denn in unserem LED-Treiber müssen wir den LAT-Pin nach der Übertragung Umgebungen und Clustern des Projekts verwendet wird. Dieses Prinzip bildet die Grundlage für ein gutes der Daten ansteuern, d.h. nur mit dem TXE-Flag reicht es uns nicht aus.

Das bedeutet, dass wir ein weiteres Flag benötigen. Schauen wir in 25.3.7 – „Statusflags“:

<…>

Das BUSY-Flag
Das BSY-Flag wird hardwareseitig gesetzt und zurückgesetzt (ein Schreiben hat keine Auswirkung). Das BSY-Flag zeigt den Status der SPI-Kommunikationsschicht an.
Es wird zurückgesetzt,
wenn die Übertragung abgeschlossen ist (außer im Master-Modus, wenn die Übertragung kontinuierlich ist)
wenn SPI deaktiviert wird
wenn ein Fehler im Master-Modus auftritt (MODF=1)
Ist die Übertragung nicht kontinuierlich, wird das BSY-Flag zwischen jeder Datenübertragung zurückgesetzt.

Okay, das ist nützlich. Lassen Sie uns herausfinden, wo sich der Tx-Puffer befindet. Dazu lesen wir das „SPI-Datenregister“:

Bits 15:0 DR[15:0] Datenregister
Die empfangenen Daten oder die zu übertragenden Daten.
Das Datenregister ist in zwei Puffer unterteilt – einen zum Schreiben (Übertragungspuffer) und einen zum Lesen (Empfangspuffer). Ein Schreiben ins Datenregister schreibt in den Tx-Puffer, und ein Lesen aus dem Datenregister gibt den Inhalt des Rx-Puffers zurück.

Und das Statusregister, wo die Flags TXE und BSY zu finden sind:

Wir schreiben:

#define _SPI_DR  0x0C
#define _SPI_SR  0x08

#define BSY         0x0080
#define TXE         0x0002

void dm_shift16(uint16_t value)
{
    _SPI2_(_SPI_DR) = value; //send 2 bytes
    while (!(_SPI2_(_SPI_SR) & TXE)); //wait until they're sent
}

Da wir 16 Mal zwei Bytes übertragen müssen, entsprechend der Anzahl der Ausgänge des LED-Treibers, sieht das ungefähr so aus:

void sendLEDdata()
{
    LAT_low();
    uint8_t k = 16;
    do
    {   k--;
        dm_shift16(leds[k]);
    } while (k);

    while (_SPI2_(_SPI_SR) & BSY); // Übertragung beenden

    LAT_pulse();
}

Aber da wir den LAT-Pin noch nicht ansteuern können, kehren wir zu I/O zurück.

Wir ordnen die Pins zu.

Bei STM32F1 sind die Register, die den Status der Pins steuern, recht ungewöhnlich. Es ist klar, dass es mehr davon gibt als bei der Atmega, aber sie unterscheiden sich auch von anderen STM-Chips. Abschnitt 9.1 Allgemeine Beschreibung von GPIO:

Jeder der allgemeinen Eingangs-/Ausgangsports (GPIO) verfügt über zwei 32-Bit-Konfigurationsregister (GPIOx_CRL und GPIOx_CRH), zwei 32-Bit-Datenregister (GPIOx_IDR und GPIOx_ODR), ein 32-Bit-Setzen/Rücksetzen-Register (GPIOx_BSRR), ein 16-Bit-Reset-Register (GPIOx_BRR) und ein 32-Bit-Sperrregister (GPIOx_LCKR).

Ungewöhnlich und auch ziemlich unpraktisch sind hier die ersten beiden Register, weil 16 Pins des Ports über sie verteilt sind im Format „vier Bits pro Pin“. D.h. die Pins von null bis sieben sind im CRL, während die anderen im CRH sind. Die übrigen Register fassen die Bits aller Pins des Ports erfolgreich zusammen – oft bleiben sie halb „reserviert“.

Zur Vereinfachung beginnen wir am Ende der Liste.

Das Sperrregister benötigen wir nicht.

Die Setzen- und Rücksetzen-Register sind recht amüsant, da sie sich teilweise duplizieren: Man kann alles nur im BSRR schreiben, wo die oberen 16 Bits den Pin auf Null setzen, während die unteren ihn auf 1 setzen, oder man verwendet auch BRR, dessen unteren 16 Bits nur den Pin zurücksetzen. Mir gefällt die zweite Variante besser. Diese Register sind wichtig, da sie atomaren Zugriff auf die Pins ermöglichen:

Atomare Setzen oder Rücksetzen
Es ist nicht notwendig, Interrupts beim Programmieren von GPIOx_ODR auf Bit-Ebene zu deaktivieren: Man kann einen oder mehrere Bits mit einer atomaren Schreiboperation auf APB2 ändern. Dies geschieht, indem man eine „1“ in das Setzen/Rücksetzen-Register (GPIOx_BSRR oder, nur zum Zurücksetzen, in GPIOx_BRR) des Bits schreibt, das man ändern möchte. Die übrigen Bits bleiben unverändert.

Die Datenregister haben recht sprechende Namen – IDR = Input Richtungsregister, Eingangsregister; ODR = Ausgabe Richtungsregister, Ausgangsregister. In dem aktuellen Projekt benötigen wir sie nicht.

Und schließlich die Steuerregister. Da uns die Pins des zweiten SPI interessieren, insbesondere PB13, PB14 und PB15, schauen wir uns sofort das CRH an:

Und sehen, dass wir etwas in die Bits von 20 bis 31 schreiben müssen.

Wir haben bereits oben geklärt, was wir von den Pins erwarten, daher kann ich hier auf einen Screenshot verzichten und einfach sagen, dass MODE die Richtung festlegt (Eingang, wenn beide Bits auf 0 gesetzt sind) und die Geschwindigkeit des Pins (wir benötigen 50MHz, d.h. beide Pins auf „1“), während CNF den Modus festlegt: normaler „Ziehen und Schieben“ – 00, „alternativ“ – 10. Standardmäßig, wie oben zu sehen, ist bei allen Pins das drittniedrigste Bit (CNF0) gesetzt, das sie in den Modus versetzt schwebender Eingang.

Da ich plane, noch etwas mit diesem Chip zu machen, habe ich zur Vereinfachung alle möglichen Werte für MODE und CNF sowohl für das untere als auch das obere Steuerregister definiert.

So sieht das aus

#define CNF0_0 0x00000004
#define CNF0_1 0x00000008
#define CNF1_0 0x00000040
#define CNF1_1 0x00000080
#define CNF2_0 0x00000400
#define CNF2_1 0x00000800
#define CNF3_0 0x00004000
#define CNF3_1 0x00008000
#define CNF4_0 0x00040000
#define CNF4_1 0x00080000
#define CNF5_0 0x00400000
#define CNF5_1 0x00800000
#define CNF6_0 0x04000000
#define CNF6_1 0x08000000
#define CNF7_0 0x40000000
#define CNF7_1 0x80000000
#define CNF8_0 0x00000004
#define CNF8_1 0x00000008
#define CNF9_0 0x00000040
#define CNF9_1 0x00000080
#define CNF10_0 0x00000400
#define CNF10_1 0x00000800
#define CNF11_0 0x00004000
#define CNF11_1 0x00008000
#define CNF12_0 0x00040000
#define CNF12_1 0x00080000
#define CNF13_0 0x00400000
#define CNF13_1 0x00800000
#define CNF14_0 0x04000000
#define CNF14_1 0x08000000
#define CNF15_0 0x40000000
#define CNF15_1 0x80000000

#define MODE0_0 0x00000001
#define MODE0_1 0x00000002
#define MODE1_0 0x00000010
#define MODE1_1 0x00000020
#define MODE2_0 0x00000100
#define MODE2_1 0x00000200
#define MODE3_0 0x00001000
#define MODE3_1 0x00002000
#define MODE4_0 0x00010000
#define MODE4_1 0x00020000
#define MODE5_0 0x00100000
#define MODE5_1 0x00200000
#define MODE6_0 0x01000000
#define MODE6_1 0x02000000
#define MODE7_0 0x10000000
#define MODE7_1 0x20000000
#define MODE8_0 0x00000001
#define MODE8_1 0x00000002
#define MODE9_0 0x00000010
#define MODE9_1 0x00000020
#define MODE10_0 0x00000100
#define MODE10_1 0x00000200
#define MODE11_0 0x00001000
#define MODE11_1 0x00002000
#define MODE12_0 0x00010000
#define MODE12_1 0x00020000
#define MODE13_0 0x00100000
#define MODE13_1 0x00200000
#define MODE14_0 0x01000000
#define MODE14_1 0x02000000
#define MODE15_0 0x10000000
#define MODE15_1 0x20000000

Unsere Pins befinden sich am Port B (Basisadresse – 0x40010C00), Code:

#define _PORTB_(mem_offset) (*(volatile uint32_t *)(0x40010C00 + (mem_offset)))

#define _BRR  0x14
#define _BSRR 0x10
#define _CRL  0x00
#define _CRH  0x04

//используем стандартный SPI2: MOSI на B15, CLK на B13
//LAT пусть будет на неиспользуемом MISO – B14

//очищаем дефолтный бит, он нам точно не нужен
_PORTB_ (_CRH) &= ~(CNF15_0 | CNF14_0 | CNF13_0 | CNF12_0);

//альтернативные функции для MOSI и SCK
_PORTB_ (_CRH) |= CNF15_1 | CNF13_1;

//50 МГц, MODE = 11
_PORTB_ (_CRH) |= MODE15_1 | MODE15_0 | MODE14_1 | MODE14_0 | MODE13_1 | MODE13_0;

Und entsprechend können Definitionen für LAT geschrieben werden, die die Register BRR und BSRR steuern:

/*** LAT pulse – high, then low */
#define LAT_pulse() _PORTB_(_BSRR) = (1<<14); _PORTB_(_BRR) = (1<<14)

#define LAT_low() _PORTB_(_BRR) = (1<<14)

(LAT_low einfach aus Gewohnheit, das war schon immer so, soll so bleiben)

Jetzt ist alles gut, funktioniert aber nicht. Weil dies ein STM32 ist, der Strom spart, müssen wir die Taktung der erforderlichen Peripherie aktivieren.

Aktivierung der Taktung

Für die Taktung sind die Uhren zuständig, ebenso wie der Clock. Und wir haben bereits die Abkürzung RCC bemerkt. Suchen wir sie in der Dokumentation: Das steht für Reset and Clock Control (Reset- und Taktsteuerung).

Wie oben erwähnt, haben die Leute von STM uns glücklicherweise die komplexesten Teile des Taktthemas abgenommen, dafür ein großes Dankeschön (ich gebe erneut den Link zu Di Halt’s Website, um zu verdeutlichen, wie kompliziert das ist). Wir benötigen lediglich die Register, die für die Aktivierung der Taktung der Peripherie (Peripheral Clock Enable Registers) verantwortlich sind. Zuerst finden wir die Basisadresse RCC, die ganz oben in der „Speicherkarte“ zu finden ist:

#define _RCC_(mem_offset) (*(volatile uint32_t *)(0x40021000 + (mem_offset)))

Dann entweder den Link anklicken und in der Tabelle nach etwas suchen, oder viel besser, die Beschreibungen der aktivierenden Register in den Abschnitten über AktivierungsregisterDurchsuchen. Dort finden wir RCC_APB1ENR und RCC_APB2ENR:

Und in diesen befinden sich entsprechend die Bits, die die Taktung von SPI2, IOPB (I/O Port B) und alternativen Funktionen (AFIO) aktivieren.

#define _APB2ENR 0x18
#define _APB1ENR 0x1C

#define IOPBEN 0x0008
#define SPI2EN 0x4000
#define AFIOEN 0x0001

//включаем тактирование порта B и альт. функций
_RCC_(_APB2ENR) |= IOPBEN | AFIOEN;

//включаем  тактирование SPI2
_RCC_(_APB1ENR) |= SPI2EN;

Den finalen Code findet man hier.

Wenn es die Möglichkeit und den Wunsch gibt zu testen, dann verbinden wir DM634 so: DAI zu PB15, DCK zu PB13, LAT zu PB14. Wir speisen den Treiber mit 5 Volt, vergessen nicht, die Masse zu verbinden.

STM8 PWM

PWM auf STM8

Als ich diesen Artikel plante, beschloss ich, zum Beispiel die Funktionen eines mir unbekannten Chips nur anhand des Datenblatts zu erkunden, damit ich nicht wie ein Schuhmacher ohne Schuhe dastehe. Der STM8 eignete sich perfekt für diese Rolle: Erstens hatte ich ein paar chinesische Boards mit STM8S103, und zweitens ist er nicht allzu populär, sodass die Versuchung, im Internet nach einer Lösung zu suchen, an dem Fehlen der Lösungen scheitert.

Der Chip hat auch ein Datenblatt und Referenzhandbuch RM0016, das im ersten Fall die Pinbelegung und die Adressen der Register enthält, im zweiten alles andere. Der STM8 wird in einer etwas eingeschränkten IDE ST Visual Develop.

programmiert.

Standardmäßig arbeitet der STM8 mit einer Frequenz von 2 MHz, das sollte sofort geändert werden.

Der Taktsignal HSI (High-Speed Internal)
stammt von einem internen 16-MHz-RC-Oszillator mit einem programmierbaren Teiler (von 1 bis 8). Er wird im Register für den Taktsignalteiler (CLK_CKDIVR) eingestellt.
Hinweis: Beim Start wird der HSI-RC-Oszillator mit einem Teiler von 8 als Haupttaktquelle gewählt.

Wir suchen die Adresse des Registers im Datenblatt, die Beschreibung im Refman und sehen, dass das Register gelöscht werden muss:

#define CLK_CKDIVR *(volatile uint8_t *)0x0050C6

CLK_CKDIVR &= ~(0x18);

Da wir PWM starten und LEDs anschließen wollen, schauen wir uns die Pinbelegung an:

Der Chip ist klein, viele Funktionen sind an die gleichen Pins gebunden. Das, was in quadratischen Klammern steht, ist "alternativer Funktionsumfang", der durch "Optionsbytes" umgeschaltet wird (Optionsbytes) – etwas wie die Fuses der Atmega. Man kann ihre Werte programmatisch ändern, aber das ist nicht nötig, da die neuen Funktionen nur nach einem Neustart aktiviert werden. Es ist einfacher, den ST Visual Programmer zu verwenden (er wird zusammen mit Visual Develop heruntergeladen), der diese Bytes ändern kann. In der Pinbelegung sieht man, dass die Ausgänge CH1 und CH2 des ersten Timers in quadratischen Klammern versteckt sind; man muss im STVP die Bits AFR1 und AFR0 setzen, wobei das zweite auch den Ausgang CH1 des zweiten Timers von PD4 auf PC5 verschiebt.

So werden insgesamt 6 Pins die LEDs steuern: PC6, PC7 und PC3 für den ersten Timer, PC5, PD3 und PA3 für den zweiten.

Die Konfiguration der I/O-Pins des STM8 ist einfacher und logischer als beim STM32:

• Register für die Datenrichtung DDR (Data Direction Register): 1 = Ausgang;
• Der erste Kontrollregister CR1 legt im Ausgangsbetrieb den Modus „Push-Pull“ (1) oder offenen Kollektor (0) fest; da ich die LEDs mit Kathoden an den Chip anschließe, lasse ich hier 0.
• Der zweite Kontrollregister CR2 legt im Ausgangsbetrieb die Taktschaltungsgeschwindigkeit fest: 1 = 10 MHz

#define PA_DDR     *(volatile uint8_t *)0x005002
#define PA_CR2     *(volatile uint8_t *)0x005004
#define PD_DDR     *(volatile uint8_t *)0x005011
#define PD_CR2     *(volatile uint8_t *)0x005013
#define PC_DDR     *(volatile uint8_t *)0x00500C
#define PC_CR2     *(volatile uint8_t *)0x00500E

PA_DDR = (1<<3); //output
PA_CR2 |= (1<<3); //fast
PD_DDR = (1<<3); //output
PD_CR2 |= (1<<3); //fast
PC_DDR = ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //output
PC_CR2 |= ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //fast

PWM-Einstellung

Zunächst definieren wir die Begriffe:

• PWM-Frequenz – die Frequenz, mit der der Timer tickt;
• Auto-Reload, AR – der automatisch ladende Wert, bis zu dem der Timer zählt (Impulsdauer);
• Update-Ereignis, UEV – ein Ereignis, das auftritt, wenn der Timer bis AR gezählt hat;
• PWM-Duty-Cycle – der Tastverhältnis im PWM, oft als "Tastverhältnis" bezeichnet;
• Capture/Compare-Wert – der Wert für das Erfassen/Vergleichen, bis zu dem der Timer eine Aktion ausführt (im Falle von PWM – invertiert das Ausgangssignal);
• Preload-Wert – vorab geladener Wert. Der Vergleichswert darf sich nicht ändern, solange der Timer tickt, andernfalls würde der PWM-Zyklus fehlerhaft sein. Neue übergebene Werte werden daher in einen Puffer gelegt und von dort abgerufen, wenn der Timer das Ende seiner Zählung erreicht und zurückgesetzt wird;
• Edge-aligned und Center-aligned-Modi – Ausrichtung am Rand und in der Mitte, das entspricht den atmel'schen Fast PWM und Phasen-korrekt PWM.
• OCiREF, Ausgangsvergleichsreferenzsignal – das Referenz-Ausgangssignal, das im PWM-Modus tatsächlich am entsprechenden Pin anliegt.

Wie bereits aus der Pinbelegung ersichtlich, haben zwei Timer – der erste und der zweite – PWM-Funktionalität. Beide sind 16-Bit, der erste hat viele zusätzliche Funktionen (unter anderem kann er sowohl aufwärts als auch abwärts zählen). Wir möchten, dass beide gleich arbeiten, deshalb habe ich beschlossen, mit dem bewusst ärmeren zweiten zu beginnen, um nicht versehentlich etwas zu verwenden, das ihm fehlt. Ein kleines Problem besteht darin, dass die Beschreibung der PWM-Funktionalität aller Timer im Referenzhandbuch im Kapitel über den ersten Timer (17.5.7 PWM-Modus) zu finden ist, sodass ich ständig hin und her springen muss.

PWM auf STM8 hat einen wichtigen Vorteil gegenüber PWM der Atmega:

PWM mit Randausrichtung
Zählkonfiguration aufwärts
Der Zählbetrieb aufwärts ist aktiv, wenn das Bit DIR im Register TIM_CR1 zurückgesetzt ist.
Beispiel
Das Beispiel verwendet den ersten PWM-Modus. Das Referenzsignal PWM OCiREF bleibt auf hohem Niveau, solange TIM1_CNT < TIM1_CCRi. Andernfalls nimmt es ein niedriges Niveau an. Wenn der Vergleichswert im Register TIM1_CCRi größer ist als der Auto-Reload-Wert (Register TIM1_ARR), bleibt das Signal OCiREF auf 1. Wenn der Vergleichswert 0 beträgt, bleibt OCiREF auf null.…

Der Timer STM8 prüft während des Update-Ereignisses zuerst den Vergleichswert, und erst dann gibt er das Referenzsignal aus. Bei Atmega arbeitet der Timer zuerst und vergleicht dann, was dazu führt, dass bei Vergleichswert == 0 Am Ende ergibt sich eine Nadel, mit der man irgendwie umgehen muss (zum Beispiel durch programmatische Inversion der Logik).

Also, was wollen wir tun: 8-Bit PWM (AR == 255), zählen von unten nach oben, Ausrichtung am Rand. Da die Lampen über Kathoden mit dem Chip verbunden sind, sollte PWM 0 (LED leuchtet) bis Vergleichswert und 1 danach ausgeben.

Wir haben bereits über einige PWM-Modigelesen, also suchen wir den entsprechenden Register des zweiten Timers im Referenzhandbuch anhand dieser Phrase (18.6.8 – TIMx_CCMR1):

110: Erster PWM-Modus – beim Zählen von unten nach oben ist der erste Kanal aktiv, solange TIMx_CNT < TIMx_CCR1. Andernfalls ist der erste Kanal nicht aktiv. [weiter im Dokument ein fehlerhafter Copy-Paste aus Timer 1]
111: Zweiter PWM-Modus – beim Zählen von unten nach oben ist der erste Kanal nicht aktiv, solange TIMx_CNT < TIMx_CCR1. Andernfalls ist der erste Kanal aktiv.

Da die LEDs über Kathoden mit dem MK verbunden sind, passt uns der zweite Modus (der erste auch, aber das wissen wir momentan noch nicht).

Bit 3 OC1PE: Auslösen der Vorladung von Ausgang 1
0: Der Vorlade-Register auf TIMx_CCR1 ist ausgeschaltet. Schreiben in TIMx_CCR1 ist jederzeit möglich. Der neue Wert wird sofort wirksam.
1: Der Vorlade-Register auf TIMx_CCR1 ist eingeschaltet. Lese-/Schreiboperationen betreffen das Vorlade-Register. Der vorab geladene Wert von TIMx_CCR1 wird bei jedem Aktualisierungsereignis in das Schattenregister geladen.
*Hinweis: Damit der PWM-Modus korrekt funktioniert, müssen die Vorlade-Register aktiviert sein. Dies ist im Einzelimpulsmodus nicht erforderlich (im Register TIMx_CR1 ist das Bit OPM gesetzt).

Okay, wir aktivieren alles, was für die drei Kanäle des zweiten Timers erforderlich ist:

#define TIM2_CCMR1 *(volatile uint8_t *)0x005307
#define TIM2_CCMR2 *(volatile uint8_t *)0x005308
#define TIM2_CCMR3 *(volatile uint8_t *)0x005309

#define PWM_MODE2   0x70 //PWM mode 2, 0b01110000
#define OCxPE       0x08 //preload enable

TIM2_CCMR1 = (PWM_MODE2 | OCxPE);
TIM2_CCMR2 = (PWM_MODE2 | OCxPE);
TIM2_CCMR3 = (PWM_MODE2 | OCxPE);

AR besteht aus zwei 8-Bit-Registern, hier ist alles einfach:

#define TIM2_ARRH  *(volatile uint8_t *)0x00530F
#define TIM2_ARRL  *(volatile uint8_t *)0x005310

TIM2_ARRH = 0;
TIM2_ARRL = 255;

Der zweite Timer kann nur von unten nach oben zählen, Ausrichtung am Rand, da muss nichts geändert werden. Wir setzen den Frequenzteiler zum Beispiel auf 256. Der Teiler für den zweiten Timer wird im Register TIM2_PSCR eingestellt und ist eine Potenz von zwei:

#define TIM2_PSCR  *(volatile uint8_t *)0x00530E

TIM2_PSCR = 8;

Nun müssen wir die Ausgänge und den zweiten Timer selbst aktivieren. Die erste Aufgabe wird mit den Registern Capture/Compare Aktivieren: es gibt zwei, drei Kanäle sind asymmetrisch verteilt. Hier erfahren wir auch, dass wir die Polarität des Signals ändern können, d.h. grundsätzlich hätte man auch PWM Mode 1 verwenden können. Wir schreiben:

#define TIM2_CCER1 *(volatile uint8_t *)0x00530A
#define TIM2_CCER2 *(volatile uint8_t *)0x00530B

#define CC1E  (1<<0) // CCER1
#define CC2E  (1<<4) // CCER1
#define CC3E  (1<<0) // CCER2

TIM2_CCER1 = (CC1E | CC2E);
TIM2_CCER2 = CC3E;

Und schließlich starten wir den Timer im Register TIMx_CR1:

#define TIM2_CR1   *(volatile uint8_t *)0x005300

TIM2_CR1 |= 1;

Wir werden eine einfache Analogie zu AnalogWrite() schreiben, die dem Timer die Werte zum Vergleichen übergibt. Die Register heißen vorhersehbar Capture/Compare-Register, zwei pro Kanal: die unteren 8 Bit in TIM2_CCRxL und die oberen in TIM2_CCRxH. Da wir einen 8-Bit-PWM-Timer implementiert haben, reicht es aus, nur die unteren Bits zu schreiben:

#define TIM2_CCR1L *(volatile uint8_t *)0x005312
#define TIM2_CCR2L *(volatile uint8_t *)0x005314
#define TIM2_CCR3L *(volatile uint8_t *)0x005316

void setRGBled(uint8_t r, uint8_t g, uint8_t b)
{
    TIM2_CCR1L = r;
    TIM2_CCR2L = g;
    TIM2_CCR3L = b;
}

Ein aufmerksamer Leser wird bemerken, dass wir eine leicht fehlerhafte PWM erhalten haben, die nicht in der Lage ist, 100% Duty Cycle abzugeben (bei einem maximalen Wert von 255 wird das Signal für einen Timerzyklus umgekehrt). Für LEDs spielt das keine Rolle, und der aufmerksame Leser kann sich bereits denken, wie man das behebt.

Die PWM des zweiten Timers funktioniert, jetzt wenden wir uns dem ersten zu.

Der erste Timer hat genau die gleichen Bits in den gleichen Registern (nur die Bits, die im zweiten Timer „reserviert“ waren, werden im ersten aktiv für verschiedene fortgeschrittene Funktionen verwendet). Daher reicht es aus, die Adressen dieser Register im Datenblatt zu finden und den Code zu kopieren. Außerdem muss der Wert des Frequenzteilers geändert werden, da der erste Timer keinen Potenz von zwei, sondern einen genauen 16-Bit-Wert in zwei Registern benötigt. Prescaler High und Niedrig. Wir machen alles und… der erste Timer funktioniert nicht. Was ist das Problem?

Das Problem kann nur gelöst werden, indem wir den gesamten Abschnitt über die Steuerregister des Timers 1 durchsehen, wo wir nach dem suchen, das es im zweiten Timer nicht gibt. Es wird gefunden: 17.7.30 Break register (TIM1_BKR), wo es ein solches Bit gibt:

Den Hauptausgang aktivieren

#define TIM1_BKR   *(volatile uint8_t *)0x00526D

TIM1_BKR = (1<<7);

Jetzt stimmt alles, der Code dort.

STM8 Multiplex

Multiplexing auf STM8

Das dritte Mini-Projekt besteht darin, acht RGB-LEDs im PWM-Modus an den zweiten Timer anzuschließen und verschiedene Farben anzuzeigen. Basierend auf der Konzept des LED-Multiplexings, bei dem es darum geht, dass, wenn wir die LEDs sehr, sehr schnell ein- und ausschalten, es uns so erscheint, als ob sie ständig leuchten (persistence of vision, die Trägheit der visuellen Wahrnehmung). Früher habe ich so etwas auf Arduino gemacht..

Der Arbeitsablauf sieht folgendermaßen aus:

• Wir verbinden die Anode der ersten RGB-LED;
• wir schalten sie ein, indem wir die erforderlichen Signale an die Kathoden senden;
• wir warten auf das Ende des PWM-Zyklus;
• wir verbinden die Anode der zweiten RGB-LED;
• wir schalten sie ein…

Und so weiter. Natürlich ist es für ein schönes Funktionieren erforderlich, dass die Verbindung der Anode und das "Zünden" der LED gleichzeitig stattfinden. Oder fast gleichzeitig. In jedem Fall müssen wir Code schreiben, der in drei Kanälen des zweiten Timers Werte ausgibt, die beim Erreichen von UEV geändert werden und gleichzeitig die aktuell aktive RGB-LED wechseln.

Da das Umschalten der LEDs automatisch erfolgt, müssen wir einen "Videospeicher" erstellen, aus dem der Interrupt-Handler die Daten beziehen kann. Dies ist ein einfacher Array:

uint8_t colors[8][3];

Um die Farbe einer bestimmten LED zu ändern, reicht es aus, die entsprechenden Werte in dieses Array zu schreiben. Die Variable, die für die Nummer der aktiven LED verantwortlich ist, heißt

uint8_t cnt;

Demux

Für das korrekte Multiplexing benötigen wir, erstaunlicherweise, den Demultiplexer CD74HC238. Der Demultiplexer ist ein Chip, der den Operator <<hardwaremäßig implementiert. Über drei Eingangspins (Bits 0, 1 und 2) geben wir ihm eine dreibitige Zahl X, und er aktiviert als Antwort den Ausgang Nummer (1<<X). Die anderen Eingänge des Chips werden zur Skalierung des gesamten Aufbaus verwendet. Wir brauchen diesen Chip nicht nur, um die Anzahl der belegten Pins des Mikrocontrollers zu reduzieren, sondern auch zur Sicherheit – um versehentlich nicht mehr LEDs zu aktivieren, als zulässig ist, und um den mikrokontroller nicht zu zerstören. Der Chip kostet kaum etwas und sollte immer in der Hausapotheke erhältlich sein.

Der CD74HC238 wird dafür zuständig sein, die Spannung zum Anoden der erforderlichen LED zu liefern. Im vollständigen Multiplexbetrieb würde er die Spannung über einen P-MOSFET an eine Spalte liefern, aber in dieser Demo kann es auch direkt erfolgen, da er laut absoluten Höchstwerte Datenblatt 20 mA zieht. Aus dem Datenblatt des CD74HC238

benötigen wir die Pinbelegung und diese Anleitung hier:

H = hoher Spannungspegel, L = niedriger Spannungspegel, X – egal

Wir schließen E2 und E1 an die Erde an, E3, A0, A1 und A3 an die Pins PD5, PC3, PC4 und PC5 des STM8. Da die obere Tabelle sowohl niedrige als auch hohe Pegel enthält, konfigurieren wir diese Pins als Push-Pull-Ausgänge.

PWM

Die PWM am zweiten Timer wird genauso konfiguriert wie in der vorherigen Geschichte, mit zwei Unterschieden: Erstens müssen wir das Interrupt für Update Event (UEV) aktivieren, welches die Funktion aufruft, die die aktive LED umschaltet. Dies geschieht durch Anpassen des Bits Update Interrupt Enable

im Register mit dem sprechenden Namen

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

Interrupt Enable Register Der zweite Unterschied betrifft das Phänomen des Multiplexings, das als – parasitäres Leuchten von Dioden. In unserem Fall kann es auftreten, weil der Timer, der einen Interrupt bei UEV auslöst, weiter tickt und der Interrupt-Handler es nicht rechtzeitig schafft, die LED umzuschalten, bevor der Timer bereits mit dem Schreiben in die Ausgänge beginnt. Um dem entgegenzuwirken, müssen wir die Logik umkehren (0 = maximale Helligkeit, 255 = nichts leuchtet) und extreme Werte der Tastverhältnisse vermeiden. D.h., wir müssen sicherstellen, dass nach UEV die Dioden für einen PWM-Takt vollständig erlöschen.

Polarisierung ändern:

//set polarity 
    TIM2_CCER1 |= (CC1P | CC2P);
    TIM2_CCER2 |= CC3P;

Wir vermeiden es, r, g und b auf 255 zu setzen und denken daran, sie bei der Verwendung umzukehren.

Interrupts

Die Idee eines Interrupts besteht darin, dass der Chip unter bestimmten Umständen die Hauptprogrammverarbeitung stoppt und eine externe Funktion aufruft. Interrupts entstehen durch externe oder interne Einflüsse, einschließlich des Timers.

Als wir zum ersten Mal ein Projekt in ST Visual Develop erstellt haben, erhielten wir neben main.c ein Fenster mit einer mysteriösen Datei stm8_interrupt_vector.c, die automatisch in das Projekt einbezogen wurde. In dieser Datei ist einer Funktion für jeden Interrupt zugewiesen NonHandledInterrupt. Wir müssen unsere Funktion dem entsprechenden Interrupt zuordnen.

Im Datenblatt gibt es eine Tabelle der Interruptvektoren, wo wir die benötigten finden:

13 TIM2 Update/Überlauf
14 TIM2 Capture/Vergleich

Wir müssen die LED bei UEV ändern, also benötigen wir Interrupt Nr. 13.

Daher müssen wir zunächst in der Datei stm8_interrupt_vector.c den Funktionsnamen, der für Interrupt Nr. 13 (IRQ13) standardmäßig zuständig ist, in unseren umbenennen:

{0x82, TIM2_Overflow}, /* irq13 */

Zweitens müssen wir eine Datei main.h mit folgendem Inhalt erstellen:

#ifndef __MAIN_H
#define __MAIN_H

@far @interrupt void TIM2_Overflow (void);
#endif

Und schließlich diese Funktion in unserem main.c:

@far @interrupt void TIM2_Overflow (void)
{
    PD_ODR &= ~(1<<5); // Demultiplexer ausschalten
    PC_ODR = (cnt<<3); // Neues Wert im Demultiplexer speichern
    PD_ODR |= (1<<5); // Demultiplexer einschalten

    TIM2_SR1 = 0; // Update Interrupt Pending Flag zurücksetzen

    cnt++; 
    cnt &= 7; // LED-Zähler bewegen

    TIM2_CCR1L = ~colors[cnt][0]; // Invertierte Werte in den Puffer übergeben
    TIM2_CCR2L = ~colors[cnt][1]; // Für den nächsten PWM-Zyklus
    TIM2_CCR3L = ~colors[cnt][2]; // 

    return;
}

Es bleibt, die Interrupts zu aktivieren. Das geschieht mit dem Assemblerbefehl rim – ihn müssen wir in Programmiertutorial:

//enable interrupts
_asm("rim");

Ein anderer Assemblerbefehl – sim – schaltet die Interrupts aus. Sie müssen während der Speicherung neuer Werte im „Videospatial“ deaktiviert werden, damit ein unglücklicher Moment des Interrupts das Array nicht beschädigt.

Der gesamte Code – auf GitHub.

Wenn dieser Artikel auch nur einer Person nützlich ist, dann habe ich ihn nicht umsonst geschrieben. Ich freue mich auf Kommentare und Anmerkungen und werde versuchen, auf alles zu antworten.

Quelle: habr.com