Kısaca değinmek gerekirse, Dr. Gerald Goertzel’in 1958 yılında yayınladığı Goertzel algoritması sinyalin içerisindeki frekans bileşenlerini çözen dijital sinyal işleme tekniğidir. Temel FFT algoritması tanımlı bir bant aralığındaki frekans bileşenlerini bizlere sunarken Goertzel algoritması sadece belirlenen, spesifik frekans bileşenlerini bizlere sunmaktadır.

Algoritmanın matematiksel ifadesi aşağıdadır:

Durum diyagramı:
a) Örnekleme Oranı
Goertzel algoritmasında, aynen FFT’de olduğu gibi, örnekleme frekansı, belirlenmesi istenen frekansların en büyüğünün en az iki katı olmalıdır.

b) Blok Boyutu
Goertzel blok boyutu N aynı FFT’de olduğu gibi filtre sonucunda çıkacak frekans çözünürlüğüne etki eder. Blok boyutunu N ile temsil edersek frekans çözünürlüğü aralığı fs/N olacaktır. Örneğin örnekleme frekansı fs=8kHz, filtre uzunluğu N=100 seçilirse sonuçta çıkacak frekans çözünürlüğü 80Hz olacaktır.
Blok boyutunu büyük seçmek, özellikle düşük frekans bileşenlerinin daha iyi kararlılıkla belirlenmesine yol açsa da büyük seçilen blok boyutu Goertzel algoritması hesaplamasını bir o kadar uzatacaktır. Dolayısıyla blok boyutu seçiminde bu iki kriter göz önüne alınarak optimum seçimin yapılması gerekmektedir. Son olarak seçilecek olan N değeri, FFT’nin aksine, 2’nin katları olmak zorunda değildir.

c) Sabitler
Goertzel algoritmasını hesaplamadan önce Goertzel algoritmasının kullanacağı katsayıları hesaplamak işlemler sırasında algoritma çözümüne hız kazandıracaktır.
Yukarıdaki katsayılar her bir tespit edilecek frekans için ayrı ayrı bulunur. Yukarıdaki N sayısı blok boyutunu temsil etmektedir.

d) Temel Goertzel
Temel Goertzel algoritması DFT ve FFT’de olduğu gibi geriye sanal frekans bileşenlerini sunar. Genlik ve faz bilgileri geriye dönen bu sanal bileşenlerden yola çıkılarak hesaplanabilir.
Geortzel algoritması hesabında Q0, Q1 ve Q2’den oluşan 3 değişken sürekli hesaplanmak zorundadır.
Bu değişkenlerin başlangıç değerleri sıfır olmak koşuluyla Goertzel algoritması aşağıdaki gibi yazılabilir.

Yukarıdaki denklemler N kez tekrarlanır.
Daha sonra ortaya çıkan Q0, Q1 ve Q2 sayıları aşağıdaki denklemlerde kullanılır.
Yine bu denklemler belirlenecek frekans sayısı kadar tekrarlanarak her bir frekans için genlik değeri bulunmuş olur.

e) Optimize Edilmiş Goertzel
Optimize edilmiş Goertzel algoritması faz açıları yerine sadece genliklere odaklanır ve temel Goertzel algoritmasından daha az işlem yapılmasını sağlar.
Q0, Q1 ve Q2 katsayıları hesaplandıktan sonra temel Goertzel’den farklı olarak yapılması gereken tek işlem;
Mikrodenetleyiciler ile bu işlem yapılırken genliği büyük olan işleme alınacaksa karekök alma işlemine gerek yoktur. Dolayısıyla buradan denklem aşağıdaki forma dönüşür.

f) FFT ve Goertzel Algoritmasının Karşılaştırılması
Yüksek sayıda örnek için FFT her ne kadar avantajlı gözükse de Goertzel düşük sayıda frekansı çözümlemek için FFT’den daha hızlıdır. Genel anlamda N blok boyutu için FFT N(log2)N Goertzel (5/6)(log2)N kadar işlem yapmaktadır.

g) Matlab Uygulaması
Goertzel algoritması için her ne kadar Matlab kendi fonksiyonunu barındırsa da yukarıdaki denklemleri kullanarak yazdığımız .m kodlarını aşağıda görebilirsiniz. Aşağıdaki kodlardan da görülebileceği üzere DTMF keypad tuşlarından 3 örneklenmiştir.

% Yazar: Fırat DEVECİ
% Konu : Goertzel Algoritması

clear all;
Fs   = 4000;           % Örnekleme frekansı
n=0:1/Fs:0.1;           % Örnek
Goertzel_N=length(n);   % Goertzel örnek sayısı

freq=[697, 770, 852, 941, 1209, 1336, 1477, 1633];  % Bulmak istediğimiz frekans bileşenleri
Bins=length(freq);                                  % Kaç adet frekans bulacağımız bilgisi
samples=sin(2*pi*697*n)+sin(2*pi*1477*n);           % Örneklediğimiz sinyal
sound(samples);                                     % Ses çalınıyor

for i=1:Bins                            % Goertzel katsayıları hesaplanıyor
    k(i)=(0.5+(Goertzel_N*freq(i))/Fs);
    coeffs(i)=2*cos(2*pi*k(i)/Goertzel_N)
end

prev1=[zeros(Bins)];
prev2=[zeros(Bins)];

for i=1:Goertzel_N                      % Hangi frekansın baskın olduğu bulunuyor
    for j=1:Bins                        % Goertzel algoritması
        val=coeffs(j)*prev1(j)-prev2(j)+samples(i);
        prev2(j)=prev1(j);
        prev1(j)=val;
    end
end

for i=1:Bins                            % Genlikler bulunuyor
    magnitude(i)=sqrt((prev1(i)*prev1(i)+prev2(i)^2)-(coeffs(i)*prev1(i)*prev2(i)));
end

freq_indices = round(freq/Fs*Goertzel_N)+1;
dft_data = goertzel(samples,freq_indices);

subplot(3,1,1);
plot(n,samples);
title('Sinyal Şekli');
subplot(3,1,2);
stem(freq,abs(magnitude));              % Ekrana basılıyor
set(gca,'xtick',freq);
xlabel('Hz');
ylabel('Magnitude');
title('Kendi Goertzel Algoritmamızın Yanıtı');
subplot(3,1,3);
stem(freq,abs(dft_data));
set(gca,'xtick',freq);
xlabel('Hz');
ylabel('Magnitude');
title('Matlab Goertzel Algoritmasının Yanıtı');

Yukarıdaki kod işletildiğinde ekrana aşağıdaki şekil (üzerine tıklarsanız büyür) ortaya çıkmaktadır. Görüldüğü üzere kendi yazdığımız optimum Goertzel algoritması oldukça sağlıklı sonuç vermektedir.
h) ANSI C Uygulaması
Yukarıda Matlab için yaptığımız uygulamayı ANSI C ortamına taşırsak aşağıdaki kod öbeğine ulaşmış oluruz.

/*
Yazar: Fırat DEVECİ
Konu : Goerzel Algoritması
*/

#include "stdio.h"
#include "stdlib.h"
#include "math.h"

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

const int   freqs    [BINS] = {697, 770, 852, 941, 1209, 1336, 1477, 1633};
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;

// 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ı iş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()
{
    int i,buyuk;
    float a;
    coefficient();

    for(i=0;i < GOERTZEL_N;i++)
        samples[i]=sin(2*Pi*697*i/4000)+sin(2*Pi*1477*i/4000);

    buyuk=goertzel();

    printf("Yazar: Firat DEVECI\n");
    printf("Konu : Goertzel Algoritmasi\n\n");
    printf("En Buyuk Genlik: %d\n\n",buyuk);
    printf("Frekanslar      Katsayilar      Goertzel Sonucu\n");

    for(i=0;i < BINS;i++)
    {
        if(i==buyuk)
            printf("%d\tHz -    %f\t -  %d*\n",freqs[i],coeffs[i],levels[i]);
        else
            printf("%d\tHz -    %f\t -  %d\n",freqs[i],coeffs[i],levels[i]);

    }

        getch();
}

Yukarıdaki kodlar herhangi bir C (Code Blocks vb.) derleyicide derlendiğinde aşağıdaki çıktı ekranı ile karşılaşılır.Sonuç
Goertzel algoritması yukarıdaki örneklerden de görüleceği üzere anlaşılması kolay, FFT'ye göre oldukça hızlı ve özellikle düşük güçteki mikrodenetleyiciler ile kolaylıkla kullanılabilecek yapıdadır. Özellikle DTMF kod çözümleme uygulamalarında tercih edilmesinin altında bu yatmaktadır.

Gelecek bölüm: Goertzel algoritmasının mikrodenetleyici ile gerçeklenmesi.

/*
 * Yazar                : FxDev - Fırat DEVECİ
 * Konu                 : DAC Uygulaması
 * Yazar WEB Sitesi     : www.fxdev.org
 */

#include "LPC23xx.H"

unsigned int adc_read(unsigned char channel)
{
	unsigned int i;
	// ADC bloğu açılıyor
	PCONP|= (1 << 12);
	// PCLK=12MHz, kanal seçimi yapılıyor
	AD0CR = 0x00200300 | ((0x01) << channel); 	// A/D çevrimi başlatılıyor
    AD0CR|= 0x01000000;
    while(!(AD0GDR& 0x80000000));
    i = AD0GDR; // Çevrim bilgisi okunuyor
    return ((i>>6) & 0x03FF); // 15:6 arasındaki 10 bitlik veri ADC data
}

int main(void)
{
	int adc_1=0;
	PINSEL0=0x00000000;	// İlk 16 pin GPIO olarak ayarlanıyor
	PINSEL1=0x00214000;

	IODIR0=0xFFFFFFFF;

	for(;;)
	{
		adc_1=adc_read(0);
		DACR=adc_1<<6;
	}
}

Uygulamaya ait resim parçalarını aşağıda görebilirsiniz.ARM’ın DAC’ını kullanmak yukarıdan da görülebileceği gibi oldukça basittir. DAC birimi kullanılarak ses, ve görüntü uygulamalarının yanında özellikle dijital kontrolde de oldukça fazla kullanılabilir.

2010′u geride bırakırken…

Bu yazımı da kapamadan önce herkesin yeni yılını kutlar, sevdikleriyle iyi ve sağlıklı bir yıl geçirmesini dilerim.
2011′de de FxDev.org’da buluşmak üzere…

3-Wire Keypad Örneğii:

/* **** www.FxDev.org ****
 * 3-Wire Keypad Demo Code
 */
#include "avr/io.h"
#include "lcd.h"
#include "avr/interrupt.h"

#define ADC_REF_AREF 0x00
#define ADC_REF_AVCC 0x40
#define ADC_REF_INT  0xC0

#define dEBOUNCE	50		// dEBOUNCE süresi kaç milisaniye olacak
#define BEKLEME		1200	// Bu sabit tuşlara basılı olduğunda kaç saniye sonra tuşun aktif olacağını belirtir

unsigned char 	ADC_REF_TYPE;
volatile int 	dbtmr=-1,
				menugecis=0;

ISR(TIMER1_OVF_vect)	// Timer1 taşma kesmesi
{
	TCNT1=0xFF83;	// TCNT1, 16 bitlik registerine 64286 yükleniyor

	if(dbtmr>=0) 		dbtmr++;
	if(menugecis>0) 	menugecis--;
}

void adc_init(unsigned char ADC_REF)
{
	ADCSRA = 0x87;
	ADC_REF_TYPE = ADC_REF;
}

unsigned int read_adc(unsigned char adc_channel)
{
	ADMUX = ADC_REF_TYPE | adc_channel;
	ADCSRA |= 0x40;
	while (ADCSRA & 0x40);
	return ADC;
}

unsigned char keypad(void)
{
	unsigned int gerilim=0;
	unsigned char key='\n';

	gerilim=read_adc(0);
	if(gerilim>100 && gerilim< =256) key= '*';
	if(gerilim>256 && gerilim< =512) key= '7';
	if(gerilim>512 && gerilim< =768) key= '4';
	if(gerilim>768) 		 key= '1';

	gerilim=read_adc(1);
	if(gerilim>100 && gerilim< =256) key= '0';
	if(gerilim>256 && gerilim< =512) key= '8';
	if(gerilim>512 && gerilim< =768) key= '5';
	if(gerilim>768) 		 key= '2';

	gerilim=read_adc(2);
	if(gerilim>100 && gerilim< =256) key= '#';
	if(gerilim>256 && gerilim< =512) key= '9';
	if(gerilim>512 && gerilim< =768) key= '6';
	if(gerilim>768) 		 key= '3';

	return key;
}

unsigned char readkeyboard(void)
{
	static char prev=0,prev1=0;
	char        curr=0,returnvalue=0;

	curr=keypad();

	if(curr!=prev1)
	{
	   dbtmr=0;
	   prev1=curr;
	   returnvalue=prev;
	}
	else
	{
		if(dbtmr>=dEBOUNCE)
		{
			prev=curr;
			prev1=curr;
			returnvalue=curr;
			dbtmr=-1;
		}
		else
		{
			returnvalue=prev;
		}
	}
	return returnvalue;
}

int main(void)
{
	PORTC=0x00;
	DDRC=0xFF;

	lcd_init();
	adc_init(ADC_REF_AVCC);

	TCNT1=0xFF83;		// TCNT1, 16 bitlik registerine 65411 yükleniyor
	TCCR1B=0x02;		// Prescaler değeri 1:8
	TIMSK|=0x04;		// Timer1 taşması kesmesi aktif

	sei();			// Genel kesmeler aktif ediliyor

	lcd_gotoxy(1,1);	// LCD'nin ilk karekterine gidiliyor
	menugecis=100;		// 100ms bekleniyor
	for(;;)
	{
		if((readkeyboard()!='\n')&& ( menugecis == 0))	// Tuşa basıldı mı
		{
			menugecis=BEKLEME;
			veri_yolla(readkeyboard());		// Basılan değer LCD'ye gönderiliyor
		}
	}
}

Kodları, ilk defa debounce sorunu yaşayan kişileri düşünerek, bu sorunu giderip, gerçek hayatta uygulanabilecek yapıda yazdım. Böylece, en azından, bu sorunu yaşayan arkadaşlarımıza yardımcı olacağımı düşünüyorum.
Herkese iyi çalışmalar.

Dip not: Okul ve ARM çalışmalarım nedeniyle bu sıralar yazılarım seyrekleşebilir.

Teşekkür: Debounce konusundaki yardımları için ENKO Elektronik’ten Hüseyin TUNA’ya sonsuz teşekkürler.

Kitabı buradan indirebilirsiniz.
Kitap ile ilgili tüm görüşlerinizi, AVR ile ilgili tüm sorularınızı yorum kısmından bana iletebilirsiniz.

1) TC72 Uygulaması

TC72 uygulamasında çok basitçe bir sıcaklık ölçümü yapılmıştır. Ölçülen sıcaklığın ondalık kısmı ekrana basılmış, ayrıca sensörün içinde bulunan ayar registerinin değeri de ekranda gösterilmiştir.
Bu uygulamaya ait tüm dosyaları yazının en altında verilen bağlantıda mevcuttur.

2 ) MCP3204 Uygulaması

MCP3204, daha önce de dediğim gibi 4 kanal 12bit çözünürlüklü bir ADC’dir. 5V besleme ile iletişim hızı 2MHz hıza kadar çıkabilir. Bu entegrenin, donanımsal SPI ile kullanımında dikkat edilmesi gereken en önemli kısım ise komut gönderimi yapıldığı anda aynı zamanda da okuma işleminin yapılması gerektiğidir.
Bu örnekte ise 0-5V aralığını ölçebilen, 4 kanal bir voltmetre uygulaması yaptım. Verdiğim simülasyon programında potlarla istediğiniz gibi oynayarak sonuçların nasıl değiştiğini görebilirsiniz.
Bu uygulamaya ait kütüphane ve simülasyon dosyalarını yazının en altında verdiğim bağlantıda bulabilirsiniz.

Uygulamlarla ilgili detaylı açıklamara ve dosyalara buradan veya Mühendislik/Atmel AVR bölümünden ulaşabilirsiniz.
Konu ile ilgili sorularınızı yorum bölümüne yazabilirsiniz.

Herkese kolay gelsin…

- Öncelikle WinAVR‘yi bilgisayarımıza kuruyoruz.
- Daha sonra Eclipse sitesinden Eclipse IDE for C/C++ Developer pakedini indiriyoruz, hemen bir yere dosyaları çıkartıp çalıştırıyoruz.
- Daha sonra ise Eclipse’in Help sekmesinden Install New Software/Add kısmına basıp Location bölümüne “http://avr-eclipse.sourceforge.net/updatesite/” yazarak, eklentiyi yüklüyoruz ve hepsi bu.

Artık yeni proje oluşturup, AVR mikrodenetleyicinizi seçip kullanabilirsiniz.
WinAVR’de ANSI C kullanıldığı için, daha önce PIC için hazırladığım donanım kütüphanelerimi çok az değiştirip kullanmak gerçekten çok rahat. Buradan hâlâ Pic Basic, CCS C kullananlara duyurulur.

Ben ilk örneğimi, Atmega16′nın ADC’lerinden bilgi okuyup, bunu LCD’de göstermek için uyguladım. Aşağıda uygulamaya ait resmi ve yazdığım basit kodları bulabilirsiniz. Üzerinde herhangi bir değişiklik yapıp kullanabilirsiniz.
Yalnız kodu iyi incelerseniz PIC’teki TRISx yerine DDRx’nin geldiğini, PORT’larn PIC’teki gibi RB0 gibi bit bit kontrol edilemediğini göreceksiniz. İlk AVR denemelerinizde buna dikkat edip, ‘maskeleme’ ne imiş öğrenmeniz gerekiyor. Gerisi yine size kalmış.

Sonuç olarak söylemem gerekirse; AVR ne denli güzelse, finaller de o denli sıkıcı.
Herkese çalışmalarında, bana da finallerde başarılar.

ADC Okuma Örneği:

/* **** www.FxDev.org ****
 * ADC'den Gerilim ve Sıcaklık Ölçen Program
 */

#include "avr/io.h"
#include "util/delay.h"
#include "lcd.h"

#define ADC_REF_AREF 0x00
#define ADC_REF_AVCC 0x40
#define ADC_REF_INT  0xC0

unsigned char ADC_REF_TYPE;

void adc_init(unsigned char ADC_REF)
{
	ADCSRA = 0x87;
	ADC_REF_TYPE = ADC_REF;
}

unsigned int read_adc(unsigned char adc_channel)
{
	ADMUX = ADC_REF_TYPE | adc_channel;
	ADCSRA |= 0x40;
	while (ADCSRA & 0x40);
	return ADC;
}

int main(void)
{
	unsigned int sicaklik,voltaj;
	PORTC=0x00;
	DDRC=0xFF;

	lcd_init();

	adc_init(ADC_REF_AVCC);

	lcd_yaz("FxDev.org Sunar!");
	lcd_gotoxy(2,1);
	lcd_yaz("AVR'ye Merhaba..");
	_delay_ms(1500);
	lcd_clear();

	lcd_gotoxy(1,1);
	veri_yolla('C');
	veri_yolla(0xDF);
	veri_yolla(':');
	lcd_gotoxy(2,1);
	lcd_yaz("V :");

	for(;;)
	{
		lcd_gotoxy(1,4);	// Okunan değer LCD'ye yazılıyor
		sicaklik=read_adc(0)*48; // Hesaplama yapılıyor
		_delay_us(50);
		veri_yolla(sicaklik/1000+48);
		veri_yolla((sicaklik%1000)/100+48);
		veri_yolla('.');
		veri_yolla((sicaklik%100)/10+48);
		veri_yolla(sicaklik%10+48);
		veri_yolla(0xDF);
		veri_yolla('C');
		lcd_gotoxy(2,4);
		voltaj=(int)(read_adc(1)/2.048);
		_delay_us(50);
		veri_yolla(voltaj/1000+48);
		veri_yolla((voltaj%1000)/100+48);
		veri_yolla('.');
		veri_yolla((voltaj%100)/10+48);
		veri_yolla(voltaj%10+48);
		veri_yolla('V');
	}
}

Klasik bir 8051′in (örneğin AT89C52) iki adet dış kesme, bir adet seri port kesmesi ve iki adet timer kesmesi ile toplam beş kesmeye ve 256 Byte RAM ile 8 kByte ROM’a sahiptir. Tek ek komponent olarak ise USART birimi ile günümüzün PIC ve ATMEGA gibi popüler mikrodenetleyicilerinin yanında oldukça sönük kalmaktadır. Bir örnekle açıklamak gerekirse, potansiyometre bilgisine göre doluluk oranı değişen bir sinyal yapmaya çalıştığımızda 8051 için ayrı bir ADC entegresi ve içine ise stabil bir kod yazılması gerekmektedir. Oysa bunu Pic ile yapmış olsak sadece ADC’si olan bir PIC kullanmamız ve doluluk oranı değişecek sinyali ise yine PIC’in CCP biriminden oluşturmamız yeterli olacaktır.

Her ne kadar 8051, genç nesil mikrodenetleyicilerinin yanında sönük kalsa da gerek kullanım, gerekse öğretim kolaylığı nedeniyle bir çok okulda, üniversitede hâlen öğrencilere gösterilmektedir. Bunun için ben de mikroişlemciler dersindeki laboratuar notlarımı ve dönem projemi bu konuda çalışmak isteyen arkadaşlar için paylaşma gereği duydum.
Laboratuar konuları aşağıdaki gibidir;
1- (ASM) Keil Programının Kullanımı
2- (ASM) Register Bankı Seçme, Portlardan Değer Okuma, Adres Modları
3- (ASM) 8051 Komutlarının Kullanımı: ADDC, SUBB, MUL, DIV, CPL, XCH, SWAP
4- (ASM) 8051 Uygulaması: Rasgele Verilen Sayıları Tek veya Çift Olarak Yerleştirme
5- (ASM) 8051 Uygulaması: Rasgele Verilen Sayıları Büyükten Küçüğe ve Küçükten Büyüğe Sıralama
6- (ASM) 8051 Uygulaması: Timer’ların Kullanımı
7- (ASM) 8051 Uygulaması: Seri Port Kullanımı
8- (C) Kronometre Yapımı
9- (C) Bankamatik Yapımı
10- (C) LM35 ve AD0831 ile Klima Yapımı
11- (C) Sinyal Üreteci Yapımı

Dönem Projesi: (C) Çok Fonksiyonlu Sıcaklık ve Zaman Uygulaması

Deneylerle ilgili detaylı açıklamara ve dönem projesine buradan veya Mühendislik/Diğerleri bölümünden ulaşabilirsiniz.
Herkese iyi çalışmalar.