void u8g_com_arduino_fast_parallel_write(u8g_t *u8g, uint8_t val)
{
U8G_ATOMIC_START();
u8g_com_arduino_fast_write_data_pin( 0, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 1, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 2, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 3, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 4, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 5, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 6, val&1 );
val >>= 1;
u8g_com_arduino_fast_write_data_pin( 7, val&1 );
val >>= 1;
U8G_ATOMIC_END();
/* EN cycle time must be 1 micro second */
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH);
u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW);
u8g_10MicroDelay(); /* ST7920 commands: 72us */
u8g_10MicroDelay(); /* ST7920 commands: 72us */
}
static void u8g_com_arduino_st7920_write_byte_seq(uint8_t rs, uint8_t *ptr, uint8_t len)
{
uint8_t i;
if ( rs == 0 )
{
/* command */
u8g_com_arduino_do_shift_out_msb_first(0x0f8);
}
else if ( rs == 1 )
{
/* data */
u8g_com_arduino_do_shift_out_msb_first(0x0fa);
}
while( len > 0 )
{
u8g_com_arduino_do_shift_out_msb_first(*ptr & 0x0f0);
u8g_com_arduino_do_shift_out_msb_first(*ptr << 4);
ptr++;
len--;
u8g_10MicroDelay();
}
for( i = 0; i < 4; i++ )
u8g_10MicroDelay();
}
static void u8g_com_rx_st7920_write_byte_hw_spi_seq(u8g_t *u8g, uint8_t rs, uint8_t *ptr, uint8_t len)
{
uint8_t i;
if ( rs == 0 )
{
/* command */
u8g_rx_st7920_hw_spi_shift_out(u8g, 0x0f8);
}
else if ( rs == 1 )
{
/* data */
u8g_rx_st7920_hw_spi_shift_out(u8g, 0x0fa);
}
while( len > 0 )
{
u8g_rx_st7920_hw_spi_shift_out(u8g, *ptr & 0x0f0);
u8g_rx_st7920_hw_spi_shift_out(u8g, *ptr << 4);
ptr++;
len--;
u8g_10MicroDelay();
}
for( i = 0; i < 1; i++ )
u8g_10MicroDelay();
}
void u8g_com_arduino_parallel_write(u8g_t *u8g, uint8_t val)
{
u8g_com_arduino_digital_write(u8g, U8G_PI_D0, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D1, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D2, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D3, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D4, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D5, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D6, val&1);
val >>= 1;
u8g_com_arduino_digital_write(u8g, U8G_PI_D7, val&1);
/* EN cycle time must be 1 micro second, digitalWrite is slow enough to do this */
u8g_Delay(1);
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH);
u8g_Delay(1);
u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW);
u8g_10MicroDelay(); /* ST7920 commands: 72us */
u8g_Delay(2);
}
static void u8g_com_rx_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val)
{
uint8_t i;
if ( rs == 0 )
{
/* command */
u8g_rx_st7920_hw_spi_shift_out(u8g, 0x0f8);
}
else if ( rs == 1 )
{
/* data */
u8g_rx_st7920_hw_spi_shift_out(u8g, 0x0fa);
}
else
{
/* do nothing, keep same state */
}
u8g_rx_st7920_hw_spi_shift_out(u8g, val & 0x0f0);
u8g_rx_st7920_hw_spi_shift_out(u8g, val << 4);
for( i = 0; i < 1; i++ )
u8g_10MicroDelay();
}
//SpeedSet:
//SPI_BAUDRATEPRESCALER_2
//SPI_BAUDRATEPRESCALER_4
//SPI_BAUDRATEPRESCALER_8
//SPI_BAUDRATEPRESCALER_16
static void spi_init(SPI_BaudRatePrescaler_TypeDef SPI_BaudRatePrescaler)
{
GPIO_Init(LCD_CS_PIN,GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_Init(LCD_CD_PIN,GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_Init(LCD_RST_PIN,GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_Init(LCD_LIGHT_PIN,GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_Init(SPI_SCK_PIN,GPIO_MODE_OUT_PP_LOW_FAST);
GPIO_Init(SPI_MOSI_PIN,GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_Init(SPI_MISO_PIN,GPIO_MODE_IN_PU_NO_IT);
//打开flash电源 开发板独有
GPIO_Init(GPIOE,GPIO_PIN_0,GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_WriteHigh(GPIOE,GPIO_PIN_0);
//打开背光
GPIO_WriteLow(LCD_LIGHT_PIN);
GPIO_WriteLow(LCD_RST_PIN);
u8g_10MicroDelay();
GPIO_WriteHigh(LCD_RST_PIN);
//关闭FLASH CS
GPIO_WriteLow(GPIOG,GPIO_PIN_0);
//初始化SPI
SPI_DeInit();
SPI_Init(SPI_FIRSTBIT_MSB, SPI_BaudRatePrescaler, SPI_MODE_MASTER, SPI_CLOCKPOLARITY_LOW, SPI_CLOCKPHASE_1EDGE, SPI_DATADIRECTION_2LINES_FULLDUPLEX, SPI_NSS_SOFT, 0x00);
SPI_Cmd(ENABLE);
}
uint8_t u8g_com_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
{
/* the last set state of the data/command pin */
static uint8_t command = 0;
switch(msg)
{
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_INIT:
/* SPI initialization should be done before U8G is initialized */
break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
/* if the requested state is different from the current state */
if(arg_val != command)
{
/* Wait until the transmission is complete before changing state */
while(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);
while(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET);
command = arg_val;
}
GPIO_WriteBit(SPIx_SCR_DC_GPIO_PORT, SPIx_SCR_DC_PIN, command);
break;
case U8G_COM_MSG_CHIP_SELECT:
/* Wait until the transmission is complete before changing the chip select state */
while(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);
while(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET);
GPIO_WriteBit(SPIx_SCR_DC_GPIO_PORT, SPIx_SCR_CS_PIN, !(arg_val > 0));
break;
case U8G_COM_MSG_RESET:
GPIO_WriteBit(SPIx_SCR_RS_GPIO_PORT, SPIx_SCR_RS_PIN, arg_val);
u8g_10MicroDelay();
break;
case U8G_COM_MSG_WRITE_BYTE:
screen_tx(SPIx, arg_val, command);
break;
case U8G_COM_MSG_WRITE_SEQ:
case U8G_COM_MSG_WRITE_SEQ_P:
{
//uint8_t *ptr = arg_ptr;
screen_tx_seq(SPIx, arg_ptr, arg_val, command);
}
break;
}
return 1;
}
uint8_t u8g_com_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
{
switch(msg)
{
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_INIT:
u8g_MicroDelay();
break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
u8g_10MicroDelay();
if (arg_val == 0)
{
control = 0;
}
else
{
control = 0x40;
}
break;
case U8G_COM_MSG_WRITE_BYTE:
{
uint8_t buffer[2];
buffer[0] = control;
buffer[1] = arg_val;
HAL_I2C_Master_Transmit(&I2C_HANDLER, DEVICE_ADDRESS, (uint8_t*) buffer, 2, I2C_TIMEOUT);
}
break;
case U8G_COM_MSG_WRITE_SEQ:
case U8G_COM_MSG_WRITE_SEQ_P:
{
uint8_t buffer[DATA_BUFFER_SIZE];
uint8_t *ptr = arg_ptr;
buffer[0] = control;
for (int i = 1; i <= arg_val; i++)
{
buffer[i] = *(ptr++);
}
HAL_I2C_Master_Transmit(&I2C_HANDLER, DEVICE_ADDRESS, (uint8_t *)buffer, arg_val, I2C_TIMEOUT);
}
break;
}
return 1;
}
static void u8g_com_atmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val)
{
uint8_t i;
if ( rs == 0 )
{
/* command */
u8g_atmega_st7920_hw_spi_shift_out(u8g, 0x0f8);
}
else if ( rs == 1 )
{
/* data */
u8g_atmega_st7920_hw_spi_shift_out(u8g, 0x0fa);
}
u8g_atmega_st7920_hw_spi_shift_out(u8g, val & 0x0f0);
u8g_atmega_st7920_hw_spi_shift_out(u8g, val << 4);
for( i = 0; i < 4; i++ )
u8g_10MicroDelay();
}
static void u8g_com_arduino_st7920_write_byte(uint8_t rs, uint8_t val)
{
uint8_t i;
if ( rs == 0 )
{
/* command */
u8g_com_arduino_do_shift_out_msb_first(0x0f8);
}
else if ( rs == 1 )
{
/* data */
u8g_com_arduino_do_shift_out_msb_first(0x0fa);
}
u8g_com_arduino_do_shift_out_msb_first(val & 0x0f0);
u8g_com_arduino_do_shift_out_msb_first(val << 4);
for( i = 0; i < 4; i++ )
u8g_10MicroDelay();
}
uint8_t u8g_com_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
{
register uint8_t *ptr = arg_ptr;
switch(msg)
{
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_INIT:
init_i2c();
//I2C_WrReg(0x80, 0xAE);
//I2C_WrReg(0x80, 0x8D);
//I2C_WrReg(0x80, 0x14);
//I2C_WrReg(0x80, 0xAF);
u8g_MicroDelay();
break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
if(arg_val == 0){
control = 0; //Send a Command (D/C# pin is low)
}
else{
control = 0x40; //send data
}
u8g_10MicroDelay();
break;
case U8G_COM_MSG_CHIP_SELECT:
break;
case U8G_COM_MSG_RESET:
break;
case U8G_COM_MSG_WRITE_BYTE:
I2C_WrReg(control, arg_val);
//u8g_i2c_start(0x78);
//u8g_i2c_send_byte(arg_val);
//u8g_i2c_stop();
u8g_MicroDelay();
break;
case U8G_COM_MSG_WRITE_SEQ:
case U8G_COM_MSG_WRITE_SEQ_P:
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY) == SET);
I2C_TransferHandling(I2C1, 0x78, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);
//Ensure the transmit interrupted flag is set
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TXIS) == RESET);
//Send the address of the register we wish to write to
I2C_SendData(I2C1, control);
//Ensure that the transfer complete reload flag is Set, essentially a standard
//TC flag
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TCR) == RESET);
I2C_TransferHandling(I2C1, 0x78, arg_val+1, I2C_AutoEnd_Mode, I2C_No_StartStop);
//Again, wait until the transmit interrupted flag is set
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TXIS) == RESET);
//Send the value you wish you write to the register
while( arg_val > 0 )
{
I2C_SendData(I2C1, *ptr++);
arg_val--;
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TXIS) == RESET);
//Wait for the stop flag to be set indicating a stop condition has been sent
}
I2C_TransferHandling(I2C1, 0x78, 0, I2C_AutoEnd_Mode, I2C_Generate_Stop);
//while(I2C_GetFlagStatus(I2C1,I2C_FLAG_STOPF) == RESET);
//I2C_ClearFlag(I2C1, I2C_FLAG_STOPF);
delay_micro_seconds(100);
//u8g_MicroDelay();
break;
}
return 1;
}
uint8_t u8g_com_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
{
switch(msg)
{
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_INIT:
if ( arg_val <= U8G_SPI_CLK_CYCLE_50NS )
{
spi_init(SPI_BAUDRATEPRESCALER_2);
}
else if ( arg_val <= U8G_SPI_CLK_CYCLE_300NS )
{
spi_init(SPI_BAUDRATEPRESCALER_4);
}
else if ( arg_val <= U8G_SPI_CLK_CYCLE_400NS )
{
spi_init(SPI_BAUDRATEPRESCALER_4);
}
else
{
spi_init(SPI_BAUDRATEPRESCALER_8);
}
u8g_MicroDelay();
break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
u8g_10MicroDelay();
set_gpio_level(LCD_CD_PIN, arg_val);
u8g_10MicroDelay();
break;
case U8G_COM_MSG_CHIP_SELECT:
if ( arg_val == 0 )
{
/* disable */
uint8_t i;
/* this delay is required to avoid that the display is switched off too early --> DOGS102 with LPC1114 */
for( i = 0; i < 5; i++ )u8g_10MicroDelay();
set_gpio_level(LCD_CS_PIN, 1);
}
else
{
/* enable */
set_gpio_level(LCD_CS_PIN, 0);
}
u8g_MicroDelay();
break;
case U8G_COM_MSG_RESET:
set_gpio_level(LCD_RST_PIN, arg_val);
u8g_10MicroDelay();
break;
case U8G_COM_MSG_WRITE_BYTE:
spi_out(arg_val);
u8g_MicroDelay();
break;
case U8G_COM_MSG_WRITE_SEQ:
case U8G_COM_MSG_WRITE_SEQ_P:
{
register uint8_t *ptr = arg_ptr;
while( arg_val > 0 )
{
spi_out(*ptr++);
arg_val--;
}
}
break;
}
return 1;
}
