Bild an TFT Display anzeigen

[clincii (Gast)]

Moin Moin,

ich muss an einem TFT-Display ein Bild ausgeben, jedoch habe ich absolut 
keine Ahnung wie ich das Bild im Code ausgeben bzw. in einer Variabel 
abspeichern kann.

Ich hoffe jemand hat ein Beispielcode wie man ein Bild am Display 
anzeigen kann. Ich programmiere in C++ mit dem Programm Eclipse.

Mit freundlichen Grüssen clincii:D

PS: Display         -->NHD-2.4-240320SF-CTXL#-FTN1
    Mikrocontroller --> STM32F407

[proggen (Gast)]

http://www.newhavendisplay.com/specs/NHD-2.4-240320SF-CTXL-FTN1.pdf
verweist auf:
http://www.newhavendisplay.com/app_notes/ILI9341.pdf

Wenn du fertige libs suchst:
"ILI9341 library" oder "ILI9341 api" lauten die Suchbegriffe.

Da wirst du aber bestimmt noch einiges konfigurieren müssen...


Have a nice day :)

[clincii (Gast)]

Hallo proggen,

viel Dank für die Antwort, die beiden Datasheets habe ich bereits 
angeschaut sowie ein wenig studiert.

Ich habe leider immer noch nicht die leiseste Ahnung wie ich das Bild 
dem Display übergeben kann. Hätte jemand ein Beispiel wie man ein Bild 
an ein TFT Display übergeben kann?

Worauf muss ich achten? Kann ich das Bild(z.B. .jpg) direkt an die 
Datenleitungen des Display senden oder muss ich das Bild in die 
einzelene Pixel aufteilen und jedes Pixel einzel ansteuern?

Danke !

[Markus S. (acepilot)]

Warum fängt eigentlich jeder zweite hier mit einem STM32F4 und Displays 
an? Und das scheinbar ohne wirklich einen genaueren Durchblick zu haben.

Hast du denn schon irgendetwas in Code geschrieben? Dann wäre es 
hilfreich, wenn du diesen mit hier anhängst damit man dir helfen kann. 
Der übliche Ablauf ist die benötigten Schnittstellen für das Display zu 
initialisieren. Wenn das geschehen ist muss das Display nach 
Datenblattangaben ebenfalls initialisiert werden. Erst wenn das 
geschehen ist kannst du versuchen etwas auf das Display zu zaubern.

Bevor du dann an die Ausgabe von Bildern denkst fang doch erstaml mit 
einer Linie und Text an. Wenn dies dann funktioniert ist der Weg zu 
einem Bild auch nicht mehr weit.

[clincii (Gast)]

Hallo,

Das Projekt ist ein Funkgerät, welches von den letztjährigen Lehrlingen 
begonnen wurde. Nun erhielt ich den Auftrag dieses zu beenden.
Und ich muss nun eben ein Bild am Display anzeigen können.

Der Code umfasst mehrere 1000 Zeilen..
Die Initialisierung des Display wurde bereits vorgenommen.

Ich möchte nur wissen wie man ein Bild an das Display sendet!

Mfg

[Thomas F. (igel)]

clincii schrieb:
> viel Dank für die Antwort, die beiden Datasheets habe ich bereits
> angeschaut sowie ein wenig studiert.

Anschauen und ein wenig studieren reicht aber nicht.
Als ich meine Lib für ein TFT schrieb habe ich das Datasheet zweimal 
komplett durchgelesen und dann abschnittsweise den Code erstellt.


> Ich habe leider immer noch nicht die leiseste Ahnung wie ich das Bild
> dem Display übergeben kann. Hätte jemand ein Beispiel wie man ein Bild
> an ein TFT Display übergeben kann?

Du musst dir Datenschnittstelle des Displays schon selber verstehen. 
Sonst wird das nix.


> Kann ich das Bild(z.B. .jpg) direkt an die
> Datenleitungen des Display senden oder muss ich das Bild in die
> einzelene Pixel aufteilen und jedes Pixel einzel ansteuern?

Hä? Jpeg ist ein komprimiertes Format! Das muss erst mal in ein Bitmap 
dekomprimiert werden. Und dann schickt man die Pixel ans Display.

[Markus S. (acepilot)]

Schau dir die Seiten ab 110 bis 113 an. Mit Hilfe dieser Befehle kannst 
du dir einen Bereich definieren, in dem Daten auf dem Display geändert 
werden sollen, wenn nicht das gesamte Display überschrieben werden soll.

Seite 114 vom Datasheet zeigt dir dann wie du ein Pixel an das Display 
schicken kannst. Die Daten die du schicken musst sind aber auch abhängig 
von dem verwendeten Color Mode, somit von deiner Initialisierung von der 
du uns ja nichts zeigen möchtest.

Ansonsten hat Thomas vollkommen recht, mit einem JPEG kannst du nichts 
anfangen, du benötigst ein unkomprimiertes Bitmapfile.

[clincii (Gast)]

Hier die Initialisierung des Displays..

 void DisplayInit(){
   // Display D4 to D0
   GPIO_InitTypeDef GPIO_InitStruct;
   GPIO_InitStruct.GPIO_Pin =  GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOE, &GPIO_InitStruct);

   // Display D7 to D5
   GPIO_InitStruct.GPIO_Pin =  GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2;
   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOB, &GPIO_InitStruct);

   // Display *Read | *Write | Data/Command
   GPIO_InitStruct.GPIO_Pin =  LCD_WRITE | LCD_READ | LCD_DC;
   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOE, &GPIO_InitStruct);

   // Display *Reset
   GPIO_InitStruct.GPIO_Pin =  LCD_RESET;
   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOC, &GPIO_InitStruct);

   //Touch Controller Chip Select
  GPIO_InitStruct.GPIO_Pin = TCH_CS;                      //Chip Select Init
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;                  //Output
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_Init(GPIOE, &GPIO_InitStruct);

  // SETUP EXTERNAL INTERRUPT PIN
  GPIO_InitStruct.GPIO_Pin = TCH_INT;                      // Touch Interrupt
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;                  // Input
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOC, &GPIO_InitStruct);

  GPIO_SetBits(GPIOE, TCH_CS);    // Touch Controller /Select

    // PWM Pin Alternate Function DISPLAY BACKLIGHT
    GPIO_PinAFConfig(GPIOD, GPIO_PinSource12, GPIO_AF_TIM4);
    // PWM Output
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_12;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOD, &GPIO_InitStruct);

  /****************************************************************/
  /*            LCD Backlight PWM            */
  /****************************************************************/
    TIM_TimeBaseInitTypeDef TIMER_InitStructure;
  TIMER_InitStructure.TIM_Prescaler = 2;
  TIMER_InitStructure.TIM_Period = 0;
  TIMER_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
  TIMER_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM4, &TIMER_InitStructure);

  TIM_OCInitTypeDef  TIM_OCInitStructure;
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 0;              // Set PWM duty cycle to 0%
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
  TIM_OC1Init(TIM4, &TIM_OCInitStructure);          // OC1  ->  Channel 1  ->  PIN12, PORTD
  TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);

  TIM_SetAutoreload(TIM4,2099);                // Set PWM to 10kHz
  TIM_Cmd(TIM4, ENABLE);                    // enable timer / counter (timer4)
  TIM_ARRPreloadConfig(TIM4, DISABLE);              // preload timer configuration


   /****************************************************************/
   /*            LCD init                */
   /****************************************************************/

   GPIO_ResetBits(GPIOC , LCD_RESET);      // Enable the Reset
   GPIO_SetBits(GPIOE , LCD_READ);        // Disable the Read mode
   GPIO_SetBits(GPIOE , LCD_WRITE);      // Disable the Write mode
   GPIO_SetBits(GPIOE , LCD_DC);        // Enable the Data mode
   delay(1200);                // Wait 120ms
   GPIO_SetBits(GPIOC , LCD_RESET);      // Disable the Reset
   delay(1200);                // Wait 120ms

   LCD_Cmd(CMD_SOFTRESET);      // Soft Reset
   delay(100);            // delay 10ms
   LCD_Cmd(CMD_DISPOFF);           // display off
   LCD_Cmd(CMD_SLPOUT);            // exit SLEEP mode
   LCD_Cmd(CMD_PWR_CTRL_A);        // power control A
   LCD_Data(0x39);
   LCD_Data(0x2C);
   LCD_Data(0x00);
   LCD_Data(0x34);
   LCD_Data(0x02);
   LCD_Cmd(CMD_PWR_CTRL_B);        //power control B
   LCD_Data(0x00);
   LCD_Data(0x81);
   LCD_Data(0x30);
   LCD_Cmd(CMD_PWR_CTRL_1);
   LCD_Data(0x26);                 //power control 1
   LCD_Data(0x04);                 //second param for ILI9340 (ignored by ILI9341)
   LCD_Cmd(CMD_PWR_CTRL_2);
   LCD_Data(0x11);                 //power control 2
   LCD_Cmd(CMD_VCOM_CTRL_1);
   LCD_Data(0x35);
   LCD_Data(0x3E);                 //VCOM control 1
   LCD_Cmd(CMD_MEM_ACC_CTRL);
   LCD_Data(0xA8);                 //memory access control = BGR and flip col&add
   LCD_Cmd(CMD_FRAME_RATE_CTRL);
   LCD_Data(0x00);
   LCD_Data(0x18);                 //frame rate control
   LCD_Cmd(CMD_DISP_FUNC_CTRL);
   LCD_Data(0x0A);
   LCD_Data(0xA2);                 //display function control
   LCD_Cmd(CMD_VCOM_CTRL_2);
   LCD_Data(0xBE);                 //VCOM control 2
   LCD_Cmd(CMD_PIXEL_FORMAT);
   LCD_Data(0x55);                 //pixel format = 16 bit per pixel
   LCD_Cmd(GAMMA_CONTROL);         //3g gamma control
   LCD_Data(0x02);                 //off
   LCD_Cmd(GAMMA_CURVE);           //gamma curve 3
   LCD_Data(0x01);
   LCD_Cmd(COLUMN_ADDRESS);
   LCD_Data(0x00);                 //column address set
   LCD_Data(0x00);                 //start 0x0000
   LCD_Data(0x00);
   LCD_Data(0xEF);                 //end 0x00EF
   LCD_Cmd(PAGE_ADDRESS);
   LCD_Data(0x00);                 //page address set
   LCD_Data(0x00);                 //start 0x0000
   LCD_Data(0x01);
   LCD_Data(0x3F);                 //end 0x003F
   LCD_Cmd(CMD_MEM_ACC_CTRL);
   LCD_Data(CMD_MEM_ACC_DATA);
   LCD_Cmd(CMD_PIXEL_FORMAT);
   LCD_Data(0xC5);
   LCD_Cmd(CMD_DISPON);            //display ON
   delay(100);          // Wait 10ms

   LCD_Fill(WHITE);        // Draw Background

  /****************************************************************/
  /*          Touch SPI + Interrupt Init          */
  /****************************************************************/
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);    // SPI Touch Controller
  //Set SPI Pins as Alternate Function
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);        //Connect SPI Pin CLK to SPI1
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);        //Connect SPI Pin MOSI to SPI1
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);        //Connect SPI Pin MISO to SPI1

  GPIO_InitStruct.GPIO_Pin = TCH_CLK | TCH_MISO  | TCH_MOSI;          // CLK | MISO
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;            // Alternative Function -> SPI
  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  //SPI Communication Init
  SPI_InitTypeDef SPI_InitStruct;
  SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;  //656.25kHz  (84MHz/128)
  SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;    //Full Duplex
  SPI_InitStruct.SPI_Mode = SPI_Mode_Master;              //Master
  SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;            //8bit
  SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;                //Software Chip Select
  SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;            //MSB first
  SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;              //Clock Idle High
  SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge;              //2nd Edge -> L->H -> Rising edge
  SPI_Init(SPI1, &SPI_InitStruct);                  //Setup SPI1
  SPI_Cmd(SPI1, ENABLE);                        //Enable SPI1

   RESTART_SPI:

   TscWrite (STMPE811_SPI_CFG, 1, STMPE811_SPI_MODE_1 | STMPE811_AUTO_INCR);//STMPE811_SPI_MODE_2 | STMPE811_AUTO_INCR); //MODE 1 and 2 WORKS

   TscRead(STMPE811_CHIP_ID, 2);  // read chip ID
   if((SPI_Buffer[0] != 0x08))      // if not good -> big problem
   {
     goto RESTART_SPI;
   }
   if((SPI_Buffer[1] != 0x11)){
     goto RESTART_SPI;
   }

   // Enable TSC,and set TSC operating mode is X, Y only.
   TscWrite (STMPE811_TSC_CTRL, 1, STMPE811_TSC_CTRL_EN | STMPE811_TSC_CTRL_XY);
   // Enable TSC and ADC
   TscWrite (STMPE811_SYS_CTRL2, 1, STMPE811_CTRL2_TS_OFF |
                    STMPE811_CTRL2_GPIO_OFF);
   // Enable Touch detect, FIFO interrupt.
   TscWrite (STMPE811_INT_EN, 1, STMPE811_INT_EN_TOUCHDET |
                 STMPE811_INT_EN_TH |
                 STMPE811_INT_EN_FIFOOFLOW);
   // To select sample time, bit number and ADC reference.
   TscWrite (STMPE811_ADC_CTRL1, 1, ((0x06 & STMPE811_ADC_CTRL1_SAMPLE_M)
                    << STMPE811_ADC_CTRL1_SAMPLE_S )|
                    STMPE811_ADC_CTRL1_MOD);
   // To select the ADC clock speed is 3.25 MHz.
   TscWrite (STMPE811_ADC_CTRL2, 1, STMPE811_ADC_CTRL2_CLK1);
   // To set Average, Touch Detect Delay and Setting Time setting.
   TscWrite (STMPE811_TSC_CFG, 1,
       STMPE811_TSC_CFG_AVE_8|
        ((0x7 & STMPE811_TSC_CFG_DELAY_M) << STMPE811_TSC_CFG_DELAY_S)|
        ((0x1 & STMPE811_TSC_CFG_SETTING_M)
        << STMPE811_TSC_CFG_SETTING_S));
   // Set FIFO threshold level.
   TscWrite (STMPE811_FIFO_TH, 1, 0x01);
   // Reset FIFO.
   TscWrite (STMPE811_FIFO_STA, 1, STMPE811_FIFO_STA_RESET);
   // Write 0x00 to put the FIFO back into operation mode.
   TscWrite (STMPE811_FIFO_STA, 1, 0x00);
   // Set the data format for Z value.
   TscWrite (STMPE811_TSC_FRACTION_Z, 1,
          (0x07 * STMPE811_FRACTION_Z_M) << STMPE811_FRACTION_Z_S);
   // Set the driving capability of the device for touchscreen controller pins.
   TscWrite (STMPE811_TSC_I_DRIVE, 1, STMPE811_TSC_I_DRIVE_50);
   // Set tracking index, set touchscreen controller op. mode and enable TSC

   TscWrite (STMPE811_TSC_CTRL, 1,STMPE811_TSC_CTRL_EN |STMPE811_TSC_CTRL_XY);
   // Clear all the interrupt status.
   TscWrite (STMPE811_INT_STA, 1, 0xFF);
   // Set interrupt mode and enable interrupt.
   TscWrite (STMPE811_INT_CTRL, 1, STMPE811_INT_TYPE|
            STMPE811_INT_GLOBAL);

   //CHECK IF VALUES OF TC REGISTERS CORRECTLY WRITTEN
   TRYAGAIN:
   SPI_Buffer[0]=0;
   TscRead(STMPE811_ID_VER, 1);    //Check SPI communication by asking for Chip ID x03
   if(SPI_Buffer[0]!= 0x03){
     goto TRYAGAIN;
   }

   // set display backlight
   uint16_t backlight = 0;
   while(backlight < 2100){
     backlight+=4;
     TIM_SetCompare1(TIM4, backlight);  // Set duty cycle to 100%
     delay(10);  //1ms
   }
 }

Kann man mit dem STM32F4 die Dateiumwandlung von jpeg in bmp vornehmen?
Oder muss ich dafür das Bild zuerest auf den PC Laden um eine 
Bitmapdatei zu erstellen?

Mfg

[Thomas F. (igel)]

clincii schrieb:
> LCD_Fill(WHITE);        // Draw Background

Da hast du doch schon eine Routine um ein Bild auszugeben. Das Bild ist 
halt derzeit lediglich einfarbig.
Das kannst du jetzt für ein BMP umschreiben.

[Markus S. (acepilot)]

Laut deiner Initialiserung benutzt du den 16Bit Modus. Das Bild würde 
ich vorher schon am PC in ein Bitmap wandeln. Achte darauf das es auch 
dort schon direkt 16Bit hat. Danach kannst du einfach Pixel für Pixel 
des Bildes an das LCD schicken.

Habe dir mal auszugsweise zwei Funktionen von mir angehängt, die ich für 
mein ILI9341 Display nutze. Vielleicht hilft dir das ja schon weiter.

//--------------------------------------------------------------
// Zeichnet ein Pixel mit einer Farbe an x,y Position
//--------------------------------------------------------------
void LCD_DrawPixel(int16_t xpos, int16_t ypos, uint16_t color)
{
  uint8_t hi,lo;

  LCD_SetWindow(xpos,ypos,xpos,ypos);

  hi=color>>8;
  lo=color&0xFF;

  P_LCD9341_CMD(0x2C);
  P_LCD9341_DATA(hi);
  P_LCD9341_DATA(lo);

}


//--------------------------------------------------------------
// stellt ein Display-Fenster zum zeichnen ein
// von xtart,ystart zu xend,yend
//--------------------------------------------------------------
void LCD_SetWindow(uint16_t xstart, uint16_t ystart, uint16_t xend, uint16_t yend)
{
  uint8_t hi1,lo1;
  uint8_t hi2,lo2;

  hi1=xstart>>8;
  lo1=xstart&0xFF;

  hi2=xend>>8;
  lo2=xend&0xFF;

  P_LCD9341_CMD(0x2A);
  P_LCD9341_DATA(hi1);
  P_LCD9341_DATA(lo1);
  P_LCD9341_DATA(hi2);
  P_LCD9341_DATA(lo2);

  hi1=ystart>>8;
  lo1=ystart&0xFF;

  hi2=yend>>8;
  lo2=yend&0xFF;

  P_LCD9341_CMD(0x2B);
  P_LCD9341_DATA(hi1);
  P_LCD9341_DATA(lo1);
  P_LCD9341_DATA(hi2);
  P_LCD9341_DATA(lo2);
}

//--------------------------------------------------------------
// interne Funktion
// Kommando per SPI an Display senden
//--------------------------------------------------------------
void P_LCD9341_CMD(uint8_t wert)
{
  // Kommando
  P_LCD9341_WRX(Bit_RESET);

  // ChipSelect auf Lo
  P_LCD9341_CS(Bit_RESET);

  // Wert senden
  spi_writeByte(wert);
 
  // ChipSelect auf Hi
  P_LCD9341_CS(Bit_SET);
}


//--------------------------------------------------------------
// interne Funktion
// Daten per SPI an Display senden
//--------------------------------------------------------------
void P_LCD9341_DATA(uint8_t wert)
{
  // Data
  P_LCD9341_WRX(Bit_SET);

  // ChipSelect auf Lo
  P_LCD9341_CS(Bit_RESET);

  // Wert senden
  spi_writeByte(wert);

  // ChipSelect auf Hi
  P_LCD9341_CS(Bit_SET);
}

[dasrotemopped (Gast)]

Erster Treffer bei Google :

Code für Copy+Paste:
http://stm32f4-discovery.net/2014/04/library-08-ili9341-lcd-on-stm32f429-discovery-board/

Gruß,

dasrotemopped.

[Dauergast (Gast)]

dasrotemopped schrieb:
> 
http://stm32f4-discovery.net/2014/04/library-08-ili9341-lcd-on-stm32f429-discovery-board/

Irgendeine Bibliothek wird ja schon benutzt (siehe LCD_Fill() im 
Init-Code). Da die für den ILI9341 alle irgendwie "gleich" aussehen, 
würde ich mal wetten, daß das schon alles vorhanden ist :-)

Irgendwo gibt es sicher auch schon eine BMP_to_ILI9341-Funktion, die 
kann man einfach finden und benutzen, denn das Anzeigen eines statischen 
Bildes auf dem Display eines Funkgerätes dürfte ja sowieso nicht das 
endgültige Ziel sein.

[clincii (Gast)]

Dauergast schrieb:
> denn das Anzeigen eines statischen
> Bildes auf dem Display eines Funkgerätes dürfte ja sowieso nicht das
> endgültige Ziel sein.

Stimmt, schlussundendlich sollte ich dann mit einem Funkgerät ein Foto 
aufnehmen können und an das andere Funkgerät schicken. Das Bild wird auf 
dem Display angezeigt sowie auf einer SD-Karte abgespeichert.
Dasselbe gilt für die SMS-Funktion

Dauergast schrieb:
> Irgendeine Bibliothek wird ja schon benutzt (siehe LCD_Fill() im
> Init-Code). Da die für den ILI9341 alle irgendwie "gleich" aussehen,
> würde ich mal wetten, daß das schon alles vorhanden ist :-)

Das habe ich mir auch schon gedacht, dass ich eigentlich diese Funktion 
nehmen kann. Jedoch verstehe ich nicht genau wie ich dann die einzelnen 
Pixel des Bitmaps ans Display schicken kann.
Klar bei einem Bitmap welches total weiss ist, ist dies kein Problem.

Hier findet ihr noch die Funktion LCD_FILL

void LCD_Fill(uint16_t color)
{
  uint16_t  column;    // column counter
  uint16_t  page;       // pages counter
  uint8_t colorH, colorL;
  colorH = color >> 8;
  colorL = color;

  //TODO: put this in a function
  //Part 1 Bitswap
  uint16_t swap_colH_1 = colorH;
  swap_colH_1 = (swap_colH_1 & 0xF0)>>4 | (swap_colH_1 & 0x0F)<<4;
  swap_colH_1 = (swap_colH_1 & 0xCC)>>2 | (swap_colH_1 & 0x33)<<2;
  swap_colH_1 = (swap_colH_1 & 0xAA)>>1 | (swap_colH_1 & 0x55)<<1;
  swap_colH_1 &=  0x0007;

  uint16_t swap_colH_2 = colorH;
  swap_colH_2 = ((swap_colH_2 >> 8) & 0x00FF) | ((swap_colH_2 << 8) & 0xFF00);
  swap_colH_2 = ((swap_colH_2 >> 4) & 0x0F0F) | ((swap_colH_2 << 4) & 0xF0F0);
  swap_colH_2 = ((swap_colH_2 >> 2) & 0x3333) | ((swap_colH_2 << 2) & 0xCCCC);
  swap_colH_2 = ((swap_colH_2 >> 1) & 0x5555) | ((swap_colH_2 << 1) & 0xAAAA);
  swap_colH_2 = (swap_colH_2 >> 3);
  swap_colH_2 &= 0x1F00;

  uint16_t colorH_swapped_1 = GPIO_ReadOutputData(GPIOB);
  uint16_t colorH_swapped_2 = GPIO_ReadOutputData(GPIOE);
  colorH_swapped_1 = swap_colH_1 | (colorH_swapped_1 & 0xFFF8);
  colorH_swapped_2 = swap_colH_2 | (colorH_swapped_2 & 0xE0FF);

  //Part 2 Bitswap
  uint16_t swap_colL_1 = colorL;
  swap_colL_1 = (swap_colL_1 & 0xF0)>>4 | (swap_colL_1 & 0x0F)<<4;
  swap_colL_1 = (swap_colL_1 & 0xCC)>>2 | (swap_colL_1 & 0x33)<<2;
  swap_colL_1 = (swap_colL_1 & 0xAA)>>1 | (swap_colL_1 & 0x55)<<1;
  swap_colL_1 &=  0x0007;

  uint16_t swap_colL_2 = colorL;
  swap_colL_2 = ((swap_colL_2 >> 8) & 0x00FF) | ((swap_colL_2 << 8) & 0xFF00);
  swap_colL_2 = ((swap_colL_2 >> 4) & 0x0F0F) | ((swap_colL_2 << 4) & 0xF0F0);
  swap_colL_2 = ((swap_colL_2 >> 2) & 0x3333) | ((swap_colL_2 << 2) & 0xCCCC);
  swap_colL_2 = ((swap_colL_2 >> 1) & 0x5555) | ((swap_colL_2 << 1) & 0xAAAA);
  swap_colL_2 = (swap_colL_2 >> 3);
  swap_colL_2 &= 0x1F00;

  uint16_t colorL_swapped_1 = GPIO_ReadOutputData(GPIOB);
  uint16_t colorL_swapped_2 = GPIO_ReadOutputData(GPIOE);
  colorL_swapped_1 = swap_colL_1 | (colorL_swapped_1 & 0xFFF8);
  colorL_swapped_2 = swap_colL_2 | (colorL_swapped_2 & 0xE0FF);

  //--------------------------------------------------------------------------
  LCD_Cmd(COLUMN_ADDRESS);            // column address set
  LCD_Data(0x00);                     // start address
  LCD_Data(0x00);                     // is 0
  LCD_Data((LCD_WIDTH-1) >> 8);       // end address
  LCD_Data((LCD_WIDTH-1));            //
  //--------------------------------------------------------------------------
  LCD_Cmd(PAGE_ADDRESS);              // page address set
  LCD_Data(0x00);                     // start address
  LCD_Data(0x00);                     // is 0
  LCD_Data((LCD_HEIGHT-1) >> 8);      // end address
  LCD_Data((LCD_HEIGHT-1));           //
  //--------------------------------------------------------------------------
  LCD_Cmd(MEMORY_WRITE);              // write data command
  for(column=0; column<LCD_HEIGHT; column++)
  {
  for(page=0; page<LCD_WIDTH; page++)
  {
    GPIO_Write(GPIOB , colorH_swapped_1);    // Values from PB0 to PB2 (Display)
    GPIO_Write(GPIOE , colorH_swapped_2);    // Values from PE8 to PE12 (Display)
    GPIO_ResetBits(GPIOE , LCD_WRITE);    // Enable the Write mode
    GPIO_SetBits(GPIOE , LCD_WRITE);      // Disable the Write mode

    GPIO_Write(GPIOB , colorL_swapped_1);    // Values from PB0 to PB2 (Display)
    GPIO_Write(GPIOE , colorL_swapped_2);    // Values from PE8 to PE12 (Display)
    GPIO_ResetBits(GPIOE , LCD_WRITE);    // Enable the Write mode
    GPIO_SetBits(GPIOE , LCD_WRITE);      // Disable the Write mode
    }
  }
}

[Thomas F. (igel)]

dasrotemopped schrieb:
> Erster Treffer bei Google :
>
> Code für Copy+Paste:
> 
http://stm32f4-discovery.net/2014/04/library-08-ili9341-lcd-on-stm32f429-discovery-board/

Und in diesem Fall unnütz da diese Lib SPI verwendet, der TO aber die 
Daten parallel überträgt.

[clincii (Gast)]

Hätte noch eine Frage bezüglich der Umwandlung von JPEG in BMP,
die Kamera nimmt das Bild im JPEG-Format auf, das Display kann jedoch 
nur Bitmapdateien verarbeiten. Kann man das Format mit dem STM32F4 
softwaremässig ändern oder muss ich dafür das Bild auf den PC laden um 
es dann dort zu ändern.

Wenn man es softwaremässig ändern kann, was ich erwarte, wie genau wird 
das Format geändert? Gibts dafür eine fertige Funktion oder muss man 
selber eine Funktion schreiben?

Mfg

[Cyblord -. (cyblord)]

clincii schrieb:
> Wenn man es softwaremässig ändern kann, was ich erwarte, wie genau wird
> das Format geändert? Gibts dafür eine fertige Funktion oder muss man
> selber eine Funktion schreiben?

Deinen Fragen nach zu Urteilen ist das Projekt drei Nummern zu groß für 
dich.

Such doch einfach mal nach Grafik Libs für den STM32F4.

Wenn aber die Umwandlung per PC eine Option ist, mach das.

Vor allem, mach doch mal bitte einen Schritt nach dem anderen. Wenn du 
dein BMP Bild erfolgreich auf dem Display hast, DANN kannst du dir doch 
überlegen wie du nun aus deinem JPEG ein BMP bastelst.

[clincii (Gast)]

Cyblord -. schrieb:
> Deinen Fragen nach zu Urteilen ist das Projekt drei Nummern zu groß für
> dich.

Wie gesagt, es ist das Projekt der letztjährigen Lehrlinge welches ich 
nun beenden muss..

Cyblord -. schrieb:
> Wenn aber die Umwandlung per PC eine Option ist, mach das.

Leider ist dies keine mögliche Funktion im Endprodukt, ansonsten hätte 
ich dies so gemacht..

[Cyblord -. (cyblord)]

clincii schrieb:
> Cyblord -. schrieb:
>> Deinen Fragen nach zu Urteilen ist das Projekt drei Nummern zu groß für
>> dich.
>
> Wie gesagt, es ist das Projekt der letztjährigen Lehrlinge welches ich
> nun beenden muss..

Ändert an der Tatsache ja nichts.

[clincii (Gast)]

Cyblord -. schrieb:
> clincii schrieb:
>> Cyblord -. schrieb:
>>> Deinen Fragen nach zu Urteilen ist das Projekt drei Nummern zu groß für
>>> dich.
>>
>> Wie gesagt, es ist das Projekt der letztjährigen Lehrlinge welches ich
>> nun beenden muss..
>
> Ändert an der Tatsache ja nichts.

Klar, jedoch kann ich wohl schlecht meinem Chef sagen, dass ich es nicht 
machen werde weil es zu schwierig ist.. oder was denkst du?

[John D. (Gast)]

clincii schrieb:
>
> Klar, jedoch kann ich wohl schlecht meinem Chef sagen, dass ich es nicht
> machen werde weil es zu schwierig ist.. oder was denkst du?

Wow, das ist gar kein Schul- oder Uni-Projekt? Dann liegt der Fehler 
nicht nur bei dir, sondern auch bei deinem Chef - offensichtlich schätzt 
er deine Fähigkeiten falsch ein. Bevor euch beiden das auf den Kopf 
fällt: Mach' ihm klar, was du kannst und was nicht!

[Cyblord -. (cyblord)]

clincii schrieb:
> Klar, jedoch kann ich wohl schlecht meinem Chef sagen, dass ich es nicht
> machen werde weil es zu schwierig ist.. oder was denkst du?

Naja eine Aufgabe die 3 Nummern zu groß ist kann und sollte man so auch 
gegenüber dem Chef kommunizieren. Wenn mein Chef heute her kommt und 
verlangt dass ich bis nächste Woche ein Space Shuttle baue muss ich da 
leider auch passen.
Außerdem hören sich deine Ausführungen schon eher so an, als ob das 
ganze Fach nicht deines ist. Bist du denn Fachkraft in einem Bereich? 
Oder auch Lehrling?

[Thomas F. (igel)]

clincii schrieb:
> meinem Chef sagen, dass ich es nicht machen werde weil es
> zu schwierig ist..

Das sagt man dann in Business-Speech: Das Projekt verzögert sich 
erheblich da die bisherige Software nur rudimentär funktioniert, du dich 
in dieses fremdes Projekt erst noch einarbeiten musst, wichtige 
Software-Komponenten noch fehlen und erst beschafft werden müssen was ja 
eigentlich eher die Aufgabe eines Softwerkers und gar nicht deine ist.

[clincii (Gast)]

Cyblord -. schrieb:
> Außerdem hören sich deine Ausführungen schon eher so an, als ob das
> ganze Fach nicht deines ist. Bist du denn Fachkraft in einem Bereich?
> Oder auch Lehrling?

Bin noch in der Ausbildung..

Thomas F. schrieb:
> Das sagt man dann in Business-Speech: Das Projekt verzögert sich
> erheblich da die bisherige Software nur rudimentär funktioniert, du dich
> in dieses fremdes Projekt erst noch einarbeiten musst, wichtige
> Software-Komponenten noch fehlen und erst beschafft werden müssen was ja
> eigentlich eher die Aufgabe eines Softwerkers und gar nicht deine ist.

Eigentlich sollten ich dies mit dem Informatiklehrling zusammen beenden, 
wie es die letztjährigen Lehrlinge konnten. Jedoch gibt es dieses Jahr 
kein Informatiklehrling mehr. Dadurch muss ich diese Arbeit übernehmen.

[Draco (Gast)]

clincii schrieb:
> Eigentlich sollten ich dies mit dem Informatiklehrling zusammen beenden,
> wie es die letztjährigen Lehrlinge konnten. Jedoch gibt es dieses Jahr
> kein Informatiklehrling mehr. Dadurch muss ich diese Arbeit übernehmen.

Gnihihi... Unsere Putzfrau macht nun auch die Arbeit unseres 
Projektmanagers weil er im Urlaub ist :-D

Tu dir selber einen gefallen! Wende dich mit diesem Problem an deinen 
Chef, sage das dies nicht in deinen Fähigkeitsbereich fällt, es sei 
denn, du bekommst jemanden zur Seite gestellt der dich darin einweisen / 
einlernen kann.

Wenn du es durchziehen willst, dann lerne dir die absoluten Grundlagen 
der µC Programmierung an. Es ist schade das dies Display schon 
initialisiert ist, denn normalerweise lernt man mit sowas umzugehen wenn 
man mit Null anfängt damit zu arbeiten. Da versteht man die Arbeitsweise 
des Displays erstmal. Du hast Glück, da gibt es sehr ausführliche Dokus 
zu deinem Display - lerne sie, verstehe sie, und mach einen Schritt nach 
dem anderen!

Nimm es mir nicht übel, du schaffst es nicht eine Routine zu schreiben 
um eine Linie oder Text auszugeben - musst du auch nicht - du bist ja 
kein Programmierer - aber greifst nach den Sternen und willst ein JPEG 
aufnehmen, umwandeln und ausgeben. Und das in einem bereits teilfertigen 
Produkt, wo man nicht mal selbst seine Struktur aufgebaut hat. Du kommst 
da auch nicht mit nem Copy'and'Paste weiter. Weil es ja doch etwas 
spezielleres ist.

Sprich mit deinem Cheff, frag ihn nach Hilfe - sollte er "komisch" 
werden, überlege ob es denn die Firma ist in der du Zukünftig arbeiten 
willst!

[proggen (Gast)]

Musst du das Ganze in absehbarer Zeit fertig stellen oder ist das ein 
"mach das mal nebenher"-Projekt?

Bei ersterem mach was die anderen dir schon geraten haben und wende dich 
an deinen Chef und zeige ihm deine Situation auf. Du musst ihm ja nicht 
sagen das du es nicht kannst, sondern das du mehr Zeit zum einarbeiten 
und/oder ein wenig Hilfe von jemand mit Erfahrung brauchst.

Sollte eher letzteres der Fall sein und du ein wenig Interesse auf dem 
Gebiet hast was dazu zu lernen, dann sieh es als Einstieg in ein schönes 
Hobby :) Aber trotzdem würde ich an deiner Stelle dem Chef 
kommunizieren, dass du auf dem Gebiet noch unwissend bist.

Fang am besten an den vorhandenen Code zu verstehen und versuch erst 
danach selber was zu machen. Bekomm raus welche library deine Vorgänger 
benutzt haben und such nach Dokumentationen dazu bzw. schau nach wie die 
Sources der library kommentiert sind.

Ich bin jetzt mal davon ausgegangen, dass du bereits etwas Erfahrung 
beim Programmieren von µC hast...