Berekenen duur van een interrupt

[conara]

Ik ben opzoek naar een methode om effectief te kunnen meten of te bepalen hoe lang de maximale duur van een interrupt is op een microcontroller (Atmel UC3A0). Ik heb een eenvoudige en korte interrupt bijvoorbeeld:

code:

        if (parameter != 100) { 
            if(parameter > 80) {
                if (parameter == 0) {
                    parameter--;
                }
            }
            else {
                if (parameter == 0) {
                    parameter++;
                }
            }
            parameter++;
                        parameter << 5;
        }
        else { 
            if(parameter == parameter) {
                if (parameter == 0) {
                    parameter++;
                }
            }
            if (parameter == 100) {
                parameter++;
            }
            parameter = (parameter >> 50);
        }
        parameter = 5;
        if (parameter == 0) {
            *zet iets in een queue (FreeRTOS)
        }

De code is niet ingewikkeld en daardoor ook lekker kort, maar ik wil toch eigenlijk meten of berekenen hoelang de interrupt duurt.

Zelf dacht ik per instructie de hoeveelheid klokslagen opzoeken (als het omgezet is naar machinecode), maar er moeten betere handigere manier zijn lijkt me. Meten is natuurlijk een andere mogelijkheid, maar hoe kan ik dacht het best aanpakken? Het is voornamelijk van belang dat ik een goede indicatie heb hoelang dit duurt, maar niet dat ik eerst uren moet gaan zitten prutsen met counters ect. Iemand goede ideeën / ervaringen waarmee binnen afzienbare tijd een goede indicatie te krijgen is.

[DiNo!]

Zet een pin hoog aan het begin van de code, weer laag aan het einde.

Sluit je oscilloscoop aan op die pin en meet de tijd. Als je scope een persistent mode heeft dan kan je mooi over een bepaalde tijd het maximum ontdekken.

[Cassettebandje]

Voor een indicatie: DiNo!'s methode. Als je het precies wilt weten: cycles tellen, maar dat is niet altijd straightforward en veel werk.
Als blijkt dat je interrupt te lang duurt: alleen een flag zetten en de hoognodige dingen doen en dan later meer verwerken in je main loop.

[ Voor 4% gewijzigd door Cassettebandje op 30-05-2015 15:01 ]

[Sissors]

Counter is één optie, dat hoeft geen uren te duren om dat in te stellen. Ik herinner me van toen ik nog Atmegas gebruikte dat toendertijd Atmel Studio 4 een redelijk makkelijk te gebruiken simulator had met cycle counter, dus die kan je ook gebruiken.


En anders kom je behalve de pin methode (wat effectief hetzelfde is als de counter, maar dan met externe counter), toch denk ik uit om instructies tellen. Gezien dat het allemaal steeds hetzelfde is zal dat niet erg veel werk zijn.

Ik neem overigens aan dat die niet je daadwerkelijke code is? Want het is nogal apart .

[Infant]

C:

if(parameter == parameter)

Wordt hoop ik weg geoptimaliseerd, want dat gaat vrij vaak true opleveren.

Een hardware counter is het handigst vind ik, je hoeft alleen maar te weten of en hoeveel counts aan delay er zou zitten na het stoppen van de counter. Maar dat kun je vast stellen door het of op te zoeken, of er eentje op 0 te zetten, te starten, en direct weer te stoppen.

[conara]

Het is inderdaad niet de echte code, maar heb alle parameters vervangen door parameter Ik denk inderdaad dat extern meten het snelst is om een indicatie te krijgen.

[Raven]

conara schreef op zaterdag 30 mei 2015 @ 13:34:
Ik ben opzoek naar een methode om effectief te kunnen meten of te bepalen hoe lang de maximale duur van een interrupt is op een microcontroller (Atmel UC3A0). Ik heb een eenvoudige en korte interrupt bijvoorbeeld:

code:

.....

De code is niet ingewikkeld en daardoor ook lekker kort, maar ik wil toch eigenlijk meten of berekenen hoelang de interrupt duurt.

Zelf dacht ik per instructie de hoeveelheid klokslagen opzoeken (als het omgezet is naar machinecode), maar er moeten betere handigere manier zijn lijkt me. Meten is natuurlijk een andere mogelijkheid, maar hoe kan ik dacht het best aanpakken? Het is voornamelijk van belang dat ik een goede indicatie heb hoelang dit duurt, maar niet dat ik eerst uren moet gaan zitten prutsen met counters ect. Iemand goede ideeën / ervaringen waarmee binnen afzienbare tijd een goede indicatie te krijgen is.

Bij Arduino's zou ik het waarschijnlijk zo doen:
- Voor begin programma (in setup): stel variabele var in als "false";
- indien interrupt triggered bij opgaande flank puls (= start puls) én var == false -> kopieer millis() naar variabele start en stel variabele var in als "true";
- indien interrupt triggered bij neergaande flank puls (= einde puls) én var == true -> kopieer millis() naar variabele einde gevolgd door een klein sommetje: variabele tijdsduur = einde - start en stel variabele var in als "false";
- writeln tijdsduur

Misschien dat iets vergelijkbaars bij de UC3A0 kan?

[conara]

Het is technisch allemaal mogelijk, maar het is meer dat ik geen zin heb omdat in me software te gaan doen. Althans dat klinkt misschien heel lui, maar als er effectievere manieren zijn dan wil ik die graag weten