driver_ssd1681.h

Go to the documentation of this file.

 
#ifndef DRIVER_SSD1681_H
#define DRIVER_SSD1681_H
 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C"{
#endif



#ifndef SSD1681_BUSY_MAX_DELAY_MS
    #define SSD1681_BUSY_MAX_DELAY_MS        10        
#endif

#ifndef SSD1681_BUSY_MAX_RETRY_TIMES
    #define SSD1681_BUSY_MAX_RETRY_TIMES     2000      
#endif

typedef enum
{
    SSD1681_BOOL_FALSE = 0x00,        
    SSD1681_BOOL_TRUE  = 0x01,        
} ssd1681_bool_t;

typedef enum  
{
    SSD1681_GATE_DRIVING_VOLTAGE_10V   = 0x03,        
    SSD1681_GATE_DRIVING_VOLTAGE_10P5V = 0x04,        
    SSD1681_GATE_DRIVING_VOLTAGE_11V   = 0x05,        
    SSD1681_GATE_DRIVING_VOLTAGE_11P5V = 0x06,        
    SSD1681_GATE_DRIVING_VOLTAGE_12V   = 0x07,        
    SSD1681_GATE_DRIVING_VOLTAGE_12P5V = 0x08,        
    SSD1681_GATE_DRIVING_VOLTAGE_13V   = 0x09,        
    SSD1681_GATE_DRIVING_VOLTAGE_13P5V = 0x0A,        
    SSD1681_GATE_DRIVING_VOLTAGE_14V   = 0x0B,        
    SSD1681_GATE_DRIVING_VOLTAGE_14P5V = 0x0C,        
    SSD1681_GATE_DRIVING_VOLTAGE_15V   = 0x0D,        
    SSD1681_GATE_DRIVING_VOLTAGE_15P5V = 0x0E,        
    SSD1681_GATE_DRIVING_VOLTAGE_16V   = 0x0F,        
    SSD1681_GATE_DRIVING_VOLTAGE_16P5V = 0x10,        
    SSD1681_GATE_DRIVING_VOLTAGE_17V   = 0x11,        
    SSD1681_GATE_DRIVING_VOLTAGE_17P5V = 0x12,        
    SSD1681_GATE_DRIVING_VOLTAGE_18V   = 0x13,        
    SSD1681_GATE_DRIVING_VOLTAGE_18P5V = 0x14,        
    SSD1681_GATE_DRIVING_VOLTAGE_19V   = 0x15,        
    SSD1681_GATE_DRIVING_VOLTAGE_19P5V = 0x16,        
    SSD1681_GATE_DRIVING_VOLTAGE_20V   = 0x17,        
} ssd1681_gate_driving_voltage_t;

typedef enum  
{
    SSD1681_VSH_2P4V  = 0x8E,        
    SSD1681_VSH_2P5V  = 0x8F,        
    SSD1681_VSH_2P6V  = 0x90,        
    SSD1681_VSH_2P7V  = 0x91,        
    SSD1681_VSH_2P8V  = 0x92,        
    SSD1681_VSH_2P9V  = 0x93,        
    SSD1681_VSH_3V    = 0x94,        
    SSD1681_VSH_3P1V  = 0x95,        
    SSD1681_VSH_3P2V  = 0x96,        
    SSD1681_VSH_3P3V  = 0x97,        
    SSD1681_VSH_3P4V  = 0x98,        
    SSD1681_VSH_3P5V  = 0x99,        
    SSD1681_VSH_3P6V  = 0x9A,        
    SSD1681_VSH_3P7V  = 0x9B,        
    SSD1681_VSH_3P8V  = 0x9C,        
    SSD1681_VSH_3P9V  = 0x9D,        
    SSD1681_VSH_4V    = 0x9E,        
    SSD1681_VSH_4P1V  = 0x9F,        
    SSD1681_VSH_4P2V  = 0xA0,        
    SSD1681_VSH_4P3V  = 0xA1,        
    SSD1681_VSH_4P4V  = 0xA2,        
    SSD1681_VSH_4P5V  = 0xA3,        
    SSD1681_VSH_4P6V  = 0xA4,        
    SSD1681_VSH_4P7V  = 0xA5,        
    SSD1681_VSH_4P8V  = 0xA6,        
    SSD1681_VSH_4P9V  = 0xA7,        
    SSD1681_VSH_5V    = 0xA8,        
    SSD1681_VSH_5P1V  = 0xA9,        
    SSD1681_VSH_5P2V  = 0xAA,        
    SSD1681_VSH_5P3V  = 0xAB,        
    SSD1681_VSH_5P4V  = 0xAC,        
    SSD1681_VSH_5P5V  = 0xAD,        
    SSD1681_VSH_5P6V  = 0xAE,        
    SSD1681_VSH_5P7V  = 0xAF,        
    SSD1681_VSH_5P8V  = 0xB0,        
    SSD1681_VSH_5P9V  = 0xB1,        
    SSD1681_VSH_6V    = 0xB2,        
    SSD1681_VSH_6P1V  = 0xB3,        
    SSD1681_VSH_6P2V  = 0xB4,        
    SSD1681_VSH_6P3V  = 0xB5,        
    SSD1681_VSH_6P4V  = 0xB6,        
    SSD1681_VSH_6P5V  = 0xB7,        
    SSD1681_VSH_6P6V  = 0xB8,        
    SSD1681_VSH_6P7V  = 0xB9,        
    SSD1681_VSH_6P8V  = 0xBA,        
    SSD1681_VSH_6P9V  = 0xBB,        
    SSD1681_VSH_7V    = 0xBC,        
    SSD1681_VSH_7P1V  = 0xBD,        
    SSD1681_VSH_7P2V  = 0xBE,        
    SSD1681_VSH_7P3V  = 0xBF,        
    SSD1681_VSH_7P4V  = 0xC0,        
    SSD1681_VSH_7P5V  = 0xC1,        
    SSD1681_VSH_7P6V  = 0xC2,        
    SSD1681_VSH_7P7V  = 0xC3,        
    SSD1681_VSH_7P8V  = 0xC4,        
    SSD1681_VSH_7P9V  = 0xC5,        
    SSD1681_VSH_8V    = 0xC6,        
    SSD1681_VSH_8P1V  = 0xC7,        
    SSD1681_VSH_8P2V  = 0xC8,        
    SSD1681_VSH_8P3V  = 0xC9,        
    SSD1681_VSH_8P4V  = 0xCA,        
    SSD1681_VSH_8P5V  = 0xCB,        
    SSD1681_VSH_8P6V  = 0xCC,        
    SSD1681_VSH_8P7V  = 0xCD,        
    SSD1681_VSH_8P8V  = 0xCE,        
    SSD1681_VSH_9V    = 0x23,        
    SSD1681_VSH_9P2V  = 0x24,        
    SSD1681_VSH_9P4V  = 0x25,        
    SSD1681_VSH_9P6V  = 0x26,        
    SSD1681_VSH_9P8V  = 0x27,        
    SSD1681_VSH_10V   = 0x28,        
    SSD1681_VSH_10P2V = 0x29,        
    SSD1681_VSH_10P4V = 0x2A,        
    SSD1681_VSH_10P6V = 0x2B,        
    SSD1681_VSH_10P8V = 0x2C,        
    SSD1681_VSH_11V   = 0x2D,        
    SSD1681_VSH_11P2V = 0x2E,        
    SSD1681_VSH_11P4V = 0x2F,        
    SSD1681_VSH_11P6V = 0x30,        
    SSD1681_VSH_11P8V = 0x31,        
    SSD1681_VSH_12V   = 0x32,        
    SSD1681_VSH_12P2V = 0x33,        
    SSD1681_VSH_12P4V = 0x34,        
    SSD1681_VSH_12P6V = 0x35,        
    SSD1681_VSH_12P8V = 0x36,        
    SSD1681_VSH_13V   = 0x37,        
    SSD1681_VSH_13P2V = 0x38,        
    SSD1681_VSH_13P4V = 0x39,        
    SSD1681_VSH_13P6V = 0x3A,        
    SSD1681_VSH_13P8V = 0x3B,        
    SSD1681_VSH_14V   = 0x3C,        
    SSD1681_VSH_14P2V = 0x3D,        
    SSD1681_VSH_14P4V = 0x3E,        
    SSD1681_VSH_14P6V = 0x3F,        
    SSD1681_VSH_14P8V = 0x40,        
    SSD1681_VSH_15V   = 0x41,        
    SSD1681_VSH_15P2V = 0x42,        
    SSD1681_VSH_15P4V = 0x43,        
    SSD1681_VSH_15P6V = 0x44,        
    SSD1681_VSH_15P8V = 0x45,        
    SSD1681_VSH_16V   = 0x46,        
    SSD1681_VSH_16P2V = 0x47,        
    SSD1681_VSH_16P4V = 0x48,        
    SSD1681_VSH_16P6V = 0x49,        
    SSD1681_VSH_16P8V = 0x4A,        
    SSD1681_VSH_17V   = 0x4B,        
} ssd1681_vsh_t;

typedef enum  
{
    SSD1681_VSL_NEGATIVE_5    = 0x0A,        
    SSD1681_VSL_NEGATIVE_5P5  = 0x0C,        
    SSD1681_VSL_NEGATIVE_6    = 0x0E,        
    SSD1681_VSL_NEGATIVE_6P5  = 0x10,        
    SSD1681_VSL_NEGATIVE_7    = 0x12,        
    SSD1681_VSL_NEGATIVE_7P5  = 0x14,        
    SSD1681_VSL_NEGATIVE_8    = 0x16,        
    SSD1681_VSL_NEGATIVE_8P5  = 0x18,        
    SSD1681_VSL_NEGATIVE_9    = 0x1A,        
    SSD1681_VSL_NEGATIVE_9P5  = 0x1C,        
    SSD1681_VSL_NEGATIVE_10   = 0x1E,        
    SSD1681_VSL_NEGATIVE_10P5 = 0x20,        
    SSD1681_VSL_NEGATIVE_11   = 0x22,        
    SSD1681_VSL_NEGATIVE_11P5 = 0x24,        
    SSD1681_VSL_NEGATIVE_12   = 0x26,        
    SSD1681_VSL_NEGATIVE_12P5 = 0x28,        
    SSD1681_VSL_NEGATIVE_13   = 0x2A,        
    SSD1681_VSL_NEGATIVE_13P5 = 0x2C,        
    SSD1681_VSL_NEGATIVE_14   = 0x2E,        
    SSD1681_VSL_NEGATIVE_14P5 = 0x30,        
    SSD1681_VSL_NEGATIVE_15   = 0x32,        
    SSD1681_VSL_NEGATIVE_15P5 = 0x34,        
    SSD1681_VSL_NEGATIVE_16   = 0x36,        
    SSD1681_VSL_NEGATIVE_16P5 = 0x38,        
    SSD1681_VSL_NEGATIVE_17   = 0x3A,        
} ssd1681_vsl_t;

typedef enum  
{
    SSD1681_DRIVING_STRENGTH_1 = (0 << 4),        
    SSD1681_DRIVING_STRENGTH_2 = (1 << 4),        
    SSD1681_DRIVING_STRENGTH_3 = (2 << 4),        
    SSD1681_DRIVING_STRENGTH_4 = (3 << 4),        
    SSD1681_DRIVING_STRENGTH_5 = (4 << 4),        
    SSD1681_DRIVING_STRENGTH_6 = (5 << 4),        
    SSD1681_DRIVING_STRENGTH_7 = (6 << 4),        
    SSD1681_DRIVING_STRENGTH_8 = (7 << 4),        
} ssd1681_driving_strength_t;

typedef enum  
{
    SSD1681_MIN_OFF_TIME_2P6  = (4 << 0),         
    SSD1681_MIN_OFF_TIME_3P2  = (5 << 0),         
    SSD1681_MIN_OFF_TIME_3P9  = (6 << 0),         
    SSD1681_MIN_OFF_TIME_4P6  = (7 << 0),         
    SSD1681_MIN_OFF_TIME_5P4  = (8 << 0),         
    SSD1681_MIN_OFF_TIME_6P3  = (9 << 0),         
    SSD1681_MIN_OFF_TIME_7P3  = (10 << 0),        
    SSD1681_MIN_OFF_TIME_8P4  = (11 << 0),        
    SSD1681_MIN_OFF_TIME_9P8  = (12 << 0),        
    SSD1681_MIN_OFF_TIME_11P5 = (13 << 0),        
    SSD1681_MIN_OFF_TIME_13P8 = (14 << 0),        
    SSD1681_MIN_OFF_TIME_16P5 = (15 << 0),        
} ssd1681_min_off_time_t;

typedef enum  
{
    SSD1681_PHASE_DURATION_10MS = 0x00,        
    SSD1681_PHASE_DURATION_20MS = 0x01,        
    SSD1681_PHASE_DURATION_30MS = 0x02,        
    SSD1681_PHASE_DURATION_40MS = 0x03,        
} ssd1681_phase_duration_t;

typedef enum  
{
    SSD1681_MODE_NORMAL       = 0x00,        
    SSD1681_MODE_DEEP_SLEEP_1 = 0x01,        
    SSD1681_MODE_DEEP_SLEEP_2 = 0x03,        
} ssd1681_mode_t;

typedef enum  
{
    SSD1681_ADDRESS_MODE_Y_DECREMENT_X_DECREMENT = 0x00,        
    SSD1681_ADDRESS_MODE_Y_DECREMENT_X_INCREMENT = 0x01,        
    SSD1681_ADDRESS_MODE_Y_INCREMENT_X_DECREMENT = 0x02,        
    SSD1681_ADDRESS_MODE_Y_INCREMENT_X_INCREMENT = 0x03,        
} ssd1681_address_mode_t;

typedef enum  
{
    SSD1681_ADDRESS_DIRECTION_UPDATED_X = 0x00,        
    SSD1681_ADDRESS_DIRECTION_UPDATED_Y = 0x01,        
} ssd1681_address_direction_t;

typedef enum  
{
    SSD1681_VCI_LEVEL_2P2V = 0x3,        
    SSD1681_VCI_LEVEL_2P3V = 0x4,        
    SSD1681_VCI_LEVEL_2P4V = 0x5,        
    SSD1681_VCI_LEVEL_2P5V = 0x6,        
    SSD1681_VCI_LEVEL_2P6V = 0x7,        
} ssd1681_vci_level_t;

typedef enum  
{
    SSD1681_TEMPERATURE_SENSOR_EXTERNAL = 0x48,        
    SSD1681_TEMPERATURE_SENSOR_INTERNAL = 0x80,        
} ssd1681_temperature_sensor_t;

typedef enum  
{
    SSD1681_DISPLAY_CONTROL_NORMAL  = 0x00,        
    SSD1681_DISPLAY_CONTROL_BYPASS  = 0x04,        
    SSD1681_DISPLAY_CONTROL_INVERSE = 0x08,        
} ssd1681_display_control_t;

typedef enum  
{
    SSD1681_DISPLAY_SEQUENCE_0  = 0x80,        
    SSD1681_DISPLAY_SEQUENCE_1  = 0x01,        
    SSD1681_DISPLAY_SEQUENCE_2  = 0xC0,        
    SSD1681_DISPLAY_SEQUENCE_3  = 0x03,        
    SSD1681_DISPLAY_SEQUENCE_4  = 0x91,        
    SSD1681_DISPLAY_SEQUENCE_5  = 0x99,        
    SSD1681_DISPLAY_SEQUENCE_6  = 0xB1,        
    SSD1681_DISPLAY_SEQUENCE_7  = 0xB9,        
    SSD1681_DISPLAY_SEQUENCE_8  = 0xC7,        
    SSD1681_DISPLAY_SEQUENCE_9  = 0xCF,        
    SSD1681_DISPLAY_SEQUENCE_10 = 0xF7,        
    SSD1681_DISPLAY_SEQUENCE_11 = 0xFF,        
} ssd1681_display_sequence_t;

typedef enum  
{
    SSD1681_VCOM_NEGATIVE_0P2 = 0x08,        
    SSD1681_VCOM_NEGATIVE_0P3 = 0x0C,        
    SSD1681_VCOM_NEGATIVE_0P4 = 0x10,        
    SSD1681_VCOM_NEGATIVE_0P5 = 0x14,        
    SSD1681_VCOM_NEGATIVE_0P6 = 0x18,        
    SSD1681_VCOM_NEGATIVE_0P7 = 0x1C,        
    SSD1681_VCOM_NEGATIVE_0P8 = 0x20,        
    SSD1681_VCOM_NEGATIVE_0P9 = 0x24,        
    SSD1681_VCOM_NEGATIVE_1P0 = 0x28,        
    SSD1681_VCOM_NEGATIVE_1P1 = 0x2C,        
    SSD1681_VCOM_NEGATIVE_1P2 = 0x30,        
    SSD1681_VCOM_NEGATIVE_1P3 = 0x34,        
    SSD1681_VCOM_NEGATIVE_1P4 = 0x38,        
    SSD1681_VCOM_NEGATIVE_1P5 = 0x3C,        
    SSD1681_VCOM_NEGATIVE_1P6 = 0x40,        
    SSD1681_VCOM_NEGATIVE_1P7 = 0x44,        
    SSD1681_VCOM_NEGATIVE_1P8 = 0x48,        
    SSD1681_VCOM_NEGATIVE_1P9 = 0x4C,        
    SSD1681_VCOM_NEGATIVE_2P0 = 0x50,        
    SSD1681_VCOM_NEGATIVE_2P1 = 0x54,        
    SSD1681_VCOM_NEGATIVE_2P2 = 0x58,        
    SSD1681_VCOM_NEGATIVE_2P3 = 0x5C,        
    SSD1681_VCOM_NEGATIVE_2P4 = 0x60,        
    SSD1681_VCOM_NEGATIVE_2P5 = 0x64,        
    SSD1681_VCOM_NEGATIVE_2P6 = 0x68,        
    SSD1681_VCOM_NEGATIVE_2P7 = 0x6C,        
    SSD1681_VCOM_NEGATIVE_2P8 = 0x70,        
    SSD1681_VCOM_NEGATIVE_2P9 = 0x74,        
    SSD1681_VCOM_NEGATIVE_3P0 = 0x78,        
} ssd1681_vcom_t;

typedef enum  
{
    SSD1681_OTP_MODE_NORMAL   = 0x0,        
    SSD1681_OTP_MODE_INTERNAL = 0x3,        
} ssd1681_otp_mode_t;

typedef enum  
{
    SSD1681_VBD_GS_TRANSITION = 0x0,        
    SSD1681_VBD_FIX_LEVEL     = 0x1,        
    SSD1681_VBD_VCOM          = 0x2,        
    SSD1681_VBD_HIZ           = 0x3,        
} ssd1681_vbd_t;

typedef enum  
{
    SSD1681_VBD_FIX_LEVEL_VSS  = 0x0,        
    SSD1681_VBD_FIX_LEVEL_VSH1 = 0x1,        
    SSD1681_VBD_FIX_LEVEL_VSL  = 0x2,        
    SSD1681_VBD_FIX_LEVEL_VSH2 = 0x3,        
} ssd1681_vbd_fix_level_t;

typedef enum  
{
    SSD1681_GS_TRANSITION_FOLLOW_LUT_RED = 0x0,        
    SSD1681_GS_TRANSITION_FOLLOW_LUT     = 0x1,        
} ssd1681_gs_transition_t;

typedef enum  
{
    SSD1681_VBD_TRANSITION_LUT0 = 0x0,        
    SSD1681_VBD_TRANSITION_LUT1 = 0x1,        
    SSD1681_VBD_TRANSITION_LUT2 = 0x2,        
    SSD1681_VBD_TRANSITION_LUT3 = 0x3,        
} ssd1681_vbd_transition_t;

typedef enum  
{
    SSD1681_END_OPT_NORMAL             = 0x22,        
    SSD1681_END_OPT_KEEP_BEFORE_OUTPUT = 0x07,        
} ssd1681_end_opt_t;

typedef enum  
{
    SSD1681_READ_RAM_BLACK = 0x0,        
    SSD1681_READ_RAM_RED   = 0x1,        
} ssd1681_read_ram_t;

typedef enum  
{
    SSD1681_STEP_HEIGHT_8   = 0x0,        
    SSD1681_STEP_HEIGHT_16  = 0x1,        
    SSD1681_STEP_HEIGHT_32  = 0x2,        
    SSD1681_STEP_HEIGHT_64  = 0x3,        
    SSD1681_STEP_HEIGHT_128 = 0x4,        
    SSD1681_STEP_HEIGHT_200 = 0x5,        
} ssd1681_step_height_t;

typedef enum  
{
    SSD1681_STEP_WIDTH_8   = 0x0,        
    SSD1681_STEP_WIDTH_16  = 0x1,        
    SSD1681_STEP_WIDTH_32  = 0x2,        
    SSD1681_STEP_WIDTH_64  = 0x3,        
    SSD1681_STEP_WIDTH_128 = 0x4,        
    SSD1681_STEP_WIDTH_200 = 0x5,        
} ssd1681_step_width_t;

typedef enum  
{
    SSD1681_COLOR_BLACK = 0x0,        
    SSD1681_COLOR_RED   = 0x1,        
} ssd1681_color_t;

typedef enum  
{
    SSD1681_FONT_12 = 0x0C,        
    SSD1681_FONT_16 = 0x10,        
    SSD1681_FONT_24 = 0x18,        
} ssd1681_font_t;

typedef struct ssd1681_handle_s
{
    uint8_t (*spi_init)(void);                                   
    uint8_t (*spi_deinit)(void);                                 
    uint8_t (*spi_write_cmd)(uint8_t *buf, uint16_t len);        
    uint8_t (*spi_read_cmd)(uint8_t *buf, uint16_t len);         
    uint8_t (*spi_cmd_data_gpio_init)(void);                     
    uint8_t (*spi_cmd_data_gpio_deinit)(void);                   
    uint8_t (*spi_cmd_data_gpio_write)(uint8_t value);           
    uint8_t (*reset_gpio_init)(void);                            
    uint8_t (*reset_gpio_deinit)(void);                          
    uint8_t (*reset_gpio_write)(uint8_t value);                  
    uint8_t (*busy_gpio_init)(void);                             
    uint8_t (*busy_gpio_deinit)(void);                           
    uint8_t (*busy_gpio_read)(uint8_t *value);                   
    void (*debug_print)(const char *const fmt, ...);             
    void (*delay_ms)(uint32_t ms);                               
    uint8_t inited;                                              
    uint8_t black_gram[200][25];                                 
    uint8_t red_gram[200][25];                                   
} ssd1681_handle_t;

typedef struct ssd1681_info_s
{
    char chip_name[32];                
    char manufacturer_name[32];        
    char interface[8];                 
    float supply_voltage_min_v;        
    float supply_voltage_max_v;        
    float max_current_ma;              
    float temperature_min;             
    float temperature_max;             
    uint32_t driver_version;           
} ssd1681_info_t;



#define DRIVER_SSD1681_LINK_INIT(HANDLE, STRUCTURE)                     memset(HANDLE, 0, sizeof(STRUCTURE))

#define DRIVER_SSD1681_LINK_SPI_INIT(HANDLE, FUC)                      (HANDLE)->spi_init = FUC

#define DRIVER_SSD1681_LINK_SPI_DEINIT(HANDLE, FUC)                    (HANDLE)->spi_deinit = FUC

#define DRIVER_SSD1681_LINK_SPI_WRITE_CMD(HANDLE, FUC)                 (HANDLE)->spi_write_cmd = FUC

#define DRIVER_SSD1681_LINK_SPI_READ_CMD(HANDLE, FUC)                  (HANDLE)->spi_read_cmd = FUC

#define DRIVER_SSD1681_LINK_SPI_CMD_DATA_GPIO_INIT(HANDLE, FUC)        (HANDLE)->spi_cmd_data_gpio_init = FUC

#define DRIVER_SSD1681_LINK_SPI_CMD_DATA_GPIO_DEINIT(HANDLE, FUC)      (HANDLE)->spi_cmd_data_gpio_deinit = FUC

#define DRIVER_SSD1681_LINK_SPI_CMD_DATA_GPIO_WRITE(HANDLE, FUC)       (HANDLE)->spi_cmd_data_gpio_write = FUC

#define DRIVER_SSD1681_LINK_RESET_GPIO_INIT(HANDLE, FUC)               (HANDLE)->reset_gpio_init = FUC

#define DRIVER_SSD1681_LINK_RESET_GPIO_DEINIT(HANDLE, FUC)             (HANDLE)->reset_gpio_deinit = FUC

#define DRIVER_SSD1681_LINK_RESET_GPIO_WRITE(HANDLE, FUC)              (HANDLE)->reset_gpio_write = FUC

#define DRIVER_SSD1681_LINK_BUSY_GPIO_INIT(HANDLE, FUC)                (HANDLE)->busy_gpio_init = FUC

#define DRIVER_SSD1681_LINK_BUSY_GPIO_DEINIT(HANDLE, FUC)              (HANDLE)->busy_gpio_deinit = FUC

#define DRIVER_SSD1681_LINK_BUSY_GPIO_READ(HANDLE, FUC)                (HANDLE)->busy_gpio_read = FUC

#define DRIVER_SSD1681_LINK_DELAY_MS(HANDLE, FUC)                      (HANDLE)->delay_ms = FUC

#define DRIVER_SSD1681_LINK_DEBUG_PRINT(HANDLE, FUC)                   (HANDLE)->debug_print = FUC



uint8_t ssd1681_info(ssd1681_info_t *info);

uint8_t ssd1681_init(ssd1681_handle_t *handle);

uint8_t ssd1681_deinit(ssd1681_handle_t *handle);

uint8_t ssd1681_clear(ssd1681_handle_t *handle, ssd1681_color_t color);

uint8_t ssd1681_gram_update(ssd1681_handle_t *handle, ssd1681_color_t color);

uint8_t ssd1681_gram_clear(ssd1681_handle_t *handle, ssd1681_color_t color);

uint8_t ssd1681_gram_write_point(ssd1681_handle_t *handle, ssd1681_color_t color, uint8_t x, uint8_t y, uint8_t data);

uint8_t ssd1681_gram_read_point(ssd1681_handle_t *handle, ssd1681_color_t color, uint8_t x, uint8_t y, uint8_t *data);

uint8_t ssd1681_gram_write_string(ssd1681_handle_t *handle, ssd1681_color_t color, uint8_t x, uint8_t y, char *str, uint16_t len, uint8_t data, ssd1681_font_t font);

uint8_t ssd1681_gram_fill_rect(ssd1681_handle_t *handle, ssd1681_color_t color, uint8_t left, uint8_t top, uint8_t right, uint8_t bottom, uint8_t data);

uint8_t ssd1681_gram_draw_picture(ssd1681_handle_t *handle, ssd1681_color_t color, uint8_t left, uint8_t top, uint8_t right, uint8_t bottom, uint8_t *img);

uint8_t ssd1681_set_driver_output(ssd1681_handle_t *handle, uint16_t mux, ssd1681_bool_t gd, ssd1681_bool_t sm, ssd1681_bool_t tb);

uint8_t ssd1681_set_gate_driving_voltage(ssd1681_handle_t *handle, ssd1681_gate_driving_voltage_t voltage);

uint8_t ssd1681_set_source_driving_voltage(ssd1681_handle_t *handle, ssd1681_vsh_t vsh1, ssd1681_vsh_t vsh2, ssd1681_vsl_t vsl);

uint8_t ssd1681_otp_initial(ssd1681_handle_t *handle);

uint8_t ssd1681_otp_initial_write(ssd1681_handle_t *handle, uint8_t param[4]);

uint8_t ssd1681_otp_initial_read(ssd1681_handle_t *handle);

uint8_t ssd1681_otp_program_vcom(ssd1681_handle_t *handle);

uint8_t ssd1681_otp_read_register(ssd1681_handle_t *handle, uint8_t param[11]);

uint8_t ssd1681_otp_program_waveform(ssd1681_handle_t *handle);

uint8_t ssd1681_otp_load_waveform(ssd1681_handle_t *handle);

uint8_t ssd1681_otp_program_selection(ssd1681_handle_t *handle);

uint8_t ssd1681_otp_write_register(ssd1681_handle_t *handle, uint8_t param[11]);

uint8_t ssd1681_otp_program_mode(ssd1681_handle_t *handle, ssd1681_otp_mode_t mode);

uint8_t ssd1681_set_booster_soft_start(ssd1681_handle_t *handle, 
                                       uint8_t phase1, uint8_t phase2,
                                       uint8_t phase3, uint8_t duration);

uint8_t ssd1681_set_mode(ssd1681_handle_t *handle, ssd1681_mode_t mode);

uint8_t ssd1681_set_data_entry_mode(ssd1681_handle_t *handle, ssd1681_address_mode_t mode, ssd1681_address_direction_t direction);

uint8_t ssd1681_software_reset(ssd1681_handle_t *handle);

uint8_t ssd1681_set_hv_ready_detection(ssd1681_handle_t *handle, uint8_t cool_down_duration, uint8_t cool_down_loop_num);

uint8_t ssd1681_set_vci_detection(ssd1681_handle_t *handle, ssd1681_vci_level_t level);

uint8_t ssd1681_set_temperature_sensor(ssd1681_handle_t *handle, ssd1681_temperature_sensor_t sensor);

uint8_t ssd1681_write_temperature_sensor(ssd1681_handle_t *handle, uint16_t control);

uint8_t ssd1681_read_temperature_sensor(ssd1681_handle_t *handle, uint16_t *control);

uint8_t ssd1681_write_temperature_sensor_ext(ssd1681_handle_t *handle, uint8_t param[3]);

uint8_t ssd1681_set_master_activate(ssd1681_handle_t *handle);

uint8_t ssd1681_set_display_update_control(ssd1681_handle_t *handle, ssd1681_display_control_t red_control, ssd1681_display_control_t black_control);

uint8_t ssd1681_set_display_sequence(ssd1681_handle_t *handle, ssd1681_display_sequence_t sequence);

uint8_t ssd1681_set_black_ram(ssd1681_handle_t *handle);

uint8_t ssd1681_set_red_ram(ssd1681_handle_t *handle);

uint8_t ssd1681_get_ram(ssd1681_handle_t *handle);

uint8_t ssd1681_set_enter_vcom_sense(ssd1681_handle_t *handle);

uint8_t ssd1681_set_vcom_sense_duration(ssd1681_handle_t *handle, uint8_t duration);

uint8_t ssd1681_set_vcom_control_reg(ssd1681_handle_t *handle);

uint8_t ssd1681_set_vcom_register(ssd1681_handle_t *handle, ssd1681_vcom_t vcom);

uint8_t ssd1681_get_user_id(ssd1681_handle_t *handle, uint8_t id[10]);

uint8_t ssd1681_get_status(ssd1681_handle_t *handle, uint8_t *status);

uint8_t ssd1681_set_lut_register(ssd1681_handle_t *handle, uint8_t *reg, uint16_t len);

uint8_t ssd1681_set_crc_calculation(ssd1681_handle_t *handle);

uint8_t ssd1681_get_crc_status(ssd1681_handle_t *handle, uint16_t *status);

uint8_t ssd1681_set_user_id(ssd1681_handle_t *handle, uint8_t id[10]);

uint8_t ssd1681_set_border_waveform(ssd1681_handle_t *handle, ssd1681_vbd_t vbd, ssd1681_vbd_fix_level_t level,
                                    ssd1681_gs_transition_t gs_tran, ssd1681_vbd_transition_t vbd_tran);

uint8_t ssd1681_set_end_option(ssd1681_handle_t *handle, ssd1681_end_opt_t opt);

uint8_t ssd1681_set_read_ram(ssd1681_handle_t *handle, ssd1681_read_ram_t ram);

uint8_t ssd1681_set_ram_x(ssd1681_handle_t *handle, uint8_t start, uint8_t end);

uint8_t ssd1681_set_ram_y(ssd1681_handle_t *handle, uint16_t start, uint16_t end);

uint8_t ssd1681_set_auto_write_red_ram(ssd1681_handle_t *handle, ssd1681_step_height_t height, ssd1681_step_width_t width);

uint8_t ssd1681_set_auto_write_black_ram(ssd1681_handle_t *handle, ssd1681_step_height_t height, ssd1681_step_width_t width);

uint8_t ssd1681_set_ram_x_address_counter(ssd1681_handle_t *handle, uint8_t cnt);

uint8_t ssd1681_set_ram_y_address_counter(ssd1681_handle_t *handle, uint16_t cnt);

uint8_t ssd1681_nop(ssd1681_handle_t *handle);



uint8_t ssd1681_write_cmd(ssd1681_handle_t *handle, uint8_t *buf, uint8_t len);

uint8_t ssd1681_write_data(ssd1681_handle_t *handle, uint8_t *buf, uint8_t len);

uint8_t ssd1681_read_data(ssd1681_handle_t *handle, uint8_t *buf, uint8_t len);


 
#ifdef __cplusplus
}
#endif
 
#endif