STM32F107 ile GLCD kullanımı Kütüphane sorunu

[Mucit23]

Hocam Son çizdiğim kartta stm32f107 nin data pinlerini portd nin düşük 8 bitine bağlamıştım. Komut pinleri ise Porte deydi. Bende hiç sıkıntı çıkarmadan çalışıyor. Ben keille yazıyorum gerçi.

Birde hocam ben şu define tanımlamalarında şüpheleniyorum.

#define CS1(x)      ((x) ? (GPIO_SetBits(GLCD_CMD_PORT,(1<<CS1_PIN)))  : (GPIO_ResetBits(GLCD_CMD_PORT,(1<<CS1_PIN))) );
#define CS2(x)		((x) ? (GPIO_SetBits(GLCD_CMD_PORT,(1<<CS2_PIN)))  : (GPIO_ResetBits(GLCD_CMD_PORT,(1<<CS2_PIN))) );
#define DI(x)		((x) ? (GPIO_SetBits(GLCD_CMD_PORT,(1<<DI_PIN )))  : (GPIO_ResetBits(GLCD_CMD_PORT,(1<<DI_PIN ))) );
#define RW(x)		((x) ? (GPIO_SetBits(GLCD_CMD_PORT,(1<<RW_PIN )))  : (GPIO_ResetBits(GLCD_CMD_PORT,(1<<RW_PIN ))) );
#define EN(x)		((x) ? (GPIO_SetBits(GLCD_CMD_PORT,(1<<EN_PIN )))  : (GPIO_ResetBits(GLCD_CMD_PORT,(1<<EN_PIN ))) );
#define RST(x)		((x) ? (GPIO_SetBits(GLCD_CMD_PORT,(1<<RST_PIN)))  : (GPIO_ResetBits(GLCD_CMD_PORT,(1<<RST_PIN))) );

Hiç glcd ile ilgili birşey yapmadan bu kısımların çalışıp çalışmadığını test edebilirmisin.

Mesela main içerisinde

     CS1(1);
     delay(100);
     CS1(0);
     delay(100);

şeklinde bir döngü ile bu komutların çalışıp çalışmadığını deneyin.
Elinizde osiloskop varsa tüm çıkış pinlerini inceleyin. Olması gerekir. Artık çalışmamasına hiçbir engel yok.
Birde Hocam sizin pin port yönlendirmelerinizdede problem olabilir.

Ben keilde port.h diye bir ek dosya kullanıyorum. Bunu programa dahil edip main içerisinde tüm portlara clock sağlama gibi işlerle uğraşmıyorum. Çok kullanışlı bir kütüphane. Tavsiye ederim sizede
port.h dosyam budur.

#include "stm32f10x_lib.h"

#define portA GPIOA
#define portB GPIOB
#define portC GPIOC
#define portD GPIOD
#define portE GPIOE

/*********************************************************//***/
/**/void defMode(GPIO_TypeDef *port,u16 value);							/**/
/**/void setOutMode(GPIO_TypeDef *port,u16 value);					/**/
/**/void output(GPIO_TypeDef *port,u16 value);							/**/
/**/void setInMode(GPIO_TypeDef *port,u16 value);						/**/
/**/int readPort(GPIO_TypeDef *port);												/**/
/**/int togglePort(GPIO_TypeDef *port);											/**/
/**/void outputBit(GPIO_TypeDef *port,u16 pin,u8 bit);			/**/
/**/int readPortBit(GPIO_TypeDef *port,int bit);
/**************************************************************/
GPIO_InitTypeDef GPIO_InitStructure;

/***********************togglePort(GPIO_TypeDef *port)************************/
/*
	*Bu metot parametre olarak aldigi portun butun pinlerini tersler
	*sonuc olarak ilgili portun cikisina terslenen datayi gonderir
	*ayrica terslenmis datayi metot sonunda parametre olarak donderir.
*/
int togglePort(GPIO_TypeDef *port){
	
	int x=readPort(port);	/*belirtilen porttan datalar okunuyor*/
	output(port,(~x));		/*~x ile okunan data tersleniyor ve cikisa gonderiliyor*/
	return (~x);					/*terslenen data geri donderiliyor*/
}

/******************************************************************************/
/*****************************setOutMode(port,value)***************************/
/* 
	*Bu metod belirlen portu cikis olarak ayarlar. 
	*Fakat cikis olarak belirlenecek portpini value degerinde set(1) edilmelidir
	*set edilmeyen(0) pinler ne giris nede cikis olarak kullanilir.
	*eger giris olarak kullanilcak bir pin var ise setInMode(port,value) metodu kullanilmalidir.
	*ayrica value degeri  0000-FFFF (0-65535) araliginda bir deger  olmadir.
	*ornek kullanim: setOutMode(portC,0x00FF); burada ilk 8 bit cikis olarak belirlenmistir.
*/
void setOutMode(GPIO_TypeDef *port,u16 value){

	defMode(port,value);														/*varsayilan port ayarlamalari yapiliyor*/
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;/*GPIO_InitStructure yapisi cikis moduna ayarlaniyor*/
	GPIO_Init(port, &GPIO_InitStructure);						/*port parametresi GPIO_InitStructure degerlerine set ediliyor*/

}

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

/*****************************output(port,value)*******************************/
/*
	*cikis olarak belirlenen portu value degeri kadar set (1) ler. set edilmeyen pinlner
	*sifir (0) ile belirtilir. value degeri 0x0000-0xFFFF (0-65535) degerleri arsinda olmadir.
	*ornek: output(portA,0xF0B1); burada portA nin cikislarina 0xF0B1 (1111000010110001) datasi gonderilmistir.
*/
void output(GPIO_TypeDef *port,u16 value){
	GPIO_Write(port,value);
}
/**********************************************************************************************/

void outputBit(GPIO_TypeDef *port,u16 pin,u8 bit){
	if(bit)
		GPIO_WriteBit(port,pin,Bit_SET);
	else
		GPIO_WriteBit(port,pin,Bit_RESET);

}
/****************************setInMode(port,value)*****************************/
/*
	* Belirlen portu giris olarak set eder. 
	* giris olarak kullaniclacak portpini value degerinde set(1) edilmelidir.
	* set edilmeyen (0) degerler ne giris nede cikis olarak setlenmis olur.
	* cikis olarak kullanilcak pinlner setOutMode(port,value); metodu ile ayalanabilir.
	* ayrica value degeri 0x0000-0xFFFF (0-65535) araliginda bir deger olmalidir.
	* ornek kullanim: setInMode(potE,0x000A); burada portE nin 1. ve 3. pinleri giris olarak ayarlanmistir.
*/
void setInMode(GPIO_TypeDef *port,u16 value){

		defMode(port,value);													/*varsayilan port ayarlamalari yapiliyor*/
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;	/*GPIO_InitStructure yapisi giris moduna ayarlaniyor*/
  	GPIO_Init(port, &GPIO_InitStructure);					/*port parametresi GPIO_InitStructure degerlerine set ediliyor*/
}

/**********************************************************************************************************/
/************************readPort(GPIO_TypeDef *port)****************************************/
/*
	* berlitilen portun datalarini okur ve geri donderir
	*	ornek kullanim:
	* int a=readPort(portA); portA nin pinlerindeki deger a degiskenine atanmis oldu
*/
int readPort(GPIO_TypeDef *port){

	return GPIO_ReadInputData(port);
}
/**********************************************************************************************************/
/*****************************readPortBit(GPIO_TypeDef *port,int bit)********************************/
/**
	* port parametresine gonderilen portun, bit paremetresine gonderilen biti okur
	* bit degeri 2^0-15 arsinda olmalidir.
	* ornek kullanim:
	* int a=readPortBit(portB,32); //32=2^5 portB nin 5.pin degeri a degiskenine ataniyor.
*/
int readPortBit(GPIO_TypeDef *port,int bit){

	return GPIO_ReadInputDataBit(port,bit);
}
/****************************************************************************************************/
void defMode(GPIO_TypeDef *port,u16 value){
	
  	GPIO_InitStructure.GPIO_Pin = value;
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	
	if(port==portA)
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	if(port==portB)
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	if(port==portC)
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	if(port==portD)
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
	if(port==portE)
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);

}

Cocox la ilgili sormak istediklerim var.

keilde sol üste seçtiğimz satırların başına çift slaş(//) koyup o satırı pasif eden bir buton var. Aynısını cocoxda yapabilirmiyim.

[muhittin_kaplan]

yok, açıklama için kendim yapıyorum.
hocam ben gpıoa,b,c,d,e ye hepsine clock uyguladım ve gpioa yı çıkış olarak tanımlaım.velhasıl olmadı.

[Mucit23]

İlginç bir durum hocam. Benim aklıma artık birşey gelmiyor.

[muhittin_kaplan]

#define GLCD_DATA_PORT	GPIOA
#define GLCD_CMD_PORT	GPIOA
#define CS1_PIN		11 // ok	
#define CS2_PIN		12 // ok					    
#define DI_PIN		8   // ok
#define RW_PIN		9   // ok
#define EN_PIN		10  // ok
//#define RST_PIN		15  // ok

tanımlamalarım bu şekilde
acaba aynı port olmuyormu ?

[Mucit23]

Hocam Mümkünse farklı portlara bağlamayı deneyin.

Ben PortD nin düşük 8 bitine (0-7) lcd nin data bacaklarını bağlamıştım. 8. bitte ise buzzer vardı. LCD data gönderirken Buzzerdende ses geliyordu. Eğer sizdede böyle bir durum var ise data bilgileri ile komut bilgileri karışıyor olabilir. Ben data gönderirken Portd nin yüksek 8 bitin maskelemiştim. Olmazsa sizde öyle bir deneyin ama bence en sağlamı ayrı portlara bağlayın.

[muhittin_kaplan]

ayrı port yapamam. makine lehimli kullandığım driverda büyük font yazdıramadım ondan ötürü bu driver a bakayım dedim. olmadı 0-9 arası ve nokta yı img olarak kaydedip istediğim yere basacağım.

[Mucit23]

Hocam ben bahsettiğim problemden şüpheleniyorum. Öncelikle datanın nereden çıktığına kesin emin olmak gerekir.

Ozaman ilk verdiğim kütüphanede deney kiti üzerinde çalışıyordum. Şimdi benim yaptığım boardda bağlantılarda bir sürü değişiklik yapmıştım.

Pek bir değişiklik yok ama bunu bir deneyin. Olmazsa Data gönderip alırken porta nın yüksek 8 bitini maskeleyin.

#include <string.h>
#include "ks0108.h"


#define EKRANAC		0x3F
#define EKRANKAPA	0x3E

#define sag 0
#define sol 1

const unsigned char TEXT[51][5] ={{0x00, 0x00, 0x00, 0x00, 0x00}, // SPACE
		                          {0x00, 0x00, 0x5F, 0x00, 0x00}, // !
		                          {0x00, 0x03, 0x00, 0x03, 0x00}, // "
		                          {0x14, 0x3E, 0x14, 0x3E, 0x14}, // #
		                          {0x24, 0x2A, 0x7F, 0x2A, 0x12}, // $
		                          {0x43, 0x33, 0x08, 0x66, 0x61}, // %
		                          {0x36, 0x49, 0x55, 0x22, 0x50}, // &
		                          {0x00, 0x05, 0x03, 0x00, 0x00}, // '
		                          {0x00, 0x1C, 0x22, 0x41, 0x00}, // (
		                          {0x00, 0x41, 0x22, 0x1C, 0x00}, // )
		                          {0x14, 0x08, 0x3E, 0x08, 0x14}, // *
		                          {0x08, 0x08, 0x3E, 0x08, 0x08}, // +
		                          {0x00, 0x50, 0x30, 0x00, 0x00}, // ,
		                          {0x08, 0x08, 0x08, 0x08, 0x08}, // -
		                          {0x00, 0x60, 0x60, 0x00, 0x00}, // .
		                          {0x20, 0x10, 0x08, 0x04, 0x02}, // /
		                          {0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0
		                          {0x04, 0x02, 0x7F, 0x00, 0x00}, // 1
		                          {0x42, 0x61, 0x51, 0x49, 0x46}, // 2
		                          {0x22, 0x41, 0x49, 0x49, 0x36}, // 3
		                          {0x18, 0x14, 0x12, 0x7F, 0x10}, // 4
		                          {0x27, 0x45, 0x45, 0x45, 0x39}, // 5
		                          {0x3E, 0x49, 0x49, 0x49, 0x32}, // 6
		                          {0x01, 0x01, 0x71, 0x09, 0x07}, // 7
		                          {0x36, 0x49, 0x49, 0x49, 0x36}, // 8
		                          {0x26, 0x49, 0x49, 0x49, 0x3E}, // 9
		                          {0x00, 0x36, 0x36, 0x00, 0x00}, // :
		                          {0x00, 0x56, 0x36, 0x00, 0x00}, // ;
		                          {0x08, 0x14, 0x22, 0x41, 0x00}, // <
		                          {0x14, 0x14, 0x14, 0x14, 0x14}, // =
		                          {0x00, 0x41, 0x22, 0x14, 0x08}, // >
		                          {0x02, 0x01, 0x51, 0x09, 0x06}, // ?
		                          {0x3E, 0x41, 0x59, 0x55, 0x5E}, // @
		                          {0x7E, 0x09, 0x09, 0x09, 0x7E}, // A
		                          {0x7F, 0x49, 0x49, 0x49, 0x36}, // B
		                          {0x3E, 0x41, 0x41, 0x41, 0x22}, // C
		                          {0x7F, 0x41, 0x41, 0x41, 0x3E}, // D
		                          {0x7F, 0x49, 0x49, 0x49, 0x41}, // E
		                          {0x7F, 0x09, 0x09, 0x09, 0x01}, // F
		                          {0x3E, 0x41, 0x41, 0x49, 0x3A}, // G
		                          {0x7F, 0x08, 0x08, 0x08, 0x7F}, // H
		                          {0x00, 0x41, 0x7F, 0x41, 0x00}, // I
		                          {0x30, 0x40, 0x40, 0x40, 0x3F}, // J
		                          {0x7F, 0x08, 0x14, 0x22, 0x41}, // K
		                          {0x7F, 0x40, 0x40, 0x40, 0x40}, // L
		                          {0x7F, 0x02, 0x0C, 0x02, 0x7F}, // M
		                          {0x7F, 0x02, 0x04, 0x08, 0x7F}, // N
		                          {0x3E, 0x41, 0x41, 0x41, 0x3E}, // O
		                          {0x7F, 0x09, 0x09, 0x09, 0x06}, // P
		                          {0x1E, 0x21, 0x21, 0x21, 0x5E}, // Q
		                          {0x7F, 0x09, 0x09, 0x09, 0x76}}; // R



const unsigned char TEXT2[44][5]={{0x26, 0x49, 0x49, 0x49, 0x32}, // S
		                          {0x01, 0x01, 0x7F, 0x01, 0x01}, // T
		                          {0x3F, 0x40, 0x40, 0x40, 0x3F}, // U
		                          {0x1F, 0x20, 0x40, 0x20, 0x1F}, // V
		                          {0x7F, 0x20, 0x10, 0x20, 0x7F}, // W
		                          {0x41, 0x22, 0x1C, 0x22, 0x41}, // X
		                          {0x07, 0x08, 0x70, 0x08, 0x07}, // Y
		                          {0x61, 0x51, 0x49, 0x45, 0x43}, // Z
		                          {0x00, 0x7F, 0x41, 0x00, 0x00}, // [
		                          {0x02, 0x04, 0x08, 0x10, 0x20}, // \'
		                          {0x00, 0x00, 0x41, 0x7F, 0x00}, // ]
		                          {0x04, 0x02, 0x01, 0x02, 0x04}, // ^
		                          {0x40, 0x40, 0x40, 0x40, 0x40}, // _
		                          {0x00, 0x01, 0x02, 0x04, 0x00}, // `
		                          {0x20, 0x54, 0x54, 0x54, 0x78}, // a
		                          {0x7F, 0x44, 0x44, 0x44, 0x38}, // b
		                          {0x38, 0x44, 0x44, 0x44, 0x44}, // c
		                          {0x38, 0x44, 0x44, 0x44, 0x7F}, // d
		                          {0x38, 0x54, 0x54, 0x54, 0x18}, // e
		                          {0x04, 0x04, 0x7E, 0x05, 0x05}, // f
		                          {0x08, 0x54, 0x54, 0x54, 0x3C}, // g
		                          {0x7F, 0x08, 0x04, 0x04, 0x78}, // h
		                          {0x00, 0x44, 0x7D, 0x40, 0x00}, // i
		                          {0x20, 0x40, 0x44, 0x3D, 0x00}, // j
		                          {0x7F, 0x10, 0x28, 0x44, 0x00}, // k
		                          {0x00, 0x41, 0x7F, 0x40, 0x00}, // l
		                          {0x7C, 0x04, 0x78, 0x04, 0x78}, // m
		                          {0x7C, 0x08, 0x04, 0x04, 0x78}, // n
		                          {0x38, 0x44, 0x44, 0x44, 0x38}, // o
		                          {0x7C, 0x14, 0x14, 0x14, 0x08}, // p
		                          {0x08, 0x14, 0x14, 0x14, 0x7C}, // q
		                          {0x00, 0x7C, 0x08, 0x04, 0x04}, // r
		                          {0x48, 0x54, 0x54, 0x54, 0x20}, // s
		                          {0x04, 0x04, 0x3F, 0x44, 0x44}, // t
		                          {0x3C, 0x40, 0x40, 0x20, 0x7C}, // u
		                          {0x1C, 0x20, 0x40, 0x20, 0x1C}, // v
		                          {0x3C, 0x40, 0x30, 0x40, 0x3C}, // w
		                          {0x44, 0x28, 0x10, 0x28, 0x44}, // x
		                          {0x0C, 0x50, 0x50, 0x50, 0x3C}, // y
		                          {0x44, 0x64, 0x54, 0x4C, 0x44}, // z
		                          {0x00, 0x08, 0x36, 0x41, 0x41}, // {
		                          {0x00, 0x00, 0x7F, 0x00, 0x00}, // |
		                          {0x41, 0x41, 0x36, 0x08, 0x00}, // }
		                          {0x02, 0x01, 0x02, 0x04, 0x02}};// ~


void delay(void)
{
	unsigned long j=20;  // delay
    while(j--);
}


void DATA_OUT(unsigned char x)
{
	GPIO_Write(GLCD_DATA_PORT,x);
	delay();
}
unsigned char DATA_READ(void)
{
	unsigned char temp=0;

	temp=GPIO_ReadInputData(GLCD_DATA_PORT);

	return temp;
}
void ks0108_init(void)
{
	
	
 	delay();
	RST(1);
	delay();
	EN(0);
	delay();
	CS1(0);
	CS2(0);
	DI(0);						//Komut verilecek
	ks0108_write(sag, 0xC0);	//En üst RAM'in ilk RAM oldugu belirleniyor
	ks0108_write(sol, 0xC0);	
	ks0108_write(sag, 0x40);	//Sütunun en basina gidiliyor, Y=0	
	ks0108_write(sol, 0x40);	
	ks0108_write(sag, 0xB8);	//Satirin en basina gidiliyor, X=0
	ks0108_write(sol, 0xB8);
	ks0108_write(sag, EKRANAC);	//Ekrani aç
	ks0108_write(sol, EKRANAC);
}

void ks0108_write(unsigned char chip, unsigned char veri)
{
	delay();
	if(chip)
	{
		CS1(0);
		CS2(1);
	}
	else
	{
		CS1(1);
		CS2(0);
	}

	delay();
	RW(0);			// Veri yazma moduna alindi
	delay();
	DATA_OUT(veri);
	EN(1);			// Düsen kenar tetiklemeli
	delay();
	EN(0);
	CS1(0);			// Chip seçim alanlari temizleniyor
	CS2(0);
}

unsigned char ks0108_read(unsigned char chip)
{
	unsigned char veri;
    GPIO_InitTypeDef GPIO_InitStructure;

  	GPIO_InitStructure.GPIO_Pin = 0xFFFF; // DATA port in yapiliyor
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  	GPIO_Init(GLCD_DATA_PORT, &GPIO_InitStructure);

	RW(1);
	if(chip)
	{
		CS1(0);
		CS2(1);
	}
	else
	{
		CS1(1);
		CS2(0);
	}
	delay();
	EN(1);
	delay();
	veri=DATA_READ();
	delay();
	EN(0);
	delay();

  	GPIO_InitStructure.GPIO_Pin = 0xFFFF; // DATA port out yapiliyor
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  	GPIO_Init(GLCD_DATA_PORT, &GPIO_InitStructure);

 	CS1(0);
	CS2(0);
	return veri;
}

void ks0108_write_byte(unsigned char x, unsigned char y, unsigned char veri)
{
	unsigned char chip=sol;

	if(x>63)
	{
		x=x-64;
		chip=sag;
	}

	DI(0);
	x=x&0x7F;
	x=x|0x40;
	ks0108_write(chip,x);
	ks0108_write(chip,(y/8 & 0xBF) | 0xB8);
	DI(1);

	DI(0);
	ks0108_write(chip,x);
	DI(1);
	ks0108_write(chip,veri);
}

void ks0108_pixel(unsigned char x, unsigned char y, unsigned char renk)
{
	unsigned char veri, kay=1;
	unsigned char chip=sol;

	if(x>63)
	{
		x=x-64;
		chip=sag;
	}

	DI(0);
	x=x&0x7F;
	x=x|0x40;
	ks0108_write(chip,x);
	ks0108_write(chip,(y/8 & 0xBF) | 0xB8);
	DI(1);
	ks0108_read(chip);
	veri=ks0108_read(chip);

	if(renk)
		veri=veri | kay<<y%8;
	else
		veri=veri & (~(kay<<y%8));

	DI(0);
	ks0108_write(chip,x);
	DI(1);
	ks0108_write(chip,veri);
}

void ks0108_fill(unsigned char renk)
{
	unsigned char i,j;

	for(i=0;i<8;i++)
	{
		DI(0);
		ks0108_write(sol,0x40);
		ks0108_write(sag,0x40);
		ks0108_write(sol,i | 0xB8);
		ks0108_write(sag,i | 0xB8);
		DI(1);
		for(j=0;j<64;j++)
		{		//delay();
			if(renk)
			{
				ks0108_write(sag, 0xFF);
				ks0108_write(sol, 0xFF);
			}
			else
			{
				ks0108_write(sag, 0x00);
				ks0108_write(sol, 0x00);
			}
		}
	}
}

void ks0108_line(unsigned char x1,unsigned char y1,unsigned char x2,unsigned char y2, unsigned char renk)
{
	int addx=1, addy=1, P;
	unsigned char i, dy, dx, diff;

	if(x2>x1)
		dx = x2 - x1;
	else
	{
		dx = x1 - x2;
		addx = -1;
	}
	if(y2>y1)
		dy = y2 - y1;
	else
	{
		dy = y1 - y2;
		addy = -1;
	}

	if(dx >= dy)
	{
		dy *= 2;
		P = dy - dx;
		diff = P - dx;

		for(i=0; i<=dx; ++i)
		{
			ks0108_pixel(x1, y1, renk);

			if(P < 0)
			{
				P  += dy;
				x1 += addx;
			}
			else
			{
				P  += diff;
				x1 += addx;
				y1 += addy;
			}
		}
	}
	else
	{
		dx *= 2;
		P = dx - dy;
		diff = P - dy;

		for(i=0; i<=dy; ++i)
		{
			ks0108_pixel(x1, y1, renk);

			if(P < 0)
			{
				P  += dx;
				y1 += addy;
			}
			else
			{
				P  += diff;
				x1 += addx;
				y1 += addy;
			}
		}
	}
}

void ks0108_bar(unsigned char amp, unsigned char n,unsigned char ustsinir,unsigned char altsinir)
{
	signed char i;
	unsigned char tempdata;
	unsigned char chip = 0;
	tempdata=amp;
	if(n > 63)
	{
		n -= 64;
		chip = 1;
	}

	for(i=ustsinir;i>=altsinir;--i)
	{
		DI(0)
		ks0108_write(chip,(0x40|n));
		ks0108_write(chip,(0xB8|i));
		DI(1)
		if(tempdata==0x00)
		{
			ks0108_write(chip,0x00);
		}
		else if(tempdata>7)
		{
			ks0108_write(chip,0xFF);
			tempdata-=8;
		}
		else
		{
			switch(tempdata)
			{
			case 1:tempdata=0x80;break;
			case 2:tempdata=0xC0;break;
			case 3:tempdata=0xE0;break;
			case 4:tempdata=0xF0;break;
			case 5:tempdata=0xF8;break;
			case 6:tempdata=0xFC;break;
			case 7:tempdata=0xFE;break;
			}
			ks0108_write(chip,tempdata);
			tempdata=0x00;
		}
	}
}

void ks0108_rect(unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, unsigned char dolu, unsigned char renk)
{
	if(dolu)
	{
		unsigned char  i, xmin, xmax, ymin, ymax;

		if(x1 < x2)
		{
			xmin = x1;
			xmax = x2;
		}
		else
		{
			xmin = x2;
			xmax = x1;
		}

		if(y1 < y2)
		{
			ymin = y1;
			ymax = y2;
		}
		else
		{
			ymin = y2;
			ymax = y1;
		}

		for(; xmin <= xmax; ++xmin)
		{
			for(i=ymin; i<=ymax; ++i)
			{
				ks0108_pixel(xmin, i, renk);
			}
		}
	}
	else
	{
		ks0108_line(x1, y1, x2, y1, renk);
		ks0108_line(x1, y2, x2, y2, renk);
		ks0108_line(x1, y1, x1, y2, renk);
		ks0108_line(x2, y1, x2, y2, renk);
	}
}

void ks0108_circle(unsigned char x,unsigned char y, unsigned char r, unsigned char dolu, unsigned char renk)
{
	unsigned char a,b;
	int P;
	a=0;
	b=r;
	P=1-r;

	do
	{
		if(dolu)
		{
			ks0108_line(x-a, y+b, x+a, y+b, renk);
			ks0108_line(x-a, y-b, x+a, y-b, renk);
			ks0108_line(x-b, y+a, x+b, y+a, renk);
			ks0108_line(x-b, y-a, x+b, y-a, renk);
		}
		else
		{
			ks0108_pixel(a+x, b+y, renk);
			ks0108_pixel(b+x, a+y, renk);
			ks0108_pixel(x-a, b+y, renk);
			ks0108_pixel(x-b, a+y, renk);
			ks0108_pixel(b+x, y-a, renk);
			ks0108_pixel(a+x, y-b, renk);
			ks0108_pixel(x-a, y-b, renk);
			ks0108_pixel(x-b, y-a, renk);
		}

		if(P < 0)
			P+= 3 + 2 * a++;
		else
			P+= 5 + 2 * (a++ - b--);
	}while(a <= b);
}
 char *textptr2="";

void ks0108_text(unsigned char x, unsigned char y,  char *textptr, unsigned char size,unsigned char color)
{
	unsigned char i, j, k, l, m;
	unsigned char pixelData[5];
	unsigned char test=0;
//	unsigned int g=0;

	int nx=0;

//ks0108_rect(x,y,x+new_size*6,y+8,1,0);

	for(i=0; textptr[i] != '\0'; ++i, ++x)
	{

	  for(;;){

		  if((textptr[i]==0x0D)&(textptr[i+1]==0x0A))
		  {
			x = 0;
			y += 7*size + 3;
		 	i=i+2;

		  }else break;

		}

		if(textptr[i] == '\0')break;

		if(textptr[i] < 'S')
			memcpy(pixelData, TEXT[textptr[i]-' '], 5);
		else if(textptr[i] <= '~')
			memcpy(pixelData, TEXT2[textptr[i]-'S'], 5);
		else
			memcpy(pixelData, TEXT[0], 5);


		if(x+5*size >= GLCD_WIDTH)
		{

			x = 0;
			y += 7*size + 3;
		}



		for(j=0; j<5; ++j, x+=size)
		{
		for(nx=y;nx<y+8;nx++)
			ks0108_pixel(x,nx,0);

//		ks0108_write_byte(x, y, 0x00);
			for(k=0; k<7*size; ++k)
			{

				test=pixelData[j]&(0x01<<k);
				if(test)
				{
					for(l=0; l<size; ++l)
					{

						for(m=0; m<size; ++m)
						{
							ks0108_pixel(x+m, y+k*size+l, color);
						}
					}
				}
			}
		}
	}
}

[muhittin_kaplan]

diğer kütüphane ile belli bir yere img basmayı denedim oldu. muhtemelen böyle yapacağım.

[Mucit23]

Bence Çabuk pes etmeyin elimde ST link Olsa Yarın deneyip çalıştıracam kodu Kafam bozuldu valla..  Dediğiniz yöntem mantıksız geliyor bana

[muhittin_kaplan]

aslında aynı yöntem mucit. Font array dan alır gibi alıp belli yere basacağım. acelem yok ama yarın büyük halde göstermem gerekiyor. (ilginç bir cümle oldu). sonrasında ele alır çözeriz kısmet oluyrsa. önce yarrını bir atlatmam gerek

[Mucit23]

Tamam hocam Kolay Gelsin

[demket]

S.A. Winstar ın ssd1963 kullanan WF43BTIBED0# tft si mevcut. Bu tft yi stm32f4 discovery ile sürmek istiyorum. Sitedeki örnekleri inceledim. DC isimli bir pin tanımlanıyor fakat tft nini Datasheet inde bu isimde bir pin yok. Keil için discovery ile ssd1963 örneği verebilecek olan varsa  bizi çok mutlu eder.

[Burak B]

DC = RS = A0

[camby]

DC = RS = A0

Hocam A0 ne oluyor , nereden geliyor ?

[demket]

S.A., stm32f10x işlemcili kitime TFT LCD bağladım. "ssd1963.h" dosyamda pin konfigürasyonu aşağıdaki gibidir. Şöyle bir derdim var. Normal şartlarda elimdeki kitin 3v3 vermesi gerekirken, lcd bağlantılarını yaptıktan sonra 2v6 ya düşmektedir. Bu arada LCD 285 mA çekmektedir. Hal böyle olunca Stm32f4 Discovery kiti inceledim. 3v çıkış pini hiç bir bağlantı yapmama rağmen (sadece kiti test ediyorum) 2v7 ölçmekteyim. Kitler USB üzerinden besleniyor. Başka bir bilgisayarda da denedim.

Doğal olarak TFT çalışmamakta(min 3v gerekli). Bilmem gereken eksik ne var? Neden gerilim düşümleri yaşanıyor olabilir?

//=============================================================================
// Configuration
//=============================================================================
#define SSD1963_DATAPORT	GPIOB
#define SSD1963_CTRLPORT	GPIOA

#define SSD1963_PIN_RD	(1 << 0)    //lcd pin6    RD
#define SSD1963_PIN_WR	(1 << 1)    //lcd pin5    WR
#define SSD1963_PIN_CS	(1 << 2)    //lcd pin15  CS
#define SSD1963_PIN_A0	(1 << 3)    //lcd pin4    RS
#define SSD1963_PIN_RST	(1 << 8)    //lcd pin16  RES

#define TFT320240
//#define TFT800480
//#define TFT640480
//#define TFTCUSTOM