ATNEL tech-forum

Re: Złe odmierzanie czasu przy CTC

2014-08-31T09:28:58+01:00

O kurcze. Mam bluebooka i widziałem jak to się liczy, ale za każdym razem klepanie w kalkulator męczy. Co do programu mkAVRCalculator to nie wiedziałem.
ŻAŁUJĘ ZA GRZECHY! PRZEPRASZAM!

Statystyki: Napisane przez matek45 — 31 sie 2014, o 09:28

Re: Złe odmierzanie czasu przy CTC

2014-08-31T09:24:23+01:00

matek45 napisał(a):

Co do obliczeń przerwań to polecam stronę: http://eleccelerator.com/avr-timer-calculator/

Cudze panie chwalicie a swego nie znacie - masz to samo w MkAvrCalculator jak nie lepiej

http://atnel.pl/mkavrcalculator.html

a co więcej - bez żadnej takiej strony - łatwo i z głowy można obliczać tylko trzeba poznać prosty sposób - wystarczy zajrzeć do Bluebooka:

http://atnel.pl/mikrokontrolery-avr-jezyk-c.html

Statystyki: Napisane przez mirekk36 — 31 sie 2014, o 09:24

Re: Złe odmierzanie czasu przy CTC

2014-08-31T09:25:12+01:00

1. Dla TCCR1A jest tylko WGM11 i WGM10, TCCR1B posiada WGM12. Nie zauważyłem tego :/
2. Co do ręcznego podziału to w ostatnim poście jest 1 dlatego, że próbowałem dla innych wartości kombinować i zapomniałem ustawić na 39, ale nie miało to znaczenia.
Bardzo dziękuję za pomoc.
Co do obliczeń przerwań to polecam stronę: http://eleccelerator.com/avr-timer-calculator/

Pozdrawiam!

Statystyki: Napisane przez matek45 — 31 sie 2014, o 09:20

Re: Złe odmierzanie czasu przy CTC

2014-08-31T08:46:58+01:00

1. Sprawdź sobie lepiej gdzie jest bit WGM12
2. sprawdź jak obliczyłeś przerwanie dla 1MHz w CTC

3. zajrzyj w tym celu do przykładu do Bluebooka np przy multipleksowaniu wyświetlaczy LED jak obliczać czas przerwania

Statystyki: Napisane przez mirekk36 — 31 sie 2014, o 08:46

Re: Złe odmierzanie czasu przy CTC

2014-08-31T00:56:52+01:00

Kod programu (po poprawkach użytkownika szopler):
[syntax=c]#include
#include
#include
#include "hd44780.h"

//int sekundy = 0;
volatile int setne = 0;
//int godziny = 0;
//int minuty = 0;

int main(void)
{
TCCR1A |= (1 << WGM12); //Ustawienie CTC
TCCR1B |= (1 << CS12); //Wewnętrzny preskaler 256
TIMSK |= (1 << OCIE1A); //Zezwolenie na przerwanie
OCR1A = 1; // Ręczny podział

lcd_init();
LCD_DISPLAY(LCDDISPLAY);
sei(); //Włączenie przerwań

while(1)
{
LCD_LOCATE(0,0);
lcd_int(setne);
}
return 0;
}

ISR(TIMER1_COMPA_vect)
{
setne++;
}[/syntax]

Plik .h dla wyświetlacza hd44780:
[syntax=c]/*
Plik hd44780.h
*/

#ifndef LCD_HD44780
#define LCD_HD44780

/* RS */
#define SET_OUT_LCD_RS DDRD |= _BV(PD0)
#define SET_LCD_RS PORTD |= _BV(PD0)
#define CLR_LCD_RS PORTD &= ~_BV(PD0)

/* RW */
#define SET_OUT_LCD_RW DDRD |= _BV(PD1)
#define SET_LCD_RW PORTD |= _BV(PD1)
#define CLR_LCD_RW PORTD &= ~_BV(PD1)

/* E */
#define SET_OUT_LCD_E DDRD |= _BV(PD2)
#define SET_LCD_E PORTD |= _BV(PD2)
#define CLR_LCD_E PORTD &= ~_BV(PD2)

/* D4 */
#define SET_OUT_LCD_D4 DDRD |= _BV(PD3)
#define SET_IN_LCD_D4 DDRD &= ~_BV(PD3)
#define SET_LCD_D4 PORTD |= _BV(PD3)
#define CLR_LCD_D4 PORTD &= ~_BV(PD3)
#define IS_SET_LCD_D4 PIND & _BV(PD3)

/* D5 */
#define SET_OUT_LCD_D5 DDRD |= _BV(PD4)
#define SET_IN_LCD_D5 DDRD &= ~_BV(PD4)
#define SET_LCD_D5 PORTD |= _BV(PD4)
#define CLR_LCD_D5 PORTD &= ~_BV(PD4)
#define IS_SET_LCD_D5 PIND & _BV(PD4)

/* D6 */
#define SET_OUT_LCD_D6 DDRD |= _BV(PD5)
#define SET_IN_LCD_D6 DDRD &= ~_BV(PD5)
#define SET_LCD_D6 PORTD |= _BV(PD5)
#define CLR_LCD_D6 PORTD &= ~_BV(PD5)
#define IS_SET_LCD_D6 PIND & _BV(PD5)

/* D7 */
#define SET_OUT_LCD_D7 DDRD |= _BV(PD6)
#define SET_IN_LCD_D7 DDRD &= ~_BV(PD6)
#define SET_LCD_D7 PORTD |= _BV(PD6)
#define CLR_LCD_D7 PORTD &= ~_BV(PD6)
#define IS_SET_LCD_D7 PIND & _BV(PD6)

#define LCD_NOP asm volatile("nop\n\t""nop\n\t" "nop\n\t" "nop\n\t" ::);

#define LCDCOMMAND 0
#define LCDDATA 1

#define LCD_LOCATE(x,y) WriteToLCD(0x80|((x)+((y)*0x40)), LCDCOMMAND)

#define LCD_CLEAR WriteToLCD(0x01, LCDCOMMAND)
#define LCD_HOME WriteToLCD(0x02, LCDCOMMAND)

/* IDS */

#define LCDINCREMENT 0x02
#define LCDDECREMENT 0x00
#define LCDDISPLAYSHIFT 0x01

#define LCD_ENTRY_MODE(IDS) WriteToLCD(0x04|(IDS), LCDCOMMAND)

/* BCD */
#define LCDDISPLAY 0x04
#define LCDCURSOR 0x02
#define LCDBLINK 0x01

#define LCD_DISPLAY(DCB) WriteToLCD(0x08|(DCB), LCDCOMMAND)

/* RL */
#define LCDLEFT 0x00
#define LCDRIGHT 0x04

#define LCD_SHIFT_DISPLAY(RL) WriteToLCD(0x18|(RL), LCDCOMMAND)
#define LCD_SHIFT_CURSOR(RL) WriteToLCD(0x10|(RL), LCDCOMMAND)

#define LCD_CGRAM_ADDRESS(A) WriteToLCD(0x40|((A)&0x3f), LCDCOMMAND)
#define LCD_DDRAM_ADDRESS(A) WriteToLCD(0x80|((A)&0x7f), LCDCOMMAND)

#define LCD_WRITE_DATA(D) WriteToLCD((D),LCDDATA)

void lcd_init(void);
void WriteToLCD(unsigned char v,unsigned char rs);
unsigned char ReadAddressLCD(void);
void lcd_puts(char *str);
void lcd_int(int val);

#endif[/syntax]

Plik .c dla wyświetlacza:
[syntax=c]/*
Plik hd44780.c

Definicje kilku funkcji do obsługi alfanumerycznego
wyświetlacza LCD HD44780
*/

#include
#include
#include "hd44780.h"
#include

/*--------------------------------------------------------*/
/* Zapis danej lub instrukcji */

void WriteToLCD (unsigned char v,unsigned char rs)
{
unsigned char bf;

SET_OUT_LCD_D4;
SET_OUT_LCD_D5;
SET_OUT_LCD_D6;
SET_OUT_LCD_D7;

if(v&0x10) SET_LCD_D4; else CLR_LCD_D4;
if(v&0x20) SET_LCD_D5; else CLR_LCD_D5;
if(v&0x40) SET_LCD_D6; else CLR_LCD_D6;
if(v&0x80) SET_LCD_D7; else CLR_LCD_D7;

CLR_LCD_E;
if(rs) SET_LCD_RS;else CLR_LCD_RS;
CLR_LCD_RW;

LCD_NOP;
SET_LCD_E;
LCD_NOP;
CLR_LCD_E;
LCD_NOP;

if(v&0x01) SET_LCD_D4; else CLR_LCD_D4;
if(v&0x02) SET_LCD_D5; else CLR_LCD_D5;
if(v&0x04) SET_LCD_D6; else CLR_LCD_D6;
if(v&0x08) SET_LCD_D7; else CLR_LCD_D7;

LCD_NOP;
SET_LCD_E;
LCD_NOP;
CLR_LCD_E;
LCD_NOP;

SET_IN_LCD_D4;
SET_IN_LCD_D5;
SET_IN_LCD_D6;
SET_IN_LCD_D7;

CLR_LCD_RS;
SET_LCD_RW;
SET_LCD_D7;

/* Przydałby się pełny odczyt */
do
{
LCD_NOP;
SET_LCD_E;
LCD_NOP;
bf = IS_SET_LCD_D7;
CLR_LCD_E;
LCD_NOP;
SET_LCD_E;
LCD_NOP;
LCD_NOP;
CLR_LCD_E;

}while( bf );
}

/*--------------------------------------------------------*/
/* Funkcja odczytuje adres i flage zajetosci */

unsigned char ReadAddressLCD ( void)
{
unsigned char g = 0 ;

CLR_LCD_RS;
SET_LCD_RW;

SET_IN_LCD_D4;
SET_IN_LCD_D5;
SET_IN_LCD_D6;
SET_IN_LCD_D7;

LCD_NOP;
SET_LCD_E;
LCD_NOP;

if(IS_SET_LCD_D4) g+=16;
if(IS_SET_LCD_D4) g+=32;
if(IS_SET_LCD_D4) g+=64;
if(IS_SET_LCD_D4) g+=128;

CLR_LCD_E;
LCD_NOP;
SET_LCD_E;
LCD_NOP;

if(IS_SET_LCD_D4) g+=8;
if(IS_SET_LCD_D4) g+=4;
if(IS_SET_LCD_D4) g+=2;
if(IS_SET_LCD_D4) g+=1;

CLR_LCD_E;

return g ;
}

/*---------------------------------------------------------*/
/* Inicjalizacja wyświetlacza */

void lcd_init(void)
{
_delay_ms(31);

SET_OUT_LCD_RS;
SET_OUT_LCD_RW;
SET_OUT_LCD_E;
SET_OUT_LCD_D4;
SET_OUT_LCD_D5;
SET_OUT_LCD_D6;
SET_OUT_LCD_D7;

CLR_LCD_E;
CLR_LCD_RS;
CLR_LCD_RW;
SET_LCD_D4;
SET_LCD_D5;
CLR_LCD_D6;
CLR_LCD_D7;

LCD_NOP;
SET_LCD_E;
LCD_NOP;
CLR_LCD_E;
LCD_NOP;
_delay_ms(10);

LCD_NOP;
SET_LCD_E;
LCD_NOP;
CLR_LCD_E;
LCD_NOP;
_delay_ms(2);

LCD_NOP;
SET_LCD_E;
LCD_NOP;
CLR_LCD_E;
LCD_NOP;
_delay_ms(2);

CLR_LCD_D4;
LCD_NOP;
SET_LCD_E;
LCD_NOP;
CLR_LCD_E;
LCD_NOP;
_delay_us(80);

WriteToLCD (0x28 , LCDCOMMAND) ;
LCD_DISPLAY(0) ;
LCD_CLEAR ;
LCD_ENTRY_MODE(LCDINCREMENT) ;
}

/*--------------------------------------------------------*/
/* Wyswietla tekst na aktualnej pozycji kursora */

void lcd_puts(char *str)
{
unsigned char i =0;

while( str[i])
LCD_WRITE_DATA(str[i++]) ;
}
void lcd_int(int val)
{
char bufor[17];
itoa(val, bufor, 10);
lcd_puts( bufor );
}[/syntax]

uC to atmega8, wyświetlacz hd44780 lcd 2x16 - niebieski, program: eclipse z avrdude i mkAVRcalculator.

Jeśli mam coś więcej powiedzieć to piszcie, bo nie wiem co jeszcze mógłbym dodać.

Statystyki: Napisane przez matek45 — 31 sie 2014, o 00:56

Re: Złe odmierzanie czasu przy CTC

2014-08-31T00:08:41+01:00

szopler napisał(a):

Kod, po którym nic mi się nie wyświetla wstawił @szopler. Dodałem w 13 linijce tego kodu: LCD_DISPLAY(LCDDISPLAY); i zaczęło "gadać".
Jednak cały czas zmienna wzrasta mi po ok.17 sekundach

Przede wszystkim to kolega szopler dobrze Ci podpowiada.

Po pierwsze przerwanie powinno zajmować jak najkrócej - czyli szybkie instrukcje wewnątrz przerwania.
A co za tym idzie po co wrzuciłeś do przerwanie inicjalizacje wyświetlacza i wyświetlanie na ekranie?
Oglądałeś poradniki o przerwaniach? link: https://www.youtube.com/watch?v=J82_Zop9cjE

Wyświetlacz inicjalizuje się tylko raz.

A wywołanie funkcji do wyświetlania wywołuj w peli głównej programu.
A i kod mógł nie działać od kolegi szoplera bo TY masz pisane funkcje z dużych liter a on zapiasał lcd_init, lcd_int z małych.
Ważne w nazewnictwie jest trzymanie się wielkości liter.

Przede wszystkim powiedz czego używasz do wyświetlania na LCD? na jakim sprzęcie działasz?
Pokaż cały kod i zawsze jak zadajesz pytanie to opisz wszystko dokładnie.

Statystyki: Napisane przez bogdanc — 31 sie 2014, o 00:08

Re: Złe odmierzanie czasu przy CTC

2014-08-30T22:57:31+01:00

Kod, po którym nic mi się nie wyświetla wstawił @szopler. Dodałem w 13 linijce tego kodu: LCD_DISPLAY(LCDDISPLAY); i zaczęło "gadać".
Jednak cały czas zmienna wzrasta mi po ok.17 sekundach

Statystyki: Napisane przez matek45 — 30 sie 2014, o 22:57

Re: Złe odmierzanie czasu przy CTC

2014-08-30T22:47:29+01:00

Witam

matek45 napisał(a):

Już nic mi nie wyświetla na ekranie.....

Może pokaż kod po którym nic Ci się nie wyświetla bo pisząc w ten sposób, można z powodzeniem odpisać że może masz wyłączony zasilacz.
Nie piszę tego złośliwie, ale najpierw strzępek kodu potem tylko opisówka....
Tutaj każdy stara się ratować tonącego, ale za coś trzeba złapać

Pozdr.

Statystyki: Napisane przez kicajek — 30 sie 2014, o 22:47

Re: Złe odmierzanie czasu przy CTC

2014-08-30T22:32:44+01:00

Już nic mi nie wyświetla na ekranie

Co do sei(), to wiem po co to jest i co to jest, tylko nie wiem dlaczego dalej potrzebna jest pętla.
Edit:
Już wyświetla, zabrakło LCD_DISPLAY, ale cały czas wolno się nalicza.

Edit2:
Zmieniłem uC na inny. Co prawda atmega8L, ale ta sama nota katalogowa i problem cały czas taki sam.
Na 1 szybko się zmienia - zaraz po włączeniu, ale na kolejne liczby trzeba czekać niecałe 17 sekund.

Statystyki: Napisane przez matek45 — 30 sie 2014, o 22:32

Re: Złe odmierzanie czasu przy CTC

2014-08-30T22:17:33+01:00

sei(); to Główny włącznik przerwań.
Zmienna "setne" powinna być volatile.
Nigdy nie rób wyświetlania w przerwaniu, że o inicjalizacji wyświetlacza za każdym razem nie wspomnę!

To powinno wyglądać tak:
[syntax=c]//int sekundy = 0;
volatile int setne = 0;
//int godziny = 0;
//int minuty = 0;

int main(void) {
TCCR1A |= (1 << WGM12); //Ustawienie CTC
TCCR1B |= (1 << CS12); //Wewnętrzny preskaler 256
TIMSK |= (1 << OCIE1A); //Zezwolenie na przerwanie
OCR1A = 39; // Ręczny podział

lcd_init();

sei(); //Włączenie przerwań

while(1) {
LCD_LOCATE(0,0);
lcd_int(setne);
}
return 0;
}

ISR(TIMER1_COMPA_vect) {
setne++;
}[/syntax]

Statystyki: Napisane przez szopler — 30 sie 2014, o 22:17

Złe odmierzanie czasu przy CTC

2014-08-30T22:13:01+01:00

Witam, problem polega na złym odmierzaniu przerwań. Wg ustawień liczba (nazwana jako "setne") powinna zmieniać się w ciągu 0.01 sekundy. Jednak sama zmiana na wyższą o 1 liczbę dokonuje się po ok.17 sekundach. Myślałem, że coś źle policzyłem przy ustawianiu częstotliwości przerwań ale nawet po zmianie prescalera i OCR na inne wartości, "setne" zmienia się tak samo. Co zrobiłem źle?
Posiadam atmege8 ustawioną na 1MHz.

[syntax=c]//int sekundy = 0;
int setne = 0;
//int godziny = 0;
//int minuty = 0;

int main(void)
{
TCCR1A |= (1 << WGM12); //Ustawienie CTC
TCCR1B |= (1 << CS12); //Wewnętrzny preskaler 256
TIMSK |= (1 << OCIE1A); //Zezwolenie na przerwanie
OCR1A = 39; // Ręczny podział
TIMSK |= (1 << OCIE1A); //Zezwolenie na przerwanie
sei(); //Procedura przerwania

while(1)
{

}
}

ISR(TIMER1_COMPA_vect)
{
setne++;
lcd_init();
LCD_DISPLAY(LCDDISPLAY);
LCD_LOCATE(0,0);
lcd_int(setne);
}[/syntax]

Jeszcze mam pytanie - dlaczego potrzebna jest pętla po zezwoleniu na przerwania ( sei(); )?

Statystyki: Napisane przez matek45 — 30 sie 2014, o 22:13