ATNEL tech-forum

Re: Zegarek i termometr czyli klasyka

2016-03-03T18:37:14+01:00

witam,
pomijając niedociągnięcia w temacie rozdzielania plików i techniki programowania
BARDZO dobry przykład dla początkujących w temacie wskaźników do funkcji
brak struktur menu itp.
dzięki za podpowiedź do mojego projektu
pozdrawiam

Statystyki: Napisane przez zbynio_k — 3 mar 2016, o 18:37

Re: Zegarek i termometr czyli klasyka

2015-09-22T20:21:06+01:00

Dzięki za linki. Przetrawiłem je.
Bardzo wartościowe linki jeżeli chodzi o jakość kodu.
Szczególnie ten http://www.ipa.go.jp/files/000040508.pdf dokument jest bardzo fajny.
Bardzo wyraźnie jest pokazane jakich konstrukcji nie stosować i dlaczego.
Polecam wszystkim.

Jeżeli chodzi o poprawę kodu/ podział na moduły to prace trwają... Z braku czasu bardzo powoli...

Statystyki: Napisane przez Jarcio — 22 wrz 2015, o 20:21

Re: Zegarek i termometr czyli klasyka

2015-09-12T20:54:16+01:00

Dziękuje za uwagi.
Z większością uwag kolegi mokrowski muszę się zgodzić. Przejrzałem kod i wychodzi na to że prościej go napisać od nowa
Człowiek uczy się na błędach. Zaciekawiła mnie uwaga z pkt 11 na temat sprawdzania kodu. Mam prośbę o lekkie rozwinięcie tematu sprawdzania jakości kodu. Czy są jakieś darmowe narzędzia do tego, czy trzeba tworzyć jakieś szablony kodu wg których następuje sprawdzanie itp..

Zacząłem na nowo pisać kod od razu dzieląc go na moduły. Funkcje do odczytania i wyświetlenia czasy wyrzuciłem do modułu czas, definicje klawiszy i wszystkiego co się wiąże z podłączeniem do avr wpisałem definicje.h. Teraz rzeczywiście wygląda to lepiej Na razie jest wyświetlany sam zegarek, reszta dojdzie w przyszłości...
Tak wygląda obecnie main.c
[syntax=c]#include
#include
#include

/*
* poniższe biblioteki z książki
* Mikrokontrolery AVR Język C - podstawy programowania
*/
#include "LCD/lcd44780.h"
#include "I2C_TWI/i2c_twi.h"

#include "Czas/czas.h"
#include "definicje.h"

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

void inicjuj (void);

/*
* main - START
*/
int main (void)
{
CZAS_t akt_czas;

inicjuj ();

sei();

while (1)
{
// działania podejmowane co 1s
if (int0_flag)
{
akt_czas = czas_odczytaj (); // odczytujemy czas z RTC
czas_wyswietl (0, 4, akt_czas, true); // i wyświetlamy na LCD
}
}

return 0;
}
/*
* main - KONIEC
*/

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

/*
* inicjujemy co można
*/
void inicjuj (void)
{
// Przerwanie INT0
MCUCR |= (1< GICR |= (1< PORTD |= (1<
// podpinamy klawisze
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN);
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN;

lcd_init(); // inicjujemy LCD

// włączamy podświetlenie LCD
DDRA |= LCD_LED_PIN;
LCD_LED_ON;

i2cSetBitrate (100); // USTAWIAMY prędkość 100 kHz na magistrali I2C
}[/syntax]
Czas.h
[syntax=c]#ifndef CZAS_CZAS_H_
#define CZAS_CZAS_H_

#define PCF8583_ADDR 0xA2

//struktura do określania czasu
typedef struct {
uint8_t godz; // godzina
uint8_t min; // minuta
uint8_t sek; // sekunda
} CZAS_t;

/*
* konwersja liczby dziesiętnej na BCD
*/
uint8_t dec2bcd(uint8_t dec);

/*
* konwersja liczby BCD na dziesiętną
*/
uint8_t bcd2dec(uint8_t bcd);

/*
* odczytanie czasu z RTC
*/
CZAS_t czas_odczytaj (void);

/*
* wyświetlenie czasu na LCD
* parametry:
* uint8_t y - pozycja y na lcd
* uint8_t x - pozycja x na lcd
* CZAS_t czas - czas do wyświetlenia
* bool czy_sek - czy wyświetlać sekundy (true/false)
*/
void czas_wyswietl (uint8_t y, uint8_t x, CZAS_t czas, bool czy_sek);

#endif /* CZAS_CZAS_H_ */[/syntax]
czas.c
[syntax=c]#include
#include

/*
* poniższe biblioteki z książki
* Mikrokontrolery AVR Język C - podstawy programowania
*/
#include "../LCD/lcd44780.h"
#include "../I2C_TWI/i2c_twi.h"

#include "czas.h"

// 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);
}

CZAS_t czas_odczytaj (void)
{
uint8_t bufor_rtc[4]; // rezerwacja bufora 4 bajty na odczyt TRC
CZAS_t czas; // zmienna na aktualny czas
//odczyt 4 bajtów do bufora od adresu 0x01 z pamięci RAM naszego RTC
TWI_read_buf( PCF8583_ADDR, 0x01, 4, bufor_rtc );

czas.sek = bcd2dec( bufor_rtc[1] );
czas.min = bcd2dec( bufor_rtc[2] );
czas.godz = bcd2dec( bufor_rtc[3] );

return czas;
}

void czas_wyswietl (uint8_t y, uint8_t x, CZAS_t czas, bool czy_sek)
{
lcd_locate(y,x);
if( czas.godz < 10 )
{
lcd_str("0");
}
lcd_int(czas.godz);
lcd_str(":");
if (czas.min < 10)
{
lcd_str("0");
}
lcd_int(czas.min);
if (czy_sek)
{
lcd_str(":");
if( czas.sek < 10 )
{
lcd_str("0");
}
lcd_int(czas.sek);
}
}[/syntax]
No i co wiąże z podłączenie pinów do procka przeniosłem do definicje.h
[syntax=c]#ifndef DEFINICJE_H_
#define DEFINICJE_H_

// definicja klawiszy
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1<// lub jeżeli jest ustawiony wygaszacz to również ręczne wyłączenie podswietlenia
// ostatnia funkcja to wyłączenie budzika :-)
// i innych rzeczy :-)
#define LCD_LED_PIN (1<#define LCD_LED_ON PORTA |= LCD_LED_PIN
#define LCD_LED_OFF PORTA &= ~LCD_LED_PIN
#define LCD_LED_TOG PORTA ^= LCD_LED_PIN

#define BEEP_PIN (1<#define BEEP_ON PORTB |= BEEP_PIN
#define BEEP_OFF PORTB &= ~BEEP_PIN
#define BEEP_TOG PORTB ^= BEEP_PIN

#endif /* DEFINICJE_H_ */[/syntax]

Statystyki: Napisane przez Jarcio — 12 wrz 2015, o 20:54

Re: Zegarek i termometr czyli klasyka

2015-09-10T21:48:01+01:00

Ja też po 20 latach programowania w Pascalu długo się trzymałem takich przyzwyczajeń jak zaczynałem uczyć się C .... a teraz ...

jak mam napisać i=i+1 to mnie obrzydzenie bierze wolę i++

co ciekawe jak na PC zaczynam coś pisać w moim Delphi bo wciąż na PC używam Delphi to aż mi brakuje takich fajnych fiuczerów z C

Statystyki: Napisane przez mirekk36 — 10 wrz 2015, o 21:48

Re: Zegarek i termometr czyli klasyka

2015-09-10T21:44:12+01:00

OK
I o to mi chodziło. Wiem na co bardziej zwrócić uwagę.

Kiedyś prawie wszędzie uczyli wszędzie Pascala - do którego osobiście nic nie mam. Cuda też można tam robić.
Pozostały również stare przyzwyczajenia z ... FoxPro dla DOS . Ciekawe czy ktoś to pamięta
Stąd też również dziwne przyzwyczajenia do formatowania kodu, co optycznie go znacznie wydłuża...
Nie napiszę kodu pętli w ten sposób:
[syntax=c]for (i=0; i<10; i++){
polecenie1();
polecenie2();
}[/syntax]U mnie musi być
[syntax=c]for (i=0; i<10; i++)
{
polecenie1();
polecenie2();
}[/syntax]
Pierwszy przypadek jest dla mnie na razie całkowicie nieczytelny.
Również z tego powodu nie zmieniam wartości zmiennych przez np i++. U mnie musi być i=i+1 itp...
I tak wychodzą przyzwyczajenia po begin..end.
Koniec marudzenia. C coraz bardziej mi się to podoba.

Statystyki: Napisane przez Jarcio — 10 wrz 2015, o 21:44

Re: Zegarek i termometr czyli klasyka

2015-09-10T07:29:04+01:00

Jarcio napisał(a):

Mam tylko nadzieję że krytyka będzie delikatna...

Krytyką to mogą się zajmować ludzie zajmujący się sztuką, kulturą, dziełami sztuki itp ....

Ja nie mam z nimi nic wspólnego więc kilka mała uwaga.

Przede wszystkim, brak podziału projektu na pliki - postaraj się tego jak najszybciej nauczyć, bo teraz przypomina ten kod - najczystszą postać z bascoma (jeden wielki plik (worek) do którego wrzucono wszystko co się da)

O ile masz w bibliotekach obsługę RTC, 1wire czy LCD to pomyśl u ciebie pięknie można wydzielić kolejne bloki logiczne jak

- obsługa menu (oddzielny plik)
- obsługa zegarka (oddzielny plik i funkcje)
- obsługa alarmów/budzika (oddzielny plik i funkcje, szczególnie ta menu_func_ustaw_budzik () wprost nadaje się do wydzielenia)
- oddzielne funkcje do wyświetlania poszczególnych danych

bo w tej chwili twoja funkcja main() jest spuchnięta do nieskończoności.

Mówię tylko, że przydałoby się to zrobić bo wtedy kod byłby 100x bardziej czytelny a tym bardziej, że bardzo ładnie go sobie komentowałeś (duży PLUS)

Podsumowując gdy nauczysz się lepszego podziału na pliki sam z tego skorzystasz - mówię ci i gorąco polecam ci takie podejście. Zaś prezentowany tu kod będzie wtedy miał wszystko czego potrzeba.

Statystyki: Napisane przez mirekk36 — 10 wrz 2015, o 07:29

Zegarek i termometr czyli klasyka

2015-09-09T22:57:47+01:00

Witam wszystkich
Jest to mój pierwszy post na tym forum więc proszę o wyrozumiałość
Od roku jestem posiadaczem ATB i niebieskiej książki. W sumie chciałem się pochwalić swoim pierwszym większym kodem.
Ponieważ prawie każdy zaczyna od zegarka, termometru, migania diodami (może nie w tej kolejności ) więc mój kod również tego dotyczy. Dodatkowo ponieważ na forum często pojawiają się pytania o menu to również chciałem przedstawić swoje podejście (jako osoby początkującej) do tego problemu.
Moje menu nie jest oparte na strukturach, listach, dużej ilości wskaźników itp. Podszedłem do problemu dość prosto.
W kodzie mam dwie tablice. Jedna zawiera opisy jakie się pojawiają na LCD. Druga tablica zawiera wskaźniki do funkcji jakie będą wywołane dla poszczególnych opisów. Poruszając się po opisach ustawiamy sobie indeks który jest użyty do wywołania właściwej funkcji z drugiej tablicy.
Dodatkowo dla uproszczenia całości w pierwszym wierszu LCD są wyświetlane tylko opisy menu. Ustawianie parametrów natomiast odbywa się w drugim wierszu.
Program może nie jest napisany w najlepszym stylu jak powinno się pisać na avr. Do tematu programowania podszedłem bowiem bardzo liniowo. Kodowi również przydałaby się jeszcze optymalizacja. W paru miejscach funkcje prawie są jednakowe, np. te od ustawiania temperatury w menu. Jeżeli chodzi o obsługę przycisków to również jest najprostsza z możliwych. Zatem ich obsługa jest czasami irytująca. Miejmy nadzieję że następna wersja będzie lepsza...
Opis połączeń na ATB i funkcjonalności programu jest w kodzie. W razie pytań o kod postaram się na nie odpowiedzieć.
Mam tylko nadzieję że krytyka będzie delikatna...
Przy okazji pytanko - jak w eclipse wpisać literę "ć". U mnie pojawia się okienko z prośbą o podanie ścieżki do ChangeLog.

[syntax=c]/*****************************************************************
* Podłączenie pinów na zestawie uruchomieniowym ATB
*****************************************************************
*
* WYSWIETLACZ
* PA0 - PA7 --> RS, RW, E, D4, D5, D6, D7, 8 (backlight)
* KLAWISZE
* K1 --> PC6
* K2 --> PC5
* K3 --> PC2
* K4 --> PC3
* RTC
* RTC INT (1) --> PD2
* 1WIRE
* 1Wire --> PB1
* BUZZER
* J5 --> PB2
*
* Wykorzystano dwa czujniki DS1820
* Jeden wbudowany zestaw, drugi podpięty do pinów ATB
*****************************************************************/

/*****************************************************************
* Opis dzialania
*****************************************************************
*
* Po podłączeniu płytki ATB zgodnie z powyższym opisem
* na wyświetlaczu powinna pojawic sie jakaś godzina z RTC
* i powinien byc odliczany czas
*
* Do momentu ustawienia w menu odpowiednich czujników do
* temperatury "zewnętrznej" i "wewnętrznej" na LCD będą
* widoczne "-----" kreski.
*
* Po ustawieniu budzika powinien się pojawic dodatkowo na LCD
* napis BUDZIK.
*
* Funkcjonalnośc menu jest opisana w pobliżu tablicy menu_opt,
* która zawiera napisy jakie pojawią się w menu.
*
* Trochę o budziku.
* Sygnał dźwiękowy jest najprostrzy jak się da. Co jedną sekundę
* włącza się beper na płycie ATB na jedną sekunę i potem sekunda przerwy. :-)
* Dodatkowo w tym samym czasie mryga podświetlenie LCD.
* Do ustawienia budzika służą aż 3 opcje z menu
* 1. USTAW BUDZIK - ustawiamy czas włączenia budzika
* 2. BUDZIK AKTYWNY - czy o danym czasie budzik ma dzwonic
* 3. SYGNAL DZWIEKOWY - czy budzik ma wydawac dźwięki
* Jeżeli jest ustawione NIE to budzik tylko mryga wyświetlaczem
* np żebyśmy poszli szybciej do łóżka a nie siedzieli po nocach przed ATB :-)
* I nie stawia całej rodziny na nogi ...
* Czas trwania budzenia został z lenistwa zaszyty w kodzie w
* #define BUDZIK_CZAS 1 - czas podajemy w minutach
*
* Wciskajac klawis K3 mozemy wywolac menu
* Za pomocą klawisza K1 wybieramy poprzednia pozycje menu
* Za pomoca klawisza K2 wybieramy nastepna pozycje menu
* Po wybraniu pozycji można ją zatwierdzic klawiszem K3
* Klawisz K4 służy do włączenia lub wyłączenia podświetlenia LCD
* oraz do wyłączenia budzika :-)
*
* W celu uproszczenia obslugi menu troche inaczej podszedlem do
* problemu jego wyswietlania i wyboru pozycji. Menu jest tylko w
* pierwszym wierszu lcd i tam są opisy
*
* Drugi wiersz służy do zmiany parametrów.
* Może nie jest to najbardziej eleganckie rozwiązanie
* ale za to proste w implementacji.
*
*****************************************************************/

#include
#include
#include
#include
#include

// poniższe biblioteki są z książki Pana Mirosława Kardasia
// Mikrokontrolery AVR Język C - podstawy programowania
// wydanej przez wydawnictwo Atnel
// i nie są załączone do kodu
#include "LCD/lcd44780.h"
#include "I2C_TWI/i2c_twi.h"
#include "1Wire/ds18x20.h"

//struktura do określania czasu
typedef struct {
uint8_t godz; // godzina
uint8_t min; // minuta
uint8_t sek; // sekunda
} CZAS;

// struktura do ustawień
typedef struct {
uint8_t beep; // beeper 0-NIE / 1 - TAK
uint8_t czas_wygaszacza; // czas do wyłączenie podświetlenia
uint8_t tz_sensor [8]; // sensor temperatury zewnetrznej
uint8_t tw_sensor [8]; // sensor temperatury wewnętrznej
uint8_t jest_budzik; // czy budzik ma działac 0-NIE/1-TAK
CZAS budzik_godz; // godzina włączenia budzika
} USTAWIENIA;

#define EEMEM __attribute__((section(".eeprom")))

USTAWIENIA EEMEM ee_ustawienia; // ustawienia przechowywane w eeprom
USTAWIENIA ustawienia; // ustawienia przechowywane w ram

#define BUDZIK_CZAS 1 // czas trwania budzika w minutach

#define MAX_OPTIONS 8 //definiujemy max ilosc opcji w menu

// opisy menu też przechowujemy w eeprom
char EEMEM menu_opt[MAX_OPTIONS][17] = {"SYGNAL DZWIEKOWY", // Czy jest beep po wciśnięciu klawisza lub sygnał dzwiękowy budzika
"USTAW CZAS", // Ustawianie zegarka i zapis danych do RTC
"WYGASZACZ", // Określenie po jakim czasie w [s] ma się wyłączyc podświetlenie LCD
"TEMP ZEWN", // Podpięcie właściwego czujnika DS18B20 do termometru zewnętrznego
"TEMP WEWN", // Podpięcie właściwego czujnika DS18B20 do termometru wewnętrznego
"BUDZIK AKTYWNY", // Budzik aktywny TAK/NIE
"USTAW BUDZIK", // Ustaw godzinę włączenia budzika
"KONIEC" // Wyjście z menu
};

// funkcje do obsługi poczczególnych pozycji menu
void menu_func_01();
void menu_func_02();
void menu_func_03();
void menu_func_04();
void menu_func_tz();
void menu_func_tw();
void menu_func_budzik_akt();
void menu_func_ustaw_budzik();

// i tablica wskaznikow do funkcji do obslugi menu
void (*menu_func[MAX_OPTIONS])() = { menu_func_01,
menu_func_02,
menu_func_03,
menu_func_tz,
menu_func_tw,
menu_func_budzik_akt,
menu_func_ustaw_budzik,
menu_func_04
};

int8_t item = 0; // biezaca pozycja menu
int8_t jestem_w_menu = 0; // jestesmy w menu
int8_t pierwszy = 0; // wyrysowanie startowe menu - po wejsciu do menu

uint8_t wygaszacz = 0; // wygaszacz ekranu NIE=0/TAK=1
uint8_t czas_wygaszenia = 0; // czas do wygaszenia ekranu

uint8_t subzero, cel, cel_fract_bits; // do obsługi termometru
uint8_t czujniki_cnt; // ilość czujników na magistrali

// definicja klawiszy
#define KEY1_PIN (1<#define KEY2_PIN (1<#define KEY3_PIN (1<#define KEY4_PIN (1< // lub jeżeli jest ustawiony wygaszacz to również ręczne wyłączenie podswietlenia
// ostatnia funkcja to wyłączenie budzika :-)

// i innych rzeczy :-)
#define LCD_LED_PIN (1<#define LCD_LED_ON PORTA |= LCD_LED_PIN
#define LCD_LED_OFF PORTA &= ~LCD_LED_PIN
#define LCD_LED_TOG PORTA ^= LCD_LED_PIN

#define BEEP_PIN (1<#define BEEP_ON PORTB |= BEEP_PIN
#define BEEP_OFF PORTB &= ~BEEP_PIN
#define BEEP_TOG PORTB ^= BEEP_PIN

#define PCF8583_ADDR 0xA2 // adres RTC

uint8_t klawisz_wcisniety(uint8_t klawisz); // funkcja obsługi wcisnietego klawisza - najprostsza z możliwych
// funkcja wzięta żywcem z BB, z małymi modyfikacjami

void disp_opt(int8_t item); // wyświetlenie określonej pozycji menu na LCD

// funkcje odpowiedzialne za wizualizacje menu na LCD
void menu_disp_tak_nie (uint8_t stan);
void menu_disp_czas (uint8_t pozycja, CZAS akt_czas, uint8_t wyswietlaj_sekundy);
void menu_disp_03 (uint8_t czas);
void menu_disp_sensor (uint8_t poz[]);

// wyświetlanie temperatury na lcd
void display_temp(uint8_t y, uint8_t x);

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);

//*******************************************************************************************
// main (void)
//*******************************************************************************************
int main(void) {

uint8_t bufor_rtc[4]; // rezerwacja bufora 4 bajty
CZAS akt_czas; // zmienna na aktualny czas

int czas_aktualny; // zmienne do wyliczanki czasów
int czas_wl_budzika;

DDRA |= LCD_LED_PIN; // włączamy podświetlenie LCD
LCD_LED_ON;

// Przerwanie INT0
MCUCR |= (1< GICR |= (1< PORTD |= (1<
DDRC &= ~(KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN);
PORTC |= KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN;

//odczyt ustawien programu
eeprom_read_block (&ustawienia, &ee_ustawienia, sizeof (ustawienia));

// sprawdzamy ile czujników DS18xxx widocznych jest na magistrali
czujniki_cnt = search_sensors();
// wysyłamy rozkaz wykonania pomiaru temperatury do wszystkich czujników na magistrali 1Wire
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
_delay_ms(750);

lcd_init();

i2cSetBitrate( 100 ); // USTAWIAMY prędkość 100 kHz na magistrali I2C

sei();

// i pętla główna programu
while(1) {

if (ustawienia.czas_wygaszacza) // jeżeli ustawiony czas wygaszacza
{
if (wygaszacz && klawisz_wcisniety (KEY4_PIN)) // i włączony LCD wygaszony
{
wygaszacz = 0;
LCD_LED_ON; // to zapal podświetlenie
}

if (!wygaszacz && klawisz_wcisniety (KEY4_PIN)) // jeżeli ustawiony czas wygaszacza
{ // to możesz ręcznie
wygaszacz = 1; // wyłączyc podświetlenie
LCD_LED_OFF;
}
}

if (ustawienia.jest_budzik) // jeżeli jest budzik
{
if (klawisz_wcisniety (KEY4_PIN)) // i wcisniemy K4
{
ustawienia.jest_budzik = 0; // to wyłącz budzik - ustawienia są zmieniane tylko w ram
// jeżeli nie będziemy nic zmieniac w menu to po resecie się przywrócą
// jeżeli coś zmienimy z wyjątkiem zegarka to się zapiszą....
if (!jestem_w_menu) // aby nie pisac po menu
{ // to jeżeli w nim nie jesteś
lcd_locate(1,1);
lcd_str (" "); // to zakryj napis BUDZIK
}
LCD_LED_ON; // i włącz wyświetlacz

if (ustawienia.beep) // tu możesz lub nie musisz
{
BEEP_OFF; // popikac beeperem
}
}
}

// wciskamy klawisz menu
if (klawisz_wcisniety (KEY3_PIN) && (!jestem_w_menu) && (!wygaszacz))
{
jestem_w_menu = 1;
pierwszy = 1;
}

// jestesmy w menu
if (jestem_w_menu)
{
// jezeli dopiero weszlismy do menu to wyswietlamy
// jednorazowo (po wejsciu do menu) menu od pierwszej pozycji
if (pierwszy)
{
disp_opt (0);
pierwszy = 0; //wyswietlilismy menu to do nastepnego wywolania menu
}

// a tu poruszamy sie po menu glownym
if (klawisz_wcisniety (KEY1_PIN)) // jezeli wcisniety KEY 1
{
item = item - 1; // zmniejsz pozycje menu
if (item < 0) // jezeli poczatek menu
{
item = 0; // to nie zmniejszaj
} // mozna ewentualnie przeskoczyc na koniec menu
disp_opt(item); // ponownie narysuj menu
}

if (klawisz_wcisniety (KEY2_PIN)) // jezeli wcisniety KEY 2
{
item = item + 1; // zwieksz pozycje menu
if (item >= MAX_OPTIONS-1) // pamietajmy ze tablice liczymy od 0 a nie od 1
{ // stąd zapis MAX_OPTIONS-1
item = MAX_OPTIONS-1; // to nie zwiekszaj
} // zamiast stac na koncu mozna przewinac menu na poczatek
// osobiscie tego nie preferuje
disp_opt(item); // ponownie narysuj menu
}

if (klawisz_wcisniety (KEY3_PIN)) // jezeli wcisniety klawisz KEY 3
{
menu_func[item](); // wywolaj funkcje obslugi wybranego menu
if (jestem_w_menu) // zabezpieczenie przed wyrysowaniem menu na LCD
{ // po wyjsciu z menu
disp_opt(item); // jezeli wyjdziesz z powyzszej funkcji obslugi menu
// to ponownie wyswietl menu na aktualnej pozycji
}
}
}

// wyświetlanie zegarka co 1s jeżeli nie jestem w menu
// dzięki przerwaniu INT0 na porcie PD1 który jest podpięty do RTC
if ( int0_flag )
{

//odczyt 4 bajtów do bufora od adresu 0x01 z pamięci RAM naszego RTC
TWI_read_buf( PCF8583_ADDR, 0x01, 4, bufor_rtc );

akt_czas.sek = bcd2dec( bufor_rtc[1] );
akt_czas.min = bcd2dec( bufor_rtc[2] );
akt_czas.godz = bcd2dec( bufor_rtc[3] );

if (ustawienia.czas_wygaszacza) // jeżeli ustawiony czas do wygaszenia LCD
{
if (!wygaszacz) // i wygaszacz nie włączony jeszcze
{
if (czas_wygaszenia >= ustawienia.czas_wygaszacza) // i nadszedł czas wyłączenia
{
LCD_LED_OFF; // to wyłącz podświetlenie LCD
wygaszacz = 1;
}
else // jeżeli nie nadszedł czas wyłączenia
{
czas_wygaszenia = czas_wygaszenia + 1; // to dalej licz ile ci brakuje do wyłączenia
}
}
}

// ponieważ nie jesteśmy w menu
// to możemy sobie spokojnie wyświetlac na LCD to co chcemy
// czyli zegarek i temperatury
if (!jestem_w_menu)
{
// wyświetlenie czasu na LCD
lcd_locate(0,0);
if( akt_czas.godz < 10 ) lcd_str("0");
lcd_int(akt_czas.godz);
lcd_str(":");
if( akt_czas.min < 10 ) lcd_str("0");
lcd_int(akt_czas.min);
lcd_str(":");
if( akt_czas.sek < 10 ) lcd_str("0");
lcd_int(akt_czas.sek);

// co trzy sekundy wysyłaj rozkaz pomiaru do czujnika
if( 1 == (akt_czas.sek%3) ) DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );

// jedną sekundę po rozkazie konwersji
// dokonuj odczytu i wyświetlania temperatury
if( 2 == (akt_czas.sek%3) )
{
// wyświetlamy temperaturę "zewnętrzną" lub '-----'
if( DS18X20_OK == DS18X20_read_meas(ustawienia.tz_sensor, &subzero, &cel, &cel_fract_bits) )
{
display_temp(0, 10);
}
else
{
lcd_locate(0,10);
lcd_str("-----");
}
// wyświetlamy temperaturę "wewnętrzną" lub '-----'
if( DS18X20_OK == DS18X20_read_meas(ustawienia.tw_sensor, &subzero, &cel, &cel_fract_bits) )
{
display_temp(1, 10);
}
else
{
lcd_locate(1,10);
lcd_str("-----");
}
}
}

// budzik jest aktywny
if (ustawienia.jest_budzik)
{
if (!jestem_w_menu)
{
lcd_locate(1,1);
lcd_str ("BUDZIK");
}

//wyliczamy aktualny czas do liczby
czas_aktualny = (akt_czas.godz * 60) + akt_czas.min;
// wyliczamy czas włączenia budzika do liczby
czas_wl_budzika = (ustawienia.budzik_godz.godz * 60) + ustawienia.budzik_godz.min;

// i porónujemy liczby
// jeżeli nam pasują czasy to włączmy budzik
if ((czas_aktualny >= czas_wl_budzika) && (czas_aktualny < (czas_wl_budzika + BUDZIK_CZAS)))
{
LCD_LED_TOG; // pomrygajmy sobie co 1s wyświetlaczem
if (ustawienia.beep)
{
BEEP_TOG; // i możemy dodatkowo poudawac że jesteśmy muzykalni...
}
}
}

int0_flag=0;
}
}
}

//*******************************************************************************************
// main (void) - KONIEC
//*******************************************************************************************

// 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);
}

//--------------------------------------------------------
// Sprawdza czy klawisz jest wcisniety
//--------------------------------------------------------
uint8_t klawisz_wcisniety(uint8_t klawisz)
{
if (!(PINC & klawisz)) // czy klawisz został wciśnięty ?
{
_delay_ms(120); // odczekajmy trochę
if(!(PINC & klawisz)) // i ponownie zobaczmy czy nadal jest wcisniety
{
// if (ustawienia.beep) // tu pikała dodatkowo klawiatura
// { // po naciśnięciu przycisku
// BEEP_ON; // ale powodowało to problemy z obsługą
// _delay_ms(30);
// BEEP_OFF;
// }

if (ustawienia.czas_wygaszacza) // jeżeli jest ustawiony czas wygaszenia wyświetlacza
{ // to po wciśnięciu przyciku
czas_wygaszenia = 0; // po prostu go zerujemy aby biegł od początku
}
return 1; // jednak jest wcisniety, to konczymy i zwracamy 1
}
}
return 0; // skoro nie jest wcisniety to zwracamy 0
}

//--------------------------------------------------------
// Wyswietla pozycje menu glownego
//--------------------------------------------------------
void disp_opt(int8_t item)
{
lcd_cls(); // czyscimy lcd
lcd_locate(0,0); // ustawiamy kursor

lcd_str_E(&menu_opt[item][0]); // to wypisz podaną pozycję menu
}

//--------------------------------------------------------
// funkcja odpowiedzialna za
// wyświetlanie menu TAK/NIE
// parametr stan - okresla logicznie stan funkcji (TAK - 1 / NIE - 0)
//--------------------------------------------------------
void menu_disp_tak_nie (uint8_t stan)
{
if (stan) // jezeli stan==1 to jest zaznaczone TAK
{
lcd_locate(1,2); // i ladnie rysujemy napis '>TAK< NIE'
lcd_char ('>');
lcd_str ("TAK");
lcd_char ('<');
lcd_locate(1,9);
lcd_char (' ');
lcd_str ("NIE");
lcd_char (' ');
}
else // jezeli stan==0 to jest zaznaczone NIE
{
lcd_locate(1,2); // i ladnie rysujemy napis 'TAK >NIE<'
lcd_char (' ');
lcd_str ("TAK");
lcd_char (' ');
lcd_locate(1,9);
lcd_char ('>');
lcd_str ("NIE");
lcd_char ('<');
}
}

//----------------------------------------------------------
// funkcja odpowiedzialna za obsluge 1 pozycji menu
// SYGNAL DZWIEKOWY przy wciskaniu klawiszy
// wybieramy TAK - jest beep
// NIE - brak beep
//--------------------------------------------------------
void menu_func_01 ()
{
uint8_t in_function = 1; // ustawiamy flagę in_function
// okresla nam czy znajdujemy sie w funkcji do obslugi
// wybranej wczesniej pozycji menu

menu_disp_tak_nie (ustawienia.beep); // w drugiej linii wypisujemy opcje menu (TAK/NIE)

while (in_function) // petla dziala dopóki nie zatwierdzimy wybory w opcji menu
{
if (klawisz_wcisniety (KEY1_PIN)) // KEY1 zmienia stan opcji menu na przeciwny
{
if (!ustawienia.beep)
{
ustawienia.beep = 1;
}
else
{
ustawienia.beep = 0;
}
menu_disp_tak_nie (ustawienia.beep); // ponownie rysujemy menu ze zmieniona opcją
}

if (klawisz_wcisniety (KEY2_PIN)) // tym razem dla klawisza KEY2 zmieniamy
{ // stan opcji menu na przeciwny
if (!ustawienia.beep)
{
ustawienia.beep = 1;
}
else
{
ustawienia.beep = 0;
}
menu_disp_tak_nie (ustawienia.beep); // ponownie rysujemy menu ze zmieniona opcją
}

if (klawisz_wcisniety (KEY3_PIN)) // klawiszem KEY3 - zatwierdzamy wybrana opcje
{
in_function = 0; // i wychodzimy do menu glownego
// jednak zanim wyjdziemy to nalezy pamietac o zapisaniu opcji
eeprom_write_block (&ustawienia, &ee_ustawienia, sizeof(ustawienia));
}
}
}

//----------------------------------------------------------
// funkcja odpowiedzialna za narysowanie zegarka ze
// znacznikami w drugim wierszu LCD
// pozycja - okresla co zmieniamy 0 - godziny, 1 - minuty, 2 - sekundy
// akt_czas - podajemy czas jaki ma byc na wyswietlaczu
// wyswietlaj_sekundy - czy wyświetlac sekundy na LCD
//
// na wyświetlaczu otrzymamy coś takiego >gg<: mm : ss
// znaczniki > < wędrują sobie po lcd w zalezności od parametru pozycja
//----------------------------------------------------------
void menu_disp_czas (uint8_t pozycja, CZAS akt_czas, uint8_t wyswietlaj_sekundy)
{
if (pozycja == 0) // ustawiamy godzine
{ // i ladnie rysujemy >hh<: mm : ss
lcd_locate(1,0);
lcd_char ('>');
if (akt_czas.godz < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.godz);

lcd_str ("<: ");
if (akt_czas.min < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.min);

if (wyswietlaj_sekundy)
{
lcd_str (" : ");
if (akt_czas.sek < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.sek);
lcd_char (' ');
}
}

if (pozycja == 1) // ustawiamy minuty
{ // i ladnie rysujemy hh :>mm<: ss
lcd_locate(1,0);
lcd_char (' ');
if (akt_czas.godz < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.godz);
lcd_str (" :>");
if (akt_czas.min < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.min);
lcd_str ("<");

if (wyswietlaj_sekundy)
{
lcd_str (": ");
if (akt_czas.sek < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.sek);
lcd_char (' ');
}
}

if ((pozycja == 2) && wyswietlaj_sekundy) // ustawiamy sekundy
{ // i ladnie rysujemy hh : mm :>ss<
lcd_locate(1,0);
lcd_char (' ');
if (akt_czas.godz < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.godz);
lcd_str (" : ");
if (akt_czas.min < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.min);
lcd_str (" :>");
if (akt_czas.sek < 10)
{
lcd_char ('0');
}
lcd_int (akt_czas.sek);
lcd_char ('<');
}
}

//----------------------------------------------------------
// funkcja odpowiedzialna za obsluge 2 pozycji menu
// USTAW CZAS - tu chodzi o zegarek
//----------------------------------------------------------
void menu_func_02 ()
{
uint8_t in_function = 1;
uint8_t pozycja = 0; // określamy czy ustawiamy godzine = 0, minuty = 1, sekundy = 2
uint8_t bufor[4]; // zmienna pozmocnicza przy odczycie czasu z PCFa

CZAS czas_ustawiany; // czas jaki mamy ustawic :-)

TWI_read_buf( PCF8583_ADDR, 0x01, 4, bufor ); // odczytujemy czas

czas_ustawiany.sek = bcd2dec( bufor[1] );
czas_ustawiany.min = bcd2dec( bufor[2] );
czas_ustawiany.godz = bcd2dec( bufor[3] );

menu_disp_czas (pozycja, czas_ustawiany, 1); // druga linia z ustawieniami czasu

while (in_function) // jestesmy w funkcji tak dlugo dopóki nie ustawimy czasu
{
if (klawisz_wcisniety (KEY1_PIN)) // wcisniety klawisz KEY 1 - zmniejszamy wartosci
{
if (pozycja == 0) // zmniejszamy godziny
{
if (czas_ustawiany.godz == 0)
{
czas_ustawiany.godz = 23;
}
else
{
czas_ustawiany.godz = czas_ustawiany.godz - 1;
}
}

if (pozycja == 1) // zmniejszamy minuty
{
if (czas_ustawiany.min == 0)
{
czas_ustawiany.min = 59;
}
else
{
czas_ustawiany.min = czas_ustawiany.min - 1;
}
}

if (pozycja == 2) // zmniejszamy sekundy
{
if (czas_ustawiany.sek == 0)
{
czas_ustawiany.sek = 59;
}
else
{
czas_ustawiany.sek = czas_ustawiany.sek - 1;
}
}

menu_disp_czas (pozycja, czas_ustawiany, 1); // i na koniec wyswietlamy czas
}

if (klawisz_wcisniety (KEY2_PIN)) // wcisniety klawisz KEY2 - zwiekszamy wartosci
{
if (pozycja == 0) // zwiekszamy godziny
{
if (czas_ustawiany.godz == 23)
{
czas_ustawiany.godz = 0;
}
else
{
czas_ustawiany.godz = czas_ustawiany.godz + 1;
}
}

if (pozycja == 1) // zwiekszamy minuty
{
if (czas_ustawiany.min == 59)
{
czas_ustawiany.min = 0;
}
else
{
czas_ustawiany.min = czas_ustawiany.min + 1;
}
}

if (pozycja == 2) // zwiekszamy sekundy
{
if (czas_ustawiany.sek == 59)
{
czas_ustawiany.sek = 0;
}
else
{
czas_ustawiany.sek = czas_ustawiany.sek + 1;
}
}
menu_disp_czas (pozycja, czas_ustawiany, 1); // i wyswietlamy ustawiony czas
}

if (klawisz_wcisniety (KEY3_PIN)) // wcisniety klawysz KEY 3 - (enter)
{
pozycja = pozycja + 1; // zwiekszamy pozycje
// czyli pozycja = 0 - ustawiamy godzine
// pozycja = 1 - ustawiamy minuty
// pozycja = 3 - ustawiamy sekundy
menu_disp_czas (pozycja, czas_ustawiany, 1); // wyswietlamy ustawienia czasu

if (pozycja > 2) // jezeli ustawimy w zmiennej pozycja 0, 1, 2
{ // to po nastepnym nacisnieciu klawisza mozemy zapisac dane do EPROM
bufor[0] = 0; // setne części sekundy
bufor[1] = dec2bcd(czas_ustawiany.sek); // sekundy
bufor[2] = dec2bcd(czas_ustawiany.min); // minuty
bufor[3] = dec2bcd(czas_ustawiany.godz); // godziny
// zapis 4 bajtów z bufora pod adres 0x01 w pamięci RAM naszego RTC
TWI_write_buf( PCF8583_ADDR, 0x01, 4, bufor );

in_function = 0; // i mozemy zakonczyc prace funkcji
}
}
}
}

//---------------------------------------------------------
// funkcja odpowiedzialna na narysowanie drugiej linii
// na wyświetlaczu w menu wygaszacza
//---------------------------------------------------------
void menu_disp_03 (uint8_t czas)
{
lcd_locate(1,0);
lcd_str ("CZAS [s]: ");
lcd_char ('>');
if (czas < 100)
{
lcd_char ('0');
}
if (czas < 10)
{
lcd_char ('0');
}
lcd_int (czas);
lcd_str ("< ");
}

//----------------------------------------------------------
// funkcja odpowiedzialna za obsluge 3 pozycji menu
// ustawienie czasu wygaszacza
// czas do ustawienia
// od 0 - wyłączony wygaszacz
// do 180 sekund z krokiem co 10s
//----------------------------------------------------------
void menu_func_03 ()
{
uint8_t in_function = 1;

menu_disp_03 (ustawienia.czas_wygaszacza); // wyswietlamy 2 linie na lcd
while (in_function)
{
if (klawisz_wcisniety (KEY1_PIN)) // zmniejszamy czas o 10 s
{
if (ustawienia.czas_wygaszacza < 10)
{
ustawienia.czas_wygaszacza = 0;
}
else
{
ustawienia.czas_wygaszacza = ustawienia.czas_wygaszacza - 10;
}
menu_disp_03 (ustawienia.czas_wygaszacza);
}

if (klawisz_wcisniety (KEY2_PIN)) // zwiekszamy czas o 10 s
{
if (ustawienia.czas_wygaszacza >= 180)
{
ustawienia.czas_wygaszacza = 180;
}
else
{
ustawienia.czas_wygaszacza = ustawienia.czas_wygaszacza + 10;
}
menu_disp_03 (ustawienia.czas_wygaszacza);
}

if (klawisz_wcisniety (KEY3_PIN)) // kończymy pracę w tym menu
{ // i zapisujemy ustawienia w eeprom
in_function = 0;
eeprom_write_block (&ustawienia, &ee_ustawienia, sizeof(ustawienia));
}
}
}

//----------------------------------------------------------
// funkcja odpowiedzialna za obsluge 4 pozycji menu
// KONIEC
//----------------------------------------------------------
void menu_func_04 ()
{
item = 0; // zerujemy pozycje w menu aby przy nastepnym wywolaniu
// menu uruchomilo sie od poczatku
jestem_w_menu = 0; // opuszczamu menu
lcd_cls (); // czyscimy po sobie ekran
}

//----------------------------------------------------------
// obsluga menu do wyboru czujnika temperatury zewnętrznej
//----------------------------------------------------------
void menu_func_tz ()
{
uint8_t in_function = 1;
uint8_t nr_sensora = 0;
uint8_t ii;

if (czujniki_cnt)
{
menu_disp_sensor (gSensorIDs[nr_sensora]);
}
else
{
lcd_locate (1,0);
lcd_str ("BRAK CZUJNIKOW");
}

while (in_function)
{
if (klawisz_wcisniety (KEY1_PIN))
{
if (nr_sensora <= 0)
{
nr_sensora = 0;
}
else
{
nr_sensora = nr_sensora - 1;
}
menu_disp_sensor (gSensorIDs[nr_sensora]);
}

if (klawisz_wcisniety (KEY2_PIN))
{
if (nr_sensora < (czujniki_cnt-1))
{
nr_sensora = nr_sensora + 1;
}
else
{
nr_sensora = czujniki_cnt-1;
}
menu_disp_sensor (gSensorIDs[nr_sensora]);
}

if (klawisz_wcisniety (KEY3_PIN)) // kończymy pracę w tym menu
{ // i zapisujemy ustawienia w eeprom
in_function = 0;

if (czujniki_cnt)
{
for (ii=0; ii<8; ii++)
ustawienia.tz_sensor[ii] = gSensorIDs[nr_sensora][ii];

eeprom_write_block (&ustawienia, &ee_ustawienia, sizeof(ustawienia));
}
}
}
}

//----------------------------------------------------------
// obsluga menu do wyboru czujnika temperatury wewnętrznej
//----------------------------------------------------------
void menu_func_tw ()
{
uint8_t in_function = 1;
uint8_t nr_sensora = 0;
uint8_t ii;

if (czujniki_cnt)
{
menu_disp_sensor (gSensorIDs[nr_sensora]);
}
else
{
lcd_locate (1,0);
lcd_str ("BRAK CZUJNIKOW");
}

while (in_function)
{
if (klawisz_wcisniety (KEY1_PIN))
{
if (nr_sensora <= 0)
{
nr_sensora = 0;
}
else
{
nr_sensora = nr_sensora - 1;
}
menu_disp_sensor (gSensorIDs[nr_sensora]);
}

if (klawisz_wcisniety (KEY2_PIN))
{
if (nr_sensora < (czujniki_cnt-1))
{
nr_sensora = nr_sensora + 1;
}
else
{
nr_sensora = czujniki_cnt-1;
}
menu_disp_sensor (gSensorIDs[nr_sensora]);
}

if (klawisz_wcisniety (KEY3_PIN)) // kończymy pracę w tym menu
{ // i zapisujemy ustawienia w eeprom
in_function = 0;

if (czujniki_cnt)
{
for (ii=0; ii<8; ii++)
ustawienia.tw_sensor[ii] = gSensorIDs[nr_sensora][ii];

eeprom_write_block (&ustawienia, &ee_ustawienia, sizeof(ustawienia));
}
}
}
}

//----------------------------------------------------------
// UAKTYWNIENIE BUDZIKA w menu
// wybieramy TAK - budzik działa
// NIE - budzik nie działa
//--------------------------------------------------------
void menu_func_budzik_akt ()
{
uint8_t in_function = 1; // ustawiamy flagę in_function
// okresla nam czy znajdujemy sie w funkcji do obslugi
// wybranej wczesniej pozycji menu

menu_disp_tak_nie (ustawienia.jest_budzik); // w drugiej linii wypisujemy opcje menu (TAK/NIE)

while (in_function) // petla dziala dopóki nie zatwierdzimy wybory w opcji menu
{
if (klawisz_wcisniety (KEY1_PIN)) // KEY1 zmienia stan opcji menu na przeciwny
{
if (!ustawienia.jest_budzik)
{
ustawienia.jest_budzik = 1;
}
else
{
ustawienia.jest_budzik = 0;
}
menu_disp_tak_nie (ustawienia.jest_budzik); // ponownie rysujemy menu ze zmieniona opcją
}

if (klawisz_wcisniety (KEY2_PIN)) // tym razem dla klawisza KEY2 zmieniamy
{ // stan opcji menu na przeciwny
if (!ustawienia.jest_budzik)
{
ustawienia.jest_budzik = 1;
}
else
{
ustawienia.jest_budzik = 0;
}
menu_disp_tak_nie (ustawienia.jest_budzik); // ponownie rysujemy menu ze zmieniona opcją
}

if (klawisz_wcisniety (KEY3_PIN)) // klawiszem KEY3 - zatwierdzamy wybrana opcje
{
in_function = 0; // i wychodzimy do menu glownego
// jednak zanim wyjdziemy to nalezy pamietac o zapisaniu opcji
eeprom_write_block (&ustawienia, &ee_ustawienia, sizeof(ustawienia));
}
}
}

//----------------------------------------------------------
// funkcja odpowiedzialna za obsluge 2 pozycji menu
// USTAW CZAS
//----------------------------------------------------------
void menu_func_ustaw_budzik ()
{
uint8_t in_function = 1;
uint8_t pozycja = 0; // określamy czy ustawiamy godzine = 0, minuty = 1, sekundy = 2

menu_disp_czas (pozycja, ustawienia.budzik_godz, 0); // i druga linie z ustawieniami czasu

while (in_function) // jestesmy w funkcji tak dlugo dopóki nie ustawimy czasu
{
if (klawisz_wcisniety (KEY1_PIN)) // wcisniety klawisz KEY 1 - zmniejszamy wartosci
{
if (pozycja == 0) // zmniejszamy godziny
{
if (ustawienia.budzik_godz.godz == 0)
{
ustawienia.budzik_godz.godz = 23;
}
else
{
ustawienia.budzik_godz.godz = ustawienia.budzik_godz.godz - 1;
}
}

if (pozycja == 1) // zmniejszamy minuty
{
if (ustawienia.budzik_godz.min == 0)
{
ustawienia.budzik_godz.min = 59;
}
else
{
ustawienia.budzik_godz.min = ustawienia.budzik_godz.min - 1;
}
}

menu_disp_czas (pozycja, ustawienia.budzik_godz, 0); // i na koniec wyswietlamy czas
}

if (klawisz_wcisniety (KEY2_PIN)) // wcisniety klawisz KEY2 - zwiekszamy wartosci
{
if (pozycja == 0) // zwiekszamy godziny
{
if (ustawienia.budzik_godz.godz == 23)
{
ustawienia.budzik_godz.godz = 0;
}
else
{
ustawienia.budzik_godz.godz = ustawienia.budzik_godz.godz + 1;
}
}

if (pozycja == 1) // zwiekszamy minuty
{
if (ustawienia.budzik_godz.min == 59)
{
ustawienia.budzik_godz.min = 0;
}
else
{
ustawienia.budzik_godz.min = ustawienia.budzik_godz.min + 1;
}
}

menu_disp_czas (pozycja, ustawienia.budzik_godz, 0); // i wyswietlamy ustawiony czas
}

if (klawisz_wcisniety (KEY3_PIN)) // wcisniety klawysz KEY 3 - (enter)
{
pozycja = pozycja + 1; // zwiekszamy pozycje
// czyli pozycja = 0 - ustawiamy godzine
// pozycja = 1 - ustawiamy minuty

ustawienia.budzik_godz.sek = 0; // sekundy budzika ustawiamy na 0
menu_disp_czas (pozycja, ustawienia.budzik_godz, 0); // wyswietlamy ustawienia czasu

if (pozycja > 1) // jezeli ustawimy w zmiennej pozycja 0, 1, 2
{ // to po nastepnym nacisnieciu klawisza mozemy zapisac dane do EPROM
eeprom_write_block (&ustawienia, &ee_ustawienia, sizeof(ustawienia));
in_function = 0; // i mozemy zakonczyc prace funkcji
}
}
}
}

//----------------------------------------------------------
// wyświetlanie ID czujnika temperatury w hex
// bez zer wiodących jeżeli liczba < 16
//----------------------------------------------------------
void menu_disp_sensor (uint8_t poz[])
{
uint8_t i;
char string[3];

lcd_locate (1, 0);
lcd_str (" ");
lcd_locate (1, 0);
for (i=0; i<8; i++)
{
itoa(poz[i], string, 16);
lcd_str (string);
}
}

//----------------------------------------------------------
// wyświetlanie temperatury na pozycji Y,X na LCD
//----------------------------------------------------------
void display_temp(uint8_t y, uint8_t x)
{
lcd_locate(y,x);
if(subzero) lcd_str("-"); // jeśli (temp. ujemna) to wyświetl '-'
else lcd_str("+"); // jeśli (temp. dodatnia) to wyświetl '+'
lcd_int(cel); // wyświetl dziesiętne części temperatury
lcd_str("."); // wyświetl kropkę
lcd_int(cel_fract_bits); // wyświetl dziesiętne części stopnia
}[/syntax]

Statystyki: Napisane przez Jarcio — 9 wrz 2015, o 22:57