ATNEL tech-forum

Re: Dataloger na karcie SD

2017-02-15T17:36:27+01:00

Jakimś cudem popchnąłem temat do przodu

po pierwsze:
update bibliotek ze strony elm-chan - potrzebna były opcja FA_OPEN_APPEND

po drugie:
po restarcie trzeba odpowiednio ustawić wskaźnik do miejsca od którego mają być zapisywane pliki po awarii - tu pomocna okazała się funkcja f_size

efekt jaki uzyskałem (a raczej jego namiastka - bo pracy jeszcze sporo):

Statystyki: Napisane przez Mellanogaster — 15 lut 2017, o 17:36

Dataloger na karcie SD

2016-11-06T21:31:24+01:00

Moze twórz codziennie następny plik? Wtedy padnie tylko ostatni dzien. Mozna tez dorobic zapisywanie/zamykanie pliku jak zniknie zasilanie.

Statystyki: Napisane przez micky — 6 lis 2016, o 21:31

Re: Dataloger na karcie SD

2016-11-06T10:08:40+01:00

normalnie char'y w stringach
powalczę jeszcze z tym FatFS

Statystyki: Napisane przez Mellanogaster — 6 lis 2016, o 10:08

Re: Dataloger na karcie SD

2016-11-06T08:59:04+01:00

Była - gościu wpadł, opisał ile błędów jest w programie autora wątku - też widziałem to i czytałem - po czym jak widać skasował swój post (bo nie było kolejnego) i zniknął

Statystyki: Napisane przez mirekk36 — 6 lis 2016, o 08:59

Re: Dataloger na karcie SD

2016-11-06T08:48:48+01:00

Daję słowo, wczoraj tu była czyjaś odpowiedź

Statystyki: Napisane przez Mellanogaster — 6 lis 2016, o 08:48

Re: Dataloger na karcie SD

2016-11-05T16:58:36+01:00

PawelGaj - bardzo inspirujący jest Twój kod!
Mam pytanie, ponieważ za każdym razem gdy zresetuję uC to plik traci swoją zawartość i jest tworzony na nowo. Jeśli jesteś w temacie lub ktoś inny to jak przerobić funkcję zapisu aby DOPISYWAĆ do istniejącego już pliku. Wiecie, miesiąc się zapisywały dane, na chwilę brakło prądu i cała archiwizacja się skasowała
Z góry dzięki

Statystyki: Napisane przez Mellanogaster — 5 lis 2016, o 16:58

Re: Dataloger na karcie SD

2015-09-22T14:13:16+01:00

Witam,
Na początku chciałem podziękować autorowi za świetny projekt, super opisany, działa pięknie

Uruchomiłem FAT FS na zestawie ATB + atmega32 + 11,059 MHz+ karta 2 GB klasy 2 - działa świetnie, ale z czasem zaczęło brakować pamięci Flash. Przesiadłem sie na Atmege644PU, poprawiłem rejestry dla Timera2 i obsługi przerwania z RTC.

Program wgrałem, RTC - działa, przerwanie z INT - również. Krata SD sie inicjalizacje, montuje, ale nie tworzy nowego pliku i nic nie zapisuje. Obsługa błędów zwraca "FR_DISK_ERR, (1) A hard error occured in the low level disk I/O layer"
Dioda LED przy SD miga 3 razy na sekundę (zasilanie SD zwarte niebieską zworką do GND).

Porównałem rejestry SPI ATmegi644 z ATmegi32 - są identyczne. Zmieniłem Timer2 na Timer0 - bez rezultatu. Wyłączyłem JTAG, i CKDIV/8 we FuseBit'ach. Połączenia na zestawie ATB są prawidłowe, ponieważ zmieniając Atmege 644 na Atmege 32 program działa poprawnie. Wgrywając ten sam program z ATmegi644 na 32 (przy zmienię rejestrów Timera2 i obsługi przerwania) również jest OK.

Zastanawia mnie tryb USART in SPI mode z danych katalogowych, oraz dzielenie wyprowadzeń kontrolera SPI z Timerem0 i przerwaniami zewnętrznymi (np. dla wyprowadzenia PB4 jest PCINT12 / OCB0/ SS). Niestety moja wiedza jeszcze nie ogarnia tak rozbudowanego kontrolera.

Czy możecie coś podpowiedzieć ?

Pozdrawiam
______________________________________________________________________________

Problem rozwiązany, informacja dla potomnych:
Zestaw ATB zasilałem z programatora USBISP. Po odłączeniu programatora i dołączeniu zewnętrznego zasilania FAT-FS wystartował.

Statystyki: Napisane przez kevin27 — 22 wrz 2015, o 14:13

Re: Dataloger na karcie SD

2015-03-06T14:13:40+01:00

Witam, chciałbym pogratulować autorowi świetnego programu, dodatkowo mam pytanie :
[syntax=c]// ########## Zapis przygotowanego stringa na karcie SD w odpowiednim miejscu ##########
res = FatFS_Write( &FIL,
"data.csv", // Nazwa pliku
(Wiersz * strlen(BuforSD) + StrlenPoczatek), // Obliczanie odpowiedniej lokalizacji w pliku
BuforSD, // Dane do zapisu
strlen(BuforSD), // Liczba bajtow do zapisu
FA_CREATE_ALWAYS | FA_WRITE); // Okreslenie typu dostepu[/syntax]
niebardzo mogę się połapać w tym, mój program błędnie zapisuje stringi różnej długości, czy sposób wywołania funkcji jak wyżej, działa tylko na stringach o jednej długości?
pozdrawiam

Statystyki: Napisane przez pacholgarbaty — 6 mar 2015, o 14:13

Re: Dataloger na karcie SD

2014-11-13T18:39:21+01:00

Dobra sam sobie odpowiedziałem już;) jakbyś ktoś kiedyś szukał to CS jest sterowane w pliku mmc.c.

------------------------ [ Dodano po: 3 minutach ]

Dziękuje panie Mirku za odp. Za szybko chce ogarnąć obsługę kart SD i później człowiek nie pomyśli, a napiszę. Ale i tak pana odp się przydała bo raz na zawsze wyjaśniła mi się funkcja CS, dzięki!;)

Statystyki: Napisane przez lauba1 — 13 lis 2014, o 18:39

Re: Dataloger na karcie SD

2014-11-13T18:37:42+01:00

lauba1 napisał(a):

skoro urządzenie w spi aktywuję się podając stan niski na CS?

A kolega myśli że co ? podczas inicjalizacji raz na zawsze należy ustawić ZERO na CS ? ... a co ? jeśli na SPI miałyby pracować jeszcze inne moduły ? toż byłaby istna JATKA

linią CS operuje się TYLKO i WYŁĄCZNIE podczas funkcji dostępu do modułu SPI, czyli wtedy gdy dokonujemy zapisu lub odczytu. A przy inicjalizacji właśnie na wszelki wypadek ustawia się wszystkie linie CS w stan wysoki żeby nie było konfliktu w razie czego z innymi modułami.

Statystyki: Napisane przez mirekk36 — 13 lis 2014, o 18:37

Re: Dataloger na karcie SD

2014-11-13T18:27:14+01:00

[syntax=c]static void FatFS_IoInit ()
{

PORTB |= (1< DDRB |= (1<
DDRB |= (1< PORTB |= (1<
SPCR |= (1<
//atmega32
/* Timer2 – inicjalizacja przerwania co 10ms */
TCCR2 = (1< TCCR2 = (1< OCR2 = 108; // przerwanie porównania co 10ms (100Hz)
TIMSK = (1<
//rtc_init(); // Initialize RTC

sei();
}[/syntax]

Możecie mi wytłumaczyć ponieważ nie łapię jednego, skoro podczas inicjalizacji void FatFS_IoInit () ustawiamy pin CHIP SELECT ( PORTB |= (1<Statystyki: Napisane przez lauba1 — 13 lis 2014, o 18:27

Re: Dataloger na karcie SD

2013-04-28T21:26:33+01:00

Wiem, wiem o tej pamięci Flash, już nawet to zrobiłem ale był warning i w sumie jakoś to usunąłem Jutro postaram się również napisać soft w C# ładnie interpretujący ten plik z datalogera, rysowanie wykresów w wybranym przedziale czasowym itd.

Statystyki: Napisane przez PawelGaj — 28 kwi 2013, o 21:26

Re: Dataloger na karcie SD

2013-04-28T21:10:34+01:00

No to ja też gratuluję uporu i przejścia hmm opanowania FatFS ... masz rację - jak się już człowiek za niego zabierze to okazuje się że to całkiem przyjazne zwierzątko

odnośnie zmian w bibliotece do LCD pod atmel toolchain to warto a nawet trzeba zrobić dwie i tam mała literówka ci się zdarzyła bo specyfikator const powinien być przed typem ale ja chciałem zwrócić uwagę żebyś na przyszłość w gotowym kodzie nie używał wyświetlania stałych tekstów tak:

[syntax=c]lcd_str("SD INIT ERROR");[/syntax]

tylko tak

[syntax=c]lcd_str_P( PSTR("SD INIT ERROR") );[/syntax]

to bardzo ważne bo tracisz nie tylko FLASH na ten tekst ale i RAM !!! rozumiesz ? dużo może ci go pożreć kod w którym dużo masz takich wyświetleń bez tego _P, a wtedy nagłówki dwóch funkcji trzeba przerobić o tak:

[syntax=c]void lcd_str_P(const char * str);[/syntax]

oraz:

[syntax=c]void lcd_defchar_P(uint8_t nr, const uint8_t *def_znak);[/syntax]

Jeśli zaś chodzi o sam kod - to jak pisał Anty wyżej, plus za komentarze, ale w kolejnych wersjach staraj się już dzielić go na więcej plików bo tak - analiza tego to hmmmm ... sam się przekonasz jak wrócisz do niego np za rok

Statystyki: Napisane przez mirekk36 — 28 kwi 2013, o 21:10

Dataloger na karcie SD

2013-05-08T21:04:00+01:00

Witam.

Dzisiaj mam do zaprezentowania dataloger. Jest to taki mój twór który zapisuje datę, czas i temperaturę na karcie SD w formacie zjadliwym dla Excela, czyli :
28.04.13;21:09; 09,3; 21,4;
No i tak właśnie zapisuje to ATMega na karcie SD. Dodam jeszcze że biblioteki do zapisu na karcie SD to ociężałe FatFS. Sam bałem się do tego podejść, przez to że jest taki opasły, ma tyyyle plików i kod jest taki długi. Jednak się przełamałem i ogarnąłem te biblioteki Nie jest to takie trudne jak mogłoby się wydawać. Po ogarnięciu zapisu postanowiłem zrobić coś innego, bardziej trudnego. I przyszedł mi na myśl dataloger. Kod zajmuje 24KB. Po otwarciu w Excelu i zrobieniu wykresu wygląda to tak :

Myślę że starczy już tego rozwodzenia się nad pomysłem i trudnością FatFSa. Czas przejść do meritum, czyli kodu.
Plik main.c wygląda tak :
[syntax=c]#include
#include
#include
#include
#include

#include "FatFS/ff.h"
#include "FatFS/diskio.h"
#include "rtc.h"
#include "LCD/lcd44780.h"
#include "I2C_TWI/i2c_twi.h"
#include "1Wire/ds18x20.h"

// ###########################
// ########## FatFS ##########
// ###########################

#define SCK PB7// Definicje pinow
#define MOSI PB5// do podlaczenia
#define CS PB4// karty SD

volatile WORD Timer; // Zmienna do soft-timera dla FatFS
FRESULT res;// Zmienna wyniku funkcji - potrzebna do obslugi bledow
RTC rtc;// Struktura RTC - potrzebna do przekazania czasu bibliotece FatFS

static void FatFS_IoInit();// Inicjalizacja pinow potrzebnych karcie SD
DWORD get_fattime ();// Przekazywanie czasu bibliotece FatFS

typedef uint8_t u08;

// #######################################
// ########## Zmienne i tablice ##########
// #######################################

char BuforSD[50] = {"Data;Czas;Out;In\r\n"};// Bufor do zapisu na karcie SD - tutaj wpisujemy co ma byc zapisane przed wejsciem do petli while

uint8_t const OK[] PROGMEM = {0, 0, 1, 1, 18, 26, 12, 4};// wzór znaku buźki w pamięci FLASH
uint8_t const ERR[] PROGMEM = {0, 0, 17, 27, 14, 14, 27, 17};

u08 IloscDS18B20;// Ilosc czujnikow na magistrali 1Wire
u08 StrlenPoczatek;// Dlugosc stringa poczatkowego
uint64_t Wiersz;// Aktualny wiersz w pliku

// ###############################
// ########## Struktury ##########
// ###############################

typedef struct DS18B20 DS18B20;// Definiujemy typ struktury

struct DS18B20{
u08 Cel;// Czesc calkowita
u08 CelFract;// Czesc dziesietna
u08 Subzero;// Temperatura ujemna (1 - tak, 0 - nie)
DS18B20 *Next;// Wskaznik na nastepna strukture
u08 x;// Lokalizacja na
u08 y;// wyswietlaczu
char String[6];// Temperatura w formie stringa
u08 Hide;// Zmienna decydujaca o wyswietlaniu na LCD (1 - Nie wyswietla, 0 - Wyswietla)
};

DS18B20 DS18B20_1;// Definiuj strukture dla czujnikow DS18B20
DS18B20 DS18B20_2;// ROBIMY TYLE STRUKTUR ILE MAMY CZUJNIKOW - INACZEJ PROGRAM NIE ODCZYTA Z NICH TEMPERATURY
DS18B20 *DS18B20_Temp;

TIME Czas;// Definiuj strukture czasu

// #############################
// ########## Funkcje ##########
// #############################

// ########## Temperatura ##########
void DS18B20StructInit(DS18B20 *Struct, uint8_t x, uint8_t y, uint8_t Hide, DS18B20 *Next);
void DS18B20Read(void);
void WyswietlTemperature(void);
void TempParse(char *String);

// ########## Czas ##########
void RTCStructInitDate(TIME *Struct, uint8_t x, uint8_t y, uint8_t Hide, char Sep, void(*lcd_puts_func)(char *Bufor), void(*lcd_goto)(uint8_t y, uint8_t x));
void RTCStructInitTime(TIME *Struct, uint8_t x, uint8_t y, uint8_t Hide, char Sep, void(*lcd_puts_func)(char *Bufor), void(*lcd_goto)(uint8_t y, uint8_t x));
void OdczytajCzasZRTC(TIME *Struktura);
void ParseTime(uint8_t *Val1, uint8_t *Val2, uint8_t *Val3, char *Separator, char *Output);
void TimeToFatFS(TIME *Struktura);

// ########## Rozne ##########
void UsunStaryString(char *String);
FRESULT FatFS_Write(FIL *File, char *Nazwa, DWORD Przesuniecie,char *Data, UINT IleBajtow, uint8_t Mode);

int main (void)
{
FATFS FS;
FIL FIL;

FatFS_IoInit();// Ustaw kierunki portow dla obslugi karty SD

// #################### Wyswietlacz LCD ####################
lcd_init();// Inicjalizacja wyswietlacza LCD

lcd_defchar_P(0x80, OK);// Wgraj do pamieci RAM wyswietlacza
lcd_defchar_P(0x81, ERR);// symbole OK i ERR

LCD_LED_INIT// Ustaw kierunek pinu dla podswietlenia LCD
LCD_LED_ON// Wlacz podswietlenie LCD

// #################### RTC ####################
i2cSetBitrate(100);// Ustaw bitrate dla I2C
RTCIntInit();// i zainicjalizuj przerwanie od RTC (INT0 - PD2)

RTCStructInitTime(&Czas, 0, 0, 0, ':', lcd_str, lcd_locate);// Inicjalizuj strukture daty
RTCStructInitDate(&Czas, 0, 1, 0, '.', lcd_str, lcd_locate);// i czasu
Czas.Rok = 13;

// #################### Karta SD ####################
res = disk_initialize(0);// Inicjalizacja karty SD
if(res != 0)// Jezeli inicjalizacja sie nie powiodla
{
lcd_locate(0,0);// Ustaw kursor na LCD
lcd_str("SD INIT ERROR");// Wyswietl komunikat o bledzie inicjalizacji karty
lcd_locate(1,7);// Ustaw odpowiednia lokalizacje
lcd_str("\x81");// I wyswietl krzyzyk
_delay_ms(5000);// Czekaj 5s i idz dalej
}
else// Jesli sie powiodla
{
res = f_mount(0, &FS);// To montuj karte SD
if(res != 0)// Jesli montowanie sie nie powiodlo
{
lcd_locate(0,0);// Ustaw kursor na LCD
lcd_str("SD MOUNT ERROR");// Wyswietl komunikat o bledzie montowania karty
lcd_locate(1,7);// Ustaw lokalizacje dla wyswietlania krzyzyka
lcd_str("\x81");// Wyswietl krzyzyk
_delay_ms(5000);// Czekaj 5s i idz dalej
}
else// Jesli sie powiodlo
{
lcd_locate(1,7);// To ustaw lokalizacje dla wyswietlenia ptaszka
lcd_str("\x80");// Wyswietl ptaszka
}
}

// #################### 1Wire ####################
IloscDS18B20 = search_sensors();// Szukaj DS18B20 na 1Wire
DS18X20_start_meas(DS18X20_POWER_EXTERN, NULL);// I wyslij do nich polecenie pomiaru

DS18B20StructInit(&DS18B20_1, 11, 0, 0, &DS18B20_2);// Inicjalizuj struktury
DS18B20StructInit(&DS18B20_2, 11, 1, 0, NULL);// czujnikow DS18B20

_delay_ms(750);// Czekaj na pomiar temperatury

// #################### Zapis poczatkowej ramki na karcie SD ####################
StrlenPoczatek = strlen(BuforSD);// Okresl dlugosc ramki
FatFS_Write(&FIL, "data.csv", 0, BuforSD, StrlenPoczatek, FA_CREATE_ALWAYS | FA_WRITE);// Zapisz ramke na karcie SD

lcd_cls();// Wyczysc wyswietlacz przed wejsciem do glownej petli

while(1)
{
if(RTCIntFlag)
{
OdczytajCzasZRTC(&Czas);// Odczytywanie czasu z RTC
TimeToFatFS(&Czas);// Przekazywanie czasu do FatFS

DS18B20Read();// Odczytywanie temperatury ze wszystkich DSow
WyswietlTemperature();// No i wyswietlanie temperatury

UsunStaryString(BuforSD);// Usuwanie starego stringa

strcat(BuforSD, Czas.DataString);// Na poczatku doklej do stringa date
strcat(BuforSD, ";");// i separator
// BuforSD = 28.04.13;

strcat(BuforSD, Czas.CzasString);// Potem doklej czas
strcat(BuforSD, ";");// i separator
// BuforSD = 28.04.13;19:59;

TempParse(BuforSD);// Tu doklejamy temperatury ze wszystkich czujnikow

strcat(BuforSD, "\r\n");// No i znak entera i nowej linii
// Teraz BuforSD wyglada tak : 28.04.13;19:59; 09,3; 21,2;\r\n

// ########## Zapis przygotowanego stringa na karcie SD w odpowiednim miejscu ##########
res = FatFS_Write(&FIL,
"data.csv", // Nazwa pliku
(Wiersz * strlen(BuforSD) + StrlenPoczatek), // Obliczanie odpowiedniej lokalizacji w pliku
BuforSD, // Dane do zapisu
strlen(BuforSD),// Liczba bajtow do zapisu
FA_CREATE_ALWAYS | FA_WRITE);// Okreslenie typu dostepu

// ########## Obsluga bledow ##########

if(res == FR_OK)// Jesli wszystko OK
{
lcd_locate(0,9);// To ustaw kursor w odpowiednim miejscu
lcd_str("\x80");// I wyswietl ptaszka
}
else// Jesli nie
{
lcd_locate(0,9);// To ustaw kursor w odpowiednim miejscu
lcd_str("\x81");// I wyswietl krzyzyk
}

Wiersz++;// Inkrementuje zmienna wiersza potrzebna do odpowiedniego przesuniecia wskaznika do miejsca zapisu na karcie SD
RTCIntFlag = 0;// Zeruje flage RTC

// Uff, to koniec ;)
}
}

}

void RTCStructInitDate(TIME *Struct, uint8_t x, uint8_t y, uint8_t Hide, char Sep, void(*lcd_puts_func)(char *Bufor), void(*lcd_goto)(uint8_t y, uint8_t x))
{
Struct -> DataX = x;
Struct -> DataY = y;
Struct -> DataHide = Hide;
Struct -> DataSep = Sep;
Struct -> lcd_goto = lcd_goto;
Struct -> lcd_puts_func = lcd_puts_func;
}

void RTCStructInitTime(TIME *Struct, uint8_t x, uint8_t y, uint8_t Hide, char Sep, void(*lcd_puts_func)(char *Bufor), void(*lcd_goto)(uint8_t y, uint8_t x))
{
Struct -> CzasX = x;
Struct -> CzasY = y;
Struct -> CzasHide = Hide;
Struct -> CzasSep = Sep;
Struct -> lcd_goto = lcd_goto;
Struct -> lcd_puts_func = lcd_puts_func;
}

void DS18B20StructInit(DS18B20 *Struct, uint8_t x, uint8_t y, uint8_t Hide, DS18B20 *Next)
{
Struct -> Next = Next;
Struct -> x = x;
Struct -> y = y;
Struct -> Hide = Hide;
}

void TempParse(char *String)
{
DS18B20_Temp = &DS18B20_1;// Ustaw wskaznik na pierwsza strukture

for(uint8_t i = 0; i < IloscDS18B20; i++)
{
strcat(String, DS18B20_Temp -> String);// Doklej do podanego wskaznika na stringa string z temperatura
strcat(String, ";");// Doklej separator
DS18B20_Temp = DS18B20_Temp -> Next;// Ustaw wskazni do stuktury na nastepna strukture
}

}

void UsunStaryString(char *String)
{
uint8_t Wsk = 0;// Zmienna do cofania wskaznika

for(uint8_t i = 0; i < strlen(String); i++)// Petla wykona sie tyle razy ile jest znakow w buforze
{
Wsk++;// Inkrementuj zmienna wskaznika, aby mozna bylo potem cofnac wskaznik do poczatku
*String = 0;// Usun stary tekst
String++;// Inkrementuj wskaznik
}
}

void OdczytajCzasZRTC(TIME *Struktura)
{

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

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

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

ParseTime(&Struktura -> Godzina, &Struktura -> Minuta, &Struktura -> Sekunda, &Struktura -> CzasSep, Struktura -> CzasString);// Przygotuj stringa z czasem

if(Struktura -> CzasHide == 0)// Jesli zmienna odpowiedzialna za ukrywanie daty == 0 to wyswietl czas na podanej lokalizacji
{
Struktura -> lcd_goto(Struktura -> CzasY, Struktura -> CzasX);// Ustaw kursor w podanym wczesniej miejscu
Struktura -> lcd_puts_func(Struktura -> CzasString);// I wyswietl string z data na wyswietlaczu
}

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

ParseTime(&Struktura -> Dzien, &Struktura -> Miesiac, &Struktura -> Rok, &Struktura -> DataSep, Struktura -> DataString);// Przygotuj stringa z data

if(Struktura -> DataHide == 0)// Jesli zmienna odpowiedzialna za ukrywanie daty == 0 to wyswietl czas na podanej lokalizacji
{
Struktura -> lcd_goto(Struktura -> DataY, Struktura -> DataX);// Ustaw kursor w podanym wczesniej miejscu
Struktura -> lcd_puts_func(Struktura -> DataString);// I wyswietl string z data na wyswietlaczu
}

}

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

UsunStaryString(Output);

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

void WyswietlTemperature(void)
{
DS18B20_Temp = &DS18B20_1;// Ustaw wskaznik na pierwszy czujnik

// ########## Petla odczytujaca dane z czujnika DS18B20 ##########
// ########## wykona sie tyle razy, ile jest czujnikow na magistrali ##########
for(uint8_t i = 0; i < IloscDS18B20; i++)
{
lcd_locate(DS18B20_Temp -> y, DS18B20_Temp -> x);// Ustaw odpowiednia lokalizacje na wyswietlaczu

if(DS18B20_Temp -> Subzero) lcd_str("-");// Jezeli temperatura jest ujemna to napisz -

lcd_int(DS18B20_Temp -> Cel);// Wyswietl temperature - czesc liczb calkowitych
lcd_str(".");// Wyswietl kropke
lcd_int(DS18B20_Temp -> CelFract);// Wyswietl temperature - czesc dziesetna

DS18B20_Temp = DS18B20_Temp -> Next;// Przestaw wskaznik do struktury na nastepny
}
}

void DS18B20Read(void)
{
DS18B20_Temp = &DS18B20_1;// Ustaw wskaznik na pierwsza strukture czujnika

char Buf[3];// Bufor na konwersje zmiennych do stringa

// ########## Petla odczytujaca dane z czujnika DS18B20 ##########
// ########## wykona sie tyle razy, ile jest czujnikow na magistrali ##########
for(u08 i = 0; i < IloscDS18B20; i++)
{
DS18X20_read_meas(gSensorIDs[i], &DS18B20_Temp -> Subzero, &DS18B20_Temp -> Cel, &DS18B20_Temp -> CelFract); // Odczytaj temperature

// ########## Petla usuwajaca poprzedniego stringa
for(uint8_t e = 0; e < sizeof(DS18B20_Temp -> String); e++)
{
DS18B20_Temp -> String[e] = 0;
}

if(DS18B20_Temp -> Subzero) strcat(DS18B20_Temp -> String, "-");// Jezeli temperatura jest na minusie to doklej minusa na poczatku
elsestrcat(DS18B20_Temp -> String, " ");// Jezeli nie, to doklej spacje

if(DS18B20_Temp -> Cel < 10)// Jesli zmienna jest mniejsza niz 10
{
itoa(DS18B20_Temp -> Cel, Buf, 10);// To przekonwertuj zmienna na string
strcat(DS18B20_Temp -> String, "0");// Doklej zero do stringa
strcat(DS18B20_Temp -> String, Buf);// I na koncu temperature
}
else// Jesli zmienna jest wieksza niz 10
{
itoa(DS18B20_Temp -> Cel, Buf, 10);// To przekonwertuj zmienna na string
strcat(DS18B20_Temp -> String, Buf);// I doklej ja do stringa
}

strcat(DS18B20_Temp -> String, ",");// Dodawanie przecinka
itoa(DS18B20_Temp -> CelFract, Buf, 10);// Przekonwertuj dziesietne temperatury na string
strcat(DS18B20_Temp -> String, Buf);// I doklej je do stringa

DS18B20_Temp = (DS18B20_Temp -> Next);// Ustaw wskaznik na nastepny czujnik
}

IloscDS18B20 = search_sensors();// Szukaj czujnikow na magistrali
DS18X20_start_meas(DS18X20_POWER_EXTERN, NULL);// i wyslij do wszystkich polecenie pomiaru
}

void TimeToFatFS(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;
}

FRESULT FatFS_Write(FIL *File, char *Nazwa, DWORD Przesuniecie,char *Data, UINT IleBajtow, uint8_t Mode)
{
UINT bw;// Zmienna zapisanych bajtow
FRESULT res;// Zmienna rezultatu funkcji

res = f_open(File, Nazwa, Mode);// Otworz plik
if(res == FR_OK)// Jesli wszystko OK - idziemy dalej
{
res = f_lseek(File, Przesuniecie);// Ustaw wskaznik zapisu do pliku w odpowiednim miejscu
if(res == FR_OK)// Jesli wszystko OK - idziemy dalej
{
res = f_write(File, Data, IleBajtow, &bw);// Zapisz co trzeba do pliku
if(res == FR_OK)// Jesli OK - idziemy dalej
{
res = f_close(File);// Zamknij plik
}
}
}

return res;// No i zwroc rezultat funkcji
}

// ###################################
// ########## Funkcje FatFS ##########
// ###################################

DWORD get_fattime ()
{

return ((DWORD)(rtc.year - 1980) << 25)
| ((DWORD)rtc.month << 21)
| ((DWORD)rtc.mday << 16)
| ((DWORD)rtc.hour << 11)
| ((DWORD)rtc.min << 5)
| ((DWORD)rtc.sec >> 1);
}

static void FatFS_IoInit ()
{

PORTB |= (1<DDRB |= (1<
DDRB |= (1<PORTB |= (1<
SPCR |= (1<
//atmega32
/* Timer2 – inicjalizacja przerwania co 10ms */
TCCR2 = (1<TCCR2 = (1<OCR2 = 108;// przerwanie porównania co 10ms (100Hz)
TIMSK = (1<
//rtc_init();// Initialize RTC

sei();
}

ISR(TIMER2_COMP_vect)
{
Timer++;/* Performance counter for this module */
disk_timerproc();/* Drive timer procedure of low level disk I/O module */
}[/syntax]

Wiem że jest nawalone bardzo dużo komentarzy, ale starałem się żeby kod był bardziej zrozumiały dla zielonych i żeby uświadomili sobie że to nie jest takie trudne. Oczywiście Mirkowe biblioteki należy dokleić sobie do projektu, jednak ja zrobiłem gdzieniegdzie kilka zmian, o których zaraz napiszę.

W pliku lcd44780.c zmieniłem to :
[syntax=c]void lcd_defchar_P(uint8_t nr, uint8_t *def_znak)[/syntax]
na to:
[syntax=c]void lcd_defchar_P(uint8_t nr, uint8_t const *def_znak)[/syntax]
ponieważ kompilator Tollchaina wyrzucał warninga.

Do pliku twi.h dokleiłem również deklaracje mojej struktury czasu i kilku funkcji
[syntax=c]extern volatile uint8_t RTCIntFlag;

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

typedef struct TIME TIME;

struct TIME {
uint8_t Sekunda;
uint8_t Minuta;
uint8_t Godzina;
uint8_t Dzien;
uint8_t Miesiac;
uint8_t Rok;

char CzasString[9];// Aktualny czas w formie stringa
char CzasSep;// Separator między jednostkami, np : albo .
uint8_t CzasX;// Lokalizacja czasu
uint8_t CzasY;// na wyswietlaczu
uint8_t CzasHide;// Zmienna decydujaca o wyswietlaniu czasu na wyswietlaczu (1 - Nie wyswietla, 0 - Wyswietla)

char DataString[9];
char DataSep;
uint8_t DataX;
uint8_t DataY;
uint8_t DataHide;

void(*lcd_puts_func)(char *Bufor);// Wskaznik do funkcji do wyswietlania stringow
void(*lcd_goto)(uint8_t y, uint8_t x);// Wskaznik do funkcji ustawiania
};

uint8_t Dec2Bcd(uint8_t dec);
uint8_t Bcd2Dec(uint8_t bcd);
void RTCIntInit(void);[/syntax]

No i zmiany w pliku twi.c
[syntax=c]volatile uint8_t RTCIntFlag;

uint8_t Bufor[6];

void RTCIntInit(void)
{
MCUCR |= (1<GICR |= (1<PORTD |= (1<}

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

ISR( INT0_vect )
{
RTCIntFlag = 1;
}[/syntax]

I to chyba wszystko, jak macie jakieś uwagi to piszcie

Zapomniałem dodać, drzewko projektu wygląda tak :

PROSZĘ POPRAWIĆ OBRAZKI W POŚCIE ---
ZASADY UMIESZCZANIA OBRAZKÓW --- topic44.html ...:: SunRiver ::...

Statystyki: Napisane przez PawelGaj — 28 kwi 2013, o 20:44