HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r67:604c231d911c

Sync, Still trying to solve 8bits ILI9328 read problems.

jeandet -

r67:604c231d911c dev_alexis

parent child

Context file:

r67:604c231d911c

Collapse all files

bsp/src/OPLAYER/bsp.c +36 -48

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_fsmc.h>
             #include <i2c.h>
             #include <core.h>
             #include <terminal.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             LCD_IF_t lcdIF0={
                 .init = &bsp_FSMC_init,
                 .writereg = &bsp_lcd0_write_reg,
                 .readreg = &bsp_lcd0_read_reg,
                 .writeGRAM = &bsp_lcd0_writeGRAM,
                 .readGRAM = &bsp_lcd0_readGRAM
             };
             LCD_t lcd0={
                 .interface = &lcdIF0,
                 .init = &ili9328init,
                 .paint = &ili9328paint,
                 .paintText = &ili9328paintText,
                 .paintFilRect = &ili9328paintFilRect,
                 .getPix = &ili9328getPix,
                 .refreshenable = &ili9328refreshenable,
                 .width= 240,
                 .height = 320
             };
             terminal_t terminal0;
-            volatile uint8_t* lcd0_CMD=(volatile uint8_t*)0x60000000;
+            volatile int8_t* lcd0_CMD=(volatile int8_t*)0x60000000;
-            volatile uint8_t* lcd0_DATA=(volatile uint8_t*)0x61FFFFF0;
+            volatile int8_t* lcd0_DATA=(volatile int8_t*)0x61FFFFF0;
             float VREF0 =(float)3.3;
             volatile vs10XXDev audioCodec0;
             sdcardDev sdcard2;
             blkdevice sdcard2blkdev;
             dikpartition sdcard2Part1;
             FAT32fs sdcard2FAT32part1;
             dikpartition sdcard2Part2;
             FAT32fs sdcard2FAT32part2;
             dikpartition sdcard2Part3;
             FAT32fs sdcard2FAT32part3;
             dikpartition sdcard2Part4;
             FAT32fs sdcard2FAT32part4;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<__MAX_OPENED_FILES__;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 bsp_spi_init();
                 bsp_SD_init();
                 bsp_Audio_init();
                 printf("\r=====================\n\r");
                 printf(  "=====================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf(  "=====================\n\r");
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 printf(  "BIG ENDIAN MACHINE\n\r");
             #else
                 printf(  "LITLE ENDIAN MACHINE\n\r");
             #endif
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t GPIO_Out_init_List[]={LED1,LED2,LCD_RESET,LCD_BACKL,VS1053xCS,VS1053xDCS,VS1053xRESET,SDCARD2CS};
                 for(int i=0;i<8;i++)
                 {
                     gpio_t GPIO_init = gpioopen(GPIO_Out_init_List[i]);
                     GPIO_init |=  gpiohighspeed | gpiooutdir | gpiopushpulltype;
                     gpiosetconfig(&GPIO_init);
                 }
                 gpio_t GPIO_In_init_List[]={VS1053DREQ,SDCARD2CD,BP3};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t GPIO_init = gpioopen(GPIO_In_init_List[i]);
                     GPIO_init |=  gpiohighspeed | gpioindir;
                     gpiosetconfig(&GPIO_init);
                 }
                 gpioclr(VS1053xRESET);
                 gpioset(VS1053xCS);
                 gpioset(VS1053xDCS);
                 gpioset(SDCARD2CS);
                 gpioclr(LCD_RESET);
                 gpioclr(LCD_BACKL);
             }
             void bsp_uart_init()
             {
                 //    if(__opnfiles__[1]==NULL)
                 //    {
                 //        //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                 //        streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                 //        uart_t uart = uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,115200,PD8,PD9,-1,-1);
                 //        uartmkstreamdev(uart,fd1);
                 //        __opnfiles__[1] = fd1;
                 //    }
                 //    else
                 //    {
                 //        uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,115200,PD8,PD9,-1,-1);
                 //    }
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10
             A20   PE4  = RS      FSMC_NE1 PD7 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             int bsp_FSMC_init()
             {
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
                 gpio_t LCD_DBxList[]={PD14,PD15,PD0,PD1,PE7,PE8,PE9,PE10\
                                       ,PD4,PD5,PD7,PE4};
                 for(int i=0;i<12;i++)
                 {
                     gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]);
                     LCD_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&LCD_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC);
                 }
                 FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
                 FSMC_NORSRAMTimingInitTypeDef  p,readtim;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
                 /*-- FSMC Configuration ------------------------------------------------------*/
                 /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM4 configuration */
-                p.FSMC_AddressSetupTime = 0xf;
+                p.FSMC_AddressSetupTime = 3;
-                p.FSMC_AddressHoldTime = 0xf;
+                p.FSMC_AddressHoldTime = 3;
                 //ili9328 -> data setup time > 10ns
-                p.FSMC_DataSetupTime = 0xf;
+                p.FSMC_DataSetupTime = 1;
                 if(getCpuFreq()>100*1000*1000)
-                    p.FSMC_DataSetupTime = 0xf;// 11;
+                    p.FSMC_DataSetupTime = 2;// 11;
-                p.FSMC_BusTurnAroundDuration = 0xf;
+                p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
-                p.FSMC_DataLatency = 0xf;
+                p.FSMC_DataLatency = 0;
                 //ili9328 -> data hold time > 15ns
                 if(getCpuFreq()>66*1000*1000)
-                    p.FSMC_DataLatency = 0xf;
+                    p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
-                readtim.FSMC_AddressSetupTime = 0xf;
-                readtim.FSMC_AddressHoldTime = 0xf;
-                //p.FSMC_DataSetupTime = 9;
-                readtim.FSMC_DataSetupTime = 0xf ;// 11;
-                if(getCpuFreq()>100*1000*1000)
-                    readtim.FSMC_DataSetupTime = 0xf;// 11;
-                readtim.FSMC_BusTurnAroundDuration = 0xf;
-                readtim.FSMC_CLKDivision = 0;
-                readtim.FSMC_DataLatency = 0xf;
-                if(getCpuFreq()>66*1000*1000)
-                    readtim.FSMC_DataLatency = 0xf;
-                readtim.FSMC_AccessMode = FSMC_AccessMode_A;
                 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_8b;
                 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_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
-                FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &readtim;
+                FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);
                 gpioset(LCD_RESET);
                 gpioclr(LCD_RESET);
                 delay_100us(500);
                 gpioset(LCD_RESET);
                 delay_100us(500);
                 lcd0.init(&lcd0);
                 gpioset(LCD_BACKL);
                 return 1;
             }
             void bsp_spi_init()
             {
                 gpio_t VSSPI_DBxList[]={VS1053SCK,VS1053MOSI,VS1053MISO};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t SPI_DBx = gpioopen(VSSPI_DBxList[i]);
                     SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SPI_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI1);
                 }
                 spiopenandconfig(VS1053SPI,spi8bits|spimaster|spimsbfirst,2*1000*1000,VS1053MOSI,VS1053MISO,VS1053SCK,-1);
                 gpio_t SDSPI_DBxList[]={SDCARD2SCK,SDCARD2MOSI,SDCARD2MISO};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t SPI_DBx = gpioopen(SDSPI_DBxList[i]);
                     SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SPI_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI3);
                 }
                 spiopenandconfig(SDCARD2SPI,spi8bits|spimaster|spimsbfirst,400*1000,SDCARD2MOSI,SDCARD2MISO,SDCARD2SCK,-1);
             }
             void bsp_iic_init()
             {
                 // i2copenandconfig(i2c2,0,10000,PF0,PF1);
             }
             void bsp_Audio_init()
             {
                 vs10XXopen(&audioCodec0,VS1053SPI,vs1052setXCS,vs1052setRST,vs1052setXDCS,vs10XXDREQ);
                 if(audioCodec0.VERSION!=UNKNOWN)
                 {
                     printf("detected Audio codec ");
                     switch (audioCodec0.VERSION) {
                     case VS1001:
                         printf("VS1001\n");
                         break;
                     case VS1011:
                         printf("VS1011\n");
                         break;
                     case VS1002:
                         printf("VS1002\n");
                         break;
                     case VS1003:
                         printf("VS1003\n");
                         break;
                     case VS1053:
                         printf("VS1053\n");
                         break;
                     case VS1033:
                         printf("VS1033\n");
                         break;
                     case VS1103:
                         printf("VS1103\n");
                         break;
                     default:
                         printf("Unknown device\n");
                         break;
                     }
                 }
             }
             void bsp_SD_init()
             {
                 if(bspsdcardpresent())
                 {
                     sdcardspimake(&sdcard2,(UHANDLE)SDCARD2SPI,spigetnc,spiputnc,spisetspeed,spigetspeed);
                     sdcardspimakeblkdev(&sdcard2blkdev,&sdcard2,bspsdcardselect,bsppowersdcard,bspsdcardpresent,bspsdcardwriteprotected);
                     if(sdcard2blkdev.initialize(&sdcard2blkdev)!=STA_NOINIT)
                     {
                         if(mbropen(&sdcard2blkdev,&sdcard2Part1,1)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part1,&sdcard2Part1))
                                 printf("Can't open fat32 partition 1\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                         delay_100us(1000);
                         if(mbropen(&sdcard2blkdev,&sdcard2Part2,2)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part2,&sdcard2Part2))
                                 printf("Can't open fat32 partition 2\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                         delay_100us(1000);
                         if(mbropen(&sdcard2blkdev,&sdcard2Part3,3)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part3,&sdcard2Part3))
                                 printf("Can't open fat32 partition 3\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                         delay_100us(1000);
                         if(mbropen(&sdcard2blkdev,&sdcard2Part4,4)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part4,&sdcard2Part4))
                                 printf("Can't open fat32 partition 4\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                     }
                     else
                     {
                         printf("Can't initialize SDCARD\n");
                     }
                 }
                 delay_100us(2000);
             }
             void vs1052setXCS(char val)
             {
                 gpiosetval(VS1053xCS,(int)val);
             }
             void vs1052setXDCS(char val)
             {
                 //gpiosetval(LED1,(int)val);
                 gpiosetval(VS1053xDCS,(int)val);
             }
             void vs1052setRST(char val)
             {
                 if(val)
                     gpioset(VS1053xRESET);
                 else
                     gpioclr(VS1053xRESET);
             }
             int vs10XXDREQ()
             {
                 return gpiogetval(VS1053DREQ);
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return gpiogetval(SDCARD2CD);
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
                 //   gpiosetval(LED1,(int)YESNO);
                 if(YESNO)
                     gpioclr(SDCARD2CS);
                 else
                     gpioset(SDCARD2CS);
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 uint8_t* pt8  = (uint8_t*)(void*)(&reg);
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)&data;
                 *lcd0_DATA=pt8[3];
                 *lcd0_DATA=pt8[2];
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)&data;
                 *lcd0_DATA=pt8[1];
                 *lcd0_DATA=pt8[0];
             #endif
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 uint8_t* pt8  = (uint8_t*)(void*)(&reg);
                 uint32_t DATA=0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)&DATA;
                 pt8[3]=*lcd0_DATA;
                 pt8[2]=*lcd0_DATA;
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)&DATA;
                 pt8[1]=*lcd0_DATA;
                 pt8[0]=*lcd0_DATA;
             #endif
                 return DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint8_t* pt8  = (uint8_t*)(void*)(&reg);
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=pt8[(2*i) +1];
                     *lcd0_DATA=pt8[2*i];
                 }
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=pt8[(2*i) +1];
                     *lcd0_DATA=pt8[2*i];
                 }
             #endif
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
-                uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
+               //uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
-                volatile uint8_t* pt8  = (uint8_t*)(void*)&reg;
+                volatile uint8_t* pt8 ;// = (uint8_t*)(void*)&reg;
-                *lcd0_CMD=(uint8_t)0;
+            /* #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-                *lcd0_CMD=(uint8_t)0;
-            #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     pt8[(2*i) +1]=*lcd0_DATA;
                     pt8[2*i]=*lcd0_DATA;
                 }
             #else
+                *lcd0_CMD=(uint8_t)0;
+                *lcd0_CMD=(uint8_t)0;
+                *lcd0_CMD=(uint8_t)0;
+                *lcd0_CMD=(uint8_t)0;
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
-                pt8  = (uint8_t*)buffer;
+                pt8  = (uint8_t*)buffer;*/
                 /*
                  * x dummy reads Cf ili9328 datasheet p79!
                 */
-                pt8[0]=*lcd0_DATA;
+               /* pt8[0]=*lcd0_DATA;
                 pt8[1]=*lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     pt8[(2*i) +1]=*lcd0_DATA;
                     pt8[2*i]=*lcd0_DATA;
                     pt8[(2*i) +1]=*lcd0_DATA;
                     pt8[2*i]=*lcd0_DATA;
-                    //        pt8[(2*i) +1]=(uint8_t)0;
-                    //        pt8[(2*i)]=(uint8_t)0;
                 }
-            #endif
+            #endif*/
+                *lcd0_CMD=(uint8_t)0;
+                *lcd0_CMD=(uint8_t)0x22;
+                pt8  = (uint8_t*)buffer;
+                pt8[1]=*lcd0_DATA;
+                pt8[0]=*lcd0_DATA;
+                for(int i=0;i<(int)count;i++)
+                {
+                    //pt8[(2*i) +1]=0;
+                    //pt8[2*i]=0;
+                    pt8[(2*i)+1]= *lcd0_DATA;
+                    pt8[2*i]= *lcd0_DATA;
+                }
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
-                    terminal_init(&terminal0 ,&lcd0,&ComicSansMS_8,fd1);
+                    terminal_init(&terminal0 ,&lcd0,&ComicSansMS_18,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

bsp/src/STM32F4Eval/bsp.c 0 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_fsmc.h>
             #include <i2c.h>
             #include <core.h>
             #include <terminal.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             LCD_IF_t lcdIF0={
                 .init = &bsp_FSMC_init,
                 .writereg = &bsp_lcd0_write_reg,
                 .readreg = &bsp_lcd0_read_reg,
                 .writeGRAM = &bsp_lcd0_writeGRAM,
                 .readGRAM = &bsp_lcd0_readGRAM
             };
             LCD_t lcd0={
                 .interface = &lcdIF0,
                 .init = &ili9328init,
                 .paint = &ili9328paint,
                 .paintText = &ili9328paintText,
                 .paintFilRect = &ili9328paintFilRect,
                 .getPix = &ili9328getPix,
                 .refreshenable = &ili9328refreshenable,
                 .width= 240,
                 .height = 320
             };
             terminal_t terminal0;
             volatile int16_t* lcd0_CMD=(volatile int16_t*)  (0x60000000 | 0x08000000);
             volatile int16_t* lcd0_DATA=((volatile int16_t*)(0x60000000 | 0x08000002));
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 printf("\r=====================\n\r");
                 printf(  "=====================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf(  "=====================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(LED1);
                 gpio_t gpio2 = gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(LED3);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
             }
             void bsp_uart_init()
             {
                 //if(__opnfiles__[1]==NULL)
                 //{
                 //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                 //  streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                 // uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //uartmkstreamdev(uart,fd1);
                 //__opnfiles__[1] = fd1;
                 //}
                 //else
                 //{
                 uartopenandconfig(0,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //}
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10     D8   PE11     D9   PE12
             D10  PE13      D11  PE14      D12  PE15     D13  PD8      D14  PD9
             D15  PD10
             A0   PF0  = RS      FSMC_NE3 PG10 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             /*-- GPIOs Configuration -----------------------------------------------------*/
             /*
              +-------------------+--------------------+------------------+------------------+
              +                       SRAM pins assignment                                   +
              +-------------------+--------------------+------------------+------------------+
              | PD0  <-> FSMC_D2  | PE0  <-> FSMC_NBL0 | PF0  <-> FSMC_A0 | PG0 <-> FSMC_A10 |
              | PD1  <-> FSMC_D3  | PE1  <-> FSMC_NBL1 | PF1  <-> FSMC_A1 | PG1 <-> FSMC_A11 |
              | PD4  <-> FSMC_NOE | PE3  <-> FSMC_A19  | PF2  <-> FSMC_A2 | PG2 <-> FSMC_A12 |
              | PD5  <-> FSMC_NWE | PE4  <-> FSMC_A20  | PF3  <-> FSMC_A3 | PG3 <-> FSMC_A13 |
              | PD8  <-> FSMC_D13 | PE7  <-> FSMC_D4   | PF4  <-> FSMC_A4 | PG4 <-> FSMC_A14 |
              | PD9  <-> FSMC_D14 | PE8  <-> FSMC_D5   | PF5  <-> FSMC_A5 | PG5 <-> FSMC_A15 |
              | PD10 <-> FSMC_D15 | PE9  <-> FSMC_D6   | PF12 <-> FSMC_A6 | PG9 <-> FSMC_NE2 |
              | PD11 <-> FSMC_A16 | PE10 <-> FSMC_D7   | PF13 <-> FSMC_A7 |------------------+
              | PD12 <-> FSMC_A17 | PE11 <-> FSMC_D8   | PF14 <-> FSMC_A8 |
              | PD13 <-> FSMC_A18 | PE12 <-> FSMC_D9   | PF15 <-> FSMC_A9 |
              | PD14 <-> FSMC_D0  | PE13 <-> FSMC_D10  |------------------+
              | PD15 <-> FSMC_D1  | PE14 <-> FSMC_D11  |
              |                   | PE15 <-> FSMC_D12  |
              +-------------------+--------------------+
             */
             int bsp_FSMC_init()
             {
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
                 gpio_t LCD_DBxList[]={
                     PD0 ,PD1 ,PD4 ,PD5 ,PD8 ,PD9 ,PD10,PD11,PD12,PD13,PD14,PD15,
                     PE0 ,PE1 ,PE3 ,PE4 ,PE7 ,PE8 ,PE9 ,PE10,PE11,PE12,PE13,PE14,
                     PE15,PF0 ,PF1 ,PF2 ,PF3 ,PF4 ,PF5 ,PF12,PF13,PF14,PF15,PG0 ,
                     PG1 ,PG2 ,PG3 ,PG4 ,PG5 ,PG9 ,PG10
                                      };
                 for(int i=0;i<43;i++)
                 {
                     gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]);
                     LCD_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&LCD_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC);
                 }
                 FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
                 FSMC_NORSRAMTimingInitTypeDef  p,readtim;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
                 /*-- FSMC Configuration ------------------------------------------------------*/
                 /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM3 configuration */
                 p.FSMC_AddressSetupTime = 0xf;
                 p.FSMC_AddressHoldTime = 0xf;
                 //ili9328 -> data setup time > 10ns
                 p.FSMC_DataSetupTime = 0xf;
                 if(getCpuFreq()>100*1000*1000)
                     p.FSMC_DataSetupTime = 0xf;// 11;
                 p.FSMC_BusTurnAroundDuration = 0xf;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0xf;
                 //ili9328 -> data hold time > 15ns
                 if(getCpuFreq()>66*1000*1000)
                     p.FSMC_DataLatency = 0xf;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 readtim.FSMC_AddressSetupTime = 0xf;
                 readtim.FSMC_AddressHoldTime = 0xf;
                 //p.FSMC_DataSetupTime = 9;
                 readtim.FSMC_DataSetupTime = 0xf ;// 11;
                 if(getCpuFreq()>100*1000*1000)
                     readtim.FSMC_DataSetupTime = 0xf;// 11;
                 readtim.FSMC_BusTurnAroundDuration = 0xf;
                 readtim.FSMC_CLKDivision = 0;
                 readtim.FSMC_DataLatency = 0xf;
                 if(getCpuFreq()>66*1000*1000)
                     readtim.FSMC_DataLatency = 0xf;
                 readtim.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_NORSRAM3;
                 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_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &readtim;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /* Enable FSMC NOR/SRAM Bank1 */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE);
                 p.FSMC_AddressSetupTime = getCpuFreq()/50000000;
                 p.FSMC_AddressHoldTime = 0;
                 p.FSMC_DataSetupTime = getCpuFreq()/25000000;
                 p.FSMC_BusTurnAroundDuration = 1;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM2;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_PSRAM;
                 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_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /*!< Enable FSMC Bank1_SRAM2 Bank */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM2, ENABLE);
                 lcd0.init(&lcd0);
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
                 i2copenandconfig(i2c1,0,10000,PB9,PB6);
             }
             void bsp_SD_init()
             {
                 gpio_t SDIO_DBxList[]={PC8 ,PC9 ,PC10 ,PC11 ,PC12,PD2};
                 for(int i=0;i<6;i++)
                 {
                     gpio_t SDIO_DBx = gpioopen(SDIO_DBxList[i]);
                     SDIO_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SDIO_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SDIO_DBx), (uint8_t)(SDIO_DBx & 0xF), GPIO_AF_SDIO);
                 }
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 *lcd0_DATA=(uint16_t)data;
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 return (uint16_t)*lcd0_DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=castedBuff[i];
                 }
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 castedBuff[0]=*lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     castedBuff[i]=*lcd0_DATA;
                 }
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
-                    //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     ili9328paintFilRect(&lcd0,0,0,240,320,0x7FFF,5,0);
                     terminal_init(&terminal0,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

examples/SOLAR_PSU_HELLO/hello.pro +1 -1

             TEMPLATE = app
             CONFIG += cpu
             UCMODEL=stm32f4
             BSP = OPLAYER
             #BSP = STM32F4Discovery-ILI9328-8bits
-            DEFINES += CPUFREQ=50000000
+            DEFINES += CPUFREQ=100000000
             SOURCES += \
                 main.c \
                 test_lcd.c

examples/SOLAR_PSU_HELLO/main.c +19 -3

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <core.h>
             #include <VS10XX.h>
             #include <bsp.h>
             #include <spi.h>
             #include <sdcard.h>
             #include <sdcard-spi.h>
             #include <fat32.h>
             #include <ucdirent.h>
             #include <string.h>
             #include <terminal.h>
             #include <ili9328.h>
             extern streamdevice* __opnfiles__[];
             extern void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color);
             extern void test_all_colors(LCD_t* LCD);
             extern void test_small_lines(LCD_t* LCD);
+            extern void test_lines(LCD_t* LCD);
+            extern void test_address(LCD_t* LCD);
             void test_uniform_rw(LCD_t* LCD);
             char buffer[512];
             void randBoxesDemo()
             {
                 int16_t x,y,w,h,t,r;
                 x=rand()%240;
                 y=rand()%320;
                 w=rand()%(240-x);
                 if(x>y)
                     r=(rand()%(y))%(320-y);
                 else
                     r=(rand()%(x))%(240-x);
                 h=rand()%(320-y);
                 t=rand()%(10);
                 ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
                 //ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
                 //delay_100us(10);
                 //for(volatile int i=0;i<(1024*2);i++);
             }
             void randTextDemo()
             {
                 int16_t x,y,w,h,t,r;
                 char buf[2];
                 buf[1]='\0';
                 x=rand()%240;
                 y=rand()%320;
                 if(x>y)
                     r=(rand()%(y))%(320-y);
                 else
                     r=(rand()%(x))%(240-x);
                 h=rand()%(320-y);
                 buf[0]=rand()%(255);
                 //ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
                 ili9328paintText(&lcd0,buf,x,y,&ComicSansMS_18,rand());
                 //ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
                 delay_100us(5000);
                 //for(volatile int i=0;i<(1024*2);i++);
             }
             void tryToplay2()
             {
                 extern blkdevice sdcard2blkdev;
                 int i=0,l=0;
                 spisetspeed(audioCodec0.SPIdev,4000000);
                 printf("Streaming File\n");
                 //printf("New LBA=0x%X\n",nextLba);
                 while(sdcard2blkdev.read(&sdcard2blkdev,buffer,l++,1)==RES_OK)
                 {
                     for(i=0;i<512;i+=32)
                     {
                         vs10XXstream32bytes(&audioCodec0,buffer+i);
                     }
                 }
             }
             void playFile(ucdirent* file,FAT32fs* part)
             {
                 extern volatile vs10XXDev audioCodec0;
                 char direntName[]="                                 \n";
                 uint32_t fileLba,nextLba;
                 int i=0;
                 fat32getdirentname(file,direntName);
                 //gpioset(LCD_BACKL);
                 printf("%s\n",direntName);
                 nextLba=fat32getdirentlba(file);
                 //printf("Streaming File\n");
                 //gpioclr(LCD_BACKL);
                 do
                 {
                     fileLba = nextLba;
                     if(sdcard2FAT32part1.part->phy->read(part->part->phy,buffer,fileLba,1)==RES_OK)
                     {
                         for(i=0;i<512;i+=32)
                         {
                             vs10XXstream32bytes(&audioCodec0,buffer+i);
                         }
                     }
                 }while ((fat32nextsectorlba(part,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
                 vs10XXsoftReset(&audioCodec0);
                 while (gpiogetval(BP3))delay_100us(1000);
             }
             void playAllparts()
             {
                 extern FAT32fs sdcard2FAT32part1,sdcard2FAT32part2,sdcard2FAT32part3,sdcard2FAT32part4;
                 ucdirent root;
                 if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part1,&root))
                 {
                     printf("Reading on SDCARD2 part1\n");
                     if(DIRENT_noErr==fat32getrootfirstent(&root))
                     {
                         do{
                             playFile(&root,&sdcard2FAT32part1);
                         }while (DIRENT_noErr==fat32nextdirent(&root));
                     }
                 }
                 gpioset(LED2);
                 if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part2,&root))
                 {
                     printf("Reading on SDCARD2 part2\n");
                     if(DIRENT_noErr==fat32getrootfirstent(&root))
                     {
                         do{
                             playFile(&root,&sdcard2FAT32part2);
                         }while (DIRENT_noErr==fat32nextdirent(&root));
                     }
                 }
             }
             int main()
             {
                 delay_100us(30000);
                 int i=0;
                 int color=0;
                // test_all_colors(&lcd0);
-                test_small_lines(&lcd0);
+               // test_small_lines(&lcd0);
-                test_uniform_rw(&lcd0);
+               // test_uniform_rw(&lcd0);
                 printf("LCD ID REG = 0x%X\n\r",lcd0.interface->readreg(ILI9328_REGISTER_DRIVERCODEREAD));
-                while(1);
+                printf("LCD ENTRY MODE REG = 0x%X\n\r",lcd0.interface->readreg(ILI9328_REGISTER_ENTRYMODE));
+                uint16_t test[16];
+                for(int i=0;i<16;i++)
+                {
+                    test[i]=0xF00F;
+                }
+                lcd0.paint(&lcd0,test,10,100,4,4);
+                lcd0.getPix(&lcd0,test,10,100,4,4);
+                for(int i=0;i<16;i++)
+                {
+                    printf("@%d=0x%X\n",i,test[i]);
+                }
+            //    test_lines(&lcd0);
+                while(1)test_address(&lcd0);
                 for(i=0;i<240;i++)
                 {
                     if(i>(240/3))
                     {
                         color= (i<<5) + 0x1F;
                     }
                     else
                     {
                         color = i;
                     }
                     if(i>(2*240/3))
                     {
                         color= (i<<10) + 0x3FF;
                     }
                     lcd0.paintFilRect(&lcd0,i,0,1,100,0,0,color);
                 }
                 while(1)printf("test ");
             //    for(i=0;i<240;i++)
             //    {
             //        if(i>(240/3))
             //        {
             //            color= (i<<5) + 0x1F;
             //        }
             //        else
             //        {
             //            color = i;
             //        }
             //        if(i>(2*240/3))
             //        {
             //            color= (i<<10) + 0x3FF;
             //        }
             //        lcd0.paintFilRect(&lcd0,i,220,1,100,0,0,color);
             //    }
                 for(i=0;i<240;i++)
                 {
                     ili9328setFrame(&lcd0,i,0,1,100);
                     lcd0.interface->readGRAM(buffer,100);
                     lcd0.paint(&lcd0,buffer,i,200,1,100);
                 }
                 while(1);
             }
             int main2()
             {
                 extern terminal_t terminal0;
                 extern volatile vs10XXDev audioCodec0;
                 printf("Volume=0x%x\n",vs10XXcmdread(&audioCodec0,VSVOL));
                 vs10XXcmdwrite(&audioCodec0,VSCLOCKF,0x2000);
                 delay_100us(1000);
                 vs10XXcmdwrite(&audioCodec0,VSVOL,0x2020);
                 printf("VSCLOCKF=0x%x\n",vs10XXcmdread(&audioCodec0,VSCLOCKF));
                 printf("VSMODE=0x%x\n",vs10XXcmdread(&audioCodec0,VSMODE));
                 //terminal_clear(&terminal0);
                // gpioclr(LCD_BACKL);
                 playAllparts();
                 return 0;
             }

examples/SOLAR_PSU_HELLO/test_lcd.c +46 -1

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <core.h>
             #include <VS10XX.h>
             #include <bsp.h>
             #include <spi.h>
             #include <sdcard.h>
             #include <sdcard-spi.h>
             #include <fat32.h>
             #include <ucdirent.h>
             #include <string.h>
             #include <terminal.h>
             #include <ili9328.h>
+            uint16_t buff[50*50];
             void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color)
             {
                 LCD->paintFilRect(LCD,x,y,w,h,0,0,color);
             }
             void test_small_lines(LCD_t* LCD)
             {
                int i=0;
                for(i=0;i<LCD->height;i+=2)
                {
                    LCD->paintFilRect(LCD,0,i,LCD->width,1,0,0,0xaa00);
                }
                for(i=1;i<LCD->height;i+=2)
                {
                     LCD->paintFilRect(LCD,0,i,LCD->width,1,0,0,0x5500);
                }
             }
             void test_uniform_rw(LCD_t* LCD)
             {
                 uint16_t buffer[50*50];
                 LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height/2,0,0,0xfaa0);
                 delay_100us(10000);
                 LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,0xfaa0);
                 ili9328setFrame(LCD,10,100,50,50);
                 while(1)
                 {
             //        LCD->interface->readGRAM((void*)buffer,50*50);
                     LCD->getPix(LCD,buffer,10,100,50,50);
                     LCD->paint(LCD,buffer,10,100,50,50);
                     delay_100us(10000);
                     //ili9328setFrame(LCD,10,100,50,50);
                     //LCD->interface->writeGRAM((void*)buffer,50*50);
                 }
             }
             void test_all_colors(LCD_t* LCD)
             {
                 uint16_t color=0;
                 char colorch[]="          ";
                 while(1)
                 {
                     LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,color);
                     sprintf(colorch,"0x%x",0xFFFF & ((int)color));
                     LCD->paintText(LCD,colorch,10,100,&ComicSansMS_18,color^-1);
                     //delay_100us(10);
                     color+=1;
                 }
             }
+            void test_address(LCD_t* LCD)
+            {
+                LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,0xFFFF);
+                uint16_t color[1];
+                for(int y=0;y<320;y++)
+                {
+                    for(int x=0;x<240;x++)
+                    {
+                        color[0]=x*y;
+                        LCD->paint(LCD,color,x,y,1,1);
+                        //delay_100us(100);
+                    }
+                }
+                LCD->getPix(LCD,buff,50,50,50,50);
+                delay_100us(5000);
+                for(int i=0;i<50*50;i++)
+                {
+                    buff[i]=i;
+                }
+                LCD->paint(LCD,buff,50,50,50,50);
+                delay_100us(5000);
+            }
+            void test_lines(LCD_t* LCD)
+            {
+                uint16_t color[2];//=0x0FF0;
+                int x=0;
+                LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,0xFFFF);
+                for(int l=0;l<0xFFFF;l++)
+                {
+                    color[0]=l;
+                    color[1]=l;
+                    for(int i=0;i<320;i++)
+                    {
+                        x=i*240/320;
+                        LCD->paint(LCD,color,x,i,2,1);
+                    }
+                    for(int i=0;i<320;i++)
+                    {
+                        x=239-(i*240/320);
+                        LCD->paint(LCD,color,x,i,2,1);
+                    }
+                }
+            }

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c +60 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #define _PRVATE_ILI9328_
             #include <ili9328.h>
             #include <stdio.h>
             #include <stddef.h>
             #include <core.h>
             #include <math.h>
             #include <stdint.h>
+            #include <malloc.h>
             #ifdef __OPTIMIZED_MATH
             #include <optimised_math.h>
             #endif
             #define ilipaintLine(LCD,X,Y,W,buffer,buffsize) \
                 for(int l=0;l<1;l++)\
             {\
                 ili9328setFrame(LCD,X,Y,W,1);\
                 int rem=(W)%buffsize;\
                 if(rem)LCD->interface->writeGRAM(buffer,rem);\
                 for(int i=rem;i<(W);i+=buffsize)\
             {\
                 LCD->interface->writeGRAM(buffer,buffsize);\
                 }\
                 }
             #define ilipaintHLineWithCont(LCD,X,Y,W,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
             {\
                 ili9328setFrame(LCD,X,Y,W,1);\
                 int rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
             {\
                 LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                 if((2*ContSz)<W) \
             {\
                 rem=(W-(2*ContSz))%buffIntsize;\
                 if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                 for(int i=rem;i<(W-(2*ContSz));i+=buffIntsize)\
             {\
                 LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                 }\
                 }\
                 rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
             {\
                 LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                 }\
             #define ilipaintVLineWithCont(LCD,X,Y,H,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
             {\
                 ili9328setFrame(LCD,X,Y,1,H);\
                 int rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
             {\
                 LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                 if((2*ContSz)<H) \
             {\
                 rem=(H-(2*ContSz))%buffIntsize;\
                 if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                 for(int i=rem;i<(H-(2*ContSz));i+=buffIntsize)\
             {\
                 LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                 }\
                 }\
                 rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
             {\
                 LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                 }\
             #define ilipaintHalfTopVLineWithCont(LCD,X,Y,H,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
             {\
                 ili9328setFrame(LCD,X,Y,1,H);\
                 int rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
             {\
                 LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                 if(ContSz<H) \
             {\
                 rem=(H-ContSz)%buffIntsize;\
                 if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                 for(int i=rem;i<(H-ContSz);i+=buffIntsize)\
             {\
                 LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                 }\
                 }\
                 }\
             #define ilipaintHalfBottomVLineWithCont(LCD,X,Y,H,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
             {\
                 ili9328setFrame(LCD,X,Y,1,H);\
                 int rem;\
                 if(ContSz<H) \
             {\
                 rem=(H-ContSz)%buffIntsize;\
                 if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                 for(int i=rem;i<(H-ContSz);i+=buffIntsize)\
             {\
                 LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                 }\
                 }\
                 rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
             {\
                 LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                 }\
             void ili9328setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress)
             {
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,Haddress);
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,Vaddress);
             }
             void ili9328refreshenable(struct LCD_t* LCD,int enable)
             {
                 if(enable)
                 {
                     //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1018);
                 }
                 else
                 {
                     //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1008);
                 }
             }
             void ili9328setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H)
             {
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)X);
+                if((X>239) || (Y>319) || ((X+W)>240) || ((Y+H)>320))
-                LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)Y);
+                    while (1);
+                }
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,(uint32_t)X);
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,(uint32_t)(W+X-1));
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,(uint32_t)Y);
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,(uint32_t)(Y+H-1));
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)X);
+                LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)Y);
             }
             void ili9328paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height)
             {
-                if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writeGRAM!=NULL) &&  (LCD->width>(Xpos+Width)) && (LCD->height>(Ypos+Height)))
+                if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writeGRAM!=NULL) &&  (LCD->width>=(Xpos+Width)) && (LCD->height>=(Ypos+Height)))
                 {
                     ili9328setFrame(LCD,Xpos,Ypos,Width,Height);
                     LCD->interface->writeGRAM(buffer,Width*Height);
                 }
             }
             void ili9328paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor)
             {
                 //Based on the mid point circle algorithm from Wikipedia
                 //http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
                 uint16_t innerbuffer[16];
                 uint16_t outterbuffer[16];
                 for(int i=0;i<16;i++)innerbuffer[i]=fillColor;
                 for(int i=0;i<16;i++)outterbuffer[i]=contColor;
                 if(contSz<r)
                 {
                     int error = -r,error_int = -r+contSz;
                     int x = r,x_int=r-contSz;
                     int y = 0,y_int=0;
                     while (x >= y)
                     {
                         ilipaintHLineWithCont(LCD,(Xpos-x),(Ypos+y),(2*x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHLineWithCont(LCD,(Xpos-x),(Ypos-y),(2*x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfTopVLineWithCont(LCD,(Xpos+y),(Ypos-x),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfTopVLineWithCont(LCD,(Xpos-y),(Ypos-x),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfBottomVLineWithCont(LCD,(Xpos-y),(Ypos),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfBottomVLineWithCont(LCD,(Xpos+y),(Ypos),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         error += y;
                         ++y;
                         error += y;
                         error_int += y_int;
                         ++y_int;
                         error_int += y_int;
                         if(error >= 0)
                         {
                             error -= x;
                             --x;
                             error -= x;
                         }
                         if(error_int >= 0)
                         {
                             error_int -= x_int;
                             --x_int;
                             error_int -= x_int;
                         }
                     }
                 }
             }
             void ili9328paintFilCirc_old(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor)
             {
                 if(contSz<r)
                 {
                     uint16_t innerbuffer[16];
                     uint16_t outterbuffer[16];
                     int32_t rr=(r*r),rr2=((r-contSz)*(r-contSz)),contSz2,Val1,Val2,X1,W,rem;
                     for(int i=0;i<16;i++)innerbuffer[i]=fillColor;
                     for(int i=0;i<16;i++)outterbuffer[i]=contColor;
                     /* Y = b +/- sqrt[r^2 - (x - a)^2] */
                     for(int32_t line=-r;line<r;line++)
                     {
             #ifdef __OPTIMIZED_MATH
                         Val1 = (uint32_t)optimised_sqrt((float32_t)(rr - (line*line)) );
                         Val2 = (uint32_t)optimised_sqrt((float32_t)(rr2 - (line*line)) );
             #else
                         Val1 = sqrt(  (double)(rr - ((line)*(line))) );
                         Val2 = sqrt(  (double)(rr2 - ((line)*(line))) );
             #endif
                         X1=Xpos - Val1;
                         contSz2= Val1-Val2;
                         ili9328setFrame(LCD,X1,line+Ypos,2*Val1,1);
                         rem=(contSz2)%16;
                         if(rem)LCD->interface->writeGRAM(outterbuffer,rem);
                         for(int i=rem;i<(contSz2);i+=16)
                         {
                             LCD->interface->writeGRAM(outterbuffer,16);
                         }
                         W=2*Val1;
                         if(W>(2*contSz2))
                         {
                             W-=2*contSz2;
                             rem=(W)%16;
                             if(rem)LCD->interface->writeGRAM(innerbuffer,rem);
                             for(int i=rem;i<(W);i+=16)
                             {
                                 LCD->interface->writeGRAM(innerbuffer,16);
                             }
                         }
                         rem=(contSz2)%16;
                         if(rem)LCD->interface->writeGRAM(outterbuffer,rem);
                         for(int i=rem;i<(contSz2);i+=16)
                         {
                             LCD->interface->writeGRAM(outterbuffer,16);
                         }
                     }
                 }
             }
             void ili9328paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor)
             {
                 ili9328setFrame(LCD,Xpos,Ypos,w,h);
                 uint16_t tmp[32];
                 for(int i=0;i<32;i++)tmp[i]=fillColor;
                 for(int i=0;i<(h*w);i+=32)
                 {
                     LCD->interface->writeGRAM(tmp,32);
                 }
                 int rem=(w*h)%32;
                 if(rem)LCD->interface->writeGRAM(tmp,rem);
                 if(contSz)
                 {
                     ili9328setFrame(LCD,Xpos,Ypos,w,contSz);
                     for(int i=0;i<32;i++)tmp[i]=contColor;
                     rem=(w*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(w*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                     ili9328setFrame(LCD,Xpos,Ypos+h-contSz,w,contSz);
                     rem=(w*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(w*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                     ili9328setFrame(LCD,Xpos,Ypos,contSz,h);
                     rem=(h*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(h*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                     ili9328setFrame(LCD,Xpos+w-contSz,Ypos,contSz,h);
                     rem=(h*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(h*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                 }
             }
             void ili9328paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color)
             {
                 int w=font->Width,h=font->Height,bpl=font->bytesPerLine,pix=0,tableoffset=0;
                 uint16_t tmp[w];
                 uint16_t linenum=0,charnum=0;
                 uint8_t line=0;
                 while(*buffer!='\0')
                 {
                     if(*buffer<32)*buffer=32;
                     if(*buffer>127)*buffer=32;
                     ili9328setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1);
                     //        LCD->interface->readGRAM(tmp,w);
                     ili9328getPix(LCD,tmp,Xpos+(charnum*w),Ypos-h,w,1);
                     for(int i=0;i<(h*w);i++)
                     {
                         if( ((i%w)==0) ) //read current line to apply text pixmap
                         {
                             if(linenum++>0)
                             {
                                 ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum -h,w,1);
                                 LCD->interface->writeGRAM(tmp,w);
-                                ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1);
+                                //ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1);
                                 //                    LCD->interface->readGRAM(tmp,w);
                                 ili9328getPix(LCD,tmp,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1);
                                 pix=0;
                             }
                         }
                         if((pix%8) == 0)
                         {
                             line=font->table[(((*buffer)-32)*h*bpl)+tableoffset++];
                         }
                         //tmp[pix]=0;
                         if((line & (uint8_t)0x01)==(uint8_t)1)tmp[pix]=(uint16_t)color;
                         pix++;
                         line>>=1;
                     }
                     linenum=0;
                     tableoffset=0;
                     charnum++;
                     buffer++;
                 }
             }
+            void ili9328paintChar(LCD_t* LCD,char buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color)
+            {
+                int w=font->Width,h=font->Height,bpl=font->bytesPerLine,pix=0,tableoffset=0;
+                uint16_t tmp[w];
+                uint16_t tmp2[w];
+                uint16_t linenum=0,charnum=0;
+                uint8_t line=0;
+                if(buffer<32)buffer=32;
+                if(buffer>127)buffer=32;
+                ili9328setFrame(LCD,Xpos,Ypos-h,w,1);
+                //        LCD->interface->readGRAM(tmp,w);
+                ili9328getPix(LCD,tmp2,Xpos,Ypos-h,w,1);
+                for(int i=0;i<w;i++)
+                {
+                    tmp[i]=0;
+                }
+                for(int i=0;i<(h*w);i++)
+                {
+                    if( ((i%w)==0) ) //read current line to apply text pixmap
+                    {
+                        if(linenum++>0)
+                        {
+                            ili9328setFrame(LCD,Xpos,Ypos + linenum -h,w,1);
+                            LCD->interface->writeGRAM(tmp,w);
+                            //ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1);
+                            //                    LCD->interface->readGRAM(tmp,w);
+                            ili9328getPix(LCD,tmp2,Xpos,Ypos + linenum + 1-h,w,1);
+                            for(int i=0;i<w;i++)
+                            {
+                                tmp[i]=0;
+                            }
+                            pix=0;
+                        }
+                    }
+                    if((pix%8) == 0)
+                    {
+                        line=font->table[(((buffer)-32)*h*bpl)+tableoffset++];
+                    }
+                    //tmp[pix]=0;
+                    if((line & (uint8_t)0x01)==(uint8_t)1)tmp[pix]=(uint16_t)color;
+                    pix++;
+                    line>>=1;
+                }
+            }
             int ili9328init(struct LCD_t* LCD)
             {
                 if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writereg!=NULL))
                 {
                     LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL1, 0x0100);  // Driver Output Control Register (R01h)
                     LCD->interface->writereg(ILI9328_REGISTER_LCDDRIVINGCONTROL, 0x0700);     // LCD Driving Waveform Control (R02h)
-                    LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x1030);             // Entry Mode (R03h)
+                    LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x0230);             // Entry Mode (R03h)
+                    LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0xC000);
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL2, 0x0302);
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL3, 0x0000);
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL4, 0x0000);       // Fmark On
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x0000);         // Power Control 1 (R10h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x0000);         // Power Control 3 (R12h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0000);         // Power Control 4 (R13h)
                     delay_100us(1000);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x14B0);         // Power Control 1 (R10h)
                     delay_100us(500);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
                     delay_100us(500);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x008E);         // Power Control 3 (R12h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0C00);         // Power Control 4 (R13h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL7, 0x0015);         // NVM read data 2 (R29h)
                     delay_100us(500);
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL1, 0x0000);         // Gamma Control 1
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL2, 0x0107);         // Gamma Control 2
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL3, 0x0000);         // Gamma Control 3
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL4, 0x0203);         // Gamma Control 4
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL5, 0x0402);         // Gamma Control 5
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL6, 0x0000);         // Gamma Control 6
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL7, 0x0207);         // Gamma Control 7
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL8, 0x0000);         // Gamma Control 8
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL9, 0x0203);         // Gamma Control 9
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL10, 0x0403);        // Gamma Control 10
                     LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION, 0x0000);                      // Window Horizontal RAM Address Start (R50h)
                     LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION, LCD->width - 1);   // Window Horizontal RAM Address End (R51h)
                     LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION, 0X0000);                        // Window Vertical RAM Address Start (R52h)
                     LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION, LCD->height - 1);    // Window Vertical RAM Address End (R53h)
                     LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL2, 0xa700);    // Driver Output Control (R60h)
                     LCD->interface->writereg(ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL, 0x0003); // Driver Output Control (R61h) - enable VLE
                     LCD->interface->writereg(ILI9328_REGISTER_PANELINTERFACECONTROL1, 0X0010);  // Panel Interface Control 1 (R90h)
                     // Display On
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0x0133);     // Display Control (R07h)
                     delay_100us(500);
                     LCD->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,0xFFFF);
                 }
                 return 0;
             }
             void ili9328cpFrame(LCD_t* LCD,void* buffer,int x,int y,int w, int h)
             {
             #define __set__Address__(_x_,_y_)   LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,_x_); \
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,_y_)
                 uint16_t* castedBuff = (uint16_t*)buffer;
                 int cx=x,cy=y;
                 for(int i=0;i<(w*h);i++)
                 {
                     __set__Address__(cx,cy);
                     LCD->interface->readGRAM((void*)(&castedBuff[i]),1);
                     cx+=1;
                     if(cx>=(w+x))
                     {
                         cx=x;
                         cy+=1;
                     }
                 }
             }
             void ili9328getPix(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h)
             {
             #define __set__Address__(_x_,_y_)   LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,_x_); \
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,_y_)
-                uint16_t* castedBuff = (uint16_t*)buffer;
                 int cx=Xpos,cy=Ypos;
+                ili9328setFrame(LCD,Xpos,Ypos,w,h);
                 for(int i=0;i<(w*h);i++)
                 {
                     __set__Address__(cx,cy);
-                    LCD->interface->readGRAM((void*)(&castedBuff[i]),1);
+                    LCD->interface->readGRAM((void*)(&buffer[i]),1);
                     cx+=1;
                     if(cx>=(w+Xpos))
                     {
                         cx=Xpos;
                         cy+=1;
                     }
                 }
             }

lib/src/common/GRAPHIC/GUI/FONTS/FONTS_STM32F4.pro 0 -1

             TEMPLATE = lib
-            OBJECTS_DIR = obj
             TARGET = fonts
             SOURCES += \
                 fonts8pts.c
             INCLUDEPATH += ../../../../includes \
             	../../../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../../../CPU/CMSIS/Include \
             	../../../../includes/GRAPHIC/CONTROLERS \
             	../../../../includes/GRAPHIC/GUI/FONTS \
             	../../../../includes/GRAPHIC/GUI/Widgets
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target

lib/src/common/GRAPHIC/GUI/Widgets/Terminal/Terminal.c +3 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <widget.h>
             #include <terminal.h>
             #include <stdint.h>
             #include <stdio.h>
             #include <gpio.h>
             #include <core.h>
             #include <malloc.h>
             #define CHARXPOS(terminal,charwidth) (((terminal)->column * charwidth) + (terminal)->Xpos)
             #define CHARYPOS(terminal,charheight) ((terminal)->line * charheight + (terminal)->Ypos+charheight)
             streamdevice_ops TERMINAL_OPS=
             {
                 .write = &terminal_write,
                 .read  = &terminal_read,
                 .setpos= &terminal_setpos,
                 .close = NULL
             };
             int terminal_init(terminal_t* terminal,LCD_t* LCD,sFONT* font,streamdevice* strdev)
             {
                 if((LCD!=NULL) && (font!=NULL) && (strdev!=NULL) && (terminal!=NULL))
                 {
                     terminal->LCD=LCD;
                     terminal->font=font;
                     terminal->line = 0;
                     terminal->column = 0;
                     terminal->horizontalSpace = 0;
                     terminal->verticalSpace = 0;
                     int charw=terminal->font->Width + terminal->horizontalSpace;
                     int charh=terminal->font->Height + terminal->verticalSpace;
                     terminal->textColor=0xFFFF;
                     terminal->backgroundColor=0xF00F;
                     terminal_setgeometry(terminal,5,5,terminal->LCD->width-(10),terminal->LCD->height-(10));
                     strdev->_stream = (UHANDLE)terminal;
                     strdev->ops = &TERMINAL_OPS;
                     strdev->streamPt = 0;
                     terminal_clear(terminal);
                     terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal, charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
                     terminal->buffer = (char*)malloc(terminal->lineCount*(terminal->columnCount + 1));
                     terminal->firstLine = 0;
                     terminal->lastLine = 0;
                     terminal->empty = 1;
                     for(int i=1;i<=terminal->lineCount;i++)
                     {
                         terminal->buffer[i * terminal->columnCount]='\n';
                     }
                     return 1;
                 }
                 return 0;
             }
             void terminal_setgeometry(terminal_t* terminal,uint16_t Xpos,uint16_t Ypos,uint16_t width,uint16_t height)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 if(terminal->LCD->height<(Ypos+height))
                     return;
                 if(terminal->LCD->width<(Xpos+width))
                     return;
                 terminal->Xpos = Xpos;
                 terminal->Ypos = Ypos;
                 terminal->height = height;
                 terminal->width = width;
                 terminal->lineCount = terminal->height/charh;
                 terminal->columnCount = (terminal->width/charw)-1;
                 terminal_clear(terminal);
             }
             void terminal_clear(terminal_t* terminal)
             {
                 terminal->firstLine = 0;
                 terminal->lastLine = 0;
                 terminal->empty = 1;
                 terminal->line =0;
                 terminal->column=0;
                 terminal->LCD->paintFilRect(terminal->LCD,terminal->Xpos,terminal->Ypos,terminal->width,terminal->height,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             void terminal_setbackgroundColor(terminal_t* terminal, uint32_t backgrooundColor)
             {
                 terminal->backgroundColor = backgrooundColor;
             }
             void terminal_settextColor(terminal_t* terminal, uint32_t textColor)
             {
                 terminal->textColor = textColor;
             }
             void terminal_movecursor(terminal_t* terminal,int n)
             {
                 terminal->column += n;
                 if(terminal->column>(terminal->columnCount))
                 {
                     terminal->line += (terminal->column)/terminal->columnCount;
                     terminal->line = terminal->line % terminal->lineCount;
                     terminal->column = (terminal->column % terminal->columnCount)-1;
                 }
             }
             void terminal_clearCurentLine(terminal_t* terminal)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 terminal->LCD->paintFilRect(terminal->LCD,terminal->Xpos,CHARYPOS(terminal, charh)-charh,terminal->width,charh,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             int terminal_writenc(terminal_t* terminal,char* data, int n)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 int l=0;
                 char buffer[2]=" ";
                 while(l<n)
                 {
                     buffer[0]=data[l];
                     if(buffer[0]=='\n')
                     {
                         terminal->line= (terminal->line+1) % terminal->lineCount;
                         terminal->column = 0;
                         if(terminal->line==0)
                             terminal_clear(terminal);
                         else
                             terminal_clearCurentLine(terminal);
                     }else {
                         if(buffer[0]=='\t')
                         {
                             for(int i=0;i<1;i++)terminal_movecursor(terminal,1);
                         }else
                             if(terminal->column==0)terminal_clearCurentLine(terminal);
                         if(buffer[0]!='\r'){
                        //     terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
-                            terminal->LCD->paintText(terminal->LCD,buffer,CHARXPOS(terminal,charw),(CHARYPOS(terminal, charh))-(terminal->verticalSpace/2),terminal->font,terminal->textColor);
+                           // terminal->LCD->paintText(terminal->LCD,buffer,CHARXPOS(terminal,charw),(CHARYPOS(terminal, charh))-(terminal->verticalSpace/2),terminal->font,terminal->textColor);
+            #include <ili9328.h>
+                            ili9328paintChar(terminal->LCD,buffer[0],CHARXPOS(terminal,charw),(CHARYPOS(terminal, charh))-(terminal->verticalSpace/2),terminal->font,terminal->textColor);
                             terminal_movecursor(terminal,1);
                         }
                     }
                     l++;
                 }
                 return n;
             }
             void terminal_print_line(terminal_t* terminal,int line)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 terminal_clearCurentLine(terminal);
                 terminal->LCD->paintText(terminal->LCD,terminal->buffer+(line*(terminal->columnCount + 1)),CHARXPOS(terminal,charw),CHARYPOS(terminal, charh),terminal->font,terminal->textColor);
             }
             int terminal_writenc2(terminal_t* terminal,char* data, int n)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 /* First copy to buffer*/
                 int offset = (terminal->lastLine*(terminal->columnCount + 1)) + terminal->column;
                 for(int i=0;i<n;i++)
                 {
                     terminal->empty=0;
                     terminal->buffer[offset] = data[i];
                     if(data[i]=='\n')
                     {
                         offset = ((offset/(terminal->columnCount + 1) + 1) * (terminal->columnCount + 1));
                     }
                     else
                     {
                         offset++;
                     }
                 }
                 if(!terminal->empty)
                 {
                     for(int i=terminal->firstLine;i<=terminal->lastLine;i++)
                     {
                         terminal_print_line(terminal,i);
                     }
                 }
                 return n;
             }
             int terminal_write(streamdevice* device,void* data,int size, int n)
             {
                 return terminal_writenc((terminal_t*)device->_stream,(char*) data,size*n);
             }
             int terminal_read(streamdevice* device,void* data,int size, int n)
             {
                 return n*size;
             }
             int terminal_setpos(streamdevice* device,int pos)
             {
                 return 1;
             }
             int terminal_close( streamdevice* device)
             {
                 return 1;
             }

lib/src/common/GRAPHIC/GUI/Widgets/Terminal/Terminal_STM32F4.pro 0 -1

             TEMPLATE = lib
-            OBJECTS_DIR = obj
             TARGET = terminal
             SOURCES += \
                 Terminal.c
             INCLUDEPATH += ../../../../includes \
             	../../../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../../../CPU/CMSIS/Include \
             	../../../../includes/GRAPHIC/CONTROLERS \
             	../../../../includes/GRAPHIC/GUI/FONTS \
             	../../../../includes/GRAPHIC/GUI/Widgets
             HEADERS += \
                 ../../../../../includes/GRAPHIC/GUI/Widgets/terminal.h
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target

lib/src/includes/GRAPHIC/CONTROLERS/ili9328.h +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #ifndef ILI9328_H
             #define ILI9328_H
             #include <uhandle.h>
             #include <genericLCD_Controler.h>
             #include <stdint.h>
             #include <fonts.h>
             extern int  ili9328init(struct LCD_t* LCD);
             extern void ili9328setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H);
             extern void ili9328setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress);
             extern void ili9328paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height);
             extern void ili9328paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color);
             extern void ili9328paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
             extern void ili9328paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
             extern void ili9328paintFilCircMidPoint(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
             extern void ili9328getPix(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h);
             extern void ili9328refreshenable(struct LCD_t* LCD,int enable);
+            extern void ili9328paintChar(LCD_t* LCD,char buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color);
             #define	ILI9328_REGISTER_DRIVERCODEREAD                 ((uint32_t) 0x0000 )
             #define	ILI9328_REGISTER_DRIVEROUTPUTCONTROL1           ((uint32_t) 0x0001 )
             #define	ILI9328_REGISTER_LCDDRIVINGCONTROL              ((uint32_t) 0x0002 )
             #define	ILI9328_REGISTER_ENTRYMODE                      ((uint32_t) 0x0003 )
             #define	ILI9328_REGISTER_RESIZECONTROL                  ((uint32_t) 0x0004 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL1                ((uint32_t) 0x0007 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL2                ((uint32_t) 0x0008 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL3                ((uint32_t) 0x0009 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL4                ((uint32_t) 0x000A )
             #define	ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL1    ((uint32_t) 0x000C )
             #define	ILI9328_REGISTER_FRAMEMAKERPOSITION             ((uint32_t) 0x000D )
             #define	ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL2    ((uint32_t) 0x000F )
             #define	ILI9328_REGISTER_POWERCONTROL1                  ((uint32_t) 0x0010 )
             #define	ILI9328_REGISTER_POWERCONTROL2                  ((uint32_t) 0x0011 )
             #define	ILI9328_REGISTER_POWERCONTROL3                  ((uint32_t) 0x0012 )
             #define	ILI9328_REGISTER_POWERCONTROL4                  ((uint32_t) 0x0013 )
             #define	ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET       ((uint32_t) 0x0020 )
             #define	ILI9328_REGISTER_VERTICALGRAMADDRESSSET         ((uint32_t) 0x0021 )
             #define	ILI9328_REGISTER_WRITEDATATOGRAM                ((uint32_t) 0x0022 )
             #define	ILI9328_REGISTER_POWERCONTROL7                  ((uint32_t) 0x0029 )
             #define	ILI9328_REGISTER_FRAMERATEANDCOLORCONTROL       ((uint32_t) 0x002B )
             #define	ILI9328_REGISTER_GAMMACONTROL1                  ((uint32_t) 0x0030 )
             #define	ILI9328_REGISTER_GAMMACONTROL2                  ((uint32_t) 0x0031 )
             #define	ILI9328_REGISTER_GAMMACONTROL3                  ((uint32_t) 0x0032 )
             #define	ILI9328_REGISTER_GAMMACONTROL4                  ((uint32_t) 0x0035 )
             #define	ILI9328_REGISTER_GAMMACONTROL5                  ((uint32_t) 0x0036 )
             #define	ILI9328_REGISTER_GAMMACONTROL6                  ((uint32_t) 0x0037 )
             #define	ILI9328_REGISTER_GAMMACONTROL7                  ((uint32_t) 0x0038 )
             #define	ILI9328_REGISTER_GAMMACONTROL8                  ((uint32_t) 0x0039 )
             #define	ILI9328_REGISTER_GAMMACONTROL9                  ((uint32_t) 0x003C )
             #define	ILI9328_REGISTER_GAMMACONTROL10                 ((uint32_t) 0x003D )
             #define	ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION	((uint32_t)	0x0050 )
             #define	ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION	((uint32_t) 0x0051 )
             #define	ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION	((uint32_t) 0x0052 )
             #define	ILI9328_REGISTER_VERTICALADDRESSENDPOSITION     ((uint32_t) 0x0053 )
             #define	ILI9328_REGISTER_DRIVEROUTPUTCONTROL2           ((uint32_t) 0x0060 )
             #define	ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL        ((uint32_t) 0x0061 )
             #define	ILI9328_REGISTER_VERTICALSCROLLCONTROL          ((uint32_t) 0x006A )
             #define	ILI9328_REGISTER_PARTIALIMAGE1DISPLAYPOSITION   ((uint32_t) 0x0080 )
             #define	ILI9328_REGISTER_PARTIALIMAGE1AREASTARTLINE     ((uint32_t) 0x0081 )
             #define	ILI9328_REGISTER_PARTIALIMAGE1AREAENDLINE       ((uint32_t) 0x0082 )
             #define	ILI9328_REGISTER_PARTIALIMAGE2DISPLAYPOSITION   ((uint32_t) 0x0083 )
             #define	ILI9328_REGISTER_PARTIALIMAGE2AREASTARTLINE     ((uint32_t) 0x0084 )
             #define	ILI9328_REGISTER_PARTIALIMAGE2AREAENDLINE       ((uint32_t) 0x0085 )
             #define	ILI9328_REGISTER_PANELINTERFACECONTROL1         ((uint32_t) 0x0090 )
             #define	ILI9328_REGISTER_PANELINTERFACECONTROL2         ((uint32_t) 0x0092 )
             #define	ILI9328_REGISTER_PANELINTERFACECONTROL4         ((uint32_t) 0x0095 )
             #define	ILI9328_REGISTER_OTPVCMPROGRAMMINGCONTROL       ((uint32_t) 0x00A1 )
             #define	ILI9328_REGISTER_OTPVCMSTATUSANDENABLE          ((uint32_t) 0x00A2 )
             #define	ILI9328_REGISTER_OTPPROGRAMMINGIDKEY            ((uint32_t) 0x00A5 )
             #ifdef _PRVATE_ILI9328_
             void ili9328cpFrame(LCD_t* LCD,void* buffer,int x,int y,int w, int h);
             #endif
             #endif

lib/src/simulator/SDLCD/SDLCD.c +12 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <SDL.h>
             #include <malloc.h>
             #include "SDLCD.h"
             SDL_Surface *screen;
             SDL_Overlay     *bmp;
             int SDLCD_Xpos=0;
             int SDLCD_Ypos=0;
             int SDLCD_XWinStrt=0;
             int SDLCD_YWinStrt=0;
             int SDLCD_XWinEnd=0;
             int SDLCD_YWinEnd=0;
             void* SDLCD_buffer;
             int SDLCD_bpp;
             void SDLCD_putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
             void SDLCD_mkscreen(int resx,int resy,int bpp,int lcdtype)
             {
                 int i=0;
                 if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER)) {
                     fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
                     exit(1);
                 }
                 screen = SDL_SetVideoMode(resx, resy, bpp, 0);
                 if(!screen) {
                     fprintf(stderr, "SDL: could not set video mode - exiting\n");
                     exit(1);
                 }
                 if ( SDL_MUSTLOCK(screen) ) {
                     if ( SDL_LockSurface(screen) < 0 ) {
                         fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                         return;
                     }
                 }
                 if ( SDL_MUSTLOCK(screen) ) {
                     SDL_UnlockSurface(screen);
                 }
                 SDL_UpdateRect(screen, 0, 0, resx, resy);
                 SDLCD_buffer = malloc(resx*resy*bpp/8);
                 SDLCD_bpp = bpp;
                 for(i=0;i<(resx*resy);i++)
                 {
                     SDLCD_putpixel(screen, i%resx, (i/resx), 0xFFFF);
                 }
             }
             int SDLCD_init()
             {
             }
             void SDLCD_writereg(uint32_t reg,uint32_t data)
             {
                 switch (reg) {
                 case ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET:
-                    if((data>=screen->w) || (data<0))printf("Warning printing out of bounds HORIZONTALGRAMADDRESSSET=%d",data);
+                    if((data>=screen->w) || (data<0))
+                        printf("Warning printing out of bounds HORIZONTALGRAMADDRESSSET=%d",data);
                     SDLCD_Xpos = data;
                     break;
                 case ILI9328_REGISTER_VERTICALGRAMADDRESSSET:
-                    if((data>=screen->h) || (data<0))printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALGRAMADDRESSSET=%d",data);
+                    if((data>=screen->h) || (data<0))
+                        printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALGRAMADDRESSSET=%d",data);
                     SDLCD_Ypos = data;
                     break;
                 case ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION:
-                    if((data>=screen->w) || (data<0))printf("Warning printing out of bounds ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION=%d",data);
+                    if((data>=screen->w) || (data<0))
+                        printf("Warning printing out of bounds ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION=%d",data);
                     SDLCD_XWinStrt = data;
                     break;
                 case ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION:
-                    if((data>=screen->w) || (data<0))printf("Warning printing out of bounds ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION=%d",data);
+                    if((data>=screen->w) || (data<0))
+                        printf("Warning printing out of bounds ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION=%d",data);
                     SDLCD_XWinEnd = data;
                     break;
                 case ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION:
-                    if((data>=screen->h) || (data<0))printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION=%d",data);
+                    if((data>=screen->h) || (data<0))
+                        printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION=%d",data);
                     SDLCD_YWinStrt = data;
                     break;
                 case ILI9328_REGISTER_VERTICALADDRESSENDPOSITION:
-                    if((data>=screen->h) || (data<0))printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALADDRESSENDPOSITION=%d",data);
+                    if((data>=screen->h) || (data<0))
+                        printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALADDRESSENDPOSITION=%d",data);
                     SDLCD_YWinEnd = data;
                     break;
                 default:
                     break;
                 }
             }
             uint32_t SDLCD_readreg(uint32_t reg)
             {
                 return 0;
             }
             void SDLCD_putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
             {
                 int bpp = surface->format->BytesPerPixel;
                 /* Here p is the address to the pixel we want to set */
                 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
                 switch(bpp) {
                 case 1:
                     *p = pixel;
                     break;
                 case 2:
                     *(Uint16 *)p = pixel;
                     break;
                 case 3:
                     if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                         p[0] = (pixel >> 16) & 0xff;
                         p[1] = (pixel >> 8) & 0xff;
                         p[2] = pixel & 0xff;
                     } else {
                         p[0] = pixel & 0xff;
                         p[1] = (pixel >> 8) & 0xff;
                         p[2] = (pixel >> 16) & 0xff;
                     }
                     break;
                 case 4:
                     *(Uint32 *)p = pixel;
                     break;
                 }
             }
             void SDLCD_putpixel_16bpp(SDL_Surface *surface, int x, int y, Uint32 pixel)
             {
                 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * surface->format->BytesPerPixel;
                 *(Uint16 *)p = pixel;
             }
             Uint32 SDLCD_getpixel_16bpp(SDL_Surface *surface, int x, int y)
             {
                 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * surface->format->BytesPerPixel;
                 return *(Uint16 *)p;
             }
             Uint32 SDLCD_getpixel(SDL_Surface *surface, int x, int y)
             {
                 int bpp = surface->format->BytesPerPixel;
                 /* Here p is the address to the pixel we want to retrieve */
                 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
                 switch(bpp) {
                 case 1:
                     return *p;
                 case 2:
                     return *(Uint16 *)p;
                 case 3:
                     if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                         return p[0] << 16 | p[1] << 8 | p[2];
                     else
                         return p[0] | p[1] << 8 | p[2] << 16;
                 case 4:
                     return *(Uint32 *)p;
                 default:
                     return 0;
                 }
                 /* shouldn’t happen, but avoids warnings */
             }
             void SDLCD_writeGRAM(void* buffer,uint32_t count)
             {
                 int i=0;
                 u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
                 u_int16_t* inptr=(u_int16_t*)buffer;
                 if ( SDL_MUSTLOCK(screen) ) {
                     if ( SDL_LockSurface(screen) < 0 ) {
                         fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                         return;
                     }
                 }
                 for(i=0;i<count;i++)
                 {
                     SDLCD_putpixel_16bpp(screen,SDLCD_Xpos,SDLCD_Ypos,inptr[i]);
                     SDLCD_Xpos+=1;
                     ptr[i]=inptr[i];
                     if(SDLCD_Xpos>=SDLCD_XWinEnd)
                     {
                         SDLCD_Xpos=SDLCD_XWinStrt;
                         SDLCD_Ypos+=1;
                     }
                     if(SDLCD_Ypos>=SDLCD_YWinEnd)
                     {
                         SDLCD_Ypos=SDLCD_YWinStrt;
                     }
                 }
                 if ( SDL_MUSTLOCK(screen) ) {
                     SDL_UnlockSurface(screen);
                 }
                 //    SDL_UpdateRect(screen, SDLCD_XWinStrt, SDLCD_YWinStrt, SDLCD_XWinEnd-SDLCD_XWinStrt, SDLCD_YWinEnd-SDLCD_YWinStrt);
                 SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
             }
             void SDLCD_writeGRAM_16bpp(void* buffer,uint32_t count)
             {
                 int i=0;
                 u_int16_t* inptr=(u_int16_t*)buffer;
                 if ( SDL_MUSTLOCK(screen) ) {
                     if ( SDL_LockSurface(screen) < 0 ) {
                         fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                         return;
                     }
                 }
                 for(i=0;i<count;i++)
                 {
                     *(( Uint16 * ) screen->pixels + SDLCD_Ypos * screen->pitch / 2 + SDLCD_Xpos)=inptr[i];
                     SDLCD_Xpos+=1;
                     if(SDLCD_Xpos>=SDLCD_XWinEnd)
                     {
                         SDLCD_Xpos=SDLCD_XWinStrt;
                         SDLCD_Ypos+=1;
                     }
                     if(SDLCD_Ypos>=SDLCD_YWinEnd)
                     {
                         SDLCD_Ypos=SDLCD_YWinStrt;
                     }
                 }
                 if ( SDL_MUSTLOCK(screen) ) {
                     SDL_UnlockSurface(screen);
                 }
                 //    SDL_UpdateRect(screen, SDLCD_XWinStrt, SDLCD_YWinStrt, SDLCD_XWinEnd-SDLCD_XWinStrt, SDLCD_YWinEnd-SDLCD_YWinStrt);
                 SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
             }
             void SDLCD_readGRAM_16bpp(void* buffer,uint32_t count)
             {
                 int i=0;
                 u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
                 u_int16_t* inptr=(u_int16_t*)buffer;
                 for(i=0;i<count;i++)
                 {
                     inptr[i]=*(( Uint16 * ) screen->pixels + SDLCD_Ypos * screen->pitch / 2 + SDLCD_Xpos);
                     SDLCD_Xpos+=1;
                     ptr[i]=inptr[i];
                     if(SDLCD_Xpos>=SDLCD_XWinEnd)
                     {
                         SDLCD_Xpos=SDLCD_XWinStrt;
                         SDLCD_Ypos+=1;
                     }
                     if(SDLCD_Ypos>=SDLCD_YWinEnd)
                     {
                         SDLCD_Ypos=SDLCD_YWinStrt;
                     }
                 }
             }
             void SDLCD_readGRAM(void* buffer,uint32_t count)
             {
                 int i=0;
                 u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
                 u_int16_t* inptr=(u_int16_t*)buffer;
                 for(i=0;i<count;i++)
                 {
                     inptr[i]=SDLCD_getpixel_16bpp(screen,SDLCD_Xpos,SDLCD_Ypos);
                     SDLCD_Xpos+=1;
                     ptr[i]=inptr[i];
                     if(SDLCD_Xpos>=SDLCD_XWinEnd)
                     {
                         SDLCD_Xpos=SDLCD_XWinStrt;
                         SDLCD_Ypos+=1;
                     }
                     if(SDLCD_Ypos>=SDLCD_YWinEnd)
                     {
                         SDLCD_Ypos=SDLCD_YWinStrt;
                     }
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages