Operácie

Meranie dĺžky impulzu 2

Z SensorWiki


MIPS pulseDemoScope01.png
Meranie impulzov na osciloskope.

V tomto návode vytvoríme program na meranie krok za krokom.


1. Neznámy signál a základný program

Najprv si vytvorte nový projekt, ktorý bude pozostávať z nasledovných súborov.

#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#include "hardware.h"
#include "uart.h"

FILE uart_stream = FDEV_SETUP_STREAM(uart_putc, uart_getc, _FDEV_SETUP_RW);


int main(void)
{   
   hw_init();              // tu je skryte nastavenie vystupu D13 (PD5) na nejaku frekvenciu a plnenie
   
   uart_init(57600);       // konfiguracia seriovej linky na rychlost 57600 Bd

   stdout = stdin = &uart_stream;
   
   printf("Ready to start...\n\n");   
 
    /* 
     * v nekonecnej slucke budeme do terminalu vypisovat
     * hodnotu na vstupe PB0 (na doske oznaceny ako D8)
     * vypis bude 10x za sekundu (preto 100ms) 
     */

   while(1)  
    {
     unsigned char inputValue =0;
	 
     if bit_is_set(PINB,PB0)
       inputValue = 1;
     else
       inputValue = 0;
	 
     printf("Input D8: %u\r",inputValue); 
     _delay_ms(100);

    }

 return(0); 
}
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define LED1  PB5          // Arduino D13 - zabudovana dioda 
#define RCinput PB3        // Arduino D8

#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))
#define toggle_bit(ADDRESS,BIT) (ADDRESS ^= (1<<BIT))

void hw_init(void);
void timer0_init(void);
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define LED1  PB5             // Arduino D13 - zabudovana dioda 
#define inputPulse PB0        // Arduino D8

#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))
#define toggle_bit(ADDRESS,BIT) (ADDRESS ^= (1<<BIT))

unsigned volatile static int timer0ext = 0;


ISR (TIMER0_OVF_vect)     
{  
   timer0ext++;	              // pomocne pocitadlo

   if (timer0ext>15)          // 15x bude Log. 1
       set_bit(PORTB,LED1);
	
   if (timer0ext>74)          // 59x (=74-15) bude log.0 
     {
	   timer0ext = 0;     // a zaroven zacne cely cyklus znova
       clear_bit(PORTB,LED1); 
	  }	 
}

void timer0_init(void)  /* CTC match mode */
{
    /* Timer 0 Normal mode with clock = I/O clock / 1024 */    
	TCCR0A = 0x00;                 // Mode 0: normal
	TCCR0B = (1<<CS02)|(1<<CS00);  // Clock :1024  
	 TCNT0 = 0x00;                 // 8-bit Counter reset
	 TIFR0 = (1 << TOV0);          // Clear interrupt flag 
	TIMSK0 = (1 << TOIE0);         // Enable Overflow Interrupt 
	  sei();					   // Enable interrupts 
	
}

void hw_init(void)
{
   cli();                     // zakaz vsetky prerusenia

   set_bit(DDRB,LED1);        // set pin LED1 as output
   clear_bit(DDRB,inputPulse);     // set RC input as input
   timer0_init();
}
 /* použite vlastný z predošlého cvičenia */
 /* použite vlastný z predošlého cvičenia */



Tento program preložte, nahrajte do procesora a pripojte sa cez sériový terminál. LED dióda na doske by mala začať blikať cca 1x za sekundu a vo výpise by ste mali vidieť, že na vstupe je stále log. 0.

2. Meranie frekvencie / periódy

Chceme najskôr zmerať, s akou frekvenciou sa mení výstup s LED diódou (teda PB5, na doske D13). Na to použijeme to najpresnejšie počítadlo, ktoré na procesore máme k dispozícii, t.j. 16-bitové počítadlo T1. Necháme ho len samovoľne počítať s nejakou frekvenciou a vždy, keď príde nábežná hrana, odchytíme aktuálny stav počítadla TCNT1 do záchytného (capture) registra ICR1 (Input Capture Register). Toto odchytenie by sme síce mohli spraviť aj softvérovo, teda kontrolovať stav na vstupe PB5 a pri zmene sa pozrieť do TCNT1 a odpamätať si aktuálny stav. Ale to je nepohodlné a nepresné, preto na to využijeme možnosť spraviť to automaticky - počítadlo T1 to umožňuje spraviť signálom na vstupe PB0. Preto musíte prepojiť káblikom výstup D13 (PB5) so vstupom D8 (PB0).

V demonštračnom programe by ste už mali vidieť meniaci sa stav na vstupe.

Ready to measure...

Input D8: 0 
Input D8: 0 
Input D8: 1 
Input D8: 1 


Ďalším krokom bude nakonfigurovanie počítadla T1 tak, aby jednak samostatne počítalo od 0 po 65 535 a zároveň aby sa aktuálny stav počítadla odchytil do registra ICR1. Pri konfigurácii sa dá vybrať, či sa odchytávanie uskutoční pri nábežnej, alebo dobežnej hrane.


MIPS pulseDemoTimer01.png
Bloková schéma počítadla T1 v režime zachytávania impulzov.

Zvolíme spúšťanie ICR nábežnou hranou, počítadlo bude počítať s frekvenciou 16 MHz:1024 (prescaler 1024), a do výpisu si pridáme aj stavy všetkých zúčastnených registrov

...

/* Doplnime definiciu funkcie, ktora inicializuje T1 */

void timer1_init(void)
{
    TCCR1A  = 0x00;                 // Mode 0: normal
    TCCR1B  = (1<<CS02)|(1<<CS00);  // Clock :1024  
    TCCR1B |= (1<<ICES1);           // Capture on rising edge
    TCNT1   = 0x0000;               // 16-bit Counter reset
	
}

...

/* ktoru potom pridame na koniec inicializacie, teda
   niekam pred while(1)                               */

  timer1_init();

...

/* a napokon rozsirime funkciu na vypis hodnot  */

printf("Input D8: %u TCNT1: %u ICR: %u\r",inputValue,TCNT1,ICR1); 

...

Mali by ste dostať výstup nejako podobný tomuto

Input D8: 0 TCNT1: 35579 ICR: 23040
Input D8: 0 TCNT1: 37238 ICR: 23040
Input D8: 0 TCNT1: 38897 ICR: 23040  // tuto niekde nastala zmena a zachyti sa novy stav do ICR
Input D8: 1 TCNT1: 40556 ICR: 39680
Input D8: 1 TCNT1: 42215 ICR: 39680
Input D8: 1 TCNT1: 43874 ICR: 39680
Input D8: 1 TCNT1: 45533 ICR: 39680
Input D8: 1 TCNT1: 47192 ICR: 39680
Input D8: 1 TCNT1: 48851 ICR: 39680
Input D8: 1 TCNT1: 50510 ICR: 39680
Input D8: 0 TCNT1: 52169 ICR: 39680
Input D8: 0 TCNT1: 53828 ICR: 39680
Input D8: 0 TCNT1: 55487 ICR: 39680  // a tuto je dalsia zmena, znova sa zachyti do ICR
Input D8: 1 TCNT1: 57145 ICR: 56320
Input D8: 1 TCNT1: 58804 ICR: 56320
Input D8: 1 TCNT1: 60463 ICR: 56320


Vo výpise vidíme, že keď sa zmení stav na vstupe D8 tak sa aktuálny stav počítadla TCNT1 prepíše do ICR. Nám teraz stačí odpočítať dve po sebe idúce hodnoty ICR a získame tak časový rozdiel medzi dvoma nábežnými hranami, čo je vlastne perióda signálu na vstupe.

V našej ukážke sme namerali zmenu dvakrát, rozdiel medzi stavom počítadla bol v oboch prípadoch rovnaký:

 56320 - 39680 = 16640

alebo

  39680 - 23040 = 16640

Ak by počítadlo T1 inkrementovalo svoj stav vždy presne po 1ms, tak by sme mali po odčítaní priamo čas v milisekundách. Lenže počítadlo T1 inkrementuje svoj stav vždy po čase

 \frac{1}{16\,000\,000:1\,024} = 64 \; [\mu s]

Preto nami nameraná dĺžka impulzu je teda

16\,640\cdot 64 = 1\,064\,960\;[\mu{}s] = 1\,064,960\; [ms] = 1,06496\;[s]

Porovnajte výsledok s obrázkom z osciloskopu v úvode stránky.

Tento výpočet by už mohol robiť aj mikroprocesor, ale nejdeme si teraz komplikovať život počítaním v plávajúcej desatinnej čiarke. Kto si život komplikovať chce, tak si prečíta Typy premenných v avr-gcc.

Zamyslieť by sme sa však mali ešte nad situáciou, keď počítadlo TCNT1 pretečie. Teda ak jedna nábežná hrana príde napríklad v čase, keď hodnota TCNT1 = 55296 a pri druhej nábežnej hrane už počítadlo začalo dávno počítať znova od nuly, takže nájdeme v ICR odchytenú hodnotu 6400.

3. Meranie frekvencie s prerušením

Ostaňme ešte pri meraní frekvencie, resp. periódy a vylepšime program aspoň o automatické vypočítavanie rozdielu, pričom by sme boli radi, aby sme už nevypisovali všetky možné stavy, ale len ten jeden, kedy sa zmení ICR a zaktualizujeme zmeranú periódu. Nie je to nič komplikované, stačí, ak zároveň s odchytením registra vyvoláme aj prerušenie a v jeho obsluhe porovnáme aktuálnu hodnotu s predošlou.

Na to musíme spraviť niekoľko krokov. Prerušenie samotné musíme najprv povoliť. To znamená, že do funkcie timer1_init(void) pridáme nasledovný riadok

	 
   TIMSK1 = (1<<ICIE1);          // Enable Input Capture Interrupt

a nesmieme zabudnúť ani na povolenie na globálnej úrovni príkazom

   sei();

ktorý zaradíme na koniec inicializácie, napr. pred while(1) cyklus.

No a samozrejme potrebujeme samotnú obsluhu prerušenia, v ktorej vypočítame rozdiel aktuálnej hodnoty ICR od predošlej a vypíšeme ho na terminál. Hneď potom si aktuálnu hodnotu ICR odložíme do premennnej oldICR, pretože pri ďalšom vyvolaní prerušenia bude ICR obsahovať už nový stav. Premenná oldICR musí byť definovaná ako globálna a typu volatile, aby sme k nej vedeli pristúpiť aj z prerušenia a aby sa nemenila medzi prerušeniami. Príznak prerušenia ICF1 nulovať nemusíme, to nastane automaticky vyvolaním obslužnej rutiny.

...

volatile unsigned int oldICR = 0;    // premenna, kam si odlozime staru hodnotu ICR

...

ISR(TIMER1_CAPT_vect)               // Timer 1 Capture Interrupt Service Routine
{
  
  printf("* Pulse %u \n",ICR1-oldICR); 
  oldICR = ICR1;

}

...


A potom dostaneme napríklad takýto výstup

Input D8: 0 TCNT1: 57617 ICR: 41728
* Pulse 16640
Input D8: 1 TCNT1: 59315 ICR: 58368
Input D8: 1 TCNT1: 60974 ICR: 58368
Input D8: 1 TCNT1: 62633 ICR: 58368

Vidíme, že pomedzi pravidelné výpisy (ktoré už teraz ani nepotrebujeme) sa občas prepašuje výpis nameranej hodnoty. Ten sa tam dostal v obsluhe prerušenia. Nie je to síce dobrá stratégia, robiť výpisy v prerušení, ale opäť to pre zjednodušenie necháme tak. Správne by sa v obsluhe mal nastaviť len príznak, že hodnota je pripravená na výpis a ten by sme spravili potom v hlavnej slučke.


4. Zobrazenie v správnych jednotkách

Ešte by sme mohli upraviť výpočet v prerušovacej rutine tak, aby sa nám vypisoval priamo čas, teda dĺžka impulzu v sekundách, resp. iných vhodných jednotkách. Vyššie sme si ukázali, že ak vynásobíme rozdiel impulzov v ICR registri hodnotou 64, dostaneme výsledok v mikrosekundách. To je trocha nepohodlné a pre naše účely by stačilo mať výsledok v milisekundách s presnosťou na 1ms aby sme sa vyhli potrebe desatinného čísla. Upravený kód pre obsluhu prerušenia môže vyzerať napríklad takto

ISR(TIMER1_CAPT_vect)                // Timer 1 Capture Interrupt Service Routine
{
  unsigned long pulsePeriod;
  
  pulsePeriod = (ICR1-oldICR);       //  16640 
  pulsePeriod = pulsePeriod*64;      //  1064960  vysledok v [us]
  pulsePeriod = pulsePeriod/1000;    //  1064     vysledok v [ms]
  
  printf("* Pulse %lu [ms]\n",pulsePeriod); //aj tu musime zmenit %u na %lu
  oldICR = ICR1;

}


Keďže rozdiel ICR môže byť aj dosť veľké číslo, ľahko by sa nám mohlo stať, že násobením hodnotou 64 by sme sa už nezmestili do rozsahu premennej typu int. Preto premennú pulsePeriod definujeme ako typ long. Mohli by sme síce prehodiť poradie operácií a najprv deliť 1000 a až potom násobiť, ale tým by sme zasa zbytočne strácali presnosť merania (stále pracujeme s celými číslami, desatiny sa stratia).

4. Meranie plnenia (striedy)

Ak chceme merať aj striedu, alebo plnenie, ktoré je definované ako pomer času log.1 k celej perióde, potrebujeme zmerať len šírku impulzu log. 1 a nie celú periódu. Preto musíme najprv zachytiť stav TCNT1 pri nábežnej hrane a potom druhý raz pri dobežnej hrane. Meranie budeme opäť realizovať s prerušením a v obsluhe prerušenia preklopíme konfiguračný bit, ktorý rozhoduje o polarite aktivačného signálu. Je to bit ICES1, ktorý je v TCCR1B.6.

  toggle_bit(TCCR1B,ICES1);   // toggle Edge Select bit

Pripomíname, že plnenie (duty cycle) je pre obdĺžnikový signál definované ako



D = \frac{T_{on}}{T_{total}} = \frac{T_{on}}{T_{on} + T_{off}}


Úloha:

Zdrojové kódy na tejto stránke majú nastavené trocha inú periódu aj plnenie ako je uvedené v texte. Vaša úloha je zmerať

  • Periódu signálu v [ms]
  • Plnenie signálu [-] (pozor na definíciu)

Literatúra