Frequency counter for Attiny3226

[elektroboard]

Hello.
I want to make a frequency measurement with Attiny3226. What should I do to be able to measure the frequency using a TCB timer (or otherwise)?

[SpenceKonde]

Connect the pin to an event channel as generator using EVSYS, set the TCB (probably TCB0, since we're defaulting TCB1 for millis?) as the event user, configure the TCB for input capture frequency measurement, figure out an appropriate clock source for the TCB. Assuming you're running at 20 MHz and do CLK_PER/2, that would get you a 0.1 us resolution (though the whole value would be off by... usually under 1% at room temp... because the oscillator speed isn't perfect (the notches from which the cal pretty much always picks the best of for operation at 25 C are 110-270 kHz apart, commonly a chip might be measured to have between 120kHz and 230kHz) and you can measure up to 2^16 - 65.5 milliseconds.

[elektroboard]

Thanks for reply.

I build below codes. Please control it.

#include <avr/io.h>

// Define a variable to store the captured value
volatile uint16_t capturedValue;

void setup() {
// Configure Pin as an Event Output (Generator) for EVSYS_CHMUX
PORTB.DIRSET = PIN0_bm; // Set PB0 as an output
PORTMUX.EVSYSROUTEA |= PORTMUX_EVOUT0_bm; // Route PB0 to Event Channel 0

// Configure TCB0 as the event user for EVSYS_CH0
EVSYS.CHANNEL0 = EVSYS_GENERATOR_PORTB_PIN0_gc; // Event channel 0 from port B, pin 0
EVSYS.USERTCB0 = EVSYS_CHANNEL_CHANNEL0_gc; // TCB0 as user for event channel 0

// Configure TCB0 for input capture mode
TCB0.CTRLB = TCB_CNTMODE_INTCAP_gc; // Input Capture Mode
TCB0.EVCTRL = TCB_CAPTEI_bm; // Enable Input Event for Capture
TCB0.INTCTRL = TCB_CAPT_bm; // Enable Capture Interrupt

// Set the appropriate clock source for TCB0
TCB0.CTRLA = TCB_CLKSEL_CLKDIV2_gc; // Set TCB0 clock source to CLK_PER/2

// Enable global interrupts
sei();
}

void loop() {

}

// Capture interrupt service routine
ISR(TCB0_INT_vect) {
// Store the captured value
capturedValue = TCB0.CCMP;
}

[hmeijdam]

Here is an example

/*
Example for TCB0 Input Capture Frequency Measurement.
It is using pin PA2 as input and prints the frequency to the serial monitor.
If measuring low frequencies (like 50Hz), you have to select a low clock speed (e.g. 2MHz) or the 16 bit timer will overflow within one period.

Clock speed    Lowest Frequency before timer overflow
 1 MHz          15Hz 
 2 Mhz          30Hz
 4 Mhz          61Hz
 5 MHz          76Hz
 8 MHz         122Hz
10 MHz         152Hz
16 MHz         244Hz
20 MHz         305Hz

Hans Meijdam, July 2023
*/ 
volatile uint16_t timer_capture;

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.PIN2CTRL = PORT_PULLUPEN_bm ; // pullup on the input pin

  // configure event channel
#if defined(__AVR_TINY_2__)// The 2 series parts have a different event system configuration
  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
#else// This is for the 0 and 1 series parts
  EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN2_gc; //link event system async ch0 to pin A2
  EVSYS.ASYNCUSER0 = EVSYS_ASYNCUSER0_ASYNCCH0_gc;// 0x01 Link TimerB (=AYNCUSER0) to event ch0
#endif

  // configure timer B
  TCB0.CTRLB |= TCB_CNTMODE_FRQ_gc; // (0x04<<0), Input Capture Frequency Measurement
  //  on rising edge, will capture into CCMP and reset counter
  TCB0.EVCTRL |= TCB_FILTER_bm ; // activate Input Capture Noise Cancellation Filter
  TCB0.EVCTRL |= TCB_CAPTEI_bm ; // Capture Event Input Enable
//  TCB0.EVCTRL |= TCB_EDGE_bm ; // uncomment if the falling edge needs to be used. Default rising edge
  TCB0.INTCTRL |= TCB_CAPT_bm ; // Capture Interrupt Enable
  TCB0.CTRLA |= (1 << 0); // enable TCB0
}

void loop () {
  Serial.print("Timer capture: ");
  Serial.print(timer_capture);
  Serial.print("  Frequency: ");
  Serial.print(F_CPU/timer_capture);
  Serial.println(" Hz");
}

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  */ 
  timer_capture = TCB0_CCMP;
}

[elektroboard]

Thanks for the response.
I just tried your example of measuring frequency. I detected the frequency steps as 166Hz. Is there a way to increase this resolution

[hmeijdam]

What clock speed did you compile? 20MHz? What frequency do you try to measure?

[elektroboard]

I want to measure approximately 40Khz at a 20Mhz oscillator.

[hmeijdam]

Then just work from the raw "timer_capture" value and create your own logic from there.
The demo I made uses integers and divisions, so is rounding anything down to whole numbers. Especially the calculation of "period" is losing a factor 20 of resolution.

Look at the "Timer capture" value when you slightly change your frequency and you will see it changing with much higher resolution than the frequency number.

[hmeijdam]

When you calculate the frequency as F_CPU/timer_capture you get a better resolution. at 40.000 Hz you would get steps of 80Hz. as it is 500 timer ticks in one period.

I have updated the example by removing the "period" and a better frequency calculation.

[elektroboard]

Can we do 32-bir resolution (TCA0 nad TCA1)?

[hmeijdam]

The datasheet describes how to connect TCB0 and TCB1 to get a 32bit timer. However in your case with the 40KHz you are effectively only using the timer value from 0 to around 500. That's in fact only 9-bits used from the 16., before the timer restarts. If you want a higher resolution, you need a timer (and processor) running at a faster speed than 20MHz.

Or you would have to take a different approach and instead of count the time it takes for just one period, counting the time it takes (micros() for many periods. You would have to use TCA for this, as that timer/counter has an option "count on events", which TCB has not.
You would need a working millis()/micros() for this to work, or you would not know how much time it took to count an x-amount of pulses.

[elektroboard]

I used the freqcount library on the atmega32u4 processor and the resolution was really good. It reads a value that is almost very close to the value I see on the frequency measuring instrument. (library http://www.pjrc.com/teensy/td_libs_FreqCount.html)

Unfortunately, this library does not work for Attiny3226. What method did they use?

[SpenceKonde]

This was meant to be mosted yesterdaty

Here's the part i don't get

// Configure Pin as an Event Output (Generator) for EVSYS_CHMUX
PORTB.DIRSET = PIN0_bm; // Set PB0 as an output
PORTMUX.EVSYSROUTEA |= PORTMUX_EVOUT0_bm; // Route PB0 to Event Channel 0

Comment after third line is total nonsense, and makes no sense to me in the context of what you're trying to do.

The EVSYS takes inputs from "Generators" that many peripherals have. You connect a generator to a channel - if you want to measure a signal coming in on PB0, you want PB0 selected as the generator.

EVSYS.CHANNEL0 = EVSYS_CHANNEL0_PORTB_PIN0_gc;

Yes, that is the channel number in the name of the group code.

That's because these are pre-Ex-series parts. so the channels are non-fungible - 2 ports are available to each channel to act as generator - here for example channels 0-1 get ports A and B, channels 2-3 get C and A, and channels 4-5 get ports B and C. (note - the generator and user organization, if you ever have to work with a 1 series, is hellish. It's so bad. and the subtle deficiencies end up being sufficiently noticeable that they interfere with your ability to use the parts. There are in fact, prior to the EA-series, no two event channels on any single device that - were you to list their generators, no two channels would be identical. without knowing what generator was needed you could never say "I can use this channel or that channel" You could say that once you knew the generator needed, because depending on the part (as long as it's not a 0/1-series tiny, which are a warren of special cases and are impossible to speak coherently about because the designers were not thinking coherently yet), one of the following three cases will be applicable: It is neither a pin nor RTC generator -> any channel can be used. It is a pin. There are 2 (or 4 on the tiny2's) channels that can carry a given pin, with consecutive numbers. On tiny2, the channels have 3 ports and 6 channels each of which can handle 2 ports. so they did obvious thing - 0/1 gets A (0x40-47) and B (0x48-4F) 2/3 gets C and A, and 4/5 gets B and C. And after 1-series but before EA series, for all parts (DA-DD, unknown which side of the line the DU will be on, hopefully EA's side- consistent with the chronology, but the Dx and Ex parts seem to be based on different designs.

And EVSYS.USERTCB0CAPT should be set to (channel number + 1) in order to use that channel as an event input.

It's very important to keep straight event inputs and outputs, as the names don't always make it obvious which it is.
The USERS, that is, device INPUTs have names starting with EVSYS.USERPERIPHERAL, and they are registers you set to a value between 0 (off, thre default) and highest channel number +1 (to get the highest number channel), that is, the channel used is the value you write to that aforementioned register less 1.

The GENERATORS, that is, the output instead get names like EVSYS_CHANNEL#_PERIPHERAL_EVENTNAME_gc, and these are values that you write to the CHANNELn registers to connect the channel to that geneator.

Each channel can connect to 1 generato
Each user can connect to 1 channel, and each can be assigned to whichever channel you like (except on 1 series)
One channel can have many users, or just 1, that part doesn't matter.

The EVOUT stuff relates to having a pin change state based on the event channel. You want the opposite so it has no place here.

[elektroboard]

Thanks for such quality information.