/* wyœwietlanie temperatury na pozycji X w pierwszej linii LCD */
void display_temp(uint8_t x) {
lcd_locate(0,x);
if(subzero) lcd_str("-"); /* jeœli subzero==1 wyœwietla znak minus (temp. ujemna) */
else lcd_str(" "); /* jeœli subzero==0 wyœwietl spacjê zamiast znaku minus (temp. dodatnia) */
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 */
lcd_str(" C"); /* wyœwietl znak jednostek (C - stopnie Celsiusza) */
lcd_char(0xDF);
}
main()
{
unsigned char ret;
unsigned char buf[8];
unsigned char i=0;
unsigned char l1=strlen(pass);
unsigned char l2;
lcd_init();
lcd_cmd(0x80);
lcd_string("password:"******"Invalid");
delay_ms(5000);
}
else
{
//ret=strcmp(pass,buf);
ret=my_comp(pass,buf,l2);
if(ret==0)
{
lcd_cmd(0x01);
lcd_string("Valid");
delay_ms(5000);
}
else
{
lcd_cmd(0x01);
lcd_string("Invalid");
delay_ms(5000);
}
}
}
void lcd_float(float f)
{
u16 t;
t=f;
lcd_int(t);
lcd_char('.');
f-=t;
f*=100;
t=f;
lcd_int(t);
}
/*ISR(ADC_vect)
{
if(i%5==0)
{
PORTB^=(1<<PB1);
wynik=(ADCH<<8)|ADCL;
i=0;
}
i++;
ADCSRA |= 1<<ADSC;
//ADCSRA&=~(1<<ADIF);
}
*/
int main()
{
DDRC&=~(1<<PC5); //Input
DDRB |=(1<<PB1);
lcd_init();
/*TCNT0=0;
TCCR0A |= (1<<WGM01);
TCCR0B |= (1<<CS02); //preskaler = 256
OCR0A = 10;*/ //podzial przez 10
/*ADMUX |= (1<<REFS1)|(1<<REFS0)|(1<<MUX2)|(1<<MUX0); //1,1V REF || Chan ADC5
ADCSRB|=(1<<ADTS1)|(1<<ADTS0); //Trigger: Timer0 CpMA
ADCSRA |= (1<<ADEN)|(1<<ADATE)|(1<<ADIE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //ADC Enable | Start Conv ||| Prescaler 128
*/
//ADMUX |= (1<<REFS1)|(1<<REFS0)|(1<<MUX2)|(1<<MUX0); //1,1V REF || Chan ADC5
//ADCSRA |= (1<<ADEN)|(1<<ADIE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //ADC Enable | Start Conv ||| Prescaler 128
//ADCSRA |= 1<<ADSC; //ADC On
ADMUX |=(3<<6)|(5<<0);
ADCSRA |=(1<<7)|(6<<0);
ADCSRA |= 1<<ADSC; //Start Meas
//sei();
while(1)
{
while(ADCSRA &(1<<ADSC));
wynik=(ADCH<<8)|ADCL;
lcd_locate(0,0);
lcd_int(wynik);
_delay_ms(500);
ADCSRA |= 1<<ADSC; //Start Meas
}
}
main()
{
unsigned char temp;
unsigned char a[10];
unsigned char i=0;
uart_init();
lcd_init();
do
{
temp=uart_rx();
uart_tx(temp);
a[i++]=temp;
lcd_cmd(0x01);
lcd_data(temp);
lcd_cmd(0x85);
lcd_int(temp);
lcd_cmd(0x89);
lcd_string("0x");
lcd_hex(temp);
delay_ms(1000);
}while(temp!=13);
a[--i]='\0';
lcd_cmd(0xc0);
lcd_string(a);
delay_ms(5000);
}
int main(int argc, char **argv) {
int val;
lnp_integrity_set_handler(&getdata);
ds_active(&SENSOR_2);
while(1) {
wait_event(WaitForData, 0);
switch (in) {
case 0: val = SENSOR_1; break;
case 1: val = SENSOR_2; break;
case 2: val = SENSOR_3; break;
}
lcd_int(val);
buf[0] = val/256;
buf[1] = val%256;
lnp_integrity_write(buf,2);
got = 0;
}
return 0;
}
int
main(int argc,
char **argv)
{
Battery b;
while (!shutdown_requested()) {
cputs("batt");
sleep(1);
lcd_int(b.get());
sleep(1);
}
return 0;
}
int main(void)
{
lcd_init();
init_adc();
while(1)
{
if(czujnik_dymu_ON)
{
lcd_locate(0,0);
lcd_str("WYKRYTO DYM");
}
else
{
lcd_locate(0,0);
lcd_str("BRAK DYMU ");
}
wartosc_pomiaru = pomiar(czujnik_dymu_ktory);
lcd_locate(1,0);
lcd_int(wartosc_pomiaru);
lcd_str(" ");
_delay_ms(500);
}
}
void M11_func_ustawienia_godzina(char *str)
{
static uint8_t i=0, edit=0;
static uint8_t state=0;
static uint32_t cnt=0, offset_cnt=0;
if(Flagi.flaga_lcd)
{
lcd_locate(0, 10);
lcd_char(0x7E);
lcd_str(str);
EI2C_read_buf(ADDR_EEMEM_24C64, offsetof(EXT_EEPROM_var, empty), SIZEOF (EXT_EEPROM_var, empty), (uint8_t *)str);
lcd_locate(1, 0);
lcd_str(str);
Flagi.flaga_lcd=0;
}
switch(state)
{
case 0:
state=1;
if(i>8)
i=0;
lcd_locate(0, 10);
lcd_char(0x7E);
fifo_bufor_lcd(str,i,strlen(str));
lcd_str(str);
cli();
cnt=25000;
offset_cnt=licznik;
sei();
break;
case 1:
if(cnt<=licznik-offset_cnt)
{
i++;
state=0;
}
break;
}
if (key_code == PRZYCISK_ENTER)
{
edit++;
if (edit>3)
edit=1;
Flagi.flaga_klawiatura=0;
}
else if (key_code == PRZYCISK_POWROT && Flagi.flaga_klawiatura==0)
{
edit=0;
Flagi.flaga_klawiatura=1;
ustaw_czas(&czas);
}
switch(edit)
{
case 1:
if (key_code == PRZYCISK_GORA && Flagi.flaga_klawiatura==0)
{
czas.godziny++;
if(czas.godziny>23)
czas.godziny=0;
lcd_locate(1,0);
if( czas.godziny < 10 ) lcd_char('0');
lcd_int(czas.godziny);
}
else if (key_code == PRZYCISK_DOL && Flagi.flaga_klawiatura==0)
{
czas.godziny--;
if((int8_t)czas.godziny<0)
czas.godziny=23;
lcd_locate(1,0);
if( czas.godziny < 10 ) lcd_char('0');
lcd_int(czas.godziny);
}
lcd_cursor_on();
lcd_blink_on();
lcd_locate(1,1);
break;
case 2:
if (key_code == PRZYCISK_GORA && Flagi.flaga_klawiatura==0)
{
czas.minuty++;
if(czas.minuty>59)
czas.minuty=0;
lcd_locate(1,3);
if( czas.minuty < 10 ) lcd_char('0');
lcd_int(czas.minuty);
}
else if (key_code == PRZYCISK_DOL && Flagi.flaga_klawiatura==0)
{
czas.minuty--;
if((int8_t)czas.minuty<0)
czas.minuty=59;
lcd_locate(1,3);
if( czas.minuty < 10 ) lcd_char('0');
lcd_int(czas.minuty);
}
lcd_cursor_on();
lcd_blink_on();
lcd_locate(1,4);
break;
case 3:
if (key_code == PRZYCISK_GORA && Flagi.flaga_klawiatura==0)
{
czas.sekundy++;
if(czas.sekundy>59)
czas.sekundy=0;
lcd_locate(1,6);
if( czas.sekundy < 10 ) lcd_char('0');
lcd_int(czas.sekundy);
}
else if (key_code == PRZYCISK_DOL && Flagi.flaga_klawiatura==0)
{
czas.sekundy--;
if((int8_t)czas.sekundy<0)
czas.sekundy=59;
lcd_locate(1,6);
if( czas.sekundy < 10 ) lcd_char('0');
lcd_int(czas.sekundy);
}
lcd_cursor_on();
lcd_blink_on();
lcd_locate(1,7);
break;
default:
lcd_cursor_off();
lcd_blink_off();
if(Flagi.flaga_rtc)
{
pobierz_czas(&czas);
Flagi.flaga_rtc=0;
}
lcd_locate(1,0);
if( czas.godziny < 10 ) lcd_char('0');
lcd_int(czas.godziny);
lcd_char(':');
if( czas.minuty < 10 ) lcd_char('0');
lcd_int(czas.minuty);
lcd_char(':');
if( czas.sekundy < 10 ) lcd_char('0');
lcd_int(czas.sekundy);
break;
}
}
void M0(char *str)
{
static uint8_t state=0, term_state=0, i=0;
static uint32_t cnt=0, offset_cnt=0;
static char buf[41], buf_lcd[9];
if(Flagi.flaga_lcd)
{
lcd_locate(0, 0);
lcd_str(str);
lcd_locate(1, 0);
lcd_str(str);
Flagi.flaga_lcd=0;
}
if (Flagi.flaga_term)
{
switch(term_state)
{
case 0:
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
term_state=1;
break;
case 1:
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
else {
lcd_locate(0,0);
lcd_str("term. error "); /* wyœwietlamy informacjê o b³êdzie jeœli np brak czujnika lub b³¹d odczytu */
}
term_state=0;
break;
}
Flagi.flaga_term=0;
}
if(Flagi.flaga_rtc)
{
pobierz_czas(&czas);
pobierz_date(&data);
Flagi.flaga_rtc=0;
}
lcd_locate(1,0);
if( czas.godziny < 10 ) lcd_char('0');
lcd_int(czas.godziny);
lcd_char(':');
if( czas.minuty < 10 ) lcd_char('0');
lcd_int(czas.minuty);
lcd_char(':');
if( czas.sekundy < 10 ) lcd_char('0');
lcd_int(czas.sekundy);
switch(state)
{
case 0:
state=1;
if(i>= 2*strlen(buf))
i=0;
lcd_wyswietl_date(&data, buf, 0);
fifo_bufor_lcd(buf, i, strlen(buf));
lcd_locate(1,8);
strncpy(buf_lcd,buf,sizeof(buf_lcd)-1);
lcd_str(buf_lcd);
cli();
cnt=25000;
offset_cnt=licznik;
sei();
break;
case 1:
if(cnt<=licznik-offset_cnt)
{
i++;
state=0;
}
break;
}
}
void move()
{
int i;
/*variable to use in figuring out the "best" option*/
int max_q_score = 0;
/*what do we do next? store it here*/
/*we init to -1 as an error*/
int next_movement = -1;
/*Where we started.*/
/*We don't use ROTATION_2 all the way through in case it changes.*/
int initial_angle = norm_rotation(ROTATION_2);
/*Where we ended up.*/
int new_angle;
/*Show the current angle*/
cputc_native_user(CHAR_A, CHAR_N, CHAR_G, CHAR_L); // ANGL
msleep(200);
lcd_int(initial_angle);
msleep(500);
/*
* Most of the time, we do the "correct" thing
* by finding the best q_score of our possible options.
* On the off chance that norm_random() is low (or EPSILON is high ;)
* we then "explore" by choosing a random movement.
*/
if(norm_random() > EPSILON_CURRENT)
{
/*We are doing what the table tells us to.*/
cputc_native_user(CHAR_r, CHAR_e, CHAR_a, CHAR_l); // real
msleep(500);
for(i=0; i<MOVEMENTS; i++)
{
if(q_score[initial_angle][i] > max_q_score)
{
max_q_score = q_score[initial_angle][i];
next_movement = i;
}
}
}
else
{
double temp;
/*We are just picking something at random.*/
cputc_native_user(CHAR_r, CHAR_a, CHAR_n, CHAR_d); // rand
msleep(500);
/*pick one. Any one.*/
temp = norm_random();
next_movement = temp*MOVEMENTS;
/*show what we do next*/
lcd_int(next_movement);
sleep(1);
}
/*what happens if next_movement never gets changed?*/
/*we'd hate to do HARD_LEFT over and over again*/
/*so we choose randomly*/
if(-1==next_movement)
{
double temp;
temp = norm_random();
next_movement = temp*MOVEMENTS;
}
/*having chosen a movement, lets do it*/
switch(next_movement)
{
case HARD_LEFT:
cputc_native_user(CHAR_H, CHAR_L, 0, 0); // HL
hard_left();
break;
case SOFT_LEFT:
cputc_native_user(CHAR_S, CHAR_L, 0, 0); // SL
soft_left();
break;
case FORWARD:
cputc_native_user(CHAR_F, CHAR_W, CHAR_W, CHAR_D); // FWD
go_forward();
break;
case SOFT_RIGHT:
cputc_native_user(CHAR_S, CHAR_R, 0, 0); // SR
soft_right();
break;
case HARD_RIGHT:
cputc_native_user(CHAR_H, CHAR_R, 0, 0); // HR
hard_right();
break;
case REVERSE:
cputc_native_user(CHAR_R, CHAR_E, CHAR_V, 0); // REV
go_back();
break;
default:
/*this is an error and should never be reached*/
cputc_native_user(CHAR_E, CHAR_R, CHAR_R, 0); // ERR
stop_motors();
sleep(1);
break;
}
/*Once we've started, we'd better stop*/
stop_motors();
/*Allows us to read direction*/
msleep(500);
/*This is here just to make the next function cleaner*/
new_angle = norm_rotation(ROTATION_2);
/*Where are we now?*/
cputc_native_user(CHAR_N, CHAR_E, CHAR_W, CHAR_W); // NEW
msleep(200);
lcd_int(new_angle);
msleep(500);
/*
* Since we know that "next_movement" took us from "initial_angle"
* to new_angle (ROTATION_2), we store that increased probability.
*/
steering_results[initial_angle][next_movement][new_angle] += ALPHA;
/*here we re-norm so that the sum of the probabilities is still 1*/
for(i=0; i<ANGLES; i++)
{
steering_results[initial_angle][next_movement][i] /= (1+ALPHA);
}
/*The last thing we do is reduce Epsilon*/
if(EPSILON_CURRENT > EPSILON_MIN)
{
EPSILON_CURRENT-=EPSILON_DECAY;
}
}
int main()
{
int x,y,z;
adc_init();
uart_init();
lcd_init(); delay(100);
lcd_char('a');
while(1)
{ cmd(0x01); // Clear LCD
AD0CR = 0x01200600; // ADC Stop, select Channel 0
//AD0CR |= 0x01000000; // Start ADC, Channel 0
x = read_adc();
cmd(0x80);
lcd_int(x);
uart_tx_num(x);
uart_tx_char(' ');
AD0CR = 0x01200602;
//AD0CR |= 0x01000000; // Start ADC, Channel 0
y = read_adc();
cmd(0x85);
lcd_int(y);
uart_tx_num(y);
uart_tx_char(' ');
AD0CR = 0x01200604;
//AD0CR |= 0x01000000; // Start ADC, Channel 0
z = read_adc();
cmd(0x8A);
lcd_int(z);
uart_tx_num(z);
uart_tx_str("\r");
if(x>600 )
{
cmd(0x01);
lcd_str("ALERT x = ");
uart_tx_str("\nAlert x");
cmd(0xc0);
lcd_int(x);
delay(1000);
cmd(0x01);
}
if(y<300 )
{
cmd(0x01);
lcd_str("ALERT y = ");
uart_tx_str("\nAlert y");
cmd(0xc0);
lcd_int(y);
delay(1000);
cmd(0x01);
}
delay(100);
}
}
void menu_update() {
// czas pobrany z RTC
time_t time;
unsigned char n;
// czyœæ ekran przed aktualizacj¹ menu
if ( menu_updated ) {
lcd_clear();
}
// rysuj g³ówne menu
lcd_xy(0,0); lcd_char(lcd_larrow);
lcd_xy(15,0); lcd_char(lcd_rarrow);
lcd_xy(2,0);
// ogranicz
if (menu_pos == 0xff) {
menu_pos = MENU_POS_COUNT - 1;
}
else if(menu_pos >= MENU_POS_COUNT) {
menu_pos = 0;
}
// wybierz g³ówne menu
switch(menu_pos) {
// czas i trzy temperatury
//
case 0:
// pobierz czas ...
ds1306_time_get(&time);
// ... i poka¿
lcd_xy(1,0);
lcd_int2(time.tm_hour); lcd_char(uptime%2 ? ':' : ' '); lcd_int2(time.tm_min);
lcd_char(' ');//lcd_text_P(PSTR(" 20"));
lcd_int2(time.tm_year);lcd_char('/');lcd_int2(time.tm_mon);lcd_char('/');lcd_int2(time.tm_mday);
// ogranicz podmenu do liczby czujników
if (menu_sub_pos == 0xff) {
menu_sub_pos = 0;
}
else if ( (menu_sub_pos > ds_devices_count-3) && (ds_devices_count > 3) ) {
menu_sub_pos = ds_devices_count-3;
}
// poka¿ temperatury
lcd_xy(1,1);
for (n=0; n<ds_devices_count && n<3; n++) {
lcd_int2(abs(ds_temp[menu_sub_pos + n])/10); lcd_char('.'); lcd_char('0' + (abs(ds_temp[menu_sub_pos + n])%10)); lcd_char(' ');
}
// strza³ki
lcd_xy(0,1); lcd_char( (menu_sub_pos > 0) ? lcd_larrow : ' ');
lcd_xy(15,1); lcd_char( (menu_sub_pos < ds_devices_count-3) ? lcd_rarrow : ' ');
break;
// temperatury
//
case 1:
// poka¿ temperatury
lcd_xy(1,0);
for (n=0; n<ds_devices_count && n<3; n++) {
lcd_int2(abs(ds_temp[n])/10); lcd_char('.'); lcd_char('0' + (abs(ds_temp[n])%10)); lcd_char(n<2 ? ' ' : lcd_rarrow);
}
lcd_xy(1,1);
for (n=3; n<ds_devices_count && n<6; n++) {
lcd_int2(abs(ds_temp[n])/10); lcd_char('.'); lcd_char('0' + (abs(ds_temp[n])%10)); lcd_char(' ');
}
break;
// sieæ (IP, brama, DHCP, pakiety)
//
case 2:
lcd_text_P(PSTR("Sie\x09/")); // sieæ
// ogranicz podmenu
if (menu_sub_pos == 0xff) {
menu_sub_pos = 6;
}
else if (menu_sub_pos > 6) {
menu_sub_pos = 0;
}
lcd_xy(7,0);
switch (menu_sub_pos) {
case 0:
lcd_text_P(PSTR("IP"));
lcd_xy(2,1);
for (n=0; n<4; n++) {
lcd_int(my_net_config.my_ip[n]);
lcd_char(n<3 ? '.' : ' ');
}
break;
case 1:
lcd_text_P(PSTR("brama"));
lcd_xy(2,1);
for (n=0; n<4; n++) {
lcd_int(my_net_config.gate_ip[n]);
lcd_char(n<3 ? '.' : ' ');
}
break;
case 2:
lcd_text_P(PSTR("DHCP"));
lcd_xy(2,1);
// DHCP
if (my_net_config.using_dhcp) {
lcd_text_P(PSTR("u\x0fywane"));
}
else {
lcd_text_P(PSTR("nie"));
}
break;
case 3:
lcd_text_P(PSTR("\x0b\x08")); lcd_text_P(PSTR("cze"));
lcd_xy(2,1);
// stan ³¹cza
if ( enc28_is_link_up() ) {
lcd_text_P(PSTR("tak"));
}
else {
lcd_text_P(PSTR("brak"));
}
break;
case 4:
lcd_text_P(PSTR("pakiety"));
lcd_xy(2,1);
lcd_text_P(PSTR("Tx: ")); lcd_int(net_ip_packet_id);
break;
case 5:
lcd_text_P(PSTR("pakiety"));
lcd_xy(2,1);
lcd_text_P(PSTR("Rx: ")); lcd_int(my_net_config.pktcnt);
break;
case 6:
lcd_text_P(PSTR("MAC"));
lcd_xy(2,1);
for (n=0; n<6; n++) {
lcd_hex(my_net_config.my_mac[n]);
}
break;
}
// strza³ki
lcd_xy(0,1); lcd_char(lcd_larrow);
lcd_xy(15,1); lcd_char(lcd_rarrow);
break;
// PID (wysterowania, nastawy, PV, SP)
//
/*
case 3:
lcd_text_P(PSTR("PID")); // PID
break;
*/
// PWM (wype³nienia)
//
case 3:
lcd_text_P(PSTR("PWM"));
// ogranicz podmenu do liczby kana³ów PWM
if (menu_sub_pos == 0xff) {
menu_sub_pos = 0;
}
else if (menu_sub_pos > PWM_CHANNELS-3) {
menu_sub_pos = PWM_CHANNELS-3;
}
// nr pokazywanych kana³ów
lcd_xy(11,0);
lcd_char('1' + menu_sub_pos);
lcd_char('-');
lcd_char('3' + menu_sub_pos);
// poka¿ wype³nienia
lcd_xy(2,1);
for (n=0; n<PWM_CHANNELS && n<3; n++) {
lcd_char('0' + pwm_get_fill(menu_sub_pos + n)/100);lcd_int2(pwm_get_fill(menu_sub_pos + n)); lcd_char(' ');
}
// strza³ki
lcd_xy(0,1); lcd_char( (menu_sub_pos > 0) ? lcd_larrow : ' ');
lcd_xy(15,1); lcd_char( (menu_sub_pos < PWM_CHANNELS-3) ? lcd_rarrow : ' ');
break;
// informacje (wersja, ENC28J60, karta pamiêci, EEPROM)
//
case 4:
lcd_text_P(PSTR("Informacje")); // sieæ
// ogranicz podmenu
if (menu_sub_pos == 0xff) {
menu_sub_pos = 6;
}
else if (menu_sub_pos > 6) {
menu_sub_pos = 0;
}
lcd_xy(2,1);
switch (menu_sub_pos) {
case 0:
lcd_text_P(PSTR(__DATE__));
break;
case 1:
lcd_text_P(PSTR("GCC " __AVR_LIBC_VERSION_STRING__));
break;
case 2:
//lcd_text_P(PSTR("Up "));
// dni
lcd_int((uptime/3600/24)); lcd_char('d');
// godziny
lcd_int2((uptime/3600)%24); lcd_char(':');
// minuty
lcd_int2((uptime/60)%60); lcd_char(':');
// sekundy
lcd_int2((uptime%60));
break;
case 3:
lcd_text_P(PSTR("ENC28 rev.B"));
lcd_char('0' + enc28_read_rev_id());
break;
case 4:
lcd_text_P(PSTR("Czujnik\x0dw: "));
lcd_int(ds_devices_count);
break;
case 5:
lcd_text_P(PSTR("EEPROM "));
lcd_int(eeprom_get_size() >> 10);
lcd_char('k');lcd_char('B');
break;
case 6:
if (sd_get_state() != SD_FAILED) {
lcd_text_P(sd_get_state() == SD_IS_SD ? PSTR("SD") : PSTR("MMC"));
lcd_char(' ');
lcd_int(sd_size >> 10); // kB
lcd_char('k');lcd_char('b');
}
else {
lcd_text_P(PSTR("SD/MMC: b\x0b\x08d"));
}
break;
}
int main(void) {
DDRA |= (1<<PA7);
PORTA |= (1<<PA7); // podœwietlenie wyœwietlacza LCD
// Przerwanie INT0
MCUCR |= (1<<ISC01); // wyzwalanie zboczem opadaj¹cym
GICR |= (1<<INT0); // odblokowanie przerwania
PORTD |= (1<<PD2); // podci¹gniêcie pinu INT0 do VCC
// 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..."));
// Ustawianie czasu na godzinê: 18:34:27
/*
bufor[0] = 0; // setne czêœci sekundy
bufor[1] = dec2bcd(27); // 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
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
EI2C_write_buf( _24C04_ADDR, 253, sizeof(tekst), tekst );
while(1) {
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] );
// wyœwietlenie czasu na LCD
lcd_locate(1,0);
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);
// odczyt z EEPROM
EI2C_read_buf( _24C04_ADDR, 253, sizeof(tekst), bo );
// wyœwietlenie napisu z EEPROM na LCD
lcd_locate(0, 9);
lcd_str( (char*)bo );
int0_flag=0;
}
}
}
