AVR Tiny 416 Input Capture

[Jürgen (Gast)]

Hallo,

ich möchte mit einem einem Tiny416 eine Capture Messung (Timer B) 
vornehmen. Leider bekomme ich das Event System nicht richtig 
konfiguriert (das Problem sitzt wahrscheinlich vor dem Rechner). Ich 
habe in ATMEL START PA4 (Mein Frequenz Eingang) als Asynchron Event 0 
konfiguriert und in ASYNCUSER0 (Asynchronus User CH 0 - TCB0) diesen 
Asynchron Event 0 eingestellt.

Wenn ich an PA4 ein TTL Signal anlege erhalte ich jedoch im Debugger 
keinen Interrupt. Die entsprechende Interrupt Routine sind in 
driver_isr.c von ATMEL START angelegt.

Was mache ich falsch?

Ciao Jürgen

[Veit D. (devil-elec)]

Hallo,

du hast das mit Atmel Start konfiguriert? Wenn ja, dass geht zwar, nur 
werden dabei soviele inklude Files erzeugt, dass man schwer durchblickt 
was wo wie definiert wurde.

Beitrag "Re: AVR128DB48 - TCB 32Bit Counter"
Hier wurden zwar zwei kaskadiert, dass sollte aber ansonsten gleich 
sein. Der Timer selbst liest sich gleich wie zum Atmega. Nimm davon 
immer nur die Konfig vom ersten TCB, dann sollte das laufen. Ansonsten 
müßtest du deinen Code zeigen. Atmel Start erzeugter Code nützt jedoch 
nichts, zu viele Dateien wie gesagt. Bau es selbst manuell auf. Die 
Register/Bitnamen etc. kannste aus dem Controller Headerfile entnehmen.

[Jürgen (Gast)]

Hallo,

ich habe mir das mal angeschaut. Stimmt eigentlich mit dem überein was 
mir ATMEL START erzeugt hat. Hier mal den Code:

int8_t TIMER_1_init()
{

  // TCB0.CCMP = 0x0; /* Compare or Capture: 0x0 */

  // TCB0.CNT = 0x0; /* Count: 0x0 */

  TCB0.CTRLB = 1 << TCB_ASYNC_bp       /* Asynchronous Enable: enabled */
               | 0 << TCB_CCMPEN_bp    /* Pin Output Enable: disabled */
               | 0 << TCB_CCMPINIT_bp  /* Pin Initial State: disabled */
               | TCB_CNTMODE_FRQPW_gc; /* Input Capture Frequency and Pulse-Width measurement */

  TCB0.DBGCTRL = 1 << TCB_DBGRUN_bp; /* Debug Run: enabled */

  TCB0.EVCTRL = 1 << TCB_CAPTEI_bp    /* Event Input Enable: enabled */
                | 1 << TCB_EDGE_bp    /* Event Edge: enabled */
                | 0 << TCB_FILTER_bp; /* Input Capture Noise Cancellation Filter: disabled */

  TCB0.INTCTRL = 1 << TCB_CAPT_bp /* Capture or Timeout: enabled */;

  TCB0.CTRLA = TCB_CLKSEL_CLKDIV2_gc  /* CLK_PER/2 (From Prescaler) */
               | 1 << TCB_ENABLE_bp   /* Enable: enabled */
               | 0 << TCB_RUNSTDBY_bp /* Run Standby: disabled */
               | 0 << TCB_SYNCUPD_bp; /* Synchronize Update: disabled */

  return 0;
}

int8_t EVENT_SYSTEM_0_init()
{

  EVSYS.ASYNCCH0 = EVSYS_ASYNCCH0_PORTA_PIN5_gc; /* Asynchronous Event from Pin PA5 */

  // EVSYS.ASYNCCH1 = EVSYS_ASYNCCH1_OFF_gc; /* Off */

  // EVSYS.ASYNCCH2 = EVSYS_ASYNCCH2_OFF_gc; /* Off */

  // EVSYS.ASYNCCH3 = EVSYS_ASYNCCH3_OFF_gc; /* Off */

  EVSYS.ASYNCUSER0 = EVSYS_ASYNCUSER0_ASYNCCH0_gc; /* Asynchronous Event Channel 0 */

  // EVSYS.ASYNCUSER1 = EVSYS_ASYNCUSER1_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER2 = EVSYS_ASYNCUSER2_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER3 = EVSYS_ASYNCUSER3_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER4 = EVSYS_ASYNCUSER4_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER5 = EVSYS_ASYNCUSER5_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER6 = EVSYS_ASYNCUSER6_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER7 = EVSYS_ASYNCUSER7_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER8 = EVSYS_ASYNCUSER8_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER9 = EVSYS_ASYNCUSER9_OFF_gc; /* Off */

  // EVSYS.ASYNCUSER10 = EVSYS_ASYNCUSER10_OFF_gc; /* Off */

  // EVSYS.SYNCCH0 = EVSYS_SYNCCH0_OFF_gc; /* Off */

  // EVSYS.SYNCCH1 = EVSYS_SYNCCH1_OFF_gc; /* Off */

  // EVSYS.SYNCUSER0 = EVSYS_SYNCUSER0_OFF_gc; /* Off */

  // EVSYS.SYNCUSER1 = EVSYS_SYNCUSER1_OFF_gc; /* Off */

  return 0;
}

/*
* Interrupt der nie angesprungen wird
*/

ISR(TCB0_INT_vect)
{
    TimerFlags = TCB0.INTFLAGS;
  TimerCNT   = TCB0.CNT;
  TimerCCMP  = TCB0.CCMP;
  
  TCB0.INTFLAGS = TCB_CAPT_bm;
}

Mit dem Scope habe geprüft ob ein Signal an PA5 anliegt. Alles ok. Mit 
dem Debugger habe ich einen Break auf die Interrupt Routine gesetzt, 
kommt nie an.

Bin mit meinem Latein am Ende.

Jürgen

[Veit D. (devil-elec)]

Hallo,

hast du die Interrupts mit sei() generell aktivert?
Funktioniert es ohne asyncron / mit ayncronen Event?
Machst du das alles mit Atmel Start?
Kann erst wieder heute spät Abend drüberschauen ...

[Jürgen (Gast)]

Hallo Veit,

Interrupts sind freigegeben. Der RTC Periodic Interrupt (PI) kommt.

Hab keinen Plan an was es "hängen" könnte.

Ja, ich mache alles mit ATMEL Studio bzw. ATMEL START.

Ciao und Danke schon mal für deine Hilfe.

[Volker B. (Firma: L-E-A) (vobs)]

Jürgen schrieb:

> Hab keinen Plan an was es "hängen" könnte.

M.W. kann ein Portpin nur dann einen Event erzeugen, wenn das zugehörige 
PINCTRL-Register entsprechend initialisiert ist, und zwar:
Bits 2:0 – ISC[2:0]

0x2 RISING Sense rising edge
0x3 FALLING Sense falling edge

Der Reset-Wert 0x0 bedeutet INTDISABLE Interrupt disabled but input 
buffer enabled.

Grüßle
Volker

[Robert (Gast)]

Jürgen schrieb:
> | TCB_CNTMODE_FRQPW_gc; /* Input Capture Frequency and
> Pulse-Width measurement */
[...]
>
>   TCB0.CTRLA = TCB_CLKSEL_CLKDIV2_gc  /* CLK_PER/2 (From Prescaler) */


Schau mal die Errata des Datenblatts:
40.2.1.4 TCB1 [...]
TCB input capture frequency and pulse-width measurement mode notworking 
with prescaled clockThe TCB input capture frequency and pulse-width 
measurement mode maylock to freeze state if CLKSEL in TCB.CTRLA is set 
to other value than 0x0.Fix/Workaround:Only use CLKSEL equal to 0x0 when 
using Input capture frequency andpulse-width measurement mode.

Hat mich auch schon mal einen Arbeitstag gekostet....

[Robert (Gast)]

> M.W. kann ein Portpin nur dann einen Event erzeugen, wenn das zugehörige
> PINCTRL-Register entsprechend initialisiert ist, und zwar:
> Bits 2:0 – ISC[2:0]
>
> 0x2 RISING Sense rising edge
> 0x3 FALLING Sense falling edge
>


Stimmt so nicht. Events sind völlig unabhängig von Interrupts.

[Veit D. (devil-elec)]

Hallo,

also. Was ich bis jetzt herausgelesen habe ist, dass der TCB im 
asyncronen Modus funktioniert nur im Single Shot Mode erlaubt ist. Laut 
Beschreibug im Manual. Ich denke auch das benötigt der TO nicht. Wenn 
das wird der Eingang der gesamten Übung, also Pin PA4, im Event System 
asyncron konfiguriert. Meine Meinung. Ich würde erstmal versuchen alles 
normal syncron zum laufen zubekommen, dann hat man eine Basis um danach 
asyncron auszuprobieren.

TCB sollte so erstmal richtig sein.

void initTCB0 (void)
{
  TCB0.CTRLA = TCB_CLKSEL_CLKDIV2_gc;       // CLK_PER divider
  TCB0.CTRLB = TCB_CNTMODE_FRQPW_gc;        // Capture Mode
  TCB0.EVCTRL = TCB_CAPTEI_bm;              // Enable Event Input and Event Edge
  TCB0.INTCTRL = TCB_CAPT_bm;               // Enable Capture interrupt
  TCB0.CTRLA |= TCB_ENABLE_bm;              // Enable TCB0
}

ISR(TCB0_INT_vect)  // Bsp.
{
  counter.periode = TCB0.CNT;             // read out CNT first, then CCMP
  counter.pulsweite = TCB0.CCMP;
  TCB0.INTFLAGS = TCB_CAPT_bm;            // Clear the interrupt flag
}

Das Eventsystem ist umfangreicher im Vergleich zu meinem ATmega.
Da müßte ich mich erst noch mehr einlesen.
Was stimmen müßte als Anfang wäre

EVSYS.SYNCCH0 = EVSYS_SYNCCH0_PORTA_PIN4_gc;      // Synchronous Event from Pin PA4

Jetzt fehlt noch diesen Sync-Channel-0 dem TCB Capture Eventeingang zu 
zuweisen.

Bei meinem ATmega reicht das hier:

EVSYS.CHANNEL0 = EVSYS_CHANNEL0_PORTA_PIN4_gc;    // set Pin PA4 as input event
EVSYS.USERTCB0CAPT = EVSYS_USER_CHANNEL0_gc;      // Connect user to event channel 0

Beim ATtiny416 ist das anders, sollte jedoch in gewisser Weise ähnlich 
sein. Vielleicht 1-2 Zeilen mehr? Was bei deinem Code fehlt ist genau 
diese Zuordnung. Du hast mittels TCB0.INTCTRL Register den Timer für das 
Eventsystem konfiguriert. Aber das Eventsystem gibt an den 
Timer-Eventeingang noch kein Signal weiter. Hier fehlt noch wie gesagt 
die Zuordnung das der Sync-Channel-0 (woran der Pin PA4 zugewiesen 
wurde) an den TCB0 weitergereicht werden soll. Die Optionsvielfalt 
erschlägt mich jetzt auch ...

[Veit D. (devil-elec)]

Hallo,

scheinbar sind alle Bezeichnungen im Headerfile anders wie ich vom 
ATmega gewohnt bin. Laut meiner Logik sollte das funktionieren. Mangels 
ATtiny kann ich selbst nicht testen. Tut mir leid.

void initEventSystem (void)
{    
  EVSYS.SYNCCH0 = EVSYS_SYNCCH0_PORTA_PIN4_gc;      // Synchronous Event from Pin PA4
  EVSYS.ASYNCUSER0 = EVSYS_ASYNCUSER0_SYNCCH0_gc;   // Connect user to event channel 0
}