Merhaba,

Bu bölümde PIC24F serisi ile 4×20 LCD’ye nasıl sürüleceğini gösteren bir program ekliyeceğim. Yararlı olacağını umuyorum.

/*
Aykut ULUSAN
Elektronik Mühendisi
IZMIR

www.uicroarm.com

işlemci : PIC24Fj32
osc: dahili fast osc, 8mhz, TCY=1us/8=125ns
LCD busy flag kullanılmayacak, 4bit interface
Board : EXPKITS  EX16L-A (PIC24F ve PIC33F geliştirme boardu)
*/

#include <p24Fxxxx.h>			// 

_CONFIG1(0x3F20)  // JTAG, WDF, flash memory'ye yazma kullanılmayacak
_CONFIG2(0x78EF)	// Dahili fast rc osc enable, xtal uçları boş olacak
//_CONFIG2(  IESO_OFF & FNOSC_PRI & FCKSM_CSDCMD & OSCIOFNC_OFF & IOL1WAY_ON & I2C1SEL_PRI & POSCMOD_HS );
//_CONFIG1(  JTAGEN_OFF & GCP_OFF &  GWRP_OFF & BKBUG_OFF & COE_OFF & ICS_PGx1 & WINDIS_OFF ); 	

#define	LCD_RS			LATBbits.LATB8		// lcd için register select pin
#define	LCD_E			LATBbits.LATB5		// lcd enable pin
#define	LCD_PORT		LATB
#define	LCD_TRIS		TRISB
#define	d				1					// lcd'ye data/karakter yazılacak
#define	c				0					// lcd'ye komut yazılacak
#define	D				d					// lcd'ye data/karakter yazılacak
#define	C				c					// lcd'ye komut yazılacak

#define NOP() 		{__asm__ volatile ("nop");}
#define CLRWDT() 	{__asm__ volatile ("clrwdt");}
#define SLEEP() 	{__asm__ volatile ("pwrsav #0");}
#define IDLE() 		{__asm__ volatile ("pwrsav #1");}

#define	LINE_1			0x80
#define	LINE_2			0xC0
#define	LINE_3			0x94
#define	LINE_4			0xD4
/*
LCD			PIC24
D4			PORTBbits.RB0
D5			PORTBbits.RB1
D6			PORTBbits.RB2
D7			PORTBbits.RB3
*/

// X*10US
void
DLY_10US(unsigned int us){
	while(us--) {
		__asm__ volatile ("repeat #33");
		__asm__ volatile ("nop");
	}
}

// 65536ms'ye kadar
void
DLY_MS(unsigned int ms){
	while(ms--){
		DLY_10US(100);
	}
}

void
LCD_ENABLE(void){
	LCD_E=1;asm("nop");asm("nop");asm("nop");asm("nop");LCD_E=0;
}

void
LCD_WRITE(unsigned char da_ta, unsigned char D_C){
	if(D_C) LCD_RS=1;					// data modu
	else	LCD_RS=0;					// komut modu
	LCD_PORT&=0x3F0;
	LCD_PORT|=da_ta>>4;					// lcd'ye gönder, RS ve E bozulmamalı
	LCD_ENABLE();						// enable

//	while(1);

	LCD_PORT&=0x3F0;
	LCD_PORT|=da_ta&0x0F;				// lcd'ye gönder
	LCD_ENABLE();						// enable
	DLY_10US(50);						// 50us delay
	LCD_RS=0;
}

void
LCD_SETUP(void){
	DLY_MS(100);			// lcd'nin kendini hazırlaması için 100ms
	LCD_PORT=0x3;
	LCD_ENABLE();
	DLY_MS(10);
	LCD_ENABLE();
	DLY_MS(10);
	LCD_ENABLE();
	DLY_MS(10);
	LCD_PORT=0x2;
	LCD_ENABLE();
	DLY_MS(10);
	LCD_WRITE(0x28,c);		// disp on, cursor off
	LCD_WRITE(0x0c,c);		//
    LCD_WRITE(0x06,c);		//
	LCD_WRITE(0x01,c);		// clear display
	LCD_WRITE(0x02,c);		//
	DLY_MS(2);		

}

void
LCD_STRING(const char *str){
	while(*str)
		LCD_WRITE(*str++,d);
} 

void
LCD_GOTO(unsigned char satir,unsigned char adres){
	LCD_WRITE(satir+adres,c);
}

int
main(void){
	AD1PCFG=0xFFFF;				// portlar dijital
	PMCON=0;
	PORTB=0;					// latch'leri temizle
	TRISB=0; asm("NOP");		// B portu çıkış

	LCD_SETUP();
	LCD_GOTO(LINE_1,0);
	LCD_STRING("www.uicroarm.com");
	LCD_GOTO(LINE_2,0);
	LCD_STRING("PIC24 by Kutay");
	while(1);
	return(0);
}

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,

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.

Merhaba,
Bu uygulamızda 3 wire(tel) üzerinden lcd uygulamasını gerçekleştirirken asm içinde macronun nasıl kullanıldığını göreceğiz. Öncelikle neden 3 wire üzerinden lcd ile haberleşmeye gereksinim var sorusuna cevap vereyim? Şahsen mümkün olduğunca küçük boyutta işlemci (az sayıda porta sahip) kullanmaya çalışıyorum ve haberleşmeleri ise seri haberleşme seçiyorum ki en az pinli işlemci kullanabileyim. Bu şekilde kullanmanın daha çok avantajları ama dezavantajları da var.

Avantajları :
Port sayısı az olduğu için işlemci ucuz oluyor, pcb’de daha az yer kaplıyor ve pcb yaptırım ücreti azalıyor.

Belki diyebilirsiniz ki, işlemci küçük ama yerine başka bir IC kullanıyorsun bu maliyete ve pcb yerleşimine etki etmiyor mu? Evet başka bir IC kullanıyorum, 74HC595, fiyat açısından çok ucuz (paha açısında çok portlu işlemci ile karşılaştırılamaz bile) ve IC’yi smd kullandığım için yer sorunu olmuyor.

LCD’yi 4bit haberleşme ile bile sürersek işlemcinin en az 7 portunu harcamamız gerekir. 3 wire kullanarak 4 port avantaja geçiyoruz. Bu olay bazı durumlarda maliyetten de önemli oluyor. Hatta 74hc595 için kullanılan latch pini hariç, serial data ve clock uçlarınıda başka IC’ler ile haberleşirken kullanabilir.

Dezavantajı : Endüstriyel uygulamalarda, 74hc595 latch’li bir shift register olduğu için yogun gürültü altında latch pini etkilenebilir ve çıkışları farklı bir değere latch edebilir.Bunun önüne geçmek için pcb üzerinde ve elektronik malzeme olarak bazı önlemler alınmalıdır. 74hc595′in diğer güzel tarafı hem latch’li olması hemde 50Mhz’e kadar clock’landırılabilir olmasıdır.

Genelde çoğu uygulamamda PC ortamında şema çizmem (aslında bunun nedeni eagle kullanıyorum ve şematik editörünü beğenmiyorum), karakalem ile şemayı belirler sonra program içinde şemadaki kritik değerleri belirtirim. Pcb’yi ise doğrudan çizerim. Elektroniğe hakimseniz böylesi kolay oluyor.

(Resimdeki lcd boardu delikli pertenax üzerine kuruludur, ana board’dan bağımsız olması ve tüm geliştirme boardlarıyla birlikte kullanılması için. Elektronik pahalı meslek, bazen ucuz çözümler kullanmak gerekir)

Bu uygulamada en kritik şey, 74hc595′in çıkışlarının lcd’ye hangi sıra ile bağlanacağıdır.
Q7 Q6 Q5 Q4 Q3 Q2 Q1 Q0 74HC595 çıkışları,
D7 D6 D5 D4 E RW RS – LCD pinleri , Q0 çıkışına bağlı pin yok.

E=enable, RW=Read/write, RS=Register select

Aşağıda bağlatının yapıldığı bir picture var. Yukarıda anlatılanlara göre bağlantısı yapıldı ve extra olarak

plaket üzerinde 78L05 (LCD 5V ve backlight için) ve backlight bias direnci var.

Program içinde benim oluşturduğum assembly’de çok kullanışlı string’ler için bir macro var. Başka macrolar da var. Program içinde uygulamaları görülecektir. Macrolar sayesinde asm dilini biraz daha basitleştirmiş oluruz ve çok tekrar gerektiren ama birbirinden farklı durumlar için bir macro yeterli olmaktadır. Bizim yazmamız gereken kodları, bizim yerimize derleyici oluşturur.

Mesela aşağıdaki örnekte , LCD’nin 1 satırından ve 1 karakterinden başlayarak “satir1″ adlı string’i yazdırır.
LCD_YAZI satir1,1,1

;==========================================================
; Aykut ULUSAN, Elektronik Mühendisi, IZMIR
;===========================================================
; 3wireLCD : 74HC595 ile SCK,SDA ve LOAD ucu ile 3 wire üzerinden LCD sürülür.
;===========================================================
LIST		P=16F877
INCLUDE		"P16F877.INC"
TITLE 		"3wire LCD"
ERRORLEVEL	-302,-207,-205
RADIX		DEC				; Sayı tipini belirtmediklerimi desimal kullan
__CONFIG 	0x3F32			; hs,code protects off,Wdt off,Pwrte on, boden off,wrt off,

CBLOCK		20H
LCD_DATA
DATA_OUT					; 3 wire LCD için
HC595_COUNT
TABLE_REG
COUNT1
COUNT2
COUNT3
ENDC

; LCD'yi 74HC595 ile sürmekteyim
#DEFINE	LCD_SDA		PORTA,1		; 74HC595'in SDA pinine
#DEFINE	LCD_SCK		PORTA,2		; 74HC595'in SCK pinine
#DEFINE	LCD_LOAD	PORTA,0		; 74HC595'in LOAD pinine

#DEFINE	CARRY_FLAG	STATUS,0	; Carry flag
#DEFINE	ZERO_FLAG	STATUS,2	; Zero flag

DLY_MS		MACRO	MS		; 1-255 msn arasında delay sağlar(20Mhz'de)
MOVLW		MS
CALL		X_MSN
ENDM

DLY_10US	MACRO US					; US'ye verilecek değer 1 - 255 ile 10usn ile 2550usn(2,5msn) delay sağlanır
MOVLW		US
MOVWF		COUNT1
CALL		X_ON_USN
ENDM

BANK0 		MACRO								; Bank0'a geç
BCF			STATUS,RP1
BCF			STATUS,RP0
ENDM

BANK1		MACRO								; Bank1'e geç
BCF			STATUS,RP1
BSF			STATUS,RP0
ENDM

MOVFF		MACRO	REG1,REG2					; Register1'i register2'ye kopyalayan macro
MOVF		REG1,W
MOVWF		REG2
ENDM

MOVLF		MACRO	L,F							; Literali file'a taşı
MOVLW		L
MOVWF		F
ENDM

; LCD karekter adresleri için macro :
; LCD_ADRES	1,1  için						; 1 .satır 1.adrese gider
; LCD_ADRES	1,3  için						; 1 .satır 3.adrese gider
; LCD_ADRES	2,1  için						; 2 .satır 1.adrese gider
LCD_ADRES MACRO	SATIR,ADRES		;
IF	SATIR==1
MOVLW	7FH						; 7F+1=80H 1. satır adres başlangıcı
ELSE
MOVLW	0BFH					; 0BF+1=0C0H 2. satır adres başlangıcı
ENDIF
ADDLW	ADRES						;80H  veya 0C0H ile ADRES değerini toplar
CALL	LCD_KOMUT_YAZ
ENDM

; YAZI : Ekrana yazdılacak yazı etiketi
; SATIR : LCD'nin satırı (1 veya 2)
; ADRES : LCD'nin adresi ( 1......16 ya kadar)
LCD_YAZI	MACRO	YAZI,SATIR,ADRES	;
LCD_ADRES	SATIR,ADRES				; LCD'de ilgili satıra gitmesini sağlar
LCD_STRING YAZI
ENDM

LCD_STRING MACRO	STRING
CLRF	TABLE_REG
MOVF	TABLE_REG,W
CALL	STRING
CALL	LCD_STR					; bu altprogram,
BTFSS	ZERO_FLAG					; table'dan 0 geldiyse çık
GOTO	$-4							; Call ile table'dan karekter alır.
ENDM

ORG		0
goto  	start

ORG		4
GOTO	start

LCD_INIT_TABLE_1:							; LCD'yi hazırlamak için hex değerler tutulur
MOVF		TABLE_REG,W
ADDWF		PCL,F
DT			30H,30H,20H,0

LCD_INIT_TABLE_2:							; Burada tüm bitler gönderilir (8 bit) (mesela önce 2 sonra 8 gönderilir)
MOVF		TABLE_REG,W
ADDWF		PCL,F
DT			28H,08H,06H,03H,0CH,0

satir1:
ADDWF		PCL,F
DT			"MACRO KULLANIMI",0

satir2:
ADDWF		PCL,F
DT			"ve 3 WIRE LCD",0

start:
CALL	PORTLARI_HAZIRLA		; port ayarlarını yap
CALL	LCD_INIT				; LCD'yi hazırla
call	YAZ_BAKALIM
goto 	$

;////////////////////////////////////////////////////////////////////////////////////////////////////
YAZ_BAKALIM:
LCD_YAZI	satir1,1,1			; 1. satır, 1 karakterden itibaren
LCD_YAZI	satir2,2,2			; 2. satır, 2 karakterden itibaren
RETURN

LCD_INIT:
;	BSF			LCD_ON				; lcd'nin power'ı ve backlight'ı iki tr. ile on yapılır
DLY_MS		.100				; LCD'nin hazırlanması için gerekli süre (en az 40msn)
MOVLW		30H					;
CALL		WRITE_595
DLY_MS		.1
MOVLW		38H
CALL		WRITE_595
DLY_MS		.1					; 1ms
MOVLW		30H					;
CALL		WRITE_595
DLY_MS		.10					; 10ms delay
CALL		CTRL_BYTE
CALL		LCD_SET_UP
RETURN
; *******************************************************************************************************
LCD_SET_UP:
CLRF		TABLE_REG
LCD_KOMUT:
CALL		LCD_INIT_TABLE_2
IORLW		0
BTFSC		ZERO_FLAG			; Table'dan W=0 gelirse geri dön
RETURN
CALL		LCD_KOMUT_YAZ
INCF		TABLE_REG,F
GOTO		LCD_KOMUT
; *******************************************************************************************************
LCD_CLR_LINE_1:						; 1. satırı sil
MOVLW		80H					; 1. satırın ilk adresini gönder
CALL		LCD_KOMUT_YAZ		;
CALL		LCD_CLR_LINE		; 16 hücreyi de sil
MOVLW		80H
CALL		LCD_KOMUT_YAZ		; 1. satırın ilk adresini gönder
RETURN

LCD_CLR_LINE_2:						; 2. satırı sil
MOVLW		0C0H				; 2. satırın ilk adresini gönder
CALL		LCD_KOMUT_YAZ		;
CALL		LCD_CLR_LINE		; 16 hücreyi de sil
MOVLW		0C0H
CALL		LCD_KOMUT_YAZ		; 2. satırın ilk adresini gönder
RETURN

LCD_CLR_LINE:
CLRF		TABLE_REG
LINE_SIL:
MOVLW		" "					; Working'e boşluk yükle
CALL		LCD_DATA_YAZ
INCF		TABLE_REG,F
BTFSS		TABLE_REG,4
GOTO		LINE_SIL
RETURN

LCD_CLEAR:							; LCD'yi komple temizler ve 2.satır başında bekler
CALL		LCD_CLR_LINE_1		; 1. satırı sil
CALL		LCD_CLR_LINE_2		; 2. satırı sil
RETURN
; *******************************************************************************************************
CTRL_BYTE:							; 4 bit komutları göndermek için kullanılır
CLRF		TABLE_REG
CTRL_BYTE_AL:
CALL		LCD_INIT_TABLE_1	;
IORLW		0					; 0 gelirse gönderme bitmiştir
BTFSC		ZERO_FLAG			; Table'dan W=0 gelirse geri dön
RETURN
CALL		CONTROL_BYTE_GONDER
INCF		TABLE_REG,F
GOTO		CTRL_BYTE_AL
; *******************************************************************************************************
CONTROL_BYTE_GONDER:
MOVWF		LCD_DATA			; komutu registere taşı
MOVF		LCD_DATA,W			; Sadece ilk 4 bit gönder, Enable=0
ANDLW		0F0H				; D7-D4 maskele
CALL		WRITE_595
MOVF		LCD_DATA,W			; Sadece ilk 4 bit gönder, Enable=0
ANDLW		0F0H				; D7-D4 maskele
IORLW		08H					; E=1
CALL		WRITE_595
MOVF		LCD_DATA,W			; Sadece ilk 4 bit gönder, Enable=0
ANDLW		0F0H				; D7-D4 maskele
CALL		WRITE_595
DLY_MS		.1
RETURN
; *******************************************************************************************************
; LCD'ye komut gönderen alt program, LCD'ye E'nin düşen kenarı ile yazılır.
; 4bitlik nibble datalar ve RS ve R/W ucları , E=0 sonra E=1 daha sonra E=0 için gönderilir
LCD_KOMUT_YAZ:
MOVWF		LCD_DATA			; komutu registere taşı
MOVF		LCD_DATA,W			; yine aynı datanın
ANDLW		0F0H				; D7-D4 bitlerini maskele
IORLW		08H					; E=1 RS=R/W=0 ve Datanın high order byte'nı LCD ye gönder
CALL		WRITE_595
MOVF		LCD_DATA,W			;
ANDLW		0F0H				; D7-D4 maskele
CALL		WRITE_595			; RS,R/W ve E ucu low, Datanın high order byte'nı LCD ye gönder
SWAPF		LCD_DATA,W			; LSB için nibble'ları değiştir
ANDLW		0F0H				; D7-D4 maskele
IORLW		08H					; E=1 RW=0 RS=0    x
CALL		WRITE_595			; RS,R/W ve E=1, Datanın low order byte'nı LCD ye gönder
SWAPF		LCD_DATA,W			; LSB için nibble'ları değiştir
ANDLW		0F0H				; D7-D4 maskele
CALL		WRITE_595			; RS,R/W ve E ucu low, Datanın low order byte'nı LCD ye gönder
DLY_10US 	.50					; LCD'nin komutu çalıştırması için 500us
RETURN
; *******************************************************************************************************
; LCD'ye karekter gönderen alt program ve karekterin hazır olması için gerekli delay'i
; kapsar

LCD_DATA_YAZ:
MOVWF		LCD_DATA			; komutu registere taşı
MOVF		LCD_DATA,W			; Ilk önce msb gönderilir
ANDLW		0F0H				; D7-D4 maskele
IORLW		0AH					; E=1 RW=0 RS=1   x
CALL		WRITE_595			; LCD ye gönder
MOVF		LCD_DATA,W			; Ilk önce msb gönderilir
ANDLW		0F0H				; D7-D4 maskele
IORLW		02H					; E=0 RW=0 RS=1   x
CALL		WRITE_595			; LCD ye gönder,
SWAPF		LCD_DATA,W			; lsb için nibble'ları değiştir
ANDLW		0F0H				; D7-D4 maskele
IORLW		0AH					; E=1 RW=0 RS=1    x
CALL		WRITE_595			; LCD ye gönder, LCD enable
SWAPF		LCD_DATA,W			; lsb için nibble'ları değiştir
ANDLW		0F0H				; D7-D4 maskele
IORLW		02H					; E=0 RW=0 RS=1    x
CALL		WRITE_595			; LCD ye gönder, LCD enable
DLY_10US 	.10					; LCD'nin datayı yazabilmesi için en az 50us
RETURN
; *******************************************************************************************************
; DATA_OUT içindeki 8 bitlik veri 595'e yazılır ve Latch edilir
; Böylece LCD'ye komut veya karekter ulaşır

WRITE_595:
MOVWF		DATA_OUT			; DATA_OUT registerinin içeriği gönderilir
MOVLW		.8
MOVWF		HC595_COUNT			; 8 Bit için sayıcı
_595_BIT:
BCF			LCD_SDA
BTFSC		DATA_OUT,7
BSF			LCD_SDA
BSF			LCD_SCK				; Shift
BCF			LCD_SCK
RLF			DATA_OUT,F
DECFSZ		HC595_COUNT,F
GOTO		_595_BIT
BSF			LCD_LOAD			; Latch et
BCF			LCD_LOAD
RETURN
; *******************************************************************************************************
LCD_STR:							; LCD_STRING macrosunda kullanılır, tüm table'lar için geçerlidir.
IORLW		0					; 0 gelirse gönderme bitmiştir
BTFSC		ZERO_FLAG			; Table'dan W=0 gelirse geri dön
GOTO		$+3					; Yazma işlemi bitmiştir , zero_flag=1'dir
CALL		LCD_DATA_YAZ
INCF		TABLE_REG,F
RETURN

BLINK_ON:							; Blink Aç
MOVLW		0DH
GOTO		$+2
BLINK_OFF:							; Blink Kapat
MOVLW		0CH
CALL		LCD_KOMUT_YAZ
RETURN

; delay routinleri
X_MSN:								; COUNT3 x 1msn delay sağlar
;	CLRWDT							; Her msn'de WDT'yi sil
MOVWF		COUNT3
CALL		ONE_MSN
DECFSZ		COUNT3,F
GOTO		$-2
RETURN

ONE_MSN:
MOVLF		.100,COUNT1			; 1msn delay için COUNT1'e 100 yükle
; Count1=1 iken  toplam 11usn delay
; count1=100 iken toplam 1ms yani 1000usn olamalı(100x9,6usn+100x0,2usn+99x0,4usn+1,2usn)=960+20+40+1,2=1021usn
; count1=25 iken 250usn olmalı (25x9,6usn+25x0,2usn+24x0,4usn+1,2usn)=240+5+9,6+1,2=256usn
X_ON_USN:								; Buraya kadar 800ns
CALL		ON_USN				; Count1x9,6usn
DECFSZ		COUNT1,F				; COUNT1x200ns
GOTO		$-2						; (COUNT1-1)x400ns
RETURN								; 400ns

; 20Mhz'de tam 9,6 usn delay sağlar
ON_USN:								; 400ns
MOVLF		.11,COUNT2			; 400ns
NOP								; 11x200ns
DECFSZ		COUNT2,F			; 11x200ns
GOTO		$-2					; 10x400ns
RETURN							; 400ns

PORTLARI_HAZIRLA:
BANK0							; Bank0'a geç
CLRF		INTCON				; Interupt Control Registerlerini clear et
CLRF		PIR1				; Interrupt Flagleri temizle
CLRF		PORTA				; Latch'leri temizle
CLRF		PORTB
CLRF		PORTC
BANK1							; Bank1'e geç
MOVLF		07H,ADCON1			; PortA Digital I/O
MOVLF		00H,OPTION_REG
CLRF		TRISA				; PortA çıkış
BANK0							; Bank0'a geç
RETURN

END

Uygula ile ilgili aşağıya bir kaç resim ekledim. Dediğim gibi bu tür uygulamaları normalde 28pin’e kadar olan uC’ler de kullanıyorum(tabii ki C versiyonunu) ama aşağıya çalışırlığını göstermek için benim yaptığım PIC184520/PIC16F877A geliştirme boardunu kullandım. Resimlerden de görüldüğü gibi, LCD ile 3 tel üzerinden haberleşiliyor. LCD kart beslemesi için 7V5-8V arası 78L05 için en iyi değerdir.