- \r\n
- Analog to digital converter<\/a>\r\n
- \r\n
- AD converter quality<\/a><\/li>\r\n
- Analog differential measurements and gain<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Digital to analog converter<\/a>\r\n
- \r\n
- Accuracy of the DAC<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Using 80 mA outputs<\/a><\/li>\r\n
- Watchdog timer<\/a><\/li>\r\n
- Sleep and power modes<\/a><\/li>\r\n
- Fastio functions<\/a><\/li>\r\n
- Timer and PWM<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Programming the LGT8F328P based “Pro Mini”<\/a>\r\n
- \r\n
- Upload via USB-to-TTL Adapter (with bootloader)<\/a><\/li>\r\n
- Upload via LarduinoISP (without Bootloader)<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Conclusion<\/a><\/li>\r\n<\/ul>\r\n\n
Overview<\/h2>\n\n
The LGT8F328P is manufactured by the Chinese company LogicGreen<\/a> (rebranded to: Prodesign Semiconductor). It is widely compatible with the AVR instruction set and the ATmega328P. The LGT8F328P is cheaper and has some technical advantages and additional functions compared to the ATmega328P. Therefore, it is not surprising that it was used to develop counterparts to the Arduino UNO R3, Arduino Nano 3 and Arduino Pro Mini. And it is these boards that I cover in this post.<\/p>\r\n
The most common are the Arduino Nano and Pro Mini compatible boards, which can be found as “LGT8F328P LQFP32 MiniEVB” in online stores for a few Euros. The Arduino UNO compatible board I tested is from AZ-Delivery<\/a>. It is a bit different from the other boards in some aspects.<\/p>\r\n\n
The LGT8F238P IC is available as an SSOP version with 20 pins (SSOP20), as QFP with 48 pins (QFP48L) or as QFP with 32 pins (QFP32L). In this article, I only deal with QFP32L based boards, which are closest to the ATmega328P based representatives. Mostly, they are labeled with “LQFP32”. I will discuss all three versions in a follow-up article. They have the same registers and essentially only differ in which functions are actually accessible through pins.\r\n<\/p>\r\n
The pinout scheme of the QFP32L shows many similarities to that of the ATmega328P, but also a few additional features.<\/p>\r\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/pinout_lgt8f328p_ic.png\")
<\/a><\/figure>\n<\/div>\nA certain disadvantage when working with the LGT8F328P is that the manufacturer does not provide an English data sheet. However, thanks to some hardworking contributors, translations are available, for example here<\/a> on GitHub. <\/p>\r\n\n
Advantages compared to the ATmega328P<\/h2>\n\n
I don’t want to list here all the technical features of the LGT8F328P. Like the ATmega328P it has 2 KB SRAM, 32 KB flash, the supply voltage is from 1.8 to 5.5 volts etc.<\/p>\r\n
These are some important differences to the ATmega328P:<\/p>\r\n\n
![\"LGT328P](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/06\/atmega328_vs_lgt8f328p_eng-1-1024x539.png\")
<\/a>LGT328P vs. ATmega328P: some important differences<\/figcaption><\/figure>\n\n Pinout of the LGT8F328P-LQFP32 based boards<\/h2>\n\n
When comparing the LGT8F328P boards with their ATmega328P counterparts, you have to look twice to see differences. This applies in particular to the pin labels. Here you can see an original Arduino Nano (blue), next to two LGT8F328P Nano boards:<\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/nano_328p_lgt8f328p-1024x161.jpg\")
<\/a>Arduino Nano (ATmega328P) between two LGT8F328P Nano boards <\/figcaption><\/figure>\n\n There are also great similarities with the originals in terms of pin functions:<\/p>\r\n\n
![\"Pinout](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/05\/lgt8f328p_nano_qfp32l_pinout-1-1024x627.jpg\")
<\/a>Pinout LGT8F32P based Nano board<\/figcaption><\/figure>\n\n A corresponding diagram for the LGT8F328P based Pro Mini can be found here<\/a>, for example. For UNO-like board I tested (source: AZ-Delivery<\/a>) I did not find such a scheme. But this should not be a problem because the UNO has the same in- and outputs. Only SWC and SWD are missing. <\/p>\r\n\n
Installation of the board package<\/h2>\n\n
Nano- \/ Pro Mini-like boards<\/h4>\n\n
To be able to program the LGT8F328P boards with the Arduino IDE, you must first install a suitable board package. For the “L-Nano” (as an abbreviation for “LGT8F328P based”) and the “L-Pro Mini” I used the great board package lgt8fx<\/a> from David Buezas<\/a>. It is based on the packages Larduino_HSP<\/a> and LGT<\/a> but is easier to handle, takes better advantage of the LGT8F328P and is better documented. You can learn more about the differences here<\/a>.<\/p>\r\n
A detailed installation guide for the board package with screenshots can be found here<\/a>. The short version is:<\/p>\r\n
- \r\n
- Go to File \u2192 Preferences.<\/li>\r\n
- Click the button behind “Additional Board Manager URLs”.<\/li>\r\n
- Enter there the line “https:\/\/raw.githubusercontent.com\/dbuezas\/lgt8fx\/master\/package_lgt8fx_index.json” (without quotes).<\/li>\r\n
- Navigate to Tools \u2192 Board: “xxx” \u2192 Boards Manager.<\/li>\r\n
- Search for “lgt8fx” and install the package “LGT8fx Boards” by dbuezas.<\/li>\r\n<\/ul>\r\n
After successful installation, select “LGT8F328” as the board. As “Variant” I have selected “328P-LQFP32 (e.g. MiniEVB nano-style or WAVGAT)”. <\/p>\r\n\n
![\"LGT8F328P](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/04\/lgt8f328p_board_selection.png\")
<\/a>LGT8F328P Board options<\/figcaption><\/figure>\n\n UNO-like board<\/h4>\n\n
For AZ-Delivery’s UNO-like board, the procedure is similar. The entry for the board manager URL is:<\/p>\r\n
- \r\n
- http:\/\/www.az-arduino.de\/package_AZ-Boards_index.json<\/li>\r\n<\/ul>\r\n
In the board manager menu, search for “AZ boards”. You can find a detailed description in the free e-book from AZ-Delivery.<\/p>\r\n\n
Checking the installation<\/h4>\n\n
Take any sketch, for example Blink.ino from the “Basics” example sketches of the Arduino IDE and upload it. The board LED should flash every second.<\/p>\r\n
How to upload sketches via an USB-to-TTL adapter (e.g. for the Pro Mini) or via LGTISP<\/a> and how to burn the bootloader, I explain at the end of the article (here). <\/p>\r\n\n
LGT8F328P-LQFP32 boards in action<\/h2>\n\n
Enough of the preparations and general explanations – now we come to the more interesting, practical part.<\/p>\r\n
I have tried many Arduino sketches with all kinds of functions unchanged on the LGT8F328P boards. Only sketches that use the watchdog timer and sleep functions had to be adapted. Everything else worked 1:1. So we can essentially focus on the additional<\/em> functions.<\/p>\r\n\n
Analog to digital converter <\/h3>\n\n
You can read the voltage at an analog pin via
analogRead()<\/code> as you are used to from the ATmega328P based boards. The default resolution is 10 bit. The standard reference voltage is the operating voltage (VCC).<\/p>\r\nIt should be noted that the “Nano-like” board has a diode built into the 5 volt line to protect the USB port. The effective operating voltage is therefore about 4.6 volts when powered via USB. You can find the diode above the pins D10 \/ D11.<\/p>\r\n
As with the conventional ATmega328P boards, you can use external voltage references. If you do this, connect it to the REF input. Alternatively, the LGT8F328P provides internal references of 1.024, 2.048 or 4.096 volts. Furthermore, the LGT8F328P allows you to increase the resolution to 11 or 12 bits. The following sketch shows how it works:<\/p>\r\n\n
\/*\r\n Parameter: Reference:\r\n DEFAULT VCC\r\n EXTERNAL External Reference (REF)\r\n INTERNAL1V024 Internal 1.024 volts\r\n INTERNAL2V048 Internal 2.048 volts\r\n INTERNAL4V096 Internal 4.096 volts\r\n*\/\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n analogReference(INTERNAL4V096);\r\n analogReadResolution(10); \/\/ Resolution = 10, 11 or 12 Bit\r\n}\r\nvoid loop(){\r\n int adcValue = analogRead(A1); \/\/ Raw value \r\n float voltage = adcValue * 4.096\/1024.0; \/\/ Voltage calculation\r\n Serial.print(\"Analog Value: \");\r\n Serial.println(adcValue);\r\n Serial.print(\"Voltage [V]: \");\r\n Serial.println(voltage,3);\r\n delay(1000); \r\n}<\/pre>\r\n\nAD converter quality<\/h4>\n\n
The good news: The LGT8F328P’s ADC works quite linearly. The bad news is that the noise is at least as high as with the AVR-based boards. Even in the 10-bit resolution, I had to average at least 100 readings to get stable values. Unfortunately, this makes an 11- or 12-bit resolution of limited use! Maybe the noise can be reduced by stabilizing the supply voltage – I have to experiment a bit more. <\/p>\r\n
Let’s focus on the positive. I tested the ADC by applying voltages with my lab power supply and converting them with the LGT8F328P. I checked the voltages with a reliable multimeter. The internal 4,096-volt reference was used for A\/D conversion, and 100 readings were averaged for each data point. I did the test with different several boards. This is a typical result:<\/p>\r\n\n
![\"Testing](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/04\/lgt8f328p_adc_check-1024x599.png\")
<\/a>Testing the ADC – blue: given voltage, orange: measured value<\/figcaption><\/figure>\n\n Each board had an individual, small and reproducible deviation. So if you need very accurate results, you can use Excel or similar programs to create a best-fit curve.<\/p>\r\n\n
Analog differential measurements and gain<\/h4>\n\n
The LGT8F328P allows you to perform differential measurements between specific analog inputs. You can amplify the differential voltages by a factor of 1, 8, 16 or 32. The function for this is
analogDiffRead()<\/code>. It expects the negative input, the positive input and the gain factor as arguments. To use the function, you have to include the differential_amplifier.h library file.<\/p>\r\nHere is an example sketch:<\/p>\r\n\n
\r\n#include<differential_amplifier.h>\r\n\/*\r\n Parameter: Reference:\r\n DEFAULT VCC\r\n EXTERNAL External Reference (REF)\r\n INTERNAL1V024 Internal 1.024 volts\r\n INTERNAL2V048 Internal 2.048 volts\r\n INTERNAL4V096 Internal 4.096 volts\r\n\r\n Available combinations:\r\n| -\\+ | A0 | A1 | A2 | A3 | A4 | A5 | A6 | A7 |\r\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | \r\n| A0 | | + | | | | | | |\r\n| A1 | + | | | | | | | |\r\n| A2 | + | + | | + | + | + | + | + |\r\n| A3 | + | + | + | | + | + | + | + |\r\n| A4 | + | + | | | | | | |\r\n| A5 | + | + | | | | | | |\r\n| A6 | + | + | | | | | | |\r\n| A7 | + | + | | | | | | |\r\n*\/\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n analogReference(INTERNAL4V096); \r\n}\r\nvoid loop(){\r\n int raw = analogDiffRead(A2,A3,GAIN_16); \/\/ GAIN_x mit x = 1, 8, 16, 32\r\n float voltage = raw \/ 1024.0 * 4096.0 \/ 16.0; \/\/ considers resolution, reference and gain\r\n Serial.println(voltage);\r\n delay(1000); \r\n}<\/pre>\r\n<\/div>\r\n\nAs you can see from the table in the sketch, only certain combinations of analog inputs are allowed for differential measurements. If you choose an invalid combination, you will get a raw value of -1.<\/p>\r\n
To use differential_amplifier.h with AZ-Delivery’s LGT8F328P based UNO, the easiest way is to download the lgt8fx package from here and extract the corresponding “.cpp” and “h.” files from the lgt8f\/libraries\/differential_amplifier folder and save them to the sketch’s folder. In this case, the header file in
#include<\/code> needs to be put in quotation marks.<\/p>\r\n\nDigital to analog converter <\/h3>\n\n
“Quasi-analog” PWM signals<\/h4>\n\n
As known from the ATmega328P boards, you can tap a PWM signal at (Arduino) pins 3, 5, 6, 9, 10 and 11 with
analogWrite()<\/code>. Likewise, the PWM frequency on pins 5 and 6 is twice as high as on the other pins. It should be noted that the frequencies depend on the clock rate. At 16 MHz they correspond to those of the ATmega328P boards, namely 490 and 980 Hertz respectively. The frequency changes proportionally with the clock rate.<\/p>\r\nI will explain how to generate PWM signals at pins 1 (TX) and 2 (D2) when we get to the timers. Some pinout schemes found on the net additionally mark pin 8 as PWM pin. However, this is wrong.<\/p>\r\n\n
Generating a real analog signal<\/h4>\n\n
At pin 4 (D4 \/ PD4 \/ DAO) you can generate a real analog signal with a resolution of 8 bit. By default, VCC is the reference, i.e. 255 \u2259 VCC. Alternatively, you can use an external reference or the internal references 1,024, 2,048 or 4,096 volts. The following little sketch shows how it works:<\/p>\r\n\n
\/*\r\n Parameter: Reference:\r\n DEFAULT VCC\r\n EXTERNAL External Reference (REF)\r\n INTERNAL1V024 Internal 1.024 volts\r\n INTERNAL2V048 Internal 2.048 volts\r\n INTERNAL4V096 Internal 4.096 volts\r\n*\/\r\n\r\nvoid setup(){\r\n analogReference(DEFAULT); \r\n pinMode(DAC0, ANALOG);\r\n analogWrite(DAC0, 125); \/\/ 0...255\r\n}\r\nvoid loop(){}<\/pre>\r\n\nAccuracy of the DAC<\/h4>\n\n
I checked the accuracy of the analog signal with the 4.096 volt reference and was quite impressed with the correlation between the calculated and measured value:<\/p>\r\n\n
![\"Analog](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/dac_check-1024x599.png\")
<\/a>Analog output test using the internal reference<\/figcaption><\/figure>\n\n Using the 80 mA outputs<\/h3>\n\n
Because of the ambiguity of the different pin designations (e.g. 1 vs. TX vs. PD1 vs. D1), I use the labels on the LGT8F328P Nano board in the following when referring to the board pins.<\/p>\r\n\n
The pins TX, D2, D5 and D6 can supply up to 80 mA. However, you must first enable this “high current” feature by setting the appropriate bits in the HDR register. Then you can – at least for the pins D5 and D6 – use the outputs with
pinMode()<\/code> anddigitalWrite()<\/code>. Here is an example:<\/p>\r\n\n\/*\r\n HDR Port\/Pin Pin Label (Nano)\r\n HDR0 --> PD5 --> D5\r\n HDR1 --> PD6 --> D6\r\n HDR2 --> PF1 --> TX\r\n HDR3 --> PF2 --> D2 \r\n HDR4 --> PE4 \/ PF4 --> none\r\n HDR5 --> PE5 \/ PF5 --> none \r\n*\/\r\n\r\nvoid setup(){ \r\n HDR |= (1<<HDR0); \/\/ Activate high current for Pin 5\r\n pinMode(5,OUTPUT);\r\n digitalWrite(5, HIGH);\r\n}\r\n \r\nvoid loop(){}<\/pre>\r\n\nIf you want to enable the 80 mA option on pins TX and D2, there is a small complication. PD1 and PF1 share TX, PD2 and PF2 share D2 (which makes naming the pins uniquely even more difficult). However, the high current option is only provided via PF1 and PF2 and not via PD1 or PD2. But since PF1 and PF2 are not implemented as Arduino pins (on the QFP32L), you have to address them directly via the ports. Here is a “high current blink sketch” for PF2:<\/p>\r\n\n
\/*\r\n HDR Port\/Pin Pin Label (Nano)\r\n HDR0 --> PD5 --> D5\r\n HDR1 --> PD6 --> D6\r\n HDR2 --> PF1 --> TX\r\n HDR3 --> PF2 --> D2 \r\n HDR4 --> PE4 \/ PF4 --> none\r\n HDR5 --> PE5 \/ PF5 --> none \r\n*\/\r\n\r\n\r\nvoid setup(){ \r\n\/* example for activating PF2 for high current *\/\r\n HDR |= (1<<HDR3);\r\n DDRF = (1<<PF2); \/\/ ~ pinMode OUTPUT\r\n}\r\n \r\nvoid loop(){\r\n PORTF |= (1<<PF2); \/\/ Pin HIGH\r\n delay(1000);\r\n PORTF &= ~(1<<PF2); \/\/ Pin LOW\r\n delay(1000); \r\n}<\/pre>\r\n\nBut here you have to be careful<\/strong>: If PF1 or PF2 are in OUTPUT \/ HIGH state and PD1 or PD2 are in OUTPUT \/ LOW state you could cause a short circuit (I didn’t try it). And PD1 could be accidentally set to this state by its TX function.\r\n<\/p>\r\n
If you are not familiar with bit operations and port manipulations such as
PORTF &= ~(1<<PF2)<\/code>, I recommend reading my post on this topic<\/a>. <\/p>\r\n\nWatchdog Timer (WDT)<\/h3>\n\n
Maybe one or the other has read my post about the watchdog timer<\/a> of the ATmega328P. The sketches I published there, work only to a limited extent on the LGT8F328P boards. If you want to use the WDT, it is best to use the library WDT<\/a> included in the board package lgt8fx<\/a> (instead of avr\/wdt.h). Here is an example sketch:<\/p>\r\n\n
\/*\r\n Parameter WDT Reset Period\r\n WTO_64MS 64 ms \r\n WTO_128MS 128 ms\r\n WTO_256MS 256 ms\r\n WTO_512MS 512 ms\r\n WTO_1S 1 s\r\n WTO_2S 2 s\r\n WTO_4S 4 s\r\n WTO_8S 8 s\r\n WTO_16S 16 s\r\n WTO_32S 32 s\r\n*\/\r\n\r\n#include <WDT.h>\r\n\r\nvoid setup() {\r\n Serial.begin(9600);\r\n Serial.println(\"Sketch started\");\r\n wdt_enable(WTO_8S);\r\n}\r\n\r\nvoid loop() {\r\n for(int i=0; i<1000; i++){\r\n Serial.print(\"Runtime [s]: \");\r\n Serial.println(i);\r\n delay(1000);\r\n\/\/ wdt_reset();\r\n }\r\n}<\/pre>\r\n\nA restart is triggered after every eight seconds. However, if you uncomment line 28, the sketch will run forever.<\/p>\r\n\n
WDT Interrupt<\/h4>\n\n
To use the WDT ISR, take the function wdt_ienable(). Here is an example:<\/p>\r\n\n
\r\n#include <WDT.h>\r\n\r\nvolatile boolean isrflag;\r\n\r\nvoid setup() {\r\n pinMode(LED_BUILTIN, OUTPUT);\r\n digitalWrite(LED_BUILTIN, LOW);\r\n Serial.begin(9600);\r\n Serial.println(\"Sketch started.\");\r\n isrflag = false;\r\n wdt_ienable(WTO_4S);\r\n}\r\n\r\nvoid loop() {\r\n int n = 0;\r\n do {\r\n Serial.print(\"Elapsed time: \");\r\n Serial.print(n);\r\n Serial.println(\" s\");\r\n delay(1000);\r\n if (digitalRead(LED_BUILTIN)) \r\n digitalWrite(LED_BUILTIN, LOW );\r\n else\r\n digitalWrite(LED_BUILTIN, HIGH);\r\n if (isrflag) {\r\n Serial.println(\"--There was a wdt interrupt.--\");\r\n isrflag = false;\r\n wdt_enable(WTO_4S); \/\/ uncomment this line...\r\n \/\/ wdt_ienable(WTO_4S); \/\/ ...comment this line and see the change\r\n }\r\n \/\/ wdt_reset(); \/\/ if uncommented, no interrupt will occur\r\n } while( n++ < 1000 );\r\n}\r\n\r\nISR (WDT_vect)\r\n{\r\n isrflag = true;\r\n wdt_reset();\r\n}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
If you don’t want to reset the LGT8F328P after the interrupt, then change lines 28 and 29 from wdt_enable() to wdt_ienable().<\/p>\r\n\n
Sleep and power modes<\/h3>\n\n
If you want to put your LGT8F328P board into sleep mode, it is best to use the PMU library<\/a> included in the board package.<\/p>\r\n
To try out the following example sketch, connect pin 2 (D2) to GND via a push button. With the settings selected in the sketch, your board will be sent to sleep, wake up after four seconds, then be sent to sleep again, and so on. If you press the push button, your board wakes up immediately due to the external interrupt.<\/p>\r\n\n
\r\n\/*\r\n Power Modes\r\n PM_IDLE0: disable core clock only\r\n PM_POWERDOWN: disable most clocks and switch main clock to rc32k\r\n PM_POFFS0: power off all core functions (digital and analog)\r\n wake up by external interrupt or periodly\r\n PM_POFFS1: the lowest power mode which close all modules and clocks \r\n wake up by external interrupt only\r\n\r\n Sleep Duration:\r\n SLEEP_xMS with x = 64, 128, 256, 512 (milliseconds), e.g. SLEEP_256MS\r\n SLEEP_yS with y = 1, 2, 4, 8, 16, 32 (seconds), e.g. SLEEP_4S\r\n SLEEP_FOREVER\r\n*\/\r\n\r\n#include <PMU.h>\r\nconst int interruptPin = 2;\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n Serial.println(\"Sketch started!\");\r\n pinMode(interruptPin, INPUT);\r\n digitalWrite(interruptPin, HIGH); \r\n attachInterrupt(digitalPinToInterrupt(interruptPin), noAction, FALLING); \r\n}\r\n \r\nvoid loop(){\r\n Serial.flush();\r\n PMU.sleep(PM_POWERDOWN, SLEEP_4S);\r\n Serial.println(\"Woke Up!\");\r\n delay(200); \/\/ for debouncing \r\n}\r\n\r\nvoid noAction(){} \/\/ dummy<\/pre>\r\n<\/div>\r\n\nFastio – Functions<\/h3>\n\n
The functions
pinMode()<\/code>,digitalWrite()<\/code> anddigitalRead()<\/code> have a lot of ballast that you don’t need in most cases. If you want to save a few microseconds, you can use port manipulation. If this is too cryptic for you,fastioMode()<\/code>,fastioWrite()<\/code>,fastioRead()<\/code> andfastioToggle()<\/code> are available as alternatives.<\/p>\r\nThe disadvantage of the functions is that you cannot pass them variable names, only the pin as a number. If you try it anyway, you will get error messages.<\/p>\r\n
Here is an example of correct usage:<\/p>\r\n\n
void setup() {\r\n fastioMode(8, OUTPUT); \/\/ equals: DDRB |= (1<<PB0);\r\n}\r\n\r\nvoid loop() {\r\n fastioWrite(8, HIGH); \/\/ equals (in essence): PORTB |= (1<<PB0);\r\n delay(100);\r\n fastioWrite(8, LOW); \/\/ equals (in essence): PORTB &= ~(1<<PB0);\r\n delay(100);\r\n fastioToggle(8); \/\/ equals: PINB = (1 << PB0);\r\n delay(1000);\r\n fastioToggle(8); \/\/ equals: PINB = (1 << PB0);\r\n delay(1000);\r\n}<\/pre>\r\n\nUsing
fastioRead()<\/code> is just as easy:<\/p>\r\nint status = fastioRead(8); \/\/ equals: int status = (PINB >> PB0) & 1;<\/pre>\r\n
The fastio functions are not a special feature of the LGT8F328P, but just a nice feature of the board package.<\/p>\r\n\n
Timer and PWM<\/h3>\n\n
The LGT8F328P has two 8-bit and two<\/strong> 16-bit timers, so one 16-bit timer more (Timer3) than the ATmega328P. Timers 0 to 2 include two output compare registers each, which you can use to generate PWM signals at the assigned outputs OCxA\/OCxB. I have explained how this works in my posts about Timer0 and Timer1<\/a> and about Timer2<\/a>. All sketches used there also work on the LGT8F328P.<\/p>\r\n
Three output compare registers and the three outputs OC3A, OC3B and OC3C belong to the Timer3. <\/p>\r\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/lgt8f328p_timer-1024x356.png\")
<\/a>The timers and associated outputs of the LGT8F328P<\/figcaption><\/figure>\n\n The pinout diagram of the LGT8F328P-QFP32L (see at the very top) is somewhat misleading in this regard. It is correct that OC3C has no output pin. It is also true that OC3A and OC3B are accessible at the pins for PD1 and PD2. However, to obtain a PWM signal, you have to set PF1 and PF2 to OUTPUT. PF1 and PF2 share their outputs with PD1 and PD2, as already mentioned.<\/p>\r\n\n
Here is an example of a fast PWM signal at PF1 (board pin: TX) with a duty cycle of 25% and a frequency of 2 kHz (when the LGT8F328P is running at 32 MHz):<\/p>\r\n\n
void setup(){ \r\n \/\/ Clear OC3A on Compare Match \/ Set OC3A at Bottom; Wave Form Generator: Fast PWM 14, Top = ICR3\r\n TCCR3A = (1<<COM3A1) + (1<<WGM31); \r\n TCCR3B = (1<<WGM33) + (1<<WGM32) + (1<<CS30); \/\/ prescaler = 1; \r\n ICR3 = 15999;\r\n OCR3A = 3999;\r\n DDRF |= (1<<PF1);\r\n} \r\n\r\nvoid loop() {} <\/pre>\r\n\nFurther explanations would lead too far here – if you are interested, have a look at the already mentioned articles about the timers of the ATmega328P. Or, if you don’t feel like calculating and picking all the bits out of the tables, you might want to try this great tool by David Buezas:Arduino Web Timers<\/a>. You find the documentation here<\/a> on GitHub.<\/p>\r\n
By the way, you can set the Timer0 and Timer1 counter to double the system frequency, i.e. up to 64 MHz<\/strong>! For this, you have to set the F2XEN bit in the “Timer Counter Clock Control and Status Register” (TCKCSR). By setting the bits TC2XS0 for Timer0 or TC2XS1 for Timer1 you tell the LGT8F328P which timer should run at double speed. E.g.:<\/p>\r\n
TCKCSR = (1 << F2XEN) | (1 << TC2XS0);<\/code><\/p>\r\nOne more reason to use David Buezas’ tool.<\/p>\r\n\n
Programming the LGT8F328P based Pro Mini<\/h2>\n\n
Upload via USB-to-TTL adapter<\/h3>\n\n
The counterpart to the Arduino Pro Mini (“L-Pro Mini”) lacks, just like the original, the on-board USB-to-TTL adapter. So, you need to attach one as an external module. Programming is most convenient if you take an adapter which has a DTR pin. <\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/lgt8f328p_with_usb2ttl-1024x254.jpg\")
<\/a>Left: USB-to-TTL adapter, right: LGT8F328P based Pro Mini<\/figcaption><\/figure>\n \n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/lgt8f328p_serial_programming.jpg\")
<\/a><\/figure>\n<\/div>\nThe adapter shown here also has the advantage that you can plug it directly onto the “L-Pro Mini”, as long as you have soldered on a pin header beforehand.<\/p>\r\n
If you connect everything by cable, you have to make sure that you connect RX to TX and TX to RX.<\/p>\r\n
Uploading is simple: select the port your adapter is connected to, and then simply upload.<\/p>\r\n
If you have a USB-to-TTL adapter without a DTR pin, it’s a little bit more complicated. When you initiate the upload process, press the reset button of the board you want to program. Release the button when the compilation is completed and the actual upload should start.<\/p>\r\n\n
Upload via LArduinoISP (without bootloader)<\/h3>\n\n
As we have already seen, the LGT8F328P has significant differences “under the hood” despite all compatibility with the ATmega328P. This is also shown by the fact that it is not programmable via its pins 11, 12 and 13 by ISP. Instead, it has two pins, SWC and SWD, for this purpose.<\/p>\r\n
But as with the ATmega328P, you can also convert a LGT8F328P based board to an ISP programmer.<\/p>\r\n
For the “LGT8F328P – UNO” from AZ-Delivery this makes little sense because this board does not have the SWC and SWD pin accessible. <\/p>\r\n\n
Turning an LGT8F328P board into a programmer<\/h4>\n\n
Connect the LGT8F328P based board that will serve as a programmer to your computer. It is best not to connect anything else to the board. Then you perform the following steps:<\/p>\r\n
- \r\n
- Select the connected board in the Arduino IDE.<\/li>\r\n
- Under Tools \u2192 “Arduino as ISP” you set the option “[To burn an ISP] SERIAL_RX_BUFFER_SIZE to 250” (see below, blue selection).<\/li>\r\n
- Go to File \u2192 Examples \u2192 “Examples for LGT8F328” in the menu and select the sketch LarduinoISP.<\/li>\r\n
- Upload the sketch.<\/li>\r\n
- Set “Arduino as ISP” in Tools back to default (64).<\/li>\r\n<\/ul>\r\n
<\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/larduinoisp_setting.png\")
<\/a>Settings for Arduino as ISP<\/figcaption><\/figure>\n\n The programmer is ready!<\/p>\r\n\n
Uploading sketches<\/h4>\n\n
Connect your new programming device to the board to be programmed (“target”) as follows:<\/p>\r\n
- http:\/\/www.az-arduino.de\/package_AZ-Boards_index.json<\/li>\r\n<\/ul>\r\n
- Upload via LarduinoISP (without Bootloader)<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Using 80 mA outputs<\/a><\/li>\r\n
- Analog differential measurements and gain<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- AD converter quality<\/a><\/li>\r\n
![\"LarduinoISP](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/lgt8f328p_nano_isp_programmer-1024x353.jpg\")
<\/a>