ATNEL tech-forum

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-03T11:04:19+01:00

Wydaje mi się, że już rozwiązałem problem. Z tym, że wprowadzę małe poprawki, tak by za każdym razem odliczanie było zatrzymywane przerwaniem zewnętrznym przez przycisk. Jak wprowadzę poprawki to wrzucę kod.

------------------------ [ Dodano po: 50 minutach ]

[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

volatile uint16_t wynik;
volatile uint8_t k;
volatile uint8_t a;
volatile uint8_t c;
volatile uint32_t b;
volatile uint8_t pin;
volatile uint8_t pomocnicza;
volatile unsigned char flaga1;
volatile unsigned char flaga2;
volatile unsigned char flaga3;
int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;

if (flaga1) {
wylaczenie();
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");
flaga1 = 0;
}

if (flaga2) {
wylaczenie();
b = (b / 5);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
lcd_int(b);
lcd_str("ms");
flaga2 = 0;
}

if (flaga3) {
wylaczenie();
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
lcd_int(wynik);
lcd_str("ms");
flaga3 = 0;
}

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
wynik = 0;
b = 0;
c = 1;
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3s
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
OCR0 = 63;
TCCR0 |= (1 << WGM01); //timer 8-bitowy
TCCR0 |= ((1 << CS02)); // prescaler 256
TIMSK |= (1 << OCIE0);
}

if (klawisz_wcisniety(KEY3_PIN)) {
lcd_cls();
wynik = 0;
b = 0;
c = 0;
for (a = 0; a < 5; a++) {
wynik = 0;
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3s
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania
OCR0 = 63;
TCCR0 |= (1 << WGM01); //timer 8-bitowy
TCCR0 |= ((1 << CS02)); // prescaler 256
TIMSK |= (1 << OCIE0);
}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}

ISR(TIMER1_COMPA_vect) {
flaga1 = 1;
}

ISR(INT0_vect) {
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
wylaczenie();
if (c == 1) {
flaga3 = 1;
}
if (a == 5) {
flaga2 = 1;
}
}

ISR (TIMER0_COMP_vect) {
wynik = wynik + 1;
TCNT0 = 0;
}[/syntax]
Tak wygląda kod po poprawkach i wygląda na to, że działa już poprawnie. Co było źle? Otóż okazuje się, że zatrzymanie timera w przerwaniu działa dobrze, natomiast gdy to zatrzymanie zrobimy za pomocą flagi to już czasami wychodzi dziwnie. Uruchomione są 2 timery, jeden zlicza impulsy by wyświetlać komunikat na wyświetlaczu, drugi zlicza milisekundy, stąd ten prescaler itp. Oczywiście można wszystko zrealizować przy pomocy jednego timera, ale miałem akurat wykorzystać jak najwięcej możliwości Atmegi i tak tez uczyniłem. Poza tym jak widać usunąłem jeden przycisk, teraz zarówno pomiar 1-krotny jak i 5-krotny zatrzymujemy tym samym przyciskiem, który służy jako przerwanie zewnętrzne. Dzięki temu uzyskałem porównywalne wyniki, gdyż wcześniej były większe rozbieżności, przez to, że w jednej metodzie timer zatrzymywałem przyciskiem, a w drugiej przerwaniem.

Statystyki: Napisane przez erykko — 3 lis 2013, o 11:04

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-02T13:26:27+01:00

Wysłałem Ci PW z kodem.

Proszę przeanalizuj go trochę i ew dopytuj ...

Statystyki: Napisane przez acid3 — 2 lis 2013, o 13:26

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-02T13:17:26+01:00

[syntax=c]if (flaga2) {
b = (b / 5);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
lcd_int(b);
lcd_str("ms");
flaga2 = 0;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
}[/syntax]
Ten fragment wykonuje obliczenia dla pomiaru wielokrotnego.

Ale by tego dokonać przerwanie ISR (TIMER0_COMP_vect) zlicza milisekundy. Jedna milisekunda to ok. 16 impulsów i co tyle wykonuję przerwanie.

Natomiast przerwanie ISR(INT0_vect) odpowiada za naciśnięcie klawisza. Jest to przerwanie zewnętrzne pochodzące od microswitcha i powodujące dodanie kolejnej wartości do zmiennej b.

Statystyki: Napisane przez erykko — 2 lis 2013, o 13:17

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-02T13:12:32+01:00

Czy mógłbyś mi opisać w którym miejscu robisz obliczenia ?

------------------------ [ Dodano po: 2 minutach ]

Ew. mam ten kod który widziałeś na filmiku i jak chcesz to moge go wrzucić... Bo nie bardzo już rozumiem Twój kod i Twój tok myślenia i dlaczego tak bardzo upierasz się przy pewnych rzeczach.

Statystyki: Napisane przez acid3 — 2 lis 2013, o 13:12

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-02T12:50:47+01:00

Usunąłem w ogóle ten fragment z dodawaniem czy odejmowaniem 80s, bo też wyniki są wtedy zbyt niskie. A dzielenie następuje przy fragmencie "if (flaga2)". Teraz kod przedstawia się mniej więcej tak:
[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<#define PO_PRZECINKU 6 //zdefiniowanie liczby cyfr wywietlanych po przecinku
uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

uint32_t mnoznik;
uint16_t wynik;
uint32_t c;
uint32_t czesc_dziesietna;
uint32_t czesc_ulamkowa;
uint8_t k;
uint8_t a;
uint32_t b;
uint8_t pin;
uint8_t pomocnicza;
volatile unsigned char flaga1;
volatile unsigned char flaga2;

int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;

if (flaga1) {
wylaczenie();
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");
flaga1 = 0;
}

if (flaga2) {
b = (b / 5);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
lcd_int(b);
lcd_str("ms");
flaga2 = 0;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
}

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
wynik = 0;
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3s
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
OCR0 = 16;
TCCR0 |= (1 << WGM01); //timer 8-bitowy
TCCR0 |= ((1 << CS02) | (1 << CS00)); // prescaler 1024
TIMSK |= (1 << OCIE0);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wylaczenie();
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
lcd_int(wynik);
lcd_str("ms");
}

if (klawisz_wcisniety(KEY3_PIN)) {
b = 0;
wynik = 0;
lcd_cls();
for (a = 0; a < 5; a++) {
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3s
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania
OCR0 = 16;
TCCR0 |= (1 << WGM01); //timer 8-bitowy
TCCR0 |= ((1 << CS02) | (1 << CS00)); // prescaler 1024
TIMSK |= (1 << OCIE0);
}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}

ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
flaga1 = 1;
}

ISR(INT0_vect) {
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
wylaczenie();
if (a == 5) {
flaga2 = 1;
}
}

ISR (TIMER0_COMP_vect) {
wynik = wynik + 1;
TCNT0 = 0;
}[/syntax]

Pojedynczy pomiar pokazuje mi czas od 200 do 300ms, czyli mniej więcej poprawny. Natomiast 5-krotny pokazuje mi na przemian raz kilka tysięcy ms, innym razem 400-700ms, czyli tez niepopranie.

Statystyki: Napisane przez erykko — 2 lis 2013, o 12:50

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-02T12:43:13+01:00

A w którym miejscu kolega napisał że to ma być podzielone przez 5 ? ( jakoś nie mogę tego dopatrzyć )

PS. 80 ms to raczej trzeba odjąć a nie dodać, bo dodajesz już przy "debouncingu" więc 2 razy oszukujesz kolesia któr się sprawdza, a to już jest 160 ms ( ~1/6 sekundy ... ) więc już całkiem sporo, zwłaszcza że wcześniej chciałeś walczyć o 1us ....

Statystyki: Napisane przez acid3 — 2 lis 2013, o 12:43

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-02T11:15:16+01:00

Poprawiłem nieco kod, tak by liczenie odbywało się w ms, a nie us (jak było wcześniej). Uruchomiłem dodatkowo timer 8-bitowy, który zlicza milisekundy. Tak przedstawia się kod:
[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<#define PO_PRZECINKU 6 //zdefiniowanie liczby cyfr wywietlanych po przecinku
uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

uint32_t mnoznik;
uint16_t wynik;
uint32_t c;
uint32_t czesc_dziesietna;
uint32_t czesc_ulamkowa;
uint8_t k;
uint8_t a;
uint32_t b;
uint8_t pin;
uint8_t pomocnicza;
volatile unsigned char flaga1;
volatile unsigned char flaga2;

int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;

if (flaga1) {
wylaczenie();
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");
flaga1 = 0;
}

if (flaga2) {
c = (b / 5);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
lcd_int(c);
lcd_str("ms");
flaga2 = 0;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
}

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
wynik = 0;
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 1ms
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
OCR0 = 16;
TCCR0 |= (1 << WGM01); //timer 8-bitowy
TCCR0 |= ((1 << CS02) | (1 << CS00)); // prescaler 1024
TIMSK |= (1 << OCIE0);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wylaczenie();
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
wynik = wynik + 80;
lcd_int(wynik);
lcd_str("ms");
}

if (klawisz_wcisniety(KEY3_PIN)) {
b = 0;
wynik = 0;
lcd_cls();
for (a = 0; a < 5; a++) {
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 1ms
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania
OCR0 = 16;
TCCR0 |= (1 << WGM01); //timer 8-bitowy
TCCR0 |= ((1 << CS02) | (1 << CS00)); // prescaler 1024
TIMSK |= (1 << OCIE0);
}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}

ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
flaga1 = 1;
}

ISR(INT0_vect) {
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
TCCR0 &= ~((1 << CS02) | (1 << CS01) | (1 << CS00));
TCNT0 = 0;
wylaczenie();
if (a == 5) {
flaga2 = 1;
}
}

ISR (TIMER0_COMP_vect) {
wynik = wynik + 1;
TCNT0 = 0;
}[/syntax]

O ile pomiar jednokrotny działa w porządku (służy do tego KEY1_PIN oraz KEY2_PIN), o tyle pomiar 5-krotny nie pokazuje prawidłowego wyniku, tak jakby nie dzielił przez 5 i mam wynik 1200-1500ms zamiast 200-300ms. Czy ktoś widzi tu może jakiś błąd? Do pomiaru 5-krotnego służy KEY3_PIN oraz przerwanie zewnętrzne ISR(INT0_vect).

Statystyki: Napisane przez erykko — 2 lis 2013, o 11:15

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T21:09:05+01:00

właśnie testuję dla 10us i 20MHZ i w ogóle czasy się nie zgadzają

Statystyki: Napisane przez acid3 — 1 lis 2013, o 21:09

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T21:07:09+01:00

Aha, czyli tu może być pies pogrzebany...

Statystyki: Napisane przez erykko — 1 lis 2013, o 21:07

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T20:51:39+01:00

Właśnie sprawdzałem jak się uC zachowa przy 1us ... nie ogarnia się , nawet przy kwarcu 20Mhz

Statystyki: Napisane przez acid3 — 1 lis 2013, o 20:51

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T14:22:29+01:00

erykko, zerknij

https://www.youtube.com/watch?v=BGTkkmNs_oE

Statystyki: Napisane przez acid3 — 1 lis 2013, o 14:22

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T13:10:53+01:00

Mam 16MHz, ale prescaler 1024, więc impulsów w ciągu sekundy mam 15625, stąd ten wynik. Ale spróbuję dodać jeszcze 80ms do wyniku, z tym że to nie wyjaśnia skąd czasami pojawia się rezultat 0,000000s. Nie wiem czy dobrze rozumuję, poprawcie mnie jeśli się mylę. W każdym razie kwarc jest 16MHz, ale 2-bitowy timer nie liczy do takiej wartości, więc używam prescalera, tak by spokojnie doliczyć do tych kilku sekund.

A po co mi tak duża dokładność? Akurat ma to być możliwie najdokładniejszy stoper, więc dlatego tak dużo miejsc po przecinku.

Statystyki: Napisane przez erykko — 1 lis 2013, o 13:10

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T08:40:56+01:00

To tak mniej więcej jesli się nie mylę to powinieneś odjąć jeszcze przynajmniej 80ms do wyniku bo tracisz je na drgania styków. A tak na gorąco - to chyba nie możliwe jest policzenie każdego impulsu zegara AtMegi ... ale muszę się jeszcze nad tym zastanowić

------------------------ [ Dodano po: 7 minutach ]

no dobra 1us to 16 instrukcji uP więc powinno się dać ... ( ale po co ? )

------------------------ [ Dodano po: 19 minutach ]

Napisałeś, że jesteś w stanie zmierzyć

erykko napisał(a):

0,000064s.

... Jak ?
O ile mnie wzrok nie myli (o tak wczesnej porze ) to jest 64 us ....

Jeden cykl zegara przy 16Mhz wykonywany jest co 62,5 ns .... więc po 16 cyklach masz dokładnie 1 us ( pod warunkiem, że nie będziesz używał delay, lcd, działań arytmetycznych, itp )

Statystyki: Napisane przez acid3 — 1 lis 2013, o 08:40

Re: Sprawdzenie kodu w C - prosty stoper

2013-11-01T07:40:55+01:00

Wycisnąłem z tego najwięcej, tzn. dokładność 6 miejsc po przecinku (mikrosekundy). A dokładnie najmniejszą częścią sekundy jaką potrafię zmierzyć jest 0,000064s.

W moim przykładzie są 2 przerwania, pierwsze jest używane do wysłania komunikatu na wyświetlacz, a drugie do zatrzymania stopera i wykonania obliczeń. Nie są one uruchamiane cyklicznie. Timer jest uruchomiony w trybie CTC, więc w każdej sekundzie pojawia się określona liczba impulsów. Po wciśnięciu przycisku następuje zatrzymanie timera, odczytanie stanu liczby impulsów zliczonych przez timer, a następnie obliczenia.

Statystyki: Napisane przez erykko — 1 lis 2013, o 07:40

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-31T23:13:48+01:00

Napisz jeszcze proszę o jakiej dokładności mówisz, jaka jest Ci potrzebna, a jaką ustawiłeś w swoim programie ?

Próbowałem zanalizować Twój kod ale naprawdę wymiękłem w pewnym momencie...

PS. Zacząłem pisać swój własny stoper i może będzie działał trochę inaczej niż napisałeś ale może jakoś Ci pomoże. Niestety nie mogę obiecać na kiedy będzie, ale postaram się jak najszybciej. Ja założyłem, że 1/100 sek jest wystarczająco dokładne, więc przerwanie będzie co 10 ms.

Statystyki: Napisane przez acid3 — 31 paź 2013, o 23:13

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-31T21:25:50+01:00

Tak wygląda schemat, korzystam ze standardowej biblioteki p. Mirka, dodałem tylko możliwość wyświetlania dłuższych liczb (long int). Czym objawia się złe działanie, otóż układ wyświetla wynik w postaci 0,012345s czy 0,001234s, który jest niemożliwy fizycznie do uzyskania. Czasami też wynik potrafi wynosić 0,000000s.

KEY1_PIN startuje timer, KEY2 go zatrzymuje, zeruje, wyświetla wynik. KEY3_PIN startuje 5 kolejnych pomiarów, z których wyciągana jest średnia. Pomiary odbywają się przy użyciu przerwania ISR(INT0_vect). Jak widać jest to licznik mierzący czas reakcji, z tym że ma dosyć dużą dokładność.

Statystyki: Napisane przez erykko — 31 paź 2013, o 21:25

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-31T20:47:58+01:00

Erykko - dalej nie mam pojęcia jak ma działać Twój układ i nikt chyba nie wie i nie rozumie jak objawia się błąd. Napisz więc proszę jak ma działać (w miarę dokładnie), dodaj schemat żeby ew. ktoś mógł sobie zbudować układ u siebie i przetestować. Napisz jak objawia się błąd i dlaczego uważasz go za błąd ( możliwe że program działa właściwie ale niezgodnie z Twoimi oczekiwaniami). Musisz napisać coś więcej.

------------------------ [ Dodano po: 1 minucie ]

Jakiej biblioteki LCD używasz ?

Statystyki: Napisane przez acid3 — 31 paź 2013, o 20:47

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-31T19:59:21+01:00

Dodam jeszcze kilka informacji w pigułce. Otóż mikrokontroler to Atmega32, kwarc to 16MHZ. Stosuję timer 16-bitowy w trybie CTC, a prescaler 1024, więc w ciągu sekundy mam 15625 impulsów. W związku z tym mnożę otrzymaną wartość razy 64, dzięki czemu po podzieleniu przez milion mogę otrzymać część całkowitą i tą ułamkową po przecinku. Gdzieś musi być jakiś błąd, z tym że nie potrafię go zauważyć. Cały kod przedstawia się tak:
[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<#define PO_PRZECINKU 6 //zdefiniowanie liczby cyfr wywietlanych po przecinku
uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

uint32_t mnoznik;
uint32_t wynik;
uint32_t c;
uint32_t czesc_dziesietna;
uint32_t czesc_ulamkowa;
uint8_t k;
uint8_t a;
uint32_t b;
uint8_t pin;
uint8_t pomocnicza;
volatile unsigned char flaga1;
volatile unsigned char flaga2;

int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;

if (flaga1) {
wylaczenie();
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");
flaga1 = 0;
}

if (flaga2) {
mnoznik = 64;
b = b / 5;
c = (mnoznik * b);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
flaga2 = 0;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
}

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wynik = TCNT1;
wylaczenie();
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
mnoznik = 64;
c = (mnoznik * wynik);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
}

if (klawisz_wcisniety(KEY3_PIN)) {
lcd_cls();
for (a = 0; a < 5; a++) {
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania
}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}
ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
flaga1 = 1;

}

ISR(INT0_vect) {
wynik = TCNT1;
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
wylaczenie();
if (a == 5) {
flaga2 = 1;
}
}[/syntax]

Jednak błędu należałoby szukać gdzieś tutaj:
[syntax=c]if (klawisz_wcisniety(KEY1_PIN)) {
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wynik = TCNT1;
wylaczenie();
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
mnoznik = 64;
c = (mnoznik * wynik);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
}[/syntax]
Analogiczny kod jest dla pomiaru 5-krotnego, więc tam występuje ten sam babol. Tylko, że za nic nie potrafię go znaleźć.

Statystyki: Napisane przez erykko — 31 paź 2013, o 19:59

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-30T12:27:45+01:00

Jeśli chodzi o przerwanie i ustawienie w nim timera to jest to wyłącznie jego zatrzymanie, a następnie wyzerowanie. Już tłumaczę o co chodzi, otóż jest to stoper, który ma za zadanie mierzyć czas reakcji odpowiednio diodą bądź buzzerem. Mam 2 opcje, pierwsza stosuje pojedynczy pomiar, z kolei kolejna to 5 pomiarów, z których wyciągana jest średnia. Przeniosłem za Twoją radą także funkcję wyłączenia do pętli głównej programu. Ale nadal byłbym wdzięczny, gdyby ktoś mi pomógł z problemem:) W tej chwili kod wygląda tak:
[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<#define PO_PRZECINKU 6 //zdefiniowanie liczby cyfr wywietlanych po przecinku
uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

uint32_t mnoznik;
uint16_t wynik;
uint32_t c;
uint8_t czesc_dziesietna;
uint32_t czesc_ulamkowa;
uint8_t k;
uint8_t a;
uint32_t b;
uint8_t pin;
uint8_t pomocnicza;
volatile unsigned char flaga1;
volatile unsigned char flaga2;

int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;
if (flaga1) {
wylaczenie();
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");
flaga1 = 0;
}

if (flaga2) {
mnoznik = 64;
b = b / 5;
c = (mnoznik * b);
wylaczenie();
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
flaga2 = 0;
}

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wynik = TCNT1;
wylaczenie();
mnoznik = 64;
c = (mnoznik * wynik);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
}

if (klawisz_wcisniety(KEY3_PIN)) {
lcd_cls();
for (a = 0; a < 5; a++) {
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania
}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}
ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
flaga1 = 1;

}

ISR(INT0_vect) {
wynik = TCNT1;
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
if (a == 5) {
flaga2 = 1;
}
}[/syntax]
Aha, mikrokontroler to Atmega32. A komentarze sobie pozostawię dla samego siebie.

Statystyki: Napisane przez erykko — 30 paź 2013, o 12:27

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-26T15:35:26+01:00

erykko napisał(a):

ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
wylaczenie();
flaga1 = 1;

}

1. myślę, że ustawianie parametrów pracy Timera już w przerwaniu, to trochę za późno
2. Jak piszę jeden z naszych kolegów - Nie pisz komentarzy, dobry kod komentuje się sam - to Twój kod nie jest jeszcze tak dobry (BTW moje też nie są ) - gdybyś napisał w komentarzu co chciałeś osiągnąć byłoby trochę łatwiej.
3. Nie doczytałem jaki procek i zasadniczo niewielkie to znaczenie ma, ale za to wiadomo którego odpalić datasheet'a
4. Przy ustawianiu Timerów nie potrzebowałem chyba jeszcze nigdy negowania rejestrów (komentarze)
5. TCNT z tego co wiem nie odpowiada za COMPARE MATCH i tu chyba kolega powinien dać OCR - ale w sumie to nie wiem co kolega chciał osiągnąć (komentarze ) więc mogę się mylić i jest dobrze ...
6. znowu wywołanie funkcji wylaczenie() w Timerze - a nie lepiej byłoby flaga_wylacz ...
6a. po co, co kilka milisekund ( chyba, że rzadziej albo częściej - komentarze ) wywoływać funkcję która gasi diody ?

Statystyki: Napisane przez acid3 — 26 paź 2013, o 15:35

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-26T14:29:14+01:00

Dzięki bardzo! Rzeczywiście nie zauważyłem tego błędu.

Jeszcze bardzo bym prosił o to by ktoś sprawdził kod pod względem obliczeń, bo mam wrażenie, że czasami dostaję dziwne wyniki z timera. Mam kwarc 16MHz i włączony preskaler. Przy takich ustawieniach najmniejsza część sekundy jaka może zostać policzona to 0,000064s. Ale czasami stoper potrafi pokazać nieprawdopodobne wyniki w stylu 0,002123 czy 0,0212345. Wydaje mi się, że gdzieś jest błąd, tylko sam nie potrafię go znaleźć. Jakby ktoś coś zauważył byłbym wdzięczny.

Statystyki: Napisane przez erykko — 26 paź 2013, o 14:29

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-26T13:51:19+01:00

Tak, po wykonaniu czynności kontrolowanej flagą, musi ona wrócić do stanu poprzedniego, tak by wejście w przerwanie mogło ją ponownie ustawić. Inaczej raz ustawiona w przerwaniu będzie powodować nieustanne wykonywanie tego bloku funkcji związanych z wyświetlaczem. A z tego co pamiętam masz tam cls więc siłą rzeczy wyświetlacz jest cały czas kasowany.

Statystyki: Napisane przez sq8dsr — 26 paź 2013, o 13:51

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-26T12:53:04+01:00

Wydaje mi się, że po ustawieniu flaga1 w Timerze i wywołaniu funkcji obsługującej daną flagę należałoby tą flagę wyzerować, na końcu funkcji na przykład, bo w pętli już po pierwszym wystąpieniu przerwania flaga cały czas jest ustawiona na 1 i cały czas się wykonuje w kółko i lcd_cls i lcd_str co może spowodować takie efekty wizualne.

Statystyki: Napisane przez acid3 — 26 paź 2013, o 12:53

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-26T12:29:43+01:00

Poprawiłem kod w następujący sposób:
[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<#define PO_PRZECINKU 6 //zdefiniowanie liczby cyfr wywietlanych po przecinku
uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

uint32_t mnoznik;
uint16_t wynik;
uint32_t c;
uint8_t czesc_dziesietna;
uint32_t czesc_ulamkowa;
uint8_t k;
uint8_t a;
uint32_t b;
uint8_t pin;
uint8_t pomocnicza;
volatile unsigned char flaga1;
volatile unsigned char flaga2;

int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;
if (flaga1) {
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");
}

if (flaga2) {
mnoznik = 64;
b = b / 5;
c = (mnoznik * b);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
}

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wynik = TCNT1;
wylaczenie();
mnoznik = 64;
c = (mnoznik * wynik);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
}

if (klawisz_wcisniety(KEY3_PIN)) {
lcd_cls();
for (a = 0; a < 5; a++) {
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania
}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}
ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
wylaczenie();
flaga1 = 1;

}

ISR(INT0_vect) {
wynik = TCNT1;
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
wylaczenie();
if (a == 5) {
flaga2 = 1;
}
}[/syntax]
Jednak jest z tym mały problem, bo wyświetlacz wyświetla te flagi tak jakby nie miał ustawionego kontrastu. Ledwo można coś dostrzec.

Statystyki: Napisane przez erykko — 26 paź 2013, o 12:29

Re: Sprawdzenie kodu w C - prosty stoper

2013-10-26T10:15:28+01:00

A gdybym jedno przerwanie zrealizował w następujący sposób? A więc dodałem nową zmienną "z", która podwyższa się co jeden przy każdym przerwaniu, ale wyświetlacz ma dostawać komunikaty dopiero w pętli głównej programu. W tej chwili to jeszcze nie działa poprawnie (wyświetlacz nic nie wyświetla, ale pracuję nad tym ).
[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "LCD/lcd.h"

//dyrektywy dla preprocesora
//dioda
#define LED_PIN (1<#define BUZZ_PIN (1<#define LED_ON PORTC |= LED_PIN //włączenie diody
#define LED_OFF PORTC &= ~(LED_PIN) //wyłączenie diody
#define LED_TOG PORTC ^=LED_PIN //zmiana stanu diody
#define BUZZ_ON PORTC |= BUZZ_PIN; //włączenie buzzera
#define BUZZ_OFF PORTC &= ~(BUZZ_PIN) //wyłączenie buzzera
#define KONTROLKA1 (1<#define KONTROLKA2 (1<#define KONTROLKA1_ON PORTA |= KONTROLKA1 //włączenie kontrolki diody
#define KONTROLKA1_OFF PORTA &= ~(KONTROLKA1) //wyłączenie kontrolki diody
#define KONTROLKA1_TOG PORTA ^=KONTROLKA1 //zmiana stanu kontrolki diody
#define KONTROLKA2_ON PORTA |= KONTROLKA2 //włączenie kontrolki buzzera
#define KONTROLKA2_OFF PORTA &= ~(KONTROLKA2) //wyłączenie kontrolki buzzera
#define KONTROLKA2_TOG PORTA ^=KONTROLKA2 //zmiana stanu kontrolki buzzera
//przycisk
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<#define KEY5_PIN (1<#define PO_PRZECINKU 6 //zdefiniowanie liczby cyfr wywietlanych po przecinku
uint8_t klawisz_wcisniety(uint8_t klawisz); //definicja funkcji
uint8_t klawisz_wcisnietypina(uint8_t klawisz); //definicja funkcji dla pinu A
void wlaczenie(void); //definicja funkcji włączenia
void wylaczenie(void); //definicja funkcji wyłączenie

uint32_t mnoznik;
uint16_t wynik;
uint32_t c;
uint8_t czesc_dziesietna;
uint32_t czesc_ulamkowa;
uint8_t k;
uint8_t z;
uint8_t a;
uint32_t b;
uint8_t pin;
uint8_t pomocnicza;

int main(void) {

//inicjalizacja wyswietlacza
lcd_init();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Witaj!");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("Nacisnij Start");
DDRC |= (LED_PIN | BUZZ_PIN); //ustawienie PC7 (dioda) i PC3 (brzęczyk) jako wyjscie
PORTC &= ~(LED_PIN); //wyłączenie diody na PC7
DDRA |= (KONTROLKA1 | KONTROLKA2); //ustawienie PA6 i PA5 (kontrolek) jako wyjscie
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN); //ustawienie PC6 i PC5, PC4 jako wejscia
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN; //podciągnięcie PC6, PC5, PC4 do VCC
DDRD &= ~(KEY4_PIN); //ustawienie PD2 jako wejscie
PORTD |= KEY4_PIN; //podciagniecie PD2 do VCC
DDRA &= ~(KEY5_PIN); //ustawienie PA7 jako wejscie
PORTA |= KEY5_PIN; //podciagniecie PA7 do VCC

MCUCR |= (1 << ISC01); //zbocze opadające
GICR |= (1 << INT0); //przerwanie od przycisku 4

KONTROLKA1_ON;

sei();
//włączenie globalnego zezwolenia na przerwania

//pętla główna programu
while (1) {
k++;

if (klawisz_wcisnietypina(KEY5_PIN)) {
pin = pin + 1;
if (pin % 2 == 0) {
pomocnicza = 0;
KONTROLKA1_ON;
KONTROLKA2_OFF;
}
if (pin % 2 == 1) {
pomocnicza = 1;
KONTROLKA1_OFF;
KONTROLKA2_ON;
}

}

if (klawisz_wcisniety(KEY1_PIN)) {
lcd_cls();
k = rand();
if (k % 3 == 0)
_delay_ms(1000);
if (k % 3 == 1)
_delay_ms(1500);
if (k % 3 == 2)
_delay_ms(2000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A);
}

if (klawisz_wcisniety(KEY2_PIN)) {
wynik = TCNT1;
wylaczenie();
mnoznik = 64;
c = (mnoznik * wynik);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU; i > strlen(ltoa(reszta, bufor, 10));
i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
}

if (klawisz_wcisniety(KEY3_PIN)) {
z = 0;
lcd_cls();
for (a = 0; a < 5; a++) {
if (z == 5) {
mnoznik = 64;
b = b / 5;
c = (mnoznik * b);
lcd_cls();
lcd_locate(0, 0);
lcd_str("Twoj wynik to");
lcd_locate(1, 0);
czesc_dziesietna = c / 1000000;
czesc_ulamkowa = (c % 1000000); //reszta z dzielenia
lcd_int(czesc_dziesietna);
lcd_char(',');
uint16_t reszta = czesc_ulamkowa;
char bufor[PO_PRZECINKU + 1];
for (uint8_t i = PO_PRZECINKU;
i > strlen(ltoa(reszta, bufor, 10)); i--) {
lcd_char('0');
}
lcd_long_int(reszta);
lcd_str("s");
}
k = rand();
if (k % 3 == 0)
_delay_ms(2000);
if (k % 3 == 1)
_delay_ms(2500);
if (k % 3 == 2)
_delay_ms(3000);
wlaczenie(); //włączenie diody
OCR1A = 46875; //próg ustawiony na 3 sekundy
TCCR1B |= (1 << WGM12); //tryb CTC, TIMER1-16bit, rejestr TCCR1B
TCCR1B |= ((1 << CS12) | (1 << CS10)); // preskaler 1024
TIMSK |= (1 << OCIE1A); //rejestr porównania

}

}
}
}

//definicja funkcji, nie posiada wrgumentów, zwraca wynik 0 lub 1
//definicja funkcji-funkcja posiada argument, zwraca 0 lub 1
uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(PINC & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINC & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

uint8_t klawisz_wcisnietypina(uint8_t klawisz) {
if (!(PINA & klawisz)) //sprawdzanie czy wcisnięty klawisz
{
_delay_ms(80); //drganie styków
if (!(PINA & klawisz))
return 1;
}
return 0; // ponowne sprawdzanie czy wcisnięty klawisz
}

void wlaczenie(void) {
if (pomocnicza == 0) {
LED_ON;
}
if (pomocnicza == 1) {
BUZZ_ON;
}
}

void wylaczenie(void) {
if (pomocnicza == 0) {
LED_OFF;
}
if (pomocnicza == 1) {
BUZZ_OFF;
}
}
ISR(TIMER1_COMPA_vect) {
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
wylaczenie();
lcd_cls();
lcd_locate(0, 0); //ustawienie w 1 wierszu 1 kolumnie
lcd_str("Blad! Za dlugi");
lcd_locate(1, 0); //ustawienie w 2 wierszu 1 kolumnie
lcd_str("czas reakcji");

}

ISR(INT0_vect) {
wynik = TCNT1;
b = b + wynik;
TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));
TCNT1 = 0;
wylaczenie();
z = z + 1;
}[/syntax]
Nadal myślę jak zrealizować to pierwsze przerwanie pochodzące od timera i wywołujące komunikat na wyświetlaczu po osiągnięciu pewnego stanu licznika.

Statystyki: Napisane przez erykko — 26 paź 2013, o 10:15