Re: Obsługa RTC dla leniwych

2013-08-08T07:27:46+01:00

Jeśli nie do końca rozumiecie np co to jest:

Paul Dirac napisał(a):

"-bed=pen+mad."[m]

to zajrzyjcie tutaj

http://mirekk36.blogspot.com/2013/08/am ... ajaca.html

Statystyki: Napisane przez mirekk36 — 8 sie 2013, o 07:27

Re: Obsługa RTC dla leniwych

2013-08-07T21:23:07+01:00

Paul Dirac napisał(a):

W sumie nie rozumiem tego fragmentu, domyslam się, że to ma przeliczyć dzień i tydzień roku
[syntax=c]y-=m<3;
uint8_t weekday;
weekday = (y+y/4-y/100+y/400+"-bed=pen+mad."[m]+d)%7;

return weekday;[/syntax]

A co do kodu, spoko.

A to z internetu jest, działa więc zostawiłem Funkcja ta oblicza dzień tygodnia

Statystyki: Napisane przez PawelGaj — 7 sie 2013, o 21:23

Re: Obsługa RTC dla leniwych

2013-08-07T21:22:23+01:00

Statystyki: Napisane przez Paul Dirac — 7 sie 2013, o 21:22

Re: Obsługa RTC dla leniwych

2013-08-07T21:03:28+01:00

Bardzo mi się podobają takie usprawnienia "dla leniwych"

Statystyki: Napisane przez mirekk36 — 7 sie 2013, o 21:03

Obsługa RTC dla leniwych

2013-08-07T20:44:32+01:00

Witam,
Ostatnio zacząłem się bawić RTC, i myśleć jakby to zautomatyzować aby wszystko się działo "w tle", było uniwersalne i wygodnie się tego używało. Starałem się również aby zajmował jak najmniej miejsca w pamięci, jednak to nie było moim głównym piorytetem. Biblioteka może działać i z LCD monochromatycznymi takimi jak HD44780 czy KS0108. Może również działać z kolorowymi, lub w ogóle bez wyświetlacza. Wszystko jest oparte na wskaźnikach do funkcji.

Inicjalizacja RTC odbywa się w następujący sposób :
[syntax=c]RTCIntInit();// Init przerwania zewnetrznego
RTCTimeStructInit(&Czas, 2, 0, 1, ':', lcd_str, lcd_locate);
RTCDataStructInit(&Czas, 0, 1, 1, '.', lcd_str, lcd_locate);

while(1)
{
RTCEvent();
}[/syntax]
Najpierw init przerwania zewnętrznego. Potem struktury RTC. Parametry są następujące. Wskaźnik na strukturę, lokalizacja na wyświetlaczu - szerokość i wysokość, separator czasu i wskaźnik do funkcji wyświetlającej tekst na wyświetlaczu i ustawianie kursora w odpowiednim miejscu. Dla kolorowego wyświetlacza jest tak samo, tylko dodane są parametry koloru tekstu i tła.

Możemy sobie również dodawać callback`i. W tej bibliotece są one rozbudowane. Nie ma jednego callbacka, zamiast jednego są cztery. Odpowiednio przed odczytem czasu, po odczycie czasu i analogicznie dla daty. Można zadawać sobie pytanie "po co ?". Przytoczę tutaj jeden przykład. Mamy sobie kolorowego LCD, wyświetlanie działa, jednak teksty z każdym odczytem daty i czasu brzydko się nakładają jeden na drugi. Tu z pomocą przychodzą callbacki przed odczytem. Wtedy rejestrujemy sobie callbacka, w funkcji callbacka czyścimy sobie fragment LCD aby nie usunąć reszty wyświetlacza i wszystko śmiga. Owszem, można dać czyszczenie tego fragmentu w pętli while, jednak wyświetliłby się ten tekst, minęła by chwila i za drugim obiegiem pętli while wszystko by się usunęło i byśmy mogli w ogóle nie zobaczyć tego tekstu .

Biblioteka również umożliwia udostępnianie czasu bibliotece FatFS

Jeszcze jedna drobniutka zaleta. Chodzi mi o funkcje RTCSaveRegister. Przy użyciu enumeratora który jest już w bibliotece możemy pięknie sobie zapisywać cokolwiek chcemy do RTC. Przykład z godziną :
[syntax=c]RTCSaveRegister(21, Godzina);[/syntax]
Niby nic, a cieszy .

Teraz kod
PCF8583.c :
[syntax=c]/*
* PCF8583.c
*
* Created on: 07-08-2013
* Author: Pawel
*/

#include
#include
#include
#include

#include "PCF8583.h"
#include "../I2C/I2C.h"

#if FAT_FS == 1
#include "rtc.h"// Tu ustawiamy lokalizacje pliku rtc.h
#endif

T_TIME *TimeStruct;

enum {x02,x03,x04,x05,x06,x07};
uint8_t Bufor[6];

volatile uint8_t RTCIntFlag;

void ParseTime(uint8_t *Val1, uint8_t *Val2, uint8_t *Val3, char *Separator, char *Output);
uint8_t Dec2Bcd(uint8_t dec);
uint8_t Bcd2Dec(uint8_t bcd);
uint8_t DniTygodnia (uint8_t m, uint8_t d, uint16_t y);
void RTCReadTime(void);

void RTCEvent(void)
{
if(RTCIntFlag)
{
RTCReadTime();
RTCIntFlag = 0;
}
}

// ###############################
// ########## CALLBACKI ##########
// ###############################
#if TIME_PRE_CALLBACK == 1
void (*RTCTimePreCallback)();

void RTCRegisterTimePreCallback(void(*Callback)())
{
RTCTimePreCallback = Callback;
}
#endif

#if TIME_POST_CALLBACK == 1
void (*RTCTimePostCallback)();

void RTCRegisterTimePostCallback(void(*Callback)())
{
RTCTimePostCallback = Callback;
}
#endif

#if DATA_PRE_CALLBACK == 1
void (*RTCDataPreCallback)();

void RTCRegisterDataPreCallback(void(*Callback)())
{
RTCDataPreCallback = Callback;
}
#endif

#if DATA_POST_CALLBACK == 1
void (*RTCDataPostCallback)();

void RTCRegisterDataPostCallback(void(*Callback)())
{
RTCDataPostCallback = Callback;
}
#endif

void RTCIntInit(void)
{
#if RTC_INT == INT0
MCUCR |= (1<GICR |= (1<PORTD |= (1<#endif

#if RTC_INT == INT1
MCUCR |= (1<GICR |= (1<PORTD |= (1<#endif

#if RTC_INT == INT2
GICR |= (1<PORTB |= (1<#endif

I2C_SetBitrate(I2C_BITRATE_KHZ);
}

#if USE_LCD == 1

#if USE_COLOR_LCD == 1

// ########## COLOR LCD ##########
void RTCTimeStructInit(T_TIME *Struct, int x, int y, uint16_t ForegroundColor, uint16_t BackgroundColor, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate))
{
Struct -> TimeX = x;
Struct -> TimeY = y;
Struct -> TimeForegroundColor= ForegroundColor;
Struct -> TimeBackgroundColor= BackgroundColor;
Struct -> TimeShow = Show;
Struct -> TimeSeparator[0] = Separator;
Struct -> TimeLcdColorLocate = LcdLocate;
Struct -> TimeLcdColorStr = LcdString;
TimeStruct = Struct;
}

void RTCDataStructInit(T_TIME *Struct, int x, int y, uint16_t ForegroundColor, uint16_t BackgroundColor, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate))
{
Struct -> DataX = x;
Struct -> DataY = y;
Struct -> DataForegroundColor= ForegroundColor;
Struct -> DataBackgroundColor= BackgroundColor;
Struct -> DataShow = Show;
Struct -> DataSeparator[0] = Separator;
Struct -> DataLcdColorLocate = LcdLocate;
Struct -> DataLcdColorStr = LcdString;
TimeStruct = Struct;
}
#endif

#if USE_COLOR_LCD == 0

// ########## MONOCHROME LCD ##########
// ########## COLOR LCD ##########
void RTCTimeStructInit(T_TIME *Struct, int x, int y, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate))
{
Struct -> TimeX = x;
Struct -> TimeY = y;
Struct -> TimeShow = Show;
Struct -> TimeSeparator[0] = Separator;
Struct -> TimeLcdLocate = LcdLocate;
Struct -> TimeLcdStr = LcdString;
TimeStruct = Struct;
}

void RTCDataStructInit(T_TIME *Struct, int x, int y, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate))
{
Struct -> DataX = x;
Struct -> DataY = y;
Struct -> DataShow = Show;
Struct -> DataSeparator[0] = Separator;
Struct -> DataLcdLocate = LcdLocate;
Struct -> DataLcdStr = LcdString;
TimeStruct = Struct;
}
#endif
#endif

#if USE_LCD == 0
// ########## NO LCD ##########
void RTCTimeStructInit(T_TIME *Struct, char Separator)
{
Struct -> TimeSeparator[0] = Separator;
TimeStruct = Struct;
}

void RTCDataStructInit(T_TIME *Struct, char Separator)
{
Struct -> DataSeparator[0] = Separator;
TimeStruct = Struct;
}
#endif

void RTCReadTime(void)
{
if(TimeStruct)// Zabezpieczenie na wypadek pustego wskaźnika
{

#if TIME_PRE_CALLBACK == 1
if(RTCTimePreCallback)RTCTimePreCallback();
#endif

I2C_read_buf( PCF8583_ADDR, 0x02, 5, Bufor );// Odczytaj czas z RTC do bufora w formacie BCD

TimeStruct -> Sekunda = Bcd2Dec(Bufor[x02]);// Odczytaj sekunde i przekonwertuj na dec
TimeStruct -> Minuta = Bcd2Dec(Bufor[x03]);
TimeStruct -> Godzina = Bcd2Dec(Bufor[x04]);
TimeStruct -> Dzien = Bcd2Dec(Bufor[x05] & 0b00111111);// Odczytaj dzien, zamaskuj odpowiednie bity i przekonwertuj na dec
TimeStruct -> Miesiac = Bcd2Dec(Bufor[x06] & 0b00011111);// Odczytaj miesiac, zamaskuj odpowiednie bity i przekonwertuj na dec
TimeStruct -> Rok = 13;
TimeStruct -> DzienTygodnia = DniTygodnia(TimeStruct -> Miesiac, TimeStruct -> Dzien, (TimeStruct -> Rok) + 2000);

// ######################################################
// ########## Przygotowywanie stringa z czasem ##########
// ######################################################

ParseTime(&TimeStruct -> Godzina, &TimeStruct -> Minuta, &TimeStruct -> Sekunda, &TimeStruct -> TimeSeparator[0], TimeStruct -> TimeString);// Przygotuj stringa z czasem
#if USE_LCD == 1
#if USE_COLOR_LCD == 1

if(TimeStruct -> TimeShow)// Jesli zmienna odpowiedzialna za pokazywanie daty == 1 to wyswietl czas na podanej lokalizacji
{
if(TimeStruct -> TimeLcdColorLocate) TimeStruct -> TimeLcdColorLocate(TimeStruct -> TimeX, TimeStruct -> TimeY);// Ustaw kursor w podanym wczesniej miejscu
if(TimeStruct -> TimeLcdColorStr) TimeStruct -> TimeLcdColorStr(TimeStruct -> TimeString, TimeStruct -> TimeForegroundColor, TimeStruct -> TimeBackgroundColor);// I wyswietl string z data na wyswietlaczu
}

#endif

#if USE_COLOR_LCD == 0

if(TimeStruct -> TimeShow)// Jesli zmienna odpowiedzialna za pokazywanie daty == 1 to wyswietl Time na podanej lokalizacji
{
if(TimeStruct -> TimeLcdLocate) TimeStruct -> TimeLcdLocate(TimeStruct -> TimeX, TimeStruct -> TimeY);// Ustaw kursor w podanym wczesniej miejscu
if(TimeStruct -> TimeLcdStr) TimeStruct -> TimeLcdStr(TimeStruct -> TimeString);// I wyswietl string z data na wyswietlaczu
}

#endif
#endif

#if TIME_POST_CALLBACK == 1
if(RTCTimePostCallback)RTCTimePostCallback();
#endif

// ####################################################
// ########## Przygotowywanie stringa z data ##########
// ####################################################

#if DATA_PRE_CALLBACK == 1
if(RTCDataPreCallback)RTCDataPreCallback();
#endif

ParseTime(&TimeStruct -> Dzien, &TimeStruct -> Miesiac, &TimeStruct -> Rok, &TimeStruct -> DataSeparator[0], TimeStruct -> DataString);// Przygotuj stringa z data

#if USE_LCD == 1

#if USE_COLOR_LCD == 1
if(TimeStruct -> DataShow)// Jesli zmienna odpowiedzialna za pokazywanie daty == 1 to wyswietl Data na podanej lokalizacji
{
if(TimeStruct -> DataLcdColorLocate) TimeStruct -> DataLcdColorLocate(TimeStruct -> DataX, TimeStruct -> DataY);// Ustaw kursor w podanym wczesniej miejscu
if(TimeStruct -> DataLcdColorStr) TimeStruct -> DataLcdColorStr(TimeStruct -> DataString, TimeStruct -> DataForegroundColor, TimeStruct -> DataBackgroundColor);// I wyswietl string z data na wyswietlaczu
}
#endif

#if USE_COLOR_LCD == 0
if(TimeStruct -> DataShow)// Jesli zmienna odpowiedzialna za pokazywanie daty == 1 to wyswietl Data na podanej lokalizacji
{
if(TimeStruct -> DataLcdLocate) TimeStruct -> DataLcdLocate(TimeStruct -> DataX, TimeStruct -> DataY);// Ustaw kursor w podanym wczesniej miejscu
if(TimeStruct -> DataLcdStr) TimeStruct -> DataLcdStr(TimeStruct -> DataString);// I wyswietl string z data na wyswietlaczu
}
#endif
#endif

#if DATA_POST_CALLBACK == 1
if(RTCDataPostCallback)RTCDataPostCallback();
#endif

#if FAT_FS == 1
TimeToFatFS(TimeStruct);
#endif

}
}

void RTCSaveTime(T_TIME *Struct)
{
Bufor[x02] = Dec2Bcd(TimeStruct -> Sekunda);
Bufor[x03] = Dec2Bcd(TimeStruct -> Minuta);
Bufor[x04] = Dec2Bcd(TimeStruct -> Godzina);
Bufor[x05] = Dec2Bcd(TimeStruct -> Dzien);
Bufor[x06] = Dec2Bcd(TimeStruct -> Miesiac);

I2C_write_buf(PCF8583_ADDR, 0x02, 5, Bufor);
}

void RTCSaveRegister(uint8_t Value, T_PCF8583Reg Register)
{
uint8_t Buff;

Buff = Dec2Bcd(Value);

I2C_write_buf(PCF8583_ADDR, Register, 1, &Buff);
}

void ParseTime(uint8_t *Val1, uint8_t *Val2, uint8_t *Val3, char *Separator, char *Output)
{
char Buf[3];// Bufor dla funkcji itoa
uint8_t Wsk = 0;

for(uint8_t i = 0; i < strlen(Output); i++)
{
*Output = 0;
Output++;
Wsk++;
}

Output -= Wsk;

if(*Val1 < 10)
{
strcat(Output, "0");// To dodaj przed nia 0
itoa(*Val1, Buf, 10);// Przekonwertuj zmienna na string
strcat(Output, Buf);// I doklej na koniec parsowanego stringa
}
else
{
itoa(*Val1, Buf, 10);// Przekonwertuj zmienna na string
strcat(Output, Buf);// I doklej na koniec parsowanego stringa
}

strcat(Output, Separator);// Doklej na koniec parsowanego stringa separator

if(*Val2 < 10)
{
strcat(Output, "0");
itoa(*Val2, Buf, 10);
strcat(Output, Buf);
}
else
{
itoa(*Val2, Buf, 10);
strcat(Output, Buf);
}

strcat(Output, Separator);

if(*Val3 < 10)
{
strcat(Output, "0");
itoa(*Val3, Buf, 10);
strcat(Output, Buf);
}
else
{
itoa(*Val3, Buf, 10);
strcat(Output, Buf);
}
}

uint8_t Dec2Bcd(uint8_t dec)
{
return ((dec / 10)<<4) | (dec % 10);
}

uint8_t Bcd2Dec(uint8_t bcd)
{
return ((((bcd) >> 4) & 0x0F) * 10) + ((bcd) & 0x0F);
}

uint8_t DniTygodnia (uint8_t m, uint8_t d, uint16_t y)
{
y-=m<3;
uint8_t weekday;
weekday = (y+y/4-y/100+y/400+"-bed=pen+mad."[m]+d)%7;

return weekday;
}

#if RTC_INT == INT0
ISR( INT0_vect )
{
RTCIntFlag = 1;
}
#endif

#if RTC_INT == INT1
ISR( INT1_vect )
{
RTCIntFlag = 1;
}
#endif

#if RTC_INT == INT2
ISR( INT2_vect )
{
RTCIntFlag = 1;
}
#endif

#if FAT_FS == 1

void TimeToFatFS(T_TIME *Struktura)
{
rtc.year = 2000 + (Struktura -> Rok);
rtc.month = Struktura -> Miesiac;
rtc.mday = Struktura -> Dzien;
rtc.hour = Struktura -> Godzina;
rtc.min = Struktura -> Minuta;
rtc.sec = Struktura -> Sekunda;
}

#endif[/syntax]

PCF8583.h :
[syntax=c]/*
* PCF8583.h
*
* Created on: 07-08-2013
* Author: Pawel
*/

#ifndef PCF8583_H_
#define PCF8583_H_

#define USE_LCD 1
#define USE_COLOR_LCD 0

#define TIME_PRE_CALLBACK0
#define TIME_POST_CALLBACK0

#define DATA_PRE_CALLBACK0
#define DATA_POST_CALLBACK0

#define PCF8583_ADDR 0xA2
#define I2C_BITRATE_KHZ 100
#define RTC_INT INT0// Wybor przerwania (INT0, INT1, INT2)

#define FAT_FS 0

typedef enum { Sekunda = 0x02, Minuta, Godzina, Dzien, Miesiac } T_PCF8583Reg;

typedef struct TIME T_TIME;
struct TIME {
uint8_t Sekunda;
uint8_t Minuta;
uint8_t Godzina;
uint8_t Dzien;
uint8_t Miesiac;
uint8_t Rok;
uint8_t DzienTygodnia;

char TimeString[9];// Aktualny czas w formie stringa
char TimeSeparator[2];// Separator między jednostkami, np : albo .

#if USE_LCD == 1
uint8_tTimeShow:1;// Zmienna decydujaca o wyswietlaniu Timeu na wyswietlaczu (1 - Nie wyswietla, 0 - Wyswietla)
intTimeX;
intTimeY;
#if USE_COLOR_LCD == 1
uint16_t TimeForegroundColor;
uint16_t TimeBackgroundColor;
void(*TimeLcdColorStr)(char *Bufor, uint16_t ForegroundColor, uint16_t BackgroundColor);
void(*TimeLcdColorLocate)(int x, int y);
#endif
#if USE_COLOR_LCD == 0
void(*TimeLcdStr)(char *Bufor);
void(*TimeLcdLocate)(int x, int y);
#endif
#endif

char DataString[9];
char DataSeparator[2];
#if USE_LCD == 1
uint8_tDataShow:1;
intDataX;
intDataY;
#if USE_COLOR_LCD == 1
uint16_t DataForegroundColor;
uint16_t DataBackgroundColor;
void(*DataLcdColorStr)(char *Bufor, uint16_t ForegroundColor, uint16_t BackgroundColor);
void(*DataLcdColorLocate)(int x, int y);
#endif
#if USE_COLOR_LCD == 0
void(*DataLcdStr)(char *Bufor);
void(*DataLcdLocate)(int x, int y);
#endif
#endif
};

#if USE_LCD == 1

#if USE_COLOR_LCD == 1

// ########## COLOR LCD ##########
void RTCTimeStructInit(T_TIME *Struct, int x, int y, uint16_t ForegroundColor, uint16_t BackgroundColor, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate));
void RTCDataStructInit(T_TIME *Struct, int x, int y, uint16_t ForegroundColor, uint16_t BackgroundColor, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate));
#endif

#if USE_COLOR_LCD == 0

// ########## MONOCHROME LCD ##########
void RTCTimeStructInit(T_TIME *Struct, int x, int y, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate));
void RTCDataStructInit(T_TIME *Struct, int x, int y, uint8_t Show, char Separator, void(*LcdString), void(*LcdLocate));
#endif
#endif

#if USE_LCD == 0
void RTCTimeStructInit(T_TIME *Struct, char Separator);
void RTCDataStructInit(T_TIME *Struct, char Separator);
#endif

#if TIME_PRE_CALLBACK == 1
void RTCRegisterTimePreCallback(void(*Callback)());
#endif

#if TIME_POST_CALLBACK == 1
void RTCRegisterTimePostCallback(void(*Callback)());
#endif

#if DATA_PRE_CALLBACK == 1
void RTCRegisterDataPreCallback(void(*Callback)());
#endif

#if DATA_POST_CALLBACK == 1
void RTCRegisterDataPostCallback(void(*Callback)());
#endif

void RTCIntInit(void);
void RTCEvent(void);
void RTCSaveTime(T_TIME *Struct);
void RTCSaveRegister(uint8_t Value, T_PCF8583Reg Register);

#if FAT_FS == 1
void TimeToFatFS(T_TIME *Struktura);
#endif

#endif /* PCF8583_H_ */[/syntax]

Jeszcze jedna ważna rzecz. Jeżeli ktoś by próbował uruchomić tego libsa z Mirkowymi libsami do HD44780 to może się rozczarować że lokalizacja na LCD nie działa prawidłowo. Powodem tego jest że Mirek w funkcji lcd_locate ma najpierw wysokość potem szerokość. W mojej bibliotece ustawia się najpierw szerokość potem wysokość. Więc jak używamy tych bibliotek to trzeba odwrotnie wpisać w inicjalizacji struktury lokalizację na LCD. Najpierw wysokość potem szerokość Żeby nie było marudzenia że coś nie działa
To by było chyba na tyle Jeżeli znajdziecie jakiś błąd czy coś nie będzie działać - piszcie, postaram się pomóc

Statystyki: Napisane przez PawelGaj — 7 sie 2013, o 20:44

ATNEL tech-forum

Re: Obsługa RTC dla leniwych

Re: Obsługa RTC dla leniwych

Re: Obsługa RTC dla leniwych

Re: Obsługa RTC dla leniwych

Obsługa RTC dla leniwych