Merhaba,
İş yoğunluğumdan dolayı yeterince site ile ilgilenemiyorum bu nedenle yazılarımın çıkışı gecikiyor. Bu uygulamızda dsPIC30F serisinde SPI modülünü kullanarak NOKIA3310 LCD’ye yazacağız. Bu konuya ek olarak C30′da program nasıl yazılır, asm30 hakkında ve microchip 16bit microcontroller’ler hakkında biraz daha detaylı bilgileri 2008 yılında 2. picproje dergisi için hazırladığım makalede bulabilirsiniz.

Web Adresi : http://dergi.picproje.org/author/kutay/

Nokia3310 lcd ile SPI haberleşme çeşidiyle iletişim kurulur. Haberleşme bit sayısı 8bit’tir. Max. clock hızı 4mhz’e kadar kullanılabilir. LCD hakkında daha fazla bilgi için LCD driver’ının datasheet’ine bakabilirsiniz. (PCD8544)
Datasheet’i iyi incelerseniz özellikle komut setini, çok daha iyi uygulamalar yapabilirsiniz. Benim tasarladığım ve geliştirme amaçlı olarak kullandığım dsPIC30F4011 boardunda denedim. Eski alışkanlıklardan dolayı şematik çizmeden pcb çizdiğim için şemasını veremiyorum ama cadsoft eagle pcb’yi dosyası aşağıdadır.

dsPIC30F4011 board pcb dosyası

Program ve resimler aşağıdadır.

/*======================================================
Proje Adı 	 : dsPIC30F4011 ile Nokia 3310 LCD kontrolü
web site      : uicroarm.com
Yazan 	 : Aykut ULUSAN, Elektronik Mühendisi, IZMIR
=======================================================*/
#include "p30F3010.h"					// 4011 kullanacağız
#include "ascii.h"						// karakter hexlerini include edelim

_FOSC(CSW_FSCM_OFF & XT_PLL8);  		//10Mhz *8 = 80 MHz /4 = 20 MIPS
_FWDT(WDT_OFF);					// WDT off
_FBORPOR(PBOR_OFF & PWRT_64 & MCLR_EN);	// MCLR on, PWRT=64ms, PBOR off
_FGS(CODE_PROT_OFF);				// kod koruması off

// clock ve data SPI portundan sağlanır, 40 pin DSpic30F4011
// SDI1      RF2  26 	- Okuma yapılmadığı için kullanılmıyor
// SDO1    RF3  25  	- Kullanılıyor
// SCK1    RF6  24	- Kullanılıyor 

/*
Nokia GLCD					dsPIC30F4011(40pin)
SCK						RF6
SDA						RF3
DC    						PORTD2
CS						PORTD0
RST						PORTD3
*/			

#define     GLCD_DC    	LATDbits.LATD2     		// Data/Command select
#define     GLCD_CS   	LATDbits.LATD0     		// Chip Select
#define     GLCD_RST   	LATDbits.LATD3     		// Reset
#define		D		1				// data gönderilecek
#define		C		0				// komut gönderilecek
#define		off		1				// Chip select on
#define		on		0				// Chip select off yapıyoruz

void GLCD_INIT(void);						 // Glcd’yi hazırla
void PORT_SETUP(void);						// portları hazırla
void GLCD_YAZ(unsigned int DA_TA,unsigned int D_C);	// GLCD’ye yaz
void GLCD_CLEAR(void);						// ekranı temizle
void GLCD_POZISYON(unsigned int sayfa, unsigned int sutun);	// koordinata git
void GLCD_KARAKTER_YAZ(char c);				// ekrana karakter yaz
void GLCD_YAZI_YAZ(const char *s);				// ekrana string yaz
void DLY_MS(unsigned int ms);					// 1ms - 65536ms delay sağlar
void DLY_US(unsigned int us);					// 1-65535 us delay sağlar
void BIR_USN(void);						// 1us lik delay

int
main (void){
	PORT_SETUP();
	GLCD_INIT();
	GLCD_CLEAR();				// Ekranı temizle
	GLCD_POZISYON(0,0);			// 0. sayfa 0. sütuna git
	GLCD_YAZI_YAZ("NOKIA 3310 LCD");	// NOKIA 3310 LCD yaz
	GLCD_POZISYON(1,0);			// 1. sayfa 0. sutuna git
	GLCD_YAZI_YAZ("UICROARM.COM");	// UICROARM.COM yazar
	GLCD_POZISYON(2,0);
	GLCD_YAZI_YAZ("EEMKUTAY");		//
	while(1);
}

void
PORT_SETUP(void){
	ADPCFG=0xFFFF;			// tüm portlar digital
	PORTB=0;
	PORTC=0;
	PORTD=0;
	PORTE=0;				// SCK1 çıkış RE8
	TRISB=0;				// çıkış
	TRISC=0;
	TRISD=0;
	TRISE=0;
	TRISF=0xFFF4;			// 0100    RF2=SDI(input) , RF3=SDO(çıkış)
// Aşağıdaki şekilde 4MIPS clock hızında ,Master,Data aktiften idle’a geçerken değişir, idle clock low
// state,aktif clock high state,8bit modunda,
//  SS1 pini kullanılmıyor olacak şekilde ayarladık
	SPI1CON=0x012F;
	SPI1STAT=0x8000;					// SPI port enable
}

void
GLCD_INIT(void){
	DLY_MS(150);		// beslemenin tam oturması için 150ms
	GLCD_CS=off;		// chip select off (reset, chip select'e bakmaz)
	GLCD_DC=D;		// Ram'i temizleyeceğimiz için data modu seçilir
	DLY_MS(10);		// Kararlılık için 10ms bekle
	GLCD_RST=0;		// resetle
	DLY_MS(50);		// 50ms bekle
	GLCD_RST=1;		// reset sonu,
	DLY_MS(10);
	GLCD_YAZ(0x21,C);	 // PD=0(Chip enable),V=0(Horizontel modu),H=1(extended instruction set)
	GLCD_YAZ(0xC8,C);	 // Vop (6/8 Vlcd)
	GLCD_YAZ(0x13,C);	 // 1/48 bias
         GLCD_YAZ(0x20,C);	 // PD=0 (Chip enable), V=0 (Horizontel modu), H=0 (basic instruction set)
         GLCD_YAZ(0x0C,C);	 // Normal Mode
//       GLCD_YAZ(0x0D,C);  // Görüntüyü invert et
}

void
GLCD_YAZ(unsigned int DA_TA,unsigned int D_C){
	unsigned int temp;		// overflow varsa temizleyeceğiz
	if (D_C==D)
		GLCD_DC = 1;      	// Data Mode
      	else
	 	GLCD_DC = 0;   	// Komut Mode
	GLCD_CS=on;			// chip on
	SPI1STATbits.SPIROV=0;	// overflow varsa da yoksa da clear
	temp=SPI1BUF;		// Buffer'ı temizle,
	SPI1BUF=DA_TA;		// gönderilecek veriyi buffer'a at
	while(SPI1STATbits.SPITBF);
	while ( !SPI1STATbits.SPIRBF);
	GLCD_CS=off;
} 

void
GLCD_CLEAR(void){
	unsigned int x;			// Counter olarak kullanacağız
	GLCD_POZISYON(0,0);	// 0.Sayfa ve 0.sutuna git
	for(x=0;x<504;x++)
		GLCD_YAZ(0x00,D);	// Data yazılacak ama 0x00
}

// sayfa yerine 0-5, sutun yerine 0-83 arası sayı girilebilir
void
GLCD_POZISYON(unsigned int sayfa, unsigned int sutun){
	GLCD_YAZ((0x40|(sayfa&0x07)),C); // sayfa'in ilk 3 bitini maskele ve 0x40 ile OR'la, C=Komut
	GLCD_YAZ((0x80|(sutun&0x7F)),C); // Sutun için ilk 7 biti maskele 0x80 ile OR'la
}

void
GLCD_KARAKTER_YAZ(char c) {  // c urada karakterdir ve 'c' şeklinde yazılır (a harfi için = 'A'yazılır)
   	unsigned int n;                // Sadece bir counter(1 karekteri ekranda göstermek için 5 byte gerekli)
   	unsigned int ch;              // Karakterin 5 byte'nın bulunduğu yeri belirler ve tutar
   	if ((c<32)||(c>126))        // Karekter değeri 48'den küçük veya 90'dan büyük ise
   	c=63;                            // c=63 yap. (bu şart sağlanıyorsa karekter sınırlarını aşmışız demektir) ? =63
   	ch = (c-32)*5;               // C'den 32(20h yani ilk karakterin hex değeri) çıkart ve 5 ile çarp
   	for(n=5; n>0; n--)	   // ch'ı bir arttır ve gösterdiği hex'i Glcd'ye gönder
      		GLCD_YAZ((font[ch++]),D);      // 5 kez bu işlem devam eder
	GLCD_YAZ(0,D);                   	// Her karakter arasında bir sütun boşluk bırakılır.
}

void GLCD_YAZI_YAZ(const char *s){
	while(*s)
	     GLCD_KARAKTER_YAZ(*s++);
}

void
BIR_USN(void){		        // 1 usn delay
	asm("REPEAT  #15");	// (15+1)x50ns=800 usn
	asm("nop");
}

// 1 usn - 65 535 usn arasında (65,536ms)
void
DLY_US(unsigned int us){
	unsigned int c;
	for(c=0;c<=us;c++)
		BIR_USN();
}

void
DLY_MS(unsigned int ms){
	unsigned int c;
	for(c=0;c<=ms;c++)
		DLY_US(1000);
}

/*========================================================
ASC2 karakterler
ascii.h
=========================================================*/
const char font[ ] ={
	0x0,0x0,0x0,0x0,0x0,  			// 	32 -esp- 20
	0x0,0x0,0x4F,0x0,0x0, 			//	33 - ! - 21
	0x0,0x7,0x0,0x7,0x0, 			//	34 - " - 22
	0x14,0x7F,0x14,0x7F,0x14, 		//	35 - # - 23
	0x24,0x2A,0x7F,0x2A,0x12, 		//	36 - $ - 24
	0x23,0x13,0x8,0x64,0x62, 		//	37 - % - 25
	0x36,0x49,0x55,0x22,0x50, 		//	38 - & - 26
	0x0,0x5,0x3,0x0,0x0, 			//	39 - ' - 27
	0x1C,0x22,0x41,0x0,0x0, 		//	40 - ( - 28
	0x0,0x0,0x41,0x22,0x1C, 		//	41 - ) - 29
	0x14,0x8,0x3E,0x8,0x14, 		//	42 - * - 2A
	0x8,0x8,0x3E,0x8,0x8, 			//	43 - + - 2B
	0x0,0x50,0x30,0x0,0x0, 		//	44 - , - 2C
	0x8,0x8,0x8,0x8,0x8, 			//	45 - - - 2D
	0x0,0x60,0x60,0x0,0x0, 		//	46 - . - 2E
	0x20,0x10,0x8,0x4,0x2, 		//	47 - / - 2F
	0x3E,0x51,0x49,0x45,0x3E, 		//	48 - 0 - 30
	0x0,0x42,0x7F,0x40,0x0, 		//	49 - 1 - 31
	0x42,0x61,0x51,0x49,0x46, 		//	50 - 2 - 32
	0x21,0x41,0x45,0x4B,0x31, 		//	51 - 3 - 33
	0x18,0x14,0x12,0x7F,0x10, 		//	52 - 4 - 34
	0x27,0x45,0x45,0x45,0x39, 		//	53 - 5 - 35
	0x3C,0x4A,0x49,0x49,0x30, 		//	54 - 6 - 36
	0x1,0x71,0x9,0x5,0x3, 			//	55 - 7 - 37
	0x36,0x49,0x49,0x49,0x36, 		//	56 - 8 - 38
	0x06,0x49,0x49,0x29,0x1E, 		//	57 - 9 - 39
	0x0,0x36,0x36,0x0,0x0, 		//	58 - : - 3A
	0x0,0x56,0x36,0x0,0x0, 		//	59 - ; - 3B
	0x8,0x14,0x22,0x41,0x0, 		//	60 - < - 3C
	0x14,0x14,0x14,0x14,0x14, 		//	61 - = - 3D
	0x0,0x41,0x22,0x14,0x8, 		//	62 - > - 3E
	0x2,0x1,0x51,0x9,0x6, 			//	63 - ? - 3F
	0x32,0x49,0x79,0x41,0x3E, 		//	64 - @ - 40
	0x7E,0x11,0x11,0x11,0x7E, 		//	65 - A - 41
	0x7F,0x49,0x49,0x49,0x36, 		//	66 - B - 42
	0x3E,0x41,0x41,0x41,0x22, 		//	67 - C - 43
	0x7F,0x41,0x41,0x22,0x1C, 		//	68 - D - 44
	0x7F,0x49,0x49,0x49,0x41, 		//	69 - E - 45
	0x7F,0x9,0x9,0x9,0x1, 			//	70 - F - 46
	0x3E,0x41,0x49,0x49,0x7A, 		//	71 - G - 47
	0x7F,0x8,0x8,0x8,0x7F, 		//	72 - H - 48
	0x0,0x41,0x7F,0x41,0x0, 		//	73 - I - 49
	0x20,0x40,0x41,0x3F,0x1, 		//	74 - J - 4A
	0x7F,0x8,0x14,0x22,0x41, 		//	75 - K - 4B
	0x7F,0x40,0x40,0x40,0x40, 		//	76 - L - 4C
	0x7F,0x2,0xC,0x2,0x7F, 		//	77 - M - 4D
	0x7F,0x4,0x8,0x10,0x7F, 		//	78 - N - 4E
	0x3E,0x41,0x41,0x41,0x3E, 		//	79 - O - 4F
	0x7F,0x9,0x9,0x9,0x6,			//	80 - P - 50
	0x3E,0x41,0x51,0x21,0x5E, 		//	81 - Q - 51
	0x7F,0x9,0x19,0x29,0x46, 		//	82 - R - 52
	0x46,0x49,0x49,0x49,0x31, 		//	83 - S - 53
	0x1,0x1,0x7F,0x1,0x1, 			//	84 - T - 54
	0x3F,0x40,0x40,0x40,0x3F, 		//	85 - U - 55
	0x1F,0x20,0x40,0x20,0x1F, 		//	86 - V - 56
	0x3F,0x40,0x38,0x40,0x3F, 		//	87 - W - 57
	0x63,0x14,0x8,0x14,0x63, 		//	88 - X - 58
	0x7,0x8,0x70,0x8,0x7, 			//	89 - Y - 59
	0x61,0x51,0x49,0x45,0x43, 		//	90 - Z - 5A
	0x7F,0x41,0x41,0x0,0x0, 		//	91 - [ - 5B
	0x2,0x4,0x8,0x10,0x20, 		//	92 - \ - 5C
	0x0,0x0,0x41,0x41,0x7F, 		//	93 - ] - 5D
	0x4,0x2,0x1,0x2,0x4, 			//	94 - ^ - 5E
	0x40,0x40,0x40,0x40,0x40, 		//	95 - _ - 5F
	0x0,0x1,0x2,0x4,0x0, 			//	96 - ` - 60
	0x20,0x54,0x54,0x54,0x78,		//	97 - a - 61
	0x7F,0x48,0x44,0x44,0x38, 		//	98 - b - 62
	0x38,0x44,0x44,0x44,0x20, 		//	99 - c - 63
	0x38,0x44,0x44,0x48,0x7F, 		//	100  d - 64
	0x38,0x54,0x54,0x54,0x18, 		//	101  e - 65
	0x8,0x7E,0x9,0x1,0x2, 			//	102  f - 66
	0xC,0x52,0x52,0x52,0x3E, 		//	103  g - 67
	0x7F,0x8,0x4,0x4,0x78, 		//	104  h - 68
	0x0,0x44,0x7D,0x40,0x0, 		//	105  i - 69
	0x0,0x20,0x40,0x44,0x3D, 		//	106  j - 6A
	0x7F,0x10,0x28,0x44,0x0, 		//	107  k - 6B
	0x0,0x41,0x7F,0x40,0x0, 		//	108  l - 6C
	0x7C,0x4,0x18,0x4,0x78, 		//	109  m - 6D
	0x7C,0x8,0x4,0x4,0x78, 		//	110  n - 6E
	0x38,0x44,0x44,0x44,0x38, 		//	111  o - 6F
	0x7C,0x14,0x14,0x14,0x8, 		//	112  p - 70
	0x8,0x14,0x14,0x18,0x7C, 		//	113  q - 71
	0x7C,0x8,0x4,0x4,0x8, 			// 	114  r - 72
	0x48,0x54,0x54,0x54,0x20, 		//	115  s - 73
	0x4,0x3F,0x44,0x40,0x20, 		//	116  t - 74
	0x3C,0x40,0x40,0x20,0x7C, 		//	117  u - 75
	0x1C,0x20,0x40,0x20,0x1C, 		//	118  v - 76
	0x3C,0x40,0x30,0x40,0x3C, 		//	119  w - 77
	0x44,0x28,0x10,0x28,0x44, 		//	120  x - 78
	0xC,0x50,0x50,0x50,0x3C, 		//	121  y - 79
	0x44,0x64,0x54,0x4C,0x44, 		//	122  z - 7A
	0x8,0x36,0x41,0x0,0x0, 		//	123  { - 7B
	0x0,0x0,0x7F,0x0,0x0, 			//	124  | - 7C
	0x0,0x0,0x41,0x36,0x8, 		//	125  } - 7D
	0x0,0x8,0x4,0x8,0x4			// 	126  ~ - 7E
};

Merhaba,
Bu video’da nokia6100 lcd ve arm7 ikilisi ile yapılabileceklerden bazıları var. Cep telefonu ile geç saatlerde çektiğim için video kaliteli değil. Videodan orjinal resimler aşağıdadır.Yakında bu lcd’yi yerleştirdiğim pcb dosyasını buradan vereceğim. (Eagle dosyası) . Üzerinde step-up voltaj konvertör var. LCD backlight için 5V’tu 8V yapmıştım.

Merhaba,

Yurtdışından ST’nin arm cortex m3 core’lu STM32F103RB işlemcisini içeren bir development boardu temin ettim.
Onunla yaptığım bazı uygulamaların bilgi ve görüntülerini burada paylaşacağım.
Arm cortex M3 tabanlı işlemciler ARM7′nin yerini alıyor gibi görünüyor. Daha az code (Thumb-2) ile arm7′den daha yüksek hız, performans, daha ucuz fiyat (arm firması, 8bit fiyatında 32bit sloganını kullandı) , mhz başına daha düşük güç vs.Arm cortex m3 hakkında daha detaylı bilgiyi http://www.arm.com/products/CPUs/ARM_Cortex-M3.html adresinden alabilirsiniz.

STM32 serisinde donanım olarak, moduler bazda nerdeyse heysey var. Eksik olanlarda ethernet vs. yeni serilerinde var görünüyor. (yakında stm32f105 ve 107 serisi çıkacak).

NXP’nin arm cortex işlemciside yakında çıkıyor. Bence NXP’nin işlemcisi biraz daha ağır basıyor, Bunun nedeni nxp’ye yakınlığım yani datasheet okuma , register yapısı ve programlama formatına alıştım. İkincisi ise benim için önemli olan bazı donanımlarının stm32′den iyi olması , çalışma hızı (100Mhz) ve SPI’ın 4-16bit ayarlanabilir olması gibi. Dezavantajı ise bir portu 4mA basar veya çeker. Stm32′de ise bu microchip işlemcilerindeki gibi 25mA’dir. Bu önemli bir özellik ama göreceli. Mesela port çıkışlarında buffer IC kullanmak işlemciyi korur.
Ayrıca ST’nin programmer manual’ini beğenmedim detaylı anlatım yok işin özüne girmeye çalıştığında birbiriyle bağlantılı bilgiler farklı kaynaklardan çıkıyor vs. Programlanması çok kolay bir işlemci. Bence NXP’nin arm7’si çok daha zordur.
Aşağıya Nokia3310 lcd ile yaptığım bir uygulama görüntülerini ekledim.(Ekranda koşan tavşan animasyonu var) Derleyici olarak keil kullandım. Ayrıca ansi C kullanmanın avantajı, PIC16,PIC18,dspic30F ve arm7′de kullandığım programın aynısını stm32 için kullandım. Sadece bir kaç tanımlama değişiyor. (SPI bus ile sürdüm, bus clock 18mhz/8′dir,nokia lcd 4mhz’e kadar destekler.) STM32′nin clock için pre ve postscaler’ı da bence yetersiz.

Bu uygulamada LPC2148′in SPI modulunu kullanacağız. LPC2000 serisinin , microchip 8-16bit işlemcilerine göre çok daha fonksiyonel ve kullanışlı. Örneğin göndereceğiniz bit sayısını (4-16bit) seçebiliyorsunuz bence bu çok önemli bir faktör özellikle hız gerektiren uygulamalarda, ayrıca yine bus frekansı microchip işlemcilerine göre çok daha hızlı , bu özellikte grafik lcd vs. sürerken önemli oluyor.Zaten tüm hız gerektiren uygulama IC’leri SPI ile haberleşir.

Aşağıya eklediğim program ile 74hc595′e SPI modulü ile yazıyoruz ve latch ediyoruz.74hc595 ile haberleşmek için 3 uç kullanılır. Serial data, serial clock ve latch (program içinde load yazdım çünkü bu pin hem datayı çıkış registerlerine yüklüyor hemde latch ediyor) kullanılıyor. Data ve clock için SPI0′ın data ve clock pinleri bağlanır , latch için ise P0.7 portu bağlanır.

/*****************************************************************************/

// Aykut ULUSAN, Elektronik Mühendisi, IZMIR

/*****************************************************************************/
#include "lpc214x.h"	// Nxp LPC2148 için header file

#define	SPI_PIN_CONFIG		0x1500	// SSEL kullanmiyacagiz
#define	PCLK	30000000 	//30Mhz

#define	HC595_LOAD		0x80	// P0.7'yi latch icin kullanacagiz
#define	HC595_LOAD_HIGH		IOSET0=HC595_LOAD
#define	HC595_LOAD_LOW		IOCLR0=HC595_LOAD

void
sistem_init(){
// Processor clock=5*12Mhz=60Hz
   PLL0CFG=0x24;
// PLLCON ve PLLCFG registerleri içerigi degistirildiginde , asagidaki
// proses uygulanir, 1) PLL0FEED=0xAA ve 2)PLL0FEED=0x55
   PLL0FEED=0xAA;	 	// Feed process
   PLL0FEED=0x55;

   PLL0CON=0x1;  		// PLL'i enable	et
   PLL0FEED=0xAA;		// Feed process
   PLL0FEED=0x55;
   while(!(PLL0STAT&0x400)) ;   // PLL kitleninceye kadar bekle (5*12Mhz=60Mhz'e kitlenir)

   PLL0CON=0x3;	 	// PLL'i clock kaynagi gibi bagla
   PLL0FEED=0xAA;	 	// Feed process
   PLL0FEED=0x55;

   MAMCR=0x2;	  		// MAM full Enable
   MAMTIM=0x4;			// MAM fetch cycles = 4CCLK

   VPBDIV=0x02;	 	// 30 MHz
}

void
DLY_MS(long ms){
   long i,j;
   for (i = 0; i<ms; i++ )
      for (j = 0; j<7500; j++ );
}

void
SPI0_SETUP(void){
   IO0DIR|=HC595_LOAD;       	// P0.7'yi port olarak kullanacagiz
   IO0CLR=HC595_LOAD;        	// P0.7=0
   PINSEL0|=0x1500;			// pinler SPI için kullanılacak
   S0SPCR=	  (0<<3) |			// CPHA = 0 , clock'un ilk kenarinda data sample yapilir
                  (0<<4) |			// CPOL = 0 ,clock aktif high
                  (1<<5) |			// MSTR=1 master mode
                  (0<<6);			// ilk önce 7. bit(msb) gönderilir
   S0SPCCR=30;					//1Mhz clock hizi
}

void
SPI0_SEND(unsigned char da_ta){
   S0SPDR=da_ta;				// datayi yukle
   while(!(S0SPSR&0x80));	// data gonderme tamamlandiginda S0SPRS'nin 7. biti(SPIF) set olur
   IOSET0=HC595_LOAD;	 		// latch et
   IOCLR0=HC595_LOAD;
   da_ta=S0SPDR;				// SPIF flag'i clear etmek icin okunur
}

int
main(void){
   unsigned char i=0;
   sistem_init();
   SPI0_SETUP();		 		// SPI0'i hazirla
   while(1){
      SPI0_SEND(i++);		 	// gonder
      DLY_MS(200);
   }
}

SPI modul kullanımı öğrenildikten sonra SPI ile haberleşen tüm elektronik komponentleri kontrol edebilirsiniz.
Benim yaptığım bazı uygulamarların resimleri aşağıdadır.