【AT-START-F425 Review】No.06 Driving Segment LCD

韵湖葱白

【AT-START-F425 Review】No.06 Driving Segment LCD [Copy link]

 

## Preface: I made an SLCD screen when I was tinkering with GD32L233. I modified it and it ran on AT32F425. The board is actually quite simple. The board is as follows:  Among them: The R parameter in the signal pin RC parameter and the voltage divider resistor of VLCD can be directly referred to the manual. ## How to test the bare screen The bare screen is driven by AC signals. It is not possible to use DC directly. It must be tested with AC. Wrap a piece of wire around the AC line and you can test it.   ## The principle of segment code LCD The most critical driving condition parameters are generally: - duty = 1/number of com - bias = 1/(sqrt(duty)+1)  SLCD executes the scanning mode according to the duty cycle, so simply understand: - SEG = Address - COM = Data --- If we need to display the first digit as 2, then the corresponding [8], where: label 2, label 3, label 4, label 6, label 7 will light up. Referring to the SEG diagram, we know: - SEG 9 corresponds to label 1, label 2, label 3, label 4, a total of 4 segments. - SEG 10 corresponds to label 5, label 6, label 7, a total of 3 segments (we don't use the battery icon). To light up label 2, label 3, label 4, label 6, label 7, then: - SEG 9: COM0 (label 4), COM1 (label 3), COM2 (label 2) are 1. - SEG 10: COM2 (label 3), COM3 (label 2) are 1. It is the following table: | | COM0 | COM1 | COM2 | COM3 | | --- | --- | --- | --- | | SEG9 | 1 | 1 | 1 | 0 | | SEG10 | 0 | 0 | 1 | 1 | That is, writing 0xE and 0x3 to these two addresses will display the number 2. Do you understand? ！ ## The GPIO port of AT32 only talks about the differences with STM32 and GD32. ### The driving capability of GPIO is defined by 2 macros. ``` GPIO_DRIVE_STRENGTH_STRONGER = 0x01, /*!< stronger sourcing/sinking strength */ GPIO_DRIVE_STRENGTH_MODERATE = 0x02 /*!< moderate sourcing/sinking strength */ ``` ### The GPIO multiplexing defines the SOURCE for each pin separately, and the encapsulation adds another function. GPIO encapsulation interface: ``` static gpio_pins_source_type get_gpio_pins_source(uint32_t pin) { switch (pin) { case GPIO_PINS_0: return GPIO_PINS_SOURCE0; case GPIO_PINS_1: return GPIO_PINS_SOURCE1; case GPIO_PINS_2: return GPIO_PINS_SOURCE2; case GPIO_PINS_3: return GPIO_PINS case GPIO_PINS_4: return GPIO_PINS_SOURCE4; case GPIO_PINS_5: return GPIO_PINS_SOURCE5; case GPIO_PINS_6: return GPIO_PINS_SOURCE6; case GPIO_PINS_7: return GPIO_PINS_SOURCE7; case GPIO_PINS_8: return GPIO_PINS_SOURCE8; case GPIO_PINS_9: return GPIO_PINS_SOURCE9; case GPIO_PINS_10: return GPIO_PINS_SOURCE10; case GPIO_PINS_11: return GPIO_PINS_SOURCE11; case GPIO_PINS_12: return GPIO_PINS_SOURCE12; case GPIO_PINS_13: return GPIO_PINS_SOURCE13 ; case GPIO_PINS_14: return GPIO_PINS_SOURCE14; case GPIO_PINS_15: return GPIO_PINS_SOURCE15; default: return GPIO_PINS_SOURCE0; } } void gpio_init_af_mode(crm_periph_clock_type rcu, gpio_type * gpio, uint32_t pin, uint32_t speed, uint32_t af_func) { gpio_init_type gpio_init_struct; crm_periph_clock_enable(rcu, TRUE); gpio_default_para_init(&gpio_init_struct); gpio_init_struct.gpio_drive_strength = (gpio_drive_type)speed; gpio_init_struct.gpio_out _type = GPIO_OUTPUT_PUSH_PULL; gpio_init_struct.gpio_mode = GPIO_MODE_MUX; gpio_init_struct.gpio_pins = pin; gpio_init_struct.gpio_pull = GPIO_PULL_NONE; gpio_init(gpio, &gpio_init_struct); gpio_pin_mux_config(gpio, get_gpio_pins_source(pin), (gpio_mux_sel_type)af_func); } void gpio_init_output_mode(crm_peri ph_clock_type rcu, gpio_type * gpio, uint32_t pin, uint32_t speed, uint8_t set) { gpio_init_type gpio_init_struct; crm_periph_clock_enable(rcu, TRUE); gpio_default_para_init(&gpio_init_struct); gpio_init_struct.gpio_drive_strength = (gpio_drive_type)speed; gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL; gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT; gpio_init_struct.gpio_pins = pin; gpio_init_struct.gpio_pull = GPIO_PULL_NONE; gpio_init(gpio, &gpio_init_struct); if (set) { gpio_bits_set(gpio, pin); } else { gpio_bits_reset(gpio, pin); } } ``` ## Driver code has a bunch of register configurations, please refer to the chip manual. I am lazy and just posted it. [Description] The timing of SLCD switching is very short, so just use counting to delay. This code is almost the same as the GD32L233 code, except that the defined pins and interface macro definitions have changed. This is the benefit of having a well-designed architecture. ``` //#define SLCD_USING_SPI #if defined(SPI1_FOR_SLCD) /* SPI1:PB13-SCK-SPI_SCK PB14-CE-SPI_MISO PB15-DATA-SPI_MOSI */ #define CURRENT_SPI SPI1 #define CURRENT_SPI_RCU RCU_SPI1 #define SLCD_RCU CRM_GPIOB_PER IPH_CLOCK #define SLCD_GPIO GPIOB #define SLCD_WR_CLK_PIN GPIO_PINS_13 #define SLCD_CS_PIN GPIO_PINS_14 #define SLCD_DATA_PIN GPIO_PINS_15 #ifdef SLCD_USING_SPI #else #define CS_HIGH gpio_bits_set(SLCD_GPIO, SLCD_CS_PIN); #define CS_LOW gpio_bits_reset(SLCD_GPIO, SLCD_CS_PIN); #define WR_CLK_HIGH gpio_bits_set(SLCD_GPIO, SLCD_WR_CLK_PIN); #define WR_CLK_LOW gpio_bits_reset(SLCD_GPIO, SLCD_WR_CLK_PIN); #define DATA_HIGH gpio_bits_set(SLCD_GP IO, SLCD_DATA_PIN); #define DATA_LOW gpio_bits_reset(SLCD_GPIO, SLCD_DATA_PIN); #define DATA gpio_input_data_bit_read(SLCD_GPIO, SLCD_DATA_PIN) #endif // SLCD command code #define CTRL_CMD 0x80 //Write control command #define DATA_CMD 0xA0 //Write data command #define LCD_ON 0x06 //Open LCD 1000 0000 011x #define LCD_OFF 0x04 //Turn off LCD 1000 0000 010x #define SYS_EN 0x02 //System oscillator on 1000 0000 001x #define RC_OSC 0x30 //Internal RC oscillator (default 256K at power-on) 1000 0011 0XXX #define COM_BIAS 0x52 //4COM,1/3bias 1000 010 10X1X #define SLCD_OFF send_cmd_slcd(LCD_OFF) #define SLCD_ON send_cmd_slcd(LCD_ON) #define SLCD_SYS_EN send_cmd_slcd(SYS_EN) #define SLCD_RC_OSC send_cmd_slcd(RC_OSC) #define SLCD_COM_BIAS send_cmd_slcd(COM_BIAS) //,C,c,d,E,F,H,h,L,n,N,o,P,r,t,U,-, ,*/ //,,0x1D,0x0E ,0x6E,0x1F,0x17,0x67,0x47,0x0D,0x46,0x75,0x37,#define DISP_0 0xD7 #define DISP_1 0x06 #define DISP_2 0xE3 #define DISP_3 0xA7 #define DISP_4 0x36 #define DISP_5 0xB5 #define DISP_6 0xF5 #define DISP_7 0x07 #define DISP_8 0xF7 #define DISP_9 0xB7 #define DISP_A 0x77 #define DISP_B 0xF7 #define DISP_b 0xF4 #define DISP_C 0xD1 #define DISP_D 0xD7 #define DISP_c 0xE0 #define DISP_d 0xE6 #define DISP_E 0xF1 #define DISP_F 0x71 #define DISP_H 0x76 #define DISP_h 0x74 #define DISP_L 0xD0 #define DISP_n 0x64 #define DISP_N 0x57 #define DISP_o 0xE4 #define DISP_P 0x73 #define DISP_r 0x60 #define DISP_t 0xF0 #define DISP_U 0xD6 #define DISP__ 0x20 #define DISP_E MPTY 0x00 void spi5_init(){} #ifdef SLCD_USING_SPI void spi1_init() { } #else void spi1_init() { gpio_init_output_mode(SLCD_RCU, SLCD_GPIO, SLCD_WR_CLK_PIN, GPIO_DRIVE_STRENGTH_MODERATE, 0); gpio_init_output_mode(SLCD_RCU, SLCD_GPIO, SLCD_CS_PIN, GPIO_DRIVE_STRENGTH_MODERATE, 0); gpio_init_output_mode(SLCD_RCU, SLCD_GPIO, SLCD_DATA_PIN, GPIO_DRIVE_STRENGTH_STRONGER, 0); } static void slcd_delay(int count) { while (count) { count--; } } void send_bit_slcd(uint8_t s dat, uint8_t cnt) { //Write the high cnt bit of data, high bit first uint8_t i; for(i = 0; i < cnt; i++) { WR_CLK_LOW; slcd_delay(20); if(sdat&0x80) { DATA_HIGH; } else { DATA_LOW; } slcd_delay (20); WR_CLK_HIGH; slcd_delay(20); sdat<<=1; } slcd_delay(20); } void send_cmd_slcd(uint8_t command) { //Send command CS_LOW; send_bit_slcd(CTRL_CMD, 4); //Write flag code b100 send_bit_slcd(command, 8); //No For commands with the highest bit as 1, directly write the highest bit of the command to 0 CS_HIGH; } void write_slcd(uint8_t addr, uint8_t sdat) { addr<<=2; CS_LOW; send_bit_slcd(DATA_CMD, 3); //Write flag code b101 send_bit_slcd(addr, 6); //Write the high 6 bits of addr send_bit_slcd(sdat, 8); //Write the 8 bits of data CS_HIGH; } void slcd_user_init(void) { SLCD_OFF; SLCD_SYS_EN; SLCD_RC_OSC; SLCD_COM_BIAS; SLCD_ON; slcd_display_data(DISP_0,DISP_0,DISP_0,DISP_0,DISP_0,DISP_0); delay_ms(600); slcd_display_data(DISP_1,DISP_1,DISP_1,DISP_1,DISP _1,DISP_1);delay_ms(600); slcd_display_data(DISP_2,DISP_2,DISP_2,DISP_2,DISP_2,DISP_2);delay_ms(600); slcd_display_data(DISP_3,DISP_3,DISP_3,DISP_3,DISP_3,DISP_3);delay_ms(600); slcd_display_data(DISP_4,DISP_4,DISP_4,DISP_4,DISP_4,DISP_4);delay_ms(600); slcd_display_data(DISP_5,DISP_5,DISP_5,DISP_5,DISP_5,DISP_5);delay_ms(600); slcd_display_data(DISP_6,DISP_6,DI SP_6,DISP_6, DISP_6,DISP_6);delay_ms(600); slcd_display_data(DISP_7,DISP_7,DISP_7,DISP_7,DISP_7,DISP_7);delay_ms(600); slcd_display_data(DISP_8,DISP_8,DISP_8,DISP_8,DISP_8,DISP_8);delay_ms(600); slcd_display_data(DISP_9,DISP_9,DISP_9,DISP_9,DISP_9,DISP_9);delay_ms(600); slcd_display_data(DISP__,DISP__,DISP__,DISP__,DISP__,DISP__);delay_ms(600); slcd_display_data(DISP_H,DISP_E,DISP_L,DISP _L, DISP_0,DISP_EMPTY); } void slcd_display_data(uint8_t data1, uint8_t data2, uint8_t data3, uint8_t data4, uint8_t data5, uint8_t data6) { uint8_t addr = 9; write_slcd(addr, data1); addr += 2; write_slcd(addr, data2); addr += 2; write_slcd(addr, data3); addr += 2; write_slcd(addr, data4); addr += 2; write_slcd(addr, data5); addr += 2; write_slcd(addr, data6); addr + = 2; } #endif #endif ``` ## Video 

lugl4313820

If you have time, please measure the power consumption of this code.