Timer PWM

Standardmäßig bietet der Arduino Uno mit dem Befehl "analogWrite(...)" die Möglichkeit, PWM-Signale mit einer Auflösung von 8 Bit und einer PWM-Frequenz von 490 Hz (Pin D3, D9, D10 und D11) bzw. 980 Hz (Pin D5 und D6) auszugeben. Wer für seine Anwendung eine höhere Auflösung und/oder eine höhere oder tiefere PWM-Frequenz haben möchte, muss zwangsläufig selbst diverse Bits in den entsprechenden Timer-/Counter-und Port-Registern setzen.

Die PWM-Pins des Arduino Uno werden von den Timern 0, 1 und 2 kontrolliert:

Pins D5 und D6: Timer0 (8 Bit)
Pins D9 und D10: Timer1 (16 Bit)
Pins D3 und D11: Timer2 (8 Bit)

Das folgende Beispiel zeigt die Verwendung des 16 Bit Timer1, wie ein PWM-Signal mit anderer Frequenz und Auflösung als standardmäßig vorgegeben, programmiert wird. Mit Timer1 können nur die Pins D9 und D10 als PWM-Pins verwendet werden!

Verwendete Register:

Timer Counter Control Register A: TCCR1A
Output Compare Register A: OCR1A (für PWM-Pin D9)
Output Compare Register B: OCR1B (für PWM-Pin D10)
Port B Data Direction Register: DDRB

Vorgehensweise:

1. Modus wählen
2. PWM-Frequenz festlegen
3. Ausgangs-Aktion festlegen
4. Pin als Ausgang definieren
5. Setzen des Wertes der Pulsweite

1. Modus wählen:

Timer 1 erlaubt drei Modi: 8 Bit-, 9 Bit- und 10 Bit-PWM. Die Auswahl erfolgt über die Bits "Waveform Generation Mode" WGM10, WGM11 und WGM12 der "Timer/Counter Controll Register" A und B (TCCR1A und TCCR1B).
Die Bits WGM10 und WGM11 befinden sich im Timer/Counter Control Register A (TCCR1A), das Bit WGM12 im Timer/Counter Control Register B (TCCR1B).

TCCR1A - Timer/Counter1 Control Register A:
7	6	5	4	3	2	1	0
COM1A1	COM1A0	COM1B1	COM1B0	-	-	WGM11	WGM10

TCCR1B - Timer/Counter1 Control Register B:
7	6	5	4	3	2	1	0
ICNC1	ICES1	-	WGM13	WGM12	CS12	CS11	CS10

Codebeispiel: Loeschen der Timer/Counter Control Register A und B
TCCR1A = 0;
TCCR1B = 0;

In der nachfolgenden Tabelle sind die Einstellungen der Bits für den gewünschten Modus ersichtlich:

Einstellungen der Bits
Modus	WGM12	WGM11	WGM10
Fast PWM 8Bit	1	0	1
Fast PWM 9Bit	1	1	0
Fast PWM 10Bit	1	1	1

Codebeispiel: Den Modus Fast PWM-Mode 9 Bit einstellen

TCCR1A |= (0 << WGM10) | (1 << WGM11);
TCCR1B |= (1 << WGM12);

Modus Fast PWM-Mode 10 Bit einstellen
TCCR1A |= (1 << WGM10) | (1 << WGM11);
TCCR1B |= (1 << WGM12);

2. PWM-Frequenz festlegen

Die PWM-Frequenz ist abhängig von der Taktfrequenz des Prozessors, der Auflösung und der Einstellung des Vorteilers (Prescaler).

Vorgaben:

PWM-Auflösung 8, 9 oder 10 Bit
CPU-Frequenz Arduino Uno: 16.000.000 Hz
Mögliche Vorteiler: 1, 8, 64, 256 oder 1024

In Abhängigkeit der Auflösung wird die PWM-Frequenz [Hz] nach folgender Formel ermittelt:
8-Bit PWM: Frequenz = CPU Frequenz/Vorteilerx256
9-Bit PWM: Frequenz = CPU Frequenz/Vorteilerx512
10-Bit PWM: Frequenz = CPU Frequenz/Vorteilerx1024

Berechnungsbeispiel:
Z.B. Auflösung = 10 Bit, Vorteiler = 256:
PWM Frequenz = 16.000.000 / (256 * 1024) = 61 Hz
oder z.B. Auflösung = 10 Bit, Vorteiler = 8:
PWM Frequenz = 16.000.000 / (8 * 1024) = 1.953 Hz (Wird im untenstehenden Programmbeispiel verwendet)
oder z.B. Auflösung = 9 Bit, Vorteiler = 1:
PWM Frequenz = 16.000.000 / (1 * 512) = 31.250 Hz
Nachfolgende Tabelle zeigt alle möglichen PWM-Frequenzen in Abhängigkeit der Auflösung und des Vorteilers bei einer Taktfrequenz des Uno von 16 MHz. Wie man sieht, liegt die höchste PWM-Frequenzen bei 62,5 kHz, die tiefste Frequenz bei 15 Hz:

Mögliche PWM Frequenzen [Hz]
Vorteiler	Auflösung
Vorteiler	8 Bit (256)	9 Bit (512)	10 Bit (1024)
1	62.500,0	31.250,0	15.625,0
8	7.812,5	3.906,3	1.953,1
64	976,6	488,3	244,1
256	244,1	122,1	61,0
1024	61,0	30,5	15,3

Berechnung möglicher PWM Frequenzen [Hz] in Excel

Der gewünschte Vorteiler muss im Timer/Counter Control Register B (TCCR1B) mit den Bits "Clock Select" CS10, 11 und 12 gesetzt werden:
7	6	5	4	3	2	1	0
ICNC1	ICES1	-	WGM13	WGM12	CS12	CS11	CS10

Die Bitkombination für den gewünschten Vorteiler ist in nachfolgender Tabelle ersichtlich:
Vorteiler	CS12	CS11	CS10
Keine Taktquelle (Timer/Counter Stopp)	0	0	0
Takt / 1 (keine Teilung)	0	0	1
Takt / 8	0	1	0
Takt / 64	0	1	1
Takt / 256	1	0	0
Takt / 1024	1	0	1

Codebeispiel: Vorteiler auf Takt / 8 setzen

TCCR1B |= (1 << CS11);

3. Ausgangsaktion festlegen
Hier legt man mit den "Compare Output Mode" - Bits des Timer/Counter1 Control Register A (TCCR1A) fest, ob das PWM-Signal nicht invertiert oder invertiert ausgegeben wird, oder ob das Signal abgeschaltet wird:

Für PWM-Pin D9 : Bit COM1A0 und COM1A1
Für PWM-Pin D10: Bit COM1B0 und COM1B1

7	6	5	4	3	2	1	0
COM1A1	COM1A0	COM1B1	COM1B0	-	-	WGM11	WGM10

Einstellungen der Bits für ein invertiertes/nicht invertiertes PWM Signal
PWM Ausgang	COM1A1/ COM1B1	COM1A0/ COM1B0
PWM ausgeschaltet	0	0
PWM Ausgang nicht inventiert	1	0
PWM Ausgang inventiert	1	1

Codebeispiel: Nichtinvertiertes PWM-Signal setzen

TCCR1A |= (1 << COM1A1);

4. PWM-Pin als Ausgang definieren:
Die PWM-Pins D9 und D10 sind Pins des Port B und können durch direktes Setzen der entsprechenden Bits DDB1 oder DDB2 im Data Direction Register Port B (DDRB) als Binärausgang definiert werden.

PWM-Pin als Ausgang definieren:
Digitalpins Port B
7	6	5	4	3	2	1	0
DDB7	DDB6	DDB5	DDB4	DDB3	DDB2	DDB1	DDB0

-	-	D13	D12	D11	D10	D9	D8

Codebeispiel: PWM-Pin D9 als Ausgang definieren

DDRB |= (1 << DDB1);

5. Pulsweite setzen:
Die gewünschte Pulsweite kann nun, je nach verwendetem PWM-Pin, in das 16-Bit Output Compare Register A (OCR1A) für PWM-Pin D9 oder Output Compare Register B (OCR1B) für PWM-Pin D10 geschrieben werden. In Abhängigkeit der eingestellten Auflösung von 8, 9 oder 10 Bit kann der Wertebereich der Pulsweite 0 bis 255, 0 bis 511 oder 0 bis 1023 betragen. Bei einer Auflösung von z.B. 9 Bit und einer Pulsweite von 255 beträgt das Impuls-Pausenverhältnis somit 50:50.

Codebeispiel: Setzen des Impuls-Pausenverhältnis
//Potiwert einlesen mit einer Auflösung Analogeingang A2 = 10 Bit
potiWert = analogRead(potiPin);
OCR1A = potiWert;

Programmbeispiel:
Im folgenden Beispielprogramm wird die Helligkeit einer LED durch ein Potentiometer mit Pulsweitenmodulation gesteuert (PWM-Frequenz = 1.953 Hz, Auflösung 10 Bit = 1024 Stufen).

Verwendete Bauteile:

1 Arduino Uno
1 LED
1 Widerstand 220 Ohm
1 Poti 10 kOhm

C++ PWM Programm 1.953Hz

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Die Helligkeit einer LED wird durch ein Potentiometer mit Pulsweitenmodulation (PWM-Frequenz = ca. 2 kHz, Aufloesung 10 Bit = 1024 Stufen) gesteuert.

**************************************************************************************************
Version: 09.03.2022
**************************************************************************************************
Board: UNO
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#define potiPin 2 //Eingang Poti ist A2

int potiWert;
bool pwmStatus = true;

void setup() {
  Serial.begin(115200);

  //Loeschen der Timer/Counter Control Register A und B

  TCCR1A = 0;
  TCCR1B = 0;

  //Modus Fast PWM-Mode 10 Bit einstellen
  TCCR1A |= (1 << WGM10) | (1 << WGM11);
  TCCR1B |= (1 << WGM12);

  //Vorteiler auf 8 setzen
  TCCR1B |= (1 << CS11);

  //Nichtinvertiertes PWM-Signal setzen
  TCCR1A |= (1 << COM1A1);

  //PWM-Pin 9 als Ausgang definieren
  DDRB |= (1 << DDB1);
}

void loop() {
  potiWert = analogRead(potiPin); //Potiwert einlesen (Aufloesung Analogeingang = 10 Bit)

   //Ist die Aufloesung des PWM-Signals z.B 8 Bit, muss der potiWert angepasst werden:
  //potiWert = map(potiWert, 0, 1023, 0, 255);

  if (potiWert == 0 && pwmStatus)
  {
    TCCR1A &= ~(1 << COM1A1); //COM1A1-Bit loeschen
    pwmStatus = false;
  }
  else if (potiWert > 0 && !pwmStatus)
  {
    TCCR1A |= (1 << COM1A1); //COM1A1-Bit setzen
    pwmStatus = true;
  }

  OCR1A = potiWert; // Setzen des Impuls-Pausenverhaeltnis

  Serial.println(potiWert);
  delay(15);
}

RAW code

C++ PWM Programm 31.250Hz Lüftersteuerung

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Motordrehzahl PWM Steuerung 31.250Hz mit Potentiometer Steuerung
(Aufloesung 9 Bit = 512 Stufen).

**************************************************************************************************
Version: 12.04.2022
**************************************************************************************************
Board: UNO
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#define potiPin 2 //Eingang Poti ist A2

int potiWert;
bool pwmStatus = true;

void setup() {
  Serial.begin(115200);

//Loeschen der Timer/Counter Control Register A und B
  TCCR1A = 0;
  TCCR1B = 0;

//Modus Fast PWM-Mode 9 Bit einstellen
  TCCR1A |= (0 << WGM10) | (1 << WGM11);
  TCCR1B |= (1 << WGM12);

//Vorteiler auf 1 setzen
  TCCR1B |= (1 << CS10);

//Nichtinvertiertes PWM-Signal setzen
  TCCR1A |= (1 << COM1A1);

//PWM-Pin 9 als Ausgang definieren
  DDRB |= (1 << DDB1);
}

void loop() {
  potiWert = analogRead(potiPin); //Potiwert einlesen (Auflösung Analogeingang = 10 Bit)


  //Anpassung PotiWert auf 10 Bit: 0-1023, keine Anpassung
  //Anpassung PotiWert auf 9 Bit: 0-511:
  //Anpassung PotiWert auf 8 Bit: 0-255:
  potiWert = map(potiWert, 0, 1023, 0, 511);


  if (potiWert == 0 && pwmStatus)
  {
    TCCR1A &= ~(1 << COM1A1); //COM1A1-Bit loeschen
    pwmStatus = false;
  }
  else if (potiWert > 0 && !pwmStatus)
  {
    TCCR1A |= (1 << COM1A1); //COM1A1-Bit setzen
    pwmStatus = true;
  }

  OCR1A = potiWert; // Setzen des Impuls-Pausenverhaeltnis

  Serial.println(potiWert);
  delay(15);
}

RAW code

PWM Lüftersteuerung für Be- und Entlüftung

Das folgende ESP32 Codebeispiel startet einen seriellen Kommunikationsport, überprüft die CPU-Taktfrquenz, die XTAL Frequenz und den APB-Bustakt und gibt sie über die serielle Schnittstelle aus. Der GPIO-Pin 5 wird mit maximaler Geschwindigkeit getaktet.
Die XTAL Frequenz ist die periphere Takt-Frequenz und der APB-Busclock (APB_CLK) wird vom CPU_CLK abgeleitet.

C++ ESP32 CPU-Frequenz ermitteln

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion:ESP32 CPU-Frequenz ermitteln

**************************************************************************************************
Version: 09.03.2022
**************************************************************************************************
Board: ESP32
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#define GPIO_pin 5

uint32_t Freq = 0;

void setup()
{
  pinMode(GPIO_pin, OUTPUT);
  Serial.begin(115200);
  Freq = getCpuFrequencyMhz();
  Serial.println("----------------------------------");
   Serial.print("CPU Freq = ");
  Serial.print(Freq);
  Serial.println(" MHz");
  Freq = getXtalFrequencyMhz();
  Serial.print("XTAL Freq = ");
  Serial.print(Freq);
  Serial.println(" MHz");
  Freq = getApbFrequency();
  Freq =(Freq)/1000000;
  Serial.print("APB Freq = ");
  Serial.print(Freq);
  Serial.println(" MHz");
  Serial.println("----------------------------------");
}

void loop()
{
  digitalWrite(GPIO_pin, 1);
  digitalWrite(GPIO_pin, 0);
}

Die ESP32 CPU Frequenz, die periphere Takt-Frequenz XTAL und der APB-Busclock am Seriellen Monitor

Mit dem folgenden Codebeispiel wird der PWM-GPIO-Pin 5 definiert, dann erfolgt die Konfiguration der Frequenz und der Auflösung des PWM-Kanals. In der Hauptschleife erhöht sich allmählich das Tastverhältnis des PWM auf den maximalen Wert und reduziert sich allmählich wieder auf den Minimalwert.

C++ ESP32 PWM Beispiel 1

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion:ESP32 PWM min -> max -> min...

**************************************************************************************************
Version: 09.03.2022
**************************************************************************************************
Board: ESP32
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#define LED_GPIO   5
#define PWM1_Ch    0
#define PWM1_Res   8  //8 Bit
#define PWM1_Freq  1000

int PWM1_DutyCycle = 0;

void setup()
{
  ledcAttachPin(LED_GPIO, PWM1_Ch);
  ledcSetup(PWM1_Ch, PWM1_Freq, PWM1_Res);
}

void loop()
{
  while(PWM1_DutyCycle < 255)
  {
    ledcWrite(PWM1_Ch, PWM1_DutyCycle++);
    delay(10);
  }
  while(PWM1_DutyCycle > 0)
  {
    ledcWrite(PWM1_Ch, PWM1_DutyCycle--);
    delay(10);
  }
}

Das gleiche Programm wie das vorherige mit Ausnahme der Auflösung. Diese ist jetzt auf 4 Bit eingestellt und das Tastverhältnis im Bereich 0 - 15.

C++ ESP32 PWM Beispiel 2

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion:ESP32 PWM min -> max -> min... 4Bit  und das Tastverhaeltnis im Bereich 0-15.

**************************************************************************************************
Version: 09.03.2022
**************************************************************************************************
Board: ESP32
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#define LED_GPIO   5
#define PWM1_Ch    0
#define PWM1_Res   4 //4Bit
#define PWM1_Freq  1000

int PWM1_DutyCycle = 0;

void setup()
{
  ledcAttachPin(LED_GPIO, PWM1_Ch);
  ledcSetup(PWM1_Ch, PWM1_Freq, PWM1_Res);
}

void loop()
{
  while(PWM1_DutyCycle < 255)
  {
    ledcWrite(PWM1_Ch, PWM1_DutyCycle++);
    delay(10);
  }
  while(PWM1_DutyCycle > 0)
  {
    ledcWrite(PWM1_Ch, PWM1_DutyCycle--);
    delay(10);
  }
}

Das nächste Programm ist ein ESP32 PWM Generator mit einem 1,3" OLED Display, der über den Seriellen Monitor konfigurierbar ist.

C++ ESP32 PWM Gemerator

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: ESP32 Frequenzgererator mit OLED 1,3" Display und Ser. Monitor Konfiguration
Ti/Tp = 0-1023
Aufloesung 8-16 Bit
**************************************************************************************************
Version: 10.04.2022
**************************************************************************************************
Board: ESP32vn IoT UNO V1.0.4
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************
**************************************************************************************************/

#include <Wire.h>
#include "SH1106.h"
#define LEDC_CHANNEL_0     0
#define LEDC_TIMER_13_BIT  13

//SSD1306  display(0x3C, 21,22);
SH1106  display(0x3C, 21,22);
unsigned int pwmpin = 27;
unsigned int freq = 1000;
unsigned int duty_set_min = 0;
unsigned int duty_set_max = 100;
unsigned int duty_timer = 100;
unsigned int duty_last = 100;
unsigned int resolution = 10;
unsigned int aresolution = pow(2,resolution)-1;
unsigned int rduty=map(duty_set_max, 0, aresolution, 0, 100);
hw_timer_t * timer = NULL;
volatile uint8_t stat = 0;

void IRAM_ATTR onTimer(){
  stat=1-stat;
  if (stat==1)duty_timer=duty_set_max;
  else if (stat==0)duty_timer=duty_set_min;

}
void setup()
{

Serial.begin(115200);
while (!Serial) {
}
delay(100);
  Serial.println(" ESP32 PWM GENERATOR");
  Serial.println(" Kommandos:");
  Serial.println(" 'f' aendere Frequenz");
  Serial.println(" 'd' aendere Ti/Tp");
  Serial.println(" 'r' aendere Aufloesung");
  Serial.println(" 'p' aendere GPIO");
  display.init();

ledcSetup(0, freq, resolution);
ledcAttachPin(pwmpin, 0);
ledcWrite(0, duty_set_max);
screen(pwmpin,freq,duty_set_max,rduty);

timer = timerBegin(1, 80, true);  // timer 0, MWDT clock period = 12.5 ns * TIMGn_Tx_WDT_CLK_PRESCALE -> 12.5 ns * 80 -> 1000 ns = 1 us, countUp
timerAttachInterrupt(timer, &onTimer, true); // edge (not level) triggered
timerAlarmWrite(timer, 1000000, true); // 1000000 * 1 us = 1 s, autoreload true
timerAlarmEnable(timer); // enable

}

void loop()
{
if (duty_last==duty_timer){
}
else {
  duty_last=duty_timer;
  pwmsettings(pwmpin,freq,duty_last,resolution);
}
if (Serial.available()) {
    char cin = Serial.read();
    byte cin1;
    switch (cin) {
    case 'f':
      Serial.println("Neue Freqenz in Hz");
      while (!Serial.available());
      freq = Serial.parseInt();
                        pwmsettings(pwmpin,freq,duty_set_max,resolution);
                        Serial.print(" Neue Frequenz:");
                        Serial.print(freq);
                        Serial.println("Hz");
                        break;
    case 'd':
      Serial.print("Neue Ti/T (0-");
      Serial.print(aresolution);
      Serial.println(")");
      while (!Serial.available());
      duty_set_max = Serial.parseInt();
                        pwmsettings(pwmpin,freq,duty_set_max,resolution);
                        Serial.print("Neue Ti/T:");
                        Serial.println(duty_set_max);
                        break;
    case 'r':
      Serial.println("Neue Aufloesung (8-16)");
      while (!Serial.available());
      resolution = Serial.parseInt();
                        pwmsettings(pwmpin,freq,duty_set_max,resolution);
                        Serial.print("Neue Aufloesung:");
                        Serial.print(resolution);
                        Serial.println(" Bit Aufloesung");
                        break;
    case 'p':
      Serial.println("Neue Pin Nummer");
      while (!Serial.available());
      pwmpin = Serial.parseInt();
                        pwmsettings(pwmpin,freq,duty_set_max,resolution);
                        Serial.print("Neu Pin Nummer:");
                        Serial.println(pwmpin);
                        break;
}
}
}
void screen(unsigned int pwmpin,unsigned int freq, unsigned int duty_set_max,unsigned int rduty)
{
    display.clear();
    display.setTextAlignment(TEXT_ALIGN_CENTER);
    display.setFont(ArialMT_Plain_10);
    display.drawString(64, 3, "PWM GENERATOR");
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    display.drawString(2, 15, "Freq: " + String(freq)+"Hz");
    display.drawString(2, 27, "Ti / T: "+String(duty_set_max)+" / "+String(aresolution)+"  ("+String(rduty)+"%)");
    display.drawString(2, 39, "Aufloesung: "+String(resolution)+" Bit");
    display.drawString(2, 51, "Pin: "+String(pwmpin));
    display.display();
}
void pwmsettings(unsigned int pwmpin,unsigned int freq, unsigned int duty_set_max,unsigned int resolution)
{
aresolution = pow(2,resolution)-1;
rduty=map(duty_set_max, 0, aresolution, 0, 100);
ledcSetup(0, freq, resolution);
ledcAttachPin(pwmpin, 0);
ledcWrite(0, duty_set_max);
screen(pwmpin,freq,duty_set_max,rduty);
}

RAW code

Der PWM Generator ist über den Seriellen Monitor kofigurierbar.
f = Frequenz; d = Ti/Tp 0-1023; r = Aufloesung 8-16 Bit; p = GPIO.

C++ ESP32 PWM mit Poti, LED und 1,3" OLED-Display

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Die Helligkeit einer LED wird durch ein Potentiometer mit Pulsweitenmodulation gesteuert.
1,30" Display an I2C
LED an GPIO 27
Poti an A2
**************************************************************************************************
Version: 15.04.2022
**************************************************************************************************
Board: ESP32vn IoT UNO
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#include <Adafruit_GFX.h>
#include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


const int ADC_pin = 2;
int sensor_reading = 0;
int dutyCycle =0;

float analog_voltage;
int LED = 27;
U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
unsigned long delayTime;

const int ledChannel = 0; // Auswahl LED-Channel 0;  ESP32: 0-15

const int resolution = 8; // 8 bit Auflösung 0-255. Auflösung beim ESP32 ist 1-16Bit

const int frequency = 25000; // Frequenz in Hz



void setup() {
  Serial.begin(115200);
   pinMode (LED, OUTPUT);
   u8g2.begin();

ledcSetup(ledChannel, frequency, resolution); // Konfiguration
ledcAttachPin(LED, ledChannel); // GPIO 27, Auswahl
}

void loop() {
sensor_reading = analogRead(ADC_pin);
dutyCycle = map(sensor_reading, 0, 4095, 0, 255); // dutyCycle = map(potiWert, 0, 4095, 0, 255);

Serial.print("Tastverhältnis: ");
Serial.println(dutyCycle); // Anzeige des Tastverhältnises am Display

ledcWrite(ledChannel, dutyCycle); // Aenderung der LED-Helligkeit durch PWM

  Serial.print("Analogeingang:");
  Serial.println(sensor_reading);
  analog_voltage = sensor_reading * 3.3 / 4095;
  Serial.print("Spannung: ");
  Serial.println(analog_voltage);
  Serial.println();


    u8g2.setFont(u8g2_font_courR08_tf);
    u8g2.firstPage();

     do {
    u8g2.setCursor(5, 8);
    u8g2.print("Analogeingang:");
    u8g2.setCursor(5, 18);
    u8g2.print(sensor_reading);
    u8g2.print("/4095 Bit");

    u8g2.setCursor(5, 28);
    u8g2.print("Spannung:");
    u8g2.setCursor(5, 38);
    u8g2.print(analog_voltage);
    u8g2.print(" V");


    u8g2.setCursor(5, 48);
    u8g2.print("Tastverhaeltnis:");
    u8g2.setCursor(5, 58);
    u8g2.print(dutyCycle);

    u8g2.print("/255");

      } while ( u8g2.nextPage() );
     delay(delayTime);
      }

RAW code

ESP32 PWM mit Poti, LED und OLED-Display 1,3"

C++ ESP32 PWM 4 Kanal Multidimmer mit Potis, LEDs und OLED-Display 1,3

/*/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Die Helligkeit der LEDs wird durch die Potentiometer mit Pulsweitenmodulation gesteuert.

1,30" Display an I2C

LED an GPIO 27
Poti an A2

LED an GPIO 16
Poti an A4

LED an GPIO 17
Poti an A34

LED an GPIO 25
Poti an A39
**************************************************************************************************
Version: 19.04.2022
**************************************************************************************************
Board: ESP32vn IoT UNO
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
*************************************************************************************************
**************************************************************************************************/

#include <Adafruit_GFX.h>
#include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

//******** Kanal 1 ************************************
const int ADC_pin01 = 2;  //P0ti an GPIO 2
int LED01 = 27;           //LED GPIO27

int sensor_reading01 = 0;
int dutyCycle01 =0;
float analog_voltage01;
unsigned long delayTime01;
const int ledChannel01 = 1; // Auswahl LED-Channel 1;  ESP32: 0-15
const int resolution01 = 8; // 8 bit Aufloesung 0-255. Aufloesung beim ESP32 ist 1-16Bit
const int frequency01 = 1000; // Frequenz in Hz
//****************************************************


//******** Kanal 2 ************************************
const int ADC_pin02 = 4; //Poti an GPIO 04
int LED02 = 16;          //LED an GPIO 16

int sensor_reading02 = 0;
int dutyCycle02 =0;
float analog_voltage02;
unsigned long delayTime02;
const int ledChannel02 = 2; // Auswahl LED-Channel 2;  ESP32: 0-15
const int resolution02 = 9; // 9 bit Aufloesung 0-255. Aufloesung beim ESP32 ist 1-16Bit
const int frequency02 = 5000; // Frequenz in Hz
//****************************************************


//******** Kanal 3 ************************************
const int ADC_pin03 = 34; //Poti an GPIO 34
int LED03 = 17;           //LED an GPIO 17

int sensor_reading03 = 0;
int dutyCycle03 =0;
float analog_voltage03;
unsigned long delayTime03;
const int ledChannel03 = 10; // Auswahl LED-Channel 0;  ESP32: 0-15
const int resolution03 = 10; // 10 bit Aufloesung 0-255. Aufloesung beim ESP32 ist 1-16Bit
const int frequency03 = 10000; // Frequenz in Hz
//****************************************************

//******** Kanal 4 ************************************
const int ADC_pin04 = 39; //Poti an GPIO 39
int LED04 = 25;           //LED an GPIO 25

int sensor_reading04 = 0;
int dutyCycle04 =0;
float analog_voltage04;
unsigned long delayTime04;
const int ledChannel04 = 7; // Auswahl LED-Channel 7;  ESP32: 0-15
const int resolution04 = 12; // 12 bit Aufloesung 0-255. Aufloesung beim ESP32 ist 1-16Bit
const int frequency04 = 20000; // 20.000   Frequenz in Hz
//****************************************************


U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

void setup() {

   pinMode (LED01, OUTPUT);
   pinMode (LED02, OUTPUT);
   pinMode (LED03, OUTPUT);
   pinMode (LED04, OUTPUT);

   Serial.begin(115200);
   u8g2.begin();

//******** Kanal 1 ************************************
ledcSetup(ledChannel01, frequency01, resolution01); // Konfiguration
ledcAttachPin(LED01, ledChannel01); // GPIO 27, Auswahl

//******** Kanal 2 ************************************
ledcSetup(ledChannel02, frequency02, resolution02); // Konfiguration
ledcAttachPin(LED02, ledChannel02); // GPIO 16, Auswahl

//******** Kanal 3 ************************************
ledcSetup(ledChannel03, frequency03, resolution03); // Konfiguration
ledcAttachPin(LED03, ledChannel03); // GPIO 17, Auswahl

//******** Kanal 4 ************************************
ledcSetup(ledChannel04, frequency04, resolution04); // Konfiguration
ledcAttachPin(LED04, ledChannel04); // GPIO 17, Auswahl
}

void loop() {
  //******** Kanal 1 ************************************
sensor_reading01 = analogRead(ADC_pin01);
dutyCycle01 = map(sensor_reading01, 0, 4095, 0, 255); // dutyCycle = map(potiWert, 0, 4095, 0, 255);

//******** Kanal 2 ************************************
sensor_reading02 = analogRead(ADC_pin02);
dutyCycle02 = map(sensor_reading02, 0, 4095, 0, 511); // dutyCycle = map(potiWert, 0, 4095, 0, 255);

//******** Kanal 3 ************************************
sensor_reading03 = analogRead(ADC_pin03);
dutyCycle03 = map(sensor_reading03, 0, 4095, 0, 1023); // dutyCycle = map(potiWert, 0, 4095, 0, 255);

//******** Kanal 4 ************************************
sensor_reading04 = analogRead(ADC_pin04);
dutyCycle04 = map(sensor_reading04, 0, 4095, 0, 4095); // dutyCycle = map(potiWert, 0, 4095, 0, 255); //Kein Mapping

Serial.print("Tastverh�ltnis 1: ");
Serial.println(dutyCycle01); // Anzeige des Tastverh�ltnises im Seriellen Montitor

Serial.print("Tastverh�ltnis 2: ");
Serial.println(dutyCycle02); // Anzeige des Tastverh�ltnises im Seriellen Montitor

Serial.print("Tastverh�ltnis 3: ");
Serial.println(dutyCycle03); // Anzeige des Tastverh�ltnises im Seriellen Montitor

Serial.print("Tastverh�ltnis 4: ");
Serial.println(dutyCycle04); // Anzeige des Tastverh�ltnises im Seriellen Montitor

//******** Kanal 1 ************************************
ledcWrite(ledChannel01, dutyCycle01); // �nderung der LED-Helligkeit durch PWM

//******** Kanal 2 ************************************
ledcWrite(ledChannel02, dutyCycle02); // �nderung der LED-Helligkeit durch PWM

//******** Kanal 3 ************************************
ledcWrite(ledChannel03, dutyCycle03); // �nderung der LED-Helligkeit durch PWM

//******** Kanal 4 ************************************
ledcWrite(ledChannel04, dutyCycle04); // �nderung der LED-Helligkeit durch PWM

//******** Kanal 1 ************************************
  Serial.print("Frequenz:");
  Serial.println(frequency01);
  analog_voltage01 = sensor_reading01 * 3.3 / 4095;
  Serial.print("Spannung: ");
  Serial.println(analog_voltage01);
  Serial.println();

 //******** Kanal 1 ************************************
    u8g2.setFont(u8g2_font_courR08_tf);
    u8g2.firstPage();

     do {
    u8g2.setCursor(5, 8);
    u8g2.print("Frequenz:");
    u8g2.setCursor(5, 18);
    u8g2.print(frequency01);
    u8g2.print("Hz");

    u8g2.setCursor(5, 28);
    u8g2.print("Spannung:");
    u8g2.setCursor(5, 38);
    u8g2.print(analog_voltage01);
    u8g2.print(" V");


    u8g2.setCursor(5, 48);
    u8g2.print("Tastverhaeltnis:");
    u8g2.setCursor(5, 58);
    u8g2.print(dutyCycle01);

    u8g2.print("/255");

      } while ( u8g2.nextPage() );
     delay(delayTime01);
      }

RAW code

PWM-Signal 1kHz 8Bit Auflösung

PWM-Signal 20kHz 12Bit Auflösung