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) Seven Segment
İlk gauge’miz biz elektronikçilerin asla vazgeçemeyeceği seven segmentle ilgili. Codeproject’te gördüğüm seven segment uygulaması Dmitry Brant‘a ait ve oldukça başarılı bir tool. İster tek bir seven segment öğesini ister küme halinde bulunan seven segment öğelerini formunuza yerleştirip, renginden, yatıklığına, büyüklüğünden, şekline kadar her şeyle oynayabiliyorsunuz. Telif hakları konusunda Dmitry Brant sadece ticari uygulamalar için kendisi ile görüşülmesini istemiş fakat Türkiye gibi bir ülkede kim bunu dikkate alır orası muamma.

2) Gauge
İkinci ve gördüğümde ‘işte bu’ dediğim gauge toolumuzu ise bu siteden buldum. İlk bakışta hiç bir şey anlaşılmasa da kaynak dosyayı indirip projenize dahil etmenizle gerçekten her anlamda kontrol edebildiğiniz bir göstergeniz oluyor. Büyüklüğünü, renklerini, açılarını, gösterge büyüklüklerini yani hemen hemen her şeyi kontrol edebiliyorsunuz. Tek yapmanız gereken class dosyasını projenize eklemek.

3) Sliding Scale
Üçüncü gaugemiz ise Tefik Becirovic‘e ait. Özellikle eski tip elektrik panolarında gördüğüm bu gösterge yerine göre oldukça faydalı işlevlerde kullanılabilir.

Projelerinize ayrı bir renk katacak bu göstergeler ile bir uygulama yapmamak olmazdı elbette. Bu düşünce ile aklıma ilk gelen uygulama, mikrodenetleyiciye bağlı sensörlerden alınan bilgilerin bu gaugeler kullanılarak bilgisayarda gösterilmesiydi ve sonucunda aşağıda görülen yapı ortaya çıktı.
Yukarıdaki resimden de görüleceği üzere seri porttan haberleşme için gerekli protokolleri ayarlayan kısım daha önceki projemden bire bir alınma. Projenin nasıl bir işleve sahip olduğu ise aşağıdaki videodan görülebilir. Videoyu tam ekran seyretmenizi öneririm. (Eğer video açılmıyorsa youtube ile ilgili bir probleminiz var demektir.)

Click here to view the embedded video.

Videodan da görüleceği üzere Proteus ve yazdığım program arasındaki bağlantı, Proteus’un içerisinde bulunan COMPIM adlı araçla mümkün olmuştur. Projenin kaynak kodlarını paylaşmayacak olsamda seri porttan gönderdiğim seri bilgi şu şekilde.
4 bit: İlk seven segment dizisinin değeri, 1234 şeklinde gitmeli,
4 bit: İkinci seven segment dizisinin değeri, 1234 şeklinde gitmeli,
4 bit: İlk gerilim kaydırıcısının değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli,
4 bit: İkinci gerilim kaydırıcısının değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli,
4 bit: Üçüncü gerilim kaydırıcısının değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli,
4 bit: İlk sıcaklık göstergesinin değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli,
4 bit: İkinci sıcaklık göstergesinin değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli,
4 bit: İlk gerilim göstergesinin değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli,
4 bit: İkinci gerilim göstergesinin değeri, 5V=1024 olarak düşünülmeli, maksimum 1024 gönderilmeli.

Toplamda 36 byte boyutundaki diziyi C# ile çekmek için ise aşağıdaki kod öbeğini kullanabilirsiniz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            text = serialPort1.ReadExisting();
 
            if (text_temp.Length == 36 && flag == true)
            {
                flag = false;
            }
            else if(flag==true)
            {
                if (text_temp.Length < = 36)
                    text_temp += text;
                else
                    text_temp = "";
            }
        }

Son olarak gauge denemesi yaparken kullandığım CoreAudioApi adlı API’ye değinelim. Windows seslerini kontrol etmek için tasarlanmış bu .dll, Ray M. tarafından yazılmış ve tamamen bedava. Api bilgisayarın master sesini kontrol ettiği gibi, o anki sağ, sol ve master ses seviyelerini de alabiliyor. Bu da bizlere ses düzeylerini öğrenmemiz konusunda yardımcı oluyor.

Denememin sonucunda bu API’yi ve gauge’leri kullanarak aşağıda görebileceğiniz VuMetre uygulamasını yaptım.
Bu uygulamaya ait video görüntüsü ise aşağıdan görülebilir. (Bilgisayarın sesini açarak dinleyiniz.)

Click here to view the embedded video.

Sonuç olarak tüm bu değerleri bir label’a ya da textbox’a yazdırıp, değişen değerleri yine gözlemleyebilirdik fakat örneklerde görüldüğü üzere gauge’ler projeye hem görsel hem de okuma kolaylığı kazandırdığından, kullanıcılar tarafından her zaman tercih edilmektedir. Bu yüzden sonraki yazılarımda bulduğum yeni gauge’leri yine sizlerle buradan paylaşacağım.

Programların 32 ve 64 bitlik sürümlerini ve Atmega16 için Proteus ve .hex dosyalarını buradan indirebilir, yeni sürüm güncellemelerini Mühendislik/C# bölümünden takip edebilirsiniz. Programların çalışabilmesi için sisteminizde Microsoft .NET Framework kurulu olması gerekmektedir. Microsoft .NET Framework kurulum dosyasına buradan ulaşabilirsiniz. Ayrıca programları istediğiniz şekilde paylaşıp, kullanabilirsiniz.

]]> http://www.fxdev.org/c-gauge/feed/ 0 http://www.fxdev.org/serial-port-terminal/ http://www.fxdev.org/serial-port-terminal/#comments Tue, 10 Aug 2010 22:24:24 +0000 FxDev http://www.fxdev.org/?p=795 Tatili meşe oynayarak geçirdiğim şu günlerde C# üzerine çalışmalarımı seri port üzerine yoğunlaştırdım. Bir elektrik ya da elektronikçi olarak, şimdilerde geçmiş yüzyılın teknolojisi kabul edilen fakat yeni başlayanlar için kullanım kolaylığı sağlayan seri port haberleşmesi ile oldukça sık uğraşacaksınız. Bu sene özellikle robot kol, FFT gibi projelerde sıkça kullandığım seri portu, C# öğrenmem vesilesi ile tekrar ele aldım. Programı yazarken herkes gibi benim de oldukça sık kullandığım Terminal v1.9b programını baz aldım.
Böyle ufak işler için hazır programlar kullanmaktansa, kendi programımı yazmak istediğimden daha önceki yazımda bahsetmiştim. Fakat var olan bir şeyi yenilemeden kopyalamanın da boşa zaman kaybı olacağını düşünmekteyim. Bunun için Terminal v1.9b programının en büyük eksikliği olarak gördüğüm, o an açık COM port’ların yenilenmemesi olayı üzerine yoğunlaştım.
Bunun asıl nedeni ise hepimizin kullandığı USB-COM Port dönüştürücülerini bilgisayara taktığımda, kullandığım seri port programını tekrardan başlatmak istemiyor oluşumdu.
Sonuç olarak ise hem seri port kontrolünü öğrendim hem de işime yarayacak bir program yaptım. Programın özellikleri ise şöyle;

Programa ait ekran görüntüleri aşağıdaki gibidir;Program arayüzü yukarıda da göreceğiniz üzere oldukça sadedir. Port, boudrate, parity ve diğer ayarları seçtikten sonra “Connect” butonuna basmanız halinde, eğer port uygunsa bağlantınız sağlanacak ve programı istediğiniz şekilde kullanabileceksiniz. Ben teslerimi bilgisayarımda seri port bulunmadığından Eltima Software‘nın sunduğu Virtual Serial Port Driver ile sanal iki port oluşturarak yaptım. Programı, eğer böyle bir uygulama yapacaksanız kesinlikle öneririm. Yaptığım bir test uygulamasının görüntüsünü ise aşağıda görebilirsiniz (resme tıklarsanız büyür).

Başta da söylediğim gibi, program Terminal v1.9b’ye alternatif olarak yazılmıştır. İstediğiniz ekstra özellikler için yorum forumundan bana ulaşıp görüş bildirirseniz, en kısa sürede o modülleri eklemeye çalışırım.

Programın 32 ve 64 bitlik sürümlerini buradan indirebilir, yeni sürümün güncellemelerini Mühendislik/C# bölümünden takip edebilirsiniz. Programın çalışması için sisteminizde Microsoft .NET Framework kurulu olması gerekmektedir. Microsoft .NET Framework kurulum dosyasına buradan ulaşabilirsiniz. Ayrıca programı istediğiniz şekilde paylaşıp, kullanabilirsiniz.

Programın çalışma mantığında ise sinyal işleme dersinde sıkça kullandığımız discrete yapılar yer alıyor.
M genlikli, toplamda N sayıda örnek için n. örneğin sinüs sinyal formülü, M*sin(4*pi*(n/N)) olmaktadır. Program temel olarak bu formül üzerine çalışmaktadır.
Programa ait ekran görüntüleri aşağıda görülebilir. (Resimlerin üzerilerine tıklarsanız büyürler)

Programı kullanmak için AVR ile çift PWM kullanarak 50 ve 100Hz frekansında iki sinüs sinyali oluşturalım.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include "avr/io.h"
#include "util/delay.h"
#include "avr/interrupt.h"
 
const unsigned char fifty_HZ_sinus[100]={
127,142,158,173,188,201,213,224,
234,241,247,251,253,253,251,247,
241,234,224,213,201,188,173,158,
142,127,112,96,81,66,53,41,
30,20,13,7,3,1,1,3,
7,13,20,30,41,53,66,81,
96,112
};
 
const unsigned char hundred_HZ_sinus[100]={
127,158,188,213,234,247,253,251,
241,224,201,173,142,112,81,53,
30,13,3,1,7,20,41,66,
96,127,158,188,213,234,247,253,
251,241,224,201,173,142,112,81,
53,30,13,3,1,7,20,41,
66,96
};
 
volatile unsigned char i=0;
 
int main(void)
{
	// 1MHz => 1us, prescalerden dolayı => 8us, 65536-65486=50
	// 25*8us=200us
 
	TCNT1=0xFFD1;	// TCNT1, 16 bitlik registerine 65511 yükleniyor
	TCCR1B=0x02;	// Prescaler değeri 1:8
	TIMSK|=0x04;	// Timer1 taşması kesmesi aktif
 
	TCNT0=0x00;
	TCNT2=0x00;
	TCCR0|=(0< <CS02)|(0<<CS01)|(1<<CS00);		// Prescaler 1:1
	// 1.000.000/256~3906Hz sinyal çıkması gerekiyor
	// OC0 ile Timer0 kesiştiğinceye kadar OC0 pinini set et
	TCCR2|=(0<<CS02)|(0<<CS01)|(1<<CS00);		// Prescaler 1:1
	// 1.000.000/256~3906Hz sinyal çıkması gerekiyor
	// OC2 ile Timer2 kesiştiğinceye kadar OC0 pinini set et
 
	TCCR0|=(1<<WGM00)|(1<<WGM01)|(1<<COM01)|(0<<COM00);
	// Fast PWM modu açık
	// OC0 ile Timer0 kesiştiğinceye kadar OC0 pinini clear et
	TCCR2|=(1<<WGM00)|(1<<WGM01)|(1<<COM01)|(0<<COM00);
	// Fast PWM modu açık
	// OC0 ile Timer0 kesiştiğinceye kadar OC0 pinini clear et
 
	DDRB|=(1<<PB3);	// OCR0 bacağı çıkış oluyor
	DDRD|=(1<<PD7);	// OCR2 bacağı çıkış oluyor
 
	OCR0=127;		// OCR0/255=Duty Cyle yapar. Şimdilik Duty %50
	OCR2=127;		// OCR2/255=Duty Cyle yapar. Şimdilik Duty %50
 
	sei();			// Genel kesmeler aktif ediliyor
 
	for(;;);
}
 
ISR(TIMER1_OVF_vect) // Timer1 overflow kesmesi
{
	TCNT1=0xFFD1;	// TCNT1, 16 bitlik registerine 65511 yükleniyor
 
	i++;
	if(i > 49) i=0;
	OCR0=fifty_HZ_sinus[i];
	OCR2=hundred_HZ_sinus[i];
}

Yukarıdaki kodu incelediğinizde aslında işlemin çok basit olduğunu göreceksiniz; Timer’ı kur, PWM yüzdesini belirle, low-pass filtreden geçir. Aşağıda ise simülasyon görüntüsünü görebilirsiniz. Aşağıda da görüleceği üzere filtreleme sağlıklı olmadığından kesikli çizgiler meydana çıkmaktadır, bu da hormonic distortion’u artırmakta ve sinüs sinyalimizi bozmaktadır. Eğer istenilen sinüs sinyalinin kesintisiz olması isteniyorsa pasif yerine aktif filtre kullanılarak daha güzel bir sinüs sinyali elde edilebilirsiniz.

Programın 32 ve 64 bitlik sürümlerini buradan indirebilir, yeni sürümün güncellemelerini Mühendislik/C# bölümünden takip edebilirsiniz. Programın çalışması için sisteminizde Microsoft .NET Framework kurulu olması gerekmektedir. Microsoft .NET Framework kurulum dosyasına buradan ulaşabilirsiniz. Ayrıca programı istediğiniz şekilde paylaşıp, kullanabilirsiniz.

Son olarak C# ve chart kullanımı üzerine daha önce çalışma yapmış olanlar, örneklerini benimle paylaşırlarsa sevinirim.
Herkese kolay gelsin.

Orta seviye sayılabilecek bir mikrodenetleyicinin tüm özelliklerine sahip bu mikrodenetleyici sadece 3.3V ile çalışıyor. Tüm bu rakamlar özellikle taşınabilir cihaz tasarımcıları için oldukça önemli değerler.
Örneğin elimize 2600mAh’lik ortalama bir pil olsun. MSP430′unda MIPS’inin her zaman aktif olduğunu düşünelim. Hemen oran orantı kurduğumuzda 2,600,000/200=13000saat~1,5yıl çalışma demek. Bir de MSP430′u uyku moduna aldığınızı düşünün.
Bu kadar özendirmeden sonra elbette bir örnek yapmadan olmaz.
Ben, staj yerinden temin ettiğim, resmini yukarıda görebileceğiniz USB geliştirme sticki üzerinde kodlarımı yazıp deniyorum, bu stick’in üzerinde ise yine yukarıdaki resimde görüleceği üzere MSP430F2013 bulunmakta. Ayrıca stickten dışarı pin çıkışları da alınmış, programlamlama ve debugger özelliğine sahip olan stick’te kontrol için bir tane de led koymuşlar.
MSP430′un geliştirme ortamı ise Texas’ın kullanıcılara bedava olarak sunduğu “IAR Embedded Workbench KickStart for MSP430″. Özellikle şunu belirtmek isterim ki, programı oldukça hızlı derlese de IAR’ın görünümü gerçekten “iğrenç”. Onun için her zaman AVR programlarken çok hoşlanıyorum, çünkü adamlar Eclipse gibi bir arayüz kullanıyorlar. İnternette yaptığım ufak araştırmalarda MSP430 için de geliştirilmiş Eclipse eklentileri gördüm, fakat deneme şansım daha olmadı. Fakat deneyip, olumlu sonuçlar aldığımda elbette buradan yine sizlerle paylaşacağım.

MSP430 için ilk örneğimizde, 16 bitlik TIMERA ve kesmesini kullanarak bir ledin 1sn’de yanıp sönmesini sağlayacağız. Krital kaynağımızı ise DCO seçeceğiz.
Örnek kodlarımız ve açıklamalarını aşağıda görebilirsiniz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include "msp430.h"       	  // MSP430 başlık dosyası
 
void main( void )
{
	WDTCTL = WDTPW + WDTHOLD; // Watchdog Timer'ı durdur.
 
	BCSCTL1= CALBC1_1MHZ;     // Kristal şu anlık 1MHz ayarlanıyor
	DCOCTL = CALDCO_1MHZ;
	BCSCTL3= LFXT1S_2;
 
	TAR=0x0000;      // TAR değeri sıfırlanıyor
	TACTL=0x02D6;    // SMCLK seçili, MOD1, 1:8, Interrupt Enable, Interrupt Flag temizleniyor
	TACCR0=62500;    // TACCR0 değerine 1.000.000/8=125.000/2=62500 yükleniyor
 
	P1DIR=0xFF;   // P1 çıkış olarak ayarlanıyor
 
	for(;;)
	{
		if((TACTL&0x0001)==0x0001)    // TimerA kesmesi bekleniyor
		{
			P1OUT^=0xFF;   // Kesme gelince P1 çıkışları tersleniyor
			TACTL&=0xFFFE; // Kesme bayrağı temizleniyor
		}
	}
}

Yukarıda yazdığımız kod TIMERA’nın kesme bayrağına sonsuz döngüde bakıyor. Bu, basit uygulamalar için uygulanabilir gözükse de oldukça amatörcedir. Bunun yerine her zaman TIMER kesmesi kullanılması tercih edilmelidir. Aynı işlemi yapan kod ise aşağıda gözükmektedir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include "msp430.h"         // MSP430 başlık dosyası
 
// TimerA kesme vektörü
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
  P1OUT^=0xFF;              // Kesme gelince P1 çıkışları tersleniyor
}
 
void main( void )
{
  WDTCTL = WDTPW + WDTHOLD; 	// Watchdog Timer'ı durdur.
 
  BCSCTL1= CALBC1_1MHZ;   // Kristal şu anlık 1MHz ayarlanıyor
  DCOCTL = CALDCO_1MHZ;
  BCSCTL3= LFXT1S_2;
 
  TAR=0x0000;             // TAR değeri sıfırlanıyor
  TACTL=0x02D6;           // SMCLK seçili, MOD1, 1:8, Interrupt Enable, Interrupt Flag temizleniyor
  TACCR0=62500;           // TACCR0 değerine 1.000.000/8=125.000/2=62500 yükleniyor
  TACCTL0=CCIE;           // CCIFG interrupt'ı açılıyor  
 
  P1DIR=0xFF;             // P1 çıkış olarak ayarlnıyor
 
  _EINT();                // Genel kesmeler açılıyor
 
  for(;;);
}

Görüleceği üzere bu kod daha sağlıklı olmuştur. Yukarıdaki kodda göreceğiniz üzere MSP430′da kesmelere gitmeden önce vektörel olarak tanımlama yapılmalıdır. Yine yukarıda görüldüğü gibi kesmeye gidildiğinde MSP430, o kesmeye ait bayrağı kendisi silmektedir.
Yazdığımız kodun çalışırken çekilmiş videosu ise aşağıda gözükmektedir.

Click here to view the embedded video.

Görüldüğü gibi o ya da bu mikrodenetleyici olsun her şey registerleri kontrol etmekte bitiyor. Onun için ben, yeni bir mikrodenetleyici öğrenirken öncelikle çevresel birimleri ve registerleri ele alıyorum. Daha sonrası kod yazmak olduğu için gerisi o ya da bu şekilde devam eder. Fakat registerler öğrenilmeden, bir led yakıp söndürmek bile işkence haline gelebilir.

İlerleyen zamanlarda yavaş da olsa bu konu üzerine eğilmek istiyorum.
Her türlü sorunuzu bana yorum kısmından sorabilirsiniz.
Herkese iyi çalışmalar.

Projenin çalışan videosu:

Click here to view the embedded video.

Projenin kodları:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

#include "avr/io.h"
#include "util/delay.h"
#include "avr/interrupt.h"
#include "ds1307.h"
 
static volatile unsigned int buffer[8];
static volatile unsigned char a=0;
static volatile unsigned int tick=0;
 
const unsigned char tanitim[]="BIR FXDEV ORG PROJESIDIR";
const unsigned int  round[8]={0x0040,0x0080,0x0100,0x0200,0x0400,0x0800,0x1000,0x2000};
 
#define PORT_595	PORTC		//74LS595 Clk girişi, yükselen kenar
#define Clock		0x00		//74LS595 Clk girişi, yükselen kenar
#define DataIO		0x01		//74LS595 Data girişi
#define Enable		0x02		//74LS595 Enable girişi
 
void three_wire_control(unsigned int temp)
{
	char i;
	PORT_595 &= ~(0x01 < < Enable);
	for(i=0;i < 14;i++)
	{
		PORT_595 &= ~(0x01 << Clock);
		if((temp<<i)&0x2000)
			PORT_595 |= (0x01 << DataIO);
		else
			PORT_595 &= ~(0x01 << DataIO);
		PORT_595 |= (0x01 << Clock);
	}
	PORT_595 |= (0x01 << Enable);
}
 
unsigned int character(unsigned char c)
{
	switch(c)
	{
		case 'A': return 0x2237; break;
		case 'B': return 0x0A8F; break;
		case 'C': return 0x2218; break;
		case 'D': return 0x088F; break;
		case 'E': return 0x2239; break;
		case 'F': return 0x2031; break;
		case 'G': return 0x023D; break;
		case 'I': return 0x0889; break;
		case 'J': return 0x001E; break;
		case 'K': return 0x2530; break;
		case 'L': return 0x0038; break;
		case 'N': return 0x0476; break;
		case 'O': return 0x003F; break;
		case 'P': return 0x2233; break;
		case 'R': return 0x2633; break;
		case 'S': return 0x222D; break;
		case 'T': return 0x0881; break;
		case 'U': return 0x003E; break;
		case 'X': return 0x1540; break;
		case 'V': return 0x1130; break;
		case 'Y': return 0x028E; break;
		case 'Z': return 0x1109; break;
		case ' ': return 0x0000; break;
		case '/': return 0x1100; break;
 
		case '0': return 0x003F; break;
		case '1': return 0x0006; break;
		case '2': return 0x221B; break;
		case '3': return 0x220F; break;
		case '4': return 0x2226; break;
		case '5': return 0x222D; break;
		case '6': return 0x223D; break;
		case '7': return 0x0007; break;
		case '8': return 0x223F; break;
		case '9': return 0x222F; break;
	}
}
 
void shift_left(const unsigned char *s)
{
	unsigned char j=0,i;
	while(*s)
	{
		for(i=0;i < 7;i++)
			buffer[i]=buffer[i+1];
 
		buffer[7]=character(*s++);
		_delay_ms(25);
	}
	for(j=0;j < 8;j++)
	{
		for(i=0;i < 7;i++)
			buffer[i]=buffer[i+1];
		buffer[7]=0x0000;
		_delay_ms(25);
	}
}
 
void left_and_right(const unsigned char word[],unsigned char tekrar)
{
	unsigned char word_length=0,i,j;
	signed char t;
 
	while(word[word_length]!='\0')
	{
		buffer[word_length]=character(word[word_length]);
		word_length++;
	}
	_delay_ms(25);
	for(i=0;i < tekrar;i++)
	{
		for(j=0;j < 8-word_length;j++)
		{
			for(t=6;t > -1;t--)
			{
				buffer[t+1]=buffer[t];
			}
			buffer[0]=0x0000;
			_delay_ms(25);
		}
 
		for(j=0;j < 8-word_length;j++)
		{
			for(t=0;t < 7;t++)
			{
				buffer[t]=buffer[t+1];
			}
			buffer[7]=0x0000;
			_delay_ms(25);
		}
	}
}
 
void clear_segments(void)
{
	unsigned char i;
	for(i=0;i < 8;i++)
		buffer[i]=0x0000;
}
 
int main(void)
{
	unsigned char gun,ay,yil,hafta,saat,dakika,saniye;
	unsigned char prev_yil;
	PORTB=0x00;
	DDRB=0x00;
	PORTC=0x00;
	DDRC=0xFF;
	PORTD=0xFF;
	DDRD=0xFF;
 
	ds1307_init();
 
	TCCR0|=0x02;	// Prescaler 1:8
	TIMSK=0x01;		// Timer0 taşması kesmesi aktif
	TCNT0=0x83;		// 1ms kesme için ön değer yükleniyor
 
	sei();			// Genel kesmeler aktif ediliyor
 
	shift_left(tanitim);
 
	left_and_right("F",1);
	left_and_right("FX",1);
	left_and_right("FXD",1);
	left_and_right("FXDE",1);
	left_and_right("FXDEV",1);
 
	clear_segments();
 
	ds1307_set_date_time(31,12,10,4,23,59,55);
	ds1307_get_date(&gun,&ay,&yil,&hafta);
 
	prev_yil=yil;
 
	for(;;)
	{
		ds1307_get_date(&gun,&ay,&yil,&hafta);
		ds1307_get_time(&saat,&dakika,&saniye);
 
		if(prev_yil < yil)
		{
			prev_yil=yil;
			clear_segments();
			shift_left("YENI YILINIZ KUTLU OLSUN");
		}
		else if(tick < 10000)
		{
			buffer[0]=character((saat/10)+48);
			buffer[1]=character((saat%10)+48);
			buffer[2]=round[saniye%8];
			buffer[3]=character((dakika/10)+48);
			buffer[4]=character((dakika%10)+48);
			buffer[5]=round[7-saniye%8];
			buffer[6]=character((saniye/10)+48);
			buffer[7]=character((saniye%10)+48);
		}
		else if(tick > 10000 && tick < 12000)
		{
			buffer[0]=character((gun/10)+48);
			buffer[1]=character((gun%10)+48);
			buffer[2]=character('/');
			buffer[3]=character((ay/10)+48);
			buffer[4]=character((ay%10)+48);
			buffer[5]=character('/');
			buffer[6]=character((yil/10)+48);
			buffer[7]=character((yil%10)+48);
		}
	}
}
 
ISR(TIMER0_OVF_vect)	// Timer0 taşma kesmesi
{
	TCNT0=0x83;			// 1ms kesme için tekrar ön değer yükleniyor
 
	if(tick < 12000) tick++; else tick=0;
 
	switch(a)
	{
		case 0:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x01; a=1; break;
		case 1:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x02; a=2; break;
		case 2:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x04; a=3; break;
		case 3:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x08; a=4; break;
		case 4:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x10; a=5; break;
		case 5:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x20; a=6; break;
		case 6:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x40; a=7; break;
		case 7:	PORTD=0xFF; three_wire_control(buffer[a]); PORTD=~0x80; a=0; break;
	}
}

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

]]> http://www.fxdev.org/14-segment-display/feed/ 0 http://www.fxdev.org/haftasonu-projesi/ http://www.fxdev.org/haftasonu-projesi/#comments Fri, 09 Jul 2010 21:03:51 +0000 FxDev http://www.fxdev.org/?p=773 Gerek işlerimin yoğunluğundan gerekse üşengeçlikten uzun süredir siteme proje koyamıyordum.
Bugün biraz bunu kırmak amaçlı ufak da olsa, pek çok amatör mikrodenetleyici kullanıcısının göz ardı ettiği ADC çoğullamaya değinmek istedim.
Öncelikle mantık devreleri dersinde hepimizin kullandığı multiplexer ya da demultiplexer entegrelerine benzer bir entegre arayışına girdim. Fakat kullanacağım yapı TTL mantığında çalışmaması gerektiğinden (yani 1V’tu sıfır algılamasını istemiyorum) multiplexer ve demultiplexer’ın bu iş için uygun olmayacağını biliyordum. Bir kaç yerde bu sorunumu dile getirdiğimde ise piyasada oldukça fazla kullanılan 74HC4051 ve 74HC4052 entegrelerini işittim.
Bu entegrelerin kullanımı ise oldukça basit. Öncelikle entegreyi enable eden pini toprağa çekiyorsunuz, ardından okumak istediğiniz kanalı, A-B-C pinlerinden ‘binary’ şeklinde girip, tek çıkışından, istediğini kanalı okuyorsunuz. Ben uygulamamda 74HC4051 kullandım. Entegrenin nasıl kullanıldığını datasheet’e bakmadan da görmeniz mümkün.
Daha sonra düşündüğümde ise sadece bunu gösterip ‘alın işte size proje’ demek içime sinmedi. Onun için stajda bolca uğraştığım NTC’leri projeye dahil ettim. Bir de merak ettiğimden Atmega16′ya 140ms’lik bir Watchdog kurdum. Anlayacağınız bir taşla 3 kuş vurmuş oldum. Bir de tüm sıcaklık değerlerini görmek için 4×20 LCD ekledim. Açılış ve çalışma ekranını aşağıdan görebilirsiniz.
NTC için ise aşağıdaki 8 bit çözünürlüklü tabloyu kullandım. Bu tablo genel bir tablo olmayıp, kullandığınız NTC’den NTC’ye değiştiği için, hazır buldum, kullanayım demeyin. Ben 40-50C civarlarının hassas olmasını istediğimden tabloyu buna göre düzenledim.

const signed char ntc_table[256] ={
127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,
127,127,127,127,127,127,127,127,126,124,122,121,119,118,117,115,
114,113,112,111,109,108,107,106,105,104,103,102,101,100,100,99,
98,97,96,95,94,94,93,92,91,91,90,89,88,88,87,86,
86,85,84,84,83,82,82,81,80,80,79,78,78,77,77,76,
76,75,74,74,73,73,72,72,71,70,70,69,69,68,68,67,
67,66,66,65,65,64,64,63,63,62,62,61,61,60,60,59,
59,58,58,57,57,56,56,55,55,54,54,53,53,52,52,51,
51,50,50,50,49,49,48,48,47,47,46,46,45,45,44,44,
43,43,42,42,41,41,41,40,40,39,39,38,38,37,37,36,
36,35,35,34,34,33,33,32,32,31,31,30,30,29,29,28,
28,27,27,26,26,25,25,24,23,23,22,22,21,21,20,20,
19,18,18,17,17,16,15,15,14,13,13,12,12,11,10,10,
9,8,7,7,6,5,4,4,3,2,1,0,0,-1,-2,-3,-4,-5,-6,-7,
-8,-9,-10,-11,-12,-13,-15,-16,-17,-19,-20,-22,
-23,-25,-27,-29,-31,-33,-35,-38,-40,-44,-47,
-51,-56,-63,-71,-85};

Proje ile ilgili simülasyon, c kodu ve .hex dosyasına buradan veya Mühendislik/Atmel AVR bölümünden ulaşabilirsiniz.
Herkese iyi çalışmalar.

Herkese iyi gülmeler..

Dip Not 1: Resimlerin şimdiden çalınacağını bildiğimden sitemin adresini yanlarına iliştirdim.
Dip Not 2: İnsanın ailesinden başka arkasını dayayabileceği başka bir ‘şey’in olmadığını bugün bir kez daha gördüm.

Yukarıdaki özellikler aldıktan sonra öncelikle FFT öğrenme çalışmalarına başladık ve burada öncelikle 18F452, daha sonra ise Radix-2 algoritmaları öğrendik. 16F serisi yerine 18F serisi PIC kullanmamızın nedeni ise 18F’lerin hafıza yapısının daha fazla olması idi. Daha sonra örnek alma işlemleri, filtre katsayılarını MATLAB’ten bulma ve bunu mikrodenetleyici programına uygulama işlemlerinden sonra aşağıdaki resimlerde (üzerilerine tıklarsanız büyürler) görüldüğü gibi uygulamamızı çalıştırdık.
Ayrıca uygulama 1 hafta içerisinde yapıldı ve not olarak 100 alındı.

100Hz Sinüs Sinyal Görüntüsü

100Hz Kare Sinyal Görüntüsü

100Hz Kare Sinyal FFT’si (100Hz, 300Hz, 500Hz, 700Hz ve 900Hz Harmonikler)

Filtrelenmiş Sinyalin FFT’si (325Hz Köşe Frekansı)

Bu proje ile ilgili detaylı açıklama ve hesaplara, ayrıca simülasyon dosyasına buradan veya Mühendislik/Mikroelektronik ve Sinyal bölümünden ulaşabilirsiniz.
Herkese iyi çalışmalar.

Tüm bu değerler göz önüne alındığında özellikle güç katı için güç transistörleri kullanmaya karar versek de boşta çekilen akımın 10mA’den düşük olması istendiğinden bu yöntemden vazgeçilmiş ve özellikle ses alanında fazlaca kullanılan TDA serisi entegrelere yönelinerek TDA2030′u seçtik. Yine aynı şekilde bas-tiz kontrol evresini de önce low-pass, high-pass olarak düşünsek de, bunun iyi sonuçlar vermediğini görüp, yine TDA’nin ürettiği, bas-tiz kontrol entegresi olan TDA1524′ü, Vumetre devresi için LM3915 ve Vu-Metreye giren ses giriş seviyesini ayarlamak için LM358 adlı opampı kullandık. Son olarak mikser devresinde, her kanal için TL074 adlı opampı seçtik.

Yaptığımız testler sonucu aldığımız veriler ise aşağıdaki gibidir. Ayrıca proje sonunda 100 üzerinden 95 alınmıştır.

Bu proje ile ilgili detaylı açıklama ve hesaplara, baskı devresi ve ayrıca simülasyon dosyasına buradan veya Mühendislik/Mikroelektronik ve Sinyal bölümünden ulaşabilirsiniz.
Herkese iyi çalışmalar.