FastPwmPin

Arduino library to generate a fast PWM signal on an output pin at maximum frequency. Examples included.

Introduction

FastPwmPin provides a means to generate a high frequency PWM signal on one specific output pin. Where the regular Arduino analogWrite() function allows for generating a fixed frequency signal, this library achieves frequencies as high as 4 MHz using fast timer manipulation. The library produces a PWM signal on a single output pin. The frequency and duty cycle can be selected. The library supports multiple MCU's. The capabilities depend on the specific MCU. While originally aimed at high frequencies, the library can now also generate very low frequencies; depending on the MCU used as low as 1 Hz.

Support for different MCUs

This library supports generating a high frequency signal on different MCUs such as ATmega 328, 168 and ATtiny85. Depending on the MCU, it uses different timers and registers to produce the high frequency signal. The table below gives an overview:

• *support for toggle mode (50%) only

Tested frequencies

This library has been tested on multiple MCU's under various condititions*. The generated signal frequency has been measured using different methods**. The table below lists frequencies measured:

* If you tested this library on a different board-setup, please send me your findings, so I can update the table.
** Frequency was measured using UT89C multimeter, DSO112 mini oscilloscope, Arduino FreqCount serial example on 16MHz Nano and a logic analyzer (@16MS/s).

Installation/Usage

The library can be downloaded from https://github.com/maxint-rd/FastPwmPin. It can be installed as an Arduino library using the Sketch|Library menu. Just add the zipfile library and the enclosed example should appear in the menu automatically.

Initialisation before Setup():

  // include header
  #include <FastPwmPin.h>

Then to initialize the high frequency signal, call the enablePwmPin() method in Setup():

FastPwmPin::enablePwmPin(11, 4000000L, 50);

The enablePwmPin() method has the following syntax:

int FastPwmPin::enablePwmPin(
   const int nPreferredPin=0,
   unsigned long ulFrequency=0L,
   uint8_t nDutyPercentage=FASTPWMPIN_TOGGLE
);

Parameters:
   nPreferredPin - prefered pin to generate the high frequency signal
   ulFrequency - frequency in Hertz
   nDutyPercentage - PWM percentage (duty cycle)

Return value:
   When succesful the method returns the preferred pin as set. If unsuccesful -1 is returned.

Note: To switch a pin fully on or fully off, you must use digitalWrite(). Duty percentages of 100 and 0 result in -1 error return value.

See the enclosed example for more details.

Features & limitations

• When Timer 0 is used (ATtiny84A/44A/13A) the delay() and millis() functions can be impacted (depending on the core used). For the ATtiny84A/44A an alternative implementation of delay() and millis() using the watchdog timer, is included in the library.
• When Timer1 is used (ATtiny85/84A/44A and ATmega 328/168/8A), regular PWM output is impacted.
• When Timer2 is used (ATmega 328/168), the tone() function is impacted.
• For Timer 3 (LGT8F328P) a fixed core with definition of OCR3A is required. See github.com/LaZsolt/lgt8fx
• When Timer3 is used (LGT8F328P) for pin 1 (TX) of the QFP32 board, the serial port cannot be used. WARNING: using this pin for PWM may impact recognition of the Holtec USB chip and may impact flashing firmware! (During my testing a small cap between pin and 3v3 saved unbricked my board).
• The resolution and frequency of the actually generated signal depend on the timer of the MCU used. The supplied parameters are truncated during calculations. The precision of the generated signal depends on this integer truncation as well as on the stability of the MCU clock. A crystal clock is more stable than an RC oscillator or PLL.
• The theoretical maximum frequency at full duty cycle resulution (256 levels) is clock speed divided by 256. At higher frequencies the resolution of the duty cycle gets smaller (converging to 50%). When the MCU is running at lower voltages than specified, the higher frequencies may become unstable.
• On ATtiny84A/44A and ATmega328/168/8A the 16-bit Timer1 is also supported, allowing for lower frequencies and for higher PWM precision (at those lower frequencies).
• At lower frequencies the prescaler is enabled, allowing for lower frequencies and for higher PWM precision (at those lower frequencies). The frequencies that use the different prescaler settings were determined through experimentation and are depending on the MCU used.
• The stability (jitter) of the generated signal depends on the MCU and the selected frequency and duty cycle. In testing the ATtiny13A showed more jitter than the ATtiny85 at higher frequencies. The jitter can easily be measured using the Arduino FreqCount serial example an the serial plotter of the Arduino IDE.

Credits

• This library is based on information found in various sources. See the links below for references.

Links

• About regular PWM:
  https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/
• Extensive post about timers and using them for PWM:
  http://www.gammon.com.au/timers
• About register manipulation to enable fast PWM:
  https://www.arduino.cc/en/Tutorial/SecretsOfArduinoPWM [original with more graphics]
  http://www.technoblogy.com/show?LE0 - "four PWMs on ATtiny85"
  https://www.re-innovation.co.uk/docs/fast-pwm-on-attiny85/
• About limited modes on certain pins:
  https://electronics.stackexchange.com/questions/49401/cant-set-to-fast-pwm-ocra-mode

Disclaimer

• All code on this GitHub account, including this library is provided to you on an as-is basis without guarantees and with all liability dismissed. It may be used at your own risk. Unfortunately I have no means to provide support.