Über den Beitrag

In diesem Beitrag gehe ich auf den Mikrocontroller LGT8F328P ein und zeige, wie ihr auf ihm basierende Entwicklungsboards der Version LQFP32 in der Arduino Umgebung programmiert. Da der LGT8F328P dem ATmega328P nicht nur namentlich nahesteht, werde ich vor allem die Unterschiede erläutern.

Folgendes kommt auf euch zu:

• Überblick
• Vorteile gegenüber dem ATmega328P
• Pinout der LGT8F328P-LQFP32 basierten Boards
• Installation der Board Pakete
• LGT8F328P-LQFP32 Boards in Action
  • Analog-Digital Wandler
    • Qualität des AD-Wandlers
    • Analoge Differenzmessungen und Verstärkung
  • Digital-Analog Wandler
    • Genauigkeit des DAC
  • 80 mA Ausgänge nutzen
  • Watchdog Timer
  • Schlaf- und Power-Modi
  • Fastio – Funktionen
  • Timer und PWM
• Den LGT8F328P basierten Pro Mini programmieren
  • Upload per USB-zu-TTL Adapter (mit Bootloader)
  • Upload per LarduinoISP (ohne Bootloader)
• Fazit

Überblick

Der LGT8F328P wird von dem chinesischen Unternehmen LogicGreen (mittlerweile anscheinend: Prodesign Semiconductor) hergestellt. Er ist mit dem AVR-Befehlssatz und dem ATmega328P weitestgehend kompatibel. Dabei ist der LGT8F328P günstiger und weist gegenüber dem ATmega328P einige technische Vorteile und zusätzliche Funktionen auf. Deshalb verwundert es nicht, dass er dafür verwendet wurde, Pendants zum Arduino UNO R3, Arduino Nano 3 und Arduino Pro Mini zu entwickeln. Und genau diese Boards behandle ich in diesem Beitrag.

Am weitesten verbreitet sind die Nano und Pro Mini kompatiblen Boards, die ihr unter der Bezeichnung „LGT8F328P LQFP32 MiniEVB“ in Online-Shops für wenige Euro bekommt. Das von mir getestete Arduino UNO kompatible Board stammt von AZ-Delivery. Es ist in einigen Aspekten etwas anders als die anderen Boards.

Den LGT8F238P IC gibt es als SSOP Ausführung mit 20 Pins (SSOP20), als QFP mit 48 Pins (QFP48L) oder als QFP mit 32 Pins (QFP32L). In diesem Beitrag behandele ich nur QFP32L basierten Boards, die den ATmega328P basierten Vertretern am nächsten stehen. Meistens sind sie mit dem Aufdruck „LQFP32“ versehen. In einem Folgebeitrag werde ich noch einmal auf alle drei Ausführungen eingehen. Sie besitzen dieselben Register und unterscheiden sich im Wesentlichen nur darin, welche Funktionen durch Pins tatsächlich zugänglich sind.

Das Pinout Schema des QFP32L zeigt viele Übereinstimmungen mit dem des ATmega328, aber auch ein paar zusätzliche Funktionen.

Ein gewisser Nachteil beim Arbeiten mit dem LGT8F328P ist, dass der Hersteller kein englisches Datenblatt zur Verfügung stellt. Dank einiger fleißiger Mitmenschen gibt es aber Übersetzungen, beispielsweise hier auf GitHub. 

Vorteile gegenüber dem ATmega328P

Ich möchte hier nicht alle technischen Eigenschaften des LGT8F328P „herunterbeten“. Wie der ATmega328P hat er 2 KB SRAM, 32 KB Flash, die Versorgungsspannung liegt zwischen 1.8 und 5.5 Volt usw.

Deswegen hier eine Auswahl wichtiger Unterschiede zum ATmega328P (ohne Anspruch auf Vollständigkeit):

Pinout der LGT8F328P-LQFP32 basierten Boards

Vergleicht man die LGT8F328P Boards mit ihren ATmega328P Pendants, muss man schon zweimal hinschauen, um Unterschiede zu erkennen. Das gilt insbesondere für die Pinbezeichnungen. Hier seht ihr einen originalen Arduino Nano (blau), umrahmt von zwei LGT8F328P Nano Boards:

Auch hinsichtlich der Pinfunktionen gibt es große Übereinstimmungen mit den Originalen:

Ein entsprechendes Schema für den LGT8F328P basierten Pro Mini findet ihr beispielsweise hier. Für das von mir getestete Board im Arduino UNO Stil (Bezugsquelle: AZ-Delivery) habe ich kein solches Schema gefunden. Das sollte aber kein Problem sein, da der UNO die gleichen Ausgänge hat. Lediglich SWC und SWD sind nicht ausgeführt.

Installation der Board Pakete

Nano / Pro Mini Style

Um die LGT8F328P Boards mit der Arduino IDE programmieren zu können, müsst ihr zunächst ein geeignetes Board Paket installieren. Für den „L-Nano“ (als Abkürzung für „LGT8F328P basiert“) und den „L-Pro Mini“ habe ich das großartige Board Paket lgt8fx von David Buezas verwendet. Es basiert auf Larduino_HSP und LGT ist aber einfacher handhabbar, nutzt die Vorteile des LGT8F328P besser und ist besser dokumentiert. Mehr zu den Unterschieden erfahrt ihr hier.

Eine detaillierte Installationsanleitung für das Board Paket mit Screenshots findet ihr hier. Die Kurzversion lautet:

• Geht auf Datei → Voreinstellungen.
• Klickt auf den Button hinter „Zusätzliche Boardverwalter-URLs“.
• Tragt dort die Zeile „https://raw.githubusercontent.com/dbuezas/lgt8fx/master/package_lgt8fx_index.json“ (ohne Anführungsstriche) ein.
• Navigiert zu Werkzeuge → Board: „xxx“ → Boardverwalter.
• Sucht nach „lgt8fx“ und installiert das Paket „LGT8fx Boards“ von dbuezas.

Nach erfolgreicher Installation wählt ihr als Board „LGT8F328“. Unter „Variant“ habe ich „328P-LQFP32 (e.g. MiniEVB nano-style or WAVGAT)“ ausgewählt. 

UNO Style

Für das UNO Board von AZ-Delivery verfahrt ihr im Prinzip genauso. Der Eintrag für die Boardverwalter-URL lautet:

• http://www.az-arduino.de/package_AZ-Boards_index.json

Im Boardverwalter Menü sucht ihr nach „AZ-Boards“. Eine detaillierte Beschreibung gibt es im kostenlosen E-Book von AZ-Delivery.

Prüfung der Installation

Nehmt irgendeinen Sketch, beispielsweise Blink.ino aus den „Basics“ Beispielsketchen der Arduino IDE und ladet ihn hoch. Die Board-LED sollte im Sekundentakt blinken.

Wie ihr Sketche per USB-zu-TTL Adapter (z.B. für den Pro Mini) oder per LGTISP hochladet und den Bootloader brennt, erkläre ich gegen Ende des Beitrages (hier). 

LGT8F328P-LQFP32 Boards in Action

Genug der Vorbereitungen und allgemeinen Erklärungen – jetzt kommen wir zum interessanteren, praktischen Teil.

Ich habe sehr viele Arduino Sketche mit unterschiedlichsten Funktionen unverändert auf den LGT8F328P Boards ausprobiert. Lediglich beim Watchdog Timer und bei den Sleep-Funktionen waren Anpassungen notwendig. Alles andere funktionierte 1:1. Im Wesentlichen können wir uns also auf die zusätzlichen Funktionen konzentrieren.

Analog-Digital Wandler

Ihr könnt, wie bei den ATmega328P basierten Boards, die Spannung an einem analogen Pin per analogRead() auslesen. Die Voreinstellung für die Auflösung ist 10 Bit. Die Standard-Referenzspannung ist die Betriebsspannung.

Dabei ist zu beachten, dass das „Nano-like“ Board eine Diode zum Schutz des USB-Ports in der 5 Volt-Leitung verbaut hat. Die effektive Betriebsspannung liegt deshalb bei USB-Betrieb bei ca. 4.6 Volt. Ihr findet die Diode oberhalb der Pins D10 / D11.

Wie bei den herkömmlichen ATmega328P Boards könnt ihr externe Spannungsreferenzen verwenden. Ihr schließt sie an den Eingang REF an. Alternativ stellt der LGT8F328P interne Referenzen von 1.024, 2.048 oder 4.096 Volt zur Verfügung. Überdies erlaubt euch der LGT8F328P, die Auflösung auf 11 oder 12 Bit zu erhöhen. Der folgende Sketch zeigt, wie es geht:

/*
    Parameter:      Reference:
    DEFAULT         VCC
    EXTERNAL        External Reference (REF)
    INTERNAL1V024   Internal 1.024 volts
    INTERNAL2V048   Internal 2.048 volts
    INTERNAL4V096   Internal 4.096 volts
*/

void setup(){
    Serial.begin(9600);
    analogReference(INTERNAL4V096);
    analogReadResolution(10); // Resolution = 10, 11 or 12 Bit
}
void loop(){
    int adcValue = analogRead(A1);  // Raw value 
    float voltage = adcValue * 4.096/1024.0;  // Voltage calculation
    Serial.print("Analog Value: ");
    Serial.println(adcValue);
    Serial.print("Voltage [V]: ");
    Serial.println(voltage,3);
    delay(1000);      
}

Qualität des AD-Wandlers

Die gute Nachricht: Der AD-Wandler des LGT8F328P arbeitet ziemlich linear. Die schlechte Nachricht: Das Rauschen ist mindestens so schlecht wie bei den AVR basierten Boards. Selbst in der 10 Bit Auflösung musste ich mindestens 100 Messwerte mitteln, um stabile Werte zu erhalten. Da nützt einem eine 11- oder 12-Bit Auflösung leider herzlich wenig! Evtl. lässt sich das Rauschen noch durch Stabilisierung der Versorgungsspannung senken, da muss ich noch mal ein wenig experimentieren.

Konzentrieren wir uns auf das Positive. Ich habe den AD-Wandler geprüft, indem ich mit meinem Labornetzteil Spannungen vorgegeben und mit dem LGT8F328P gewandelt habe. Die Spannungen habe ich mit einem zuverlässigen Multimeter überprüft. Bei der A/D-Wandlung kam die interne 4.096 Volt Referenz zum Einsatz und je 100 Messwerte wurden gemittelt. Die Messung habe ich mit verschiedenen Boards durchgeführt. Hier ein typisches Ergebnis:

Jedes Board hatte eine individuelle, geringe und reproduzierbare Abweichung. Wer es genau braucht, der könnte sich also mit Excel o. ä. eine Ausgleichsfunktion erstellen.

Analoge Differenzmessungen und Verstärkung

Der LGT8F328P ermöglicht euch Differenzmessungen zwischen bestimmten analogen Eingängen. Die Differenzspannungen könnt ihr 1-, 8-, 16- oder 32-fach verstärken. Die Funktion dazu lautet analogDiffRead(). Sie erwartet als Argumente den negativen Eingang, den positiven Eingang und den Verstärkungsfaktor. Um die Funktion nutzen zu können, müsst ihr die Bibliotheksdatei differential_amplifier.h einbinden.

Hier ein Beispiel:

#include<differential_amplifier.h>
/*
    Parameter:      Reference:
    DEFAULT         VCC
    EXTERNAL        External Reference (REF)
    INTERNAL1V024   Internal 1.024 volts
    INTERNAL2V048   Internal 2.048 volts
    INTERNAL4V096   Internal 4.096 volts

 Available combinations:
| -\+ | A0  | A1  | A2  | A3  | A4  | A5  | A6  | A7  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | 
| A0  |     |  +  |     |     |     |     |     |     |
| A1  |  +  |     |     |     |     |     |     |     |
| A2  |  +  |  +  |     |  +  |  +  |  +  |  +  |  +  |
| A3  |  +  |  +  |  +  |     |  +  |  +  |  +  |  +  |
| A4  |  +  |  +  |     |     |     |     |     |     |
| A5  |  +  |  +  |     |     |     |     |     |     |
| A6  |  +  |  +  |     |     |     |     |     |     |
| A7  |  +  |  +  |     |     |     |     |     |     |
*/

void setup(){
    Serial.begin(9600);
    analogReference(INTERNAL4V096); 
}
void loop(){
    int raw = analogDiffRead(A2,A3,GAIN_16); // GAIN_x mit x = 1, 8, 16, 32
    float voltage = raw / 1024.0 * 4096.0 / 16.0; // considers resolution, reference and gain
    Serial.println(voltage);
    delay(1000);      
}

Wie ihr an der Tabelle im Sketch seht, sind nur bestimmte Kombinationen analoger Eingänge erlaubt. Wählt ihr eine unzulässige Kombination, erhaltet ihr als Rohwert -1.

Die Dokumentation zur Differential Amplifier Bibliothek findet ihr hier.

Um differential_amplifier.h mit dem LGT8F328P basierten UNO von AZ-Delivery zu nutzen, ladet ihr euch am einfachsten das Paket lgt8fx von hier herunter und extrahiert die entsprechenden „.cpp“- und „h.“-Dateien aus dem Ordner lgt8f/libraries/differential_amplifier und speichert sie Ordner des Sketches. Bei der #include Anweisung müsst ihr die Bibliotheksdatei in Anführungsstriche setzen.

Digital-Analog Wandler

„Quasi-analoge“ PWM Signale

Wie von den ATmega328P Boards gewohnt, könnt ihr mit analogWrite() an den (Arduino) Pins 3, 5, 6, 9, 10 und 11 ein PWM-Signal abgreifen. Ebenso ist die PWM-Frequenz an den Pins 5 und 6 doppelt so hoch wie an den anderen Pins. Zu beachten ist, dass die Frequenzen von der Taktrate abhängen. Bei 16 MHz entsprechen sie mit 490 bzw. 980 Hertz denen der ATmega328P Boards. Der Wert ändert sich proportional mit der Taktrate.

Wie ihr an den Pins 1 (TX) und 2 (D2) PWM Signale erzeugt, erkläre ich, wenn wir zu den Timern kommen. Einige Pinout Schemata, die man im Netz findet, weisen zusätzlich den Pin 8 als PWM Pin aus. Das ist jedoch falsch.

Ein echtes analoges Signal erzeugen

Am Pin 4 (D4 / PD4 / DAO) könnt ihr ein echtes analoges Signal mit einer Auflösung von 8 Bit einstellen. Standardmäßig ist VCC die Referenz, sprich 255 ≙ VCC.  Alternativ könnt ihr eine externe Referenz oder die internen Referenzen 1.024, 2.048 oder 4.096 Volt nutzen. Der folgende kleine Sketch zeigt, wie es funktioniert:

/*
    Parameter:      Reference:
    DEFAULT         VCC
    EXTERNAL        External Reference (REF)
    INTERNAL1V024   Internal 1.024 volts
    INTERNAL2V048   Internal 2.048 volts
    INTERNAL4V096   Internal 4.096 volts
*/

void setup(){
    analogReference(DEFAULT); 
    pinMode(DAC0, ANALOG);
    analogWrite(DAC0, 125); // 0...255
}
void loop(){}

Genauigkeit des DAC

Ich habe die Genauigkeit des analogen Signals unter Verwendung der 4.096 Volt Referenz überprüft und war von der Übereinstimmung zwischen kalkulierten und gemessenen Wert ziemlich beeindruckt:

80 mA Ausgänge nutzen

Wegen der Doppeldeutigkeit der unterschiedlichen Pinbezeichnungen (z.B. 1 vs. TX vs. PD1 vs. D1) verwende ich im Folgenden die Bezeichnungen auf dem LGT8F328P Nano Board, wenn ich mich auf die Boardpins beziehe.

Die Pins TX,  D2, D5 und D6 sind bis zu 80 mA belastbar. Allerdings müsst ihr diese „Hochstrom“-Funktion erst aktivieren, indem ihr die entsprechenden Bits im HDR Register setzt. Dann könnt ihr – jedenfalls für die Pins D5 und D6 – die Ausgänge mit pinMode() und digitalWrite() nutzen. Hier ein Beispiel:

/*
       HDR      Port/Pin     Pin Label (Nano)
       HDR0 --> PD5       --> D5
       HDR1 --> PD6       --> D6
       HDR2 --> PF1       --> TX
       HDR3 --> PF2       --> D2 
       HDR4 --> PE4 / PF4 --> none
       HDR5 --> PE5 / PF5 --> none 
*/

void setup(){    
    HDR |= (1<<HDR0); // Activate high current for Pin 5
    pinMode(5,OUTPUT);
    digitalWrite(5, HIGH);
}
  
void loop(){}

Wenn ihr die 80 mA Option an den Pins TX und D2 aktivieren wollt, dann gibt es eine kleine Komplikation. PD1 und PF1 teilen sich TX, PD2 und PF2 teilen sich D2 (was eine eindeutige Benennung der Pins noch schwieriger macht). Die Hochstromoption wird aber nur an PF1 und PF2 bereitgestellt und nicht an PD1 oder PD2. Da aber PF1 und PF2 nicht als Arduino Pins implementiert sind (beim QFP32L), müsst ihr sie direkt über die Ports ansprechen. Hier ein „Hochstrom-Blink-Sketch“ für PF2:

/*
       HDR     Port/Pin      Pin Label (Nano)
       HDR0 --> PD5       --> D5
       HDR1 --> PD6       --> D6
       HDR2 --> PF1       --> TX
       HDR3 --> PF2       --> D2 
       HDR4 --> PE4 / PF4 --> none
       HDR5 --> PE5 / PF5 --> none 
*/


void setup(){    
/* example for activating PF2 for high current */
    HDR |= (1<<HDR3);
    DDRF = (1<<PF2);  // ~ pinMode OUTPUT
}
  
void loop(){
    PORTF |= (1<<PF2); // Pin HIGH
    delay(1000);
    PORTF &= ~(1<<PF2); // Pin LOW
    delay(1000); 
}

Aber hier ist Vorsicht geboten: Wenn PF1 oder PF2 sich im Zustand OUTPUT / HIGH befinden und PD1 bzw. PD2 auf OUTPUT / LOW könntet ihr einen Kurzschluss verursachen (ausprobiert habe ich es nicht). Und PD1 könntet ihr versehentlich über seine TX-Funktion in diesen Zustand bringen.

Falls ihr euch mit Bitoperationen und Portmanipulationen wie beispielsweise PORTF &= ~(1<<PF2) nicht auskennt, empfehle ich meinen Beitrag zu diesem Thema. 

Watchdog Timer (WDT)

Vielleicht hat der/die eine oder andere meinen Beitrag über den Watchdog Timer des ATmega328P gelesen. Die Sketche funktionieren auf den LGT8F328P Boards nur eingeschränkt. Wenn ihr den WDT verwenden wollt, dann nutzt ihr am besten die im Board Paket lgt8fx enthaltene Bibliothek WDT (anstelle avr/wdt.h). Hier ein Beispielsketch:

/*
    Parameter   WDT Reset Period
    WTO_64MS         64 ms   
    WTO_128MS       128 ms
    WTO_256MS       256 ms
    WTO_512MS       512 ms
    WTO_1S            1 s
    WTO_2S            2 s
    WTO_4S            4 s
    WTO_8S            8 s
    WTO_16S          16 s
    WTO_32S          32 s
*/

#include <WDT.h>

void setup() {
    Serial.begin(9600);
    Serial.println("Sketch started");
    wdt_enable(WTO_8S);
}

void loop() {
    for(int i=0; i<1000; i++){
        Serial.print("Runtime [s]: ");
        Serial.println(i);
        delay(1000);
//        wdt_reset();
    }
}

Nach jeweils acht Sekunden wird ein Neustart ausgelöst. Wenn ihr jedoch die Zeile 28 entkommentiert, läuft der Sketch durch.

WDT Interrupt

Um die WDT ISR zu nutzen, verwendet ihr die Funktion wdt_ienable(). Hier ein Beispiel:

#include <WDT.h>

volatile boolean isrflag;

void setup() {
    pinMode(LED_BUILTIN, OUTPUT);
    digitalWrite(LED_BUILTIN, LOW);
    Serial.begin(9600);
    Serial.println("Sketch started.");
    isrflag = false;
    wdt_ienable(WTO_4S);
}

void loop() {
    int n = 0;
    do {
        Serial.print("Elapsed time: ");
        Serial.print(n);
        Serial.println(" s");
        delay(1000);
        if (digitalRead(LED_BUILTIN)) 
            digitalWrite(LED_BUILTIN, LOW );
        else
            digitalWrite(LED_BUILTIN, HIGH);
        if (isrflag) {
            Serial.println("--There was a wdt interrupt.--");
            isrflag = false;
            wdt_enable(WTO_4S); // uncomment this line...
            // wdt_ienable(WTO_4S);   // ...comment this line and see the change
        }
        // wdt_reset(); // if uncommented, no interrupt will occur
    } while( n++ < 1000 );
}

ISR (WDT_vect)
{
    isrflag = true;
    wdt_reset();
}

Wenn ihr den LGT8F328P nach dem Interrupt nicht neu starten wollt, dann wechselt in Zeile 28/29 von wdt_enable() auf wdt_ienable().

Schlaf- und Power-Modi

Wenn ihr euer LGT8F328P Board in den Schlaf schicken wollt, dann nutzt ihr am besten die im Board Paket enthaltene Bibliothek PMU.

Um den folgenden Beispielsketch auszuprobieren, verbindet ihr Pin 2 (D2) über einen Taster mit GND. Mit den im Sketch gewählten Einstellungen wird euer Board in den Schlaf geschickt, wacht nach vier Sekunden wieder auf, um dann wieder in den Schlaf geschickt zu werden usw. Drückt ihr den Taster, wacht euer Board durch den externen Interrupt sofort auf.

/*
    Power Modes
    PM_IDLE0:     disable core clock only
    PM_POWERDOWN: disable most clocks and switch main clock to rc32k
    PM_POFFS0:    power off all core functions (digital and analog)
                  wake up by external interrupt or periodly
    PM_POFFS1:    the lowest power mode which close all modules and clocks 
                  wake up by external interrupt only

    Sleep Duration:
    SLEEP_xMS with x = 64, 128, 256, 512 (milliseconds), e.g. SLEEP_256MS
    SLEEP_yS  with y = 1, 2, 4, 8, 16, 32 (seconds), e.g. SLEEP_4S
    SLEEP_FOREVER
*/

#include <PMU.h>
const int interruptPin = 2;

void setup(){
    Serial.begin(9600);
    Serial.println("Sketch started!");
    pinMode(interruptPin, INPUT);
    digitalWrite(interruptPin, HIGH); 
    attachInterrupt(digitalPinToInterrupt(interruptPin), noAction, FALLING); 
}
 
void loop(){
    Serial.flush();
    PMU.sleep(PM_POWERDOWN, SLEEP_4S);
    Serial.println("Woke Up!");
    delay(200); // for debouncing 
}

void noAction(){} // dummy

Fastio – Funktionen

Die Funktionen pinMode(), digitalWrite() und digitalRead() haben eine ganze Menge Ballast, den man in den meisten Fällen nicht braucht. Wenn ihr ein paar Mikrosekunden einsparen wollt, dann könnt ihr die schon erwähnte Portmanipulation anwenden. Wem das zu kryptisch ist, dem stehen fastioMode(), fastioWrite(), fastioRead() und fastioToggle() als Alternativen zur Verfügung.

Der Nachteil an den Funktionen ist, dass ihr ihnen keine Variablennamen übergeben dürft, sondern nur die Pinnummer. Versucht ihr es trotzdem, hagelt es Fehlermeldungen.

Hier ein Beispiel für den korrekten Gebrauch:

void setup() {
    fastioMode(8, OUTPUT); // equals: DDRB |= (1<<PB0);
}

void loop() {
    fastioWrite(8, HIGH); // equals (in essence): PORTB |= (1<<PB0);
    delay(100);
    fastioWrite(8, LOW);  // equals (in essence): PORTB &= ~(1<<PB0);
    delay(100);
    fastioToggle(8); // equals: PINB = (1 << PB0);
    delay(1000);
    fastioToggle(8); // equals: PINB = (1 << PB0);
    delay(1000);
}

Die Verwendung von fastioRead() ist genauso einfach:

int status = fastioRead(8); // equals: int status = (PINB >> PB0) & 1;

Die fastio-Funktionen sind kein besonderes Merkmal des LGT8F32P, sondern nur ein nettes Feature des Board Paketes. 

Timer und PWM

Der LGT8F328P besitzt zwei 8-Bit und zwei 16-Bit Timer, also einen 16-Bit Timer mehr (Timer3) als der ATmega328P. Zu den Timern 0 bis 2 gehören je zwei Output Compare Register, mit deren Hilfe ihr an den zugeordneten Ausgängen OCxA/OCxB PWM Signale erzeugen könnt. Wie das funktioniert, habe ich in meinen Beiträgen über die Timer0 und Timer1 und über den Timer2 erklärt. Alle dort verwendeten Sketche funktionieren auch auf dem LGT8F328P.

Zum Timer3 gehören drei Output Compare Register und die drei Ausgänge OC3A, OC3B und OC3C.

Das Pinoutschema des LGT8F328P-QFP32L (siehe ganz oben) ist diesbezüglich etwas irreführend. Richtig ist, dass OC3C keinen Ausgangspin hat. Ebenso stimmt, dass OC3A und OC3B an den Pins für PD1 und PD2 ausgeführt sind. Um ein PWM Signal auszugeben, müsst ihr allerdings PF1 und PF2 auf OUTPUT setzen. PF1 und PF2 teilen sich, wie schon erwähnt, ihre Ausgänge mit PD1 und PD2.

Hier ein Beispiel für ein Fast PWM Signal an PF1 (Board Pin: TX) mit einem Duty Cycle von 25 % und einer PWM-Frequenz von 2 kHz (wenn der LGT8F328P auf 32 MHz läuft):

void setup(){ 
  // Clear OC3A on Compare Match / Set OC3A at Bottom; Wave Form Generator: Fast PWM 14, Top = ICR3
  TCCR3A = (1<<COM3A1) + (1<<WGM31); 
  TCCR3B = (1<<WGM33) + (1<<WGM32) + (1<<CS30); // prescaler = 1; 
  ICR3 = 15999;
  OCR3A = 3999;
  DDRF |= (1<<PF1);
} 

void loop() {} 

Weitere Erklärungen würden hier zu weit führen – bei Interesse schaut in die schon erwähnten Beiträge über die Timer des ATmega328P. Oder, wer keine Lust hat zu rechnen und sich die ganzen Bits aus den Tabellen herauszusuchen, mag vielleicht dieses tolle Tool von David Buezas ausprobieren: Arduino Web Timers. Die Dokumentation dazu gibt es hier auf GitHub.

Ihr könnt den Timer0 und Timer1 Counter übrigens auch auf die doppelte Systemfrequenz einstellen, also auf bis zu 64 MHz! Dazu müsst ihr im „Timer Counter Clock Control und Status Register“ (TCKCSR) das F2XEN-Bit setzen. Durch Setzen der Bits TC2XS0 für Timer0 bzw. TC2XS1 für Timer1 teilt ihr dem LGT8F328P mit, welcher Timer auf doppelter Geschwindigkeit laufen soll. Also z.B.:

TCKCSR = (1 << F2XEN) | (1 << TC2XS0);

Ein Grund mehr, das Tool von David Buezas einzusetzen.

Den LGT8F328P basierten Pro Mini programmieren

Upload per USB-zu-TTL Adapter

Dem Pendant zum Arduino Pro Mini („L-Pro Mini“) fehlt, genau wie dem Original, der USB-zu-TTL Adapter. Ihr braucht also einen solchen als externes Modul. Die Programmierung ist am bequemsten, wenn ihr einen Adapter mit DTR Pin nehmt. 

Der hier abgebildete Adapter hat zudem den Vorteil, dass ihr ihn direkt auf den „L-Pro Mini“ stecken könnt, sofern ihr zuvor eine Pinleiste aufgelötet habt.

Solltet ihr hingegen alles per Kabel zusammenstecken, müsst ihr darauf achten, dass ihr RX mit TX und TX mit RX verbindet.

Der Upload ist einfach: Wählt den Port aus, an dem euer Adapter hängt und dann einfach hochladen.

Falls ihr einen USB-zu-TTL Adapter ohne DTR-Pin habt, ist es ein kleines bisschen komplizierter. Wenn ihr den Hochladevorgang einleitet, dann drückt ihr auf die Reset-Taste des zu programmierenden Boards. Lasst die Taste los, wenn die Kompilierung beendet ist und das eigentliche Hochladen starten soll.

Upload per LArduinoISP (ohne Bootloader)

Wie wir schon gesehen haben, weist der LGT8F328P bei aller Kompatibilität mit dem ATmega328P „unter der Haube“ deutliche Unterschiede auf. Das zeigt sich auch darin, dass er nicht über seine Pins 11, 12 und 13 per ISP programmierbar ist. Stattdessen besitzt er zu diesem Zweck die Pins SWC und SWD.

Aber wie beim ATmega328P, könnt ihr auch ein LGT8F328P basiertes Board zu einem ISP Programmer umfunktionieren.

Für den „LGT8F328P – UNO“ von AZ-Delivery macht das wenig Sinn, da dieses Board den SWC und SWD-Pin nicht ausgeführt hat. 

Ein LGT8F328P Board zum Programmer machen

Ihr nehmt das LGT8F328P basiertes Board, das als Programmer dienen soll und verbindet es mit eurem Rechner. Schließt am besten nichts weiter an das Board an. Dann führt ihr die folgenden Schritte aus:

• Wählt in der Arduino IDE das angeschlossene Board aus.
• Unter Werkzeuge → „Arduino as ISP“ stellt ihr die Option „[To burn an ISP] SERIAL_RX_BUFFER_SIZE to 250“ ein (s.u., blaue Auswahl).
• Geht im Menü auf Datei → Beispiele → „Beispiele für LGT8F328“ und wählt dort den Sketch LarduinoISP aus.
• Ladet den Sketch hoch.
• Stellt „Arduino as ISP“ in den Werkzeugen wieder zurück auf Default (64).

Fertig ist der Programmer!

Sketche hochladen

Nehmt euren Programmer und verbindet ihn wie folgt mit dem zu programmierenden Board („Target“):

Um beim Upload auf das Target einen Reset des Programmers zu verhindern, verbindet ihr den RST-Pin des Programmers über einen 10 µF Kondensator mit dem 5 V Pin. Notfalls könnt ihr die beiden Pins auch direkt verbinden, dann dürft ihr aber keinesfalls den Reset-Knopf des Programmers drücken (Kurzschluss!).

So sieht das Ganze beispielsweise mit einem „L-Nano“ als Programmer und einem „L-Pro Mini“ als Target aus:

Wählt die folgenden Einstellungen in der Arduino-IDE:

• Als Board wählt ihr das Target-Board aus.
• Unter Werkzeuge → Programmer wählt ihr „AVR ISP“.

Zum Hochladen geht ihr dann auf Sketch → Hochladen mit Programmer oder ihr verwendet die Tasten-Kombi: Strg + Umschalt + U.

Den Bootloader zurückbringen

Wenn ihr einen Sketch per LarduinoISP hochgeladen habt, dann ist der Bootloader gelöscht. Um das Board wieder direkt per USB bzw. USB-zu-TTL Adapter programmieren zu können, müsst ihr den Bootloader zurückbringen. Nichts einfacher als das: Verwendet dieselben Einstellungen wie beim Hochladen per LarduinoISP-Programmer und geht auf Werkzeuge → Bootloader brennen.

Probleme mit dem lilafarbenen LQFP32 Board als LArduinoISP Programmer

Das lilafabene LQFP32 Board mit dem CH9340C USB-zu-TTL Chip lässt sich aus mir bisher nicht bekannten Gründen nicht als LArduinoISP Programmer einsetzen.

Fazit

LGT8F328P basierte Boards sind eine leistungsstarke Alternative zu ihren ATmega328P Pendants. Dank der verfügbaren Board Pakete sind die LGT8F328P Boards einfach zu handhaben. Sketche, die ihr für die ATmega328P Boards geschrieben habt, sind mit wenigen Ausnahmen direkt übertragbar. Dazu bietet der LGT8F328P einige zusätzliche, sinnvolle Features.

Danksagung

Ich danke David Buezas, LaZsolt und dwillmore für die hervorragende Arbeit an dem Board Paket lgt8fx und für das Review dieses Artikels.