Meranie dĺžky impulzu 2
Zo stránky SensorWiki
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>20) // 20x bude Log. 1
set_bit(PORTB,LED1);
if (timer0ext>64) // 44x (=64-20) 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
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.
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ý:
alebo
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 (1/16 000 000:1024) = 64 us (mikrosekund). Preto nami nameraná dĺžka impulzu je teda
Syntaktická analýza (parsing) neúspešná (syntaktická chyba): {\displaystyle 16640 x 64 = 1 064 960 us = 1064,960 ms = 1,06496 s }
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. Ale program môžeme vylepšiť aspoň o automatické vypočítavanie rozdielu. 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.
3. Meranie frekvencie s prerušením
Ak chceme merať aj striedu, musíme meranie realizovať s prerušením a v obsluhe prerušenia preklopiť konfiguračný bit, ktorý rozhoduje o prepise TCNT do ICR registra. Je to bit ICES1, ktorý je v TCCR1B.6.
#include <avr/interrupt.h>
volatile int newTick = 0; // The variable for interrupt should be declared as a volatile one!
ISR(TIMER1_CAPT_vect) // Timer 1 Capture Interrupt Service Routine
{
TCCR1B = ?? // toggle Edge Select bit
newTick = ICR1;
};
main()
{
DDRB = ?? // Set ICR - Port B, pin0 as INPUT
TCCR1B = ?? // T1 clk = F_CPU : 1024, falling edge pin ICP1,
TCCR1A = ?? // T1 in timer mode !! Note: if You omit this, TCNT1 will be only 8-bit !!
TCNT1 = 0x0000; // initialize the counter (16-bit! Low+High bytes)
TIFR1 = ?? // (1<<ICF1); if a 1 is written to a ICF1 bit
// - the ICF1 bit will be cleared
TIMSK1 = ?? // Enable ICR interrupt
sei(); // Enable ALL interrupts
.... // TODO: display measured value somewhere
}
Ukážka pre Arduino využíva zabudovaný príkaz PulseIn:
#define SWITCH 8 // select the pin for Switch
unsigned long duration;
void setup()
{
pinMode(SWITCH, INPUT); // this pin is an INPUT
Serial.begin(9600);
Serial.println("PulsIn test:");
}
void loop() // endless loop
{
duration = pulseIn(SWITCH, HIGH);
Serial.print(" T1 = ");
Serial.print(duration,DEC);
Serial.print(" [us]");
duration = pulseIn(SWITCH, LOW);
Serial.print(" T0 = ");
Serial.print(duration,DEC);
Serial.println(" [us]");
}
Literatúra
- AVR130: Setup and Use the AVR® Timers. Aplication Note, Atmel Corporation 2002.
+ software download - AVR135: Using Timer Capture to Measure PWM Duty Cycle. Aplication Note, Atmel Corporation 2005.
+ software download