Examples for using events, timers and interrupts together

[fijam]

Arguably the most compelling feature of those newer chips is the event system and the more powerful timers. Unfortunately there is not much on how to actually use them together. The documentation in PWMandTimers.md mentions that the type B timers are great as utility timers but no examples are provided (I only found examples for TCA and PWM stuff).

I know that there is a plan to wrap this functionality in a more convenient library eventually (#481) but in the meantime some examples for simple stuff (how do I configure a timer? how do I connect an event to a timer? how do I get the timer to generate an interrupt when it expires? how can I measure the length of a pulse?) would be a tremendous help. I can take a look at examples provided by Nick Gammon 10 years ago for the classic Atmel parts such as this one and be up and running in minutes. Something like that but updated for the new features in the 0/1/2 series would be very useful.

I've tried to start with the example for DxCore in MCUdude/MegaCoreX#126 (comment) but I guess some parts of the event library were added after the 2.4.2 release of megaTinyCore.

[hmeijdam]

As part of my own learning curve with these features. I played with capturing a servopulse from an RC receiver and print that.
It's using the event system and the input capture.
Maybe it helps.

(compile with millis disabled)

// ATtiny412 / ARDUINO
//                                     _____
//                             VDD   1|*    |20  GND
//       (TXD) (DAC) (AIN6) PA6  0   2|     |19  4~  PA3 (AIN3)(SCK)(EXTCLK)
//       (RXD)       (AIN7) PA7  1   3|     |18  5   PA0 (nRESET/UPDI)
// (MOSI)(TXD*)(SDA) (AIN1) PA1  2   4|_____|17  3   PA2 (AIN2)(MISO)(RXD*)(SCL)
//
//
// connect servo signal to PA2 for triggering PWM capture
// use PA6 to read pulsewidth on serial terminal (9600 baud)
// connect servo to PA1

volatile uint16_t pulsewidth;

void setup () {
  //Serial.swap();// use this to set the TXD*/RXD* to their alternate pins
  Serial.begin(19200);// Default Serial TX is on pin 0 (PA6)
  //  PORTA.PIN3CTRL = PORT_PULLUPEN_bm | PORT_ISC_LEVEL_gc; // interrupt active at low level
  PORTA.PIN2CTRL = PORT_PULLUPEN_bm ; // pullup
  //  PORTA.PIN3CTRL = PORT_PULLUPEN_bm | PORT_ISC_RISING_gc; // rising edge
  //  PORTA.PIN3CTRL = PORT_PULLUPEN_bm | PORT_ISC_BOTHEDGES_gc; // both edges

  // configure event channel
  EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN2_gc; //link event system async ch0 to pin A2
  // EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN3_gc; //0x0d, link event ch0 to pin PA3
  // EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN2_gc; //link event ch0 to pin PA2
  EVSYS.ASYNCUSER0 = EVSYS_ASYNCUSER0_ASYNCCH0_gc;// 0x01 Link TimerB (=AYNCUSER0) to event ch0

  // configure timer B
  TCB0.CTRLA |= TCB_CLKSEL_CLKDIV2_gc; // 0x2 , select clock (divided by 2)
  TCB0.CTRLB |= TCB_CNTMODE_PW_gc; // (0x04<<0), Input Capture Pulse-Width measurement
  // will reset counter on positive edge and capture next falling edge into CCMP
  TCB0.EVCTRL |= TCB_FILTER_bm ; // activate Input Capture Noise Cancellation Filter
  TCB0.EVCTRL |= TCB_CAPTEI_bm ; // Capture Event Input Enable
  TCB0.INTCTRL |= TCB_CAPT_bm ; // Capture Interrupt Enable
  TCB0.CTRLA |= (1 << 0); // enable TCB0

  sei();// enable interrupts
 
}
void loop () {
  uint16_t servopulse = pulsewidth / (F_CPU / 2000000L);
//  Serial.print("Pulsewidth is: ");
  Serial.println(servopulse);
//  Serial.println(" ms");

}
ISR (TCB0_INT_vect) {
  /*The CAPT Interrupt flag is automatically cleared 
  after the low byte of the Compare/Capture (TCBn.CCMP) register has been read.
  datasheet chapter 21.3.3.1.5  */ 
  pulsewidth = TCB0_CCMP;
}

[elektroboard]

Hi. how can we adapt these codes for Attiny3226?

[hmeijdam]

The event system has to be configured slightly different in that case.
replace it with this in above example

  // configure event channel
  EVSYS.CHANNEL0 = EVSYS_CHANNEL0_PORTA_PIN2_gc; //link event system ch0 to pin A2
  EVSYS.USERTCB0CAPT = EVSYS_USER_CHANNEL0_gc;// Connect TCB0 capture to event channel 0

[hmeijdam]

Then I did more or less the same to learn about using TimerD

// ATtiny412 / ARDUINO
//                                     _____
//                             VDD   1|*    |20  GND
//       (TXD) (DAC) (AIN6) PA6  0   2|     |19  4~  PA3 (AIN3)(SCK)(EXTCLK)
//       (RXD)       (AIN7) PA7  1   3|     |18  5   PA0 (nRESET/UPDI)
// (MOSI)(TXD*)(SDA) (AIN1) PA1  2   4|_____|17  3   PA2 (AIN2)(MISO)(RXD*)(SCL)
//
//

volatile uint16_t pulsewidth;
volatile uint8_t pulse_available;

void setup() {
  takeOverTCD0();// Understand this will give me control of the timer.

  //  Serial.swap();// use this to set the TXD*/RXD* to their alternate pins
  Serial.begin(115200);// Default Serial TX is on pin 0 (PA6)

  // configure event channel
  PORTA.PIN2CTRL = PORT_PULLUPEN_bm;
  EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN2_gc; //link event system async ch0 to pin A2
  // EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN3_gc; //0x0d, link event ch0 to pin PA3
  // EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN2_gc; //link event ch0 to pin PA2
  EVSYS.ASYNCUSER6 = EVSYS_ASYNCUSER6_ASYNCCH0_gc;// Link TimerD Event0 (=ASYNCUSER6) to event ch0
  EVSYS.ASYNCUSER7 = EVSYS_ASYNCUSER7_ASYNCCH0_gc;// Link TimerD Event1 (=ASYNCUSER7) to event ch0


  // configure timer D
  TCD0.EVCTRLA = B01010101; // 7,6 CFG=filter on, 4 edge=rise , 2 action=capture, 0 input enable
  TCD0.EVCTRLB = B01000101; // 7,6 CFG=filter on, 4 edge=fall , 2 action=capture, 0 input enable

  TCD0.CTRLB |= TCD_WGMODE_ONERAMP_gc; // Set timer to one ramp mode (=default)
  TCD0.CTRLA |= TCD_CLKSEL_SYSCLK_gc; // Internal 16/20 MHz Oscillator (OSC20M)
  TCD0.CTRLA |= TCD_CNTPRES_DIV4_gc; // Division factor  (1, 4 or 32 possible)
  TCD0.CTRLA |= TCD_SYNCPRES_DIV4_gc; // Division factor  (1, 2, 4 or 8 possible)
  TCD0.INTCTRL |= TCD_TRIGB_bm; // Enable interrupt when trigger B is received (falling edge)
  TCD0_CMPBCLR = 4095; // set TOP

  TCD0.CTRLA |= TCD_ENABLE_bm; // enable TCD0 (also sends a sync)

  Serial.println(TCD0.CTRLA, BIN); // to check content of CTRLA
  Serial.println(TCD0.STATUS, BIN);// to check content of STATUS
  Serial.println(TCD0_CMPBCLR);
}

void loop() {
  if (pulse_available) {
    //    risecapture = (TCD0_CAPTUREA << 4);
    //    fallcapture = (TCD0_CAPTUREB << 4);
    //    Serial.print(risecapture);
    //    Serial.print("   ");
    //    Serial.print(fallcapture);
    //    Serial.print(" difference:  ");
    Serial.println(pulsewidth >> 4);
    pulse_available = 0;
  }
}

ISR (TCD0_TRIG_vect) {
  byte flags = TCD0.INTFLAGS;  // read the interrupt flags
  pulsewidth = (TCD0_CAPTUREB << 4) - (TCD0_CAPTUREA << 4);
  TCD0.INTFLAGS = flags;// writing "1" to the interruptflag bit will clear it
  pulse_available = 1;
}

[hmeijdam]

And an example playing with the Real Time Clock (RTC) and the Programmable Interruupt Timer (PIT)

//// Blink AttinyXX4 with Realtime RTC-Timer ////
// need to have PortB, so no 8 pin parts.
//
void setup() {
  //configure output pins
  VPORTA_DIR |= PIN6_bm;   // set pin PA6 as output
  VPORTB_DIR |= PIN0_bm;   // set pin PB5 as output

//  CCP = CCP_IOREG_gc;    // enable write to protected IO registers (timed sequence)
//  CLKCTRL_MCLKCTRLA |= CLKCTRL_CLKOUT_bm;// output CLK to CLKOUT pin

  //Configure clock source used by both PIT and RTC
  RTC_CLKSEL = RTC_CLKSEL_INT32K_gc; /* Internal 32kHz OSC */
  //RTC_CLKSEL = RTC_CLKSEL_INT1K_gc; /* Internal 1kHz OSC */
  //RTC_CLKSEL = RTC_CLKSEL_EXTCLK_gc;  // Use EXTCLK pin as clock source (connect to CLKOUT)
  //Configure RTC
  while (RTC_STATUS & RTC_PERBUSY_bm) {} // wait until RTC_PER is available for writing
  RTC_PER = 500; // write period (16bit) to period
//  RTC_PER = 50000; // write period (16bit) to period
  RTC_INTCTRL |= RTC_OVF_bm; // activate overflow interrupts
  RTC_CTRLA |= RTC_RTCEN_bm; // turn on RTC

  //Configure PIT
  RTC_PITINTCTRL |= RTC_PI_bm;    // activate PIT Interrupt enable
  RTC_PITCTRLA   |= RTC_PERIOD_CYC1024_gc | RTC_PITEN_bm;// set PIT period and enable

//  sei(); // turn on global interrupts (not needed ??)
}

void loop() {}

ISR(RTC_PIT_vect) {             // RTC Interrupt
  RTC_PITINTFLAGS = RTC_PI_bm;  // clear  Interrupt Flag
  PORTA_OUTTGL = PIN6_bm;       // toggle Pin/A6
}

ISR(RTC_CNT_vect) {             // RTC Interrupt
  RTC_INTFLAGS = RTC_OVF_bm;  // clear  Interrupt Flag
  PORTB_OUTTGL = PIN0_bm;       // toggle Pin/B5
}


//The Realtimer-Counter (RTC) have a own 32,768KHz Cristal.
// 32.768KHz / CYCprescale = periodtime in mS
//
//  BIN         NAME        TIME
// 0b00001001  CYC4        0,122 mS
// 0b00011001  CYC8        0,244 mS
// 0b00011001  CYC16       0,488 mS
// 0b00100001  CYC32       0,977 mS
// 0b00101001  CYC64       1,953 mS
// 0b00110001  CYC128      3,906 mS
// 0b00111001  CYC256      7,813 mS
// 0b01000001  CYC512      15,63 mS
// 0b01001001  CYC1024     31,25 mS
// 0b01010001  CYC2048     62,50 mS
// 0b01011001  CYC4096    125,00 mS
// 0b01100001  CYC8192    250,00 mS
// 0b01101001  CYC16384   500,00 mS
// 0b01110001  CYC32768  1000,00 mS

[SpenceKonde]

Are you folks aware of the Event.h library?

It's now actually usable, and equipped with functions that will find an unused channel for many generators, and give you generators if you specify just pass it the periperhal (ie, you pass gen_from_peripheral(CCL,1) you get the generator 1 from the CCL (that is, CCLLUT1OUT.)

Works with most of the peripherals you're likel;y to care about.

I also had code that would make a tiny 412 act to split WS2812 datastreams (ie first 100 LEDs go down this wire, then the rest go down that wire), but I was havign problems with it and since Im in the midst of a move what was forced on us (we're being evicted, a great thanks from the landlord for paying our rent on time and in full throughout the pandemic - we've got a new place that I need to move a heroic amount of stuff tyo in the next 14 days.... and my roommmates just told me that they've LOST THE FUICKING KEYS TO THE NEW PLACE/.....anyway.... I haven'y ad a cance to work on that further. It was pretty cooll tjough And with a tiny424, you could do up to 4 strings the use case is the fairy lghts, which are usuially not chainable, and even if they were the power injection wires would loook likeshit.

[hmeijdam]

I know about the Event.h library, but have not used it yet.

Good luck with your move LOL.

[SpenceKonde]

Good luck with your move LOL.

It's a bit too late for that. I'll accept "neutral luck" at this point.

[fijam]

@hmeijdam those examples look very useful, much obliged!

@SpenceKonde do you plan a new release of megaTinyCore after you move? I think a lot of work went into the event library since 2.4.2

[SpenceKonde]

2.5.0and DxCore 1.4.0 are going out tonight. They were planned to go out sunday.

[SpenceKonde]

After that, no major development work will be permitted on the modern cores until I've released 2.0.0 ATTinyCore whose popularity still dwarfs the modern parts (and after that I will decree that it will no longer be gettign new features and in another 6 months or so start referring to them as legacy parts. 😎

[SpenceKonde]

Once attinyCore 2.0.0 s out, I'll work on power save and rtc libraries for over here. and try to pull off a few particularly bold tricks I've ben wanting to involving WS2812 control. interruptdriven 2812B control anyone? What about a WS2812 spy? As long as you can output at serial > 1 mbaud. (ie, so you don't have buffering overhead, a WS2812B signal should be relatively graceful to spyon and output the data as serial. Could also have something that could modifythe datastream on the fly and retransmit....

[SpenceKonde]

One comment about events and timers - that "timeout check mode" of TCB is an incredibly useful mode for a lot of things.

[Rollpopptery]

I would love to setup a timer to run an ISR periodically.

[SpenceKonde]

There's actually a library that does that, the guy maintaining it made a thread at Arduino forums. it will never be particularly performant, because of the nature of how any form of "attachInterrupt() like function works (the compiler has to respect both the ABI (which says that a function may freely clobber r0, find 0 in r1, and freely clobber r18-r27, and r30/r31) and the rules about behavior in interrupts (all working registers must have their state restored) - in other words "save and restore an extra 14 registers that we may not even need". Also because of the code is , and the inlining that would normally save you from this can't occur because it's using an indirect call (icall) with the net effect of wasting like 50 clocks and 30 bytes, plus the overhead of the library itself, but whether you care will depend on your use case. (in a normal function, the compiler plans ahead by storing results that are not referenced again in those registers, so while it might need to make room elsewhere within the working registers to store stuff it will need to know after a function, it doesn't have to save and restore a register that it doesn't care what the value of is. In an ISR all working registers have tobe assumed to contain vital data and need to be saved and restored (2 words and 3 clocks per register). If the interrupt didn't have to make an actual function call, only registers it needed would be saved and restored, but icalls are a barrier to that optimization, since they could point to any function. And the overhead of the library slows things down further...

But it does more for you.

Minimal periodic int demo is something like

// setup
// You could use TCB1 with by changing the register names to start with TCB0
// Whichever timer you use, it can't be the millis timer. 
TCB1.CTRLA = 0x00; // turn off timer(if not known to be 0)
TCB1.CTRLB = 0x00; //periodic interrupt, and those other 3 bits are all unused here. 
TCB1.INTFLAGS = TCB1.INTFLAGS;
TCB1.INTCTRL = 0x01;
// How often do we want it to fire? convert to clock cycles.
// We'll call this number T
// If T is less than 2^16:
uint8_t ctrla = 0x01 // enable clock source div/1
// otherwise divide T by 2 (if you were doing this at runtime you'd rightshift, not divide, but often you're doing this out on paper for constant values. 
// if T is now less than 2^16
uint8_t ctrla = 0x03; // enable, clock source = div/2
// Aw shit, we can't prescale the clock enough, so have to borrow a the prescaler of timer A. Assuming that's not been changed from the core default of 64, divide T by 32 ( rightshift 5) 
// if T is *now* less than 2^16
uint8_ctrla = 0x07; // Enable borrowing TCA0's prescaler. which the core set to 64
// If T is still larger than 2^16, you have a problem. 
// You can set TCA0's prescaler higher, but that slows down PWM frequency too. The options  are 1,2,4,8,16,64,256,1024 - and we're already at 64 when the core starts... 
// and you'd better not be using TCA for millis. 
// If that is acceptable, 
uint8_ctrla = 0x07; 
// divide T by 4. Is this less than 2^16? If so:
TCA0.SINGLE.CTRLA = 0x0D; // ref: 21.7.1 Control A - Split Mode, this is 256 prescale
// will dividing it by 4 one last time do it?
// if so we can do it with the maximum prescaling
TCA0.SINGLE.CTRLA = 0x0F; // 1024 prescale
// If T is still higher than 2^16, even after you've in total divided it by 1024, that's more than I'm willing to write an example for 
TCB1.CCMP = T;
TCB1.CTRLA=ctrla;  //only after assigning T to CCMP do we write to CTRLA to turn it on. 
// end setup 


// outside of any functions 
ISR(TCB1_INT_vect) {
 //do your stuff here, remembering that you want it to be short, and that things that require memory are at a speed premium and function calls that won't be optimized away by inlining are very costly (a function will be inlined only if set to always inline or if it is only called from one place)
TCB1.INTFLAGS = 0x01;  //You must reset the intflag at the end of the interrupt, or you will immediately retrigger, executing only 1 instruction outside of the interrupt per loop iteration. 
}

Periodic interrupt mode is very simple. The others are much more complicated to use.

That said, give thought to whether a periodic interrupt is the correct approach - frequently it is not, and you;d be better served by using millis and blink-without-delay tactics.

In short, you want to only do in an ISR somethingthat can't be done any other way.

[Rollpopptery]

Thankyou very much for this. I ended up with TCB0 because attiny806, and found microchip doc TB3214. My interrupt is at 53 KHz, I'm bit-banging 8 independent PWMs on 8 different pins. also, using Wire and SerialUART . Everything is rock solid As an aside; I was programming z80 in 1994 using op-codes from a book, the idea of calling a function from within an interrupt makes me feel sick to the stomach.

[nlCortana]

Hi,
Thank you for these examples. It really helped me out getting the interrupt working (forgot to clear the flag :(

I see a lott of helpfull name constants/macro's, like:
TCD_WGMODE_ONERAMP_gc
RTC_CLKSEL_INT1K_gc

Where are these macro's / constant names documented? I cannot find these.

[hmeijdam]

They are mostly defined in the part specific header file

They are sometimes a bit hard to find in the directory structure. I am using portable installations of the Arduino IDE, so on my PC it is this directory
E:\Arduino\arduino-1.8.13-megatinycore\portable\sketchbook\hardware\megaTinyCore\megaavr\extras\ioheaders

For the Attiny412 the file would be named as iotn412.h

But you can find them also all here