ATNEL tech-forum

Re: Jak ustawić funkcję budzika

2019-06-25T10:07:27+01:00

Witam.
Też jestem w trakcie uczenia się, ale może takie rozwiązanie tobie spasuje (wycinek z mojego sterownika stworzonego na postawie BB)
[syntax=c]//zdefiniuj
#define il_pk 8
char t_pk[il_pk][4];
char PK[8]={PA0,PA1,PA2,PA3,PA4,PA5,PA6,PA7};

void czas(TDATETIME * dt ){
DS3231_get_datetime( &datetime );
sec = (dt->ss);
godz = (dt->hh);
min = (dt->mm);
rok = (dt->year);
miesc = (dt->month);
dzien = (dt->day);
dtydz = (dt->dayofwek);
}
// i sprawdzaj
czas(&datetime);
for(int i = 0;i{
if((((t_pk[i][0]*60)+t_pk[i][1])<=((godz*60)+min))&&(((t_pk[i][2]*60)+t_pk[i][3])>=((godz*60)+min)))
{PORTA &= ~(1<
if(((t_pk[i][2]*60)+t_pk[i][3])<=((godz*60)+min)){PORTA |= (1<
}[/syntax]

Oczywiści musisz trochę zmodyfikować pod swoje potrzeby, ale chodzi o samą ideę, pozostanie tylko zapis i odczyt z EEPROM, bo ja korzystałem z zewnętrznej pamięci 24c32.

Statystyki: Napisane przez Bigrazor — 25 cze 2019, o 10:07

Re: Jak ustawić funkcję budzika

2019-06-17T08:54:05+01:00

OK pisałem że się nie znam

Statystyki: Napisane przez miki53 — 17 cze 2019, o 08:54

Re: Jak ustawić funkcję budzika

2019-06-16T21:46:49+01:00

miki53 napisał(a):

Jeszcze raz się przyglądam twojej funkcji i coś mi nie gra chodzi mi o wskażnik al->
wskazuje on na czas ustalany przez RTC oraz na czas który my ustawiamy jako czas
alarmu potem ten sam wskażnik wskazuje na godziny alarmu ( ahh ), minuty ( amm )
oraz sekundy ( ass )

Nie za dużo iak na jeden wskażnik ?

Bez obawy nie jest za dużo wskaźnik al-> wskazuje na zmienne w strukturze i nie robi się "kogel mogel"

popatrz, na początku wpisuje do zmiennych ahh, amm, ass wartości czasu alarmu, żeby później można było policzyć czas alarmu - użyłem wskaźnika bo zmienne są w strukturze. Później wpisuję do zmiennej czas (także ona jest w strukturze), wartość aktualnego czasu odczytanego z RTC przez wskaźnik dt-> ponieważ te są w innej strukturze, a ponieważ mam utworzony TYP strukturalny to zmienne alarm1, alarm2, alarm3 tworzą osobne struktury i nic się nie pomiesza W końcu wszystko działa według założenia.

miki53 napisał(a):

Mirek moał osobny wskażnik ( tak dla przykładu )

dla godziny i inny dla daty
tak aby to się nie pomieszało wszystko w jednym

Popatrz np. na funkcję Pana Mirka get_rtc_datetime, on tam dużo używa wskaźnika dt->, a zmiennych w strukturze TDATETIME jest dużo więcej niż w mojej strukturze TALARM. Chyba, że o inny wskaźnik Ci chodzi? Bo Pan Mirek dla daty i czasu używa wskaźnika dt->.

Statystyki: Napisane przez Tom92 — 16 cze 2019, o 21:46

Re: Jak ustawić funkcję budzika

2019-06-16T17:19:38+01:00

W mojej funkcji są porty ustawione na stałe ale
podczas ustawień dla danego wyjścia można je przełączać

np. można zmieniać wyjście dla każdej nastawy niezależnie

zobacz

// USTAWIANIE włącz - hh - mm - ss - nr portu / wyłącz - hh - mm - ss - nr portu
// ----------------------------------------------------------------
// set_rtc_alarm( &datetime, 15, 32, 0, 2, 15, 33, 0, 2 );
// ****************************************************************

w miejscu gdzie ustawiasz - port - możesz wstawiać dowolny port zamiast 2- dla PD5 wpisz
1 i masz już ustawiony port PD6
możesz nawet mieszać, włączasz port PD5 a wyłączasz wcześniej ustawiony port PD6
i wszystkie są ustawiane pełnym czasem ( godziny, minuty, sekundy )

Jeszcze raz się przyglądam twojej funkcji i coś mi nie gra chodzi mi o wskażnik

------------------------ [ Dodano po: 41 minutach ]

Jeszcze raz się przyglądam twojej funkcji i coś mi nie gra chodzi mi o wskażnik al->
wskazuje on na czas ustalany przez RTC oraz na czas który my ustawiamy jako czas
alarmu potem ten sam wskażnik wskazuje na godziny alarmu ( ahh ), minuty ( amm )
oraz sekundy ( ass )

Nie za dużo iak na jeden wskażnik ?

Ja staram się podglądać jak to robi Mirek

Mirek moał osobny wskażnik ( tak dla przykładu )

dla godziny i inny dla daty
tak aby to się nie pomieszało wszystko w jednym

A Ty masz jeden wskażnik prawie do wszystkiego
Ja tam się nie znam ale na chłopski rozum to w tym wskażniku musi być kogel mogel

[syntax=c]al->ahh = godzina;
al->amm = minuta;
al->ass = sekunda;

// obliczanie czasu i alarmu w konkretnym alarmie(1,2,3)
al->czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
al->alarm = ( al->ahh * 3600 ) + ( al->amm * 60 ) + ( al->ass );

// włączenie wyjścia
if( al->czas >= al->alarm && al->czas <= al->alarm+dlugosc ) {[/syntax]

Statystyki: Napisane przez miki53 — 16 cze 2019, o 17:19

Re: Jak ustawić funkcję budzika

2019-06-16T14:38:50+01:00

Moja funkcja może wydawać się skomplikowana dlatego, że chciałem, aby byla uniwersalna. Ale dzięki temu można sterować dowolnym pinem na dowolnym porcie niezależnie. W pliku main.c tam są źle opisane wywołania bo zrobiłem copy and paste, ale myślę że można się domyślić z argumentów, ktore piny są sterowane.

Co do Twojej funkcji to jak działa to jest dobrze, ale za każdym razem jak bedziesz chcial zmienic port i pin to musisz ingerować w funkcję. Ja napisalem tak żeby tego uniknąć.

A co do ilości zmiennych żeby ustawić 8 alarmów to nic mi nie przychodzi do głowy czy dało by sie uprościć. Musialby się ktoś wypowiedzieć z doświadczeniem

Statystyki: Napisane przez Tom92 — 16 cze 2019, o 14:38

Re: Jak ustawić funkcję budzika

2019-06-16T12:23:14+01:00

Teraz nasuwa się następny problem
jak wyprowadzić ustawienia czasów alarmów na zewnątrz
aby można było ustawiać czasy za pomocą przycisków

tylko że na jedną nastawę potrzebuję
dla włącz - hh - mm - ss - port / dla wyłącz - hh - mm - ss - port = 8 x 8 nastaw dla 8 portów
to wychodzi 64 zmienne trochę sporo

Czy dało by się prościej ?

Statystyki: Napisane przez miki53 — 16 cze 2019, o 12:23

Re: Jak ustawić funkcję budzika

2019-06-15T13:10:33+01:00

Dzięki Ci za pomoc

Tylko Ty zechciałeś pomóc i podjąć temat za to gorące dzięki.

Co do twojej funkcji to wydaje mi się że jest nieco skomplikowana
bo wskażnik goni wskażnik ale nie twierdzę że jest zła
ma działać i oto chodzi

ja nie umiem jeszcze programować więc piszę w prosty sposób
mam nadzieję że kiedyś się nauczę
moja funkcja w nowej formie wygląda tak
( działa całkiem fajnie )

plik main.c - ustawiam porty

[syntax=c]//******** DOTYCZY WYJSC STERUJĄCYCH ********************************************
DDRD |= (1< PORTD |= (1< DDRD |= (1< PORTD |= (1<// *******************************************************************************[/syntax]

plik main.c - ustawienia dla dwóch wyjść alarmu pracujących niezależnie

[syntax=c]while(1) {

UART_RX_STR_EVENT( uart_buf ); // wywoływanie funkcji UARTA

// do funkcji EVENT - ss - mm - hh - wpisujemy czas po jakim ma się zsynchronizowac zegar
//GetNtpTime_EVENT( &Timer2, 10, 0, 0, NULL );

// ** USTAWIANIE GODZINY ALARMU WŁĄCZ - WYŁĄCZ - PORT PD5 i PD6
// ** ustawiamy dla włączenia hh-mm-ss-port dla wyłączenia hh-mm-ss-port ****
// ----------------------------------------------------------------
set_rtc_alarm( &datetime, 15, 32, 0, 1, 15, 33, 0, 1 ); // ALARM NR-1 PORT - PD5
// ****************************************************************
// ----------------------------------------------------------------
set_rtc_alarm( &datetime, 15, 34, 0, 2, 15, 35, 0, 2 ); // ALARM NR-2 PORT - PD6
// ****************************************************************[/syntax]

plik mk_pcf8583.c - funkcja

[syntax=c]// **** FUNKCJA WŁĄCZAJĄCA PORT PC7 DLA ALARMU ********************************************
void set_rtc_alarm( TDATETIME * dt, uint8_t ahh, uint8_t amm, uint8_t ass, uint8_t port, uint8_t wahh, uint8_t wamm, uint8_t wass, uint8_t wyj ){
czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
alarm = ( ahh * 3600 ) + ( amm * 60 ) + ass;

if ( (czas == alarm) && ( port == 1)) {
PORTD &= ~(1< }
else
if ( (czas == alarm ) && ( port == 2)) {
PORTD &= ~(1< }

// **** FUNKCJA WYŁĄCZAJĄCA PORT PC7 DLA ALARMU ********************************************
czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
walarm = ( wahh * 3600 ) + ( wamm * 60 ) + wass;

if (( czas == walarm) && (wyj == 1 )) {
PORTD |= (1< }
else
if ((czas == walarm) && ( wyj == 2)) {
PORTD |= (1< }
}
// *****************************************************************************************[/syntax]

plik mk_pcf8583.h - zmienne globalne

[syntax=c]// *** MOJE ZMIENNE GLOBALNE DLA ALARMU *******************
uint16_t alarm;
uint16_t walarm;
uint16_t czas;
// ********************************************************[/syntax]

plik mk_pcf8583.h - nagłówek funkcji

[syntax=c]// *** MOJA FUNKCJA DLA ALARMU *****************************************************************************************
void set_rtc_alarm( TDATETIME * dt, uint8_t ahh, uint8_t amm, uint8_t ass, uint8_t port, uint8_t wahh, uint8_t wamm, uint8_t wass, uint8_t wyj );
// ************************************************************************************************[/syntax]

Napisz swoje zdanie na temat mojego nieudolnego pisania ( ale bez owijania w bawełnę )

Statystyki: Napisane przez miki53 — 15 cze 2019, o 13:10

Re: Jak ustawić funkcję budzika

2019-06-15T10:48:18+01:00

Dobra miki53, mam dla Ciebie funkcję - może Cie ucieszy ewentualnie dopiszesz sobie trzy argumenty do wpisania godziny wyłączenia alarmu bo ja wpisałem długość trwania alarmu.

Nawiązując do:

miki53 napisał(a):

A teraz chciałbym to rozwinąć do niezależnej możliwości włączania i wyłączania 8-mioma portami C
Czy macie jakieś pomysły ?, aby nie pisać jednej funkcji dla jednego wyjścia
Może by się dało jedną funkcją niezależnie wysterować 8 portów?

chodziło Ci o piny chyba? Więc spróbowałem swoich sił i wyszła mi funkcja, która jest poniżej. Działa, jeśli ktoś widzi jakieś błędy to proszę o poprawę

Zgodnie z tym co pisałem wyżej o utworzeniu struktury dla alarmów w pliku *.h mamy:
[syntax=c]/* struktura alarmu */
typedef struct {
uint8_t ahh;
uint8_t amm;
uint8_t ass;
uint16_t czas;
uint16_t alarm;
} TALARM;

extern TALARM alarm1, alarm2, alarm3;// wskaźnik do zmiennych tablicowych alarmów

void set_rtc_alarm( TDATETIME * dt, TALARM * al, uint8_t pin_mask, volatile uint8_t * port, uint8_t godzina, uint8_t minuta, uint8_t sekunda, uint16_t dlugosc );[/syntax]
W pliku *.c:
[syntax=c]TALARM alarm1, alarm2, alarm3; // wskaźnik do zmiennych tablicowych

/*
* Parametry wejściowe:
* * dt - wskaźnik na zmienną w strukturalną czasu
* * al - wskaźnik na zmienną strukturalną alarmu
* pin_mask - maska pinu wyjściowego np. PB3
* * port - nazwa PINx portu na którym jest pin wyjściowy np: PINB
* godzina - godzina włączenia alarmu
* minuta - minuta włączenia alarmu
* sekunda - sekunda włączenia alarmu
* dlugosc - czas trwania alarmu w sekundach
*/
void set_rtc_alarm( TDATETIME * dt, TALARM * al, uint8_t pin_mask, volatile uint8_t * port, uint8_t godzina, uint8_t minuta, uint8_t sekunda, uint16_t dlugosc ) {

// wpisanie czasu do konkretnego alarmu(1,2,3)
al->ahh = godzina;
al->amm = minuta;
al->ass = sekunda;

// obliczanie czasu i alarmu w konkretnym alarmie(1,2,3)
al->czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
al->alarm = ( al->ahh * 3600 ) + ( al->amm * 60 ) + ( al->ass );

// włączenie wyjścia
if( al->czas >= al->alarm && al->czas <= al->alarm+dlugosc ) {

*port &= ~(1<
// wyłączenie wyjścia
} else {

*port |= (1<
}
}[/syntax]
W main.c:
[syntax=c]// przed while(1) trzeba zainicjować wyjścia
DDRB |= (1<PORTB |= (1<
DDRC |= (1<PORTC |= (1<

while(1) {

RTC_EVENT();// zdarzenie z RTC

set_rtc_alarm( &datetime, &alarm1, PC7, &PORTC, 3, 0, 0, 10 ); // o 3:00:00 włącz diodę na PC7, wyłącz po 10s
set_rtc_alarm( &datetime, &alarm2, PC5, &PORTC, 3, 0, 10, 10 ); // o 3:00:10 włącz diodę na PC7, wyłącz po 10s
set_rtc_alarm( &datetime, &alarm3, PB4, &PORTB, 3, 0, 20, 10 ); // o 3:00:20 włącz diodę na PC7, wyłącz po 10s

}[/syntax]
Przeanalizuj i daj znać

Statystyki: Napisane przez Tom92 — 15 cze 2019, o 10:48

Re: Jak ustawić funkcję budzika

2019-06-14T14:13:19+01:00

Coś w tym rodzaju
z tym że ja rozbudowałem nieco funkcję o element wyłączania

zaraz pokażę jak ta funkcja teraz wygląda

plik mk_pcf8583.c
[syntax=c]// **** FUNKCJA WŁĄCZAJĄCA PORT PC7 DLA ALARMU ********************************************
void set_rtc_alarm( TDATETIME * dt, uint8_t ahh, uint8_t amm, uint8_t ass, uint8_t wahh, uint8_t wamm, uint8_t wass ){
czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
alarm = ( ahh * 3600 ) + ( amm * 60 ) + ass;

if ( czas == alarm ){
alert = 1;
}

if ( alert == 1){
// PORTC ^= (1< PORTC &= ~(1< }
// **** FUNKCJA WYŁĄCZAJĄCA PORT PC7 DLA ALARMU ********************************************
czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
walarm = ( wahh * 3600 ) + ( wamm * 60 ) + wass;

if ( czas == walarm ){
PORTC |= (1< alert = 0;
}
}
// *****************************************************************************************[/syntax]

A tak się zmieniło w pliku main.c
[syntax=c]while(1) {

UART_RX_STR_EVENT( uart_buf ); // wywoływanie funkcji UARTA

// do funkcji EVENT - ss - mm - hh - wpisujemy czas po jakim ma się zsynchronizowac zegar
//GetNtpTime_EVENT( &Timer2, 10, 0, 0, NULL );

// ** USTAWIANIE GODZINY ALARMU WŁĄCZ - WYŁĄCZ - PORT PC7
// ** ustawiamy dla włączenia hh-mm-ss dla wyłączenia hh-mm-ss ****
// ----------------------------------------------------------------
// set_rtc_alarm( &datetime, 15, 32, 0, 15, 33, 0 );
// ****************************************************************

RTC_EVENT();[/syntax]

Teraz myślę aby wykorzystać komendy #define
w ten sposób aby przypisać portom numery rozpoznawcze

aby to wyglądało w taki sposób

DDRC |= (1<#define A1 PORTC &= ~LED_PIN // załączanie diody
#define A2 PORTC |= LED_PIN // wyłączanie diody

DDRC |= (1<#define A3 PORTC &= ~LED_PIN // załączanie diody
#define A4 PORTC |= LED_PIN // wyłączanie diody

// USTAWIANIE włącz - hh - mm - ss - nr portu / wyłącz - hh - mm - ss - nr portu
// ----------------------------------------------------------------
// set_rtc_alarm( &datetime, 15, 32, 0, 1, 15, 33, 0, 2 );
// ****************************************************************

( nie piszę tego fragmentu w SYNTEX C bo to tylko dla celów pokazowych a nie kod )

Ale nie wiem na razie jak do tego doprowadzić
aby to zadziałało w taki sposób?

Statystyki: Napisane przez miki53 — 14 cze 2019, o 14:13

Re: Jak ustawić funkcję budzika

2019-06-13T16:45:58+01:00

Mam pewną koncepcje. Utworzyć typ strukturalny dla alarmów i wtedy funkcję mozna by wywolywać w ten sposób:

[syntax=c]set_rtc_alarm( &datetime, &alarm1, PORTC, PC5, 8, 30, 45, 10);
set_rtc_alarm( &datetime, &alarm2, PORTD, PD3, 7, 20, 55, 15);[/syntax]

Gdzie po kolei przekazywałbyś wskaźnik na strukturę czasu, wskaźnik na strukturę alarmów, port, pin, godzinę alarmu, minutę alarmu, sekundę alarmu, długość trwania alarmu w sekundach.

Czy chodziłoby Ci o coś takiego?

Statystyki: Napisane przez Tom92 — 13 cze 2019, o 16:45

Re: Jak ustawić funkcję budzika

2019-06-13T10:18:22+01:00

Panie i Panowie mamy uzupełnioną bibliotekę PCF8583 o funkcję budzika

wstawiłem ustawianie godziny alarmu w to miejsce w pliku main.c
[syntax=c]while(1) {

UART_RX_STR_EVENT( uart_buf ); // wywoływanie funkcji UARTA

// do funkcji EVENT - ss - mm - hh - wpisujemy czas po jakim ma się zsynchronizowac zegar
//GetNtpTime_EVENT( &Timer2, 10, 0, 0, NULL );

// ******* USTAWIANIE GODZINY ALARMU ***********************
// set_rtc_alarm( &datetime, 17, 17, 0 );
// *********************************************************

RTC_EVENT();[/syntax]

i faktycznie działa

A teraz chciałbym to rozwinąć do niezależnej możliwości włączania i wyłączania 8-mioma portami C
Czy macie jakieś pomysły ?, aby nie pisać jednej funkcji dla jednego wyjścia
Może by się dało jedną funkcją niezależnie wysterować 8 portów?

To znaczy
że ustawiamy tylko 8 takich kodów ( jak niżej ) dla poszczególnych nastaw
[syntax=c]// ******* USTAWIANIE GODZINY ALARMU ***********************
// set_rtc_alarm( &datetime, 17, 17, 0 );
// *********************************************************[/syntax]
Ale jak wybrać port jakiego ma dotyczyć ?

Gdyby się udało rozwinąć ten temat to mielibyśmy sterownik imitujący obecność domowników
gdy nas niema w domu , lub fajny sterownik

Statystyki: Napisane przez miki53 — 13 cze 2019, o 10:18

Re: Jak ustawić funkcję budzika

2019-06-13T08:53:07+01:00

Cześć miki53,

Sprawdziłem teraz Twoją funkcję. Wszystko jest dobrze, jedynie musisz wrzucić wywołanie funkcji:
[syntax=c]set_rtc_alarm( &datetime, 15, 32, 00 );[/syntax]

do funkcji void RTC_EVENT( void ), żeby Twoja funkcja zaczęła pobierać aktualny czas.

Jak wywołasz funkcję przed pętlą to wartość zmiennej czas = 0.

Sprawdziłem, Twoją funkcję tak jak napisałem wyżej i działa. Po osiągnięciu ustawionego czasu dioda zmienia swój stan.

Statystyki: Napisane przez Tom92 — 13 cze 2019, o 08:53

Re: Jak ustawić funkcję budzika

2019-06-12T20:17:23+01:00

OK dzięki

Statystyki: Napisane przez miki53 — 12 cze 2019, o 20:17

Re: Jak ustawić funkcję budzika

2019-06-12T19:41:22+01:00

Postaram sie pomóc jutro rano bo będę u siebie to będę mógł przetestować kod narazie nic nie zauważyłem

Statystyki: Napisane przez Tom92 — 12 cze 2019, o 19:41

Re: Jak ustawić funkcję budzika

2019-06-12T19:22:21+01:00

Koledzy podpowiedzcie coś jeśli macie jakiś pomysł
Ja staram się pisać posty tak aby każdy mógł w jasny sposób
z nich z korzystać i zastosować w swoich projektach
ale nie jestem orłem w programowaniu jestem naprawdę na początku tej drogi

I wasze podpowiedzi przydadzą się nie tylko mi ale też będą z pożytkiem
dla innych

Statystyki: Napisane przez miki53 — 12 cze 2019, o 19:22

Re: Jak ustawić funkcję budzika

2019-06-12T12:10:58+01:00

Zapomniałem dodać jak ustawiam alarmu
plik main.c
[syntax=c]// **** USTAWIANIE GODZINY ALARMU ***************************
// set_rtc_alarm( &datetime, 15, 32, 00 );
// ***********************************************************[/syntax]

Statystyki: Napisane przez miki53 — 12 cze 2019, o 12:10

Re: Jak ustawić funkcję budzika

2019-06-11T14:49:05+01:00

Witam serdecznie

Po wielkich bojach udało mi się dzięki Mirka poradnikom Dawca czasu i RTC programowanie w C
zrobić zegar z wyświetlaczem LCD, chciałem wstawić funkcję budzika do biblioteki PCF8583
aby móc ją w pużniejszym czasie przerobić na sterownik z większą ilością wyjść sterowanych czasowo

wstawiłem funkcje budzika w kod i nawet niema błędów tylko że ne wiem jak z niej wyjść aby
włączyła mi diodę testową

Prosiłbym o pomocne podpowiedzi

plik mk_pcf8583.h
zmienne globalne
[syntax=c]// *** MOJE ZMIENNE GLOBALNE DLA ALARMU *******************
uint16_t alarm;
uint16_t czas;
uint8_t alert;
// ********************************************************[/syntax]
plik mk_pcf8583.h
deklaracja funkcji dla alarmu
[syntax=c]// *** MOJA FUNKCJA DLA ALARMU ***********************************************
void set_rtc_alarm( TDATETIME * dt, uint8_t ahh, uint8_t amm, uint8_t ass );
// ***************************************************************************[/syntax]
mk_pcf8583.c
definicja funkcji alarmu
[syntax=c]// **** MOJA FUNKCJA DLA ALARMU ********************************************
void set_rtc_alarm( TDATETIME * dt, uint8_t ahh, uint8_t amm, uint8_t ass ) {
czas = ( dt->hh * 3600 ) + ( dt->mm * 60 ) + ( dt->ss );
alarm = ( ahh * 3600 ) + ( amm * 60 ) + ass;

if ( czas == alarm ){
alert++;
}

if ( alert > 0){
PORTC ^= (1< }
}

// *************************************************************************[/syntax]

Testowa dioda PC7 nie chce mi się włączyć nawet
jeśli wpiszę warunek jej zapalania do funkcji main.c
po uprzednim za komentowaniu if w funkcji
to znaczy
[syntax=c]if ( alert > 0){
PORTC ^= (1< }[/syntax]

Czy koledzy mogliby mi podpowiedzieć co zrobić aby to zadziałało

Statystyki: Napisane przez miki53 — 11 cze 2019, o 14:49

Re: Jak ustawić funkcję budzika

2019-05-16T19:05:07+01:00

miki53 napisał(a):

Mirku mógłbyś spojrzeć na powyższy kod czy on ma prawo zadziałać

Ja nie jestem (przykro mi) analizować długich kodów - tylko i wyłącznie krótkie wyekstrachowane fragmenty kodów testowych ... nie mam po prostu aż tyle czasu

ale widzę, że kolega wyżej zrobił tą analizę i napisał tobie kilka uwag - proszę pochyl się nad nimi

------------------------ [ Dodano po: kilkunastu sekundach ]

Poza tym tak jak pisałem wyżej napisz krótki main.c ze sztucznym zegarkiem wg opisu jaki ci podałem i sam potestuj - no to nie powinno być trudne - a i kod do analizy na forum ci się skróci drastycznie

Statystyki: Napisane przez mirekk36 — 16 maja 2019, o 19:05

Re: Jak ustawić funkcję budzika

2019-05-16T17:13:58+01:00

Mirku mógłbyś spojrzeć na powyższy kod czy on ma prawo zadziałać
kod ten jest pisany w podobny sposób jak biblioteka dla PCF8583
jeśli w tym kodzie to zadziała to i w kodze biblioteki jeśli w ten sposób
wstawię to powinno zadziałać tak mi się wydaje

Nie chcę nadużywać cierpliwości ale starczy jak powiesz że będzie działać
lub nie

Statystyki: Napisane przez miki53 — 16 maja 2019, o 17:13

Re: Jak ustawić funkcję budzika

2019-05-16T17:02:29+01:00

Nie zadziała! Pomieszane zdrowo w kodzie . Pierwsze to definicje diody wyrzuć przed int main, a po drugie co Ci ma załaczyć diodę jak w petli main nie masz odpowiednich funkcji . Przeczytaj od początku ksiąke Mirka i zacznij od migania diodą i zrozumienia podstaw, bo tutaj przepisałeś kod i powstawiałeś przypadkowo.

Statystyki: Napisane przez Kaz K — 16 maja 2019, o 17:02

Re: Jak ustawić funkcję budzika

2019-05-16T16:40:40+01:00

miki53 napisał(a):

Przepraszam że zadaję tego typu pytanie ale nie posiadam jeszcze układu DS3231
na który jest napisany ten kod i nie mogę tego fizycznie sam sprawdzić

Jak można pisać, że nie da się tego sprawdzić bez DS3231 ??? no panie kochany, a co za problem sztucznie napędzać sobie czas w procku i sprawdzać alarm ? toż to tylko inkrementowanie godzin, minut i sekund - gdzieś w timerze programowym co sekundę i już masz sztuczny zegarek do sprawdzania

------------------------ [ Dodano po: kilkunastu sekundach ]

programowanie nie polega tylko na pisaniu gotowego kodu ale pisaniu fragmentów do testowania swojego kodu

Statystyki: Napisane przez mirekk36 — 16 maja 2019, o 16:40

Re: Jak ustawić funkcję budzika

2019-05-16T13:51:51+01:00

Jeśli wstawię procedury obsługi alarmu w sposób jak poniżej w kodzie to to mi
zadziała ?
Przepraszam że zadaję tego typu pytanie ale nie posiadam jeszcze układu DS3231
na który jest napisany ten kod i nie mogę tego fizycznie sam sprawdzić
proszę o wyrozumiałość

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

#include "LCD/lcd44780.h"
#include "I2C_TWI/i2c_twi.h"

typedef union {
uint8_t bytes[7];
struct {
uint8_t ss;
uint8_t mm;
uint8_t hh;
uint8_t dayofwek;
uint8_t day;
uint8_t month;
uint8_t year;
};
} TDATETIME;

typedef struct {
int8_t cel;
uint8_t fract;
} TTEMP;

#define DS3231_ADDR 0xD0

void DS3231_init( void );
uint8_t dec2bcd(uint8_t dec);
uint8_t bcd2dec(uint8_t bcd);
void DS3231_get_datetime( TDATETIME * dt );
void show_time( TDATETIME * dt );
void show_date( TDATETIME * dt );
void DS3231_set_time( uint8_t hh, uint8_t mm, uint8_t ss );
void DS3231_set_date( uint8_t year, uint8_t month, uint8_t day, uint8_t dayofweek );
void DS3231_get_temp( TTEMP * tmp );
void show_temperature( TTEMP * tmp );

TDATETIME datetime;
TTEMP temperature;

char days[7][4] = {
"pon", "wto", "sro", "czw", "pia", "sob", "nie"
};

// ******** ZMIENNE DLA ALARMU *****************************

uint16_t czas;
uint16_t alarm;

// ******** ZMIENNE DO WŁACZANIA ALARMU -- TESTOWEJ LED ***

uint8_t ah = 00;// * TU USTAWIAM
uint8_t am = 01;// * TESTOWY
uint8_t as = 00;// * CZAS NA -- 00:01:00
uint8_t i;

// **********************************************************
// ******* ZMIENNE DO WYŁĄCZANIA ALARMU -- TESTOWEJ LED *****

uint8_t ahw = 00;// * TU USTAWIAM
uint8_t amw = 01;// * TESTOWY
uint8_t asw = 50;// * CZAS NA -- 00:01:50

// ** ahw = alarm godziny wyłączania *************************
// ** amw = alarm minuty wyłączania *************************
// ** asw = alarm sekundy wyłączania *************************

uint8_t stc[] = {12,18,18,12,32,32,32,32};

int main( void ) {

lcd_init();
lcd_defchar(0, stc);
lcd_cls();
lcd_LED(1);
lcd_str("start...");

// konfiguracja wejścia INT0
PORTD |= (1<MCUCR |= (1<

i2cSetBitrate(100);

DS3231_init();

//DS3231_set_time( 17,46,0 );
//DS3231_set_date( 13, 10, 31, 4 );

// ******** DOTYCZY ALARMU -- MASZYNA STANU DLA DIODY TESTOWEJ **********************

DDRC |= (1<
#define LED_PIN (1<#define LED_ON PORTC &= ~LED_PIN // załączanie diody
#define LED_OFF PORTC |= LED_PIN // wyłączanie diody
#define LED_TOG PORTC ^= LED_PIN // zmiana stanu diody
// ******************************************************************************

// sei();
while(1) {

// **** WŁĄCZA ALARM ************************************
LED_OFF;// stan początkowy diody -- wyłączona

if (i>0)
{
LED_ON; //TESTOWA DIODA LED - stan WŁĄCZ
}
// *****************************************************

if( GIFR & (1<
DS3231_get_datetime( &datetime );
DS3231_get_temp( &temperature );

lcd_locate(0,0);
show_date( &datetime );

lcd_locate(1,0);
show_time( &datetime );

lcd_locate(1,9);
show_temperature( &temperature );

GIFR |= (1<}

}
}

void DS3231_init( void ) {
uint8_t ctrl = 0;
TWI_write_buf( DS3231_ADDR, 0x0e, 1, &ctrl );
}

void DS3231_get_datetime( TDATETIME * dt ) {
uint8_t i;
uint8_t buf[7];
TWI_read_buf( DS3231_ADDR, 0x00, 7, buf );
for( i=0; i<7; i++ ) dt->bytes[i] = bcd2dec( buf[i] );
}

void show_time( TDATETIME * dt ) {
if( dt->hh < 10 ) lcd_str("0");
lcd_int(dt->hh);
lcd_str(":");
if( dt->mm < 10 ) lcd_str("0");
lcd_int(dt->mm);
lcd_str(":");
if( dt->ss < 10 ) lcd_str("0");
lcd_int(dt->ss);

}

void show_date( TDATETIME * dt ) {
lcd_str("20");
if( dt->year < 10 ) lcd_str("0");
lcd_int(dt->year);
lcd_str("-");
if( dt->month < 10 ) lcd_str("0");
lcd_int(dt->month);
lcd_str("-");
if( dt->day < 10 ) lcd_str("0");
lcd_int(dt->day);
lcd_str(" ");
lcd_str( days[ dt->dayofwek - 1 ] );
}

void DS3231_set_time( uint8_t hh, uint8_t mm, uint8_t ss ) {
uint8_t buf[3];
buf[0]=dec2bcd(ss);
buf[1]=dec2bcd(mm);
buf[2]=dec2bcd(hh);
TWI_write_buf( DS3231_ADDR, 0x00, 3, buf );

// ******** USTAWIENIA DLA ALARMU -- WŁĄCZANIE TESTOWEJ LED ************************

czas = (hh*3600)+(mm*60)+ss;
alarm = (ah * 3600)+(am * 60)+as;

if (czas == alarm ){

i=1; // WŁĄCZ LED
}

// ******************************************************************************
// ********* USTAWIANIE DLA ALARMU -- WYŁĄCZANIE TESTOWEJ LED **********************

czas = (hh*3600)+(mm*60)+ss;
alarm = (ahw * 3600)+(amw * 60)+asw;

if (czas == alarm ){

i=0; // WYŁĄCZ LED
}

// ******************************************************************************

}

void DS3231_set_date( uint8_t year, uint8_t month, uint8_t day, uint8_t dayofweek ) {
uint8_t buf[4];
buf[0]=dayofweek;
buf[1]=dec2bcd(day);
buf[2]=dec2bcd(month);
buf[3]=dec2bcd(year);
TWI_write_buf( DS3231_ADDR, 0x03, 4, buf );
}

void DS3231_get_temp( TTEMP * tmp ) {
uint8_t buf[2];
TWI_read_buf( DS3231_ADDR, 0x11, 2, buf );
tmp->cel = buf[0] ;
tmp->fract = buf[1]>>6;

TWI_read_buf( DS3231_ADDR, 0x0e, 1, buf );
buf[0] |= (1<<5);
TWI_write_buf( DS3231_ADDR, 0x0e, 1, buf );
}

void show_temperature( TTEMP * tmp ) {
uint8_t fr[4] = {0,2,5,7};

if( tmp->cel < 100 ) lcd_str(" ");
if( tmp->cel < 10 ) lcd_str(" ");

lcd_int(tmp->cel);
lcd_str(".");
if( tmp->cel >= 0 ) lcd_int( fr[ tmp->fract ] );
else lcd_int( fr[ 3 - tmp->fract ] );

lcd_str("\x80""C");
}

// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec) {
return ((dec / 10)<<4) | (dec % 10);
}

// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd) {
return ((((bcd) >> 4) & 0x0F) * 10) + ((bcd) & 0x0F);
}[/syntax]

Statystyki: Napisane przez miki53 — 16 maja 2019, o 13:51

Re: Jak ustawić funkcję budzika

2019-05-15T19:17:54+01:00

Poszukaj sobie informacji o kodowaniu czasu unixowego - to bardzie rozbudowane niż to co ci podałem i co już uruchomiłeś - ale zawiera również datę

Statystyki: Napisane przez mirekk36 — 15 maja 2019, o 19:17

Re: Jak ustawić funkcję budzika

2019-05-15T17:09:59+01:00

Proszę o wybaczenie za moje marudzenie ale mam jeszcze parę pytań
związanych z alarmem ale w związku z poniższym kodem tym razem
dotyczącego układu DS3231 kod napisany dla tego układy jest trochę
w innej formie i nie bardzo potrafię się odnieść do zastosowania
Mirka wzoru z górnego listingu do tego kodu, prosiłbym o dalsze podpowiedzi

Czy mógłbym jeszcze prosić o przykład z zastosowaniem nie tylko alarmu ustawianego
na konkretną godzinę ale jeszcze na konkretny dzień ?

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

#include "LCD/lcd44780.h"
#include "I2C_TWI/i2c_twi.h"

typedef union {
uint8_t bytes[7];
struct {
uint8_t ss;
uint8_t mm;
uint8_t hh;
uint8_t dayofwek;
uint8_t day;
uint8_t month;
uint8_t year;
};
} TDATETIME;

typedef struct {
int8_t cel;
uint8_t fract;
} TTEMP;

#define DS3231_ADDR 0xD0

void DS3231_init( void );
uint8_t dec2bcd(uint8_t dec);
uint8_t bcd2dec(uint8_t bcd);
void DS3231_get_datetime( TDATETIME * dt );
void show_time( TDATETIME * dt );
void show_date( TDATETIME * dt );
void DS3231_set_time( uint8_t hh, uint8_t mm, uint8_t ss );
void DS3231_set_date( uint8_t year, uint8_t month, uint8_t day, uint8_t dayofweek );
void DS3231_get_temp( TTEMP * tmp );
void show_temperature( TTEMP * tmp );

TDATETIME datetime;
TTEMP temperature;

char days[7][4] = {
"pon", "wto", "sro", "czw", "pia", "sob", "nie"
};

uint8_t stc[] = {12,18,18,12,32,32,32,32};

int main( void ) {

lcd_init();
lcd_defchar(0, stc);
lcd_cls();
lcd_LED(1);
lcd_str("start...");

// konfiguracja wejścia INT0
PORTD |= (1<MCUCR |= (1<

i2cSetBitrate(100);

DS3231_init();

//DS3231_set_time( 17,46,0 );
//DS3231_set_date( 13, 10, 31, 4 );

// sei();
while(1) {

if( GIFR & (1<
DS3231_get_datetime( &datetime );
DS3231_get_temp( &temperature );

lcd_locate(0,0);
show_date( &datetime );

lcd_locate(1,0);
show_time( &datetime );

lcd_locate(1,9);
show_temperature( &temperature );

GIFR |= (1<}

}
}

void DS3231_init( void ) {
uint8_t ctrl = 0;
TWI_write_buf( DS3231_ADDR, 0x0e, 1, &ctrl );
}

void DS3231_get_datetime( TDATETIME * dt ) {
uint8_t i;
uint8_t buf[7];
TWI_read_buf( DS3231_ADDR, 0x00, 7, buf );
for( i=0; i<7; i++ ) dt->bytes[i] = bcd2dec( buf[i] );
}

void show_time( TDATETIME * dt ) {
if( dt->hh < 10 ) lcd_str("0");
lcd_int(dt->hh);
lcd_str(":");
if( dt->mm < 10 ) lcd_str("0");
lcd_int(dt->mm);
lcd_str(":");
if( dt->ss < 10 ) lcd_str("0");
lcd_int(dt->ss);
}

void show_date( TDATETIME * dt ) {
lcd_str("20");
if( dt->year < 10 ) lcd_str("0");
lcd_int(dt->year);
lcd_str("-");
if( dt->month < 10 ) lcd_str("0");
lcd_int(dt->month);
lcd_str("-");
if( dt->day < 10 ) lcd_str("0");
lcd_int(dt->day);
lcd_str(" ");
lcd_str( days[ dt->dayofwek - 1 ] );
}

void DS3231_set_time( uint8_t hh, uint8_t mm, uint8_t ss ) {
uint8_t buf[3];
buf[0]=dec2bcd(ss);
buf[1]=dec2bcd(mm);
buf[2]=dec2bcd(hh);
TWI_write_buf( DS3231_ADDR, 0x00, 3, buf );
}

void DS3231_set_date( uint8_t year, uint8_t month, uint8_t day, uint8_t dayofweek ) {
uint8_t buf[4];
buf[0]=dayofweek;
buf[1]=dec2bcd(day);
buf[2]=dec2bcd(month);
buf[3]=dec2bcd(year);
TWI_write_buf( DS3231_ADDR, 0x03, 4, buf );
}

void DS3231_get_temp( TTEMP * tmp ) {
uint8_t buf[2];
TWI_read_buf( DS3231_ADDR, 0x11, 2, buf );
tmp->cel = buf[0] ;
tmp->fract = buf[1]>>6;

TWI_read_buf( DS3231_ADDR, 0x0e, 1, buf );
buf[0] |= (1<<5);
TWI_write_buf( DS3231_ADDR, 0x0e, 1, buf );
}

void show_temperature( TTEMP * tmp ) {
uint8_t fr[4] = {0,2,5,7};

if( tmp->cel < 100 ) lcd_str(" ");
if( tmp->cel < 10 ) lcd_str(" ");

lcd_int(tmp->cel);
lcd_str(".");
if( tmp->cel >= 0 ) lcd_int( fr[ tmp->fract ] );
else lcd_int( fr[ 3 - tmp->fract ] );

lcd_str("\x80""C");
}

// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec) {
return ((dec / 10)<<4) | (dec % 10);
}

// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd) {
return ((((bcd) >> 4) & 0x0F) * 10) + ((bcd) & 0x0F);
}[/syntax]

Statystyki: Napisane przez miki53 — 15 maja 2019, o 17:09

Re: Jak ustawić funkcję budzika

2019-05-14T17:44:20+01:00

Mirku jesteś naprawdę WIELKI !!

Fajnie kod zadziałał mogę włączać i wyłączać diodę testową o ustalonych godzinach

DLA KOLEGÓW

PRZYKŁADOWY KOD DO TESTOWANIA ZACZERPNIĘTY Z BB
Mikrokontrolery AVR
Język C
podstawy programowania

Wszystkie potrzebne biblioteki są zawarte w lekcji o nazwie - 08_I2C_SOFT

DZIAŁAJĄCY KOD Z ALARMEM to tylko testowy kod a nie ostateczny program

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

#include "LCD/lcd44780.h"

#include "I2C_SOFT/i2c_soft.h"

//#define PCF8583_ADDR 0xA0// gdy A1 --> GND
#define PCF8583_ADDR 0xA2// gdy A1 --> VCC

//ja #define _24C04_ADDR 0xA8

uint8_t tekst[] = "EEPROM!";

// ******** ZMIENNE DLA ALARMU *****************************

uint16_t czas;
uint16_t alarm;

// ******** ZMIENNE DO WŁACZANIA ALARMU -- TESTOWEJ LED ***

uint8_t ah = 00;// * TU USTAWIAM
uint8_t am = 01;// * TESTOWY
uint8_t as = 00;// * CZAS NA -- 00:01:00
uint8_t i;

// **********************************************************
// ******* ZMIENNE DO WYŁĄCZANIA ALARMU -- TESTOWEJ LED *****

uint8_t ahw = 00;// * TU USTAWIAM
uint8_t amw = 01;// * TESTOWY
uint8_t asw = 50;// * CZAS NA -- 00:01:50

// ** ahw = alarm godziny wyłączania *************************
// ** amw = alarm minuty wyłączania *************************
// ** asw = alarm sekundy wyłączania *************************

uint8_t bo[ sizeof(tekst)+1 ]; // bufor pomocniczy na odczyt z EEPROM

volatile uint8_t int0_flag=1;// flaga zmieniana w przerwaniu i sprawdzana w pętli głównej

// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec);
// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd);

// odczyt danych z pamięci EEPROM
//ja void EI2C_read_buf(u08 device, u16 subAddr, u16 len, u08 *buf);

// zapis danych do pamięci EEPROM
//ja void EI2C_write_buf(u08 device, u16 subAddr, u16 len, u08 *buf);

int main(void) {

//******** DOTYCZY ALARMU ********************************************************
DDRC |= (1<#define LED_PIN (1<#define LED_ON PORTC &= ~LED_PIN // załączanie diody
#define LED_OFF PORTC |= LED_PIN // wyłączanie diody
#define LED_TOG PORTC ^= LED_PIN // zmiana stanu diody

//******** USTAWIONE PORTY PODŚWIETLENIA LCD DLA ATMEGI_8 ************************

DDRC |= (1<PORTC |= (1<//********************************************************************************
// Przerwanie INT0
MCUCR |= (1<GICR |= (1<PORTD |= (1<

// definiujemy sobie dla polepszenia czytelności programu typ wyliczeniowy
// wskazujący nam później na odpowiednie indeksy w tablicy (buforze)
enum {ss=1, mm, hh};
uint8_t bufor[4];// rezerwacja bufora 4 bajty
uint8_t sekundy, minuty, godziny;

i2c_init();
lcd_init();

sei();

lcd_str_P(PSTR("start..."));
_delay_ms(500);

//***************************************************************************
// Ustawianie czasu na godzinę: 18:34:27
/*
bufor[0] = 0;// setne części sekundy
bufor[1] = dec2bcd(00);// sekundy
bufor[2] = dec2bcd(44);// minuty
bufor[3] = dec2bcd(15);// godziny
// zapis 4 bajtów z bufora pod adres 0x01 w pamięci RAM naszego RTC
I2C_write_buf( PCF8583_ADDR, 0x01, 4, bufor );
*/
//****************************************************************************
// zapis tekstu do pamięci EEPROM od adresu 253, dlatego aby tekst
// został zapisany w jednym i drugim banku pamięci
//jaEI2C_write_buf( _24C04_ADDR, 253, sizeof(tekst), tekst );

while(1) {

// **** WŁĄCZA ALARM ************************************
LED_OFF;// stan początkowy diody -- wyłączona

if (i>0)
{
LED_ON; //TESTOWA DIODA LED - stan WŁĄCZ
}
// ******************************************************

// ***** TEST PRZED FLAGĄ ********************************
/*
czas = (godziny*3600)+(minuty*60)+sekundy;
alarm = (ah * 3600)+(am * 60)+as;

if (czas == alarm ){

i++; // WŁĄCZ LED
}
*/
// *******************************************************

if ( int0_flag ) {
//odczyt 4 bajtów do bufora od adresu 0x01 z pamięci RAM naszego RTC
I2C_read_buf( PCF8583_ADDR, 0x01, 4, bufor );

sekundy = bcd2dec( bufor[ss] );
minuty = bcd2dec( bufor[mm] );
godziny = bcd2dec( bufor[hh] );

// ******** ustawienia dla alarmu WŁĄCZANIE TESTOWEJ LED ************************

czas = (godziny*3600)+(minuty*60)+sekundy;
alarm = (ah * 3600)+(am * 60)+as;

if (czas == alarm ){

i=1; // WŁĄCZ LED
}

// ******************************************************************************
// ********* ustawienia dla alarmu WYŁĄCZANIE TESTOWEJ LED **********************

czas = (godziny*3600)+(minuty*60)+sekundy;
alarm = (ahw * 3600)+(amw * 60)+asw;

if (czas == alarm ){

i=0; // WYŁĄCZ LED
}

// ******************************************************************************

// wyświetlenie czasu na LCD
lcd_cls();// kasowanie ekranu
lcd_locate(0,4);
if( godziny < 10 ) lcd_str("0");
lcd_int(godziny);
lcd_str(":");
if( minuty < 10 ) lcd_str("0");
lcd_int(minuty);
lcd_str(":");
if( sekundy < 10 ) lcd_str("0");
lcd_int(sekundy);

lcd_locate(1, 0);
lcd_str_P(PSTR("ustaw alarm"));

// odczyt z EEPROM
//ja EI2C_read_buf( _24C04_ADDR, 253, sizeof(tekst), bo );

// wyświetlenie napisu z EEPROM na LCD
//jalcd_locate(1, 9);
//jalcd_str( (char*)bo );

int0_flag=0;
}

}
}

// procedura obsługi przerwania INT 0
ISR( INT0_vect ) {
int0_flag = 1;
}

// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec) {
return ((dec / 10)<<4) | (dec % 10);
}

// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd) {
return ((((bcd) >> 4) & 0x0F) * 10) + ((bcd) & 0x0F);
}[/syntax]

Statystyki: Napisane przez miki53 — 14 maja 2019, o 17:44