ATNEL tech-forum

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T19:40:54+01:00

Rozumiem twój kod i wiem jak on działa. Poprzednie moje pytanie odnosiło się do mojego ostatniego kodu. Twoja idea nie jest zła, też o tym myślałem ale przy taktowaniu 8Mhz i timer0 nie da się tego zrobić żeby na wyjściu była liczba od 0 do 255. Teraz myślę nad twoim pomysłem ale na timerze1 który ma 16 bitów.

Statystyki: Napisane przez Adam — 4 maja 2013, o 19:40

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T15:37:29+01:00

Może wyjaśnię jeszcze raz. W zmiennej wynik masz zawsze aktualną pozycję serwa. Ponieważ w przerwaniu przy zboczu narastający uruchamiasz timer0 zwiększasz flagę i zmieniasz przerwanie INT0 na zbocze opadające. Wychodzimy z przerwania a timer dalej zlicza długość impulsu od serwa. Impuls ten trwa np. 1,5 ms po tym czasie zmieni się stan z wysokiego na niski i wyzwoli przerwanie INT0 (zbocze opadające ) . W obsłudze przerwania w drugim warunku instrukcji switch zatrzymujemy timer zerujemy flagę i wartość licznika przypisujemy do zmiennej wynik i zmieniamy zbocze na narastają. I cykl się powtarza. Więc co 20ms masz zawsze nową pozycję serwa w zmiennej wynik. Przy długości impulsu 1,5 ms timer zliczy do około 187. Przy długości impulsu np.1,25ms licznik zliczy do około 156 ( 0,00125 s / 0,000 008 s ).

Statystyki: Napisane przez vol_up — 4 maja 2013, o 15:37

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T14:39:36+01:00

50Hz czyli co 20ms idzie impuls od 1ms do 2ms.

------------------------ [ Dodano po: 36 minutach ]

Czym mogą być spowodowane błędy jeśli przypisuje przypisuje do TCNT0 więcej niż 224? (ostatni kod) Poniżej tej wartości wszystko działa jak należy, przy wyższej wartość, odświeżanie wyniku jest ok 2 razy na sekundę a wyniki nie są poprawne.

Statystyki: Napisane przez Adam — 4 maja 2013, o 14:39

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T14:10:05+01:00

Możesz przybliżyć z jaką częstotliwości pozycja tego serwa się zmienia?

Statystyki: Napisane przez vol_up — 4 maja 2013, o 14:10

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T13:03:38+01:00

Ok, otrzymam w ten sposób pozycję neutralną ale ja w programie potrzebuje mieć wartości od 0 do 255 i nie mogę na to czekać dłużej niż 50ms.

Statystyki: Napisane przez Adam — 4 maja 2013, o 13:03

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T12:35:13+01:00

Spróbuj tak. Ustaw serwo w pozycji skrajną lewo i odczytaj zmienną wynik. Ustaw w pozycję skrajną prawą odczytaj zmienną wynik. Jeśli dodasz te dwie wartości i podzielisz przez dwa to otrzymasz pozycję neutralną.

Statystyki: Napisane przez vol_up — 4 maja 2013, o 12:35

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T12:25:51+01:00

Rozumiem, tylko problemem jest wynik. Chodzi o to aby w pozycji neutralnej było ok 128 +/- 10. analogicznie wychylanie w prawo, lewo. Będzie mi to później potrzebne.

Statystyki: Napisane przez Adam — 4 maja 2013, o 12:25

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T12:03:32+01:00

Chyba się za bardzo nie rozumiemy. Z zastosowaniem mojej koncepcji musi ulec zmianie prawie cała funkcja main (). Nie ma przerwania od timera0. wszystko załatwia INT0. W zmiennej wynik otrzymamy czas trwania impulsu sterującego serwo.
Wyjaśnię może co nieco. Jeśli zmienna wynik wyniesie np. 187 to będziesz wiedział, że serwo jest w pozycji neutralnej. Ponieważ 187 * 8 us da nam 1,5 ms.

Statystyki: Napisane przez vol_up — 4 maja 2013, o 12:03

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T11:59:13+01:00

no tak... całkowicie o tym zapomniałem. Dzięki.

Teraz kod wygląda tak:
[syntax=c]ISR(INT0_vect)
{
if(MCUCR & (1<{
TCNT0 = 224;// zliczaj od 224
i = 0;// zewruj licznik
}
else// zbocze opadające
{
sgn0 = i;// zapisz wynik

}

MCUCR ^= (1<}

//-------------------------------------------------------------------------------------------------
// obsługa przerwania od przepełnienia TIMER0
//-------------------------------------------------------------------------------------------------
SIGNAL(SIG_OVERFLOW0)
{
i++;
TCNT0 = 224;
}[/syntax]

I działa o wiele lepiej. Jednak nie pojmuje jednej rzeczy. Bo stan wysoki zmienia się od 1ms do 2ms, więc od zmierzonego czasu trzeba odjąć 1ms i mamy przedział od 0 - 1ms. Ale w zależności od tego urządzenia zadającego odpowiedni impuls czas ten może być krótszy lub dłuższy w moim przypadku jest to ok 800us, więc postanowiłem do rejestru TCNT0 przypisywać większą wartość 240 i niestety jest problem. Wynik jest ten sam co przy TCNT0 = 224 i odświeżany ok 2 razy na sekundę.
W czym może tkwić problem?

Statystyki: Napisane przez Adam — 4 maja 2013, o 11:59

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T11:24:13+01:00

panowie mamy tu do czynienia z przerwaniem od INT0 a nie timera0.

Adam napisał(a):

....
Co do obliczeń, nie rozumiem dlaczego 2 razy dzielisz przez 256?
...

Jeśli licznik zliczy do 256 to minie około 2ms. A zatem jeśli licznik zliczy tylko do 1 to minie 80us. Obliczam w ten sposób czas 1 impulsu.

Statystyki: Napisane przez vol_up — 4 maja 2013, o 11:24

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T11:03:55+01:00

Dzięki za odpowiedź.
Co do obliczeń, nie rozumiem dlaczego 2 razy dzielisz przez 256?

8 000 000 Hz / 64 = 125 000 Hz
125 000 Hz / 256 = 488,281 250 Hz
1 s / 488,281 = 0,002 048 s ( około 2 ms )

Przerwanie wykona się co 2ms. Zgadza się?

Statystyki: Napisane przez Adam — 4 maja 2013, o 11:03

Re: Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-04T10:22:01+01:00

proszę oto jedna z koncepcji

[syntax=c]ISR(INT0_vect)
{
//----------------------------- makrodefinicje ---------------------------------
#define start_t0 TCCR0 |= ( 1<< CS01 )|( 1<< CS00 ) ; //-- preskaler 64
#define stop_t0 TCCR0 &= ~( 1<< CS01 )|( 1<< CS00 ) ; //- zatrzymujemy timer
#define zb_opad MCUCR &= ~( 1<< ISC00 ) ; // ------------ przerwanie na zbocze opadające
#define zb_nara MCUCR |= ( 1<< ISC00 ) ; // ------------- przerwanie na zbocze narastające ( ISC01 mamy już ustawione )
//----------------------------- koniec makrodefinicji ---------------------------

static uint8_t flag_1 ; //zmienna na potrzeby instrukcji switch ( static ponieważ kompilator zainicjuje nam ją zerem )

//------------ instrukcja switch
switch ( flag_1 )
{
case 0 : // ---------- przerwanie INT0 na zbocze narastające
start_t0 ; // ---- startujemy timer
flag_1++ ; // ---- zwiększamy flagę
zb_opad ; // ----- ustawiamy przerwanie INT0 na zbocze opadające
break ;

case 1 : // ---------- przerwanie INT0 na zbocze opadające
stop_t0 ; // ----- zatrzymujemy timer
wynik = TCNT0 ; // do zmiennej wynik wartość TCNT0
flag_1-- ; // ---- zerujemy flagę
zb_nara ; // ----- ustawiamy przerwanie INT0 na zbocze narastające
break ;
}
// -------------------- koniec instrukcji switch
}[/syntax]

Jest to tylko kod obsługi przerwania INT0.

Preskaler w liczniku ustawiasz na 64. Dzięki temu otrzymamy:

8 000 000 Hz / 64 = 125 000 Hz
125 000 Hz / 256 = 488,281 250 Hz
1 s / 488,281 250 = 0,002 048 s ( około 2 ms )
0,002 048 s / 256 = 0,000 008 s ( 8 us )

Tym sposobem, jeżeli zmienna wynik wyniesie np. 200 to wiadomo że, serwo wychylone będzie np. w prawo.
Ponieważ 8 us * 200 = 1,6 ms . Jak wiadomo jeśli serwo dostaje impuls około 1,5 ms to jest to pozycja neutralna. Wartości odbiegające od tej normy powodują wychylenie w lewo lub w prawo.
Zaznaczam, że mogę wypisywać tu jakieś herezje bo w programowaniu avr-ów jestem średnio początkujący.

Statystyki: Napisane przez vol_up — 4 maja 2013, o 10:22

Timer0, Odczytanie pozycji serwa, problem z TCNT0

2013-05-03T21:47:08+01:00

Witam.
Tworzę program który ma za zadanie odczytać pozycję serwa i na wyjściu podać wartość od 0 do 255.

Stan wysoki impulsu pojawia się co 20ms i trwa ok 1ms, więc początkowa idea była następująca:

Wejście sygnału podłączone do INT0 wyzwala przerwanie gdzie na zboczu narastającym timer zaczyna liczyć ile razy przerwanie od timer-a zostało wykonane, a na opadającym zapisuje wynik do zmiennej. Timer0, tryb normal bez preskalera, wyzwala przerwanie co 4us. (1000/256)

1) 1s / 8MHz = 0,125us - co 0,125us timer dostaje impuls do rejestru TCNT0.
2) 4us / 0,125 = 32, więc 256 - 32 = 224 czyli timer ma zliczać od TCNT0 = 224.

Kod:
[syntax=c]volatile int sgn0;// zmienna przechowująca wynik
volatile int i;// licznik
char wynik[20];

int main (void)
{
LCD_Initalize (); // Funkcja inicjalizuje wyswietlacz

//---------------------konfiguracja przerwań---------------------------------------------
DDRD &= ~(1<PORTD |= (1<MCUCR |= (1<GICR |= (1<//---------------------------------------------------------------------------------------
TCCR0 |= (1<TIMSK |= (1<TCNT0 = 0;// zliczaj impulsy od 156 (256-100=156)
sei();// globalne zezwolenie na przerwania

while (1)
{

//---------------wyświetlenie wyniku-----------------------------------
itoa (sgn0, wynik, 10);
LCD_Clear();
LCD_WriteText (wynik);
_delay_ms (100);
}
}

//-------------------------------------------------------------------------------------------------
// obsługa przerwania INT0
//-------------------------------------------------------------------------------------------------
SIGNAL(SIG_INTERRUPT0)
{
if(!(MCUCR & (1<{
TCNT0 = 224;// zliczaj od 224
i = 0;// zeruje licznik i
}
else// zbocze opadające
{
sgn0 = i;//zapisuje wynik do sgn0
}

MCUCR ^= (1<}
//-------------------------------------------------------------------------------------------------
// obsługa przerwania od przepełnienia TIMER0
//-------------------------------------------------------------------------------------------------
SIGNAL(SIG_OVERFLOW0)
{
i++;
}[/syntax]

Kod ten działa ale problemem jest wynik który jest taki sam jak przy TCNT0 = 0. Cokolwiek bym do tego rejestru nie wpisał wynik jest taki jak powinien być przy TCNT0 = 0.

Proszę o pomoc, w rozwiązaniu problemu.

Procek to Atmega8 taktowana wewnętrznym oscylatorem 8MHz, dokładności nie ziemskiej się nie spodziewam.
Wybrałem przerwanie INT0 ponieważ to jeden z niewielu wolnych pinów na płytce.

Z góry dziękuje. Pozdrawiam.

Statystyki: Napisane przez Adam — 3 maja 2013, o 21:47