HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r36:f47a2524d7d3

sync

jeandet@PC-DE-JEANDET.lab-lpp.local -

r36:f47a2524d7d3 dev_alexis

parent child

Context file:

r36:f47a2524d7d3

Collapse all files

bsp/includes/BEAGLESYNTH/bsp.h +7 -1

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #include <ili9328.h>
             #include <genericLCD_Controler.h>
             #define __MAX_OPENED_FILES__ 4
             #define __FS_ROOT_SIZE__ 4
             /*
             #ifndef PD8
               #define PD8
             #endif
             #ifndef PD9
               #define PD9
             #endif
             */
             #define LED1 PF6
             #define LED2 PF7
             #define LED3 PF8
             #define PSU_DISABLE PH2
             #define PSU_ALERT_5V PF2
             #define PSU_ALERT_1_5V PF3
             #define PSU_ALERT_3_3V PF4
             #define LCD_RESET PE2
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern LCD_t lcd0;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
-            extern void bsp_FSMC_init();
+            extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
+            void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
+            uint32_t bsp_lcd0_read_reg(uint32_t reg);
+            void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
+            void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             #endif

bsp/src/BEAGLESYNTH/bsp.c +27 -18

             /*------------------------------------------------------------------------------
             --  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_t lcd0;
-            LCD_IF_t lcdIF0;
+            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);
                 }
             }
-            void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
-            uint32_t bsp_lcd0_read_reg(uint32_t reg);
-            void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
-            void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
-            void bsp_FSMC_init()
+            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 = 1;
+                p.FSMC_AddressSetupTime = 2;
                 p.FSMC_AddressHoldTime = 0;
                 //p.FSMC_DataSetupTime = 9;
-                p.FSMC_DataSetupTime = 3;
+                p.FSMC_DataSetupTime = 4;
                 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);
-                lcdIF0.writereg=&bsp_lcd0_write_reg;
-                lcdIF0.readGRAM=&bsp_lcd0_readGRAM;
-                lcdIF0.readreg=&bsp_lcd0_read_reg;
-                lcdIF0.writeGRAM=&bsp_lcd0_writeGRAM;
-                lcd0.interface=&lcdIF0;
-                lcd0.init=&ili9328init;
-                lcd0.paint=&ili9328paint;
                 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(uint32_t i=0;i<count;i++)
+                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(uint32_t i=0;i<count;i++)
+                for(int i=0;i<(int)count;i++)
                 {
                      castedBuff[i]=*lcd0_DATA;
                 }
             }

examples/BeagleSynthHello/main.c +17 -22

             #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__[];
             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);
                 while(1)
                 {
-                   /* *regtest=(int16_t)ILI9328_REGISTER_ENTRYMODE;
+                    //ili9328setFrame(&lcd0,0,0,240,320);
-                    *regtest2=(int16_t)0x1008;*/
+                    //ili9328setGRAMaddress(&lcd0,0,0);
-                    ili9328setFrame(&lcd0,0,0,240,320);
+                    *regtest=(int16_t)0x20;
+                    *regtest2=(int16_t)0x0;
+                    *regtest=(int16_t)0x21;
+                    *regtest2=(int16_t)0x0;
                     *regtest=(int16_t)0x22;
-                    for(volatile int i=0;i<(320*240);i++)
+                    for(int i=0;i<(320*240);i++)
                     {
                         *regtest2=(int16_t)0x001F;
-                        //for(volatile int l=0;l<(1024);l++);
                     }
-                   /* *regtest=(int16_t)ILI9328_REGISTER_ENTRYMODE;
-                    *regtest2=(int16_t)0x1018;*/
                     for(volatile int i=0;i<(320*240*100);i++);
-                   /* *regtest=(int16_t)ILI9328_REGISTER_ENTRYMODE;
+                    //uint16_t test[100];
-                    *regtest2=(int16_t)0x1008;*/
+                    //ili9328setFrame(&lcd0,10,10,10,10);
-                    //ili9328setGRAMaddress(&lcd0,60,80);
+                    //*regtest=(int16_t)0x22;
-                    uint16_t test[80*80];
+                    //for(int i=0;i<(10*10);i++)
-                    ili9328setFrame(&lcd0,10,10,100,100);
+                    //{
-                    *regtest=(int16_t)0x22;
+                    //   *regtest2=(int16_t)(0xF800);
-                    for(volatile int i=0;i<(100*100);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);
-                    /**regtest=(int16_t)ILI9328_REGISTER_ENTRYMODE;
+                    //for(volatile int i=0;i<(320*240*100);i++);
-                    *regtest2=(int16_t)0x1018;*/
-                    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/genericLCD_Controler.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 GENERICLCD_CONTROLER_H
             #define GENERICLCD_CONTROLER_H
             #include <uhandle.h>
             #include <stdint.h>
             typedef struct LCD_IF_t
             {
                 int (*init)();
                 void (*writereg)(uint32_t reg,uint32_t data);
                 uint32_t (*readreg)(uint32_t reg);
                 void (*writeGRAM)(void* buffer,uint32_t count);
                 void (*readGRAM)(void* buffer,uint32_t count);
             }LCD_IF_t;
             typedef struct LCD_t
             {
                 LCD_IF_t* interface;
                 int (*init)(struct LCD_t* LCD);
                 void (*paint)(struct LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height);
+                void (*refreshenable)(struct LCD_t* LCD,int enable);
                 uint16_t width;
                 uint16_t height;
             }LCD_t;
             #endif              /*GENERICLCD_CONTROLER_H*/

lib/includes/GRAPHIC/CONTROLERS/ili9328.h +2 -1

             /*------------------------------------------------------------------------------
             --  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>
             extern int ili9328init(struct LCD_t* LCD);
-            extern void ili9328setFrame(LCD_t* LCD,uint16_t HaddressStart,uint16_t VaddressStart,uint16_t HaddressStop,uint16_t VaddressStop);
+            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 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 +25 -8

             /*------------------------------------------------------------------------------
             --  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 ili9328setFrame(LCD_t* LCD,uint16_t HaddressStart,uint16_t VaddressStart,uint16_t HaddressStop,uint16_t VaddressStop)
+            void ili9328refreshenable(struct LCD_t* LCD,int enable)
+            {
+                if(enable)
+                {
+                    //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1018);
+                }
+                else
                 {
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,HaddressStart);
+                    //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1008);
-                LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,VaddressStart);
-                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,HaddressStop);
-                LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,VaddressStop);
+            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,X);
+                LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,Y);
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,X);
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,X);
+                LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,W+X);
+                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)))
                 {
                     printf("paint\n\r");
-                    ili9328setFrame(LCD,Xpos,Ypos,Xpos+Width,Ypos+Height);
+                    ili9328setFrame(LCD,Xpos,Ypos,Width,Height);
-                    ili9328setGRAMaddress(LCD,Xpos,Ypos);
+                    //ili9328setGRAMaddress(LCD,Xpos,Ypos);
                     LCD->interface->writeGRAM(buffer,Width*Height);
                 }
             }
             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_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, 0x1030);
+                    LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x1018);
                     LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL1, 0x0100);
                     //ili9328WriteCmd(ILI9328_REGISTER_WRITEDATATOGRAM);
                 }
                 return 0;
             }

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