Re: Zawieszanie sie programu

2015-05-24T14:03:35+01:00

Odkryłem ze za zawieszanie programu odpowiedzialna jest funkcja

Źle zamieszczony listing - Różowo-zielony J.

Moje pytanie czy dochodzi tu do przepełnienia stosu używam tu zmiennych typu static. Jak obejść problem by nadal mieć możliwość uśredniania pomiarów.

Statystyki: Napisane przez MirekP — 24 maja 2015, o 14:03

Re: Zawieszanie sie programu

2015-05-23T16:17:59+01:00

Przede wszystkim zastosuj polecany przez Mirka sposób na debugowanie programu - debuger jednodiodowy.
Ustalisz tym sposobem, gdzie program utyka zaoszczędzając multum czasu.
Jak będziesz wiedział, gdzie jest problem, rozwiążesz go sam, lub zadasz konkretne pytanie.
Kodu w takiej postaci i ilości raczej nikt nie zechce analizować, jak już wczesniej wspomniano.

Statystyki: Napisane przez jerrylu — 23 maja 2015, o 16:17

Re: Zawieszanie sie programu

2015-05-23T15:37:55+01:00

Pytanie czy zmniejszać czy zwiększać preskaler aby odmierzyć sekundę która opcja poprawi stabilność działania?

Statystyki: Napisane przez MirekP — 23 maja 2015, o 15:37

Re: Zawieszanie sie programu

2015-05-23T11:04:00+01:00

Problem nie jest z menu bo jak zakomentuje obsługę menu to i tak sie zawiesi

Statystyki: Napisane przez MirekP — 23 maja 2015, o 11:04

Re: Zawieszanie sie programu

2015-05-21T10:34:48+01:00

MirekP napisał(a):

Mam problem z programem który zawiesza mi się co jakiś czas

Przyznam szczerze, że spróbowałem rzucić okiem, ale niestety ZAWIESZAM się za każdym razem czytając ten hektar kodu. Nie dziwię się więc, że procek się zawiesza ale i też sam autor co widać.

Język C daje OGROMNE możliwości podziału projektu na logiczne bloki funkcjonalne w postaci funkcji, które można jeszcze umieszczać w różnych plikach projektu. Proponuję zacząć jednak uczyć się właśnie tego - jeśli chodzi o C ... a nie pisać takiego (proszę się nie obrazić) "potworka" .... Już to że milion linii kodu to pal pies - ale właśnie te zagnieżdżenia do tego w ramach jednego pliku ? masakra ....

Tu jednak szczerze koledze polecam Bluebooka
http://atnel.pl/mikrokontrolery-avr-jezyk-c.html

od tego warto zacząć - bo to co widać w załączniku w pierwszym poście to niestety tak jakby ktoś żywcem z Bascoma projekt przepisał

Statystyki: Napisane przez mirekk36 — 21 maja 2015, o 10:34

Re: Zawieszanie sie programu

2015-05-21T09:17:19+01:00

Właśnie, program dość nie czytelny - ale każdy ma swój styl ...
Polecam takie rozwiązanie, otóż weź sobie podłącz do pozostałych pinów (jeśli takie są) ledy, następnie w każdej z procedurek funkcji zapalaj i gaś leda po wyjściu z niej. Wtedy zobaczysz chociaż której procedurce się zawiesza... albo zamiast ledów np wypluwać na uarta znak informujący jaka procedurka czy sekcja programu działa...

Statystyki: Napisane przez xbary — 21 maja 2015, o 09:17

Zawieszanie sie programu

2015-05-20T21:55:40+01:00

Witam
Mam problem z programem który zawiesza mi się co jakiś czas, nie mam pomysłu co może być nie tak. Sprzętowo raczej jest wszystko ok bo inny prostszy program chodzi bez zażutu testowany 2 dni a ten poniżej przedstawiony co jkąś godzine ew 2 sie zawiesza. Dodam że korzystam do obsługi wyświetlacza led z standardowej biblioteki umieszczonej w bluebooku wyk przerwania z (timera 1). w załączniku plik main. Prosze o sugestie co może być nie tak. Pozdrawiam.

[syntax=c]/*
* main.c
*
* Created on: 2015-04-07
* Autor: Mirosław Pastor
*

*
*/
#include
#include
#include
#include
#include
#include
#include "LED/d_led.h"

#include "I2C_TWI/i2c_twi.h"

#define PCF8583_ADDR 0xA2

//-----------------Flagi zgłoszenia przerwań-------------------------------------------------------
volatile uint8_t s1_flag; /* flaga tyknięcia timera co 1 sekundę */
volatile uint8_t s0_flag; /* flaga tyknięcia timera t0 */
//-------------------------------------------------------------------------------------------------
//Definicja klawiszy funkcyjnych
#define MENU_KEY (1<#define UP_KEY (1<#define DOWN_KEY (1<#define ESC_KEY (1<#define KEY_PIN PIND

//-------------------DEF ZNAKÓW MENU---------------------------------------------------------------
enum {
t = 14, t_dp, U, U_dp, H, H_dp, P, P_dp, Z, Z_dp, S, C, A, F, M, G, O, E, d
};
//-------------------------------------------------------------------------------------------------

//------------------------ADC---------------------------------------------------------------------
#define VREF_256 (1<//----------------------
uint16_t pomiar(uint8_t kanal);
//-----------------------------------
// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec);
// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd);
// Rozmiar bufora służącego do wyliczania średniej z pomiarów ADC
#define SR 8
// Pomoc przy uśrednianiu wyników z ADC
typedef struct {
uint16_t ref_adc;
uint16_t ref_v;
uint16_t vol;

} TVOL;

//uint16_t tab_pom1[3] = { 0 }, tab_pom2[3] = { 0 }, tab_pom3[3] = { 0 };
//-------------------------------------------------------------------------------------------------

//-----------------------EEPROM-------------------------------------------------------------------
// utworzenie typu u08, odpowiednika uint8_t aby kod był bardziej czytelny
typedef unsigned char u08;
typedef unsigned short u16;

#define EEMEM __attribute__((section(".eeprom")))
// odczyt danych z pamięci EEPROM
void EI2C_read_buf(u08 device, u16 subAddr, u16 len, u08 *buf);
// zapis danych do pamięci EEPROM
void EI2C_write_buf(u08 device, u16 subAddr, u16 len, u08 *buf);
//Ustawienia użytkownika
typedef struct {
uint8_t his_pp;
uint8_t his_pc;
uint8_t delta_temp_pp;
uint8_t delta_temp_pc;
uint8_t minutyPP;
uint8_t godzPP;
uint8_t minutyPC;
uint8_t godzPC;
uint8_t czas_zal_godz_PP;
uint8_t czas_zal_min_PP;
uint8_t czas_zal_godz_PC;
uint8_t czas_zal_min_PC;
} DANE;

//static uint8_t his_pp;
//static uint8_t his_pc;
//static uint8_t delta_temp_pp;
//static uint8_t delta_temp_pc;

DANE store EEMEM;
DANE user_data;

//-------------------------------------------------------------------------------------------------

//-------------------FUNKCJE POMOCNICZE------------------------------------------------------------
void show_time(uint8_t sekundy, uint8_t minuty, uint8_t godziny);
void show_mesure(uint16_t mesure);
void show_option(uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4);
void show_setings(uint8_t d1, uint8_t d2, uint8_t value);
void get_vol(uint16_t adc, TVOL * voltage);
uint8_t klawisz_wcisniety(uint8_t klawisz);
void menu(DANE dane);
//-------------------------------------------------------------------------------------------------

int main(void) {

DDRD &= ~(MENU_KEY | UP_KEY | DOWN_KEY | ESC_KEY);
PORTD |= (MENU_KEY | UP_KEY | DOWN_KEY | ESC_KEY);

d_led_init();

//-----------------------------

/* ustawienie TIMER0 dla F_CPU=1MHz */
TCCR2 |= (1 << WGM21); /* tryb CTC */
TCCR2 |= (1 << CS22) | (1 << CS21) | (1 << CS20); /* preskaler = 64 */
OCR2 = 156; /* dodatkowy podział przez 156 (rej. przepełnienia) */
TIMSK |= (1 << OCIE2); /* zezwolenie na przerwanie CompareMatch */
/* przerwanie wykonywane z częstotliwością ok 20ms (50 razy na sekundę) */

//------------------------------
ADMUX |= VREF_256; //Zewnętrzne źródło napięcia odniesienia 2,56V
//włączenie modułu ADC ustawienie preskalera na 64
ADCSRA |= (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); //64khz |(1<
TVOL adc1, adc2, adc3;
//DANE dane;

adc1.ref_adc = 90;
adc1.ref_v = 24;
adc2.ref_adc = 90;
adc2.ref_v = 24;
adc3.ref_adc = 90;
adc3.ref_v = 24;

//--------------------------------
// 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 = 0, minuty = 0, godziny = 0;
uint16_t mesure_t1, mesure_t2, mesure_t3;

sei();

// Ustawianie czasu na godzinę: 18:34:00
bufor[0] = 0; // setne części sekundy
bufor[1] = dec2bcd(00); // sekundy
bufor[2] = dec2bcd(34); // minuty
bufor[3] = dec2bcd(18); // godziny
// zapis 4 bajtów z bufora pod adres 0x01 w pamięci RAM naszego RTC
TWI_write_buf(PCF8583_ADDR, 0x01, 4, bufor);

uint8_t d1, d2, d3, d4;
uint16_t wynik1, wynik2, wynik3;

eeprom_busy_wait();
eeprom_read_block(&user_data, &store, sizeof(user_data));

///----------------------------------

///-------------------------------------

while (1) {

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

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

//wyswietlanie na LED pomiarów z kanałów 7,6,5 przetwornika A/C

mesure_t1 = (pomiar(5));
mesure_t2 = (pomiar(4));
mesure_t3 = (pomiar(7));

s1_flag = 0;
}

if (klawisz_wcisniety(MENU_KEY))
menu(user_data);

get_vol(mesure_t1, &adc1);
get_vol(mesure_t2, &adc2);
get_vol(mesure_t3, &adc3);

wynik1 = adc1.vol;
wynik2 = adc2.vol;
wynik3 = adc3.vol;

if ((sekundy >= 0) && (sekundy < 15)) {

show_time(sekundy, minuty, godziny);

}

else if ((sekundy >= 15) && (sekundy < 30)) {

cy1 = 14;
cy2 = 12;
d3 = (wynik2) / 10;
if (d3)
cy3 = d3;
else
cy3 = 0;
d4 = (wynik2 - (d3 * 10));
if (d4)
cy4 = d4;
else
cy4 = 0;

} else if ((sekundy >= 30) && (sekundy < 45)) {
cy1 = 14;
cy2 = 13;
d3 = (wynik3) / 10;
if (d3)
cy3 = d3;
else
cy3 = 0;
d4 = (wynik3 - (d3 * 10));
if (d4)
cy4 = d4;
else
cy4 = 0;
} else if ((sekundy >= 45) && (sekundy < 60)) {

cy1 = 14;
cy2 = 11;
d3 = (wynik1) / 10;
if (d3)
cy3 = d3;
else
cy3 = 0;
d4 = (wynik1 - (d3 * 10));
if (d4)
cy4 = d4;
else
cy4 = 0;
}

};

}
//------------FUNKCJE-POMOCNICZE-----------------------------
//-----------------------------------------------------------

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

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

while (len--) {
TWI_start();
TWI_write(device | ((subAddr >> 8) << 1));
TWI_write(subAddr);
TWI_start();
TWI_write(device + 1);
*buf++ = TWI_read(NACK);
TWI_stop();
subAddr++;
}

}

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

while (len--) {
TWI_start();
// ustawienie 9 bitu adresu pamięci EEPROM w ramach
// sprzętowego adresu urządzenia na pozycji bitu 1 (nr.2)
TWI_write(device | ((subAddr >> 8) << 1));
TWI_write(subAddr);

TWI_write(*buf++);

TWI_stop();
_delay_ms(5); // oczekiwanie na zapis
subAddr++;
}
}
//--------------------------------------------
uint16_t pomiar(uint8_t kanal) {
//ustawienie wybranego kanalu w rejestrze ADMUX
ADMUX = (ADMUX & 0xF8) | kanal;
//start pomiaru przez ustawienie bitu ADSC w rejestrze ADCSR
ADCSRA |= (1 << ADSC);
//oczekiwanie na koniec pomiaru dopuki bit ADSC jest =1
while (ADCSRA & (1 << ADSC))
;
//po zakończeniu pomiaru gdy bit ADSC =0 zwrucenie wyniku
// w postaci 16 bitowej wartosci z rejestrów ADCH oraz ADCL
return ADCW;
}
//----------------------WEKTORY-PRZERWAŃ-------------------------
//---------------------------------------------------------------

// procedura obsługi przerwania od timera 2
ISR(TIMER2_COMP_vect)
{
static uint8_t cnt = 0; /* statyczna zmienna cnt do odliczania setnych ms */

if (++cnt > 50) { /* gdy licznik ms > 99 (minęła 1 sekunda) */
s1_flag = 1; /* ustaw flagę tyknięcia sekundy */
cnt = 0; /* wyzeru licznik setnych ms */
}
}
// srednia ciągnięta z pomiarów ADC
void get_vol(uint16_t adc, TVOL * voltage) {
static uint16_t sr[SR];
static uint8_t idx;
uint32_t sr1 = 0;
uint8_t i;

sr[idx] = adc;
idx++;
if (idx > 7)
idx = 0;

for (i = 0; i < SR; i++)
sr1 += sr[i];
sr1 /= SR;
uint16_t wynik = (sr1 * (uint32_t) voltage->ref_v) / voltage->ref_adc;
voltage->vol = wynik;

}
//---------------------------------------------------------------------

void show_time(uint8_t sekundy, uint8_t minuty, uint8_t godziny) {

uint8_t d1, d2, d3, d4;
d1 = godziny / 10;
if (d1)
cy1 = d1;
else
cy1 = 0;
d2 = godziny % 10;
if (d2)
cy2 = d2;
else
cy2 = 0;
d3 = minuty / 10;
if (d3)
cy3 = d3;
else
cy3 = 0;
d4 = minuty % 10;
if (d4)
cy4 = d4;
else
cy4 = 0;
}

void show_mesure(uint16_t mesure) {
uint16_t d3, d4;
d3 = mesure / 10;
if (d3)
cy3 = d3;
else
cy3 = 0;
d4 = mesure % 10;
if (d4)
cy4 = d4;
else
cy4 = 0;
}
void show_setings(uint8_t d1, uint8_t d2, uint8_t value) {

uint16_t d3, d4;

if (d1)
cy1 = d1;
else
cy1 = 10;
if (d2)
cy2 = d2;
else
cy2 = 10;

d3 = value / 10;
if (d3)
cy3 = d3;
else
cy3 = 0;
d4 = value % 10;
if (d4)
cy4 = d4;
else
cy4 = 0;
}
void show_option(uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4) {

if (d1)
cy1 = d1;
else
cy1 = 10;
if (d2)
cy2 = d2;
else
cy2 = 10;
if (d3)
cy3 = d3;
else
cy3 = 10;
if (d4)
cy4 = d4;
else
cy4 = 10;
}

uint8_t klawisz_wcisniety(uint8_t klawisz) {
if (!(KEY_PIN & klawisz)) // klawisz wcisnięty?
{
_delay_ms(30); // czas drgania styków
if ((KEY_PIN & klawisz))
return 1; //jesli tak zwróć 1
}
return 0; //jesli nie to 0
}

void menu(DANE dane) {

TIMSK &= ~(1 << OCIE2);

show_option(10, 10, 10, 10);
uint8_t opcion = 1;
uint8_t bufor[4]; // rezerwacja bufora 4 bajty
uint8_t sekundy = 0, minuty = 0, godziny = 0;
//-----------------------do struktury-------------------------------------
//------------------------------------------------------------------------

do {
if (klawisz_wcisniety(DOWN_KEY)) {
opcion--;
}
if (klawisz_wcisniety(UP_KEY)) {
opcion++;
}
if (opcion >= 5)
opcion = 5; //jezeli przekroczono wyznaczoną liczbe opcji zatrzymaj sie na ostatniej
if (opcion <= 1)
opcion = 1;

switch (opcion) { //reakcja na nacisniete klawisze

case 1:
show_option(C, Z, A, S);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{

show_time(sekundy, minuty, godziny);

while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
godziny = godziny + 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
minuty = minuty + 1;
}
if (godziny > 24)
godziny = 0;
if (minuty > 60)
minuty = 0;

show_time(sekundy, minuty, godziny);

bufor[0] = 0;
bufor[1] = dec2bcd(00); // sekundy
bufor[2] = dec2bcd(minuty); // minuty
bufor[3] = dec2bcd(godziny); // godziny
};
// zapis 4 bajtów z bufora pod adres 0x01 w pamięci RAM naszego RTC
TWI_write_buf(PCF8583_ADDR, 0x01, 4, bufor);
}
break;
case 2:
show_option(H, 1, S, 10);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
uint8_t option_his = 1;
do {
if (klawisz_wcisniety(DOWN_KEY)) {
option_his--;
}
if (klawisz_wcisniety(UP_KEY)) {
option_his++;
}
if (option_his >= 2)
option_his = 2; //jezeli przekroczono wyznaczoną liczbe opcji zatrzymaj sie na ostatniej
if (option_his <= 1)
option_his = 1;
switch (option_his) {
case 1:
show_option(H, Z, P, P);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.his_pp = user_data.his_pp + 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.his_pp = user_data.his_pp - 1;
}
if (user_data.his_pp >= 10)
user_data.his_pp = 10;

if (user_data.his_pp <= 1)
user_data.his_pp = 1;

show_setings(P, P, user_data.his_pp);
}

}
break;
case 2:
show_option(H, Z, P, C);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.his_pc = user_data.his_pc + 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.his_pc = user_data.his_pc - 1;
}
if (user_data.his_pc >= 10)
user_data.his_pc = 10;

if (user_data.his_pc <= 1)
user_data.his_pc = 1;

show_setings(P, C, user_data.his_pc);
}

}
break;
}

} while (!klawisz_wcisniety(ESC_KEY)); //jezeli nacisnięty klawisz ESCAPE zakończ
}
break;
case 3:
show_option(P_dp, Z_dp, C, Z_dp);
//-----------------------------------
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
uint8_t option_zal_czas = 1;
do {
if (klawisz_wcisniety(DOWN_KEY)) {
option_zal_czas--;
}
if (klawisz_wcisniety(UP_KEY)) {
option_zal_czas++;
}
if (option_zal_czas >= 2)
option_zal_czas = 2; //jezeli przekroczono wyznaczoną liczbe opcji zatrzymaj sie na ostatniej
if (option_zal_czas <= 1)
option_zal_czas = 1;
switch (option_zal_czas) {
case 1:
show_option(P, P, 10, 10);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
uint8_t option_czasPP = 1;
do {
if (klawisz_wcisniety(DOWN_KEY)) {
option_czasPP--;
}
if (klawisz_wcisniety(UP_KEY)) {
option_czasPP++;
}
if (option_czasPP >= 2)
option_czasPP = 2; //jezeli przekroczono wyznaczoną liczbe opcji zatrzymaj sie na ostatniej
if (option_czasPP <= 1)
option_czasPP = 1;
switch (option_czasPP) {
case 1:
show_option(G, O, d, Z);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{

show_time(0, user_data.minutyPP,
user_data.godzPP);

while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.godzPP
= user_data.godzPP + 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.minutyPP
= user_data.minutyPP
+ 1;
}
if (user_data.godzPP > 24)
user_data.godzPP = 0;
if (user_data.minutyPP > 60)
user_data.minutyPP = 0;

show_time(0, user_data.minutyPP,
user_data.godzPP);
};
}
break;
case 2:
show_option(C, Z, A, S);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{

show_time(0, user_data.czas_zal_min_PP,
user_data.czas_zal_godz_PP);

while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.czas_zal_godz_PP
= user_data.czas_zal_godz_PP
+ 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.czas_zal_min_PP
= user_data.czas_zal_min_PP
+ 1;
}
if (user_data.czas_zal_godz_PP > 5)
user_data.czas_zal_godz_PP = 0;
if (user_data.czas_zal_min_PP > 60)
user_data.czas_zal_min_PP = 0;

show_time(0,
user_data.czas_zal_min_PP,
user_data.czas_zal_godz_PP);
};
}
break;
}

} while (!klawisz_wcisniety(ESC_KEY)); //jezeli nacisnięty klawisz ESCAPE zakończ
}
break;
case 2:
show_option(P, C, 10, 10);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
uint8_t option_czasPC = 1;
do {
if (klawisz_wcisniety(DOWN_KEY)) {
option_czasPC--;
}
if (klawisz_wcisniety(UP_KEY)) {
option_czasPC++;
}
if (option_czasPC >= 2)
option_czasPC = 2; //jezeli przekroczono wyznaczoną liczbe opcji zatrzymaj sie na ostatniej
if (option_czasPC <= 1)
option_czasPC = 1;
switch (option_czasPC) {
case 1:
show_option(G, O, d, Z);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{

show_time(0, user_data.minutyPC,
user_data.godzPC);

while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.godzPC
= user_data.godzPC + 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.minutyPC
= user_data.minutyPC
+ 1;
}
if (user_data.godzPC > 24)
user_data.godzPC = 0;
if (user_data.minutyPC > 60)
user_data.minutyPC = 0;

show_time(0, user_data.minutyPC,
user_data.godzPC);
};
}
break;
case 2:
show_option(C, Z, A, S);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{

show_time(0, user_data.czas_zal_min_PC,
user_data.czas_zal_godz_PC);

while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.czas_zal_godz_PC
= user_data.czas_zal_godz_PC
+ 1;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.czas_zal_min_PC
= user_data.czas_zal_min_PC
+ 1;
}
if (user_data.czas_zal_godz_PC > 5)
user_data.czas_zal_godz_PC = 0;
if (user_data.czas_zal_min_PC > 60)
user_data.czas_zal_min_PC = 0;

show_time(0,
user_data.czas_zal_min_PC,
user_data.czas_zal_godz_PC);
};
}
break;
}

} while (!klawisz_wcisniety(ESC_KEY)); //jezeli nacisnięty klawisz ESCAPE zakończ
}
break;
}

} while (!klawisz_wcisniety(ESC_KEY)); //jezeli nacisnięty klawisz ESCAPE zakończ
}
//-----------------------------------------
break;
case 4:
show_option(t, E, M, P);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
uint8_t option_delta_temp = 1;
do {
if (klawisz_wcisniety(DOWN_KEY)) {
option_delta_temp--;
}
if (klawisz_wcisniety(UP_KEY)) {
option_delta_temp++;
}
if (option_delta_temp >= 2)
option_delta_temp = 2; //jezeli przekroczono wyznaczoną liczbe opcji zatrzymaj sie na ostatniej
if (option_delta_temp <= 1)
option_delta_temp = 1;
switch (option_delta_temp) {
case 1:
show_option(t_dp, Z_dp, P, P);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.delta_temp_pp++;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.delta_temp_pp--;
}
if (user_data.delta_temp_pp >= 40)
user_data.delta_temp_pp = 40;

if (user_data.delta_temp_pp <= 1)
user_data.delta_temp_pp = 1;

show_setings(P, P, user_data.delta_temp_pp);
}

}
break;
case 2:
show_option(t_dp, Z_dp, P, C);
if (klawisz_wcisniety(MENU_KEY)) //edycja
{
while (!klawisz_wcisniety(ESC_KEY)) { //edycja dopóki nie naciśniemy ESC
if (klawisz_wcisniety(UP_KEY)) //zwiększenie
{
user_data.delta_temp_pc++;
}
if (klawisz_wcisniety(DOWN_KEY)) //zmniejszenie
{
user_data.delta_temp_pc--;
}
if (user_data.delta_temp_pc >= 40)
user_data.delta_temp_pc = 40;

if (user_data.delta_temp_pc <= 1)
user_data.delta_temp_pc = 1;

show_setings(P, C, user_data.delta_temp_pc);
}
}
break;
}

} while (!klawisz_wcisniety(ESC_KEY)); //jezeli nacisnięty klawisz ESCAPE zakończ
}
break;
case 5:
show_option(F, U, M, C);
break;
}

} while (!klawisz_wcisniety(ESC_KEY)); //jezeli nacisnięty klawisz ESCAPE zakończ
show_option(10, 10, 10, 10);

eeprom_busy_wait();
eeprom_write_block(&user_data, &store, sizeof(user_data));

TIMSK |= (1 << OCIE2);

}[/syntax]

Statystyki: Napisane przez MirekP — 20 maja 2015, o 21:55

ATNEL tech-forum

Re: Zawieszanie sie programu

Re: Zawieszanie sie programu

Re: Zawieszanie sie programu

Re: Zawieszanie sie programu

Re: Zawieszanie sie programu

Re: Zawieszanie sie programu

Zawieszanie sie programu