Bu konularla pek ilgisi olmayan bir kişinin “bu tasarım ne işime yarayacak” sorusuna şöyle cevap verebilirim; hepimiz öyle ya da böyle regülatör tasarımı ya da step down, step up, izolasyonlu topojiler kullanarak güç kaynakları yapıyor ya da satın alıyoruz. Özellikle bazı uygulamalarda ya da aldığımız ürünün kalitesini, ne kadar zorlayabileceğimizi görmek için gerilim/akım grafiklerine gerek duyuyoruz.
Örneğin aldığımız bir SMPS 24V/10A kaynağının gerçekteki regülasyonu bilmek, ileride yapacağımız uygulama için önemli olabilir. Bu bir güneş panelinden, DC motora, herhangi bir pilden, adaptölere kadar uzanabilmektedir. Yaptığımız cihaz ise bu grafiği sadece 10-15 saniye gibi bir aralıkta bizlere sunmaktadır. Bu da güç kaynağımızın kalitesi hakkında bize yorum yapma olanağı sağlar.
Bunun yanında proje özellikle bataryalarla çok fazla çalışan, telsizciler, hobi araçlar, quadrotorlar ve daha bir çok batarya kullanılan alanda bataryanın performansını ölçmek için kullanılabilir.

1) Digital Dummy Load (Dijital Yük)
Örnek olarak kendi evimde hobi amaçla kullandığım bilgisayar güç kaynağının 12V çıkışının gerilim akım grafiğini göstermek istiyorum. Grafiği yorumlarsak regülasyonun oldukça kötü olduğunu söylemek mümkündür (resme tıklarsanız büyür).Aşağı yukarı 10 yıllık bir güç kaynağının (SMPS tamircileri daha iyi bilecektir) çıkış kapasitörlerinin değer kaybetmesinden dolayı bu sorunun olabileceğini düşünerekten çıkışa sağlam kapasitörler bağlandığında elde edilen aşağıdaki grafik ise yukarıdakine nazaran bize daha iyi regülasyon sağlamaktadır (resme tıklarsanız büyür).Akım gerilim grafiğinin kapasite bağlandıktan sonraki ölçümünü ve cihazın genel özelliklerini aşağıdaki videodan izleyebilirsiniz (tam ekran ve yüksek çözünürlükte izlemenizi öneririm).

Click here to view the embedded video.

2) Battery Capacity Tester (Batarya Kapasite Testi)
Batarya testi aslında oldukça basit bir testtir. Genel itibari ile belirlenen sabit bir akım değeri, belirli bir süre boyunca çekilir. Grafiğin altında kalan alan ise bizlere kapasite değerini Ah birimiyle geri döndürür.
Örneğin; 7.2V 1500mAh bir bataryamız olduğunu düşünelim. Bu değer bize bu bataryadan 1.5A’i 1 saat boyunca alabileceğimizi söylemektedir. Peki aklımıza şu soru gelebilir; 1 saat uzun bir süre bunu 15dk gibi kısa bir sürede yükleyip tam kapasite değerini ölçemez miyiz? Aslında ölçebiliriz, örneğin bir batarya bir saat boyunca 1.5A verebiliyorsa, 15dk için 6A verebilir. Yalnız gerek sıcaklık, gerekse diğer etmenler nedeniyle hiç bir zaman bu örnekteki bataryadan 15dk boyunca 6A çekemeyiz. Bu durum Alman bilimadamı W. Peukert tarafından 1897′de Peukert denklemi ile aşağıdaki şekilde açıklanmıştır.

Sonuç olarak…

Belki herkesin değil fakat benim gibi güç elektroniği konusuna meraklı arkadaşların bu tür bir cihaza sahip olmaları bence oldukça önemli. Örnek olarak daha önce burada ve burada yaptığım incelemelerde dirençleri paralel bağlayarak ancak uygun yükleme işlemini gerçekleştirdiğimi hatırladığımda ya da bir bataryanın testi için 1 saate yakın bir lambayı yaktığımda böyle bir aracın benim için vazgeçilmez olduğunu anladım. Şu an için ürün her ne kadar ilk versiyonda olsa elde edilen sonuç bence oldukça tatmin edici.

Yukarıda tanıttığım ve geliştirmesini üstlendiğim ürünün hazır halini satın almak isteyen arkadaşlar iletişim bölümünden benimle irtibata geçebilir artı daha fazla bilgiyi mail yoluyla öğrenebilirler.

Her türlü sorunuzu, tasarım ile ilgili düşüncelerinizi yorum kısmından bana ulaştırabilirsiniz..
Herkese çalışmalarında başarılar, bol elektronikli günler dilerim..

Özellikle bir konuda çalışmaya başlamadan önce yapılan ön hazırlıkları ve sitemde daha önce hiç PCB örneği paylaşmadığım için hazırladığım bu yazıyı bitirirken ileride yapacağım USB çalışmalarımın detaylarını yine buradan paylaşacağımı hatırlatmak isterim.
Yapacağım çalışmalarımı CCS C ile yapmayacağımdan, bu konuda bana gelecek soruları cevapsız bırakacağımı şimdiden söylemeliyim. Onun için herkesi C18‘e davet ediyorum

Yazıyla ilgili tüm PCB şematik ve baskı devre dosyalarına, ilgili programlara ve resimlere buradan ulaşabilirsiniz. Son olarak devre çiziminde Eagle 5.11.0 kullandığımı söylemek isterim.

Ayrıca yukarıda resmi görülen kiti edinmek isteyenler bana mesaj yoluyla ulaşabilirler.

Herkese çalışmalarında başarılar dilerim..

Özellikle tez çalışmalarım sırasında, C# ile bilgisayar arayüzü geliştirirken bir yazı dizisini, belirli süreyle seri porttan göndermem gerekti. Bunun gibi ihtiyaçları Terminal v1.9b programını geliştirenler görmüş olacaklar ki, programa 3 adet makro tanımlama bölgesi koymuşlar. Her ne kadar bu programı sevmesem de, programı tez geliştirme süresince kullanıyor olmak beni ayrıca sinirlendirdi ve beni seri port terminal programımın 1.1 sürümünü çıkarmaya zorladı.

Bu sürümde programa eklenen özellikleri ise aşağıdaki tablodan görebilirsiniz.

Programın yeni sürümüne ait görüntüyü aşağıdan görebilirsiniz.

Programın son sürümünü buradan veya buradan indirebilirsiniz.
Herkese çalışmalarında başarılar dilerim.

- Spagetti kod yazımı, yani sonsuz for, binlerce if/else’den kurtulmak,
- Kodların bakımını daha kolay yapabilmek ve kodun bölümlerini daha keskin belirleyebilmek,
- Bizim için acil olan işlemleri, tam belirlenen sürede yaptırabilmek,
- Görünürde paralel işlem yapabilmek için.

Normal kod yazdığımızı düşündüğümüzde işlemlerimizi bir sıraya sokar, bir kesme yardımıyla bu işlemleri sırasıyla yürütürüz. Elbette kısa kod parçaçıkları yazdığımızda bunu kontrol etmesi ve yönetmesi bizim için kolaydır, fakat onlarca kontrol mekanizması işin içine girdiğinde sistemin takibi ve bakımı oldukça zorlaşır ve işin içinden çıkılamaz noktaya gelinir. İşte bu noktada RTOS işin içine girer. Burada unutulmaması gereken iki konu vardır, RTOS sisteminize artı bir hız katmaz, işleyiş organizasyonu ve yönetimi katar. Tasarlanan RTOS sistemleri kurulduğu sistemden bağımsızdır ve bunun için neredeyse tüm RTOS’ların farklı mikrodenetleyicilerle de rahatça çalıştığı görülür.

RTOS tercihleri konusunda ise oldukça fazla alternatifiniz var. İnternette “RTOS” diye aradığınızda bedava veya ücretli binlerce RTOS ile karşılaşıyorsunuz. Ben ise bedava olduğu ve 8 bitlik mikrodenetleyicilerde kolay bir biçimde kullanmak için OSA RTOS’u tercih ettim. İlgili sistemi incelemek ve indirmek için buraya tıklayabilirsiniz. Bu yazıda yaptığım örneğin ise yapım aşamalarını aşağıdaki videodan izleyebilirsiniz(1080p ve tam ekran izlemenizi öneririm). RTOS kullanımına geçmeden önce OSA RTOS’un yardım dosyasını çok dikkatli bir şekilde okumanızı şiddetle tavsiye ediyorum. Gerçekten en ince ayrıntısına kadar özenilerek hazırlanmış bir kaynak.

Click here to view the embedded video.

// www.FxDev.org

#include < p18f2520.h >

// Fuse ayarlamaları, ayrıntılı bilgi için C18 help dosyasına bakılmalı
#pragma config OSC      = HSPLL
#pragma config FCMEN    = OFF
#pragma config IESO     = OFF
#pragma config PWRT     = ON
#pragma config BOREN    = ON
#pragma config BORV     = 1
#pragma config MCLRE    = ON
#pragma config LPT1OSC  = OFF
#pragma config PBADEN   = OFF
#pragma config STVREN   = OFF
#pragma config DEBUG    = OFF
#pragma config WDT      = OFF
#pragma config LVP      = OFF

int i,flag;

void PIC_Init(void)
{
    LATC            = 0x00;
    TRISC           = 0x00;

    T1CON           = 0x80;     // 16bit mode
    TMR1H           = 0xD8;     // 1ms'de bir kesme için değerler yükleniyor
    TMR1L           = 0xF0;

    INTCON = 0;
    INTCONbits.PEIE = 1;
    PIR1bits.TMR1IF = 0;        // Timer1 kesme bayrağı siliniyor
    PIE1bits.TMR1IE = 1;        // Timer1 kesmesi aktif
    T1CONbits.TMR1ON= 1;        // Timer1 çalıştırılıyor
    INTCONbits.GIE  = 1;        // Kesmeler açılıyor
}

void main(void)
{
    PIC_Init();                     // Pic için genel ayarlar yapılıyor

    for(;;)
    {
        if(flag)
        {
            flag=0;
            i++;
            if((i%100)==0) {LATCbits.LATC0^=1;}
            if((i%200)==0) {LATCbits.LATC1^=1;}
            if((i%300)==0) {LATCbits.LATC2^=1;}
            if((i%400)==0) {LATCbits.LATC3^=1;}
        }
    }
}

/*//////////////////////  Kesme Rutinleri \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/
void kesme(void);       // Kesme fonksiyonu tanımlanıyor
                        // Ayrıntılı bilgi için C18 User Guide Interrupt Kısmına bakılmalı
//----------------------------------------------------------------------------

// Yüksek öncelikli kesme vektörü
#pragma code InterruptVectorHigh = 0x08
void InterruptVectorHigh (void)
{
  _asm
    goto kesme         //Kesmeye atla
  _endasm
}
#pragma code

#pragma interrupt kesme
void kesme(void)
{
    if (PIR1bits.TMR1IF)
    {
        PIR1bits.TMR1IF = 0;
        TMR1H           = 0xD8;     // 1ms'de bir kesme için değerler yükleniyor
        TMR1L           = 0xF0;
        flag=1;
    }
}

Şimdi de aynı işlemi OSA RTOS kullanarak yazalım.

// www.FxDev.org
// OSA RTOS Örneği
#include < p18f2520.h >
#include < osa.h >

// Fuse ayarlamaları, ayrıntılı bilgi için C18 help dosyasına bakılmalı
#pragma config OSC      = HSPLL
#pragma config FCMEN    = OFF
#pragma config IESO     = OFF
#pragma config PWRT     = ON
#pragma config BOREN    = ON
#pragma config BORV     = 1
#pragma config MCLRE    = ON
#pragma config LPT1OSC  = OFF
#pragma config PBADEN   = OFF
#pragma config STVREN   = OFF
#pragma config DEBUG    = OFF
#pragma config WDT      = OFF
#pragma config LVP      = OFF

void PIC_Init(void)
{
    LATC            = 0x00;
    TRISC           = 0x00;

    T1CON           = 0x80;     // 16bit mode
    TMR1H           = 0xD8;     // 1ms'de bir kesme için değerler yükleniyor
    TMR1L           = 0xF0;

    INTCON = 0;
    INTCONbits.PEIE = 1;
    PIR1bits.TMR1IF = 0;        // Timer1 kesme bayrağı siliniyor
    PIE1bits.TMR1IE = 1;        // Timer1 kesmesi aktif
    T1CONbits.TMR1ON= 1;        // Timer1 çalıştırılıyor
}

void Task_1(void)
{
    for(;;)
    {
        OS_Delay(100);
        LATCbits.LATC0^=1;
    }
}

void Task_2(void)
{
    for(;;)
    {
        OS_Delay(200);
        LATCbits.LATC1^=1;
    }
}

void Task_3(void)
{
    for(;;)
    {
        OS_Delay(300);
        LATCbits.LATC2^=1;
    }
}

void Task_4(void)
{
    for(;;)
    {
        OS_Delay(400);
        LATCbits.LATC3^=1;
    }
}

void main(void)
{
    PIC_Init();                     // Pic için genel ayarlar yapılıyor

    OS_Init();                      // RTOS ilk ayarları yapılıyor

    OS_Task_Create(1,Task_1);       // 1. task oluşturuluyor, öncelik 1
    OS_Task_Create(2,Task_2);       // 2. task oluşturuluyor, öncelik 2
    OS_Task_Create(3,Task_3);       // 3. task oluşturuluyor, öncelik 3
    OS_Task_Create(4,Task_4);       // 4. task oluşturuluyor, öncelik 4

    OS_EI();                        // Kesmeler açılıyor
    OS_Run();                       // RTOS çalıştırılıyor
}

/*//////////////////////  Kesme Rutinleri \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/
void kesme(void);       // Kesme fonksiyonu tanımlanıyor
                        // Ayrıntılı bilgi için C18 User Guide Interrupt Kısmına bakılmalı
//----------------------------------------------------------------------------

// Yüksek öncelikli kesme vektörü
#pragma code InterruptVectorHigh = 0x08
void InterruptVectorHigh (void)
{
  _asm
    goto kesme         //Kesmeye atla
  _endasm
}
#pragma code

#pragma interrupt kesme
void kesme(void)
{
    if (PIR1bits.TMR1IF)
    {
        PIR1bits.TMR1IF = 0;
        TMR1H           = 0xD8;     // 1ms'de bir kesme için değerler yükleniyor
        TMR1L           = 0xF0;
        OS_Timer();
    }
}

Her iki kodu da derlediğimizde aşağıda göreceğiniz üzere, yer konusunda aralarında bariz bir fark oluşmamaktadır.Fakat bu örnekte tam olarak belli olmasa da öncelik atayabilme, işi zamanında tamamlama, büyüyen kod öbeklerinde anlaşılabileceği gibi sistemin takip edilebilirliğinin kolay olmasından RTOS tercihimiz olacaktır.
Örneğin elinizde 10ms’de bir ADC’den örnek alan, alınan değeri 0.5ms’de bir PI, PID’den geçiren ve tüm sonuçları 200ms’de bir bilgisayara aktaran, 50ms’de bir ise sistemin tepkisini değiştiren yazılım parçaları bulunsun. Bunu if/else’ler ile oluşturmaktansa RTOS’un bize sunduğu Task’larla yapmak hem kolay hem de anlaşılır olacaktır. Dahası sürelerin kesin ve görevlere kolaylıkla öncelik atanabilmesi de cabası.

RTOS ile ilgili giriş yazımı kapamadan önce, ileriki RTOS örneklerimde kullanacağım OSA RTOS‘un 10F’ten 24F’e, AVR ve STM’e kadar mikrodenetleyici ve C18, C30, CCS C, Hi-Tech, WinAVR gibi çok farklı derleyiciler için rahatça kullanılabildiğini belirtmek isterim.

İleride daha komplike örnekler ve OSA RTOS’un derin görevlerini de ele almayı düşünüyorum.
Herkese çalışmalarında başarılar dilerim.

Dip Not: Kodları Rus’lar yazdığı için de müzik onlara özel..

Günümüzde ister elektronik isterseniz de elektriğe gönül vermiş olun, şartlar herkese bir mikrodenetleyici ya da bir mikroişlemciyi öğrenme zorunluluğu getirmiştir. Özellikle yeni başlayan birinin kafasındaki en büyük problemler ise nereden, hangi kaynak ve dil ile hangi donanımı öğreneceğinin yanında bunu hazır bir kitle yapıp yapmayacağıdır. Profesyonel bir kişi için ise kullanılacak kit üzerinde barındırdığı donanım ve kullanım kolaylığı açısından ele alınır. Ayrıca yine günümüzde zaman ve para oldukça değerli olduğundan, alınacak herhangi bir elektronik kitin, çabuk ve ucuz elimizde olması da ayrıca istediğimiz bir durumdur.
Tüm bunlar ve Türkiye şartlarını göz önünde bulundurduğumuzda bir elin parmağını geçmeyen bir kaç firma içerisinden ExpKits özellikle öğrenci dostu olması nedeniyle diğerlerinden bir adım öne çıkmaktadır. Özellikle ürettiği ürünün kalite, yardım ve desteği konusunda benzerlerine nazaran çok az sorun yaşanmaktadır.

Expkits’in piyasaya geçtiğimiz ay sürdüğü ExpKits EX33DS, özellikle 32 bit, ARM ve PIC mikrodenetleyicilerine giriş yapacaklar için oldukça ideal bir tasarım. Kit, yukarıdaki resimde görüldüğü gibi, tek başına aslında bir donanım kartı. Üzerinde kullanılmak üzere aşağıdaki donanımları barındırmakta;
- 2×16 LCD giriş soketi,
- 128×64 ve 240×128 GLCD giriş soketleri,
- RS232, RS485, RF, IRDA, PS2 gibi klasikleşmiş haberleşme ve bunların yanında,
- ENC28J60 kontrollü Ethernet birimi,
- Servo motor sürme soketleri,
- DS18B20, SHT7XX, I2C EEPROM birimleri,
- 64 adet led ve yine 64 adet giriş birimi,
- Bu birimlerin Pull-Up ya da Pull-Down ayarlanabilmesi,
- Joystick ve 4×4 keypad,
- 2 adet röle ve yine 2 adet optocoupler,
- MiniSD kart yuvası,
- 4×7 segment ve Buzzer,
- GLCD’ler için touch screen soketi,
- 2 adet harici pot ve uygulama için bir adet LDR,
- USB’den haberleşme ve enerjisini yine buradan sağlama gibi daha bir çok özellik.

Yukarıdaki listeden de görülebileceği gibi eğitim için kullanılmak üzere tasarlanmış ve her türlü ihtiyacı karşılayan bir tasarım olmuş. Tasarlanan bu donanım kartını tek başına kullanmak mümkün olmasa da yine ExpKits’in ürettiği MCU kartları ile ürünü istediğiniz mikrodenetleyiciye göre kullanmak mümkün. Bu da bizleri her yeni mikrodenetleyici için yeni bir kit alımı yapmaktan ve gereksiz masraflardan kurtarmakta. Ayrıca karta özel kendi tasarımımızı yaparak donanım kartını istediğimiz mikrodenetleyici ile kullanmak ise sadece sizin yeteneğinizle sınırlı. Özellikle Türkiye’de ARM kiti eksikliği yaşayan ve ARM konusuna yeni başlayacaklara yurtdışındaki değişik firmaların kitleri yerine bu kit şiddetle önerimdir.

Kitin en güzel ve benim için en önemli konusu ise örnek kodların açıklamalarının Türkçe ve diğer firmalar gibi örnek kodların firmanın kendine has programıyla yazılmamış olmasıdır. Bu da bizlere çalışmalarımızda kolaylık sağlamaktadır. Genel geçer kurala göre; 16 Bit PIC’ler C30, ARM ailesi ise Keil ile programlanır. Onun içindir ki firmanın örnek kodlarını bu derleyicilerle çıkarması ve kullanıcılara bunu rahatça sunması bence çok önemli ve artı puan.

Hazırlanan kit bize donanım sunduğundan, hazır kitlerde görmeye alıştığımız herhangi bir programlayıcıyı üzerinde barındırmamaktadır. Bunun yerine programlama işi PIC MCU kartlarında ICSP’den, ARM MCU kartları ise gerek JTAG üzerinden gerekse seri port+Flash Magic programı ile sağlanmaktadır.

Sonuç olarak Türkiye şartları ele alındığında piyasaya çıkmış olan bu kart biz öğrenciler ve kendini geliştirmek isteyenler için güzel özelliklere sahip, işlevli bir kit olmuştur.

Kiti incelemek isteyen arkadaşlar buraya basarak kitin tanıtım sayfasına ve yazılmış örnek kodlara ulaşabilirler.

Kit konusunda merak ettiğiniz her tür sorunuzu yorum kısmından bana ulaştırırsanız elimden geldiğince sizlere yardımcı olmaya çalışırım.

Herkese çalışmalarında başarılar dilerim.

Peki bir elektronikçinin, bir programlayıcıdan beklentileri nelerdir?
Bu sorunun yanıtı kişiden kişiye, uygulamadan uygulamaya değişmekle birlikte, bir programlayıcıdan beklenen genel geçer istekler aşağıdaki gibi sıralanabilir;

1) Desteklediği PIC, EEPROM vb. aygıtların sayısının oldukça fazla olması, son çıkan ürünlere hızlı adapte olabilmesi,
2) Firmware güncellemelerinin çok hızlı bir biçimde gerçekleştirmesi,
3) Her türlü gerilim aralığını, PIC’ler için bu 3.3 ve 5V oluyor, desteklemesi,
4) Çok hızlı bir şekilde program atılabilmesi,
5) Programlayıcılar için vazgeçilmez olan ve bu konuda ilerlemek isteyenlerin mutlaka kullanacağı hata ayıklama yani debugger özelliğinin olması,
6) MPLAB, Hi-Tide veya benzeri IDE’lere uyum sağlaması,
7) Sadece bir programlayıcı olarak değil, gerektiğinde seri port ve logic analyzer olarak kullanılabilmesi,
8) Programmer-To-Go özelliğini bulunması,
9) ZIF soket barındırması.

Yukarıdaki çoğu maddeyi, PIC programlamaya yeni başlayan birinin anlaması elbette beklenemez. Fakat klasik hale gelen fiyat/performans durumu herkes için ön plandadır. Hem bunu düşünerek, hem de yeni başlayan kullanıcılara yardımda bulunmak amacıyla, elimde bulunan ExpKits PicKit2 Klonu, Memox Brenner ve JDM PIC programlayıcılarını inceledim. Bu programlayıcıların karşılaştırılmarını aşağıdaki tabloda görebilirsiniz.Yukarıdaki tablodan da anlaşılacağı üzere Microchip haklı sebeplerle diğer ürünleri geride bırakıyor. Tabloda dikkatinizi çekmek istediğim bir diğer nokta da Memox Brenner’inin firmware güncellemesinin kapalı gelmesi. Amatör kullanıcıların Memox’un 2 yıllık garantisi bozulur diye tornavida değemedikleri kutuyu açtığınızda ise PIC18F2550′nin soket yerine direk karta lehimlenmiş olduğunu göreceksiniz. Dolayısıyla programlama yapmanız için PIC’i önce lehimlerden sökmeli daha sonra da programlamalısınız. Bu elbette istenmeyen bir durum.
JDM ise seri portlu bir bilgisayarınız varsa özellikle okulda ödevleri öğrenmek için değil de ders geçmek için yapanlar için biçilmiş kaftan.

Sonuç Olarak..

Eğer ileride amacınız mikrodenetleyicilerle haşır neşir olmaksa ve bunlar içinde PIC sık sık kullanacağınız bir donanımsa o halde kesinlikle ister clone ya da orijinal alın, ister kendiniz yapın, kesinlikle bir Pickit2 sahibi olun. İleride bu kararınız size en azından fazla bir programlayıcı edinmekten kurtaracaktır.
Ayrıca elinizin altına JDM tarzı, delikli karta çok kolay yapabileceğiniz bir programlayıcının olması size avantaj sağlayabilir, en olmadık anda günü kurtarabilir.

Dip not: Karşılaştırmayı direk sitelerden ziyade elimde bulunan donanımı test ederek yaptım. Eğer donanımlarınızda var olan ya da olmayan özellikler varsa, bunu bana bildirirseniz sevinirim.

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.
Öncelikle kullanacağımız MDD File System kütüphanesine ait tüm dosyaları buradan indirebilirsiniz. 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. Bu dosyaları buradan indirebilirsiniz.

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.Uygulama verilerini Excel’e atıp grafik çizdirdiğimde ise aşağıdaki sonucu aldım.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.

Dip Not: Çalışmada ExpKits firmasının EX33DS adlı geliştirme kiti ile PIC24FJ256GB110 mikrodenetleyici kartı kullanılmıştır.

Uygulamada temel bileşen ile (50Hz) özellikle elektrik ve güç elektroniği ile ilgilenenlerin başını sıkça ağrıtan ilk 10 harmoniği (150-250-350-450-550-650-750-850-950-1050) algılamaya çalıştım. Yaptığım uygulama ayrıca PIC24F serileri ile örnek alımını ve bu serilerin ADC ve Timer birimlerini öğrenmek isteyenlere güzel bir örnek teşkil edeceğini düşünüyorum.

Yaptığım uygulamaya ait blok diyagram aşağıda görülebilir.Yukarıdaki blok diyagramın görevini yerine getiren kodu aşağıda görebilirsiniz.

/*
 * Yazar: Fırat Deveci (FxDev)
 * Konu : Goertzel Algoritması
 */

#include "p24FJ64GA002.h"
#include "math.h"

_CONFIG1(JTAGEN_OFF & GCP_OFF & GWRP_OFF & BKBUG_OFF & COE_OFF & ICS_PGx1 & FWDTEN_OFF & WINDIS_OFF);
_CONFIG2(IESO_OFF & SOSCSEL_LPSOSC & WUTSEL_FST & FNOSC_FRCPLL & FCKSM_CSDCMD & OSCIOFNC_OFF & IOL1WAY_OFF & I2C1SEL_PRI & POSCMOD_NONE)

#define Fs              5000            // Örnekleme frekansımız, izleyeceğimiz en yüksek frekans değerinin en az iki katı
#define BINS            11              // 11 temel frekans izlenecek
#define Pi              3.141592654     // Pi sayısı tanımlanıyor
#define GOERTZEL_N      100             // 128 örnek alınacak
#define Level_Segment   7
#define divider         16000000/Fs

const int   freqs    [BINS] = {50, 150, 250, 350, 450, 550, 650, 750, 850, 950, 1050};
float       samples  [GOERTZEL_N];

float       coeffs   [BINS];
float       prev1    [BINS];
float       prev2    [BINS];
float       magnitude[BINS];
int         levels   [BINS];
float       n        [GOERTZEL_N];

unsigned char sample_counter    = 0;
unsigned char sample_complete   = 0;

void timer2_init(void)
{
    // 16Mhz/ftimer=PR2 olmalı.
    PR2                 = divider;
    T2CON               = 0x0000;     // 1:1, Fosc/2
    IPC1bits.T2IP       = 6;          // Kesme öncelik sırası 6
    IFS0bits.T2IF       = 0;          // Timer1 kesme bayrağı temizleniyor
    IEC0bits.T2IE       = 1;          // Timer1 kesmesi aktif
    T2CONbits.TON       = 1;          // Timer1 açılıyor
}

void ADC_init(void)
{
    AD1PCFG             = 0xFFFC;       // AN0 ve AN1 ADC portu, diğer AN portları digital I/O
    AD1CON2             = 0x0000;       // AVdd ve AVss seçildi, 28pinli modeller için bunlar zaten VDD ve VSS'ye bağlı
    AD1CON3bits.ADRC    = 0;            // Tcy kullanılacak
    AD1CON3bits.SAMC    = 3;            // Minimum Tad süresi 75ns'den büyük seçilmeli, 32MHz kristal için Tcy=62.5ns, bu değer için 2 yeterlidir
    AD1CON3bits.ADCS    = 2;            // ADCS=(Tad/Tcy)-1 şeklinde seçilir
    AD1CON1             = 0x00E0;       // Atomatik örnekleme ve çevrim yapılacak, ASAM yada SAMP bitine emirle çevrim başlayacak
    AD1CSSL             = 0x0000;       // Auto tarama yapılmayacak
    AD1CON1bits.ADON    = 1;            // ADC açılıyor
}

int ADC_read(unsigned char channel)
{
    AD1CHS              = channel;
    AD1CON1bits.DONE    = 0;
    AD1CON1bits.SAMP    = 1;           // Çevrim başlama komutu veriliyor
    while(AD1CON1bits.SAMP);
    while(!AD1CON1bits.DONE);          // Çevrimin bitmesi bekleniyor

    return ADC1BUF0;
}

// Goertzel için katsayılar hesaplanıyor

void coefficient(void)
{
    unsigned int k, i;
    for(i=0;i < BINS;i++)
    {
        k           =(unsigned int)(0.5 + (float)GOERTZEL_N * freqs[i] / Fs);
        coeffs[i]   = 2.0 * cos(2.0 * Pi * ((float)k/GOERTZEL_N));
    }
}

int goertzel(void)
{
    int big =0,
        i   =0;
    float val = 0,
          max = 0;

    // Geçici dizilerin içerisi temizleniyor
    for(i=0;i < BINS;i++)
    {
        prev2[i]=0;
        prev1[i]=0;
    }

    // GOERTZEL Algoritması İşletiliyor
    for(sample_counter=0;sample_counter < GOERTZEL_N; sample_counter++)
    {
        for(i=0;i < BINS;i++)
        {
            val     = coeffs[i] * prev1[i] - prev2[i] + (float)samples[sample_counter];
            prev2[i]= prev1[i];
            prev1[i]= val;
        }
    }

    // Genlikler belirleniyor
    for(i=0;i < BINS;i++)
    {
        magnitude[i] = (prev1[i] * prev1[i]) + (prev2[i] * prev2[i]) - (coeffs[i] * prev1[i] * prev2[i]);
        if(magnitude[i]>max)
        {
            max=magnitude[i];
            big=i;
        }
    }

    for(i=0;i < BINS;i++)
    {
        levels[i]=(int)(Level_Segment*(float)(magnitude[i]/max));
    }

    return big;
}

int main(void)
{
    CLKDIV=0;
    TRISB=0x0000;

    lcd_init();

    coefficient();
    ADC_init();
    timer2_init();

    lcd_gotoxy(2,1);
    lcd_yaz("FxDev.org");

    for(;;)
    {
        if(sample_complete)
        {
            goertzel();     // Goertzel hesaplanıyor
            lcd_gotoxy(1,1);
            veri_yolla(levels[0]);
            veri_yolla(levels[1]);
            veri_yolla(levels[2]);
            veri_yolla(levels[3]);
            veri_yolla(levels[4]);
            veri_yolla(levels[5]);
            veri_yolla(levels[6]);
            veri_yolla(levels[7]);
            veri_yolla(levels[8]);
            veri_yolla(levels[9]);
            veri_yolla(levels[10]);
            sample_complete = 0;
            sample_counter  = 0;
            IEC0bits.T2IE   = 1;
            T2CONbits.TON   = 1;
        }

    }
}

void __attribute__((__interrupt__, auto_psv)) _T2Interrupt(void)
{
    samples[sample_counter++]=(ADC_read(0)-512);
    if(sample_counter==GOERTZEL_N)
    {
        IEC0bits.T2IE   = 0;
        T2CONbits.TON   = 0;
        sample_complete = 1;
    }
    IFS0bits.T2IF = 0;
}

Yukarıdaki kodun daha önce burada anlattığım C kodlarıyla ne kadar fazla benzerlik gösterdiğini görebilirsiniz.
Uygulamaya ait çalışma videosunu aşağıda seyredebilirsiniz.

Click here to view the embedded video.

Bir başka çalışmada görüşmek üzere.
Herkese kolay gelsin.

PIC24F ve RTC Birimi

Bu uygulamamda kullandığım PIC 24FJ256GB110‘nun dahili RTC’sini kullanmak için öncelikle bir kaç adımı uygulamamız gerekiyor. Bunlardan ilki RTC registerlerine yazım izni vermek ile alakalı. Bu özellikle yazılım güvenliği için çok hoş bir uygulama, çünkü üreticiler genelde RTC’yi fabrika çıkışında bir kez ayarlayıp, ayarladıkları bu RTC değerinin hiç bir koşulda değişmemesini isteyebilirler. Buradan da garanti süresi veya daha çeşitli bilgilere çok kolay erişim sağlayabilirler. Bu özelliği ortadan kaldıran assembly kod öbeğini aşağıda verdiğim kodda görmeniz mümkün.
Daha sonraki işlem ise daha önceki RTC’lerde karşılaşmadığım türden. Örneğin biz 10/01/1988 pazartesi saat 23:50:05′i RTC’mize girmek isteyelim. Bu noktada PIC’in datasheet’ini açıp register yapılarına baktığımızda bizden istenen sayı yapısının sırayla aşağıdaki gibi olduğu görülebilir.

GLCD ve Analog Saat Uygulaması

Analog saatler küçüklüğümden beri hep ilgimi çekmiştir. Özellikle buradaki uygulamayı gördükten sonra ‘bunu neden her yerde bulunabilecek GLCD’lere uygulamayayım’ diye düşünürken bugün en sonunda aşağıda videosunu görebileceğiniz uygulamamı gerçekleştirdim.
Öncelikle oluşturulan saatin piksel sayısının düşüklüğü dolayısı ile çok da hoş görünmediğini fakat benim için yeterli olduğunu söylemek isterim. Ayrıca uygulamamda ortaokulda gördüğümüz trigonometrik denklemleri kullandığımı da belirtmek isterim.
Bunun için yanda görülebilecek birim çemberden yola çıkıp istenilen saniye, dakika, saat değeri için istenilen koordinatlar çok kolay bir şekilde bulunabilir. Örnek bir hesabı sizler için yaparsam:
360derece/60saniye=6 derece/saniye yapar. Buradan her saniyede 6 derece katedileceği görülebilir.
GLCD’mizin x=31 ve y=31 noktası için düşünürsek 1. saniye için değerler; x=31+28*(cos(pi/2-pi*saniye/30)), y=31-28*(sin(pi/2-pi*saniye/30)) olur. Buradaki 28 ise saniye çubuğunun uzunluğudur. Aynı şekilde düşünülerek akrep ve yelkovan da çok kolay bir şekilde oluşturulabilir.
Tüm bunları ele aldığımızda oluşan uygulamaya ait videoyu aşağıdan seyredebilirsiniz.

Click here to view the embedded video.

/*
 * Yazar                : FxDev - Fırat DEVECİ
 * Konu                 : RTC ve GLCD uygulaması
 * Yazar WEB Sitesi     : www.fxdev.org
 */

#include "p24Fxxxx.h"
#include "math.h"
#include "stdio.h"
#include "delay.h"
#include "ks0108.h"

_CONFIG3(WPCFG_WPCFGDIS & WPDIS_WPDIS)
_CONFIG2(IESO_OFF & FNOSC_FRC & FCKSM_CSDCMD & OSCIOFNC_OFF & IOL1WAY_ON & DISUVREG_OFF & POSCMOD_XT)
_CONFIG1(JTAGEN_OFF & GCP_OFF & GWRP_OFF & BKBUG_OFF & COE_OFF & ICS_PGx1 & FWDTEN_OFF & WINDIS_OFF)

#define pi 3.1416

char saat_bilgisi[2]="";

int pre_saniye,
    pre_dakika,
    pre_saat,
    pre_gun,
    pre_ay,
    pre_yil;

int s_x,s_y,s_xx,s_yy,
    m_x,m_y,m_xx,m_xxx,m_yy,m_yyy,
    h_x,h_y,h_xx,h_yy,h_xxx,h_yyy;

void tarih_saat_yaz(int saat, int dakika, int saniye, int gun, int ay, int yil)
{
    if(pre_saniye!=saniye)
    {
        sprintf(saat_bilgisi,"%02d",pre_saniye);
        ks0108_text(104,9,saat_bilgisi,1,0);
        sprintf(saat_bilgisi,"%02d",saniye);
        ks0108_text(104,9,saat_bilgisi,1,1);
        ks0108_line(s_xx,s_yy,s_x,s_y,0);
        pre_saniye=saniye;
    }
    if(pre_dakika!=dakika)
    {
        sprintf(saat_bilgisi,"%02d",pre_dakika);
        ks0108_text(87,9,saat_bilgisi,1,0);
        sprintf(saat_bilgisi,"%02d",dakika);
        ks0108_text(87,9,saat_bilgisi,1,1);
        ks0108_line(m_xx,m_yy,m_x,m_y,0);
        ks0108_line(m_xxx,m_yyy,m_x,m_y,0);
        pre_dakika=dakika;
    }
    if(pre_saat!=saat)
    {
        sprintf(saat_bilgisi,"%02d",pre_saat);
        ks0108_text(70,9,saat_bilgisi,1,0);
        sprintf(saat_bilgisi,"%02d",saat);
        ks0108_text(70,9,saat_bilgisi,1,1);
        ks0108_line(h_xx,h_yy,h_x,h_y,0);
        ks0108_line(h_xxx,h_yyy,h_x,h_y,0);
        pre_saat=saat;
    }
    if(pre_yil!=yil)
    {
        sprintf(saat_bilgisi,"%02d",pre_yil);
        ks0108_text(106,32,saat_bilgisi,1,0);
        sprintf(saat_bilgisi,"%02d",yil);
        ks0108_text(106,32,saat_bilgisi,1,1);
        pre_yil=yil;
    }
    if(pre_ay!=ay)
    {
        sprintf(saat_bilgisi,"%02d",pre_ay);
        ks0108_text(88,32,saat_bilgisi,1,0);
        sprintf(saat_bilgisi,"%02d",ay);
        ks0108_text(88,32,saat_bilgisi,1,1);
        pre_ay=ay;
    }
    if(pre_gun!=gun)
    {
        sprintf(saat_bilgisi,"%02d",pre_gun);
        ks0108_text(70,32,saat_bilgisi,1,0);
        sprintf(saat_bilgisi,"%02d",gun);
        ks0108_text(70,32,saat_bilgisi,1,1);
        pre_gun=gun;
    }
}

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

int main(void)
{
    int saniye=59,
        dakika=15,
        saat=11,
        haftagun,
        gun=10,
        ay=1,
        yil=88;

    TRISB=0x00;
    TRISE=0x00;

    ks0108_init();
    RTC_init(16,12,10,1,20,36,50);

    ks0108_circle(31,31,30,0,1);
    ks0108_circle(31,31,5,1,1);
    ks0108_line(30,0,30,2,1);       // 12 çizgisi
    ks0108_line(30,60,30,62,1);     // 6 çizgisi
    ks0108_line(0,30,2,30,1);       // 9 çizgisi
    ks0108_line(60,31,62,31,1);     // 3 çizgisi

    ks0108_text(70,0,"Saat",1,1);
    ks0108_text(70,9,"  :  :  ",1,1);
    ks0108_text(70,24,"Tarih",1,1);
    ks0108_text(70,32,"  /  /  ",1,1);
    ks0108_text(65,50,"FxDev.org",1,1);

    for(;;)
    {
        RTC_read(&gun,&ay,&yil,&haftagun,&saat,&dakika,&saniye);
        tarih_saat_yaz(saat,dakika,saniye,gun,ay,yil);

        // Saniye okunun yönleri belirleniyor
        s_x=31+28*(cos(pi/2-pi*saniye/30));
        s_y=31-28*(sin(pi/2-pi*saniye/30));
        s_xx=31+7*(cos(pi/2-pi*saniye/30));
        s_yy=31-7*(sin(pi/2-pi*saniye/30));

        // Dakika okunun yönleri belirleniyor
        m_x     =31+25*(cos(pi/2-pi*dakika/30));
        m_y     =31-25*(sin(pi/2-pi*dakika/30));
        m_xx    =31+7*(cos(pi/2-pi*dakika/30-pi/12));
        m_yy    =31-7*(sin(pi/2-pi*dakika/30-pi/12));
        m_xxx   =31+7*(cos(pi/2-pi*dakika/30+pi/12));
        m_yyy   =31-7*(sin(pi/2-pi*dakika/30+pi/12));

        // Saat okunun yönleri belirleniyor
        if(saat>12)saat-=12;
        h_x     =31+19*(cos(pi/2-pi*((saat*5)+dk/12)/30));
        h_y     =31-19*(sin(pi/2-pi*((saat*5)+dk/12)/30));
        h_xx    =31+7*(cos(pi/2-pi*((saat*5)+dk/12)/30-pi/12));
        h_yy    =31-7*(sin(pi/2-pi*((saat*5)+dk/12)/30-pi/12));
        h_xxx   =31+7*(cos(pi/2-pi*((saat*5)+dk/12)/30+pi/12));
        h_yyy   =31-7*(sin(pi/2-pi*((saat*5)+dk/12)/30+pi/12));

        ks0108_line(s_xx,s_yy,s_x,s_y,1);
        ks0108_line(m_xx,m_yy,m_x,m_y,1);
        ks0108_line(m_xxx,m_yyy,m_x,m_y,1);
        ks0108_line(h_xx,h_yy,h_x,h_y,1);
        ks0108_line(h_xxx,h_yyy,h_x,h_y,1);
    }
}

Konuyla ilgili her türlü soruyu bana yorum bölümünden iletebilirsiniz.
Herkese çalışmalarında başarılar dilerim.

* Müzik: Gülden Gökşen – Türkicaz
* Uygulamanın gerçekleştirildiği ExpKits EX33DS geliştirme kartı için ExpKits‘e teşekkürler.

Click here to view the embedded video.

*Müzik: Fullmetal Alchemist Original Soundtrack 2 – Lapis Philosophorum (Piano Solo)