ATNEL tech-forum

Re: Przyciski a przetwania

2017-01-02T13:41:28+01:00

Zegarek działa zgodnie z założeniami. Dziękuję!

Lekcja na przyszłość, warto odpocząć jak się utknie, ego nie jest najważniejsze

Statystyki: Napisane przez Krlk — 2 sty 2017, o 13:41

Re: Przyciski a przetwania

2017-01-02T12:01:46+01:00

Dodatkowo zmień na:
[syntax=c]#include [/syntax]

Tutaj jest błąd:
[syntax=c]// testowa dioda
TEST_LED_PORT |= TEST_LED;
TEST_LED_PORT |= TEST_LED; // dioda off[/syntax]

A jeśli zadeklarujesz zmienną static uint8_t licznik1;, którą masz w przerwaniu jako zmienną globalną uint8_t licznik1;to później możesz napisać:
[syntax=c]if ( (licznik0 == 1) && ( licznik1<=29 ) ) // kropka(GG.MM MM.SS)
{
SEGMENTY_PORT &= ~SEG_DP;

}[/syntax]
zamiast:
[syntax=c]if(licznik0 == 1) // kropka(GG.MM MM.SS)
{
SEGMENTY_PORT &= ~SEG_DP;

}[/syntax]
Aby ta cyfra z kropką nie migała, trzeba jeszcze zwiększyć trochę odświeżanie np OCR0=171 czyli 250Hz
Ostatni element tablicy const uint8_t cyfry[] PROGMEM tak na prawdę jest niepotrzebny:
[syntax=c]~(SEG_DP),[/syntax]

OCR2 powinno być równe 107, a nie 108.

No i na koniec musisz jeszcze gdzieś wywołać tą funkcję:
[syntax=c]zmiana_wys(stan);[/syntax]

Pozdrawiam

Statystyki: Napisane przez anshar — 2 sty 2017, o 12:01

Re: Przyciski a przetwania

2017-01-02T07:24:44+01:00

Poza tym chochlikiem w sposobie odczytywania stanu bitów portu,
jeszcze mało znaczący, ale też duszek.
w przerwaniu wartość wyliczana w pętli to min. 1 max 99 = 99 a nie 100. (przydało by się else).
[syntax=c]// Zliczanie sekund
ISR(TIMER2_COMP_vect) { // wchodze tu 100 razy na sekunde

static uint8_t licznik1;

if(licznik1 == 99) {

czas(); // czas(); - wykonuje 1 raz na sekunde
licznik1 = 0;
}
else licznik1++;
};[/syntax]
teraz jest od 0 do 99 = 100. setnym działaniem jest tylko wpisanie zera - bez inkrementacji.

Statystyki: Napisane przez Daro69 — 2 sty 2017, o 07:24

Re: Przyciski a przetwania

2017-01-02T06:36:33+01:00

Krlk napisał(a):

if( !key_lock && !(PORT_KEY & KEY ) ) {
key_lock=50000;

TEST_LED_PORT &= ~TEST_LED;
//_delay_ms(10000);

//stan ^= true;

} else if( key_lock && (PORT_KEY & KEY ) ) key_lock++;

Bo to NIGDY nie ma prawa zadziałać, zajrzyj na bloga i porównaj toż masz tam poprawny kod

Statystyki: Napisane przez mirekk36 — 2 sty 2017, o 06:36

Re: Przyciski a przetwania

2017-01-02T05:32:16+01:00

Przeniosłem sei(); przed pętlę while, a obie procedury obsługi przerwań napisałem w pliku z funkcjami, pliku.c (tam gdzie jest funkcja "init_IO"), ale w dalszym ciągu nie wchodzę do zdażenia "PRES BUT"...myślałem że to może coś sprzętowego, ale po podłączenia pinu 7 portu C, na którym mam zdefiniowany przycisk, zarówno do GND i VCC płytki, nie mam reakcji więc to prawie na pewno kwestia programowa...

Ten projekcik to zwykły zegarek na wyświetlaczu siedmiosegmentowym zestawu ATB. Płytka Atnel ma standardowo 4 moduły cyfr, wszystko działa, to znaczy kiedy chcę wyświetlić godzinę i minuty albo minuty i sekundy, ale do skończenia całości zostało mi do zrealizowania przełączanie pomiędzy tymi stanami czyli wyświetlaniem GG:MM i MM:SS po przyciśnięciu guzika...niby najprostsza rzecz na świecie...no i właśnie z nią mam ten problem...

Wrzucę niżej jak wygląda całość kodu może czegoś się dopatrzycie
Był bym wdzięczny

zegar.h:
[syntax=c]// zegar.h

#ifndef MULTIPLEKS_H_
#define MULTIPLEKS_H_

// definicje portu i rejestru kierunkowego dla SEGMENTÓW wysw
#define SEGMENTY_PORTPORTA
#define SEGMENTY_KIERUNEKDDRA

// definicje portu i rejestru kierunkowego dla ANOD wysw
#define ANODY_PORTPORTC
#define ANODY_KIERUNEKDDRC

// definicje bitów dla ANOD
#define ANODA_1(1<<0)
#define ANODA_2(1<<1)
#define ANODA_3(1<<2)
#define ANODA_4(1<<3)

#define MASKA_ANODY (ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4)

// definicje bitów dla SEGMENTÓW
#define SEG_A(1<<0)
#define SEG_B(1<<1)
#define SEG_C(1<<2)
#define SEG_D(1<<3)
#define SEG_E(1<<4)
#define SEG_F(1<<5)
#define SEG_G(1<<6)
#define SEG_DP(1<<7)

extern uint8_t cyfry_do_wys[6];

// czas na wyświetlacz
extern uint8_t g1;
extern uint8_t g2;
extern uint8_t m1;
extern uint8_t m2;
extern uint8_t s1;
extern uint8_t s2;

// sprawdzenie czy wcisniety klawisz
extern _Bool stan;

//
#define MIN2_PLUS ((s1 == 5) & (s2 ==9))
#define GODZ2_PLUS ((m1 == 5) & (m2 == 9))

// przycisk
#define PORT_KEY PORTC
#define KEY (1<
// testowa dioda
#define TEST_LED(1<#define TEST_LED_PORTPORTC

// moje funkcje
void init_IO(void);// inicjalizacja wejść wyświetlacza 7 segmentowego
void czas(void);// funkcja wpisujaca godzine do tablicy cyfr wyswietlanych na wyswietlaczu
void zmiana_wys(_Bool zm_wys);// zmiana z GG:MM na MM:SS po wciśnięciu but

#endif /* MULTIPLEKS_H_ */[/syntax]

zegar.c:
[syntax=c]// zegar.c

#include
#include
#include
#include

#include "zegar.h"

const uint8_t cyfry[] PROGMEM = {
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F ),// 0
~(SEG_B | SEG_C),// 1
~(SEG_A | SEG_B | SEG_D | SEG_E | SEG_G),// 2
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_G),// 3
~(SEG_B | SEG_C | SEG_F | SEG_G),// 4
~(SEG_A | SEG_C | SEG_D | SEG_F | SEG_G),// 5
~(SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G),// 6
~(SEG_A | SEG_B | SEG_C | SEG_F),// 7
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G), // 8
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G),// 9
~(SEG_DP),// .
};

uint8_t cyfry_do_wys[6]; // zmienna tablicowa zawierająca cyfry do wyświetlenia

// czas na wyświetlacz
uint8_t g1;
uint8_t g2;
uint8_t m1;
uint8_t m2;
uint8_t s1;
uint8_t s2;

// sprawdzenie czy wcisniety klawisz
_Bool stan = true;

void init_IO(void) {
// przycisk
DDRC &= ~KEY;
PORT_KEY |= KEY;

// testowa dioda
TEST_LED_PORT |= TEST_LED;
TEST_LED_PORT |= TEST_LED; // dioda off

SEGMENTY_KIERUNEK|= 0xff;// ustawienie portu katod(segmentow) jako wyjścia
SEGMENTY_PORT|= 0xff;// wygaszam wszystkie segmenty przez podanie 1 na katody

ANODY_KIERUNEK|= ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4;// ustawienie anod jako wyjsc
ANODY_PORT|= ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4;// w ATB 1.05 zastosowano kluczowanie nap przez tranzystory PNP, a emiter jest na Vcc, czyli dla 1 na bazie potencjał będzie 0, a dla 0 potencjał na bazie będzie 1.

//********************************************************************************************** TIMERY

// TIMER0
TCCR0 |= (1<< WGM01);// Tryb pracy CTC
TCCR0 |= (1<OCR0 = 215;// 200 Hz
TIMSK |= (1<
// TIMER2
TCCR2 |= (1<< WGM21);// Tryb pracy CTC
TCCR2 |= (1<OCR2 = 108;// 100 Hz = 0.01 s
TIMSK |= (1<}

//*************************************************************************************************** PRZERWANIA

// Multipleksowanie wyświetlacza
ISR(TIMER0_COMP_vect) { // funkcja przerwań, tu piszę CO MA SIĘ DZIA PODCZAS PRZERWANIA!!!

static uint8_t licznik0; //static - zmienna istnieje przez cały czas trwania programu, Prawie zmienna globalna!
// nie jest tak że cały czas tworzę od nowa tą zmienną? nie powinna się wyzerować za każdym razem???

ANODY_PORT |= MASKA_ANODY; // wygaszenie

SEGMENTY_PORT = pgm_read_byte(&cyfry[cyfry_do_wys[licznik0]]);

ANODY_PORT = (ANODY_PORT & ~MASKA_ANODY) | (~(1<
if (licznik0 == 1) // kropka(GG.MM MM.SS)
{
SEGMENTY_PORT &= ~SEG_DP;
}

licznik0++;
if(licznik0 >3) licznik0 =0;

};

// Zliczanie sekund
ISR(TIMER2_COMP_vect) { // wchodze tu 100 razy na sekunde

static uint8_t licznik1;

if(licznik1 == 99) {

czas();// czas(); - wykonuje 1 raz na sekunde
licznik1 = 0;
}

licznik1++;
};

void czas(void) {

// g1g2:m1m2:s1:s2

// MIN2_PLUS -> ((s1 == 5) & (s2 ==9))
// GODZ2_PLUS -> ((m1 == 5) & (m2 == 9))

// g1
if ((g1 <2) & (g2 == 9) & GODZ2_PLUS & MIN2_PLUS ){
if((g1 == 1) & (g2 ==9) & GODZ2_PLUS & MIN2_PLUS) {
g1=2;
g2=0;
goto skok;
}
g1++;
}
else if((g1 == 2) & (g2 == 3) & GODZ2_PLUS & MIN2_PLUS) {
g1=0;
g2=0;
goto skok;
}

// g2
//dla 19 lub 10
if ((g1 < 2) & (g2 < 9) & GODZ2_PLUS & MIN2_PLUS){
g2++;
}
else if((g1 < 2) & (g2 == 9) & GODZ2_PLUS & MIN2_PLUS) {
g2 = 0;
}

//dla 23
else if((g1 > 1) & (g2 < 3) & GODZ2_PLUS & MIN2_PLUS) {
g2++;
}

skok:

// m1
if ((m1<5) & (m2 == 9) & MIN2_PLUS){
m1++;
}
else if(GODZ2_PLUS & MIN2_PLUS){
m1 = 0;
}

// m2
if ((m2<9) & MIN2_PLUS){
m2++;
}
else if ((m2 ==9) & MIN2_PLUS){
m2 =0;
}

// s1
if ((s1 < 5) & (s2 == 9)){
s1++;
}
else if (MIN2_PLUS){
s1 =0;
}

//s2
if (s2 == 9) {
s2 = 0;
}
else {
s2++;
}

// wpisanie godziny
cyfry_do_wys[0] = g1;
cyfry_do_wys[1] = g2;
cyfry_do_wys[2] = m1;
cyfry_do_wys[3] = m2;
cyfry_do_wys[4] = s1;
cyfry_do_wys[5] = s2;

};

// Przełączanie GG:MM na MM:SS
void zmiana_wys(_Bool zm_wys){
if(!zm_wys){
cyfry_do_wys[0] = m1;
cyfry_do_wys[1] = m2;
cyfry_do_wys[2] = s1;
cyfry_do_wys[3] = s2;
}
else{
cyfry_do_wys[0] = g1;
cyfry_do_wys[1] = g2;
cyfry_do_wys[2] = m1;
cyfry_do_wys[3] = m2;
}

};[/syntax]

main.c:
[syntax=c]#include
#include
#include
#include
#include

#include "Lib/zegar.h"

uint16_t key_lock;

int main(void)
{
init_IO(); // inicjalizacja I/O

// godzina początkowa g1g2:m1m2:s1s2
g1=2;
g2=3;
m1=4;
m2=9;
s1=5;
s2=4;

// Czy dobre dane wejściowe?
g1=(g1>2) ? 2 : g1;// dla g1
// dla g2
if ((g1<2) & (g2>9)){
g2=9;
}
else if ((g1>1) & (g2>3)) {

g2 = 3;
}
m1=(m1>5) ? 5 : m1;// dla m1
m2=(m2>9) ? 9 : m2;// dla m2
s1=(s1>5) ? 5 : s1;// dla s1
s2=(s2>9) ? 9 : s2;// dla s2

sei();

while(1) {
if( !key_lock && !(PORT_KEY & KEY ) ) {
key_lock=50000;

TEST_LED_PORT &= ~TEST_LED;
//_delay_ms(10000);

//stan ^= true;

} else if( key_lock && (PORT_KEY & KEY ) ) key_lock++;

//TEST_LED_PORT ^= TEST_LED;
//_delay_ms(1000);
}
}[/syntax]

Siedzę nad tym całą noc, ale jestem już tak bardzo tym sfrustrowany że nie ma szans żebym dzisiaj coś znalazł

Tak naprawdę to program jest gotowy o ile załapie przycisk...

Statystyki: Napisane przez Krlk — 2 sty 2017, o 05:32

Re: Przyciski a przetwania

2017-01-02T04:21:36+01:00

sei(); powinno znajdować się tuż przed pętlą główną while(1).
Czy masz napisane procedury obsługi tych przerwań?
Przynajmniej tak:
[syntax=c]ISR(TIMER0_COMP_vect) {

}
ISR(TIMER2_COMP_vect) {

}[/syntax]

Statystyki: Napisane przez anshar — 2 sty 2017, o 04:21

Przyciski a przetwania

2017-01-02T02:49:06+01:00

Cześć, ostatnio napisałem mały programik wykorzystujący timery i przerwania w trybie CTC, teraz chciałem dodać obsługę klawisza.
Dodałem obsługę taką jak na blogu Pana Mirka:

[syntax=c]while(1) {

if( !key_lock && !(PINC & KEY1 ) ) {
key_lock = 50000;

// reakcja na PRESS (wcinięcie przycisku)
PORTC ^= LED;

} else if( key_lock && (PINC & KEY1 ) ) key_lock++;
}
}[/syntax]

I tu pojawia się pewne ALE...nie mogę wejść do zdażenia "PRESS"...

Dla przetestowania wstawiłem sobie tam zapalanie diody ale co bym nie robił to ta nie chce się załączyć...

Oczywiście próbowałem również podstawowej wersji detekcji wciśnięcia:
[syntax=c]if(!(PINC & (1<i nic...

Tu rodzi się moje pytanie. Czy przerwanie może w jakiś sposób zakłócić odczyt wciśnięcia klawisza?

Poniżej, najistotniejsze fragmenty kodu, z punktu widzenia tego posta.

main.c:
[syntax=c]#include
...
...
...

uint16_t key_lock;

int main(void)
{
sei();

init_IO(); //inicjalizacja I/O

...
...
...

while(1) {

if( !key_lock && !(PORT_KEY & KEY ) ) {
key_lock=50000;

TEST_LED_PORT ^= TEST_LED;
_delay_ms(10000);

} else if( key_lock && (PORT_KEY & KEY ) ) key_lock++;

//TEST_LED_PORT ^= TEST_LED;
//_delay_ms(1000);

if (!(PORT_KEY & KEY)) {

TEST_LED_PORT &= ~TEST_LED;

//zmiana_wys(stan);

//stan ^= true;
}
}

}[/syntax]

biblioteka z funkcja "init_IO".c:
[syntax=c]void init_IO(void) {
// przycisk
DDRC &= ~KEY;
PORT_KEY |= KEY;

// testowa dioda
DDRC |= TEST_LED;
TEST_LED_PORT |= TEST_LED; // dioda off
...
...
...

// TIMER0
TCCR0 |= (1<< WGM01);// Tryb pracy CTC
TCCR0 |= (1<OCR0 = 215;// 200 Hz
TIMSK |= (1<
// TIMER2
TCCR2 |= (1<< WGM21);// Tryb pracy CTC
TCCR2 |= (1<OCR2 = 108;// 100 Hz = 0.01 s
TIMSK |= (1<}[/syntax]

plik z definicjami plik.h:
[syntax=c]// przycisk
#define PORT_KEY PORTC
#define KEY (1<
// testowa dioda
#define TEST_LED(1<#define TEST_LED_PORTPORTC[/syntax]

Statystyki: Napisane przez Krlk — 2 sty 2017, o 02:49