HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r37:b6a4710d362a

added text painter on ili9328

jeandet@pc-de-jeandet3.LAB-LPP.LOCAL -

r37:b6a4710d362a dev_alexis

parent child

Context file:

r37:b6a4710d362a

Collapse all files

bsp/cfg/BEAGLESYNTH/bsp.pri +4 0

@@ -1,3 +1,7
1	CPU=stm32f4xxxG	1	CPU=stm32f4xxxG
2	DEFINES+=BSP=\\\"BEAGLESYNTH\\\"	2	DEFINES+=BSP=\\\"BEAGLESYNTH\\\"
3	include($$(libuc2)/rules/stm32f4-arm-none-eabi-gcc/rules.pri)	3	include($$(libuc2)/rules/stm32f4-arm-none-eabi-gcc/rules.pri)
		4
		5	beagleCp.target = beagleCp
		6	beagleCp.commands = scp $$DESTDIR/$(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin
		7	QMAKE_EXTRA_TARGETS += beagleCp

bsp/src/BEAGLESYNTH/bsp.c +2 -5

             /*------------------------------------------------------------------------------
             --  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@gmail.com
             -------------------------------------------------------------------------------*/
             #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>
             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,
                 .refreshenable = &ili9328refreshenable,
                 .width= 240,
                 .height = 320
             };
             volatile int16_t* lcd0_CMD=(volatile int16_t*)  0x60000000;
             volatile int16_t* lcd0_DATA=(volatile int16_t*)(0x61FFFFF0);
             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();
                 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);
                 gpio_t gpio4 = gpioopen(PSU_DISABLE);
                 gpio_t gpio5 = gpioopen(PSU_ALERT_5V);
                 gpio_t gpio6 = gpioopen(PSU_ALERT_1_5V);
                 gpio_t gpio7 = gpioopen(PSU_ALERT_3_3V);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetspeed(&gpio4,gpiohighspeed);
                 gpiosetspeed(&gpio5,gpiohighspeed);
                 gpiosetspeed(&gpio6,gpiohighspeed);
                 gpiosetspeed(&gpio7,gpiohighspeed);
                 gpioclr(PSU_DISABLE);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio4,gpiooutdir);
                 gpiosetdir(&gpio5,gpioindir);
                 gpiosetdir(&gpio6,gpioindir);
                 gpiosetdir(&gpio7,gpioindir);
                 gpioclr(PSU_DISABLE);
             }
             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);
                 }
             }
             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 gpio1 = gpioopen(LCD_RESET);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpioclr(LCD_RESET);
                 gpio_t LCD_DBxList[]={PD14,PD15,PD0,PD1,PE7,PE8,PE9,PE10,PE11,PE12,PE13,PE14,PE15\
                                       ,PD8,PD9,PD10,PD4,PD5,PD7,PE4};
                 for(int i=0;i<20;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;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
               /*-- FSMC Configuration ------------------------------------------------------*/
               /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM4 configuration */
                 //p.FSMC_AddressSetupTime = 5;
-                p.FSMC_AddressSetupTime = 2;
+                p.FSMC_AddressSetupTime = 1;
                 p.FSMC_AddressHoldTime = 0;
                 //p.FSMC_DataSetupTime = 9;
-                p.FSMC_DataSetupTime = 4;
+                p.FSMC_DataSetupTime = 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 /* Color LCD configuration ------------------------------------
                    LCD configured as follow:
                       - Data/Address MUX = Disable
                       - Memory Type = SRAM
                       - Data Width = 16bit
                       - Write Operation = Enable
                       - Extended Mode = Enable
                       - Asynchronous Wait = Disable */
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_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 NOR/SRAM Bank1 */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);
                 gpioset(LCD_RESET);
                 lcd0.init(&lcd0);
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
                 i2copenandconfig(i2c2,0,400000,PF0,PF1);
             }
             void bsp_SD_init()
             {
             }
             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)
             {
-                printf("Write %X @ %d\n\r",data,reg);
                 *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)
             {
-                printf("Write to GRAM %d pixels from 0x%X\t\n\r",count,(int)buffer);
                 *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];
                 }
-                printf("[Done]\n\r");
             }
             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;
                 }
             }

examples/BeagleSynthHello/main.c +24 -26

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <i2c.h>
             #include <CS43L22.h>
             #include <ina226.h>
             #include <fonts.h>
             extern streamdevice* __opnfiles__[];
+            #define LCD_COLOR_WHITE          0xFFFF
+            #define LCD_COLOR_BLACK          0x0000
+            #define LCD_COLOR_GREY           0xF7DE
+            #define LCD_COLOR_BLUE           0x001F
+            #define LCD_COLOR_BLUE2          0x051F
+            #define LCD_COLOR_RED            0xF800
+            #define LCD_COLOR_MAGENTA        0xF81F
+            #define LCD_COLOR_GREEN          0x07E0
+            #define LCD_COLOR_CYAN           0x7FFF
+            #define LCD_COLOR_YELLOW         0xFFE0
             int main()
             {
                 INA226_t ina5VSens,ina33VSens,ina15VSens;
                 gpioset(PSU_DISABLE);
                 volatile int16_t* regtest=(volatile int16_t*)0x60000000;
                 volatile int16_t* regtest2=(volatile int16_t*)(0x61FFFFF0);
                 //ina226open(&ina5VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,0,15,1000000);
                 //ina226open(&ina15VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,1,0,15,1000000);
                 *regtest=(int16_t)0;
                 printf("LCD ID=%x\n\r",0xFFFF&(*regtest2));
-                //lcd0.refreshenable(&lcd0,1);
+                uint16_t x=90,y=0;
+                ili9328paintFilRect(&lcd0,0,0,240,320,0x01F,0x01F);
+               // ili9328paintText(&lcd0,"Hello",14,38,&Font16x24,0);
+                ili9328paintText(&lcd0,"Hello",10,34,&Font16x24,0xF800);
                 while(1)
                 {
-                    //ili9328setFrame(&lcd0,0,0,240,320);
+                    ili9328paintText(&lcd0," World !",90,y+24,&Font16x24,0xF800);
-                    //ili9328setGRAMaddress(&lcd0,0,0);
+                    ili9328paintFilRect(&lcd0,x,y,20,20,0x01F,0xF800);
-                    *regtest=(int16_t)0x20;
+                    for(volatile int i=0;i<(320*500);i++);
-                    *regtest2=(int16_t)0x0;
+                    ili9328paintFilRect(&lcd0,90,y,150,24,0x01F,0x01F);
-                    *regtest=(int16_t)0x21;
+                    ili9328paintFilRect(&lcd0,x,y,20,20,0x01F,0x01F);
-                    *regtest2=(int16_t)0x0;
+                    y+=10;
-                    *regtest=(int16_t)0x22;
+                    if(y>290){y=0;x+=20;}
-                    for(int i=0;i<(320*240);i++)
+                    if(x>220){x=90;}
-                        *regtest2=(int16_t)0x001F;
-                    for(volatile int i=0;i<(320*240*100);i++);
-                    //uint16_t test[100];
-                    //ili9328setFrame(&lcd0,10,10,10,10);
-                    //*regtest=(int16_t)0x22;
-                    //for(int i=0;i<(10*10);i++)
-                    //{
-                    //   *regtest2=(int16_t)(0xF800);
-                    //test[i]=(int16_t)0xF800;
-                    //for(volatile int l=0;l<(1024);l++);
-                    //}
-                    //bsp_lcd0_writeGRAM(test,10*10);
-                    //lcd0.paint(&lcd0,test,100,100,80,80);
-                    //for(volatile int i=0;i<(320*240*100);i++);
                 }
                 if(-1==ina226open(&ina33VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,1,15,1000000))
                 {
                     printf("Can't open 3.3V monitor\n\r");
                 }
                 int current5V,current33V,current15V;
                 printf("\t5V\t3.3V\n\r");
                 while(1)
                 {
                     for(volatile int i=0;i<1024*1024;i++);
                     gpioset(LED1);
                     gpioclr(LED2);
                     for(volatile int i=0;i<1024*1024;i++);
                     gpioclr(LED1);
                     gpioset(LED2);
                     //current5V = ina226getCurrent(&ina5VSens);
                     current33V = ina226getCurrent(&ina33VSens);
                     //current15V = ina226getCurrent(&ina15VSens);
                     //current = ina226getReg(&Psens1,INA226_Current_Reg);
                     //printf("%duA  %dmA\t%duA  %dmA\n\r",current5V,current5V/1000,current33V,current33V/1000);
                     printf("%duA  %dmA\n\r",current33V,current33V/1000);
                 }
                 printf("hello world\n\r");
                 return 0;
             }

lib/includes/GRAPHIC/CONTROLERS/ili9328.h +3 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,uint32_t fillColor);
             extern void ili9328refreshenable(struct LCD_t* LCD,int enable);
             #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	)
             #endif

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c +61 -17

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #include <ili9328.h>
             #include <stdio.h>
             #include <stddef.h>
             #define _delay_(del) for(volatile int _d_e_l_=0;_d_e_l_<(del);_d_e_l_++);
             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)
             {
-                printf("setFrame X=%d Y=%d W=%d H=%d\n\r",(int)X,(int)Y,(int)W,(int)H);
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)X);
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,X);
+                LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)Y);
-                LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,Y);
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,(uint32_t)X);
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,X);
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,(uint32_t)(W+X-1));
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,X);
+                LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,(uint32_t)Y);
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,W+X);
+                LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,(uint32_t)(Y+H-1));
-                LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,Y);
-                LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,Y+H);
             }
             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 ili9328paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,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);
+            }
+            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,pix=0,tableoffset=0;
+                uint16_t tmp[w];
+                uint16_t line=0,linenum=0,charnum=0;
+                while(*buffer)
                 {
-                    printf("paint\n\r");
+                    ili9328setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1);
-                    ili9328setFrame(LCD,Xpos,Ypos,Width,Height);
+                    LCD->interface->readGRAM(tmp,w);
-                    //ili9328setGRAMaddress(LCD,Xpos,Ypos);
+                    for(int i=0;i<(h*w);i++)
-                    LCD->interface->writeGRAM(buffer,Width*Height);
+                        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);
+                                LCD->interface->readGRAM(tmp,w);
+                                pix=0;
+                            }
+                        }
+                        if((i%16) == 0)
+                        {
+                            line=font->table[(((*buffer)-32)*h)+tableoffset++];
+                        }
+                        if((line & 0x0001)==1)tmp[pix]=(uint16_t)color;
+                        pix++;
+                        line>>=1;
+                    }
+                    linenum=0;
+                    tableoffset=0;
+                    charnum++;
+                    buffer++;
                 }
             }
             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_DISPLAYCONTROL2, 0x0302);
+                    LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL2, 0x0202);
                     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_(1000000);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x14B0);         // Power Control 1 (R10h)
                     _delay_(500000);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
                     _delay_(500000);
                     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_(500000);
                     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, 240 - 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, 320 - 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_(500000);
-                    LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x1018);
+                    LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x0038);
-                    LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL1, 0x0100);
-                    //ili9328WriteCmd(ILI9328_REGISTER_WRITEDATATOGRAM);
                 }
                 return 0;
             }

lib/src/stm32f4/CPU/stm32f4xxxG/cpuinit.c +1 -1

             #include "stm32f4xx.h"
             #include <stdint.h>
             #include <stdlib.h>
             #include <stdio.h>
             #include <bsp.h>
             #include <stm32f4xx_rcc.h>
             #include <core.h>
             extern int main();
             void cpu_init()
             {
                 extern uint32_t currentCpuFreq;
-                currentCpuFreq = 140000000;
+                currentCpuFreq = 160000000;
                 enable_FPU();
                 RCC->CR |= (uint32_t)0x00000001;
                 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
                 reset_AHB1();
                 reset_AHB2();
                 reset_APB1();
                 reset_APB2();
                 RCC->CR |= (uint32_t)0x00000001;
                 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
                 RCC->CFGR = 0x00000000;
                 RCC->CIR = 0x00000000;
                 SCB->VTOR = FLASH_BASE;
                 RCC->APB1ENR |= RCC_APB1ENR_PWREN;
                 PWR->CR |= PWR_CR_PMODE;
                 currentCpuFreq=setCpuFreq(currentCpuFreq);
                 bsp_init();
                 RCC_ClocksTypeDef RCC_ClocksStatus;
                 RCC_GetClocksFreq(&RCC_ClocksStatus);
                 printf("PLL Configured got:\n\r SYS=%uHz\n\r CPU=%uHz\n\r APB1=%uHz\n\r APB2=%uHz\n\r",(unsigned int)RCC_ClocksStatus.SYSCLK_Frequency,(unsigned int)RCC_ClocksStatus.HCLK_Frequency,(unsigned int)RCC_ClocksStatus.PCLK1_Frequency,(unsigned int)RCC_ClocksStatus.PCLK2_Frequency);
                 printf("Enter Main\n\r");
                 int res=main();
                 printf("\n\rprogram exited with code ");
                 printf("%u",res);
                 printf("\n\r");
                 while(1)
                 {
                     for(volatile int i=0;i<1024*64;i++);
                     gpioset(PD14);
                     for(volatile int i=0;i<1024*64;i++);
                     gpioclr(PD14);
                 }
             }

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