ATNEL tech-forum

Re: Problem z wymuszonym opuszczeniem pętli for

2019-01-21T21:17:37+01:00

SylwekK napisał(a):

Najważniejsze żeby wszystko już na stole działało w 100% zgodnie z założeniami wtedy po zainstalowaniu na bramie będzie łatwiej uruchamiać

Sam ATtiny działa w 100%, ale sterownik będzie zawierał jeszcze dwa komparatory na LM393 - jeden do czujnika zmierzchowego, drugi do zabezp. przeciążeniowego, współpracujący z modułem pomiaru prądu na ukłdzie ACS712. I tu mogą zdarzyć się niespodzianki, a niespodzianki mnie lubią, bez wzajemności
Może też się okazać konieczne zamienić miejscami jakieś piny, żeby uprościć ścieżki na płytce.
Na razie dopracowuję schemat na papierze. Muszę to przespać, kilka razy przemyśleć, może nasunie się jakiś nowy pomysł. Został mi jeden wolny pin w mikrokontrolerze, więc kto wie?
Gdy to dopracuję, na pewno umieszczę całą konstrukcję w dziale DIY.

Statystyki: Napisane przez oowan — 21 sty 2019, o 21:17

Re: Problem z wymuszonym opuszczeniem pętli for

2019-01-21T16:09:32+01:00

Najważniejsze żeby wszystko już na stole działało w 100% zgodnie z założeniami wtedy po zainstalowaniu na bramie będzie łatwiej uruchamiać

Statystyki: Napisane przez SylwekK — 21 sty 2019, o 16:09

Re: Problem z wymuszonym opuszczeniem pętli for

2019-01-21T14:19:05+01:00

Praktycznie ukończyłem program. Jest wszystko co chciałem osiągnąć. Pewnie potrzebne będą jakieś korekty przy uruchamianiu sterownika - z tym poczekam do wiosny, nie chcę marznąć teraz w garażu
[syntax=c]#include
#include
#include

#include "pwm.h" // dołączenie pliku nagłówkowego z obsługą PWM
#include "timer.h" // dołączenie pliku nagłówkowego z obsługą timera tykającego co 1ms

#define PWM_WY (1<#define PKO_WY (1<#define PKZ_WY (1<#define PK_LAMP (1<#define LED_WY (1<
#define KEY_STOP (1<#define KEY_PINZ (1<#define KEY_PINO (1<#define KEY_KASUJ (1<#define KEY_LAMP (1<#define KEY_INDO (1<#define KEY_KRZ (1<#define KEY_KRO (1<//wejścia na porcie A
#define ZMIERZCH (1<#define IN_AMPER (1<//wejścia na porcie D
#define FOTO (1<
#define PKO_OFF PORTD &= ~PKO_WY // makrodefinicja - załączenie przekaźnika OTWARCIA
#define PKO_ON PORTD |= PKO_WY // makrodefinicja - wyłączenie przekaźnika OTWARCIA
#define PKZ_OFF PORTD &= ~PKZ_WY // makrodefinicja - załączenie przekaźnika ZAMKNIĘCIA
#define PKZ_ON PORTD |= PKZ_WY // makrodefinicja - wyłączenie przekaźnika ZAMKNIĘCIA
#define LAMP_ON PORTD |= PK_LAMP // makrodefinicja - załączenie przekaźnika LAMPA
#define LAMP_OFF PORTD &= ~PK_LAMP// makrodefinicja - wyłączenie przekaźnika LAMPA
#define LED_MIG PORTD ^= LED_WY // miganie LED - kontrolka
#define LED_ON PORTD |= LED_WY // załącz LED - kontrolka
#define LED_OFF PORTD &= ~LED_WY // wyłącz LED - kontrolka
#define NO_SENS_TIME 120//czas nieczułości czujnika zmierzchowego - podany w sekundach
#define SHORT_TIME 120//krótki czas świecenia lampy - czas podany w sekundach
#define LONG_TIME 900//długi czas świecenia lampy - czas podany w sekundach
#define TEST_TIME 2//testowy czas świecenia lampy, po zadziałaniu czujnika zmierzchowego
// (gdy jest jasno)

//określenia "maszyny stanów"
enum maszyna_st {
stop, otwieranie, zamykanie, przeciazenie
};

enum maszyna_st stan;

uint8_t predkosc_rampy = 6; //prędkość rampy PWM do przyspieszania/zwolniania silnika
uint8_t predkosc_silnika; //deklaracja zmiennej licznika dla PWM
uint8_t key_lock;//zmienna pomocnicza przy obsłudze włączania LAMPY (inkrementacja do 255)
volatile uint8_t mig; //zmienna dla migania LED

//Pole bitowe
struct {
uint8_t zmierzch:1; //flaga wył. zmierzchowego 0=ciemno, 1=jasno
uint8_t pauza:1; //flaga 0=wyłączony timer nieczułości, 1=włączony timer nieczułości
uint8_t rampa_kierunek:1; //flaga 0=postój, 1=praca silnika
uint8_t krancowka_O:1;//flaga krańcówki całkowitego otwarcia
uint8_t krancowka_Z:1;//flaga krańcówki całkowitego zamknięcia
uint8_t wolniej:1;//flaga czujnika zwolnienia silnika
uint8_t x;//flaga w funkcji pressKR
uint8_t lampa;//flaga 0=lampa "na czuwaniu", 1=lampa włączona ręcznie przyciskiem
} flaga;

//deklaracja funkcji obsługi przycisków z filtracją zakłóceń
void press(uint8_t KEY_x, uint8_t stan_x, uint8_t timer_key_x);
uint8_t pressKR(uint8_t KEY_x, uint8_t timer_key_x);

int main(void) {

timer_init(); // inicjalizacja timera tykającego co 1ms
pwm_init(); // inicjalizacja PWM

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

DDRD |= PKO_WY | PKZ_WY | PK_LAMP; //ustawienie pinów portu D jako wyjścia
DDRD |= PWM_WY | LED_WY;
PORTB |= KEY_PINO | KEY_PINZ | KEY_KRO | KEY_STOP; //podciągnięcie wejść do Vcc
PORTB |= KEY_INDO | KEY_LAMP | KEY_KRZ | KEY_KASUJ;//tylko jeśli nie ma wlutowanych
PORTA |= ZMIERZCH | IN_AMPER;//rezystorów podciągających
PORTD |= FOTO;

_delay_ms(10); // oczekiwanie na ustalenie się stanu wysokiego na wejściach

while (1) {

if(stan == zamykanie) {//zadziałanie fotokomórki tylko podczas zamykania
press(FOTO, stop, timer_FOTO);
}

if(stan) {//zadziałanie zabezp. przeciążeniowego silnika
if (!(PINA & IN_AMPER)) stan = przeciazenie;
}

if(stan!=przeciazenie){//Po zadziałąniu zabezp. przeciciążenia blokowane są
//przyciski STOP, OTWÓRZ, ZAMKNIJ aż do skasowania przyciskiem KASUJ
press(KEY_STOP, stop, timer_keySTOP);//wejście przycisku STOP

if(stan != zamykanie) {//Blokowanie przycisku OTWÓRZ podczas zamykania
press(KEY_PINO, otwieranie, timer_keyO);//wywołanie funkcji / wejście przycisku OTWÓRZ
}

if(stan != otwieranie) {//Blokowanie przycisku ZAMKNIJ podczas otwierania
press(KEY_PINZ, zamykanie, timer_keyZ);//wejście przycisku ZAMKNIJ
}
}

flaga.krancowka_O = pressKR(KEY_KRO, timer_keyKRO);//wejście krańcówki otwarcia

flaga.krancowka_Z = pressKR(KEY_KRZ, timer_keyKRZ);//wejście krańcówki zamknięcia

flaga.wolniej = pressKR(KEY_INDO, timer_keyIND);//wejście czujnika indukcyjnrgo, zwalniającego

flaga.lampa = pressKR(KEY_LAMP, timer_keyLAMP);//wejście przycisku wł-wył LAMPY

switch (stan) {
case stop: //stan = 0
predkosc_silnika = 0;
OCR0B = 0;
flaga.rampa_kierunek = 0;
flaga.pauza = 0;
PKO_OFF;
PKZ_OFF;
break;

case otwieranie: //stan = 1
PKO_ON;//kierunek silnika otwieranie
if(!flaga.zmierzch) {//jeśli jest jasno, to timer_lampy NIE zostanie ustawiony
if(timer_lampy < SHORT_TIME) timer_lampy = SHORT_TIME;//jeśli czas świecenia lampy jest krótszy od SHORT_TIME
}//lub jeśli lampa jest wyłączona (timer_lampy=0),
//to timer_lampy zostanie ustawiony na czas SHORT_TIME

if (!timer_ind && !flaga.pauza) {
timer_ind = 2;//timer czasu nieczułości czujnika zwalniania w sekundach
flaga.pauza = 1;
}
if (flaga.krancowka_O) {
stan = stop;//wyłącz po osiągnięciu krańcówki otwarcia
//LED_ON;
}
break;

case zamykanie: //stan = 2
PKZ_ON;//kierunek silnika zamykanie
if(!flaga.zmierzch) {//jeśli jest jasno, to timer_lampy NIE zostanie ustawiony
if(timer_lampy < SHORT_TIME) timer_lampy = SHORT_TIME;//jeśli czas świecenia lampy jest krótszy od SHORT_TIME
}//lub jeśli lampa jest wyłączona (timer_lampy=0),
//to timer_lampy zostanie ustawiony na czas SHORT_TIME

if (!timer_ind && !flaga.pauza) {
timer_ind = 2;//timer czasu nieczułości czujnika zwalniania w sekundach
flaga.pauza = 1;
}
if (flaga.krancowka_Z) {
stan = stop; //wyłącz po osiągnięciu krańcówki zamknięcia
//LED_OFF;
}
break;

case przeciazenie: //stan = 3Po zadziałaniu zabezp. przeciążeniowego silnika
predkosc_silnika = 0;//trzeba skasować stan PRZECIĄŻENIE, aby wejść w stan STOP
OCR0B = 0;
flaga.rampa_kierunek = 0;
flaga.pauza = 0;
PKO_OFF;
PKZ_OFF;
if (!(PIND & KEY_KASUJ)) stan = stop;

}

if (!timer && stan) //połączony warunek - wykonuj tylko jeśli jakiś ruch ma być
{
timer = predkosc_rampy;
OCR0B = predkosc_silnika;

if (flaga.wolniej && !timer_ind) //zmienna timer_ind blokuje czujnik zwalniania prędkości
flaga.rampa_kierunek = 1; //po tym czasie czeka na dojechanie do drugiego czujnika zwalniania prędkości

if (!flaga.rampa_kierunek) {
if (predkosc_silnika < 255)
predkosc_silnika++; //przyspieszanie
} else {
if (predkosc_silnika > 10)
predkosc_silnika--; //zwalnianie - 50 to minimalna prędkość dojazdowa przy jakiej silnik jeszcze kręci
}
}

// Warunek zezwalający na miganie diody
if(flaga.krancowka_Z || flaga.krancowka_Z) mig = 0; //jeżeli jedna z krańcówek jest wciśnięta - miganie wyłączone
else mig = 1;//jeżeli obie krańcówki są zwolnione - miganie włączone
if(stan == przeciazenie) mig = 2;
if(flaga.krancowka_O) LED_ON;
if(flaga.krancowka_Z) LED_OFF;

//Procedura czasu nieczułości czujnika zmierzchowego
if (PINA & ZMIERZCH)
{
if(!timer_zmierzch) flaga.zmierzch = 1;// flaga.zmierzch = 1-jasno
}
else {
timer_zmierzch=NO_SENS_TIME;
flaga.zmierzch = 0;// flaga.zmierzch = 0-ciemno
}

//Procedura skracania czasu świecenia lampy po rozjaśnieniu
if((timer_lampy>TEST_TIME) && flaga.zmierzch) timer_lampy=TEST_TIME;// Jeżeli timer_lampy był ustawiony i lampa świeciła,
// to po rozwidnieniu czas świecenia zostanie skrócony do 3 sekund.
// Wciśnięcie przycisku LAMPA, włączy lampę na 2 sek.

//Obsługa przycisku wł-wył LAMPY
if (!key_lock && flaga.lampa) {//flaga.lampa=0 przycisk puszczony,
key_lock = 1;//flaga.lampa=1 przycisk wciśnięty
if(!timer_lampy) {
if(!flaga.zmierzch) timer_lampy = LONG_TIME;//Gdy jest ciemno, lampa świeci przez czas LONG_TIME
else timer_lampy=TEST_TIME;// po rozwidnieniu lampa włącza się na czas TEST_TIME (3 sek.)
}
else timer_lampy = 0;

} else if(key_lock && !flaga.lampa) key_lock++;

//Warunek zezwalający na włączenie lampy
if (timer_lampy) LAMP_ON;
else LAMP_OFF;

}
}

//FUNKCJA OBSŁUGI PRZYCISKU Z FILTRACJĄ ZAKŁÓCEŃ
void press(uint8_t KEY_x, uint8_t stan_x, uint8_t timer_key_x){
if (!(PINB & KEY_x)){//nasiśnięcie przycisku, jeśli będzie to szpilka zakłócająca, to po jej
//zaniku warunek nie będzie spełniony i przejdzie do else
if(!timer_key_x) stan = stan_x;//gdy timer_key odliczy w przerwaniu do zera, to silnik się włączy
}
else timer_key_x = 10;//licznik będzie permanentnie ustawiany na 10 - opóźnienie 10ms
}

//FUNKCJA OBSŁUGI KRAŃCÓWKI Z FILTRACJĄ ZAKŁÓCEŃ
uint8_t pressKR(uint8_t KEY_x, uint8_t timer_key_x){
if (!(PINB & KEY_x)){
if(!timer_key_x) flaga.x = 1;
}
else {
flaga.x = 0;
timer_key_x = 10;
}
return flaga.x;
}

// PROCEDURA OBSŁUGI PRZERWANIA COMPARE MATCH - timer0A - timer programowy
ISR(TIMER0_COMPA_vect) {
if (timer) timer--; // zmienna timera do określenia predkosc_rampy dla PWM ok.1,5sek.
if (timer_keyO) timer_keyO--;//odliczanie 10ms na pominięcie ewentualnych zakłóceń
if (timer_keyZ) timer_keyZ--;
if (timer_keyKRO) timer_keyKRO--;
if (timer_keyKRZ) timer_keyKRZ--;
if (timer_keyIND) timer_keyIND--;
if (timer_keySTOP) timer_keySTOP--;
if (timer_FOTO) timer_FOTO--;
if (timer_keyLAMP) timer_keyLAMP--;
}

// PROCEDURA OBSŁUGI PRZERWANIA COMPARE MATCH timer1A
ISR(TIMER1_COMPA_vect) {
static uint8_t cnt; // statyczna zmienna cnt

if (++cnt > 9) { // zmienna cnt jest zwiększana od 0 - 8

if (timer_ind) timer_ind--;//timer czasu nieczułości czujnika zwalniania prędkości
//zmniejsza się co sekundę
if(timer_lampy) timer_lampy--;//timer_lampy odlicza czas włączenia lampy
if(timer_zmierzch) timer_zmierzch--; //timer czasu nieczułości czujnika zmierzchowego
cnt = 0;
}

if(mig == 2) LED_MIG;//po wykryciu przeciążenia LED miga co 100ms
else if (!(cnt % 5) && mig == 1) LED_MIG; // przełącz diodę co 500ms
}[/syntax]
Wielkie dzięki za pomoc

Statystyki: Napisane przez oowan — 21 sty 2019, o 14:19

Re: Problem z wymuszonym opuszczeniem pętli for

2019-01-12T12:12:57+01:00

Można i tak, ale wystarczy dodatkowy timer programowy z dzielnikiem przez, np. 100 dodać.

Statystyki: Napisane przez SylwekK — 12 sty 2019, o 12:12

Re: Problem z wymuszonym opuszczeniem pętli for

2019-01-12T08:10:46+01:00

SylwekK napisał(a):

Jeśli w pętli głównej używasz do timera 16-bitowej zmiennej, która jest odliczania w przerwaniach to ZAWSZE będzie problem z regularnym odliczaniem chyba, że... podczas tego odświeżania zostaną wyłączone przerwania (poczytaj atomic blok).

Poszedłem w innym kierunku - uruchomiłem drugi timer sprzętowy na 10Hz, do obsługi migania i odmierzania czasu świecenia lampy. To chyba prostsze rowiązanie? Chyba, że do odmierzania minut dla lampy dam osobny timer, 16-bitowy Jakby nie było, tiny2313 ma dwa dwukanałowe timery

Statystyki: Napisane przez oowan — 12 sty 2019, o 08:10

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-28T20:55:57+01:00

Statystyki: Napisane przez SylwekK — 28 gru 2018, o 20:55

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-28T20:37:43+01:00

oowan napisał(a):

jeżeli przedstawisz ciało funkcji 'timer_init();', to może coś da się wywnioskować/wyliczyć.

[syntax=c]void timer_init(void){
//***** Sprzętowy timer0A w ATTiny2313 dla F_CPU=8,0MHz *******
TCCR0A |= (1<TCCR0B |= (1<OCR0A = 124;/* dodatkowy podział przez 125 (rejestr przepełnienia) */
TIMSK |= (1</* przerwanie wykonywane co 1ms (1000 razy na sek.) */
}[/syntax]
Spróbowałem ten fragment
[syntax=c]if (!(cnt % 250) && flaga.mig) LED_MIG; // przełącz diodę co 250ms[/syntax] przenieść z obsługi przerwania do pętli głównej. Oczywiście zmienną cnt zmieniłem z lokalnej na globalną volatile.
Dioda migała, ale bardzo nieregularnie. Czasem kilka krótkich błysków, czasem dłuższe przerwy lub dłoższe świecenie.

Statystyki: Napisane przez oowan — 28 gru 2018, o 20:37

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-28T17:35:02+01:00

witam,

oowan napisał(a):

, tylko że odliczana sekunda ma tak na oko 1,6s. Co może być przyczyną?

jeżeli przedstawisz ciało funkcji 'timer_init();', to może coś da się wywnioskować/wyliczyć.
Przejrzałem wątek i nie zauważyłem jak jest ustawiony timer.

Statystyki: Napisane przez Daro69 — 28 gru 2018, o 17:35

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-28T13:34:33+01:00

Program powoli się rozrasta - dołożyłem wyłącznik czasowy do sterowania lampą przed garażem.
Jest to kolejny timer programowy (tym razem uint16_t) odliczany co sekundę w przerwaniu.
[syntax=c]// PROCEDURA OBSŁUGI PRZERWANIA COMPARE MATCH - timer programowy
ISR(TIMER0_COMPA_vect) {
static uint16_t cnt; // statyczna zmienna cnt do odliczania milisekund
if (++cnt > 999) { // zmienna cnt jest zwiększana od 0 - 999

if (timer_ind) timer_ind--;//timer czasu nieczułości czujnika zwalniania prędkości
//zmniejsza się co sekundę
if(timer_lampy) timer_lampy--;//timer_lampy odlicza czas włączenia lampy
cnt = 0;
}

if (timer) timer--; // zmienna timera do określenia predkosc_rampy dla PWM ok.1,5sek.

if (timer_keyO) timer_keyO--;//odliczanie 10ms na pominięcie ewentualnych zakłóceń
if (timer_keyZ) timer_keyZ--;
if (timer_keyKRO) timer_keyKRO--;
if (timer_keyKRZ) timer_keyKRZ--;
if (timer_keyIND) timer_keyIND--;
if (timer_keySTOP) timer_keySTOP--;
if (timer_keyLAMP) timer_keyLAMP--;

if (!(cnt % 250) && flaga.mig) LED_MIG; // przełącz diodę co 250ms

}[/syntax]
Wszystko działa prawidłowo, tylko że odliczana sekunda ma tak na oko 1,6s. Co może być przyczyną?

Statystyki: Napisane przez oowan — 28 gru 2018, o 13:34

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-24T13:43:47+01:00

W efekcie wyszły dwie funkcje:
[syntax=c]//deklaracja funkcji obsługi przycisków z filtracją zakłóceń
void press(uint8_t KEY_x, uint8_t stan_x, uint8_t timer_key_x);
uint8_t pressKR(uint8_t KEY_x, uint8_t timer_key_x);
.
.
int main(void) {
.
.
while (1) {

press(KEY_STOP, stop, timer_keySTOP);//wejście przycisku STOP

if(stan == zamykanie) { //zadziałanie fotokomórki tylko podczas zamykania
press(KEY_STOP, stop, timer_keySTOP);
}

press(KEY_PINO, otwieranie, timer_keyO); //wywołanie funkcji / wejście przycisku OTWÓRZ

press(KEY_PINZ, zamykanie, timer_keyZ);//wejście przycisku ZAMKNIJ

flaga.krancowka_O = pressKR(KEY_KRO, timer_keyKRO);//wejście krańcówki otwarcia

flaga.krancowka_Z = pressKR(KEY_KRZ, timer_keyKRZ);//wejście krańcówki zamknięcia

flaga.wolniej = pressKR(KEY_INDO, timer_keyIND);//wejście czujnika indukcyjnrgo, zwalniającego

switch (stan) {
.
.
}
}
}

//FUNKCJA OBSŁUGI PRZYCISKU Z FILTRACJĄ ZAKŁÓCEŃ
void press(uint8_t KEY_x, uint8_t stan_x, uint8_t timer_key_x){
if (!(PINB & KEY_x)){//nasiśnięcie przycisku, jeśli będzie to szpilka zakłócająca, to po jej
//zaniku warunek nie będzie spełniony i przejdzie do else
if(!timer_key_x) stan = stan_x;//gdy timer_key odliczy w przerwaniu do zera, to silnik się włączy
}
else timer_key_x = 10;//licznik będzie permanentnie ustawiany na 10 - opóźnienie 10ms
}

//FUNKCJA OBSŁUGI KRAŃCÓWKI Z FILTRACJĄ ZAKŁÓCEŃ
uint8_t pressKR(uint8_t KEY_x, uint8_t timer_key_x){
if (!(PINB & KEY_x)){
if(!timer_key_x) flaga.x = 1;
}
else {
flaga.x = 0;
timer_key_x = 10;
}
return flaga.x;
}

// PROCEDURA OBSŁUGI PRZERWANIA COMPARE MATCH - timer programowy
.
.[/syntax]
Nie wiem, czy znowu nie przekombinowałem, ale działa, przynajmniej to, co mam fizycznie podłączone do testów.

Życzę wszystkim WESOŁYCH ŚWIĄT!!!

Statystyki: Napisane przez oowan — 24 gru 2018, o 13:43

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-21T23:33:37+01:00

oowan napisał(a):

Wynika mi z tego, że każdy przycisk musi mieć osobny timer programowy dekrementowany w przerwaniu, bo chyba nie da się tego obsłużyć jednym timerem?

Jeśli będzie to robione sposobem, który podałem to TAK, ale zawsze można inaczej to zrobić i o ile przyciski nie są wciskane równocześnie to można by z jednego timera korzystać.

Statystyki: Napisane przez SylwekK — 21 gru 2018, o 23:33

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-20T13:49:04+01:00

SylwekK napisał(a):

Może najpierw trochę porządków, bo są pewne nieścisłości.

Taaak, nie wiem jak ten PIND się tam znalazł? Po zmianie na PINB jest OK! Dzięki!
Teraz należy taką sekwencję wstawić w badanie kolejnych wejść. Myślę, że byłoby bardziej przejrzyście i elegancko, gdyby to ująć w funkcję. Muszę zajrzeć do BB, bo funkcja będzie mieć kilka argumentów

dziobak7 napisał(a):

Cztery poziomy zagnieżdżenia.

Ja naprawdę jestem początkujący, zasugeruj coś może w celu uproszczenia kodu, tworzonego w pocie czoła - tworzę jak potrafię. Jak widać nie ma się czym chwalić

Po przemyśleniach, wykrystalizowała się taka funkcja
[syntax=c]void push(uint8_t KEY_x, uint8_t stan_x, uint8_t timer_key_x); //deklaracja funkcji obsługi przycisku z filtracją zakłóceń
.
.
push(KEY_PINO, otwieranie, timer_keyO); //wywołanie funkcji w pętli głównej
.
.
//FUNKCJA OBSŁUGI PRZYCISKU Z FILTRACJĄ ZAKŁÓCEŃ
void push(uint8_t KEY_x, uint8_t stan_x, uint8_t timer_key_x){
if (!(PINB & KEY_x)){//nasiśnięcie przycisku, jeśli będzie to szpilka zakłócająca, to po jej
//zaniku warunek nie będzie spełniony i przejdzie do else
if(!timer_key_x) stan = stan_x;//gdy timer_key odliczy w przerwaniu do zera, to silnik się włączy
}
else timer_key_x = 10;//licznik będzie permanentnie ustawiany na 10
}[/syntax]
Wynika mi z tego, że każdy przycisk musi mieć osobny timer programowy dekrementowany w przerwaniu, bo chyba nie da się tego obsłużyć jednym timerem?

Statystyki: Napisane przez oowan — 20 gru 2018, o 13:49

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-20T11:51:26+01:00

Taaaak...
Może najpierw trochę porządków, bo są pewne nieścisłości. Proszę wyjaśnij to i wskaż jakiś wspólny mianownik:

[syntax=c]#define KEY_PINO (1<.
.
PORTB |= KEY_PINO | KEY_PINZ | KEY_KRO; //podciągnięcie wejść do Vcc
.
.
if (!(PIND & KEY_PINO)){ //nasiśnięcie przycisku, jeśli będzie to szpilka zakłócająca, to po jej[/syntax]

Statystyki: Napisane przez SylwekK — 20 gru 2018, o 11:51

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-20T10:09:23+01:00

SylwekK napisał(a):

Wrzuć całość, bo takie sprawdzanie programu w kawałkach do niczego dobrego nie doprowadzi

[syntax=c]#include
#include
#include

#include "pwm.h" // dołączenie pliku nagłówkowego z obsługą PWM
#include "timer.h" // dołączenie pliku nagłówkowego z obsługą timera tykającego co 1ms

#define PWM_WY (1<#define PKO_WY (1<#define PKZ_WY (1<#define LED_WY (1<
#define KEY_PINO (1<#define KEY_PINZ (1<#define KEY_KRO (1<#define KEY_KRZ (1<#define KEY_INDO (1<#define KEY_INDZ (1<#define FOTO (1<#define KEY_STOP (1<
#define PKO_OFF PORTD &= ~PKO_WY // makrodefinicja - załączenie przekaźnika OTWARCIA
#define PKO_ON PORTD |= PKO_WY // makrodefinicja - wyłączenie przekaźnika OTWARCIA
#define PKZ_OFF PORTD &= ~PKZ_WY // makrodefinicja - załączenie przekaźnika ZAMKNIĘCIA
#define PKZ_ON PORTD |= PKZ_WY // makrodefinicja - wyłączenie przekaźnika ZAMKNIĘCIA
#define LED_MIG PORTD ^= LED_WY // miganie LED - kontrolka
#define LED_ON PORTD |= LED_WY // załącz LED - kontrolka
#define LED_OFF PORTD &= ~LED_WY // wyłącz LED - kontrolka

//określenia "maszyny stanów"
enum maszyna_st {
stop, otwieranie, zamykanie,
};

enum maszyna_st stan;

volatile uint8_t timer_key;//timer programowy do opóźniania reakcji klawiszy/przycisków

uint8_t predkosc_rampy = 6; //prędkość rampy PWM do przyspieszania/zwolniania silnika
uint8_t predkosc_silnika; //deklaracja zmiennej licznika dla PWM

struct {
volatile uint8_t mig:1; //flaga dla migania LED
uint8_t pauza:1; //flaga 0=wyłączony timer nieczułości, 1=włączony timer nieczułości
uint8_t rampa_kierunek:1; //flaga 0=postój, 1=praca silnika
uint8_t krancowka_O:1;//flaga krańcówki całkowitego otwarcia
uint8_t krancowka_Z:1;//flaga krańcówki całkowitego zamknięcia
uint8_t wolniej:1;//flaga czujnika zwolnienia silnika
} flaga;

int main(void) {

timer_init(); // inicjalizacja timera tykającego co 1ms
pwm_init(); // inicjalizacja PWM

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

DDRD |= PKO_WY | PKZ_WY; //ustawienie pinów portu D jako wyjścia
DDRD |= PWM_WY | LED_WY;
PORTB |= KEY_PINO | KEY_PINZ | KEY_KRO; //podciągnięcie wejść do Vcc
PORTB |= KEY_INDO | KEY_INDZ | KEY_KRZ;
PORTD |= FOTO | KEY_STOP;

_delay_ms(10); // oczekiwanie na ustalenie się stanu wysokiego na wejściach

while (1) {

if (!(PIND & KEY_STOP))
stan = stop;
/*if (!(PINB & KEY_PINO))
stan = otwieranie;*/

//PROCEDURA FILTRACJI ZAKŁÓCEŃ
if (!(PIND & KEY_PINO)){//nasiśnięcie przycisku, jeśli będzie to szpilka zakłócająca, to po jej
//zaniku warunek nie będzie spełniony i przejdzie do else
if(!timer_key) stan = otwieranie;//gdy timer_key odliczy w przerwaniu do zera, to silnik się włączy
}
else timer_key = 10;//licznik będzie permanentnie ustawiany na 10

if (!(PINB & KEY_PINZ))
stan = zamykanie;
if (!(PIND & FOTO) && (stan == zamykanie)) //zadziałanie fotokomórki tylko podczas zamykania
stan = stop; //wejście na porcie D
if (!(PINB & KEY_KRO))
flaga.krancowka_O = 1;
else
flaga.krancowka_O = 0;
if (!(PINB & KEY_KRZ))
flaga.krancowka_Z = 1;
else
flaga.krancowka_Z = 0;
if (!(PINB & KEY_INDO))
flaga.wolniej = 1;
else
flaga.wolniej = 0;

switch (stan) {
case stop: //stan = 0
predkosc_silnika = 0;
OCR0B = 0;
flaga.rampa_kierunek = 0;
flaga.pauza = 0;
PKO_OFF;
PKZ_OFF;
break;

case otwieranie: //stan = 1
PKO_ON;//kierunek silnika otwieranie
if (!timer_ind && !flaga.pauza) {
timer_ind = 3;//timer czasu nieczułości czujnika zwalniania w sekundach
flaga.pauza = 1;
}
if (flaga.krancowka_O) {
stan = stop;//wyłącz po osiągnięciu krańcówki otwarcia
LED_ON;
}
break;

case zamykanie: //stan = 2
PKZ_ON;//kierunek silnika zamykanie
if (!timer_ind && !flaga.pauza) {
timer_ind = 3;//timer czasu nieczułości czujnika zwalniania w sekundach
flaga.pauza = 1;
}
if (flaga.krancowka_Z) {
stan = stop; //wyłącz po osiągnięciu krańcówki zamknięcia
LED_OFF;
}
break;
}

if (!timer && stan) //połączony warunek - wykonuj tylko jeśli jakiś ruch ma być
{
timer = predkosc_rampy;
OCR0B = predkosc_silnika;

if (flaga.wolniej && !timer_ind) //zmienna timer_ind blokuje czujnik zwalniania prędkości
flaga.rampa_kierunek = 1; //po tym czasie czeka na dojechanie do drugiego czujnika zwalniania prędkości

if (!flaga.rampa_kierunek) {
if (predkosc_silnika < 255)
predkosc_silnika++; //przyspieszanie
} else {
if (predkosc_silnika > 10)
predkosc_silnika--; //zwalnianie - 50 to minimalna prędkość dojazdowa przy jakiej silnik jeszcze kręci
}
}

// Warunek zezwalający na miganie diody podczas pracy silnika
if (stan) {
flaga.mig = 1;
} else
flaga.mig = 0;

}
}

// PROCEDURA OBSŁUGI PRZERWANIA COMPARE MATCH - timer programowy
ISR(TIMER0_COMPA_vect) {

if (++cnt > 999) { // zmienna cnt jest zwiększana od 0 - 999
sekundy++;
if(sekundy>59) sekundy=0;
if (timer_ind) timer_ind--; //timer czasu nieczułości czujnika zwalniania prędkości
//zmniejsza się co sekundę
cnt = 0;
}

if (timer) timer--; // zmienna timera do określenia predkosc_rampy dla PWM ok.1,5sek.

if (timer_key) timer_key--;//odliczanie 10ms na pominięcie ewentualnych zakłóceń

if (!(cnt % 250) && flaga.mig) LED_MIG; // przełącz diodę co 250ms

}[/syntax]
Spróbowałem przy inicjalizacji ustawić timer_key na wartość 10, ale nic to nie dało.

Statystyki: Napisane przez oowan — 20 gru 2018, o 10:09

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-19T18:38:16+01:00

Wrzuć całość, bo takie sprawdzanie programu w kawałkach do niczego dobrego nie doprowadzi

Statystyki: Napisane przez SylwekK — 19 gru 2018, o 18:38

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-19T11:29:46+01:00

No, dobra SylwkK. W teorii jest ok, ale w praktyce niepowodzenie. Program po włączeniu zasilania ustawia zmienną stan = otwieranie z pominięciem softstartu (PWM = 255). Po czasie nieczułości działa spowolnienie, jednak krańcówką KEY_KRO nie można wyłączyć silnika. Kontrolka ciągle miga, czyli zmienna stan ciągle jest różna od zera.

Statystyki: Napisane przez oowan — 19 gru 2018, o 11:29

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-19T11:29:46+01:00

Statystyki: Napisane przez oowan — 19 gru 2018, o 11:29

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-17T11:30:51+01:00

Można to oczywiście zrobić na kilka innych sposobów, ale ten jest o tyle fajny, że ZAWSZE musi się sygnał utrzymać przez zadany czas zanim zostanie zatwierdzony. Jakakolwiek przerwa czy zakłócenie powoduje, że licznik od nowa mierzy ten czas.

Statystyki: Napisane przez SylwekK — 17 gru 2018, o 11:30

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-17T10:08:09+01:00

SylwekK napisał(a):

A co jest po "else" ? Permanentnie ustawienie licznika jeśli klawisz nie jest wyciśnięty, a po jego wciśnięciu jest normalnie w przerwaniach odliczany aż dojdzie do zera

Aaa... no jakie to proste
Pomroczność jasna mnie ostatnio nachodzi

Statystyki: Napisane przez oowan — 17 gru 2018, o 10:08

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-16T12:32:25+01:00

A co jest po "else" ? Permanentnie ustawienie licznika jeśli klawisz nie jest wyciśnięty, a po jego wciśnięciu jest normalnie w przerwaniach odliczany aż dojdzie do zera

Statystyki: Napisane przez SylwekK — 16 gru 2018, o 12:32

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-16T12:24:56+01:00

SylwekK napisał(a):

Zamiast tego co tak rozbudowałeś po prostu tak:
[syntax=c]//DEKLARACJE
volatile uint8_t timer_key; //timer programowy do opóźniania reakcji klawiszy/przycisków

//PROCEDURA FILTRACJI ZAKŁÓCEŃ
if (!(PIND & KEY_PINO))
{
if(!timer_key) stan = otwieranie;
}
else timer_key=10;[/syntax]

Znowu musisz mnie chyba oświecić, bo wg mnie po naciśnięciu przycisku lub przy impulsie zakłócającym, zmienna stan od razu przyjmie wartość otwieranie gdyż warunek jest spełniony (timer_key == 0). Dopiero po puszczeniu przycisku, ewentualnie zaniku impulsu, timer_key zacznie odliczanie, króre nie ma już praktycznie znaczenia. Tak to widzę.
Ja chcę pojenczy, przypadkowy impuls przeczekać i wywołać reakcję po ponownym sprawdzeniu stanu wejścia KEY_PINO. Taki przykład był w BB, ale z użyciem delayów.
Ogólnie sposoby na drgające styki bez delayów, jakie znalazłem, reagują na pierwszy impuls i ignorują następne i to jest skuteczne, ale wg mnie nie nadaje się do programowego filtrowania zakłóceń.

Statystyki: Napisane przez oowan — 16 gru 2018, o 12:24

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-13T14:25:41+01:00

SylwekK napisał(a):

Z analizą nie powinieneś mieć problemu.

No, to mam nad czym myśleć w weekend
Dzięki za sugestie.

Statystyki: Napisane przez oowan — 13 gru 2018, o 14:25

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-13T13:49:03+01:00

Znowu zupełnie inne spojrzenie na program kiedy przechodzę ze smartfona na kompa
Zamiast tego co tak rozbudowałeś po prostu tak:

[syntax=c]//DEKLARACJE
volatile uint8_t timer_key; //timer programowy do opóźniania reakcji klawiszy/przycisków

//PROCEDURA FILTRACJI ZAKŁÓCEŃ
if (!(PIND & KEY_PINO))
{
if(!timer_key) stan = otwieranie;
}
else timer_key=10;[/syntax]

Nawet flaga nie potrzebna Z analizą nie powinieneś mieć problemu.

Statystyki: Napisane przez SylwekK — 13 gru 2018, o 13:49

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-13T12:01:58+01:00

Dużo prościej i efektywniej będzie jak zamiast flagi zrobisz licznik jaki stosuje w swojej obsłudze klawisza krótki/długi. Na forum o tym pisałem w moim temacie. I tak bajt jest zużyty więc nie ma problemu Zapewniam, że sposób niezawodny.

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

To twoje rozwiązanie też by dało radę, ale potrzeba przeróbki i "else" przy głównym badaniu klawisza

Statystyki: Napisane przez SylwekK — 13 gru 2018, o 12:01

Re: Problem z wymuszonym opuszczeniem pętli for

2018-12-13T11:38:22+01:00

oowan napisał(a):

Kolejny mój . Generalnie układ ma taki charakter, że nie potrzeba gasić drgań styków, ale niestety wejścia łapią zakłócenia, bo przewody do krańcówek mają po kilka metrów.

Przeanalizowałem problem zakłóceń na wejściach i doszedłem do wniosku, że szpilki zakłócające są raczej pojedyncze i trzeba je przeczekać. 10ms chyba wystarczy, może mniej. Wszyscy wiedzą, che, che, najprościej dać delaya
Ale na poważnie, zrobiłem kolejny timer programowy, tylko nie wychodzi mi teraz procedura obsługi przycisku. coś jest ewidentnie źle, nie ma reakcji na przycisk.
Było tak:
[syntax=c]if (!(PINB & KEY_PINO))
stan = otwieranie;[/syntax]
Teraz jest tak:
[syntax=c]//DEKLARACJE
volatile uint8_t timer_key;//timer programowy do opóźniania reakcji klawiszy/przycisków
uint8_t y;//flaga pomocnicza do obsługi klawiszy/przycisków

//PROCEDURA FILTRACJI ZAKŁÓCEŃ
if (!(PIND & KEY_PINO)){//nasiśnięcie przycisku, jeśli będzie to szpilka zakłócająca, to po jej
//zaniku warunek nie będzie spełniony
if(!timer_key && !y) {
y = 1;//ustawienie flagi pomocniczej
timer_key=10;//uruchomienie timera, żeby odczekać 10ms
}
if(!timer_key && y) {//jeżeli przycisk będzie dalej nasiśnięty, a timer_key doliczy do zera,
stan = otwieranie;//to silnik się włączy
y = 0; //zerowanie flagi pomocniczej
}
}[/syntax]
i w przerwaniu:
[syntax=c]if (timer_key) timer_key--;//odliczanie 10ms na pominięcie ewentualnych zakłóceń[/syntax]
I tak sobie myślę, że ze względu na te zakłócenia, w finalnym układzie lepiej będzie podciągać wejścia rezystorami 5k do 10k. Powinno być bardziej stabilnie.

Statystyki: Napisane przez oowan — 13 gru 2018, o 11:38