Jump to content

nicks1980

Members
 View Profile  See their activity

  • Posts

    2

  • Joined

  • Last visited

 Content Type 

Posts posted by nicks1980

  1. I want to register the callback on each window

    in Support

    Posted

    I want to register the callback on each window

    By pressing one button all callbacks are called.

     


    typedef struct {
       GListener glListener;    
       GHandle   ghContainer;       GContainerObject gObjContainer;    
       GHandle   ghCustoms;         GButtonObject    gObjCustoms;
       GHandle   ghManagedProgramm; GButtonObject    gObjManagedProgramm;
       GHandle   ghPlayList;        GButtonObject    gObjPlayList;
    } GUI_MAIN_MENU;

    typedef struct {
        GListener glListener;    
        GHandle   ghContainer;       GContainerObject gObjContainer;
        GHandle   ghMainLabel;       GLabelObject     gObjMainLabel;
        GHandle   ghList;            GListObject      gObjList;    
        GHandle   ghReturn;          GButtonObject    gObjReturn;
        GHandle   ghLoad;            GButtonObject    gObjLoad;
    } GUI_MANAGEPROG_MENU;
     

    //// Плей лист  (360 байт)
    typedef struct {
        GListener glListener;    
        GHandle   ghContainer;       GContainerObject gObjContainer;
        GHandle   ghMainLabel;       GLabelObject     gObjMainLabel;
        GHandle   ghList;            GListObject      gObjList;    
        GHandle   ghUpdate;          GButtonObject    gObjUpdate;
        GHandle   ghReturn;          GButtonObject    gObjReturn;
        GHandle   ghLoad;            GButtonObject    gObjLoad;
    } GUI_PLAYLIST_MENU;

    typedef struct {
       GListener glListener;    
       GHandle   ghContainer;       GContainerObject gObjContainer;
       GHandle   ghMainLabel;       GLabelObject     gObjMainLabel;
       GHandle   ghAmplifier;       GButtonObject    gObjAmplifier;
       GHandle   ghUSB;             GButtonObject    gObjUSB;
       GHandle   ghLAN;             GButtonObject    gObjLAN;    
       GHandle   ghSDCards;         GButtonObject    gObjSDCards;
       GHandle   ghSecurity;        GButtonObject    gObjSecurity;
       GHandle   ghWaterLevel;      GButtonObject    gObjWaterLevel;
       GHandle   ghDataTime;        GButtonObject    gObjDataTime;
       GHandle   ghReturn;          GButtonObject    gObjReturn;
    } GUI_CUSTOM_MENU;

    GUI_MANAGEPROG_MENU  m_ManageProgMenu;

    GUI_CUSTOM_MENU  m_CustomMenu;

    GUI_PLAYLIST_MENU  m_PlayListMenu;

    GUI_MANAGEPROG_MENU  m_ManageProgMenu;

     

    ...

        geventListenerInit(&m_MainMenu.glListener);
        gwinAttachListener(&m_MainMenu.glListener);
        
        geventRegisterCallback(&m_MainMenu.glListener, gui_MainMenu_cb, (void *)&m_MainMenu.ghCustoms);
        geventRegisterCallback(&m_MainMenu.glListener, gui_MainMenu_cb, (void *)&m_MainMenu.ghManagedProgramm);
        geventRegisterCallback(&m_MainMenu.glListener, gui_MainMenu_cb, (void *)&m_MainMenu.ghPlayList);

     

        geventListenerInit(&m_PlayListMenu.glListener);
        gwinAttachListener(&m_PlayListMenu.glListener);
        geventRegisterCallback(&m_PlayListMenu.glListener, gui_PlayListMenu_cb, (void *)&m_PlayListMenu.ghList);
        geventRegisterCallback(&m_PlayListMenu.glListener, gui_PlayListMenu_cb, (void *)&m_PlayListMenu.ghReturn);
        geventRegisterCallback(&m_PlayListMenu.glListener, gui_PlayListMenu_cb, (void *)&m_PlayListMenu.ghLoad);
        geventRegisterCallback(&m_PlayListMenu.glListener, gui_PlayListMenu_cb, (void *)&m_PlayListMenu.ghUpdate); 

     

        geventListenerInit(&m_ManageProgMenu.glListener);
        gwinAttachListener(&m_ManageProgMenu.glListener);    
        geventRegisterCallback(&m_ManageProgMenu.glListener, gui_ManageProgMenu_cb, (void *)&m_ManageProgMenu.ghList);
        geventRegisterCallback(&m_ManageProgMenu.glListener, gui_ManageProgMenu_cb, (void *)&m_ManageProgMenu.ghReturn);
        geventRegisterCallback(&m_ManageProgMenu.glListener, gui_ManageProgMenu_cb, (void *)&m_ManageProgMenu.ghLoad);

     

        geventListenerInit(&m_CustomMenu.glListener);
        gwinAttachListener(&m_CustomMenu.glListener);    
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghAmplifier);
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghUSB);
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghLAN);
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghSDCards);
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghSecurity);    
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghWaterLevel);
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghDataTime);    
        geventRegisterCallback(&m_CustomMenu.glListener, gui_CustomMenu_cb, (void *)&m_CustomMenu.ghReturn);

     

     

     

    void gui_MainMenu_cb(void* param,GEvent *pe)
    {
        switch(pe->type)
        {
            case GEVENT_GWIN_BUTTON:
                printf("000000000000\n\r");
            break;
            default:
            break;            
        };
    }

    void gui_PlayListMenu_cb(void* param,GEvent *pe)
    {
        switch(pe->type)
        {
            case GEVENT_GWIN_BUTTON:
                printf("222222222222\n\r");
            break;
            case GEVENT_GWIN_LIST:
                printf("222222222222\n\r");
            break;
            default:
            break;
            
        };
    }

    void gui_ManageProgMenu_cb(void* param,GEvent *pe)
    {
        switch(pe->type)
        {
            case GEVENT_GWIN_BUTTON:
                printf("111111111111\n\r");
            break;
            case GEVENT_GWIN_LIST:
                printf("111111111111111\n\r");
            break;
            default:
            break;            
        };
    }

    void gui_CustomMenu_cb(void* param,GEvent *pe)
    {
        switch(pe->type)
        { 
            case GEVENT_GWIN_BUTTON:
                printf("3333333333333\n\r");
            break;
            case GEVENT_GWIN_LIST:
                printf("3333333\n\r");
            default:
            break;            

       }

    }
       

     

     

     

     

  2. stm32h7 fmc sd1963 800x480 working ok

    in Development and Feedback

    Posted · Edited by nicks1980

    MPU 

    int Mpu_Init(void)
{
    ///// SDIO
    MPU_Region_InitTypeDef MPU_InitStructSDIO;
    /// Disable the MPU
    HAL_MPU_Disable();

    /// Enable the MPU
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    MPU_Region_InitTypeDef MPU_InitStruct;
    HAL_MPU_Disable();
    MPU_InitStruct.Enable=MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress = 0x60000000;
    MPU_InitStruct.Size = MPU_REGION_SIZE_1MB; 
    MPU_InitStruct.AccessPermission=MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.TypeExtField=MPU_TEX_LEVEL0;
    MPU_InitStruct.IsCacheable=MPU_ACCESS_NOT_CACHEABLE;
    MPU_InitStruct.IsBufferable=MPU_ACCESS_BUFFERABLE;
    MPU_InitStruct.IsShareable=MPU_ACCESS_SHAREABLE;
    MPU_InitStruct.Number=MPU_REGION_NUMBER0;
    MPU_InitStruct.SubRegionDisable=0x00;
    MPU_InitStruct.DisableExec=MPU_INSTRUCTION_ACCESS_ENABLE;
    HAL_MPU_ConfigRegion(&MPU_InitStruct);
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

/// board_H..
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H


#define LCD_PIN_PWM           GPIO_PIN_13
#define LCD_PORT_PWM          GPIOD

#define LCD_PIN_RESET         GPIO_PIN_11
#define LCD_PORT_RESET        GPIOD

#define SSD1963_DELAY(ms)        gfxSleepMilliseconds(ms)
#define SSD1963_RESET_PIN_SET    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_11,GPIO_PIN_SET);
#define SSD1963_RESET_PIN_RESET  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_11,GPIO_PIN_RESET);    

#define SSD1963_REG              (*((volatile unsigned short *) 0x60000000))
#define SSD1963_RAM              (*((volatile unsigned short *) 0x60040000))
#define SSD1963_WRITE_CMD(cmd)    SSD1963_REG=((unsigned short)cmd)
#define SSD1963_WRITE_DATA(data)  SSD1963_RAM=((unsigned short)data)
#define SSD1963_READ_DATA()       SSD1963_RAM
/*
static const LCD_Parameters	DisplayTimings[] = {
	// You need one of these array elements per display
	{
		800, 480,								// Panel width and height
		0, 0, 48,								// Horizontal Timings (back porch, front porch, pulse)
		CALC_PERIOD(800,0,0,48),				// Total Horizontal Period (calculated from above line)
		2, 2, 10,								// Vertical Timings (back porch, front porch, pulse)
		CALC_PERIOD(480,2,2,10),				// Total Vertical Period (calculated from above line)
		CALC_FPR(800,480,2,2,48,2,2,10,60ULL),	// FPR - the 60ULL is the frames per second. Note the ULL!
		gFalse,									// Flip horizontally
		gFalse									// Flip vertically
	},
};*/
#define PANEL_WIDTH               800
#define PANEL_HEIGHT              480
#define HORIZONTAL_BACK_PORCH     46
#define HORIZONTAL_FRONT_PORCH    210
#define HORIZONTAL_PULSE_WIDTH    1
#define HORIZONTAL_TOTAL          1056
#define VERTICAL_BACK_PORCH       23
#define VERTICAL_FRONT_PORCH      22
#define VERTICAL_PULSE_WIDTH      1
#define VERTICAL_TOTAL            525

static const LCD_Parameters DisplayTimings[] = {
        // You need one of these array elements per display
        {
        PANEL_WIDTH, PANEL_HEIGHT,
        HORIZONTAL_BACK_PORCH,  HORIZONTAL_FRONT_PORCH, HORIZONTAL_PULSE_WIDTH,
        CALC_PERIOD(PANEL_WIDTH,HORIZONTAL_BACK_PORCH,  HORIZONTAL_FRONT_PORCH,HORIZONTAL_BACK_PORCH), ///  HORIZONTAL_TOTAL
        VERTICAL_BACK_PORCH,      VERTICAL_FRONT_PORCH, VERTICAL_PULSE_WIDTH,
        CALC_PERIOD(PANEL_HEIGHT, VERTICAL_BACK_PORCH,      VERTICAL_FRONT_PORCH,HORIZONTAL_BACK_PORCH),
        //CALC_FPR(PANEL_WIDTH,480,2,2,48,2,2,10,60ULL)
        HORIZONTAL_TOTAL * VERTICAL_TOTAL * 60ULL * 1048576 / 100000000,
		gFalse,									// Flip horizontally
		gTrue									// Flip vertically
        },
};

static GFXINLINE void init_board(GDisplay *g)
{
	(void) g;
    GPIO_InitTypeDef          gpio = {0};
    SRAM_HandleTypeDef        hsram1 = {0};
    FMC_NORSRAM_TimingTypeDef Timing = {0};
    FMC_NORSRAM_TimingTypeDef ExtTiming = {0};
    
    
    /// Pwm
    gpio.Pin   = LCD_PIN_PWM;
    gpio.Mode  = GPIO_MODE_OUTPUT_PP;
    gpio.Pull  = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(LCD_PORT_PWM, &gpio);
    
    /// Reset
    gpio.Pin   = LCD_PIN_RESET;
    gpio.Mode  = GPIO_MODE_OUTPUT_PP;
    gpio.Pull  = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(LCD_PORT_RESET, &gpio);
    

    __HAL_RCC_FMC_CLK_ENABLE();
    /// FMC GPIO Configuration
    /// PE7   ------> FMC_D4
    /// PE8   ------> FMC_D5
    /// PE9   ------> FMC_D6
    /// PE10   ------> FMC_D7
    /// PE11   ------> FMC_D8
    /// PE12   ------> FMC_D9
    /// PE13   ------> FMC_D10
    /// PE14   ------> FMC_D11
    /// PE15   ------> FMC_D12
    /// PD8   ------> FMC_D13
    /// PD9   ------> FMC_D14
    /// PD10   ------> FMC_D15
    /// PD12   ------> FMC_A17
    /// PD14   ------> FMC_D0
    /// PD15   ------> FMC_D1
    /// PD0   ------> FMC_D2
    /// PD1   ------> FMC_D3
    /// PD4   ------> FMC_NOE
    /// PD5   ------> FMC_NWE
    /// PD7   ------> FMC_NE1
    gpio.Pin = GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10 
              |GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14 
              |GPIO_PIN_15;

    gpio.Mode      = GPIO_MODE_AF_PP;
    gpio.Pull      = GPIO_NOPULL;
    gpio.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    gpio.Alternate = GPIO_AF12_FMC;
    HAL_GPIO_Init(GPIOE, &gpio);

    gpio.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_12 
              |GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_0|GPIO_PIN_1 
              |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_7;
                          
    gpio.Mode = GPIO_MODE_AF_PP;
    gpio.Pull = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    gpio.Alternate = GPIO_AF12_FMC;
    HAL_GPIO_Init(GPIOD, &gpio);
    
    /// USER CODE BEGIN FMC_MspInit 1
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_11,GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_SET);

    /// Perform the SRAM1 memory initialization sequence
    hsram1.Instance = FMC_NORSRAM_DEVICE;
    hsram1.Extended = FMC_NORSRAM_EXTENDED_DEVICE;
    /// hsram1.Init
    hsram1.Init.NSBank = FMC_NORSRAM_BANK1;
    hsram1.Init.DataAddressMux = FMC_DATA_ADDRESS_MUX_DISABLE;
    hsram1.Init.MemoryType = FMC_MEMORY_TYPE_SRAM;
    hsram1.Init.MemoryDataWidth = FMC_NORSRAM_MEM_BUS_WIDTH_16;
    hsram1.Init.BurstAccessMode = FMC_BURST_ACCESS_MODE_DISABLE;
    hsram1.Init.WaitSignalPolarity = FMC_WAIT_SIGNAL_POLARITY_LOW;
    hsram1.Init.WaitSignalActive = FMC_WAIT_TIMING_BEFORE_WS;
    hsram1.Init.WriteOperation = FMC_WRITE_OPERATION_ENABLE;
    hsram1.Init.WaitSignal = FMC_WAIT_SIGNAL_DISABLE;
    hsram1.Init.ExtendedMode = FMC_EXTENDED_MODE_ENABLE;
    hsram1.Init.AsynchronousWait = FMC_ASYNCHRONOUS_WAIT_DISABLE;
    hsram1.Init.WriteBurst = FMC_WRITE_BURST_DISABLE;
    hsram1.Init.ContinuousClock = FMC_CONTINUOUS_CLOCK_SYNC_ONLY;
    hsram1.Init.WriteFifo = FMC_WRITE_FIFO_ENABLE;
    hsram1.Init.PageSize = FMC_PAGE_SIZE_NONE;
    /// Timing
    Timing.AddressSetupTime = 3;
    Timing.AddressHoldTime = 15;
    Timing.DataSetupTime = 14;
    Timing.BusTurnAroundDuration = 0;
    Timing.CLKDivision = 16;
    Timing.DataLatency = 17;
    Timing.AccessMode = FMC_ACCESS_MODE_A;
    /// ExtTiming
    ExtTiming.AddressSetupTime = 1;
    ExtTiming.AddressHoldTime = 15;
    ExtTiming.DataSetupTime = 2;
    ExtTiming.BusTurnAroundDuration = 0;
    ExtTiming.CLKDivision = 16;
    ExtTiming.DataLatency = 17;
    ExtTiming.AccessMode = FMC_ACCESS_MODE_A;
    
    if (HAL_SRAM_Init(&hsram1, &Timing, &ExtTiming) != HAL_OK)
    {
        Error_Handler( );
    }    
    
}

static GFXINLINE void post_init_board(GDisplay *g)
{
	(void) g;
}

static GFXINLINE void setpin_reset(GDisplay *g, gBool state) {
	(void) g;
	(void) state;
    if(state==gFalse)
    {
        printf("SSD1963_RESET_PIN_SET\n\r");
        SSD1963_RESET_PIN_SET;
    }
    else
    {
        printf("SSD1963_RESET_PIN_RESET\n\r");
        SSD1963_RESET_PIN_RESET;
    }
}

static GFXINLINE void acquire_bus(GDisplay *g) {
	(void) g;
}

static GFXINLINE void release_bus(GDisplay *g) {
	(void) g;
}

static GFXINLINE void write_index(GDisplay *g, gU16 index) {
	(void) g;
	(void) index;
    SSD1963_WRITE_CMD(index); 
}

static GFXINLINE void write_data(GDisplay *g, gU16 data) {
	(void) g;
	(void) data;
    SSD1963_WRITE_DATA(data);
}

#endif /* _GDISP_LLD_BOARD_H */


/// gdisp_lld_ssd1963
LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g)
{
    unsigned short color_bus;
    acquire_bus(g);
    set_viewport(g);
    write_index(g, SSD1963_READ_MEMORY_START);
    color_bus = SSD1963_READ_DATA();
    release_bus(g);
    return  (color_t)color_bus ;
}

LLDSPEC gBool gdisp_lld_init(GDisplay *g)
{
	LCD_Parameters *	lcdp;

    ///	Some displays (e.g. Displaytech) have an on-board setup process which just requires that we don't touch anything for a time after power up.
    /// For this type of display define GDISP_SSD1963_NO_INIT as TRUE, and implement an appropriate delay in the board file.
    ///	With such displays we can skip most of the initialisation. We also skip pulsing the reset pin, since it
    ///	will introduce an extra second or so of display to the startup time.
   
	// The private area for this controller is the LCD timings
	lcdp = (void *)&DisplayTimings[g->controllerdisplay];
	g->priv = lcdp;

	// Initialise the board interface
	init_board(g);
 

///	Some displays (e.g. Displaytech) have an on-board setup process which just requires that we don't touch anything for a time after power up.
///	For this type of display define GDISP_SSD1963_NO_INIT as GFXON, and implement an appropriate delay in the board file.
///	With such displays we can skip most of the initialisation. We also skip pulsing the reset pin, since it
///	will introduce an extra second or so of display to the startup time.
 
	// The private area for this controller is the LCD timings
	lcdp = (void *)&DisplayTimings[g->controllerdisplay];
	g->priv = lcdp;

	// Initialise the board interface
	//init_board(g);

	#if !GDISP_SSD1963_NO_INIT
		// Hardware reset
		setpin_reset(g, gTrue);
		gfxSleepMilliseconds(5);
		setpin_reset(g, gFalse);
		gfxSleepMilliseconds(5);
	#endif

	// Get the bus for the following initialisation commands
	acquire_bus(g);

	#if !GDISP_SSD1963_NO_INIT
		write_index(g, SSD1963_SOFT_RESET);             // Software reset - clears almost everything (apart from PLL)
		write_index(g, SSD1963_SOFT_RESET);             // Software reset - clears almost everything (apart from PLL)
		write_index(g, SSD1963_SOFT_RESET);             // Software reset - clears almost everything (apart from PLL)
		gfxSleepMilliseconds(5);
		/// Driver PLL config
		write_index(g, SSD1963_SET_PLL_MN);
		write_data(g, 35);								// PLLclk = REFclk (10Mhz) * 36 (360Mhz)
		write_data(g, 2);								// SYSclk = PLLclk / 3  (120MHz)
		write_data(g, 54);								// Apply calculation bit, else it is ignored        
        
		write_reg(g, SSD1963_SET_PLL, 0x01);			// Enable PLL
		gfxSleepMilliseconds(5);                
        /*write_reg(g, SSD1963_SET_PLL, 0x03);			// Use PLL
        */
        write_index(g, SSD1963_SET_PLL);        
        gfxSleepMilliseconds(1);  /// !!!!
        write_data(g, 0x03);
        gfxSleepMilliseconds(1); /// !!!!
        
        //SSD1963_WRITE_CMD(0x00E6);              /// PLL setting for PCLK, depends on resolution
        //SSD1963_WRITE_DATA(0x0003);
        //SSD1963_WRITE_DATA(0x00FF);
        //SSD1963_WRITE_DATA(0x00FF);

		/// LCD panel parameters
		write_index(g, SSD1963_SET_LCD_MODE);
		write_data(g, lcdp->mode & 0xFF);
		write_data(g, (lcdp->mode >> 8) & 0xFF);
		///	write_data(g, 0x18);					//Enabled dithering
		///	write_data(g, 0x00);
		write_data16(g, lcdp->width-1);
		write_data16(g, lcdp->height-1);
		write_data(g, 0x00);							// RGB - line sequences for serial TFT
	#endif

	/// Display flipping
	if (lcdp->flipHorz)
    {
		write_reg(g, SSD1963_SET_ADDRESS_MODE, SSD1963_ADDR_MODE_FLIP_HORZ);
	} else if (lcdp->flipVert)
    {
		write_reg(g, SSD1963_SET_ADDRESS_MODE, SSD1963_ADDR_MODE_FLIP_VERT);
	} else if (lcdp->flipHorz && lcdp->flipVert)
    {
		write_reg(g, SSD1963_SET_ADDRESS_MODE, SSD1963_ADDR_MODE_FLIP_VERT | SSD1963_ADDR_MODE_FLIP_HORZ);
	}
    else
    {
		write_reg(g, SSD1963_SET_ADDRESS_MODE, 0x00);
	}


	write_reg(g, SSD1963_SET_PIXEL_DATA_INTERFACE, SSD1963_PDI_16BIT565);
	write_reg(g, SSD1963_SET_PIXEL_FORMAT, 0x50);
    

	#if !GDISP_SSD1963_NO_INIT
		/// LCD Clock specs
        
		write_index(g, SSD1963_SET_LSHIFT_FREQ);
		write_data(g, (lcdp->fpr >> 16) & 0xFF);
		write_data(g, (lcdp->fpr >> 8) & 0xFF);
		write_data(g, lcdp->fpr & 0xFF);

		write_index(g, SSD1963_SET_HORI_PERIOD);
		write_data16(g, lcdp->hperiod);
		write_data16(g, lcdp->hpulse + lcdp->hbporch);        
		write_data(g, lcdp->hpulse - 1);
		write_data(g, 0x00);
		write_data(g, 0x00);
		write_data(g, 0x00);


		write_index(g, SSD1963_SET_VERT_PERIOD);
		write_data16(g, lcdp->vperiod);
		write_data16(g, lcdp->vpulse + lcdp->vbporch);
		write_data(g, lcdp->vpulse - 1);
		write_data(g, 0x00);
		write_data(g, 0x00);

		#if 0
			/// Enable DBC to control Backlight
			write_index(g, SSD1963_SET_DBC_CONF);
			write_data(g, 0x2F);
		#endif
	#endif

/*
	#if 0
		/// Tear effect indicator ON. This is used to tell the host MCU when the driver is not refreshing the panel (during front/back porch) 
		write_reg(g, SSD1963_SET_TEAR_ON, 0x00);
	#endif
*/

	/// Turn on
	write_index(g, SSD1963_SET_DISPLAY_ON);
	
	/// Turn on the back-light
	set_backlight(g, GDISP_INITIAL_BACKLIGHT);

	// Finish Init
	post_init_board(g);

	// Release the bus
	release_bus(g);

	/// Initialise the GDISP structure
    
	g->g.Width = lcdp->width;
	g->g.Height = lcdp->height;
	g->g.Orientation = gOrientation0;
	g->g.Powermode = gPowerOn;
	g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
	g->g.Contrast = GDISP_INITIAL_CONTRAST;
    
    HAL_GPIO_WritePin(LCD_PORT_PWM, LCD_PIN_PWM, GPIO_PIN_SET);
	return gTrue;
}

     

×
×
  • Create New...