STM32F4x Çalışmalarım

[ErsinErce]

kullandığınız tft sürücüsünün kodu nedir?

sitenizde gördüğüm kadarıyla ssd1963 kullanmışsınız fsmc ile şuan ki driver farklı mı?

FSMC de 4 page bulunmakta bu page leri farklı modlara ayarlayabiliyorsunuz
reference manualde detayları mevcut

1. page atıyorum 70000000-7fffffff
2. page 80000000-8fffffff
3. ..
4. ...
arasında gibi
siz 70000000 adersine ulaşmaya çalıştığınızda fsmc otomatik o adres yapısına göre hareket ederken
8000000 diğer yapıya göre hareket edebiliyorsunuz

nor/nand sram vs gibi modlar mevcut
nand için ya 2.page ya 3, sram 1-4 farketmiyor gibi sınırlandırmalarda var dikkat etmek lazım
spi ram ler nvram olarak geçiyor içeriği elektrik kesilince silinmiyor. bu sebepten daha az yazma yapılabiliyor.

normal ram ile aynı performansta spi ram yok en yakını fram diye biliyorum mram, pcm diye sıralama devam ediyor.
boyut/ maliyet oranıda ters yönde

[Mucit23]

SSD1289

#include "stm3240f_lcd.h"
#include "fonts.c"

typedef struct
{
  __IO uint16_t LCD_REG;
  __IO uint16_t LCD_RAM;
} LCD_TypeDef;


#define Bank1_LCD_D    ((uint32_t)0x60020000)    //disp Data ADDR
#define Bank1_LCD_C    ((uint32_t)0x60000000)	 //disp Reg ADDR

#define MAX_POLY_CORNERS   200
#define POLY_Y(Z)          ((int32_t)((Points + Z)->X))
#define POLY_X(Z)          ((int32_t)((Points + Z)->Y))

#define ABS(X)  ((X) > 0 ? (X) : -(X))     

static sFONT *LCD_Currentfonts;

static __IO uint16_t TextColor = 0x0000, BackColor = 0xFFFF;
  

#ifndef USE_Delay
static void delay(__IO uint32_t nCount);
#endif /* USE_Delay*/
static void LCD_PolyLineRelativeClosed(pPoint Points, uint16_t PointCount, uint16_t Closed);

void STM3240F_LCD_Init(void)
{ 
  LCD_CtrlLinesConfig();
  LCD_FSMCConfig();

    GPIOC->BSRRL = GPIO_BSRR_BS_6;
    _delay_(5);
  	GPIOC->BSRRH = GPIO_BSRR_BS_6;
    _delay_(30);
  	GPIOC->BSRRL = GPIO_BSRR_BS_6;
    _delay_(5);

   // power supply setting
    // set R07h at 0021h (GON=1,DTE=0,D[1:0]=01)
    LCD_WriteReg(0x0007,0x0021);
    // set R00h at 0001h (OSCEN=1)
    LCD_WriteReg(0x0000,0x0001);
    // set R07h at 0023h (GON=1,DTE=0,D[1:0]=11)
    LCD_WriteReg(0x0007,0x0023);
    // set R10h at 0000h (Exit sleep mode)
    LCD_WriteReg(0x0010,0x0000);
    // Wait 30ms
    _delay_(3);
    // set R07h at 0033h (GON=1,DTE=1,D[1:0]=11)
    LCD_WriteReg(0x0007,0x0033);
    // Entry mode setting (R11h)
    // R11H Entry mode
    // vsmode DFM1 DFM0 TRANS OEDef WMode DMode1 DMode0 TY1 TY0 ID1 ID0 AM LG2 LG2 LG0
    //   0     1    1     0     0     0     0      0     0   1   1   1  *   0   0   0
    LCD_WriteReg(0x0011,0x6038);  
    // LCD driver AC setting (R02h)
    LCD_WriteReg(0x0002,0x0600);
    // power control 1
    // DCT3 DCT2 DCT1 DCT0 BT2 BT1 BT0 0 DC3 DC2 DC1 DC0 AP2 AP1 AP0 0
    // 1     0    1    0    1   0   0  0  1   0   1   0   0   1   0  0
    // DCT[3:0] fosc/4 BT[2:0]  DC{3:0] fosc/4
    
	  LCD_WriteReg(0x0003,0xA8A4);//0xA8A4
    LCD_WriteReg(0x000C,0x0000);//0x0000
    LCD_WriteReg(0x000D,0x080C);// 0x080C --> 0x0808
    // power control 4
    // 0 0 VCOMG VDV4 VDV3 VDV2 VDV1 VDV0 0 0 0 0 0 0 0 0
    // 0 0   1    0    1    0    1    1   0 0 0 0 0 0 0 0
    LCD_WriteReg(0x000E,0x2B00); //0x2900
    LCD_WriteReg(0x001E,0x00B8); //0x00B8
    LCD_WriteReg(0x0001,0x293F); //0110000000101000 293f
    LCD_WriteReg(0x0010,0x0000);
    LCD_WriteReg(0x0005,0x0000);
    LCD_WriteReg(0x0006,0x0000);
    LCD_WriteReg(0x0016,0xEF1C);
    LCD_WriteReg(0x0017,0x0003);
    LCD_WriteReg(0x0007,0x0233);
    LCD_WriteReg(0x000B,0x0000|(3<<6));
    LCD_WriteReg(0x000F,0x0000);
    LCD_WriteReg(0x0041,0x0000);
    LCD_WriteReg(0x0042,0x0000);
    LCD_WriteReg(0x0048,0x0000);
    LCD_WriteReg(0x0049,0x013F);
    LCD_WriteReg(0x004A,0x0000);
    LCD_WriteReg(0x004B,0x0000);
    LCD_WriteReg(0x0044,0xEF00);
    LCD_WriteReg(0x0045,0x0000);
    LCD_WriteReg(0x0046,0x013F);
    LCD_WriteReg(0x0030,0x0707);
    LCD_WriteReg(0x0031,0x0204);
    LCD_WriteReg(0x0032,0x0204);
    LCD_WriteReg(0x0033,0x0502);
    LCD_WriteReg(0x0034,0x0507);
    LCD_WriteReg(0x0035,0x0204);
    LCD_WriteReg(0x0036,0x0204);
    LCD_WriteReg(0x0037,0x0502);
    LCD_WriteReg(0x003A,0x0302);
    LCD_WriteReg(0x003B,0x0302);
    LCD_WriteReg(0x0023,0x0000);
    LCD_WriteReg(0x0024,0x0000);
    LCD_WriteReg(0x0025,0x8000);  
    LCD_WriteReg(0x004f,0);        
    LCD_WriteReg(0x004e,0);       
  LCD_SetFont(&LCD_DEFAULT_FONT);
}
/**
  * @brief  Sets the LCD Text and Background colors.
  * @param  _TextColor: specifies the Text Color.
  * @param  _BackColor: specifies the Background Color.
  * @retval None
  */
void LCD_SetColors(__IO uint16_t _TextColor, __IO uint16_t _BackColor)
{
  TextColor = _TextColor; 
  BackColor = _BackColor;
}

/**
  * @brief  Gets the LCD Text and Background colors.
  * @param  _TextColor: pointer to the variable that will contain the Text 
            Color.
  * @param  _BackColor: pointer to the variable that will contain the Background 
            Color.
  * @retval None
  */
void LCD_GetColors(__IO uint16_t *_TextColor, __IO uint16_t *_BackColor)
{
  *_TextColor = TextColor; *_BackColor = BackColor;
}

/**
  * @brief  Sets the Text color.
  * @param  Color: specifies the Text color code RGB(5-6-5).
  * @retval None
  */
void LCD_SetTextColor(__IO uint16_t Color)
{
  TextColor = Color;
}


/**
  * @brief  Sets the Background color.
  * @param  Color: specifies the Background color code RGB(5-6-5).
  * @retval None
  */
void LCD_SetBackColor(__IO uint16_t Color)
{
  BackColor = Color;
}

/**
  * @brief  Sets the Text Font.
  * @param  fonts: specifies the font to be used.
  * @retval None
  */
void LCD_SetFont(sFONT *fonts)
{
  LCD_Currentfonts = fonts;
}

/**
  * @brief  Gets the Text Font.
  * @param  None.
  * @retval the used font.
  */
sFONT *LCD_GetFont(void)
{
  return LCD_Currentfonts;
}

/**
  * @brief  Clears the selected line.
  * @param  Line: the Line to be cleared.
  *   This parameter can be one of the following values:
  *     @arg Linex: where x can be 0..n
  * @retval None
  */
void LCD_ClearLine(uint8_t Line)
{
  uint16_t refcolumn = LCD_PIXEL_WIDTH - 1;
  /* Send the string character by character on lCD */
  while (((refcolumn + 1)& 0xFFFF) >= LCD_Currentfonts->Width)
  {
    /* Display one character on LCD */
    LCD_DisplayChar(Line, refcolumn, ' ');
    /* Decrement the column position by 16 */
    refcolumn -= LCD_Currentfonts->Width;
  }
}

/**
  * @brief  Clears the hole LCD.
  * @param  Color: the color of the background.
  * @retval None
  */
void LCD_Clear(uint16_t Color)
{
  uint32_t index = 0;
  int i;
	
  //	 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
//  LCD_SetCursor(0x00, 0x013F); 
  LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
//  _delay_(5);
  	// GPIO_SetBits(GPIOD, GPIO_Pin_11);
  for(index = 0; index < 76800; index++)
  {
   // LCD->LCD_RAM = Color;
	*(__IO uint16_t *) (Bank1_LCD_D)= Color;   
	for(i=0;i<2;i++);
  }  
}

/**
  * @brief  Sets the cursor position.
  * @param  Xpos: specifies the X position.
  * @param  Ypos: specifies the Y position. 
  * @retval None
  */
void LCD_SetCursor(uint16_t Xpos, uint8_t Ypos)
{
  LCD_WriteReg(0x004E, Ypos);
  LCD_WriteReg(0x004F, Xpos);
	LCD_WriteRAM_Prepare();
}

/**
  * @brief  Draws a character on LCD.
  * @param  Xpos: the Line where to display the character shape.
  * @param  Ypos: start column address.
  * @param  c: pointer to the character data.
  * @retval None
  */
void LCD_DrawChar(uint16_t Xpos, uint8_t Ypos, const uint16_t *c)
{
	uint32_t index = 0, i = 0;
//  LCD_SetDisplayWindow(Xpos, Ypos, Xpos+(LCD_Currentfonts->Width-1), Ypos+(LCD_Currentfonts->Height-1));

  for(index = 0; index <LCD_Currentfonts->Height; index++)
  {
    for(i = 0; i < LCD_Currentfonts->Width; i++)
    {
			LCD_SetCursor(Xpos+i,Ypos+index);
      if((((c[index] & ((0x80 << ((LCD_Currentfonts->Width / 12 ) * 8 ) ) >> i)) == 0x00) &&(LCD_Currentfonts->Width <= 12))||
        (((c[index] & (0x1 << i)) == 0x00)&&(LCD_Currentfonts->Width > 12 )))
      {
        LCD_WriteRAM(BackColor);
      }
      else
      {
        LCD_WriteRAM(TextColor);
      } 
    }
  }
}

/**
  * @brief  Displays one character (16dots width, 24dots height).
  * @param  Line: the Line where to display the character shape .
  *   This parameter can be one of the following values:
  *     @arg Linex: where x can be 0..9
  * @param  Column: start column address.
  * @param  Ascii: character ascii code, must be between 0x20 and 0x7E.
  * @retval None
  */
void LCD_DisplayChar(uint16_t Column, uint8_t Line, uint8_t Ascii)
{
  Ascii -= 32;
  LCD_DrawChar(Column, Line, &LCD_Currentfonts->table[Ascii * LCD_Currentfonts->Height]);
}

/**
  * @brief  Displays a maximum of 20 char on the LCD.
  * @param  Line: the Line where to display the character shape .
  *   This parameter can be one of the following values:
  *     @arg Linex: where x can be 0..9
  * @param  *ptr: pointer to string to display on LCD.
  * @retval None
  */
void LCD_DisplayStringLine(uint16_t Xpos, uint8_t Ypos, uint8_t *ptr)
{
  uint16_t refcolumn = Xpos, refrow = Ypos;

  /* Send the string character by character on lCD */
  while (*ptr != 0)
  {
    /* Display one character on LCD */
    LCD_DisplayChar(refcolumn, refrow, *ptr);
    /* increment the column position by 16 */
    refcolumn += LCD_Currentfonts->Width;
		if (refcolumn>=LCD_PIXEL_WIDTH-1) 
		{
			refcolumn=0;
			refrow+=LCD_Currentfonts->Height;
		}
    /* Point on the next character */
    ptr++;
  }	
}

/**
  * @brief  Sets a display window
  * @param  Xpos: specifies the X buttom left position.
  * @param  Ypos: specifies the Y buttom left position.
  * @param  Height: display window height.
  * @param  Width: display window width.
  * @retval None
  */
void LCD_SetDisplayWindow(uint16_t Xpos, uint8_t Ypos, uint16_t Width, uint8_t Height)
{
   LCD_WriteReg(0x0044,(uint16_t)(Height<<8)|Ypos);
	 LCD_WriteReg(0x0045,Xpos);
	 LCD_WriteReg(0x0046,Width);
	 LCD_SetCursor(Xpos,Ypos);
}

/**
  * @brief  Put Pixel LCD.
  * @param  Xpos, Ypos, rgb_data
  * @retval None
  */
void LCD_PutPixel(uint16_t Xpos, uint8_t Ypos, uint16_t rgb_data)
{
   LCD_SetCursor(Xpos, Ypos);
	 LCD_WriteRAM(rgb_data);
}
/**
  * @brief  Get Pixel LCD.
  * @param  Xpos, Ypos
  * @retval RGB_Data
  */
uint16_t LCD_GetPixel(uint16_t Xpos, uint8_t Ypos)
{
  LCD_SetCursor(Xpos, Ypos);
  return LCD_ReadRAM();
}

/**
  * @brief  Disables LCD Window mode.
  * @param  None
  * @retval None
  */
void LCD_WindowModeDisable(void)
{
  //LCD_SetDisplayWindow(239, 0x13F, 240, 320);
  LCD_WriteReg(LCD_REG_3, 0x1018);    
}

/**
  * @brief  Displays a rectangle.
  * @param  X1: specifies the X position.
  * @param  Y1: specifies the Y position.
  * @param  X2: display rectangle height.
  * @param  Y2: display rectangle width.
  * @retval None
  */
void LCD_Rectangle(uint16_t x1, uint8_t y1, uint16_t x2, uint8_t y2, uint8_t fill)
{
		LCD_DrawLine(x1, y1, x2, y1);
		LCD_DrawLine(x1, y2, x2, y2);
		LCD_DrawLine(x1, y1, x1, y2);
		LCD_DrawLine(x2, y1, x2, y2);
}

/**
  * @brief  Displays a circle.
  * @param  Xpos: specifies the X position.
  * @param  Ypos: specifies the Y position.
  * @param  Radius
  * @retval None
  */
void LCD_DrawCircle(uint8_t Xpos, uint16_t Ypos, uint16_t Radius)
{
  int32_t  D;/* Decision Variable */ 
  uint32_t  CurX;/* Current X Value */
  uint32_t  CurY;/* Current Y Value */ 
  
  D = 3 - (Radius << 1);
  CurX = 0;
  CurY = Radius;
  
  while (CurX <= CurY)
  {
    LCD_SetCursor(Xpos + CurX, Ypos + CurY);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos + CurX, Ypos - CurY);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos - CurX, Ypos + CurY);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos - CurX, Ypos - CurY);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos + CurY, Ypos + CurX);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos + CurY, Ypos - CurX);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos - CurY, Ypos + CurX);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    LCD_SetCursor(Xpos - CurY, Ypos - CurX);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    LCD_WriteRAM(TextColor);
    if (D < 0)
    { 
      D += (CurX << 2) + 6;
    }
    else
    {
      D += ((CurX - CurY) << 2) + 10;
      CurY--;
    }
    CurX++;
  }
}

/**
  * @brief  Displays an uni line (between two points).
  * @param  x1: specifies the point 1 x position.
  * @param  y1: specifies the point 1 y position.
  * @param  x2: specifies the point 2 x position.
  * @param  y2: specifies the point 2 y position.
  * @retval None
  */
void LCD_DrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
{
  int16_t deltax = 0, deltay = 0, x = 0, y = 0, xinc1 = 0, xinc2 = 0, 
  yinc1 = 0, yinc2 = 0, den = 0, num = 0, numadd = 0, numpixels = 0, 
  curpixel = 0;
  
  deltax = ABS(x2 - x1);        /* The difference between the x's */
  deltay = ABS(y2 - y1);        /* The difference between the y's */
  x = x1;                       /* Start x off at the first pixel */
  y = y1;                       /* Start y off at the first pixel */
  
  if (x2 >= x1)                 /* The x-values are increasing */
  {
    xinc1 = 1;
    xinc2 = 1;
  }
  else                          /* The x-values are decreasing */
  {
    xinc1 = -1;
    xinc2 = -1;
  }
  
  if (y2 >= y1)                 /* The y-values are increasing */
  {
    yinc1 = 1;
    yinc2 = 1;
  }
  else                          /* The y-values are decreasing */
  {
    yinc1 = -1;
    yinc2 = -1;
  }
  
  if (deltax >= deltay)         /* There is at least one x-value for every y-value */
  {
    xinc1 = 0;                  /* Don't change the x when numerator >= denominator */
    yinc2 = 0;                  /* Don't change the y for every iteration */
    den = deltax;
    num = deltax / 2;
    numadd = deltay;
    numpixels = deltax;         /* There are more x-values than y-values */
  }
  else                          /* There is at least one y-value for every x-value */
  {
    xinc2 = 0;                  /* Don't change the x for every iteration */
    yinc1 = 0;                  /* Don't change the y when numerator >= denominator */
    den = deltay;
    num = deltay / 2;
    numadd = deltax;
    numpixels = deltay;         /* There are more y-values than x-values */
  }
  
  for (curpixel = 0; curpixel <= numpixels; curpixel++)
  {
    LCD_PutPixel(x, y, TextColor);             /* Draw the current pixel */
    num += numadd;              /* Increase the numerator by the top of the fraction */
    if (num >= den)             /* Check if numerator >= denominator */
    {
      num -= den;               /* Calculate the new numerator value */
      x += xinc1;               /* Change the x as appropriate */
      y += yinc1;               /* Change the y as appropriate */
    }
    x += xinc2;                 /* Change the x as appropriate */
    y += yinc2;                 /* Change the y as appropriate */
  }
}

/**
  * @brief  Displays a monocolor picture.
  * @param  Pict: pointer to the picture array.
  * @retval None
  */
void LCD_DrawMonoPict(const uint32_t *Pict)
{
  uint32_t index = 0, i = 0;
  //LCD_SetCursor(0, (LCD_PIXEL_WIDTH - 1)); 
  LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
  for(index = 0; index < 2400; index++)
  {
    for(i = 0; i < 32; i++)
    {
      if((Pict[index] & (1 << i)) == 0x00)
      {
        LCD_WriteRAM(BackColor);
      }
      else
      {
        LCD_WriteRAM(TextColor);
      }
    }
  }
}

/**
  * @brief  Displays a bitmap picture loaded in the internal Flash.
  * @param  BmpAddress: Bmp picture address in the internal Flash.
  * @retval None
  */
void LCD_WriteBMP(uint32_t BmpAddress)
{

  uint32_t index = 0, size = 0;
  /* Read bitmap size */
  size = *(__IO uint16_t *) (BmpAddress + 2);
  size |= (*(__IO uint16_t *) (BmpAddress + 4)) << 16;
  /* Get bitmap data address offset */
  index = *(__IO uint16_t *) (BmpAddress + 10);
  index |= (*(__IO uint16_t *) (BmpAddress + 12)) << 16;
  size = (size - index)/2;
  BmpAddress += index;
  /* Set GRAM write direction and BGR = 1 */
  /* I/D=00 (Horizontal : decrement, Vertical : decrement) */
  /* AM=1 (address is updated in vertical writing direction) */
  LCD_WriteReg(LCD_REG_3, 0x1008);
 
  LCD_WriteRAM_Prepare();
 
  for(index = 0; index < size; index++)
  {
    LCD_WriteRAM(*(__IO uint16_t *)BmpAddress);
    BmpAddress += 2;
  }
 
  /* Set GRAM write direction and BGR = 1 */
  /* I/D = 01 (Horizontal : increment, Vertical : decrement) */
  /* AM = 1 (address is updated in vertical writing direction) */
  LCD_WriteReg(LCD_REG_3, 0x1018);
}

/**
  * @brief  Displays a bitmap picture loaded in the internal Flash.
  * @param  BmpAddress: Bmp picture address in the internal Flash.
  * @retval None
  */
void LCD_WriteBMP2(uint16_t Xpos, uint8_t Ypos, uint16_t Width, uint16_t Height, unsigned char *bitmap)
{
  volatile uint32_t index;
  unsigned short *bitmap_ptr = (unsigned short *)bitmap;
  uint16_t i;
  LCD_SetDisplayWindow(Xpos, Ypos, Width, Height);

	//LCD_SetCursor(Xpos, Ypos);
  LCD_WriteRAM_Prepare();
 
  for(index = 0; index < 76800; index++)
  {
	  LCD_WriteRAM(bitmap_ptr[index]);
		for(i=0;i<100;i++);
  }

}
/**
  * @brief  Displays a full rectangle.
  * @param  Xpos: specifies the X position.
  * @param  Ypos: specifies the Y position.
  * @param  Height: rectangle height.
  * @param  Width: rectangle width.
  * @retval None
  */
void LCD_DrawFullRect(uint16_t x1, uint8_t y1, uint16_t x2, uint8_t y2)
{
  unsigned char  i, xmin, xmax, ymin, ymax;
	unsigned char xend=x2-x1;
	unsigned char yend=y2-y1;
	
	LCD_SetDisplayWindow(x1,y1,xend+1,yend+1);

		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)
			{
				LCD_PutPixel(xmin, i, TextColor);
			}
		}
}

/**
  * @brief  Displays a full circle.
  * @param  Xpos: specifies the X position.
  * @param  Ypos: specifies the Y position.
  * @param  Radius
  * @retval None
  */
void LCD_DrawFullCircle(uint16_t Xpos, uint8_t Ypos, uint16_t Radius)
{
	
	signed int a,b,P;
	a=0;
	b=Radius;
	P=1-Radius;
	
	do
	{
			LCD_DrawLine(Xpos-a, Ypos+b, Xpos+a, Ypos+b);
			LCD_DrawLine(Xpos-a, Ypos-b, Xpos+a, Ypos-b);
			LCD_DrawLine(Xpos-b, Ypos+a, Xpos+b, Ypos+a);
			LCD_DrawLine(Xpos-b, Ypos-a, Xpos+b, Ypos-a);	
		if(P < 0)
      P+= 3 + 2*a++;
    else
      P+= 5 + 2*(a++ - b--);
	  
  }while(a<=b);
}



/**
  * @brief  Displays an polyline (between many points).
  * @param  Points: pointer to the points array.
  * @param  PointCount: Number of points.
  * @retval None
  */
void LCD_PolyLine(pPoint Points, uint16_t PointCount)
{
  int16_t X = 0, Y = 0;

  if(PointCount < 2)
  {
    return;
  }

  while(--PointCount)
  {
    X = Points->X;
    Y = Points->Y;
    Points++;
    LCD_DrawLine(X, Y, Points->X, Points->Y);
  }
}

/**
  * @brief  Displays an relative polyline (between many points).
  * @param  Points: pointer to the points array.
  * @param  PointCount: Number of points.
  * @param  Closed: specifies if the draw is closed or not.
  *           1: closed, 0 : not closed.
  * @retval None
  */
static void LCD_PolyLineRelativeClosed(pPoint Points, uint16_t PointCount, uint16_t Closed)
{
  int16_t X = 0, Y = 0;
  pPoint First = Points;

  if(PointCount < 2)
  {
    return;
  }  
  X = Points->X;
  Y = Points->Y;
  while(--PointCount)
  {
    Points++;
    LCD_DrawLine(X, Y, X + Points->X, Y + Points->Y);
    X = X + Points->X;
    Y = Y + Points->Y;
  }
  if(Closed)
  {
    LCD_DrawLine(First->X, First->Y, X, Y);
  }  
}

/**
  * @brief  Displays a closed polyline (between many points).
  * @param  Points: pointer to the points array.
  * @param  PointCount: Number of points.
  * @retval None
  */
void LCD_ClosedPolyLine(pPoint Points, uint16_t PointCount)
{
  LCD_PolyLine(Points, PointCount);
  LCD_DrawLine(Points->X, Points->Y, (Points+PointCount-1)->X, (Points+PointCount-1)->Y);
}

/**
  * @brief  Displays a relative polyline (between many points).
  * @param  Points: pointer to the points array.
  * @param  PointCount: Number of points.
  * @retval None
  */
void LCD_PolyLineRelative(pPoint Points, uint16_t PointCount)
{
  LCD_PolyLineRelativeClosed(Points, PointCount, 0);
}

/**
  * @brief  Displays a closed relative polyline (between many points).
  * @param  Points: pointer to the points array.
  * @param  PointCount: Number of points.
  * @retval None
  */
void LCD_ClosedPolyLineRelative(pPoint Points, uint16_t PointCount)
{
  LCD_PolyLineRelativeClosed(Points, PointCount, 1);
}


/**
  * @brief  Displays a  full polyline (between many points).
  * @param  Points: pointer to the points array.
  * @param  PointCount: Number of points.
  * @retval None
  */
void LCD_FillPolyLine(pPoint Points, uint16_t PointCount)
{
  /*  public-domain code by Darel Rex Finley, 2007 */
  uint16_t  nodes = 0, nodeX[MAX_POLY_CORNERS], pixelX = 0, pixelY = 0, i = 0,
  j = 0, swap = 0;
  uint16_t  IMAGE_LEFT = 0, IMAGE_RIGHT = 0, IMAGE_TOP = 0, IMAGE_BOTTOM = 0;

  IMAGE_LEFT = IMAGE_RIGHT = Points->X;
  IMAGE_TOP= IMAGE_BOTTOM = Points->Y;

  for(i = 1; i < PointCount; i++)
  {
    pixelX = POLY_X(i);
    if(pixelX < IMAGE_LEFT)
    {
      IMAGE_LEFT = pixelX;
    }
    if(pixelX > IMAGE_RIGHT)
    {
      IMAGE_RIGHT = pixelX;
    }
    
    pixelY = POLY_Y(i);
    if(pixelY < IMAGE_TOP)
    { 
      IMAGE_TOP = pixelY;
    }
    if(pixelY > IMAGE_BOTTOM)
    {
      IMAGE_BOTTOM = pixelY;
    }
  }
  
  LCD_SetTextColor(BackColor);  

  /*  Loop through the rows of the image. */
  for (pixelY = IMAGE_TOP; pixelY < IMAGE_BOTTOM; pixelY++) 
  {  
    /* Build a list of nodes. */
    nodes = 0; j = PointCount-1;

    for (i = 0; i < PointCount; i++) 
    {
      if (POLY_Y(i)<(double) pixelY && POLY_Y(j)>=(double) pixelY || POLY_Y(j)<(double) pixelY && POLY_Y(i)>=(double) pixelY) 
      {
        nodeX[nodes++]=(int) (POLY_X(i)+((pixelY-POLY_Y(i))*(POLY_X(j)-POLY_X(i)))/(POLY_Y(j)-POLY_Y(i))); 
      }
      j = i; 
    }
  
    /* Sort the nodes, via a simple "Bubble" sort. */
    i = 0;
    while (i < nodes-1) 
    {
      if (nodeX[i]>nodeX[i+1]) 
      {
        swap = nodeX[i]; 
        nodeX[i] = nodeX[i+1]; 
        nodeX[i+1] = swap; 
        if(i)
        {
          i--; 
        }
      }
      else 
      {
        i++;
      }
    }
  
    /*  Fill the pixels between node pairs. */
    for (i = 0; i < nodes; i+=2) 
    {
      if(nodeX[i] >= IMAGE_RIGHT) 
      {
        break;
      }
      if(nodeX[i+1] > IMAGE_LEFT) 
      {
        if (nodeX[i] < IMAGE_LEFT)
        {
          nodeX[i]=IMAGE_LEFT;
        }
        if(nodeX[i+1] > IMAGE_RIGHT)
        {
          nodeX[i+1] = IMAGE_RIGHT;
        }
        LCD_SetTextColor(BackColor);
        LCD_DrawLine(pixelY, nodeX[i+1], nodeX[i+1] - nodeX[i], LCD_DIR_HORIZONTAL);
        LCD_SetTextColor(TextColor);
        LCD_PutPixel(pixelY, nodeX[i+1], TextColor);
        LCD_PutPixel(pixelY, nodeX[i], TextColor);
        /* for (j=nodeX[i]; j<nodeX[i+1]; j++) PutPixel(j,pixelY); */
      }
    }
  } 

  /* draw the edges */
  LCD_SetTextColor(TextColor);
}

/**
  * @brief  Writes to the selected LCD register.
  * @param  LCD_Reg: address of the selected register.
  * @param  LCD_RegValue: value to write to the selected register.
  * @retval None
  */
void LCD_WriteReg(uint8_t LCD_Reg, uint16_t LCD_RegValue)
{	
  *(__IO uint16_t *) (Bank1_LCD_C)=	LCD_Reg; 
  *(__IO uint16_t *) (Bank1_LCD_D)=	LCD_RegValue;
}

/**
  * @brief  Reads the selected LCD Register.
  * @param  LCD_Reg: address of the selected register.
  * @retval LCD Register Value.
  */
uint16_t LCD_ReadReg(uint8_t LCD_Reg)
{
  return (*(__IO uint16_t *) (Bank1_LCD_D));
}

/**
  * @brief  Prepare to write to the LCD RAM.
  * @param  None
  * @retval None
  */
void LCD_WriteRAM_Prepare(void)
{	 
  	*(__IO uint16_t *) (Bank1_LCD_C)= LCD_REG_34;
}

/**
  * @brief  Writes to the LCD RAM.
  * @param  RGB_Code: the pixel color in RGB mode (5-6-5).
  * @retval None
  */
void LCD_WriteRAM(uint16_t RGB_Code)
{   
 *(__IO uint16_t *) (Bank1_LCD_D)=RGB_Code;
}

/**
  * @brief  Reads the LCD RAM.
  * @param  None
  * @retval LCD RAM Value.
  */
uint16_t LCD_ReadRAM(void)
{
  *(__IO uint16_t *) (Bank1_LCD_C)=LCD_REG_34	;
  return *(__IO uint16_t *) (Bank1_LCD_D);
}

/**
  * @brief  Power on the LCD.
  * @param  None
  * @retval None
  */
void LCD_PowerOn(void)
{
/* Power On sequence ---------------------------------------------------------*/
  LCD_WriteReg(LCD_REG_16, 0x0000); /* SAP, BT[3:0], AP, DSTB, SLP, STB */
  LCD_WriteReg(LCD_REG_17, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */
  LCD_WriteReg(LCD_REG_18, 0x0000); /* VREG1OUT voltage */
  LCD_WriteReg(LCD_REG_19, 0x0000); /* VDV[4:0] for VCOM amplitude*/
  _delay_(20);                 /* Dis-charge capacitor power voltage (200ms) */
  LCD_WriteReg(LCD_REG_16, 0x17B0); /* SAP, BT[3:0], AP, DSTB, SLP, STB */
  LCD_WriteReg(LCD_REG_17, 0x0137); /* DC1[2:0], DC0[2:0], VC[2:0] */
  _delay_(5);                  /* Delay 50 ms */
  LCD_WriteReg(LCD_REG_18, 0x0139); /* VREG1OUT voltage */
  _delay_(5);                  /* Delay 50 ms */
  LCD_WriteReg(LCD_REG_19, 0x1d00); /* VDV[4:0] for VCOM amplitude */
  LCD_WriteReg(LCD_REG_41, 0x0013); /* VCM[4:0] for VCOMH */
  _delay_(5);                  /* Delay 50 ms */
  LCD_WriteReg(LCD_REG_7, 0x0173);  /* 262K color and display ON */
}

/**
  * @brief  Enables the Display.
  * @param  None
  * @retval None
  */
void LCD_DisplayOn(void)
{
  /* Display On */
  LCD_WriteReg(LCD_REG_7, 0x0173); /* 262K color and display ON */
}

/**
  * @brief  Disables the Display.
  * @param  None
  * @retval None
  */
void LCD_DisplayOff(void)
{
  /* Display Off */
  LCD_WriteReg(LCD_REG_7, 0x0); 
}

/**
  * @brief  Configures LCD Control lines (FSMC Pins) in alternate function mode.
  * @param  None
  * @retval None
  */
void LCD_CtrlLinesConfig(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  /* Enable GPIOD, GPIOE, GPIOF, GPIOG and AFIO clocks */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD |  RCC_AHB1Periph_GPIOE, ENABLE);

/*-- GPIO Configuration ------------------------------------------------------*/
  /* SRAM Data lines,  NOE and NWE configuration */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_8 | GPIO_Pin_9 |
                                GPIO_Pin_10 | GPIO_Pin_14 | GPIO_Pin_15 | 
                                GPIO_Pin_4 |GPIO_Pin_5;;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;

  GPIO_Init(GPIOD, &GPIO_InitStructure);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource4, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource5, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource8, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource9, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource10, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_FSMC);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 |
                                GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | 
                                GPIO_Pin_15;
  GPIO_Init(GPIOE, &GPIO_InitStructure);

  GPIO_PinAFConfig(GPIOE, GPIO_PinSource7 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource8 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource9 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource10 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource11 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource12 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource13 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource14 , GPIO_AF_FSMC);
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource15 , GPIO_AF_FSMC);

   /* NE1 configuration */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;    
  GPIO_Init(GPIOD, &GPIO_InitStructure);
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource7, GPIO_AF_FSMC);

  
  /* SRAM Address lines configuration */   
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  GPIO_Init(GPIOD, &GPIO_InitStructure);  
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource11, GPIO_AF_FSMC);

}

/**
  * @brief  Configures the Parallel interface (FSMC) for LCD(Parallel mode)
  * @param  None
  * @retval None
  */
void LCD_FSMCConfig(void)
{
  FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
  FSMC_NORSRAMTimingInitTypeDef  p;
   
  /* Enable FSMC clock */
  RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG , ENABLE);
  
/*-- FSMC Configuration ------------------------------------------------------*/
/*----------------------- SRAM Bank 3 ----------------------------------------*/
  /* FSMC_Bank1_NORSRAM4 configuration */
  p.FSMC_AddressSetupTime = 0;
  p.FSMC_AddressHoldTime = 0;
  p.FSMC_DataSetupTime = 9;
  p.FSMC_BusTurnAroundDuration = 0;
  p.FSMC_CLKDivision = 1;
  p.FSMC_DataLatency = 0;
  p.FSMC_AccessMode = FSMC_AccessMode_A;
  /* Color LCD configuration ------------------------------------
     LCD configured as follow:
        - Data/Address MUX = Disable
        - Memory Type = SRAM
        - Data Width = 16bit
        - Write Operation = Enable
        - Extended Mode = Enable
        - Asynchronous Wait = Disable */

  FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1;
  FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
  FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
  FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
  FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
  FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
  FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
  FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
  FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
  FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
  FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Enable;//
  FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Enable;//
  FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
  FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
  FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;

  FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);   

  /* Enable FSMC NOR/SRAM Bank3 */
  FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);
}

#ifndef USE_Delay
/**
  * @brief  Inserts a delay time.
  * @param  nCount: specifies the delay time length.
  * @retval None
  */
static void delay(__IO uint32_t nCount)
{
  __IO uint32_t index = 0; 
  for(index = (100000 * nCount); index != 0; index--)
  {
  }	 
}
#endif /* USE_Delay*/

[ErsinErce]

bu lcd yi de fsmc ile kullanıyorsunuz ztn
hatta page 1 i atamışsınız

stm32f4 den ram için gereken diğer pinleri çıkarıp direk bağlayın
page 2 ye de ram i atayın

FSMC_BCR1..4 diye 4 farklı register mevcut

page -> bank olarak geçiyormuş

[Mucit23]

Hocam yarın konuyu biraz araştırayım. Bu Page1, Page 2 konularını hiç bilmiyorum. Bu konuda birazdaha başınızı ağrıtabilirim. Atama işlemi anlattığınız kadar kolaysa ne mutlu bana. Yanlız bunlarında fiyatı çok pahalı. Tanesi 17 küsür lira. Eğer Page Atama işini çözersem hurda pc ramlerinden işime yarayacak bir tane bulmaya çalışayım. Benzerdir herhalde.

Son yarım saattir bir yandanda gözüm STM32F429-Discovery de geziniyor. SDRam LCD felan herşeyi üzerinde. 64Mbit SD ram bulunuyor üzerinde. Sanırsam LCD ile ortak kullanılıyor. Buradaki Ortak kullanımdaki karışmaları page'ler ilemi hallediyorlar?

DMA2D denen bir donanım eklemişler. Layer meselesi hoşuma gitti.
http://www.youtube.com/watch?v=TJWeVvicvZk#ws

[Mucit23]

Daha önce STM32F429'da DMA2D modülünü araştıran oldumu. Bazı güzel Özellikleri var.

Örnek programlarda bakıyorum anlamadığım bir iki nokta var. LCD ye yazı yazılacağı zaman LCD nin RAM alanı yerine direk SDRAM'e data gönderiliyor. Anladığım kadarıyla DMA2D donanımıda SDRAMdeki datayı alıp LCD nin ram alanına taşıyor. Bu sayede LCD ye data göndermeden önce DMA2D donanımı sayesinde Görüntüde işlemeler yapılabiliyor. Yani hiç bir zaman direk LCD nin ram alanına yazılma yapılmıyor. Durum böyle işliyor değilmi?

Bir başka örnekte kart üzerindeki SD ram'in kullanımı gösterilmiş. Kullanıcı SD ram'e data yazabiliyor. Anlamadığım nokta şudur. SD ram LCD için kullanılıyorsa kullanıcının Ram alanına veri yazması Sıkıntı çıkarmazmı? Gördüğüm kadarıyla kullanıcıya ayrılmış özel bir alan yok. Hem LCD hemde Kullanıcı SDRam'de aynı adresi kullanıyor.

SDRAM, LTDC ve DMA2D donanımları birlikte nasıl işliyor. SDRAM nasıl kullanılıyor? Açıklayacak olan varmı?

[yamak]

Hocam olay şu şekilde:
FMC modülü yardımıyla SDRAM sürülüyor. DMA2D aracılığıyla da lcd'ye basılacak olan veriler SDRAM'in başlangıç adresinden itibaren yazılır.Mesela Stm32f429 da bu adres 0xD0000000.LTDC donanımı da konfigüre edilirken start adres olarak da bu adres verilir.Böylece LTDC donanımı bu adresten itibaren adresleri tarar ve herbir pixele tekbül eden adresteki veriyi ekrana basar.
Bu arada LTDC donanımı arada bir tft driver entegresi olmadığı durumlarda kullanıyor.Yani driver'ın görevini LTDC yapmış oluyor.

[Mucit23]

Anladım. Ama mesela LCD kütüphanesini inceliyorum Text basarken direk SDRAM'in başlangıc adresinden itibaren yazma yapılıyor.Bunun yanı sıra  DrawLine, DrawRect gibi fonksiyonlarda DMA2D kullanılıyor. Burada istenseydi direk SDRAM'e yazılabilirdi değilmi. DMA2D kullanılmasındaki sebeb nedir?

Örnek kodları inceliyorum. LTDC  donanımının init edildiği kısımda SDRAM de init ediliyor. Fakat LTDC donanımının SDRAM'in başlangıc adresinden itibaren tarama yapılabilmesi için LTDC donanımına mutlaka bir yerde SDRAM in başlangıc adresini tanımlamaları lazım. Bunu nerede yapıyorlar çözemedim.

Hocam LCD de driver ic yok diyorsunuz ama ILI9341 yokmu?

[Mucit23]

Birde;
Hocam Ben 192+4Kb işinde birşey anlamadım. Bana 153 kb boyutunda bir dizi lazım. Keil bana müsade etmiyor.

Dizi kullanmadan şuanki program boyutum aşağıdaki gibi.

Program Size: Code=19044 RO-data=6556 RW-data=96 ZI-data=1656 

Aslında diziyi tanımlıyorum sıkıntı yok ama diziyi kullanmak istediğimde keil bana aşağıdaki hatayı veriyor

.\Output\Discovery.axf: Error: L6406E: No space in execution regions with .ANY selector matching main.o(.bss).
.\Output\Discovery.axf: Error: L6407E: Sections of aggregate size 0x25800 bytes could not fit into .ANY selector(s).

Atladığım bir noktamı var. Acaba tek seferde tanımlanabilecek max. bir dizi boyutumu var? Atladığım nokta nedir?

[yamak]

Hocam stm32f4xx lerde.Ram iki bölümden oluşuyomuş.
128 kb'lık Major Ram+64 Kb CCM Data Ram şeklinde.
64 Kb CCM Data Ram kısmına çevre birimleri ya da DMA tarafından erişilemiyor.Bu alanı sadece CPU'yu kullanabiliyor.Reference Manual'de Memory And Bu Architecture bölümünde bahsediliyor biraz.

[Mucit23]

Anladım hocam, STM32F429 ile ilgili son bir soru sormak istiyorum. LCD sürekli SDRAM i kullanıyor. Fakat hepsini kullanmıyor herhalde. Çünkü SDRAM yanlış hatırlamıyorsam 8Mbyte. LCD için çok fazla bir değer. Acaba LCD, SDRAM de nekadarlık bir alanı kullanıyor? Ben Hem LCD yi kullanıp hemde SDRAM'i external ram olarak kullanabilirmiyim?

@Ersin Hocam

STM32F407'ye paralel SD ram bağlama içinden vazgeçtim. Çok fazla kablolama işi yapmam gerekiyor. Sırf 12 tane Adres, 15 tane Data, 7-8 tanede kontrol için kablo çekmem gerekiyor. Açıkçası gözüm korktu bu kablolama işinden.

Ben yine SPI RAM konularına bakacağım. Şuanda piyasada birtek microchip'in SPI SRAM'leri işimi görüyor. Zaten başka bir firmadada SPI Sram bulamadım. 23LCV1024 var. Her biri 125KB, Bundan iki tane bağlayıp toplamda 2 adet CS 3 adette SPI haberleşme hattı ile RAM işini çözmeyi düşünüyorum. Datasheet'te "Unlimited Read and Write Cycles" yazıyor. Yazma okuma ömründe problem yok. Benim gözümte tek eksiği max 20Mhz desteklemesi. Onuda şuanda göz ardı ediyorum. 20Mhz'in yeterli olup olmadığını gerçek uygulamada test edip göreceğim.

Bana 4 adet 23LCV1024 lazım. Türkiyede bulamadım. Yurtdışından satın almayı düşünüyorum. Nerden almam daha uygun olur?

[yamak]

Anladım hocam, STM32F429 ile ilgili son bir soru sormak istiyorum. LCD sürekli SDRAM i kullanıyor. Fakat hepsini kullanmıyor herhalde. Çünkü SDRAM yanlış hatırlamıyorsam 8Mbyte. LCD için çok fazla bir değer. Acaba LCD, SDRAM de nekadarlık bir alanı kullanıyor? Ben Hem LCD yi kullanıp hemde SDRAM'i external ram olarak kullanabilirmiyim?

Hocam kodları inceledim biraz anladığım kadarıyla yaklaşık 600 kb lık bir alan kullanılıyor.Geri kalan alanı siz istediğiniz bir işlem için kullanabilirsiniz.

[Mucit23]

Az önce her bir pixel nekadar sürede geliyor onu ölçebilmek için DMA Transfer Complete kesmesini açtım. Her bir pixel geldiğinde kesme oluşacağı için  kesme içinde bir pini toggle yaparak pixel frekansını ölçtüm.

Pixel frekansı konusunda ufak bir tespit yaptım. Kameranın FPS değeri düşünce gelen dataların hızı değişmiyor. Herzaman 3Mhz frekansta kesme oluşuyor. Yani 333ns aralıklarla yeni bir pixel geliyor. Bu frekansta gelen 16 bit bir datayı spi ile göndermek x16 clock daha demektir. Microchip'in SPI SRAMleri bu frekansta çalışması olanaksız.

STM32F407 için Paralel SDRAM den başka çözüm yok. Onunlada uğraşmak istemiyorum. STM32F429 Discovery alacağım.

[Mucit23]

Arkadaşlar bir problemim var.

STM32F429 Discovery'ye kamera bağlayacağım. Aynı zamanda LCD de kullanacağım. Discovery üzerinde zaten LCD var. LTDC ile kullanılabiliyor. DCMI modülüde var ama öyle bir zıtlık varki bu iki modül aynı anda kullanılamıyor? DCMI ve LTDC bazı pinleri ortak kullanıyor. Bu bir hatamı yoksa st bilerekmi böyle yapmışlar anlam veremedim. Biraz hayal kırıklığına uğradım açıkçası

Çakışan pinler aşağıdaki gibi

PA4 = DCMI_HSYNC = LTDC_VSYNC
PA6 = DCMI_PXCLK = LTDC_G2
PC6 = DCMI_D0       = LTDC_HSYNC
PC7 = DCMI_D1       = LTDC_G6
PD3 = DCMI_D5       = LTDC_G7

DCMI modülünün işlemci üzerinde kullanılabilecek bütün pinlerine baktım. Çakışan D0, D1 ve D5 Pinlerini Başka pinlere taşıyabiliyorum ama DCMI_ PXCLK ve DCMI_HSYNC pinlerinin başka karşılığı yok bulamadım ben. Yinede gözümden kaçmış bir nokta olabilir. Birde siz inceleyebilirmisiniz

[Mucit23]

Yok olmuyor. Çok kötü bir durum. 

Hatta şurada benzer bir konu var.
https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=https%3a%2f%2fmy%2est%2ecom%2fpublic%2fSTe2ecommunities%2fmcu%2fLists%2fcortex_mx_stm32%2fSTM32F429I-DISCO%20LCD%20and%20DCMI&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=284

Sadece 2 Pinin LTDC ile çakışması yüzünden (HSYNC ve PXCLK) DCMI kullanamıyacam. Büyük ihtimal Kamerayı Software kullanmam gerekecek..

[ercan_t]

merhaba
AF tablosunda
istediğin fonksiyon ucları başka pinlerede tanımlanmış görünüyor?


PI9,PI13   = LTDC_VSYNC
PJ9,PH13  = LTDC_G2
PI10,PI12 = LTDC_HSYNC
PK1,PI1    = LTDC_G6
PI2,Pk2    = LTDC_G7
bunları kullanabilirsin işine yarayabilir.