PWM : Example 2: Variable frequency and duty cycle PWM

[coderatchance]

Hello all,

I am digging into the PWM on the series 1, so far so good, I can program the chips easily thanks to this core!

Used the basic analogWrite() and I am not happy with the freq. I get, for example, on tiny45, 85 it was below around 500Hz, but now, if the same is used , somehow the freq. is 1kHz, hence I am looking into the manual configuration, namely "taking over the TCA0".

Started with the basic example , such as Example 2: Variable frequency and duty cycle PWM, however, I get the compilation error with the following line:

PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;

Anybody faced the same issue ?

The idea is update the following code with the new PWM setup.

This code runs OK on the AT Tiny 3216 which I am programming via the Arduino UNO general UPDI ... !

//LED Pin
byte brightness;
const byte ledPin = 0;  // PA4
const byte touchPin = 1; //QT sensor output, this can as well be a simple switch, however, it should have the digital out, otherwise problems of debounce may occur.

bool OS;

//(original) PWM table (255) according to (excel formula) : =1/(1+EXP(((A2/21)-6)*-1))*255
const PROGMEM byte table[] = {
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  3, 3, 3, 3, 3,
  4, 4, 4, 4, 4,
  5, 5, 5, 5,
  6, 6, 6, 6,
  7, 7, 7, 7,
  8, 8, 8, 8, 8,
  9, 9, 9, 9,
  10, 10, 10, 10,
  11, 11, 11, 11,
  12, 12, 12,
  13, 13,
  14, 14, 14,
  15, 16,
  17, 17,
  18, 19, 20,
  21, 21,
  22, 23, 24, 25, 26, 27, 28, 29, 30,
  32, 33, 34,
  36, 37, 39,
  41, 42,
  44, 46, 47, 49, 51, 53, 55, 57, 59, 62, 64, 66, 69, 71, 73, 76, 79,
  81, 84, 87, 89, 92, 95, 98, 101, 104, 106, 109, 112, 115, 118, 121, 124, 128, 131, 134, 137, 140, 143, 146, 149, 151, 154, 157, 160, 163, 166,
  168, 171, 174, 176, 179, 182, 184, 186, 189, 191, 193, 196, 198, 200, 202, 204, 206, 208, 209, 211, 213, 214, 216, 218, 219, 221, 222, 223,
  225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 238, 239, 240, 240, 240,
  241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 247, 248, 248, 248, 249, 249, 249, 249,
  250, 250, 250, 250, 250, 250,
  251, 251, 251, 251, 251, 251, 251,
  252, 252, 252, 252, 252, 252, 252, 252,
  253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
  254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254
};

void setup()   {
  Serial.begin(115200);
  Serial.println(" Setup: Serial ON ");

  pinMode(touchPin, INPUT); // set the port for the input // is there as well the pull_down available on at tiny3216 ?

  //begin with the brightness 135, it is 8bit so it should be between 0 and 255
  brightness = 135;

}

void loop() {

  //printing out the values
  Serial.print(OS);
  Serial.print(" ");
  Serial.println(brightness);


  OS = digitalReadFast(touchPin);

  //fading up if touch pin is high
  if (OS) {
    if (brightness < 255) { //254
      // not sure how to otherwise speedup the brightness
      brightness = brightness + 1; //15
      if (brightness >= 255) {
        // fade the led
        analogWrite(ledPin, pgm_read_byte(&table[brightness]));
      }
    }
  }

  //fading down, if touch pin is low, which is when it is not high :)
  //fading going down
  if (!OS) {
    if (brightness > 1) { //1
      // not sure how to otherwise speedup the brightness
      brightness = brightness - 1;  //-15
      if (brightness <= 1) {

        //fade the led
        analogWrite(ledPin, pgm_read_byte(&table[brightness]));

      }
    }
  }
}//end of main loop

And this is the error when trying to compile the Example 2: Variable frequency and duty cycle PWM :

/Users/imac/Documents/Arduino/At_Tiny_3216/tre_PWM/tre_PWM.ino: In function 'void setup()':
treniram_PWM:15:11: error: 'PORTMUX_t {aka struct PORTMUX_struct}' has no member named 'TCAROUTEA'
   PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;
           ^~~~~~~~~
treniram_PWM:15:34: error: 'PORTMUX_t {aka struct PORTMUX_struct}' has no member named 'TCAROUTEA'
   PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;
                                  ^~~~~~~~~
treniram_PWM:15:48: error: 'PORTMUX_TCA0_gm' was not declared in this scope
   PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;
                                                ^~~~~~~~~~~~~~~
/Users/imac/Documents/Arduino/At_Tiny_3216/treniram_PWM/treniram_PWM.ino:15:48: note: suggested alternative: 'PORTMUX_TCB0_bm'
   PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;
                                                ^~~~~~~~~~~~~~~
                                                PORTMUX_TCB0_bm
treniram_PWM:15:68: error: 'PORTMUX_TCA0_PORTC_gc' was not declared in this scope
   PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;
                                                                    ^~~~~~~~~~~~~~~~~~~~~
/Users/imac/Documents/Arduino/At_Tiny_3216/treniram_PWM/treniram_PWM.ino:15:68: note: suggested alternative: 'PORTMUX_TCA0_1_bm'
   PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTC_gc;
                                                                    ^~~~~~~~~~~~~~~~~~~~~
                                                                    PORTMUX_TCA0_1_bm
exit status 1
'PORTMUX_t {aka struct PORTMUX_struct}' has no member named 'TCAROUTEA'

Any ideas ?

[hmeijdam]

If you post your whole sketch, that gives you the error, and tell which attiny you are using, people can import your sketch and try it out.

[SpenceKonde]

The timer clocks are derived from the system clock. We don't get as many options for prescalers as we would like. Generally you get options a factor of 4 away, keep the pwm speed within a factor of 2 of 980Hz.

There were two important differences between the modern tinyAVR timers and classic tiny85 timer:

1. The tiny85's timer1 had every power of 2 up to 1024 as an option, whereas we get 1/2/4/8/16/64/256/1024 on the TCA's, 1/2/"copy that TCA" on TCBs, and the TCD can have count prescale of 1/4/32, and sync prescale of 1/2/4/8, giving a total of 1/2/4/8/16/32/64/128/256 clocks per timer tick. This is considerably more constraining)
2. The tiny85 you were getting ~500 Hz out of was likely running at 8 MHz, the new tiny is likely running at 16 or 20. Hence the frequency is going to be higher.

Prescaler	TCAn	TCBn	TCD0	TCD0 sync	TD0 counter
CLK	YES	YES	YES	YES	YES
CLK2	YES	YES	YES*	YES	NO
CLK/4	YES	TCA	YES	YES	YES
CLK/8	YES	TCA	YES*	YES	NO
CLK/16	YES	TCA	YES*	NO	NO
CLK/32	NO	NO	YES	NO	YES
CLK/64	YES	TCA	YES*	NO	NO
CLK/128	NO	NO	YES*	NO	NO
CLK/256	YES	TCA	YES*	NO	NO
CLK/1024	YES	TCA	NO	NO	NO
(from Ref_Timers)

megaTinyCore expected pwm speeds:

CLK_PER	Prescale	fPWM
32 MHz	256	490 Hz
30 MHz	64	1836 Hz
28 MHz	64	1716 Hz
27 MHz	64	1654 Hz
25 MHz	64	1532 Hz
24 MHz	64	1471 Hz
20 MHz	64	1225 Hz
16 MHz	64	980 Hz
10 MHz	64	613 Hz
8 MHz	64	490 Hz
5 MHz	16	1225 Hz
4 MHz	16	980 Hz
1 MHz	8	490 Hz

Target was minimum 490 Hz, under 1900 Hz - that's a frequency range that most MOSFETs can be PWMed at directly, though the top half of that range starts to get dicey if the fet beefy - but my only other option was to drop the prescale all the way down to 256, at which point the PWM would be slow enough to see a flicker.
(see https://github.com/SpenceKonde/ProductInfo/blob/master/MOSFETs/Guide.md for excruciating detail on how fast you can drive a mosfet without specialized IC's)

We use a PWM timer period of 255 ticks, meaning period = 254. If you do 256 ticks, not only is the millis math using a TCA much harder, it also ensures that analogWrite() cannot take a 0-255 argument and do what it promises: There are 257 states (on 100%, plus 0 through 255 256ths on) that you're trying to choose from which is impossible with 8 bits. So we took the very strong hint and did 254.

TCBs are not used by mTC for generating PWM - they overlap in almost every case with other timers for PWM, plus they are spectacular millis timers when configured in a way that doesn't let them generate PWM.

(We default TCA0 for millis on 0-series with only a single TCB, so that that tcb can be used for tone or servo; on 1-series we fob the task off on the unruly TCD0 by default because nobody is likely to take it over, even though it's the worst of the timers for millis, and on 2-series, since they have 2 TCBs, we use one of those as the default millis.
See https://github.com/SpenceKonde/megaTinyCore/edit/master/megaavr/extras/Ref_Timers.md would be highly recommended reading.

[coderatchance]

Thanks for this info, I am new to this, however, I am expecting to have a problem with a MOSFET, because it is indeed not fast enough and due it may overheat itself by even trying t follow , so, looking for a basic PWM with 490Hz or even less like 300Hz, but on the 20MHz clock with the Tiny3216/17 ?
Not sure where to set the "Prescale" to even get the 490Hz...

Looked at the ATTiny_PWM library, but the issues is the same... although the API seems to be more approachable then putting the code together with raw TCA0...

[SpenceKonde]

if 1/4th the 1225 Hz figure would be good, you're in luck!
because that ~305 Hz frequency is what you get out on all the TCA PWM pins (PC0 and PC1 have TCD pwm and dont quite work the same) * if you were to change nothing else and just nudge the prescaler down to 256 instead of 64.
From register summary we see that clkctrl is in ctrla, per description in

Bits 3:1 – CLKSEL[2:0] Clock Select
These bits select the clock frequency for the timer/counter.

Value	Name	Description
0x0	DIV1	fTCA = fCLK_PER
0x1	DIV2	fTCA = fCLK_PER/2
0x2	DIV4	fTCA = fCLK_PER/4
0x3	DIV8	fTCA = fCLK_PER/8
0x4	DIV16	fTCA = fCLK_PER/16
0x5	DIV64	fTCA = fCLK_PER/64
0x6	DIV256	fTCA = fCLK_PER/256
0x7	DIV1024	fTCA = fCLK_PER/1024

Using the defines that toolchain provides:

uint8_t ctrla = (TCA0.SINGLE.CTRLA &~(TCA_SINGLE_CLKSEL_gm)); // mask off old value
ctrla |= TCA_SINGLE_CLKSEL_DIV256_gc; //set bits of new value 
TCA0.SINGLE.CTRLA = ctrla;  

also demonstrates proper practice of the local variable when accessing a volatile register.

The core only sets that register during initialization and during takeOverTCAn so the core shouln't stamp on your toes there.

Our general policy on code that exists primarily to expose a peripheral should be in a library unless tight integration with the core is required (as with the ADC) - for example. Event, CCL, Opamp (DxCore) are all effectively independent libraries, whereas the enhanced ADC section isn't because it is intimately linked to normal ADC functionality.

So TCA, TCB, and TCD all really ought to have their own library even if all it does is provide enums and and paraphrase a combination of the datasheet and common sense. Except as you start looking, it becomes unavoidably obvious that these are useless without tightly associated code and dear god on total they are incredibly complicated. So nobody has written a library to even do this minimal level of making them more user friendly. But just making minimalist wrapper libraries is a lot of work,

Personally, I'd break them down like:

TCASplit.h // Full control over a TCA in SPLIT mode
TCASingle.h // Full control over a TCA in SINGLE mode
TCBPWM.h // Full control over a TCB in PWM mode, would be easy to write.
TCBSingleShot.h //Single shot - possibly combinable with timeout and interrupt. 
TCBInterrupt.h // periodic interrupt. would be trivial to write 
TCBTimeout.h // Timeout mode two or all three of these may work to combine into one
TCBEvent.h // For 0x02, where it works like it did on old AVR - that is, the timer never resets, you have to track it yourself, but you never miss events that you shouldn't miss. Here, the time of the event is determined from comparing the most recent and previous counter values. We could do this automatically quickly, and require the user function to accept a uint16_t and a uint8_t with the time since last trigger and whether OVF was set.) 
TCBAdvEvent.h  // For all the 4 other event capture modes! Here the timer DOES reset in most measurement cycles, but often provides may provide two values. We could pass the user code 2 16-bit values (ccmp and cnt) and possibly a uint8_t indicating if an OVF was detected. 
TCDBasic.h // 2 PWM channels. No fault events, dither, delayed events, etc. 
TCDFull.h // As above, but with the mindnumbing number of options and parameters. 

*- you do not want to have to fiddle with the TCD if you can avoid it, the TCD is the most complicated peripheral on any modern AVR, rivaled only by the ADC on the EA, and that while surely more complicated under the hood, was at least explained reasonably well in the documentation (removal of the mysterious constants helped too), whereas I think the TCD chapter could go at least half again as long to properly cover the subject.

[coderatchance]

Thanks, I have put the above code to the setup() and it works like a charm!
Indeed, simple libraries would help a lot!