P10 Panel Kullanımı(Algooritma)

[Mucit23]

Bir Sorum Olacak,

Satır kaydırma fonksiyonunu tümüyle değiştirdim

/*******************************************************************************
*   Satir Kaydirma Fonksiyonu                                                  *
*   Parameter:    Line, clstart, clend, ZeroBit                                *
*   Return:       OwerFlow                                                     *
*   Not: Bu Fonksiyon belirtilen satirin clstart ve clend parameteleri         *
*        ile verilen araliktaki ledleri bir bit sola kaydirir.                 *
*******************************************************************************/
BOOL LineScroll(uint8_t Line, uint8_t clstart, uint8_t clend, BOOL ZeroBit){
	int i=0;
  uint8_t y1=Line%4;
  uint8_t y2=(Line/4)*8;
  BOOL OwerFlow=0;
	BOOL Carry=0;
  ZeroBit=1-ZeroBit;
  
  OwerFlow=(display_ram[((y2)+clstart)][y1]/128)&0x01; // Sol Taraftan Tasan bit aliniyor
	   
	for(i=clstart;i<clend+1;i++) 
	{
     display_ram[((y2)+i)][y1] = display_ram[((y2)+i)][y1]<<1;                    //1 Bit Sola kaydir
		 if(i<7)
		 {
	  	 Carry=(display_ram[((y2)+(i+1))][y1]/128)&0x01;   //Bir Sonraki Byte'in Tasan Bitini Carry'e yerlestir.
		   display_ram[((y2)+i)][y1]=(uint8_t)display_ram[((y2)+i)][y1] | Carry;    //Carry'yi Bir Önceki Byte'in 0. bitine yerlestir Yerlestir
		 }
  }
	if(ZeroBit){         //Sag Taraftan Fonksiyona gönderilen bit ekleniyor..
    display_ram[((y2)+clend)][y1]=(uint8_t)display_ram[((y2)+clend)][y1] | 0x01; 
  }else{
    display_ram[((y2)+clend)][y1]=(uint8_t)display_ram[((y2)+clend)][y1] & 0xFE; 
  }
  return OwerFlow;      //Soldan Tasan Biti Geri gönder
}

Önceden yan yana bulunan 4 byte değişkeni birleştirip tek bir 32 bitlik değişken haline getiriyordum. Ardından bir bir sola kaydırıp tekrar 4 byte parçalıyordum.

Şimdi Yaptığım sistem biraz farklı çalışıyor. Her byte ı ayrı ayrı kaydırıp sağdaki byte dan taşan biti alıp soldakine veriyorum.

Kodlar çalışıyor fakat ufak bir problem var..

Örnekle açıklayayım

aşağıdaki kodda display_ram isimli dizinin ilgili byte'ını bir bit sola kaydırmışım.

display_ram[((y2)+i)][y1] = display_ram[((y2)+i)][y1]<<1;

Ardından kaydırılacak olan bir sonraki byte'ın 7. bitini alıp, bir önceki byte ın 0. bitine eklemek gerekiyor. Bunuda burada yapıyorum.

Carry=(display_ram[((y2)+(i+1))][y1]/128)&0x01; 
display_ram[((y2)+i)][y1]=(uint8_t)display_ram[((y2)+i)][y1] | Carry;   

Bundan sonra en son kaydırdığımız elemanın 0. bitine fonksiyona gönderilen bit ekleniyor. Oda burada yapılıyor.

if(ZeroBit){                                                                    //Sag Taraftan Fonksiyona gönderilen bit ekleniyor..
    display_ram[((y2)+clend)][y1]=(uint8_t)display_ram[((y2)+clend)][y1] | 0x01; 
  }else{
    display_ram[((y2)+clend)][y1]=(uint8_t)display_ram[((y2)+clend)][y1] & 0xFE; 
  }

P10 Paneli sürerken display_ram isimli dizi ekranın ram alanını temsil ediyor ve kesme ile sürekli ekrana yani ledlere yansıtılıyor. Bu P10panel üzerindeki ledler ise ortak anot olarak bağlı Yani 74595 lerin çıkışı lojik 0 olduğu zaman led yanıyor.

Sıkıntı şudur.

Biz örneğin display_ram isimli dizinin herhangi bir elemanını bir bit sola kaydırdığım zaman sağ taraftan 0 ekleniyordu. Eğer tam bu sırada sola kaydırdığım eleman alınıp ekrana gönderilirse sağ taraftan eklenen sıfır o bite denk gelen ledin yanmasına sebeb oluyor. Bu satır kaydırma fonksiyonunda hemen düzeltiliyor ama 800us aralıklarla kesme oluştuğu için aynı elemanın  güncellenmesi 2.4ms sürüyor. Dolayısıyla o yanık kalan led 2.4 ms süreyle yanık kalmış oluyor. Göze çok çarpıyor. 

Bu şekilde kurduğum mantık öncekine göre çok hızlı çalışıyor fakat bahsettiğim sorun yaşanıyor.

Bu dediğim sorunu nasıl önleyebilirim. Aklıma birşey gelmiyor

[Mucit23]

Kimsenin fikri yokmu?

[kantirici]

Fonksiyon işini yapana kadar ekran güncellenmesin .

[Mucit23]

Aslında tarama işlemine karışmak istemiyorum. O kısım kendi başında iyi çalışıyor. Kapatıp açarak düzenini bozmayalım. Benim aklıma şöyle bir fikir geliyor

Her 4 kez kesme oluştuğunda ekrandaki bir byte lık alan güncelleniyor. Diğer 3 kesmede başka bölgeler güncelleniyor. Bende kesme sırasını takip edip her seferinde ekrana gönderilmeyen bölgeler üzerinde kaydırma yapayım diyorum. Nasıl yaparım bilmiyorum ama bi bakayım. Başka fikri olan varmı?

[Mucit23]

Akşam Akşam Esti yine Ufak birşeyler yapayım dedim.
STM32F103 ile P10 Panelde Bargraph Testi, Random sayılar basılıyor. Spectrum Analyser lere benzedi.

P10 Panel Test

[OG]

Güzel olmuş. Zaten bu panellerle standart işler yaparak para kazanma devri gecti, specific birşeyler yapmak gerek.

[Mucit23]

Güzel olmuş. Zaten bu panellerle standart işler yaparak para kazanma devri gecti, specific birşeyler yapmak gerek.

Aynen öyle hocam. Panellerin kullanımı çok esnek. Güzel çözümler getiriyor.

[gilamada]

s.a. merhabalar. mucit hocam üzerinden 1 sene geçmiş ama stm ile yaptığınız uygulamanın dosya paylaşımı var mı aceba? teşekkürler.

[M_B]

@Mucit23 Hocam;

Stm icin duzenlemiş olduğunuz kodu paylaşabilirmisiniz.  Once Tek renkle test edip sonra dual renk icin duzenleyecem. ( picle RG icin duzenlemiştim )

Stm deki bilgilerimi unutmusum yeninden çalışmaya başladım. Timer  vb..  arabirimlere yeniden göz atacam.

[Mucit23]

Hocam vereyim ama main kodlarını bulamadım. STM32 için aşağıdaki iki dosyayı düzenlemiştim. Timer rutinleri main.c dosyasında olacaktı. main dosyasını almamışım. Timer rutinlerini ve SPI rutinlerini yeniden yazmalısınız.

Font dataları da const unsigned char tipinde olacak.

P10_Panel_Driver.c

#include "stm32f10x.h"
#include "P10_Panel_Driver.h"
#include "SPI.h"
#include "PWM.h"
#include "systick.h"
#include "Font1.h"
#include "Font2.h"
#include "Font3.h"
#include "Font4.h"

uint8_t display_ram[32][4];
unsigned char Text[50];


void P10_Panel_Init(){
   GPIO_InitTypeDef GPIO_InitStructure;
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   /* Configure P10_Panel pins: A, B, OE and LATCH */
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
	
   SPI1_Init();
   PWM_init();
	
}

void Write_Data(int row_adr){
   uint8_t i=0,j=0;
   uint8_t k=7,z=0;
   while(k!=255)                                   // Bu Döngü ileriye dogru sayarsa panel sagdan 
   {j=31-k;                                        // Sola Dogru yüklenir. 
     for (i=0;i<4;i++)                             // Satirlar dolduruluyor..
     {
			 SPI1_WriteByte(display_ram[j][row_adr]);
			 z=2;while(z!=0){z--;}
       j-=8;
     }
     k--;
   }
   Set_LATCH;
	 i=50;while(i!=0){i--;}
   Clr_LATCH;
}

void Panel_Test(void){
	int x=0;
	for(x=0;x<16;x++)
	{
	    LineScroll(x,0,6,0);
  }
}

/***********************Türkçe KArakterler burada ayrilir**********************/
int CharAdres(char c){
  int adr=0;
  switch(c)
  {
  case 'Ü':adr=96;break;
  case 'Ö':adr=97;break;
  case 'S':adr=98;break;
  default:
    adr=c-32;
  break;
  }
  return adr;
}
/*******************************************************************************
*   Satir Kaydirma Fonksiyonu                                                  *
*   Parameter:    Line, clstart, clend, ZeroBit                                *
*   Return:       OwerFlow                                                     *
*   Not: Bu Fonksiyon belirtilen satirin clstart ve clend parameteleri         *
*        ile verilen araliktaki ledleri bir bit sola kaydirir.                 *
*******************************************************************************/
BOOL LineScroll(uint8_t Line, uint8_t clstart, uint8_t clend, BOOL ZeroBit){
	int i=0;
  uint8_t y1=Line%4;
  uint8_t y2=(Line/4)*8;
  BOOL OwerFlow=0;
	BOOL Carry=0;
  ZeroBit=1-ZeroBit;
  
  OwerFlow=(display_ram[((y2)+clstart)][y1]/128)&0x01; // Sol Taraftan Tasan bit aliniyor
	   
	for(i=clstart;i<clend+1;i++) 
	{
		 if(i<7)
		 {
	  	 Carry=(display_ram[((y2)+(i+1))][y1]/128)&0x01;                            //Bir Sonraki Byte'in Tasan Bitini Carry'e yerlestir.
			 display_ram[((y2)+i)][y1] = display_ram[((y2)+i)][y1]<<1;                  //1 Bit Sola kaydir
		   display_ram[((y2)+i)][y1]=(uint8_t)display_ram[((y2)+i)][y1] | Carry;      //Carry'yi Bir Önceki Byte'in 0. bitine yerlestir Yerlestir
		 }
		 else
		 {
			 display_ram[((y2)+i)][y1] = display_ram[((y2)+i)][y1]<<1;                  //1 Bit Sola kaydir
     }
  }
	if(ZeroBit){                                                                    //Sag Taraftan Fonksiyona gönderilen bit ekleniyor..
    display_ram[((y2)+clend)][y1]=(uint8_t)display_ram[((y2)+clend)][y1] | 0x01; 
  }else{
    display_ram[((y2)+clend)][y1]=(uint8_t)display_ram[((y2)+clend)][y1] & 0xFE; 
  }
  return OwerFlow;                                                                //Soldan Tasan Biti Geri gönder
}

/*******************************************************************************
*   Ekran Temizleme Fonksiyonu                                                 *
*   Parameter:    fill                                                         *
*   Return:                                                                    *
*******************************************************************************/
void Clear_Display(BOOL fill){
uint8_t i=0,j=0,fdata=0;
if (fill){
  fdata=0x00;
}else{
  fdata=0xFF;
}
  for (i=0;i<4;i++)
  {
    for (j=0;j<32;j++)
    {
      display_ram[j][i]=fdata;
    }
  }
}
/*******************************************************************************
*   Ekran Tersleme Fonksiyonu                                                  *
*   Parameter:                                                                 *
*   Return:                                                                    *
*******************************************************************************/
void invert_screen(void){
 uint8_t i=0,j=0;
 
 for(i=0;i<4;i++)
 {
   for(j=0;j<32;j++)
   {
     display_ram[j][i] =~ display_ram[j][i];  //Önbellekteki deger degillenip geri yaziliyor      
   }
 }
}

/*******************************************************************************
*   Pixel Fonksiyonu                                                           *
*   Parameter:    Xpos, Ypos, fill                                             *
*   Return:                                                                    *
*******************************************************************************/
void PutPixel(uint8_t Xpos,uint8_t Ypos, BOOL fill)
{
  uint8_t y1=0,x1=0;
  uint8_t y2=0,x2=0;
  uint8_t temp=0;
           
  y1 = Ypos%4;
  y2 = Ypos/4;
  x1 = Xpos%8;   
  x2 = Xpos/8;
  
  if(fill)  //Nokta Koy
  {
    temp=display_ram[(y2*8)+x2][y1]; //Ram'deki deger ön bellege aliniyor.
    display_ram[(y2*8)+x2][y1] = (temp & (255-(128>>x1))); //x'inci bit 0 yapilir
  }
  else     //Noktayi Sil
  {
    temp=display_ram[(y2*8)+x2][y1]; //Ram'deki deger ön bellege aliniyor.
    display_ram[(y2*8)+x2][y1] = (temp | (128>>x1)); //x'inci Bit 1 yapilir    
  }
}

/*******************************************************************************
*   Pixel Okuma Fonksiyonu                                                     *
*   Parameter:    Xpos, Ypos                                                   *
*   Return: value                                                              *
*******************************************************************************/
BOOL GetPixel(uint8_t Xpos, uint8_t Ypos){
  uint8_t y1=0,x1=0;
  uint8_t y2=0,x2=0;
  uint8_t temp=0;
  BOOL value=0;
  
  y1 = Ypos%4;
  y2 = Ypos/4;
  x1 = Xpos%8;    
  x2 = Xpos/8;
  
  temp=display_ram[(y2*8)+x2][y1]; //Ram'deki deger ön bellege aliniyor.
  value=1-(0x80 & temp<<x1)/128;   //Ram adresindeki bit geri gönderiliyor
  return value;
}

/*******************************************************************************
*   Çizgi Çizme Fonksiyonu                                                     *
*   Parameter:    x1, x2, y1, y2, fill                                         *
*   Return:                                                                    *
*******************************************************************************/
void Line(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, BOOL fill)
{
  signed int addx=1, addy=1, P;
  signed int 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++)
      {
         PutPixel(x1, y1, fill);

         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)
      {
         PutPixel(x1, y1, fill);

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

/*******************************************************************************
*   Dikdörtgen Çizme Fonksiyonu                                                *
*   Parameter:    x1, x2, y1, y2, fill                                         *
*   Return:                                                                    *
*******************************************************************************/
void Rectangle(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, BOOL fill)
{
   uint16_t i, xmin, xmax, ymin, ymax;

  if(fill)
   {
      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)
         {
            PutPixel(xmin, i, 1);
         }
      }
   }
   else
   {
      Line(x1, y1, x2, y1, 1);
      Line(x2, y1, x2, y2, 1);
      Line(x2, y2, x1, y2, 1);
      Line(x1, y2, x1, y1, 1);
   }      
}

/*******************************************************************************
*   Çember Cizme Fonksiyonu                                                    *
*   Parameter:    x, y, Size, fill                                             *
*   Return:                                                                    *
*******************************************************************************/
void Circle(uint8_t x, uint8_t y, uint8_t size, BOOL fill)
{
   signed int a,b,P;
   a=0;
   b=size;
   P=1-size;
   
   do
   {
      if(fill)
      {
         Line(x-a, y+b, x+a, y+b,1);
         Line(x-a, y-b, x+a, y-b,1);
         Line(x-b, y+a, x+b, y+a,1);
         Line(x-b, y-a, x+b, y-a,1);
      }
      else
      {
         PutPixel(a+x, b+y,1);
         PutPixel(b+x, a+y,1);
         PutPixel(x-a, b+y,1);
         PutPixel(x-b, a+y,1);
         PutPixel(b+x, y-a,1);
         PutPixel(a+x, y-b,1);
         PutPixel(x-a, y-b,1);
         PutPixel(x-b, y-a,1);
      }
      
      if(P < 0)
      P+= 3 + 2*a++;
    else
      P+= 5 + 2*(a++ - b--);
     
  }while(a<=b);

}

/*******************************************************************************
*   Bargraph Çizme Fonksiyonu                                                  *
*   Parameter:    x1, y1, x2, y2, Mode, Value                                  *
*   Return:                                                                    *
*******************************************************************************/
void Bargraph (uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, BOOL hor, uint8_t value)
{
  uint8_t w=0;    
  uint8_t h=0;
  uint8_t a=0,b=0;
  uint16_t barval=0;
  
  if(x1>x2) w=x1-x2;
  if(x1<x2) w=x2-x1;  
  if(y1>y2) h=y1-y2; 
  if(y1<y2) h=y2-y1;
  
  if(value>100)value=100;
  
  if(hor) //Bar Dikey Olarak Olusturulacak
  {
    barval=((int16_t)value*h)/100;
  
    for (a=0;a<h+1;a++)
    {
      for(b=0;b<w+1;b++)
      {
        if(barval>=a){
           PutPixel(x1+b,15-a+y1,1);
        }else{
           PutPixel(x1+b,15-a+y1,0);
        }
      }
    }
    
  }else{  //Bar Yatay olarak Olusturulacak
  
    barval=((int16_t)value*w)/100;
    
    for (a=0;a<w+1;a++)
    {
      for(b=0;b<h+1;b++)
      {
        if(barval>=a)
        {
          PutPixel(x1+a,y1+b,1);
        }else{
          PutPixel(x1+a,y1+b,0);
        }
      }
    }
  }
}
/*******************************************************************************
*   Karakter Basma Fonksiyonu  Font1                                           *
*   Parameter:    x, y, char, Fill                                             *
*   Return:                                                                    *
*******************************************************************************/
void DrawCharFont1(unsigned int x, unsigned int y, unsigned char c, BOOL fill){
unsigned int a=0,b=0;
unsigned int cdata=0;

      for(b=0;b<5;b++)
      {
         cdata=Font_5x7[c-32][b];
         for(a=0;a<8;a++)
         {
            PutPixel(x+b,y+a,(fill-(cdata>>a) & 0x01));
         }
      }
     
}
/*******************************************************************************
*   Karakter Basma Fonksiyonu  Font2                                           *
*   Parameter:    x, y, char, Fill                                             *
*   Return:                                                                    *
*******************************************************************************/
void DrawCharFont2(unsigned int x, unsigned int y, unsigned char c, BOOL fill){
unsigned int a=0,b=0;
unsigned int cdata=0;
      
       for(b=0;b<16;b=b+2)
       {
         cdata=Font_8x12[c-32][b];
         for(a=0;a<8;a++)
         {
           PutPixel(x+(b/2),y+a,(fill-(cdata>>a) & 0x01));
         }
         cdata=Font_8x12[c-32][b+1];
         for(a=0;a<4;a++)
         {
           PutPixel(x+(b/2),y+8+a,(fill-(cdata>>a) & 0x01));
         }
       }
}
/*******************************************************************************
*   Karakter Basma Fonksiyonu  Font3                                           *
*   Parameter:    x, y, char,  Fill                                            *
*   Return:                                                                    *
*******************************************************************************/
void DrawCharFont3(unsigned int x, unsigned int y, unsigned char c, BOOL fill){
unsigned int a=0,b=0;
unsigned int cdata=0;

       for(b=0;b<24;b=b+2)
       {
         cdata=Font_12x14[c-32][b];
         for(a=0;a<8;a++)
         {
           PutPixel(x+(b/2),y+a,(fill-(cdata>>a) & 0x01));
         }
         cdata=Font_12x14[c-32][b+1];
         for(a=0;a<6;a++)
         {
           PutPixel(x+(b/2),y+8+a,(fill-(cdata>>a) & 0x01));
         }
       }  
}

/*******************************************************************************
*   Text Basma Fonksiyonu  Font4                                               *
*   Parameter:    x, y, char, Fill                                             *
*   Return:                                                                    *
*******************************************************************************/
void DrawCharFont4(unsigned int x, unsigned int y, unsigned char c, BOOL fill){
unsigned int a=0,b=0;
unsigned int cdata=0;
unsigned int cadr=0;

       cadr=CharAdres(c);  //Türkçe Karakterler Belirleniyor.
      
       for(b=0;b<24;b=b+2)
       {
         cdata=Font_12x16[cadr][b];
         for(a=0;a<8;a++)
         {
           PutPixel(x+(b/2),y+a,(fill-(cdata>>a) & 0x01));
         }
         cdata=Font_12x16[cadr][b+1];
         for(a=0;a<8;a++)
         {
           PutPixel(x+(b/2),y+8+a,(fill-(cdata>>a) & 0x01));
         }
       }
}
/*******************************************************************************
*   Text Basma Fonksiyonu                                                      *
*   Parameter:    x, y, size, fill                                             *
*   Return:                                                                    *
*******************************************************************************/
void ShowString(uint8_t x, uint8_t y, uint8_t size, BOOL fill, unsigned char *s){
	unsigned int clm=x,row=y;
	BOOL exit=0;
  while(*s!='\0')
  {
    switch(size)
    {
      case 1:                 //1. Font Secili ise
				if(clm+5>WIDTH)      //Satir sonuna gelindimi Bir Alt Satira Geç
        { 
          clm=0;         
          row=row+8;
          if(row+8>HEIGHT+1) exit=1;
        }
				DrawCharFont1(clm, row, *s, fill);
				clm=clm+6;
			  break;
			case 2:
        if(clm+8>WIDTH) exit=1; //Satir sonuna gelindimi döngüden çik
				DrawCharFont2(clm, row, *s, fill);
        clm=clm+8;				
				break;
			case 3:
			  if(clm+12>WIDTH) exit=1;//Satir sonuna gelindimi Bir Alt Satira Geç
				DrawCharFont3(clm, row, *s, fill);
				clm=clm+12;
				break;
			case 4:
			 if(clm+12>WIDTH) exit=1;//Satir sonuna gelindimi Bir Alt Satira Geç
			  DrawCharFont4(clm, row, *s, fill);
			  clm=clm+12;
			break;
      default: break;
    }
		s++;             //Karakter adresini Arttir 
		if(exit) break;  //Döngüden çikis biti
  }
}

/*******************************************************************************
*   Text Kaydirma Fonksiyonu                                                   *
*   Parameter:    clstart, clend, ypos, size, fill                             *
*   Return:                                                                    *
*******************************************************************************/
void TextScroll(uint8_t clstart, uint8_t clend, uint8_t ypos, uint8_t speed, uint8_t size, BOOL fill, unsigned char *s){
  unsigned int a=0,b=0;	
	unsigned int cdata=0;
	unsigned int delay=110-(speed*10);
	unsigned int cadr=0;
	BOOL ZeroBit=0;
	
	while(*s!='\0')
	{
		switch(size)
		{
       case 1:
           for(b=0;b<5;b++)
			     {
              cdata=Font_5x7[*s-32][b];
						  for (a=0;a<8;a++)  //
              {
                 ZeroBit=fill-(cdata>>a) & 0x01;
                 LineScroll(ypos+a,clstart,clend,ZeroBit); 
              }
							delay_ms(delay);
           }
					 for (a=0;a<8;a++)  //Harf Arasi Bosluk ekleniyor..
           {
              LineScroll(ypos+a, clstart, clend, 0);
           }
					 delay_ms(delay);
				 break;
			 case 2:
         for(b=0;b<16;b=b+2)
         {
           cdata=Font_8x12[*s-32][b];
           for(a=0;a<8;a++)
           {
             ZeroBit=fill-(cdata>>a) & 0x01;
             LineScroll(ypos+a, clstart, clend, ZeroBit);
           }  
             cdata=Font_8x12[*s-32][b+1];
           for(a=0;a<4;a++)
           {
             ZeroBit=fill-(cdata>>a) & 0x01;
             LineScroll(ypos+8+a, clstart, clend, ZeroBit);
           } 
           delay_ms(delay);
         }				 
				 break;
			 case 3:
         for(b=0;b<24;b=b+2)
         {
           cdata=Font_12x14[*s-32][b];
           for(a=0;a<8;a++)
           {
             ZeroBit=fill-(cdata>>a) & 0x01;
             LineScroll(ypos+a, clstart, clend, ZeroBit);
           }  
           cdata=Font_12x14[*s-32][b+1];
           for(a=0;a<6;a++)
           {
             ZeroBit=fill-(cdata>>a) & 0x01;
             LineScroll(ypos+8+a, clstart, clend, ZeroBit);
           } 
           delay_ms(delay);
         }
				 break;
			 case 4:
         cadr=CharAdres(*s);
    
         for(b=0;b<24;b=b+2)
         {
           cdata=Font_12x16[cadr][b];
           for(a=0;a<8;a++)
           {
             ZeroBit=fill-(cdata>>a) & 0x01;
             LineScroll(a, clstart, clend, ZeroBit);
           }    
           cdata=Font_12x16[cadr][b+1];
           for(a=0;a<8;a++)
           {
             ZeroBit=fill-(cdata>>a) & 0x01;
             LineScroll(8+a, clstart, clend, ZeroBit);
           } 
           delay_ms(delay);
         }
				 break;
    }
		s++;  //Sonraki Karakteri al..        
  }
	
}

void NumberToUpScroll(uint8_t oldnumber, uint8_t newnumber)
{


}

#include "main.h"

/*********************************Pin Tanimlamalari******************************/
#define Set_A  GPIOA->BSRR  = 0x00000002;
#define Clr_A  GPIOA->BRR   = 0x00000002;

#define Set_B  GPIOA->BSRR  = 0x00000004;
#define Clr_B  GPIOA->BRR   = 0x00000004;

#define Set_OE GPIOA->BSRR  = 0x00000008;
#define Clr_OE GPIOA->BRR   = 0x00000008;

#define Set_LATCH GPIOA->BSRR  = 0x00000010;
#define Clr_LATCH GPIOA->BRR   = 0x00000010;
/********************************************************************************/
#define Font1H   8
#define Font2H   12
#define Font3H   14
#define Font4H   16
#define RIGHT     0                        //
#define LEFT      1                        //
#define WIDTH     63
#define HEIGHT    15
/****************************Fonksiyonlar***************************************/
extern void P10_Panel_Init    (void);
extern void Write_Data        (int row_adr);
extern void Panel_Test        (void);
extern BOOL LineScroll        (uint8_t Line, uint8_t clstart, uint8_t clend, BOOL ZeroBit);
extern void Clear_Display     (BOOL fill);
extern void invert_screen     (void);
extern void PutPixel          (uint8_t Xpos, uint8_t Ypos, BOOL fill);
extern BOOL GetPixel          (uint8_t Xpos, uint8_t Ypos);
extern void Line              (uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, BOOL fill);
extern void Rectangle         (uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, BOOL fill);
extern void Circle            (uint8_t x, uint8_t y, uint8_t size, BOOL fill);
extern void Bargraph          (uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, BOOL hor, uint8_t value);
extern void ShowString        (uint8_t x, uint8_t y, uint8_t size, BOOL fill, unsigned char *s);
extern void TextScroll        (uint8_t clstart, uint8_t clend, uint8_t ypos, uint8_t speed, uint8_t size, BOOL fill, unsigned char *s);
extern void NumberToUpScroll  (uint8_t oldnumber, uint8_t newnumber);
/****************************Global Degiskenler*********************************/

/*******************************************************************************/
//PinA     GPIOA.1
//PinB     GPIOA.2
//PinOE    GPIOA.3
//PinLatch GPIOA.4
//PinSCK   GPIOA.5
//PinDTA   GPIOA.7
//PWM      GPIOB.0

[nobitaemon]

Merhaba,
Panel p10 nasıl 4 parçaya kadar?
Metin nasıl çalışır hale getirilir.

[görkem]

@Mucit23  Merhaba sizin yapmış olduğunuz p10 panel kütüphanesini 2 panel ile kullanıyorum normal text basabiliyorum sıkıntı yok fakat text i kaydıramıyorum anlamsız ledler yanıyor ne gibi değişiklik gerekiyor  kütüphanenizde çözümü nedir yardımcı olursanız sevinirim.

[görkem]

güncel.

[Mucit23]

LineScroll ve text kaydırma fonksiyonlarınıda düzenlemeniz gerekecektir.

[görkem]

stm32 için kullandığınız kaydırma fonksiyonunu pic18 için kullanmak istedim fakat çalışmadı ilk 3 satırda anlamsız ledler kayıyor linescroll ve text kaydırma fonksiyonlarında nasıl bir düzenleme gerekli örnek ile açıklayabilirmisiniz.