SD/MMC Kart ve Data Logger Uygulaması

İki aydır sınavlardan ve tez çalışmalarımdan bana kalan küçük boşluklarda çalıştığım FAT ve SD/MMC kart uygulamamı en sonunda tamamlayabildim. Benim gibi bu konu üzerine uygulama yapmak isteyenleri doktora tezi kıvamında bir çalışma yapmadan nasıl SD ve MMC kartlara yazım yapabileceklerini bu yazımda ele almaya çalışacağım.

SD/MMC kart ve FAT16/32, bu konu üzerinde çalışanların bileceği gibi yeri geldiğince gerçekten baş ağrıtıcı bir uygulama olabilmektedir. İstatistiksel bir rakam vermem gerekirse internette bu konuda yapılmış çalışmaların %90’nı üreticilerin örnek kodlarının devşirilip, yontulmasıyla oluşturulmuş ve neredeyse tüm insanlık Chan’ın o ünlü kütüphanesine yönelmiş.

Elektor dergisinin Ocak 2011 sayısında da değindiği bu konuya, aşağıdaki basit soruları sorarak giriş yapmak istiyorum.

FAT16/FAT32 Nedir?

Günümüzde taşınabilir (SD/MMC/Flash Bellek) depolama aygıtlarının ortak dosya sistemi haline gelen FAT, özellikle büyük hacimli ve sürekli yazım/silim işlemleri yapılan veri saklama birimleri için geliştirilmiş bir dosya sistemidir. Günümüzde en fazla kullanılanı FAT32 olmakla beraber FAT16 ve FAT12 dosya sistemleri de bulunmaktadır.

Hangi Bağlantı Çeşidini Kullanacağız?

SD/MMC kartlar bir çok iletişim yöntemini desteklese de biz SPI iletişimini tercih edeceğiz. İletişim hızımız ise maksimum 20MHz ile sınırlı kalacak.

En Önemlisi, Hangi Kütüphaneyi Tercih Etmeliyiz?

Yazımın başında da belirttiğim gibi SD/MMC ve FAT konusunda lider Chan FatFS kütüphanesi olarak gözükmektedir. Bir çok firma, çoğu ARM üreticisi, Atmel AVR ve Texas Inst., bu kütüphane ile uygulama örneklerini sitelerine koymuşlardır. Microchip ise kendine ait MDD File System adlı SD/MMC kütüphanesini kullanmaktadır.

Ben bu konu hakkında ilk çalışmama Chan ile başlamış olsam da, istediğim başarıyı sağlayamadıktan sonra MDD File System’e yöneldim. Gerek PIC üzerinde çalışmam gerekse kullanımının oldukça basit oluşu MDD File System’e ısınmamı sağladı.

Fakat bu Chan FatFs’in elbette kötü bir kütüphane olduğu anlamına gelmez. Çalışmak istediğimiz FAT dökümanı istediğimiz işlemlerimizi gerçekleştiriyorsa benim için ister Chan FatFs ister MDD File System ister FıratFs olmuş açıkçası hiç önemli değil. Sonuç olarak hazır kütüphane kullanıyoruz ve her şeyin bize uymasını beklemek yanlış olur.

Birbirlerine Karşı Üstünlükleri Var Mıdır?

Her iki kütüphane de en temel fonksiyonları, dosya/klasör açma, okuma, yaratma, değiştirme bünyesinde barındırmaktadır. Sadece MDD kütüphanesi FatFs kütüphanesine nazaran boyut olarak biraz daha büyüktür.

PIC Dışındaki Mikrodenetleyicilerde Ne Yapmalıyız?

PIC dışındaki mikrodenetleyicilerde de durum aynıdır. Fakat ARM ve Chan FatFs kütüphanesi ile ilgili bir çok örnek internette bulunmaktadır. İstenirse MDD File System kütüphanesi de istediğiniz mikrodenetleyici için düzenlenebilir.

Bunca Sene Hazır Kütüphaneye Karşı Çıkan Sen, Şimdi Neden Hazır Kütüphane Öneriyorsun?

Başta da belirttiğim gibi FAT dosya sistemi çok karışık gözükmese de bunu herkesin kullanabileceği standart haline getirmek bizlere oldukça fazla zaman kaybettirir. Ayrıca dünya çapında bir çok kullanıcının deneyip, geri bildirimlerde bulunduğu ve geliştirilmesini sağladığı bu kütüphanelerin bizim sıfırdan yazacağımız kütüphanelerden daha iyi olacağını düşünmek sanırım yanlış olmaz.

Bunun için Amerika’yı tekrar keşfetmeye hiç gerek yok. Sadece ileride çıkabilecek sorunlara karşın kütüphanenin ve dosya sisteminin nasıl çalıştığını anlayalım yeter.

Uygulamalarda Takıldığın En Önemli Konu Nedir?

FAT ve SD/MMC uygulama örneklerinde en fazla takıldığım konu yukarıda da bahsettiğim gibi üretici firmanın ya da örneklerinin devşirilerek kullanılmasıdır. Buradaki en önemli eksiklik SD/MMC karta bir TXT dosyası yazıldığında başarının elde edildiği yanılgısıdır. Bir çok üretici firma kodlarını seri haberleşmeyle birleştirip, özellikle mikrodenetleyicinin herhangi bir Timer ya da başka bir modülünü kullanmaktadır.

Bunlar bazı uygulamalarda açıklansa da çoğu uygulamada es geçilmektedir. Dolayısıyla yaptığınız sistemde oluşturduğunuz bir kesmenin ya da başka bir işlemin dosya sistemine zarar verip vermediği bilinememektedir.

Peki Bizler Ne Arıyoruz?

Çoğu kütüphanede olduğu gibi yapmayı istediğimiz şey, donanımı en az yoracak şekilde aşağıdaki işlemleri yapmaktır.

– SD/MMC’yi tanı, tanıt,
– SD/MMC karta yeni dosya aç, veri yaz, veri oku,
– Açılan dosyayı kapa.

Onun için gayet sade ve fonksiyonların ne olduğu açık saf kütüphaneler kullanmak her zaman bizim avantajımıza olacaktır.

Data Logger Uygulaması

Bu kadar söz ettikten sonra gelelim Data Logger uygulamamıza. Data Logger, adından da anlaşılacağı üzerinde dış ortamdan ya da sistemden alınan verileri belirli zaman aralıklarıyla kayıt altına alma işlemidir. Ben de bu uygulamamda DS18B20 dijital sıcaklık sensöründen aldığım verileri Micro SD karta yazarak basit bir kayıt işlemi yaptım.

Benim kullandığım Micro SD kartta herhangi bir yazım koruma metodu olmadığından, uygulamamda “yazım koruma kontrolü” yapmadım ve kütüphaneyi buna göre düzenledim. Değişiklik yaptığım fonksiyon isimleri aşağıdaki gibidir;

–SD-SPI.c dosyasındaki MDD_SDSPI_InitIO(),
–SD-SPI.c dosyasındaki MDD_SDSPI_MediaDetect(),
-Ve tüm kütüphane kısayol tanımlamaları.

Kütüphaneyi indirip, proje klasörüne attıktan sonra yapmamız gerekenler şunlardır;

–HardwareProfile.h dosyasının içerisinden kullanacağımız pin tanımlamaları yapılmalıdır. İstenirse kullanılacak registerler de buradan değiştirilebilir.

–FSConfig.h dosyasının içerisinden de SD/MMC kart ile ilgili tüm ayarlar yapılabilir.
-Her iki dosyada da tanımlamaların ne işe yaradığı belirtilmektedir.

Tüm bu işlemleri yaptığımızda MDD File System dosyaları yandaki hiyerarşide toplanmalıdır. Daha sonra istediğimiz uygulama bu kütüphane dosyaları kullanılarak geliştirilebilir. Ben uygulamamda PIC24FJ256GB110 ile 128×64 GLCD kullandığım için onunla ilgili kütüphane dosyalarımı projeme ekledim.

Projemize gelecek olursak öncelikle elimizde bulunan Micro SD kartımızın içerisinde “fxdev-1.txt“, “fxdev-2.txt” ve “fxdev-3.txt” adında 3 adet TXT dosyası oluşturalım ve içerilerine istediğimiz metni yazıp kaydedelim.

Benim yazdığım metinler aşağıdaki resimde görülebilir.

Ben projemde bu belgelerin içeriklerini sırasıyla GLCD’de gösterip, “fxdev-3.txt” belgesinin silimini gerçekleştirdim. Daha sonra “DATA.TXT” adlı metin belgesi açıp sırasıyla tarih, saat ve o anki sıcaklık bilgilerini 5’er saniye aralıklarla kaydettim.

Bu işlemler olmadan önce RTC tarihini 09/02/2011 ve saatini 20:42:05 ayarladım. Dosya yaratma, kaydetme işlemleri RTC üzerinden olduğundan son kaydetme işlemi bittiğinde aradan ne kadar süre geçtiğini görebildim. Kayıt işlemini bitirmek içinse RA7 bacağına bağlı butona basarak işlemi tamamladım. Tüm bu işlemler sonrasında Micro SD kartının barındırdığı son dosyalar ve “DATA.txt” dosyasının içeriği aşağıdaki resimde görülebilir.

Yukarıdaki resimde bir yükselti görülmektedir. Bu yükselti ben tam sensörü tuttuğumda gerçekleşmiştir.

Bu uygulamaya ait main.c dosyasının içeriği aşağıda görülebilir.

// Yazar:   Fırat DEVECİ
// Konu :   Micro SD Kart ile Data Logger Uygulaması
// Tarih:   10/02/2011

#include "p24Fxxxx.h"
#include "string.h"
#include "stdio.h"
#include "FSIO.h"
#include "ks0108.h"
#include "ds18b20.h"

_CONFIG3(WPCFG_WPCFGDIS & WPDIS_WPDIS)
_CONFIG2(IESO_OFF & PLLDIV_NODIV & PLL_96MHZ_ON & FNOSC_FRCPLL & FCKSM_CSDCMD & OSCIOFNC_OFF & IOL1WAY_OFF & DISUVREG_OFF & POSCMOD_EC)
_CONFIG1(JTAGEN_OFF & GCP_OFF & GWRP_OFF & BKBUG_OFF & COE_OFF & ICS_PGx1 & FWDTEN_OFF & WINDIS_OFF)

char sendBuffer1[] = "\tFxDev.org Sunar!";
char sendBuffer2[] = "\r\nDS18B20 ile MMC Data Logger Uygulamasi\r\n\r\n";
char sendBuffer3[] = "Tarih\t\tSaat\t\tSicaklik\r\n";
char sendBuffer4[] = "%0.2d/%0.2d/%0.2d\t%0.2d:%0.2d:%0.2d\t%3.1f\r\n";
char receiveBuffer1[120];
char receiveBuffer2[120];
char receiveBuffer3[120];

void RTC_init(int gun, int ay, int yil, int haftagun, int saat, int dakika, int saniye)
{
    // RTC ilk ayarlamaları //
    // 32768Hz kristal girişi açılıyor
    __builtin_write_OSCCONL(0x02);
    // RTCWREN başta kapalı gelir, bu da registerlere erişmemizi engeller
    // Aşağıdaki asm koduyla bu kilit kaldırılır
    asm volatile("disi #5");
    asm volatile("mov #0x55, w7");
    asm volatile("mov w7, _NVMKEY");
    asm volatile("mov #0xAA, w8");
    asm volatile("mov w8, _NVMKEY");
    // Bu bilgi direk datasheetten alınmıştır
    RCFGCALbits.RTCWREN=1;  // Artık registerlere yazım yapılabilir
    RCFGCALbits.RTCEN=0;    // RTC kapatılıyor
    PADCFG1bits.RTSECSEL=1; // Alarm kullanılacaksa bu bit sıfır olmalı
                            // Biz saniye çıkışını dışarı vereceğiz
    RCFGCALbits.RTCOE=1;    // Eğer PADCFG1bits.RTSECSEL=1 olursa bu bitte 1 olmak zorunda
    RCFGCALbits.RTCPTR=3;   // Yıldan itibaren değerler yüklenmeye başlayacak
                            // RTCVAL registerine her yükleme sonrasında RCFGCALbits.RTCPTR
                            // registerinin içeriği bir azalarak sırasıyla ay-gün,haftasaat-saat,dakika-saniye
                            // değerlerinin girilmesine izin verecek
                            // Alarm kurmak için de ALRMPTR bitleri aynen bu şekilde kullanılır
                            // Çok gıcık bir yöntem olduğunu bende kabul ediyorum
    // Şimdi tarih ve saat bilgilerini girelim.
    // Bir aptal uygulama daha burada bizi bekliyor
    // Örneğin ay değeri için aralıkta 0x12 girmemiz gerekiyor, yıl için de aynen 0x2009
    // Ya da gün için 0x31 0x24 gibi. Bunun neden 21,23 şeklinde yapılmadığını microchip'e sorabilirsiniz.

    gun=(gun/10)*16+gun%10;
    ay=(ay/10)*16+ay%10;
    yil=(yil/10)*16+yil%10;
    haftagun=(haftagun/10)*16+haftagun%10;
    saat=(saat/10)*16+saat%10;
    dakika=(dakika/10)*16+dakika%10;
    saniye=(saniye/10)*16+saniye%10;

    // Tüm tarih-saat bileşenleri yukarıdaki anlatılan şekle dönüştürüldü.
    // Şimdi ise registerler için bunları aşağıdaki şekilde birleştirmek gerekiyo
    // RTCPTR=3
    RTCVAL=yil;                 // 99 yıla kadar değer alabiliyor
    // RCFGCALbits.RTCPTR 1 azaldı, RTCPTR=2
    RTCVAL=(ay< <8)+gun;         // Ay 12'ye kadar gün ise 31'e kadar yazılabilir
    // RCFGCALbits.RTCPTR 1 azaldı, RTCPTR=1
    RTCVAL=(haftagun<<8)+saat;  // Haftagün 0-6, saat 23'e kadar yazılabilir
    // RCFGCALbits.RTCPTR 1 azaldı, RTCPTR=0
    RTCVAL=(dakika<<8)+saniye;  // Dakika 59, saniye 59'a kadar yazılabilir

    RCFGCALbits.CAL=0;      // Kablibrasyon yapılmayacak
    RCFGCALbits.RTCEN=1;    // RTC açılacak
    RCFGCALbits.RTCWREN=0;  // RTC yazımı engellenecek, böylelikle cihaza reset atılsa da RTC çalışmasına devam edecek
                            // Elbette bizim uygulamamızda bu olmayacak
}

void RTC_read(int *gun, int *ay, int *yil, int *haftagun, int *saat, int *dakika, int *saniye)
{
    int yil_temp,ay_gun,haftagun_saat,dakika_saniye;
    while(RCFGCALbits.RTCSYNC); // Tam değişim anında okuma yapmamak için bu bitin sıfır olması bekleniyor
    RCFGCALbits.RTCPTR=3;       // Yine bu registeri 3 yaparak yıldan itibaren okumaya başlıyoruz

    yil_temp        =RTCVAL;    // RTCPTR=3 oldu
    ay_gun          =RTCVAL;    // RTCPTR=2 oldu
    haftagun_saat   =RTCVAL;    // RTCPTR=1 oldu
    dakika_saniye   =RTCVAL;    // RTCPTR=0 oldu

    *yil=((yil_temp>>4)&0x0F)*10+(yil_temp&0x0F);
    *ay=((ay_gun>>12)&0x0F)*10+((ay_gun>>8)&0x0F);
    *gun=((ay_gun>>4)&0x0F)*10+(ay_gun&0x0F);
    *haftagun=(haftagun_saat>>8)&0x0F;
    *saat=((haftagun_saat>>4)&0x0F)*10+(haftagun_saat&0x0F);
    *dakika=((dakika_saniye>>12)&0x0F)*10+((dakika_saniye>>8)&0x0F);
    *saniye=((dakika_saniye>>4)&0x0F)*10+(dakika_saniye&0x0F);
}

void loading(int i)
{
    switch(i)
    {
        case 0: ks0108_circle(32,29,4,1,1);ks0108_circle(44,29,4,0,0);ks0108_circle(56,29,4,0,0);ks0108_circle(68,29,4,0,0);ks0108_circle(80,29,4,0,0);ks0108_circle(92,29,4,0,0);break;
        case 1: ks0108_circle(32,29,4,0,0);ks0108_circle(44,29,4,1,1);ks0108_circle(56,29,4,0,0);ks0108_circle(68,29,4,0,0);ks0108_circle(80,29,4,0,0);ks0108_circle(92,29,4,0,0);break;
        case 2: ks0108_circle(32,29,4,0,0);ks0108_circle(44,29,4,0,0);ks0108_circle(56,29,4,1,1);ks0108_circle(68,29,4,0,0);ks0108_circle(80,29,4,0,0);ks0108_circle(92,29,4,0,0);break;
        case 3: ks0108_circle(32,29,4,0,0);ks0108_circle(44,29,4,0,0);ks0108_circle(56,29,4,0,0);ks0108_circle(68,29,4,1,1);ks0108_circle(80,29,4,0,0);ks0108_circle(92,29,4,0,0);break;
        case 4: ks0108_circle(32,29,4,0,0);ks0108_circle(44,29,4,0,0);ks0108_circle(56,29,4,0,0);ks0108_circle(68,29,4,0,0);ks0108_circle(80,29,4,1,1);ks0108_circle(92,29,4,0,0);break;
        case 5: ks0108_circle(32,29,4,0,0);ks0108_circle(44,29,4,0,0);ks0108_circle(56,29,4,0,0);ks0108_circle(68,29,4,0,0);ks0108_circle(80,29,4,0,0);ks0108_circle(92,29,4,1,1);break;
    }
}

int main (void)
{
    FSFILE *yazi;

    float sicaklik;
    int yil,ay,gun,haftagun,saat,dakika,saniye;
    int pre_saniye;

    TRISA=0x80;
    TRISB=0x00;
    TRISE=0x00;
    ks0108_init();

    // SDIN -> RP4 olmalı
    // SDOT -> RP12
    // SCLK -> RP3

    _RP3R=8;
    _RP12R=7;
    _SDI1R = 4;

    // RTC ayarları yapılıyor
    RTC_init(9,2,11,4,20,42,5);

    ks0108_text(20,1,"Karti Takiniz..",1,1);
    // Kartın takılı olup olmadığı kontrol ediliyor
    // Kart takılı ise SD_CD pini sıfır olmalıdır
    while (!MDD_MediaDetect());

    ks0108_fill(0);
    // SD/MMC kart için ilk ayarlamalar yapılıyor
    while (!FSInit());

    LATAbits.LATA1=1;
    
    ks0108_text(1,1,"FxDev-1.TXT",1,1);
    ks0108_line(1,9,60,9,1);
    yazi=FSfopen ("FxDev-1.TXT","r");
    FSfread (receiveBuffer1, 120, 1, yazi);
    while(FSfclose (yazi));
    ks0108_text(1,11,receiveBuffer1,1,1);

    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    ks0108_fill(0);

    ks0108_text(1,1,"FxDev-2.TXT",1,1);
    ks0108_line(1,9,60,9,1);
    yazi=FSfopen ("FxDev-2.TXT","r");
    FSfread (receiveBuffer2, 120, 1, yazi);
    while(FSfclose (yazi));
    ks0108_text(1,11,receiveBuffer2,1,1);

    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    ks0108_fill(0);

    ks0108_text(1,1,"FxDev-3.TXT",1,1);
    ks0108_line(1,9,60,9,1);
    yazi=FSfopen ("FxDev-3.TXT","r");
    FSfread (receiveBuffer3, 120, 1, yazi);
    while(FSfclose (yazi));
    ks0108_text(1,11,receiveBuffer3,1,1);

    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    ks0108_fill(0);

    FSchdir ("\\");
    // FxDev-3.TXT'yi silelim
    while(FSremove ("FxDev-3.TXT"));

    ks0108_text(1,1,"Dosya Silindi",1,1);
        
    LATAbits.LATA0=1;       // Buraya kadar her şey yolundaysa LATA0'a bağlı led yanacak

    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);
    DelayMs(250);DelayMs(250);DelayMs(250);DelayMs(250);

    yazi=FSfopen("DATA.TXT", "w");    // Data Logs.TXT adında bir text dosyası açılıyor

    if (yazi == NULL)
    {
        ks0108_text(1,9,"DATA.TXT Yaratilamadi",1,1);
        while(1);
    }
    else
    {
        ks0108_text(1,9,"DATA.TXT Olusturuldu",1,1);
    }

    FSfwrite(sendBuffer1, 1, strlen(sendBuffer1), yazi);
    FSfwrite(sendBuffer2, 1, strlen(sendBuffer2), yazi);
    FSfwrite(sendBuffer3, 1, strlen(sendBuffer3), yazi);
    FSfclose (yazi);

    ks0108_text(1,17,"Kayit Basladi",1,1);
    	
    RTC_read(&gun,&ay,&yil,&haftagun,&saat,&dakika,&saniye);
    pre_saniye=saniye;
    yazi=FSfopen ("DATA.TXT","a");

    for(;;)
    {
        RTC_read(&gun,&ay,&yil,&haftagun,&saat,&dakika,&saniye);
        loading(saniye%6);

        if((((saniye%10)-(pre_saniye%10))==5)||(((pre_saniye%10)-(saniye%10))==5))
        {
            pre_saniye=saniye;
            sicaklik=ds18b20_read();
            sprintf(sendBuffer4,"%0.2d/%0.2d/%0.2d\t%0.2d:%0.2d:%0.2d\t%3.1f\r\n", gun,ay,yil,saat,dakika,saniye,sicaklik);
            FSfwrite(sendBuffer4, 1, strlen(sendBuffer4), yazi);
            LATAbits.LATA1^=1;      // LATA1'e bağlı led her data girişinde toggle yapacak
        }

        if(PORTAbits.RA7)
        {
            DelayMs(50);
            while(PORTAbits.RA7);
            break;
        }
    }

    LATAbits.LATA2=1;
    FSfclose (yazi);
    ks0108_text(1,34,"Kayit Sonlandi",1,1);
    
    for(;;);
}

Yukarıdaki kodlarda görülen taralı alanların Micro SD kart ile ilgili olduğunu belirtmek isterim. Bu fonksiyonların ne işe yaradıklarını Microchip’in 01045b kodlu uygulama dökümanında bulabilirsiniz.

Uygulamaya ait fotoğraflara aşağıdan bakabilirsiniz. Fotoğraflar cep telefonundan çekildiğinden kaliteleri düşük olabilir.

Bitirirken..

FxDev.org’un en uzun teknik yazısını bitirirken SD/MMC, FAT ve data logger konularına değinmeye ve anlatmaya çalışırken bunu özellikle cluster şöyledir, buna bu kadar veri yollanmalıdır, cevap şu alınmalıdır tarzı açıklamalarla kafa bulandırmamaya, en kısa yoldan SD/MMC karta FAT dosya sistemiyle veri yazma/okuma işlemlerinin nasıl yapıldığını anlatmaya çalıştım.

Son olarak Chan FatFs tutkunları için de ARM çalışmalarıma başladığımda bir uygulama yapmak istediğimi söyleyerek herkese çalışmalarında başarılar diler, her türlü soruyu yorum bölümüne beklerim.

MDD File System kütüphanesine ait dosyalar;